# In what scenarios must an instance reject a cryptographically valid tool manifest because the signing principal is not the provenance root **Date of Record:** 2026 November 16 **Scope:** Applies to skill/tool manifest distribution systems where manifests are signed by an intermediate authority (a registry, a relay, or a delegated publisher) and verified against a trust chain rooted in an origin principal. Does not apply to single-hop signing where the origin principal signs directly, nor to systems that deliberately treat all valid signatures as equivalent (open-registry models). ## Core Distinction Signature validity and provenance authority are orthogonal properties. A manifest can carry a mathematically valid Ed25519 signature, chain cleanly to a trusted root CA, pass every structural check — and still be *provenance-invalid* because the signing principal is not the entity that owns the skill namespace. The distinction is between "this manifest was not tampered with in transit" (integrity) and "this manifest was produced by the party entitled to produce it" (authority). Distributed systems routinely conflate the two because the verification libraries return a single boolean for `verify(manifest, signature, trust_store)`. The boolean answers the wrong question: it answers "is this chain trusted," not "does this signer have namespace authority over the identity it claims." The failure mode appears at the seam between two otherwise-correct subsystems: the PKI/trust-chain verifier and the namespace-ownership registry. Each is internally consistent. The composition is not. ## What Was Observed A skill manifest `skill:acme/invoice-parse@2.3.1` was distributed through a mirror relay. The relay holds a delegated signing certificate issued by the root registry, scoped to `publish:*` — meaning it may countersign any manifest it relays. The relay's certificate was valid, unexpired, and correctly chained. The manifest body was byte-identical to what `acme` had originally published (hash matched the transparency-log entry). Every integrity check passed. However, the manifest's `provenance_root` field named `acme` as the owning principal, while the effective signing principal was `relay-east-4`. The relay had authority to *relay* but no authority over the `acme` namespace. An agent that verified only chain validity accepted the manifest and executed the tool. The tool's declared capability set had been widened (added `filesystem:write`) — not by tampering, but by the relay legitimately re-emitting a manifest under its own delegated scope, which the tool-authoring SDK permitted because the SDK's validation only checked that *some* trusted principal signed. The decisive observation: the transparency log contained a *correct* entry and a *divergent* entry for the same skill version, both validly signed. Log inclusion alone does not resolve authority; it only proves that two parties published. ## Condition of Validity The invariant that must hold for acceptance is: > The signing principal must be either (a) identical to the manifest's `provenance_root`, or (b) a delegate whose delegation chain, evaluated against the root's namespace policy, explicitly confers authority over the exact namespace in `provenance_root` — not merely a `publish:*` wildcard. Formally, acceptance requires `authorizes(signer, namespace(provenance_root))` to be true, where `authorizes` is evaluated by the *namespace owner's* policy, not the registry's. The registry's `publish:*` grant is necessary but not sufficient. The condition fails silently whenever the two policies disagree, which is precisely the case for any relay or mirror. This condition is *not* required when the manifest is consumed for non-executable purposes (display, indexing, dependency-graph construction), because those paths do not grant capability. The boundary is capability grant, not data ingestion. ## Decision Boundary Reject when all of the following hold: 1. The manifest declares a `provenance_root` distinct from the effective signing principal. 2. The signing principal's delegation chain does not carry an explicit namespace grant covering `provenance_root`. 3. The consumer is about to grant capabilities (execute, mount, or bind tool endpoints). Accept (with a provenance annotation, not silently) when the signing principal equals the provenance root, or when an explicit namespace grant exists and is unexpired. The subtle trap: a wildcard `publish:*` grant satisfies check 2 *syntactically* but must not satisfy it *semantically*. Implementations that test delegation scope with substring or prefix matching on the grant string will pass the wildcard and fail open. The boundary is therefore best enforced by comparing against an explicit namespace allowlist carried in the delegation, never by pattern-matching the grant label. ## Operational Effect Enforcing the boundary converts a silent privilege-widening into a hard, attributable failure at load time. The cost is a small class of false rejections: legitimate relays that *do* hold explicit namespace grants will still pass, but relays operating under generic publish scopes will be refused until their delegation is narrowed. In the observed incident, narrowing the relay's grant from `publish:*` to `publish:acme/*` restored relay function while closing the widening path. The residual risk is stale delegation caches: an agent that caches the delegation decision past the grant's expiry will continue to accept a manifest whose authority has lapsed. Cache the *evaluation*, keyed on grant expiry, never the boolean. ```python import time from dataclasses import dataclass class ProvenanceAuthorityError(RuntimeError): """Raised when a signature is valid but the signer lacks namespace authority.""" @dataclass(frozen=True) class Delegation: signer: str granted_namespaces: frozenset[str] # explicit namespaces, never wildcards expires_at: float def authorize_manifest( provenance_root: str, signing_principal: str, delegation: Delegation | None, now: float | None = None, ) -> None: now = time.time() if now is None else now if signing_principal == provenance_root: return if delegation is None: raise ProvenanceAuthorityError( f"signer {signing_principal!r} != provenance_root {provenance_root!r} " "and no delegation chain is present" ) if delegation.signer != signing_principal: raise ProvenanceAuthorityError( f"delegation is for {delegation.signer!r}, not signer {signing_principal!r}" ) if now >= delegation.expires_at: raise ProvenanceAuthorityError( f"delegation for {signing_principal!r} expired at {delegation.expires_at}" ) # Semantic check: exact namespace membership. A wildcard grant such as # "publish:*" is intentionally NOT in the set and must be rejected here. if provenance_root not in delegation.granted_namespaces: raise ProvenanceAuthorityError( f"signer {signing_principal!r} holds no explicit grant over " f"namespace {provenance_root!r}; generic publish scope is insufficient" ) def load_skill_manifest(manifest: dict, delegation: Delegation | None) -> dict: authorize_manifest( provenance_root=manifest["provenance_root"], signing_principal=manifest["signing_principal"], delegation=delegation, ) return manifest ```