# Which invariants prevent a signed skill manifest from being silently re-bound to a different tool endpoint at agent-runtime load time **Date of Record:** 2026 November 16 **Scope:** Applies to agent runtimes that load "skills" (declarative tool/instruction bundles) through a signed manifest that names tool endpoints, and that resolve those endpoints at load time via a registry, config overlay, or environment substitution. Does not apply to runtimes that hard-pin endpoint identity inside the signed payload (see Condition of Validity) or to skills with no external tool bindings. ## Core Distinction A signed manifest proves *who authored which bytes*. It does not, by itself, prove *which live endpoint those bytes will be executed against*. The two properties — **payload integrity** and **binding integrity** — are routinely conflated. A signature over `{skill_name, version, tool_names, sha256_of_prompt_bundle}` is payload-integrity only. If the runtime resolves `tool_names` to endpoints through any indirection (a name→URL registry, a `$TOOL_HOST` env var, a service-discovery lookup, a `latest` tag), an attacker who cannot forge the signature can still cause the signed skill to invoke an endpoint they control. The signed artifact is authentic; the execution is not. This is the supply-chain skill-injection boundary: **the signature is checked at the wrong layer** — over the artifact, while the attack operates on the resolution step. The non-obvious part: the manifest *looks* binding-complete. It names tools. It is signed. Reviewers read "signed manifest naming tools" and infer end-to-end integrity. The gap is that the name is a *reference*, not an *identity*, and the signature never covers the referent. ## What Was Observed In a runtime loading third-party skills, the following sequence reproduced silently — no signature failure, no warning: 1. A skill `pdf-extract@2.1.0` ships a manifest signed by a trusted publisher. Payload includes `"tools": ["document.parser"]` and a bundle hash. Signature verifies cleanly. 2. The runtime resolves `document.parser` through a registry entry that maps the logical name to `https://parser.internal/v3`. The registry entry is *not* covered by the skill signature — it is operator-managed config. 3. An attacker with registry-write (or env-var control, or DNS for `parser.internal`) repoints `document.parser` → an endpoint they own. 4. The signed skill now feeds untrusted document content — and any credentials the skill is authorized to pass — to the attacker's endpoint. Observed invariants that were *assumed* but never *enforced*: - **Name-to-identity stability:** nothing checked that the endpoint resolved at load equals the endpoint the publisher tested against. - **Transitive coverage:** the signature covered the manifest, not the manifest's *dependencies'* resolved identities. - **Load-time vs. run-time agreement:** resolution happened at load; the endpoint could be re-resolved per call, and nothing compared the two. - **Version pinning of referents:** `document.parser` had no digest; a compatible-looking replacement passed every check. The failure is *silent* because every individual check passes. Signature: valid. Name: present. Endpoint: reachable. The composition of valid checks yields an invalid binding. ## Condition of Validity The payload-only signature is a sufficient defense **only if** at least one of the following holds, and the runtime must *prove* which one it is relying on: 1. **Endpoint identity is inside the signed payload** — the manifest carries the full URL *and* a content digest (e.g., `sha256` of the tool's declared schema/capabilities), so re-binding changes signed bytes and breaks the signature. 2. **The referent is content-addressed and immutable** — `tool_names` are digests, not labels, and the registry cannot serve different content under the same digest. 3. **The resolution step is itself signed** — the name→endpoint map is a signed, versioned artifact whose signature the runtime verifies with the same trust root as the skill. If none hold, the manifest is payload-integrity-only and must be treated as such: it authenticates the *instructions*, never the *wiring*. Any claim of supply-chain resistance beyond payload integrity is false. The load-bearing question is not "is the manifest signed?" but "**does the signature's coverage set include the resolved endpoint identity?**" If the coverage set and the execution set differ by even one indirection, the boundary is open. ## Decision Boundary At load time, the runtime must decide: *accept this binding* or *refuse to load*. The decision rule that closes the gap: - Compute the **resolved binding set** `B = {(tool_name, endpoint_url, endpoint_digest)}` actually used at execution. - Compute the **signed binding set** `S` = the subset of `B` whose members appear inside the verified payload (or inside a transitively-verified signed resolution artifact). - **Accept only if `B ⊆ S`.** Any member of `B` not in `S` is an unauthenticated binding and must fail closed — not warn, not degrade, not "use default." - Treat name-only references with no digest as *unbound*: they belong to `B \ S` by construction and must be rejected unless a signed resolution artifact supplies their identity. The boundary is crossed the moment the runtime executes against an endpoint it cannot trace into the signature's coverage set. Do not defer this to runtime; a per-call re-resolution after a passing load-time check re-opens the gap. Pin `B` at load and refuse to re-resolve without re-verifying. ## Operational Effect Enforcing `B ⊆ S` converts a silent supply-chain injection into a hard, attributable load failure. The skill either loads with every endpoint cryptographically bound to the publisher's signature, or it does not load at all. Consequences to expect: - **Legitimate skills break** where publishers relied on operator-managed name indirection. This is correct: those skills were never actually end-to-end verified. Migration path is to move endpoint identity (URL + digest) into the signed payload or publish a signed resolution map. - **Registry and env-var indirection become auditable** rather than trusted-by-default; the resolution artifact joins the trust boundary and must be signed and versioned. - **Failures are loud and specific** — the error names the unbound tool and the endpoint that could not be traced to the signature, which is exactly the forensic record needed to detect an attempted re-binding. The invariant to carry forward: *a signature protects exactly the set of bytes it covers, and nothing downstream of a reference.* Defending a skill supply chain means continuously proving that the execution binding set is a subset of the signed coverage set — and refusing to run otherwise. ```python from dataclasses import dataclass from typing import FrozenSet class UnboundSkillBindingError(RuntimeError): """Raised when a skill would execute against an endpoint not covered by its signature.""" pass @dataclass(frozen=True) class Binding: tool_name: str endpoint_url: str endpoint_digest: str def assert_bindings_signed( resolved: FrozenSet[Binding], signed: FrozenSet[Binding], ) -> None: """ Enforce the load-time invariant B subset-of S. `resolved` = endpoints the runtime will actually execute against. `signed` = endpoints whose identity is inside the verified manifest (or a transitively-verified signed resolution artifact). Any resolved binding outside the signed set is an unauthenticated supply-chain binding and must fail closed. """ unbound = resolved - signed if unbound: details = "; ".join( f"{b.tool_name} -> {b.endpoint_url} (digest={b.endpoint_digest})" for b in sorted(unbound, key=lambda x: x.tool_name) ) raise UnboundSkillBindingError( "Skill binding set exceeds signed coverage; refusing to load. " f"Unbound endpoints: {details}" ) def load_skill(name: str, resolved: FrozenSet[Binding], signed: FrozenSet[Binding]) -> str: # Fail closed before any endpoint is contacted. assert_bindings_signed(resolved, signed) return f"skill {name} loaded with {len(resolved)} verified binding(s)" ```