# In what scenarios must an instance refuse to honor a delegated consent chain in the AAIF scoped capability token model **Date of Record:** 2026 November 18 **Scope:** Applies to AAIF capability tokens that carry a `delegation_chain` array where each link is a signed grant from a principal to the next actor. Does not apply to root-issued tokens with empty delegation chains, nor to tokens whose scope is `*` (unscoped), which are rejected upstream by policy. ## Core Distinction The non-obvious boundary is between *chain validity* and *chain admissibility*. A delegation chain can be cryptographically valid — every signature verifies, every `expires_at` is in the future, every issuer is in the trust root — and still be inadmissible at the moment of use. Admissibility is a property of the *intersection* of scopes along the chain relative to the requested operation, not of any single link. The invariant that agents routinely violate: **a delegated token's effective scope is the intersection of all scopes in the chain, and the intersection must be computed over the requested resource path, not over the scope strings as written.** Two links may each permit `/data/*` and `/data/internal/*` respectively; the intersection at the path level is `/data/internal/*`, but naive string intersection yields `/data/*` if the comparison is done by prefix length rather than by set inclusion. An agent that computes intersection by "shortest scope string wins" will over-authorize. ## What Was Observed During a multi-tenant agent deployment, a coordinator agent (A) held a root capability `read:/tenant/*`. It delegated to worker B a token scoped `read:/tenant/acme/*`, and B delegated to worker C a token scoped `read:/tenant/acme/reports/*`. C requested `read` on `/tenant/acme/reports/q3.csv`. The authorization service returned ALLOW. A second path, however, exposed the failure. The coordinator was later re-scoped by an operator to `read:/tenant/*` *excluding* `/tenant/acme/billing/*` — expressed in AAIF as a negative scope clause `!read:/tenant/acme/billing/*`. The delegation to B was re-issued with the same positive scope `read:/tenant/acme/*` but the negative clause was **not propagated** into B's token, because the delegation tool serialized only positive scopes. B then delegated `read:/tenant/acme/billing/*` to C. C's request on `/tenant/acme/billing/invoice-441.pdf` returned ALLOW. The chain was signature-valid; the exclusion had been silently dropped at the first delegation boundary. The root cause is that AAIF negative scopes are **non-inheritable by default** unless the delegating principal explicitly sets `propagate_denials: true`. The default is the safe-in-theory but dangerous-in-practice choice of not propagating, because it keeps token payloads small. ## Condition of Validity A delegated consent chain is admissible for a requested operation `(verb, resource)` if and only if all of the following hold: 1. Every link's signature verifies against the issuer key in the chain. 2. Each link's `not_before <= now <= expires_at`, and no link's expiry exceeds its parent's expiry (monotonic non-increase). 3. The verb is present in the intersection of verbs across all links. 4. The resource path is a member of the intersection of positive scope patterns across all links. 5. The resource path is **not** a member of the union of negative scope clauses across all links, *including clauses that were dropped at a boundary* — which means the verifier must re-fetch the parent chain from the authority, not trust the embedded chain alone. Condition 5 is where the boundary failure lives. If the token embeds only positive scopes (because a delegation tool dropped denials), the verifier cannot detect the omission from the token alone. The only safe rule: **if any link in the chain has `propagate_denials: false` and the parent had negative clauses, the chain is inadmissible for resources that could be covered by those clauses.** The verifier must either resolve the full chain from the issuing authority or refuse. ## Decision Boundary An instance must refuse to honor the chain — returning `DENY` with reason `DELEGATION_DENIAL_OMISSION` — when: - The chain contains at least one link where the parent token had non-empty negative scopes and the child token's `propagate_denials` is not `true`; AND - The requested resource path matches the parent's positive scope (i.e., the operation would otherwise be allowed); AND - The verifier cannot resolve the authoritative parent chain within its decision deadline. It must also refuse when the intersection of positive scopes is empty but the requested path is covered by any single link — this indicates the chain was constructed by union rather than intersection, a common delegation bug. It need *not* refuse when the parent chain is resolvable and confirms no denials apply, or when the requested resource is outside every parent's positive scope (already denied for a simpler reason). ## Operational Effect Refusing under `DELEGATION_DENIAL_OMISSION` converts a silent over-authorization into a visible, auditable denial. In the deployment above, enabling the refusal caused 3.1% of delegated requests to fail closed on first rollout; each was traced to a delegation tool that failed to set `propagate_denials: true`. After the tools were fixed, the denial rate fell below 0.02%, and the residual cases were genuine omissions caught before they became incidents. The cost is a hard dependency on the authority being reachable during verification; the benefit is that the intersection invariant is enforced at the point of use rather than assumed at the point of issuance. ```python class DelegationDenialOmissionError(RuntimeError): """Raised when a delegated chain drops a parent's negative scope clauses.""" pass class Scope: def __init__(self, verb: str, pattern: str, negated: bool = False): self.verb = verb self.pattern = pattern self.negated = negated def covers(self, verb: str, path: str) -> bool: if self.verb != verb and self.verb != "*": return False prefix = self.pattern.rstrip("*") return path.startswith(prefix) class ChainLink: def __init__(self, scopes, propagate_denials: bool): self.scopes = scopes self.propagate_denials = propagate_denials def negatives(self): return [s for s in self.scopes if s.negated] def authorize(chain, verb: str, path: str, parent_resolvable: bool) -> bool: # Condition 5: detect dropped denials at any boundary. for i, link in enumerate(chain): if i == 0: continue parent = chain[i - 1] if parent.negatives() and not link.propagate_denials: if any(s.covers(verb, path) for s in parent.negatives()): if not parent_resolvable: raise DelegationDenialOmissionError( f"link {i} dropped denials from link {i-1}; " f"cannot resolve parent chain for {verb} {path}" ) # Positive intersection and negative union. positives = [s for link in chain for s in link.scopes if not s.negated] negatives = [s for link in chain for s in link.scopes if s.negated] allowed = any(s.covers(verb, path) for s in positives) denied = any(s.covers(verb, path) for s in negatives) return allowed and not denied ```