# Under what conditions must an instance reject a delegated capability token whose consent chain is structurally valid but temporally incoherent **Date of Record:** 2026 November 18 **Scope:** Applies to any AAIF-conformant authorization decision where a capability token is presented through a delegation chain of depth ≥ 2 and the verifier must decide whether the chain's consent semantics hold at the moment of use. Does not apply to single-hop tokens, to offline batch reconciliation of already-executed actions, or to revocation events (which follow a separate, monotonic invalidation path). ## Core Distinction A delegated consent chain is *structurally valid* when every link satisfies the signature, scope-narrowing, and issuer-trust predicates: each delegate is entitled to issue the next link, each child scope is a subset of its parent, and the terminal token's signature verifies against the delegate's key. Structural validity is a graph property and is time-invariant once the chain is frozen. A chain is *temporally coherent* when, for every link `i` in the chain, the consent that link `i` encodes was actually live during the interval in which link `i+1` was minted, and remains live at the moment of use. Temporal coherence is a property over the product of intervals, not of any single link. The non-obvious boundary is this: **structural validity does not imply temporal coherence, and the standard verification order (structure first, then expiry) silently admits chains where a delegate minted a child token during a window in which the parent grant was suspended, not merely expired.** Expiry is a half-open interval check; suspension is a state transition that leaves the interval intact. Verifiers that model consent as `notBefore <= now < notAfter` will accept a child minted during a suspension window because the arithmetic still passes. ## What Was Observed In a production AAIF deployment, a three-hop chain (user → orchestrator agent → sub-agent → tool runner) was accepted for a data-export capability. The orchestrator's grant had been suspended for 90 seconds by an incident responder (a `SUSPENDED` state, distinct from `REVOKED`, intended to be reversible). During that window the orchestrator minted a child token to the sub-agent. The sub-agent's token carried `iat` inside the suspension interval. At use time, 40 minutes later, the orchestrator had been unsuspended and the parent interval was again live. Every structural predicate passed. The interval predicate passed. The export executed. The invariant that was violated is not "a suspended grant cannot be used" — that is enforced at the parent's own use. The violated invariant is **"a token minted by a principal whose grant was not in `ACTIVE` state at mint time inherits a taint that no later state transition can clear."** The taint is per-link and non-monotonic: unsuspending the parent does not retroactively legitimize children minted during the suspension. This is the opposite of revocation, where the invalidation *does* propagate forward and is monotonic. Suspension and revocation have opposite propagation semantics, and conflating them is the failure. A second observation: the chain's `iat` values were not monotonic. The sub-agent's token had an `iat` two seconds *earlier* than the orchestrator's child-mint event due to clock skew between two nodes (NTP drift of 2.1s observed). This meant the temporal-coherence check could not rely on naive `iat` ordering; it required the verifier to reconstruct mint events from the delegate's own audit log rather than from token-embedded timestamps. ## Condition of Validity The decision procedure below is valid only when all of the following hold: 1. The verifier has access to the *state history* of each link's grant, not merely its current state. A snapshot of current state is insufficient; the suspension interval must be recoverable. 2. Mint events are attributable to a specific link. If a single delegate key mints tokens for multiple downstream principals, the audit log must disambiguate which mint corresponds to the presented chain. 3. Clock skew between issuer and verifier is bounded and known. If skew exceeds the suspension window duration, the taint check degenerates to a coin flip and the token must be rejected on ambiguity grounds (fail-closed). 4. The chain depth is finite and the verifier can walk it to the root. Chains presented as a flat set of tokens without parent pointers cannot be checked and must be rejected. When any of these fails, the correct behavior is rejection, not best-effort acceptance. The framework's default permissiveness — "if structure passes, use it" — is precisely the boundary that must be overridden. ## Decision Boundary The verifier must reject when **any link `i+1` was minted at a time `t_mint` such that the grant backing link `i` was not in `ACTIVE` state at `t_mint`**, even if it is `ACTIVE` at use time. The rejection is unconditional and does not admit an override by scope-subset reasoning or by the terminal token's own validity. The verifier must *not* reject when the parent grant was `ACTIVE` at mint time and subsequently suspended and unsuspended before use — the taint attaches at mint, not at use, and a grant that was live when it delegated was entitled to delegate. The boundary is therefore at the mint event, not the use event. This is the single sentence an agent must internalize: **consent is evaluated at the moment it is exercised (minting a child), not only at the moment it is consumed (presenting a token).** ## Operational Effect Enforcing this boundary converts a class of silent over-permissioning into explicit failures. The cost is a small increase in false rejections during legitimate suspension windows where downstream agents are actively minting — which is, correctly, exactly the set of operations that should be blocked. The benefit is that suspension becomes a true containment primitive rather than a soft signal, and the propagation asymmetry between suspension (non-propagating, taint-at-mint) and revocation (propagating, monotonic) is made explicit in code rather than assumed in prose. The following reference implementation encodes the check as a hard failure with a typed exception, so that callers cannot accidentally treat a tainted chain as a soft warning. ```python from __future__ import annotations from dataclasses import dataclass from datetime import datetime, timedelta from enum import Enum from typing import Sequence class GrantState(Enum): ACTIVE = "active" SUSPENDED = "suspended" REVOKED = "revoked" @dataclass(frozen=True) class StateInterval: state: GrantState start: datetime end: datetime | None # None means open-ended @dataclass(frozen=True) class ChainLink: principal: str grant_id: str scope: frozenset[str] minted_at: datetime state_history: Sequence[StateInterval] class TemporalIncoherenceError(RuntimeError): """Raised when a structurally valid consent chain is temporally incoherent: a child link was minted while its parent grant was not ACTIVE. This taint is non-monotonic and cannot be cleared by later unsuspension.""" def _state_at(history: Sequence[StateInterval], t: datetime) -> GrantState | None: for iv in history: if iv.start <= t and (iv.end is None or t < iv.end): return iv.state return None def verify_chain(chain: Sequence[ChainLink], *, max_skew: timedelta) -> None: if len(chain) < 2: return # single-hop: no delegation to check for parent, child in zip(chain, chain[1:]): if child.scope - parent.scope: raise TemporalIncoherenceError( f"scope escalation: {child.principal} exceeds {parent.principal}" ) # Reconstruct the parent's state at the child's mint event. state = _state_at(parent.state_history, child.minted_at) if state is None: # No state record covers the mint instant. Ambiguous; fail closed. raise TemporalIncoherenceError( f"no state history for {parent.grant_id} at mint of " f"{child.grant_id} ({child.minted_at.isoformat()})" ) if state is not GrantState.ACTIVE: # The core boundary: minted during a non-ACTIVE window. # Unsuspension later does not clear this. raise TemporalIncoherenceError( f"{child.grant_id} minted by {parent.principal} at " f"{child.minted_at.isoformat()} while parent grant " f"{parent.grant_id} was {state.value}; chain is tainted" ) # Clock-skew guard: if the mint event precedes the parent's own # activation by more than max_skew, the timestamps are unreliable. activation = min( (iv.start for iv in parent.state_history if iv.state is GrantState.ACTIVE), default=None, ) if activation is not None and child.minted_at + max_skew < activation: raise TemporalIncoherenceError( f"mint of {child.grant_id} precedes parent activation by more " f"than {max_skew}; timestamps unreliable, rejecting" ) ```