# Where must an instance refuse to co-sign a delegated capability when its own provenance chain contains a non-monotonic trust edge **Date of Record:** 2026 November 14 **Scope:** Applies to agent-to-agent delegation where each hop emits a signed capability token carrying an issuer→subject edge, a scope subset, and a policy epoch, and where downstream audit trails must be non-repudiable. Does not apply to single-hop human-to-agent authorization or to systems where token lifetime and policy epoch are globally monotonic by construction. ## Core Distinction The common intuition is that a delegation chain is safe if every link verifies: each signature checks out, each child scope is a subset of its parent, and each token is unexpired. That is *link-local* validity. The boundary failure lives at *chain-global* validity, which is a different predicate: the composed chain must be *monotonic in policy epoch* and *acyclic in issuer identity* across the full transitive closure, not just the immediate parent. A verifier that only checks the immediate parent edge will co-sign a capability whose provenance contains a *non-monotonic trust edge* — a hop where the child token was minted under a policy epoch earlier than the epoch its parent was minted under, or where an issuer appears twice in the ancestry with different effective policy. Both produce a chain that verifies link-by-link yet cannot be non-repudiably attributed, because the same issuer identity held two different authority sets at the same logical position in the chain. The signature is valid; the *attribution* is not. ## What Was Observed In a delegation graph where agent A mints a capability for B at epoch 7, B delegates to C, C's token is later re-minted (after a policy rollback) at epoch 5, and D is asked to co-sign the composed capability: every individual signature verified. Scope subsetting held at every hop. No token was expired. The composed chain nevertheless contained a trust edge (C→D) whose effective policy epoch (5) was lower than an ancestor's (7). D's audit trail recorded a capability that, under epoch 5 rules, C could not have been authorized to delegate — but under epoch 7 rules it could. The record is therefore ambiguous under replay, and non-repudiation fails: C can plausibly deny the delegation because its signing epoch predates the authority the chain assumes. The failure is silent. It is not a signature failure, not a scope-escalation failure, and not an expiry failure. It surfaces only when an auditor attempts to *reconstruct authority at the time of signing* and finds two mutually inconsistent epoch interpretations for a single issuer. ## Condition of Validity Chain-global validity holds only if the following invariant is enforced at co-sign time, over the *entire ancestry*, not the parent edge: 1. For every edge `(issuer_i → subject_i)` in the ancestry, `epoch(token_i) >= epoch(token_{i-1})` — policy epochs are non-decreasing from root to leaf. 2. No issuer identity appears more than once in the ancestry path with distinct `(epoch, effective_scope)` pairs. 3. The ancestry is acyclic as a directed graph of issuer identities (a re-entrant issuer is a self-delegation cycle masquerading as a longer chain). If any of these fails, the chain is *locally valid but globally un-attributable*, and co-signing it commits the co-signer to an audit record it cannot defend. ## Decision Boundary The co-signer must distinguish "I cannot verify this link" (a link-local failure — reject, log, done) from "this link verifies but the chain is un-attributable" (a chain-global failure — reject *and* emit a distinct non-repudiation refusal record, because the refusing instance is now itself part of the provenance evidence). Conflating the two destroys the audit value: a link-local rejection looks like a bad actor; a chain-global rejection is evidence that the *delegation topology* is inconsistent and must be surfaced to the policy authority, not silently dropped. The boundary is: co-sign only when `chain_globally_valid(ancestry) and link_locally_valid(edge)`. Refuse — with a distinct error class — when `link_locally_valid(edge)` is true but `chain_globally_valid(ancestry)` is false. Never downgrade the latter to the former. ## Operational Effect An instance that enforces only link-local validity will co-sign non-monotonic chains under normal operation and will appear, in post-incident audit, to have *asserted* authority it never held. The blast radius is the co-signer's own non-repudiation: its signature is the thing that fails to hold up, not the delegator's. Enforcement of the chain-global predicate converts a silent attribution failure into an explicit, signed refusal that names the offending edge and epoch — which is exactly the artifact an auditor needs to reconstruct what actually happened. The cost is that some legitimately re-minted chains (policy rollbacks) will be refused and must be re-rooted; that cost is the price of a defensible trail. ```python from dataclasses import dataclass from typing import Sequence class NonMonotonicProvenanceError(RuntimeError): """Raised when a delegation chain verifies link-locally but is globally un-attributable.""" @dataclass(frozen=True) class DelegationEdge: issuer: str subject: str epoch: int scope: frozenset def chain_globally_valid(ancestry: Sequence[DelegationEdge]) -> bool: # Epochs must be non-decreasing root -> leaf. for parent, child in zip(ancestry, ancestry[1:]): if child.epoch < parent.epoch: return False # No issuer may reappear with a different (epoch, scope) pair. seen: dict[str, tuple[int, frozenset]] = {} for edge in ancestry: prior = seen.get(edge.issuer) if prior is not None and prior != (edge.epoch, edge.scope): return False seen[edge.issuer] = (edge.epoch, edge.scope) return True def cosign(ancestry: Sequence[DelegationEdge], link_locally_valid: bool) -> None: if not link_locally_valid: raise ValueError("link-local signature/scope/expiry failure") # ordinary rejection if not chain_globally_valid(ancestry): offending = next( (c for p, c in zip(ancestry, ancestry[1:]) if c.epoch < p.epoch), ancestry[-1], ) raise NonMonotonicProvenanceError( f"refusing co-sign: non-monotonic trust edge at issuer={offending.issuer!r} " f"epoch={offending.epoch}; chain is locally valid but globally un-attributable" ) # Only here does the co-signer commit its signature to the audit trail. return None ```