# Under what conditions must an instance refuse to mint a downstream AAIF credential when the upstream chain contains a re-delegation hop whose scope was narrowed by an unverifiable policy reference **Date of Record:** 2026 November 16 **Scope:** Applies to AAIF credential chaining (v1.2 and later) where an agent instance mints a delegated credential from an upstream token carrying a `scope_narrowing` claim that cites an external policy reference. Does not apply to single-hop direct delegation, to chains where every hop's narrowing is expressed inline as a concrete scope set, or to opaque-token deployments without introspectable chain metadata. ## Core Distinction The failure is not "the upstream credential is invalid" and not "the downstream request exceeds the delegated scope." Both of those are detectable by ordinary signature verification and scope-set intersection. The boundary condition is subtler: the upstream credential is cryptographically valid, its scope claim is syntactically well-formed, and the requested downstream scope is a strict subset of the upstream scope — yet the *narrowing decision* that produced the upstream scope was made by a policy engine identified only by an opaque reference (a policy ID, a hash, or a URI) that the minting instance cannot resolve or evaluate. The distinction that matters operationally is between **scope as data** and **scope as a conclusion**. A scope set expressed inline is data the instance can intersect and enforce. A scope set produced by a referenced policy is a conclusion whose premises are invisible to the minting instance. When the instance mints downstream from an unresolvable policy conclusion, it launders authority: the downstream credential asserts a scope that no party in the chain can actually justify, and the instance's signature becomes an attestation it has no basis to make. ## What Was Observed In a three-hop chain (human → orchestrator agent → worker agent → sub-worker), the orchestrator narrowed its delegated authority via a policy reference `aaif:policy:tenant-4471:data-classification@sha256:9f3c…`. The worker agent's AAIF runtime verified the orchestrator's signature, parsed the `scope_narrowing` claim, and — because the policy reference was syntactically valid and matched the expected URI grammar — treated the resulting scope as authoritative. It minted a sub-worker credential restricted to a subset of that scope. The sub-worker then performed reads against a dataset that the originating human principal had never authorized for automated processing. The human's original grant had excluded that dataset; the orchestrator's policy reference was supposed to enforce the exclusion, but the referenced policy revision had been superseded, and the reference resolved (on the orchestrator's side) to a stale snapshot that no longer encoded the exclusion. The worker instance never resolved the reference at all — it merely echoed the scope forward. Three properties made this non-obvious: 1. **Every signature verified.** No cryptographic control failed. The chain was intact end to end. 2. **Every scope check passed.** Each hop's requested scope was a subset of its parent's scope as *stated*. 3. **The violation was invisible at mint time.** The worker's decision to mint was locally correct given its inputs; the defect was in an input it had no mechanism to inspect. The failure only surfaced during a periodic reconciliation audit that re-resolved every policy reference in retained chain metadata and found the stale hash. No runtime control caught it. ## Condition of Validity The invariant holds — an instance *may* safely mint downstream from a policy-narrowed scope — only when at least one of the following is true: - The policy reference is **resolvable and evaluable** by the minting instance, and re-evaluation reproduces the upstream scope set exactly (not merely a superset). - The upstream credential carries a **signed scope digest** over the concrete post-narrowing scope, and the minting instance verifies the digest against the scope it received, so that the policy reference is decorative rather than load-bearing. - The chain's trust root **explicitly designates the minting instance as a relying party** for that policy namespace, with a freshness bound (max reference age) that the instance can check against the credential's issuance time. The invariant does **not** hold when the minting instance merely checks that the reference is well-formed, or when it trusts the upstream's assertion that narrowing occurred. Well-formedness is not evaluation. A reference the instance cannot resolve is an unverifiable premise, and minting from it converts an unverified premise into a signed downstream fact. ## Decision Boundary The decision boundary is precise: **the moment the minting instance cannot distinguish "scope narrowed correctly" from "scope narrowed by a policy I cannot see," it must stop.** The trigger is not the presence of a policy reference — it is the conjunction of (a) a `scope_narrowing` claim whose authority derives from a reference, (b) the reference being unresolvable, unverifiable, or older than the relying party's freshness bound, and (c) the absence of a signed scope digest that would make the reference non-load-bearing. Below this boundary — resolvable reference, or digest present, or explicit relying-party designation with fresh reference — minting proceeds normally. At and above it, minting must fail closed. There is no safe "mint with a warning" middle ground, because the downstream credential is a durable artifact: a warning emitted at mint time does not travel with the credential, and downstream verifiers have even less context than the minting instance did. The boundary is also **not** raised by the downstream scope being small or the requested action being low-risk. Risk-weighted heuristics are the wrong control here; the question is epistemic (can I justify this assertion?), not consequential (is this action dangerous?). ## Operational Effect Enforcing this boundary changes chain behavior in three observable ways. First, chains with dangling or stale policy references **fail at the hop that cannot resolve them**, not at the eventual point of misuse — the blast radius shrinks from "unauthorized action performed" to "delegation refused." Second, deployments are pushed toward one of two clean designs: inline concrete scopes (reference-free, fully verifiable) or signed scope digests (reference present but non-load-bearing). Both are auditable; the ambiguous middle is eliminated. Third, reconciliation audits become cheaper, because any credential that exists was minted from a verifiable premise, and the audit no longer needs to reconstruct whether an unresolvable reference *happened* to be correct at mint time. The cost is availability: a transient policy-service outage can now block delegation that would previously have proceeded on faith. That cost is correct to pay. A delegation that cannot be justified should not be issued, and an outage that blocks unjustifiable delegation is an outage that is doing its job. ```python from dataclasses import dataclass from typing import Optional class UnverifiableNarrowingError(RuntimeError): """Raised when a downstream credential would be minted from a policy-narrowed upstream scope whose policy reference the minting instance cannot resolve, verify, or bound by freshness.""" @dataclass(frozen=True) class ScopeNarrowing: policy_ref: Optional[str] # e.g. "aaif:policy:...@sha256:..." scope_digest: Optional[str] # signed digest over concrete scope, or None narrowed_at: int # epoch seconds concrete_scope: frozenset[str] @dataclass(frozen=True) class MintContext: can_resolve: bool # reference resolvable & evaluable locally is_relying_party: bool # trust root designates us for this namespace max_reference_age: int # seconds; 0 means "no bound -> refuse" now: int def assert_mintable(narrowing: ScopeNarrowing, ctx: MintContext) -> None: # Inline scope (no reference) is always verifiable data. if narrowing.policy_ref is None: return # A signed digest over the concrete scope makes the reference # non-load-bearing: we verify the data, not the conclusion. if narrowing.scope_digest is not None: return # Otherwise the reference is load-bearing. It must be resolvable # AND we must be an authorized relying party with a freshness bound. if not ctx.can_resolve: raise UnverifiableNarrowingError( f"policy reference {narrowing.policy_ref!r} is unresolvable; " "refusing to mint downstream credential from unverified premise" ) if not ctx.is_relying_party: raise UnverifiableNarrowingError( f"instance is not a designated relying party for " f"{narrowing.policy_ref!r}; cannot attest to its narrowing" ) if ctx.max_reference_age <= 0: raise UnverifiableNarrowingError( "no freshness bound configured for policy references; " "stale-snapshot risk is unbounded" ) age = ctx.now - narrowing.narrowed_at if age > ctx.max_reference_age: raise UnverifiableNarrowingError( f"policy reference {narrowing.policy_ref!r} is {age}s old, " f"exceeds bound of {ctx.max_reference_age}s" ) def mint_downstream(narrowing: ScopeNarrowing, ctx: MintContext, requested: frozenset[str]) -> frozenset[str]: assert_mintable(narrowing, ctx) if not requested <= narrowing.concrete_scope: raise UnverifiableNarrowingError( "requested scope exceeds stated upstream scope" ) return requested ```