fix repo resolution: use correct collection and dynamic knot routing

CLAUDE.md

···
 - `git push origin main` → both remotes
 
 ## tools
-- all accept `owner/repo` format (e.g., `zzstoatzz/tangled-mcp`)
-- server-side resolution: handle → DID → repo AT-URI
+- all accept `owner/repo` or `@owner/repo` format (e.g., `zzstoatzz/tangled-mcp`)
+- server-side resolution:
+  1. handle → DID (via atproto identity resolution)
+  2. query `sh.tangled.repo` collection on owner's PDS
+  3. extract knot hostname and repo name from record
+  4. call knot's XRPC endpoint (e.g., `https://knot1.tangled.sh/xrpc/...`)
 
 ## dev
 - justfile: `setup`, `test`, `check`, `push`
 - versioning: uv-dynamic-versioning (git tags)
 - type checking: ty + ruff (I, UP)
+
+## architecture notes
+- repos stored as atproto records in collection `sh.tangled.repo` (NOT `sh.tangled.repo.repo`)
+- each repo record contains `knot` field indicating hosting server
+- appview (tangled.org) uses web routes, NOT XRPC
+- knots (e.g., knot1.tangled.sh) expose XRPC endpoints for git operations

docs/architecture.md

···
+# architecture
+
+## tangled platform overview
+
+tangled is a git collaboration platform built on the AT Protocol. it consists of:
+
+### components
+
+- **appview** (tangled.org): web interface using traditional HTTP routes
+  - handles OAuth authentication for browser users
+  - serves HTML/CSS/JS for the UI
+  - proxies git operations to knots
+  - does NOT expose XRPC endpoints
+
+- **knots** (e.g., knot1.tangled.sh): git hosting servers
+  - expose XRPC endpoints for git operations
+  - host actual git repositories
+  - handle git-upload-pack, git-receive-pack, etc.
+
+- **PDS** (Personal Data Server): AT Protocol user data storage
+  - stores user's atproto records
+  - repos stored in `sh.tangled.repo` collection
+  - each repo record contains: name, knot, description, etc.
+
+### data flow
+
+1. user creates repo on tangled.org
+2. appview writes repo record to user's PDS (`sh.tangled.repo` collection)
+3. repo record includes `knot` field indicating which knot hosts it
+4. git operations routed through appview to the appropriate knot
+
+## MCP server implementation
+
+### resolution flow
+
+when a client calls `list_repo_branches("@owner/repo")`:
+
+1. **normalize input**: strip @ if present (`@owner` → `owner`)
+
+2. **resolve handle to DID**:
+   - if already DID format: use as-is
+   - otherwise: call `com.atproto.identity.resolveHandle`
+   - result: `did:plc:...`
+
+3. **query repo collection**:
+   - call `com.atproto.repo.listRecords` on owner's PDS
+   - collection: `sh.tangled.repo` (NOT `sh.tangled.repo.repo`)
+   - find record where `name` matches repo name
+
+4. **extract knot**:
+   - get `knot` field from repo record
+   - example: `knot1.tangled.sh`
+
+5. **call knot XRPC**:
+   - construct URL: `https://{knot}/xrpc/sh.tangled.repo.branches`
+   - params: `{"repo": "{did}/{repo_name}", "limit": N}`
+   - auth: service token from `com.atproto.server.getServiceAuth`
+
+### authentication
+
+uses AT Protocol service auth:
+
+1. authenticate to user's PDS with handle/password
+2. call `com.atproto.server.getServiceAuth` with `aud: did:web:tangled.org`
+3. receive service token (60 second expiration)
+4. use token in `Authorization: Bearer {token}` header for XRPC calls
+
+### key implementation details
+
+- **collection name**: `sh.tangled.repo`
+- **knot resolution**: dynamic based on repo record, not hardcoded
+- **handle formats**: both `owner/repo` and `@owner/repo` accepted
+- **private implementation**: resolution logic in `_tangled/` package
+- **public API**: clean tool interface in `server.py`
+
+### error handling
+
+- invalid format: `ValueError` with clear message
+- handle not found: `ValueError` from identity resolution
+- repo not found: `ValueError` after querying collection
+- XRPC errors: raised from httpx with status code

pyproject.toml

···
 filterwarnings = [
     # upstream atproto issue: https://github.com/MarshalX/atproto/issues/625
     "ignore::pydantic.warnings.UnsupportedFieldAttributeWarning",
+    # upstream: atproto SDK uses deprecated httpx API
+    "ignore::DeprecationWarning:httpx",
 ]
 
 [tool.ty.src]

src/tangled_mcp/_tangled/_client.py

···
 from tangled_mcp.settings import TANGLED_APPVIEW_URL, TANGLED_DID, settings
 
 
-def resolve_repo_identifier(owner_slash_repo: str) -> str:
-    """resolve owner/repo format to repository AT-URI
+def resolve_repo_identifier(owner_slash_repo: str) -> tuple[str, str]:
+    """resolve owner/repo format to (knot, did/repo) for tangled XRPC
 
     Args:
-        owner_slash_repo: repository identifier in "owner/repo" format
-                         (e.g., "zzstoatzz/tangled-mcp")
+        owner_slash_repo: repository identifier in "owner/repo" or "@owner/repo" format
+                         (e.g., "zzstoatzz.io/tangled-mcp" or "@zzstoatzz.io/tangled-mcp")
 
     Returns:
-        repository AT-URI (e.g., "at://did:plc:.../sh.tangled.repo.repo/...")
+        tuple of (knot_url, repo_identifier) where:
+        - knot_url: hostname of knot hosting the repo (e.g., "knot1.tangled.sh")
+        - repo_identifier: "did/repo" format (e.g., "did:plc:.../tangled-mcp")
 
     Raises:
-        ValueError: if format is invalid or repo not found
+        ValueError: if format is invalid, handle cannot be resolved, or repo not found
     """
     if "/" not in owner_slash_repo:
         raise ValueError(
···
         except Exception as e:
             raise ValueError(f"failed to resolve handle '{owner}': {e}") from e
 
-    # query owner's repo collection to find repo by name
+    # query owner's repo collection to find repo and get knot
     try:
         records = client.com.atproto.repo.list_records(
             models.ComAtprotoRepoListRecords.Params(
                 repo=owner_did,
-                collection="sh.tangled.repo.repo",
-                limit=100,  # should be enough for most users
+                collection="sh.tangled.repo",  # correct collection name
+                limit=100,
             )
         )
     except Exception as e:
         raise ValueError(f"failed to list repos for '{owner}': {e}") from e
 
-    # find repo with matching name
+    # find repo with matching name and extract knot
     for record in records.records:
         if hasattr(record.value, "name") and record.value.name == repo_name:
-            return record.uri
+            knot = getattr(record.value, "knot", None)
+            if not knot:
+                raise ValueError(f"repo '{repo_name}' has no knot information")
+            return (knot, f"{owner_did}/{repo_name}")
 
     raise ValueError(f"repo '{repo_name}' not found for owner '{owner}'")
 
···
 def make_tangled_request(
     method: str,
     params: dict[str, Any] | None = None,
+    knot: str | None = None,
 ) -> dict[str, Any]:
-    """make an XRPC request to tangled's appview
+    """make an XRPC request to tangled's knot
 
     Args:
         method: XRPC method (e.g., 'sh.tangled.repo.branches')
         params: query parameters for the request
+        knot: optional knot hostname (if not provided, must be in params["repo"])
 
     Returns:
         response data from tangled
     """
     token = get_service_token()
 
-    url = f"{TANGLED_APPVIEW_URL}/xrpc/{method}"
+    # if knot not provided, extract from repo identifier
+    if not knot and params and "repo" in params:
+        raise ValueError("knot must be provided or repo must be resolved first")
+
+    url = f"https://{knot}/xrpc/{method}"
 
     response = httpx.get(
         url,
···
 
 
 def list_branches(
-    repo: str, limit: int = 50, cursor: str | None = None
+    knot: str, repo: str, limit: int = 50, cursor: str | None = None
 ) -> dict[str, Any]:
     """list branches for a repository
 
     Args:
-        repo: repository identifier (e.g., 'did:plc:.../repoName')
+        knot: knot hostname (e.g., 'knot1.tangled.sh')
+        repo: repository identifier in "did/repo" format (e.g., 'did:plc:.../repoName')
         limit: maximum number of branches to return
         cursor: pagination cursor
 
···
     if cursor:
         params["cursor"] = cursor
 
-    return make_tangled_request("sh.tangled.repo.branches", params)
+    return make_tangled_request("sh.tangled.repo.branches", params, knot=knot)
 
 
 def create_issue(repo: str, title: str, body: str | None = None) -> dict[str, Any]:

src/tangled_mcp/server.py

···
     Returns:
         list of branches with optional cursor for pagination
     """
-    # resolve owner/repo to AT-URI
-    repo_uri = _tangled.resolve_repo_identifier(repo)
-    response = _tangled.list_branches(repo_uri, limit, cursor)
+    # resolve owner/repo to (knot, did/repo)
+    knot, repo_id = _tangled.resolve_repo_identifier(repo)
+    response = _tangled.list_branches(knot, repo_id, limit, cursor)
 
     # parse response into BranchInfo objects
     branches = []
···
     Returns:
         dict with uri and cid of created issue
     """
-    # resolve owner/repo to AT-URI
-    repo_uri = _tangled.resolve_repo_identifier(repo)
-    response = _tangled.create_issue(repo_uri, title, body)
+    # resolve owner/repo to (knot, did/repo)
+    knot, repo_id = _tangled.resolve_repo_identifier(repo)
+    # create_issue doesn't need knot (uses atproto putRecord, not XRPC)
+    response = _tangled.create_issue(repo_id, title, body)
     return {"uri": response["uri"], "cid": response["cid"]}
 
 
···
     Returns:
         dict with list of issues and optional cursor
     """
-    # resolve owner/repo to AT-URI
-    repo_uri = _tangled.resolve_repo_identifier(repo)
-    response = _tangled.list_repo_issues(repo_uri, limit, cursor)
+    # resolve owner/repo to (knot, did/repo)
+    knot, repo_id = _tangled.resolve_repo_identifier(repo)
+    # list_repo_issues doesn't need knot (queries atproto records, not XRPC)
+    response = _tangled.list_repo_issues(repo_id, limit, cursor)
 
     return {
         "issues": response["issues"],

tests/test_resolver.py

···
             resolve_repo_identifier("owner/repo")
 
     def test_valid_format_with_at_prefix(self):
-        """test that @owner/repo format is accepted"""
+        """test that @owner/repo and owner/repo resolve identically"""
         from tangled_mcp._tangled._client import resolve_repo_identifier
 
-        # this will fail at the resolution step, but not at parsing
-        with pytest.raises(Exception):  # will fail during actual resolution
+        # both formats should behave the same (@ is stripped internally)
+        # they'll both fail resolution with fake handle, but in the same way
+        with pytest.raises(ValueError, match="failed to resolve handle 'owner'"):
             resolve_repo_identifier("@owner/repo")
+
+        with pytest.raises(ValueError, match="failed to resolve handle 'owner'"):
+            resolve_repo_identifier("owner/repo")
 
     def test_valid_format_with_did(self):
         """test that did:plc:.../repo format is accepted"""