# Which invariants prevent delegation-chain identity collapse when AAIF attestation is co-signed across trust domains **Date of Record:** 2026 November 15 **Scope:** Applies to AAIF (Agent Identity Attestation Framework) deployments where an agent's verifiable credential (VC) is presented alongside a delegation chain that crosses at least one trust-domain boundary (issuer registry A → issuer registry B), and where per-tool capability tokens (PCTs) are minted downstream of the chain root. Does not apply to single-domain chains terminated by a single issuer, nor to bearer-only tokens with no VC binding. ## Core Distinction A delegation chain is *structurally valid* when every link's signature verifies against the predecessor's `issuer` key and the chain's `exp`/`nbf` intervals are monotone non-increasing down the chain. A chain is *identity-coherent* when the subject identifier at each link resolves to the same cryptographic principal under the *verifier's* trust-domain key-resolution policy — not the issuer's. These two properties diverge exactly at the cross-domain boundary. The chain can verify end-to-end and still describe two different principals, because link `k` was signed by an issuer in domain A that domain B's resolver maps to a *different* DID document (same `did:web` hostname, different key material, different controller). Signature validity is local; identity coherence is global. The invariant that matters is **principal stability across resolver boundaries**, not signature chaining. ## What Was Observed In a three-link chain — root agent `did:web:corp.example:agents:orchestrator` → sub-agent `did:web:corp.example:agents:researcher` → tool-scope delegation to `did:web:partner.example:agents:fetcher` — the partner-domain verifier accepted the chain and minted a PCT for `tool:http:fetch` scoped to the researcher's subject. The failure surfaced 40 minutes later when the orchestrator's VC was rotated and `did:web:corp.example` re-published its DID document with a new `keyAgreement` key but retained the old `verificationMethod` id `#key-2`. The re-resolution of `#key-2` under the partner resolver returned the *new* key material because the partner domain caches DID documents by document hash, not by key id, and its cache had not yet seen the rotation. The PCT's `cnf` (confirmation) claim bound to the old key, but the delegation chain's link-1 signature — re-verified lazily at each PCT use — now resolved `#key-2` to a key that no longer matched the signature. The chain did not *fail*; it *silently re-anchored* to a principal the partner domain had never attested, and the PCT continued to be honored because the PCT's own signature (minted by the partner, over the partner's key) remained valid. The tool call proceeded with a capability token whose binding principal was, at the moment of use, unresolvable to the original delegator. The observable signal was not an error. It was a `cnf` mismatch that the verifier's policy treated as a *refreshable* condition rather than a *fatal* one, because the chain's `exp` had not passed. The capability was exercised for 11 minutes against a principal whose key had been superseded. ## Condition of Validity The principal-stability invariant holds only when all of the following are true simultaneously at every PCT use: 1. The resolver used to dereference each link's `issuer` is the *same resolver instance* (same cache, same policy version) used at chain-construction time — or the resolver exposes a monotone version vector and the verifier rejects on any version advance between construction and use. 2. Key identifiers (`verificationMethod` ids) are treated as *immutable bindings*: a re-resolution that returns different key bytes for the same id is a hard failure, not a refresh. 3. The PCT's `cnf` claim is checked against the *chain-root* principal, not the immediate delegator, on every use — because intermediate links can be re-anchored without invalidating the PCT's own signature. 4. Delegation `exp` is strictly less than the delegator's VC `exp` at every link (no equal-expiry links), so that a delegator's rotation cannot occur inside a still-valid delegate's window. Violation of any one of these is sufficient to permit silent re-anchoring. In the observed incident, conditions 1, 2, and 3 were all violated; condition 4 held, which is why the window was bounded to 11 minutes rather than the full delegation lifetime. ## Decision Boundary The operational decision is **fail-closed on re-resolution divergence, not fail-open on signature validity**. Concretely: - If a link's `verificationMethod` id re-resolves to different key bytes than at construction, the chain is *revoked*, not refreshed. The PCT is invalidated. The tool call is denied with a distinct error class (`PrincipalReanchoredError`), not a generic auth failure, so that callers do not silently retry against a stale resolver. - If the resolver version vector has advanced between chain construction and PCT use, the PCT is *re-validated from the root*, not merely re-checked at the leaf. Leaf-only re-check is the specific bug that allowed the incident. - Cross-domain chains must carry a `resolver_attestation` extension: a signed statement from the partner domain's resolver binding `(did, verificationMethod id, key thumbprint, resolver_version)` at construction time. On use, the verifier compares the live resolution against the attested thumbprint. Mismatch → revoke. The boundary is *not* "does the signature verify." It is "does the principal the signature resolves to remain the principal the root attested." These coincide in single-domain deployments and diverge precisely at the resolver boundary — which is why single-domain test suites never catch this. ## Operational Effect After enforcing the boundary, the observed incident class drops to zero but a new class appears: **false revocations on legitimate rotation**. When a delegator rotates keys *and* re-publishes under a new `verificationMethod` id (the correct rotation procedure), chains that referenced the old id are revoked even though the principal is unchanged. This is the intended trade: identity coherence is preserved at the cost of requiring re-delegation on rotation. The mitigation is not to relax the boundary but to make rotation *id-preserving* — publish the new key under a new id and keep the old id resolvable (to the old key) until all downstream delegations expire. The `resolver_attestation` extension makes this auditable: the attestation pins the id-to-thumbprint mapping, so a rotation that changes the mapping under a stable id is detectable as a policy violation rather than absorbed as a refresh. The net effect on the system is that PCT lifetime is bounded by the *shortest* of: tool-scope policy TTL, delegation `exp`, delegator VC `exp`, and resolver-version stability window. In practice the resolver-version window is the binding constraint in cross-domain deployments, and operators who do not measure it will see PCTs revoked earlier than their nominal TTL suggests — a signal, not a bug. ```python class PrincipalReanchoredError(RuntimeError): """Raised when a verificationMethod id re-resolves to different key bytes than were attested at delegation-chain construction time. Fail-closed: the PCT is invalidated, not refreshed.""" pass def verify_pct_against_chain(pct, chain, resolver, attested_bindings): # attested_bindings: {(did, vm_id): key_thumbprint} captured at construction for link in chain.links: did, vm_id = link.issuer, link.verification_method_id live_thumb = resolver.resolve_thumbprint(did, vm_id) attested_thumb = attested_bindings.get((did, vm_id)) if attested_thumb is None: raise PrincipalReanchoredError( f"no construction-time attestation for {did}#{vm_id}" ) if live_thumb != attested_thumb: raise PrincipalReanchoredError( f"principal re-anchored: {did}#{vm_id} resolved to " f"{live_thumb!r}, attested {attested_thumb!r}" ) if resolver.version_vector() != chain.resolver_version_at_construction: # resolver advanced: re-validate from root, never leaf-only return verify_pct_against_chain( pct, chain, resolver, attested_bindings ) root_principal = chain.links[0].subject if pct.cnf_principal != root_principal: raise PrincipalReanchoredError( f"PCT bound to {pct.cnf_principal!r}, chain root is {root_principal!r}" ) return True ```