@openwop/openwop-conformance 2.46.44 → 2.47.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [2.47.0] — 2026-11-13 — Cache-key recipe 2, telemetry export, sabotage ledger
+
+- **RFC 0260.** `v2-replay-llm-cache-key`: a server-free shape leg, an unaided implies-idempotency leg, and four host legs on `GET /runs/{runId}/effects` (key recorded, parameters in the key, stable, portable), gated on `replay.llmCacheKeyRecipe` and the `conformance-llm-cache-key` fixture. Judges in `lib/llm-cache-key-2.ts`.
+- **RFC 0262.** `v2-telemetry-export`: a server-free shape leg and five legs against the suite OTLP collector (run span, node span, `traceparent`, no secret in spans, GenAI attributes), gated on the `telemetry` family.
+- **RFC 0263.** `v2-sabotage-ledger` (coherence) drives `check-accepted-predicate` rules 5 and 6 on fixture trees, with positive and negative controls.
+
 ## [2.46.44] — 2026-11-08 — Bounded loopback and resolvedVia go Active
 
 - **RFC 0258.** `v2-bounded-loopback`: a server-free shape leg and six host legs (re-arm, history from the log, `ApprovalData.loopback`, withdraw, fail on exhaustion, replay re-arm), gated on the `loopback` family and the `conformance-loopback-refine` / `-fail` fixtures. Judges in `lib/bounded-loopback-witness.ts`.

package/README.md

@@ -137,7 +137,7 @@ Each scenario file records its disposition and assertion count in `<report-dir>/
 
 ## What's Covered
 
-The current suite has 668 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 228 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
+The current suite has 670 scenario files under `src/scenarios/`. By target major ([`scenario-majors.json`](./scenario-majors.json)): 230 files run against a v2 host and 455 against a v1 host; 15 of them run at both.
 
 The v2 scenarios (`src/scenarios/v2-*.test.ts`) cover, by area:
 
@@ -166,7 +166,7 @@ Three kinds of scenario share the tree:
 - **Host** checks drive a live host over HTTP.
 - **Gated** checks run only when the host advertises the family, profile or fixture they need, and otherwise record `inapplicable` or `blocked` with a reason. `--require-behavior` turns an advertised-but-unwitnessable behaviour into a failure.
 
-Current source tree: 668 scenario files. [`coverage.md`](./coverage.md) maps each spec document and every OpenAPI operation to its scenarios. [`CHANGELOG.md`](./CHANGELOG.md) records when each scenario landed.
+Current source tree: 670 scenario files. [`coverage.md`](./coverage.md) maps each spec document and every OpenAPI operation to its scenarios. [`CHANGELOG.md`](./CHANGELOG.md) records when each scenario landed.
 
 ## How the 2.x suite is built
 

package/dist/spec-artifacts.lock.json

@@ -1,5 +1,5 @@
 {
   "package": "@openwop/spec-artifacts",
-  "version": "2.46.44",
-  "stampSha256": "e300a0ad34ed84f4615a9c50caeb9d25598c83c66924ad027cd8cfb9ee8b2651"
+  "version": "2.47.0",
+  "stampSha256": "f03caded5ddba2a0fd12bf7b6a93995789afdd4ae5ffd56d0cfcde8701f7a657"
 }

package/fixtures/conformance-llm-cache-key.json

@@ -0,0 +1,23 @@
+{
+  "id": "conformance-llm-cache-key",
+  "name": "Conformance: LLM cache key recipe 2 (RFC 0260)",
+  "version": "1.0",
+  "description": "Fixture for `v2-replay-llm-cache-key.test.ts` (RFC 0260; the rules are the `replay.llmCacheKeyRecipe` facet description and the effect-ledger `cacheKey` description). One node, `conformance.callai.cache-key` (conformance-RESERVED). It makes exactly one `ctx.callAI` call through the host's conformance mock provider, whose provider id is `conformance-mock` and model id `conformance-mock-1`. The call sends one message `{role: \"user\", content: inputs.request.prompt}`, no tools, no toolChoice, no responseSchema, and exactly the parameters in `inputs.request.params` (keys from recipe 2's named set: `temperature`, `maxTokens`, `stop`, `seed`, `topP`, `topK`, `frequencyPenalty`, `presencePenalty`), nothing more. The mock replies `ok`. The host records the call on `GET /runs/{runId}/effects` under this node's id, carrying `cacheKey`. The node completes with `outputs.text`, the reply. A host that does not advertise `replay.llmCacheKeyRecipe` MUST NOT advertise this fixture.",
+  "nodes": [
+    {
+      "id": "llm-call",
+      "typeId": "conformance.callai.cache-key",
+      "name": "One ctx.callAI call through the conformance mock",
+      "position": { "x": 0, "y": 0 },
+      "config": {},
+      "inputs": {}
+    }
+  ],
+  "edges": [],
+  "triggers": [{ "id": "manual", "type": "manual", "enabled": true }],
+  "variables": [
+    { "name": "request", "type": "object" }
+  ],
+  "metadata": { "tags": ["conformance", "replay", "llmCacheKeyRecipe"] },
+  "settings": { "timeout": 0 }
+}

package/fixtures.md

@@ -150,6 +150,7 @@ All fixtures MUST advertise:
 | v2 fs Sandbox Probe | `conformance-fs-probe` | `storage.md` §`fs` — one `core.conformance.fs-probe` node (conformance-RESERVED) calls the host's own `ctx.fs.read` / `write` with the run's `path`, unchanged; a rejection fails the node with its code and details. Operator symlink `<sandboxRoot>/conformance/escape-link` points outside the root. See §"The storage probe fixtures" | `completed` inside the root; `failed` (`forbidden`, `details.reason: path-outside-sandbox`) for an escape | ≤ 30s |
 | v2 tableStorage Schema Probe | `conformance-table-schema-probe` | `storage.md` §`tableStorage` — one `core.conformance.table-schema-probe` node (conformance-RESERVED) creates a table `{ k: string, n: number }` with the host's own `ctx.storage.table`, then inserts a well-typed row (`control`), a row whose `n` is a string (`insert-mistyped`), or updates `n` to a string (`update-mistyped`). See §"The tableStorage schema probe fixture" | `completed` for `control`; `failed` (`validation_error`, `details.service: tableStorage`) for a mistyped write | ≤ 30s |
 | v2 ctx.callAI Attempt Accounting | `conformance-callai-attempt-accounting` | RFC 0248 — one `conformance.callai.echo-attempts` node (conformance-RESERVED) that makes one `ctx.callAI` call through the host's conformance mock, serves the run's `script`, and echoes the result's `attempts` (`v2-callai-attempt-accounting`) | each case run completes or fails as its script dictates | ≤ 30s |
+| v2 LLM Cache Key | `conformance-llm-cache-key` | RFC 0260 — one `conformance.callai.cache-key` node (conformance-RESERVED) making one `ctx.callAI` call through the suite's mock provider with the run's prompt and params unchanged (`v2-replay-llm-cache-key`) | completes; the call's effect record carries `cacheKey` | ≤ 30s |
 | v2 safeFetch SSRF Probe | `conformance-safefetch-probe` | `host-services.md` §`httpClient` — one `core.conformance.safefetch-probe` node (conformance-RESERVED) calls the host's own `ctx.http.safeFetch(url)` with the run's `url`, unchanged; completes with the response `status` only; a rejection fails the node with its code and details. See §"The safeFetch probe fixture" | `failed` (`egress_denied`, `details.reason: ssrf-blocked`) for a refused target | ≤ 60s |
 | A2A Task Roundtrip                        | `conformance-a2a-task-roundtrip`                                                                | Track 6 — host consumes the conformance suite's synthetic A2A peer; covers drift points #3 (`AUTH_REQUIRED`) and #4 (`REJECTED`). Node `core.conformance.a2a-invoke` is a **conformance-RESERVED** typeId (renamed 2026-08-16 from `core.a2a.invoke`, a multi-segment `core.*` id no host shipped and the corpus never defined): a host that consumes A2A peers MUST map it to its A2A bridge node (a host-extension node — `a2a-integration.md` §"State projection"); a host that does not consume A2A MUST NOT advertise this fixture                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | `failed` or `waiting-input` (per `driftScenario` input)                             | ≤ 30s                        |
 | WASM Pack Roundtrip                       | `conformance-wasm-pack-roundtrip`                                                               | RFC 0008 — invokes `vendor.openwop.rust-hello.greet` (loaded WASM pack); exercises required exports + at least one import                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | `completed`                                                                         | ≤ 10s                        |
@@ -924,6 +925,8 @@ For `v2-tool-catalog-annotations`' unclassified-MCP leg, a host that advertises
 
 `conformance-callai-attempt-accounting` is what `v2-callai-attempt-accounting` drives. Its node, `conformance.callai.echo-attempts`, is conformance-RESERVED. A host that advertises `aiProviders.callAccounting` maps it to a node that makes exactly one `ctx.callAI` call through the host's conformance mock provider. It does no counting of its own. A host that does not advertise `callAccounting` MUST NOT advertise the fixture.
 
+`conformance-llm-cache-key` is what `v2-replay-llm-cache-key` drives. Its node, `conformance.callai.cache-key`, is conformance-RESERVED. A host that advertises `replay.llmCacheKeyRecipe` maps it to a node that makes exactly one `ctx.callAI` call through the host's conformance mock provider, passing the run's prompt and parameters unchanged, so the suite can recompute the recipe-2 key from the inputs it sent. A host that does not advertise `llmCacheKeyRecipe` MUST NOT advertise the fixture.
+
 **Inputs.** `request` is passed to `ctx.callAI` unchanged: `prompt`, and optionally `responseSchema`, `maxTokens` and `retry`. `script` is the mock's replies.
 
 **The mock.** It serves `script` to the call's provider requests in order, one entry per request, and repeats the last entry past the end. Each entry is `{ kind, outputTokens?, usage?, structuredMode? }`:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openwop/openwop-conformance",
-  "version": "2.46.44",
+  "version": "2.47.0",
   "description": "Black-box conformance suite for OpenWOP hosts (v2 current; v1 scenarios retained for the frozen v1 tree).",
   "repository": {
     "type": "git",
@@ -56,6 +56,6 @@
     "@openwop/spec-artifacts": "file:../spec-artifacts"
   },
   "peerDependencies": {
-    "@openwop/spec-artifacts": "2.46.44"
+    "@openwop/spec-artifacts": "2.47.0"
   }
 }

package/requirements.json

@@ -2,11 +2,11 @@
   "$comment": "GENERATED by conformance/scripts/generate-requirement-registry.mjs — do not edit. One record per it()/test() in src/scenarios. Ids: openwop.it.<file-stem>.<title-slug>[~n] (src/lib/requirement-ids.ts). A record with id null has an interpolated title; its run-time row is keyed by the rendered title and maps here by file+line only. Renamed ids need a row in requirement-aliases.json.",
   "generatedFrom": "src/scenarios/*.test.ts",
   "counts": {
-    "files": 751,
-    "tests": 2888,
-    "withStableId": 2888,
+    "files": 754,
+    "tests": 2903,
+    "withStableId": 2903,
     "interpolatedTitles": 0,
-    "explicitIds": 2744
+    "explicitIds": 2747
   },
   "records": [
     {
@@ -37052,6 +37052,84 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-replay-llm-cache-key.the-effect-ledger-record-admits-cachekey-recipe-digest-and-refuses-anything-else",
+      "file": "v2-replay-llm-cache-key.test.ts",
+      "line": 102,
+      "title": "the effect-ledger record admits cacheKey {recipe, digest} and refuses anything else",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": "replay facet llmCacheKeyRecipe + effect-ledger-projection cacheKey (RFC 0260)",
+          "requirement": "a record without cacheKey MUST validate (the facet is opt-in)"
+        },
+        {
+          "section": "replay facet llmCacheKeyRecipe + effect-ledger-projection cacheKey (RFC 0260)",
+          "requirement": "cacheKey {recipe: openwop-llm-key-2, digest: 64 hex} MUST validate"
+        },
+        {
+          "section": "replay facet llmCacheKeyRecipe + effect-ledger-projection cacheKey (RFC 0260)",
+          "requirement": "an unregistered recipe MUST fail"
+        },
+        {
+          "section": "replay facet llmCacheKeyRecipe + effect-ledger-projection cacheKey (RFC 0260)",
+          "requirement": "an uppercase or short digest MUST fail"
+        },
+        {
+          "section": "replay facet llmCacheKeyRecipe + effect-ledger-projection cacheKey (RFC 0260)",
+          "requirement": "digest is REQUIRED"
+        },
+        {
+          "section": "replay facet llmCacheKeyRecipe + effect-ledger-projection cacheKey (RFC 0260)",
+          "requirement": "cacheKey is closed: a preimage member MUST fail"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-replay-llm-cache-key.a-host-advertising-replay-llmcachekeyrecipe-also-advertises-idempotency",
+      "file": "v2-replay-llm-cache-key.test.ts",
+      "line": 117,
+      "title": "a host advertising replay.llmCacheKeyRecipe also advertises idempotency",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": "replay facet llmCacheKeyRecipe + effect-ledger-projection cacheKey (RFC 0260)",
+          "requirement": "a host advertising replay.llmCacheKeyRecipe MUST advertise idempotency: the effect ledger is where the key is recorded"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-replay-llm-cache-key.the-provider-call-record-carries-cachekey-with-recipe-openwop-llm-key-2",
+      "file": "v2-replay-llm-cache-key.test.ts",
+      "line": 125,
+      "title": "the provider-call record carries cacheKey with recipe openwop-llm-key-2",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-replay-llm-cache-key.two-runs-that-differ-only-in-maxtokens-have-different-keys",
+      "file": "v2-replay-llm-cache-key.test.ts",
+      "line": 133,
+      "title": "two runs that differ only in maxTokens have different keys",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-replay-llm-cache-key.two-identical-runs-have-the-same-key",
+      "file": "v2-replay-llm-cache-key.test.ts",
+      "line": 143,
+      "title": "two identical runs have the same key",
+      "explicitId": null,
+      "citations": []
+    },
+    {
+      "id": "openwop.it.v2-replay-llm-cache-key.the-key-equals-recipe-2-recomputed-over-the-inputs-the-fixture-pins",
+      "file": "v2-replay-llm-cache-key.test.ts",
+      "line": 153,
+      "title": "the key equals recipe 2 recomputed over the inputs the fixture pins",
+      "explicitId": null,
+      "citations": []
+    },
     {
       "id": "openwop.it.v2-replay-suppression-ordinal.a-replay-fork-resolves-each-execution-of-a-looped-side-effecting-node-by-its-own",
       "file": "v2-replay-suppression-ordinal.test.ts",
@@ -38710,6 +38788,133 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-telemetry-export.the-telemetry-record-requires-otlp-protocols-from-the-closed-transports-genaisem",
+      "file": "v2-telemetry-export.test.ts",
+      "line": 102,
+      "title": "the telemetry record requires otlp.protocols from the closed transports; genAiSemconv is semver",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "a record with otlp.protocols MUST validate"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "genAiSemconv as semver MUST validate"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "otlp is REQUIRED"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "protocols MUST be non-empty"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "an unknown transport MUST fail"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "a non-semver genAiSemconv MUST fail"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-telemetry-export.a-run-exports-an-openwop-run-span-with-its-run-and-workflow-ids",
+      "file": "v2-telemetry-export.test.ts",
+      "line": 115,
+      "title": "a run exports an openwop.run span with its run and workflow ids",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "every run MUST produce a span named openwop.run carrying openwop.run_id"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "the run span MUST carry openwop.workflow_id"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-telemetry-export.each-node-execution-exports-an-openwop-node-typeid-span-with-its-node-attributes",
+      "file": "v2-telemetry-export.test.ts",
+      "line": 125,
+      "title": "each node execution exports an openwop.node.<typeId> span with its node attributes",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "every node execution MUST produce a span named openwop.node.<typeId>"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "the node span MUST carry openwop.node_id"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "the node span MUST carry openwop.node_type, and its name MUST be openwop.node.<typeId>"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "openwop.node_attempt MUST be a non-negative integer"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-telemetry-export.a-run-created-with-a-traceparent-exports-its-spans-in-that-trace",
+      "file": "v2-telemetry-export.test.ts",
+      "line": 139,
+      "title": "a run created with a traceparent exports its spans in that trace",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "a run created with a valid W3C traceparent MUST emit its spans in that trace"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-telemetry-export.no-exported-span-carries-the-resolved-store-secret",
+      "file": "v2-telemetry-export.test.ts",
+      "line": 149,
+      "title": "no exported span carries the resolved store secret",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "a span name, attribute, event or resource attribute MUST NOT carry a resolved secret"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-telemetry-export.a-host-advertising-genaisemconv-puts-the-gen-ai-attributes-on-the-model-call-spa",
+      "file": "v2-telemetry-export.test.ts",
+      "line": 167,
+      "title": "a host advertising genAiSemconv puts the gen_ai attributes on the model-call span",
+      "explicitId": null,
+      "citations": [
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "the model-call span MUST carry the provider attribute its version names"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "the model-call span MUST carry gen_ai.request.model"
+        },
+        {
+          "section": "spec/v2/core/telemetry.md (RFC 0262)",
+          "requirement": "the model-call span MUST carry input and output token usage"
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-terminal-event-once.every-run-observed-to-a-terminal-state-has-exactly-one-terminal-event-and-no-for",
       "file": "v2-terminal-event-once.test.ts",
@@ -48642,7 +48847,7 @@
     {
       "id": "openwop.it.v2-front-door-counts.every-stated-count-of-spec-v2-core-documents-equals-the-tree",
       "file": "v2-front-door-counts.test.ts",
-      "line": 51,
+      "line": 52,
       "title": "every stated count of spec/v2/core/ documents equals the tree",
       "explicitId": "openwop.requirement.front-door.core-doc-count",
       "citations": [
@@ -48656,7 +48861,7 @@
     {
       "id": "openwop.it.v2-front-door-counts.capabilities-md-5-names-as-many-core-families-as-the-declaration-declares",
       "file": "v2-front-door-counts.test.ts",
-      "line": 74,
+      "line": 75,
       "title": "capabilities.md §5 names as many core families as the declaration declares",
       "explicitId": "openwop.requirement.front-door.core-family-count",
       "citations": [
@@ -49428,6 +49633,130 @@
         }
       ]
     },
+    {
+      "id": "openwop.it.v2-sabotage-ledger.a-every-witnessable-falsifiability-row-names-an-id-or-says-planned",
+      "file": "v2-sabotage-ledger.test.ts",
+      "line": 85,
+      "title": "§A every witnessable Falsifiability row names an id or says planned",
+      "explicitId": "openwop.requirement.0263.falsifiability-names-ids",
+      "citations": [
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": null,
+          "interpolated": true
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a table naming an id, a planned row and a claims-check row MUST pass at Active"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a witnessable row with no id and no `planned` MUST fail"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "the refusal MUST name §A"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "an RFC before 0258 is not in scope"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a Draft RFC is not in scope"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "from RFC 0260 a planned row MUST block Accepted"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "the refusal MUST name the planned row"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "before RFC 0260 a planned row does not block Accepted"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-sabotage-ledger.c-an-accepted-rfc-from-0260-has-a-red-ledger-row-for-every-id-it-cites",
+      "file": "v2-sabotage-ledger.test.ts",
+      "line": 101,
+      "title": "§C an Accepted RFC from 0260 has a red ledger row for every id it cites",
+      "explicitId": "openwop.requirement.0263.sabotage-recorded-before-accepted",
+      "citations": [
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "an executed-fail row for the cited id MUST satisfy §C"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a red row on a leg under the cited id MUST satisfy §C"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "with no ledger row the flip MUST fail"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "the refusal MUST name the id"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a red row for a different id MUST NOT satisfy §C"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "§C binds the Accepted flip, not Active"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "an RFC before 0260 is not retroactively invalidated"
+        }
+      ]
+    },
+    {
+      "id": "openwop.it.v2-sabotage-ledger.b-the-ledger-records-red-runs-in-a-closed-shape-never-on-a-certified-bundle",
+      "file": "v2-sabotage-ledger.test.ts",
+      "line": 114,
+      "title": "§B the ledger records red runs, in a closed shape, never on a certified bundle",
+      "explicitId": "openwop.requirement.0263.ledger-shape",
+      "citations": [
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "well-formed rows, one with a red digest, MUST pass"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a sabotage that passed MUST fail the shape"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "the refusal MUST say why"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "an unknown member MUST fail"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a sabotage that does not say what was broken MUST fail"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a subject without a build MUST fail"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "a row naming a certified bundle's digest MUST fail — that bundle recorded the pass"
+        },
+        {
+          "section": "RFC 0263 · scripts/check-accepted-predicate.mjs rules 5 and 6",
+          "requirement": "the refusal MUST name the certified bundle"
+        }
+      ]
+    },
     {
       "id": "openwop.it.v2-seams-not-in-canonical.the-corpus-gate-script-exits-0",
       "file": "v2-seams-not-in-canonical.test.ts",

package/scenario-majors.json

@@ -1,9 +1,9 @@
 {
   "$comment": "GENERATED by conformance/scripts/generate-scenario-majors.mjs (RFC 0168 §D.3). Do not edit; add a file to BOTH_MAJORS in the generator to target both majors.",
   "counts": {
-    "files": 668,
+    "files": 670,
     "v1": 455,
-    "v2": 228
+    "v2": 230
   },
   "majors": {
     "a2a-1-0-agent-card.test.ts": [
@@ -1740,6 +1740,9 @@
     "v2-relaxation-recorded.test.ts": [
       2
     ],
+    "v2-replay-llm-cache-key.test.ts": [
+      2
+    ],
     "v2-replay-suppression-ordinal.test.ts": [
       2
     ],
@@ -1833,6 +1836,9 @@
     "v2-table-schema-enforcement.test.ts": [
       2
     ],
+    "v2-telemetry-export.test.ts": [
+      2
+    ],
     "v2-terminal-event-once.test.ts": [
       2
     ],

package/schemas/CORPUS-STAMP.json

@@ -1,17 +1,17 @@
 {
   "_comment": "Provenance of @openwop/spec-artifacts (RFC 0168 §D.2). files: SHA-256 per file; the conformance suite compares the installed peer against dist/spec-artifacts.lock.json at start.",
   "package": "@openwop/spec-artifacts",
-  "version": "2.46.44",
-  "corpusTag": "v2.46.44",
+  "version": "2.47.0",
+  "corpusTag": "v2.47.0",
   "files": {
     "api/.redocly.lint-ignore.yaml": "bf5a8350b88a72fa43f59605ed8d903ed24b6cfccda5e45509c9f6ed9ee4e712",
     "api/asyncapi.yaml": "d5ecb9ee6114582be3b1f662c84bfac9ae96dae7bacb853e461168f70a8e1c7d",
     "api/grpc/openwop.proto": "c3e72bb17cba514ee98feb6434e6c9b6ea6795bfd086489ec69fd882dd1ad977",
     "api/openapi.yaml": "ac6de5303872664b78ff419c035915593e01599e02835e777a0123de1baeb398",
     "api/redocly.yaml": "b0604c89b2ca6d5076ec25725c539dad44a741a811fe524439ee6daef8baa09f",
-    "api/seams-v2.yaml": "55b4467b4ca8278dc8c5944cc0d11e69a2a92fcc6f8608269d7cac2c77626833",
-    "api/v2/asyncapi.yaml": "bbd713d6b5e254622342e21f5a7331514d0901094d8d7daffb3ccac4e15b5558",
-    "api/v2/openapi.yaml": "d82512b61f6b7eeda8a9efeeebc987e5702f452250ad0000623c826a3e5c5aaf",
+    "api/seams-v2.yaml": "dffb86d9287e72ee6261bd830b6920068ac78c1a0947f8d5087b47ecc19f11e5",
+    "api/v2/asyncapi.yaml": "7a8c4937c9b4f8387cc8d7cd6a5b890449b751ac2254b991f3434774798452d9",
+    "api/v2/openapi.yaml": "0c3ba86687c60e7b65add574b011c306c1ad132e1cc371c954ac1190c1f3781e",
     "api/v2/redocly.yaml": "1e66b60e6118ad11a823bb620678be464d99dfe50a40e3e6f93ec9429b88b34c",
     "schemas/README.md": "276fc1d51eb08e14e9127b9fd27761d7046ee33c12000f3a64a801322db8bf58",
     "schemas/a2a-task-state.schema.json": "75d5049dea8bd873ff0e7546f1c60c8d36c219bec7084264360be54a8be30ae1",
@@ -115,8 +115,8 @@
     "schemas/v2/artifact.schema.json": "85b9dc284d39b99d2a66fa8cbf47f2dd3d8526d3bd6cc411ad315b372de38975",
     "schemas/v2/audit-verify-result.schema.json": "14af8e9283510f0a40e48a2059c929ee44e0fc9fa3cc66a95bfbe90b17c48297",
     "schemas/v2/budget-policy.schema.json": "1de68095db0beb5c7a4be629de26e79f62ebbe748a88d46f36e768edfd1f0d68",
-    "schemas/v2/capabilities.schema.json": "c912974988bb56d3d1457cbbd09ff4ffe64533ca7de0953efa5a1d8144ac0b43",
-    "schemas/v2/certification-bundle.schema.json": "29d2ff33d8256d8729cd4914e2ecff5ff07afc310264e2db483a9c0ae13df2a6",
+    "schemas/v2/capabilities.schema.json": "609aa5998cafb549badbae7a6d94100ee32d130ade03dc6dfa40005f40154ac1",
+    "schemas/v2/certification-bundle.schema.json": "29d0be495dfaa2265f30394de92a96ca95058f1a89f663ece97c67ea6fae94c0",
     "schemas/v2/channel-presence-payload.schema.json": "fc03df0c20cc12a25f7ee6a47503a4c5931d79fe3d5ff24815e8fd7c1bcb9a87",
     "schemas/v2/channel-written-payload.schema.json": "ccecff3c71a3275ad8db035ac0e04db25e6f8d23cf091ddbcd5a60d1be1cbb6b",
     "schemas/v2/chat-card-pack-manifest.schema.json": "9cf235f5d0fe662f34f7e72bfbf2a82e0743046059a9d5af7aec948e228fdb0e",
@@ -132,7 +132,7 @@
     "schemas/v2/credential-reference.schema.json": "ea699ce30f58fb2c32d4279158b3f730f70be7b2dc8c3037693a76e66eb3e001",
     "schemas/v2/debug-bundle.schema.json": "0ec1e0bca9c0a359cc6cf3448e5200a1c3d3d5b1e5efaa6605231477daaf3fee",
     "schemas/v2/dispatch-config.schema.json": "27cb203d2a5cec90d8eb398569acbd8314ad9b8e231d1acfb8db4aa76f8d8f8b",
-    "schemas/v2/effect-ledger-projection.schema.json": "0d118d385a43921118a76888449c5c3c5618eab1b80914b84a0a1b48d18822c1",
+    "schemas/v2/effect-ledger-projection.schema.json": "ac1f577ec420ece9a5fbe74a33a54aa5bbe4d8259f3c5e9c2bd9b8901ed1c289",
     "schemas/v2/effect-seam-manifest.schema.json": "197ef9944ab027a50d1b9352f317cbbc12c8ad955fdb14650fb90477052ffef0",
     "schemas/v2/error-envelope.schema.json": "5d566a910b715452e99b32876426cd490ef803f2177e3ecbbd1051170d4d4462",
     "schemas/v2/eval-summary.schema.json": "d07f4d116c5410997a81d0bc5387545fb61933a6333c360a26ab8a71c749336b",
@@ -203,14 +203,14 @@
     "schemas/workspace-file.schema.json": "464de85c2a068243084ee9c1d969bc7cd5d8f7948574e58450d6493c38a0e1e4",
     "spec/v1/alias-detectors.json": "202a443678e592a515e33aad7f6ab679a07d8408809f2d4b0f59d156c84ffc65",
     "spec/v1/capability-declaration-classes.json": "e7729aed5c4b4e1dd02abab0530f14cc95f5d4070fe51fb139e7f5cccefa00c6",
-    "spec/v1/core-standard-manifest.json": "561a3f85b9d00c3f2d6031428b2ca28e95805ed18eb3b069c6c983da62e8f6cc",
+    "spec/v1/core-standard-manifest.json": "9c3d53b164244ae9f238d5047681e01701c0df244172489a50509e62265514bc",
     "spec/v1/deprecations.json": "901fdab0a7212627f1838cbb06ae7b7204f0dff528299e56d3d938deecea27c1",
     "spec/v1/deprecations.schema.json": "3e393c405d2a41b467d8c5e3c468549078df1ce6a6d2588fc488097b95d9b55b",
     "spec/v1/end-of-support.json": "35f0bf3b70fe78b16e2a2fd81a153fc27e703f6c16376c6fe7cdf1f4f2c4e6d4",
     "spec/v1/event-codemap.json": "3da60d884157793a360da532a9fcbbfb5285636db325a74cec94b34622186d97",
     "spec/v1/event-codemap.schema.json": "d05933b2e88103aff51a2f774df97b9bda065e0fc88dbd9b114cc47a32189174",
     "spec/v1/extensions.json": "79a60754aa16cbdbdb604f8e5c00038af535a1690a4d07bd5ff7c38f0256a7bc",
-    "spec/v1/gaps.json": "871b4b7f12412609c65df1dee40af4cea9dc46996480a157d7863337572d1cb2",
+    "spec/v1/gaps.json": "08579ba52f384764f8b5849ee7d0bc97a0cb49318f6c6ccd0561707ab5f3be80",
     "spec/v1/gaps.schema.json": "8fd83259f556553c9df0f53e7a82ca8c2a4771d471197f69b4e2ae0ceeacfd66",
     "spec/v1/migrations.json": "4c50760be70cb644d02427bcaf5749606700edf4513f423903cf3b1d12f5c300",
     "spec/v1/migrations.schema.json": "886779aa6c22e646db097f5df210adb018a4dd14a7b815465a18c8a7056c8f72",
@@ -218,7 +218,7 @@
     "spec/v1/spec-gaps.json": "ea9612af55bea9dae3e82223d4f714243f8f590b0193f1188257b13491a38afc",
     "spec/v2/README.md": "c58acd84bb67c69043d9f777cbaa16d03e4f0f0a8158d2984526b69981067a14",
     "spec/v2/core/artifact-type-packs.md": "ba5a258ac93b1aa4d74a4464c63a8f72dbbc5d24fd56f34a2c2ce9f464892799",
-    "spec/v2/core/capabilities.md": "316dc256259968e74f24a5529015ad7b78d5866b914aa0c108cb8e7abb724d4d",
+    "spec/v2/core/capabilities.md": "7ab4c1ab5b0b0a95a5e35ff2db9b45c5fb6bf23844c97ffeed6d6ebda3d17c7e",
     "spec/v2/core/conformance.md": "2e12b5fceb9cbd1bbf4a536310fe92a4cd44947e48d0466013327c5de202a2d9",
     "spec/v2/core/connection-packs.md": "c80f95bd6a03698f35c72cdb2b46bd973f49203bbd786c26760e35fa86e6f23d",
     "spec/v2/core/conversation.md": "8d6abedf6af408a74577753bfca24719d318e2632e10b45ff5d63bdcf31a8aaa",
@@ -239,17 +239,18 @@
     "spec/v2/core/packs.md": "c46a3bbd8a3a8cfbb6476b88f90d234a45f724aa1f640c9ce6430ba05bacb069",
     "spec/v2/core/persistence.md": "d1767bde0db8038bf6c4f8dc31c4900c67dbd77b4ccc382e99b9f29501b472a3",
     "spec/v2/core/portability.md": "93b9cb8bb85448669df716effb7627236b2bb069f8c5ca7306e8971b9355abfd",
-    "spec/v2/core/replay.md": "cf992b8c7f646a79bd0bdd39451cc9d015f7150a3c342c312b2a89d95abe49de",
+    "spec/v2/core/replay.md": "de705ad72e4878def9a0e1d215df9020c129eabae5f224b8c9b3330bd3b48c47",
     "spec/v2/core/runs.md": "f9c26490e52fa69a10c8e98c8a489e3bc8dfbe3effe334bb1793bc9b575f5efe",
     "spec/v2/core/security-defaults.md": "18c9956cae51c3da1def80ce94741ad1fd664a8150701160c6cd0ef367c79749",
     "spec/v2/core/storage.md": "bfcc74526d0f24539188b1c5d1567d8510e80d0b6c39fdc4d19204fcd6fd1f85",
+    "spec/v2/core/telemetry.md": "5e2f30919c51195b57566a2a277663e72dffd1a56a68c19fb8b0d3260629ff7f",
     "spec/v2/core/tool-catalog.md": "d16a9004418719c48301804aefa4d7ab6f41112a4ed83727f552aa1b92b418b0",
     "spec/v2/core/versioning.md": "f25c64849e9fa7e3ddc976f33c502bbf0e3fdd158c5c2d5730d524b1f8a19bfe",
     "spec/v2/core/webhooks.md": "861284396eb4f445f4b7bec210f07dd2c96d18084f8511371235b98617bf2b90",
     "spec/v2/core/workflow-chain-packs.md": "fdce7a8477e269950a2bac05ee6eddbd66eb0b670b464d00054f7196ec05d29c",
     "spec/v2/corrections.json": "5ee76d1ee87677a86d5d9ee2f477b88fc29f9f9d37611040b9ccb08f8f30fb2d",
     "spec/v2/corrections.schema.json": "02f6a0a9531e657693be311af0f59d6432f3efcf645f56ccbf39e5b141e6b641",
-    "spec/v2/declaration.json": "3c3953f30eddf26341ed7ffab7e64bc2807e1def47d57b7e408047e28aab7c0d",
+    "spec/v2/declaration.json": "7c8da768d45866b70544fad1e26c513f1dce8657c276ffa7148127d11b744811",
     "spec/v2/declaration.schema.json": "ef951633e4070899f64828f5cf1b5f4870270a0360f81dbb49b5b4d6cd407550",
     "spec/v2/eos-override.json": "4c72d2f6a658943b01c1de1643cf294642091933af7832f38ee5495df684cb2d",
     "spec/v2/errors.json": "8b4d2ebab569b26f608323ca4c9adaf805ab515286d26532db23fcb97541787f",
@@ -282,6 +283,7 @@
     "spec/v2/facets/connections.schema.json": "f998bb206a5814183bb4720cc34fa43b7ab64d61e39a79437b009c589ce8b78e",
     "spec/v2/facets/heartbeat.schema.json": "81d7fa1895a8b0241bd07cf00a7e7905bef0fd14eb3427325261c62eee5746a6",
     "spec/v2/facets/hostEvents.schema.json": "8834c2fde7bc2ba9eb433f22c9d6ec3f9739f44049eecdbf0a05baf2bfa0bb7d",
+    "spec/v2/facets/idempotency.schema.json": "f20c1e0b08749385b443a7e65293197cfe68cb51486b29659c6af6b96179fa98",
     "spec/v2/facets/interrupt.schema.json": "e89e008a06b0a53cebfeac500c1622ca871c920fc8856b31c019689c5df41b66",
     "spec/v2/facets/limits.schema.json": "e68327665def83007f2573b413757caa602e82ad347d1b85e9853fea153ffb48",
     "spec/v2/facets/loopback.schema.json": "577a34333d1633f8ab00f11e1aeaee2708022faa69a26cf316fc5bea00ee7d50",
@@ -289,9 +291,10 @@
     "spec/v2/facets/nondeterminismPolicy.schema.json": "e9dfaa32e0778a1a837fdad3b8a0673fccda9579ab08c8bfe9777362dd15e989",
     "spec/v2/facets/oauth.schema.json": "3a0cbe249d3bd5a5982349ae7ba2534776cc958e4a57e0fbeabf2bdab6e99e69",
     "spec/v2/facets/packs.schema.json": "d544a280419c0052ce0f3c3b378f7aa04085cadc31df52a3c8f43da600b131b1",
-    "spec/v2/facets/replay.schema.json": "0a5aefb0108c708c6794fadd533cf256709704c4f16dbf44cd63fa8980c78018",
+    "spec/v2/facets/replay.schema.json": "ebb1ce04ed1e4fca237f448e565fe75c833e630320930accecba2ce4e660c8d9",
     "spec/v2/facets/runList.schema.json": "6223e1baaebbb9f4faa71bfe968f8d22b4aa88046d0e43e8d5f56409e7f86e90",
     "spec/v2/facets/sandbox.schema.json": "e75f54486d387b2d089791aa93b5093cd1450f1920753a0f97fc23acdfe978ed",
+    "spec/v2/facets/telemetry.schema.json": "56e96a26910ff1d891eabfc520c2d152fd9881449fdcea7e03df34793763849e",
     "spec/v2/facets/uiPlugins.schema.json": "1fd3f8440cfb6e4422553a7c4b5f091eb3e10a40da0d43e8b977a18929116758",
     "spec/v2/facets/webhooks.schema.json": "54b576f1d150e28e1642693d846ce471c118e9c521bdf3924185305fbd1d0de4",
     "spec/v2/facets/workflowChainPacks.schema.json": "ea625ce818fbeb746478f00f31f96ee9613d538e4409c258c1bfb517acdeaba9",
@@ -306,9 +309,9 @@
     "spec/v2/path-manifest.json": "3720e502614f301efc7556e0bfcbfa7b7ad8a37c579256ba6bca82417a2728f1",
     "spec/v2/peer-dependency-aliases.json": "cbf62f551f9295b0ac7ba6cc0466abb153563354a57b0622f3ec6e6689cba47e",
     "spec/v2/profiles.json": "b382b261c7844798575f7c1b37c934f0da19846016a2337d883d4f5ef6e05479",
-    "spec/v2/release.json": "26d4c0eb733574959b9bc9a92a5cc1674f73c63b3792241156f628709dad3a1a",
+    "spec/v2/release.json": "6082692ec2549fcb02ca33f24336e7f9f417ec4ff08a14d23fc02533d8a00527",
     "spec/v2/retention-floors.json": "eaf3722d95c79947af1d4269ef85117e126518c588cfcf1a2b21b97269f51624",
-    "spec/v2/surface-baseline.json": "fedf128175065f105c7abb1deb5173093aac64a7b0b7fda286e9697969dbbcb9"
+    "spec/v2/surface-baseline.json": "c67e5764105a35d5dc575942582b7b0784c0ad2e3739fe7b5b23de28ea58408f"
   },
-  "corpusCommit": "2111a4fb43c27c18f080355eb0b1dc2e6653bc43"
+  "corpusCommit": "aeb6ca4f976b56668c3770acd128c08ec59cfb18"
 }

package/src/lib/llm-cache-key-2.ts

@@ -0,0 +1,114 @@
+/**
+ * RFC 0260 — LLM cache key recipe 2 (`openwop-llm-key-2`). A pure function: the
+ * suite recomputes the key a host recorded and compares (§B, `0260.key-portable`).
+ *
+ *   key = hex(SHA-256(JCS({ recipe, model, provider, messages, tools, toolChoice,
+ *                           responseSchema, params })))
+ *
+ * `params` names every sampling or output-shaping parameter; one the host did not
+ * send is `null`, never omitted. `stop` is sorted (UTF-16 code-unit order, as JCS
+ * orders keys) and de-duplicated. Any other parameter sits under `params.extra`.
+ * A string message content is the one-part array `[{type: "text", text}]`. No
+ * Unicode normalisation: the bytes are as sent.
+ */
+import { createHash } from 'node:crypto';
+import { canonicalJSON, codeUnitCompare } from './jcs.js';
+
+export const RECIPE_2 = 'openwop-llm-key-2';
+
+/** The parameters recipe 2 names. A request that omits one puts `null` in the key. */
+export const NAMED_PARAMS = ['temperature', 'maxTokens', 'stop', 'seed', 'topP', 'topK', 'frequencyPenalty', 'presencePenalty'] as const;
+export type NamedParam = (typeof NAMED_PARAMS)[number];
+
+export interface KeyInputs {
+  readonly model: string;
+  readonly provider: string;
+  readonly messages: readonly { readonly role: string; readonly content: string | readonly Record<string, unknown>[] }[];
+  readonly tools?: readonly unknown[];
+  readonly toolChoice?: unknown;
+  readonly responseSchema?: unknown;
+  readonly params?: Partial<Record<NamedParam, unknown>> & { readonly extra?: Record<string, unknown> };
+}
+
+const nullIfAbsent = (v: unknown): unknown => (v === undefined ? null : v);
+
+/** The object recipe 2 hashes, before canonicalization. Exported so a failure can show what was hashed. */
+export function keyPreimage(i: KeyInputs): Record<string, unknown> {
+  const p = i.params ?? {};
+  const params: Record<string, unknown> = {};
+  for (const name of NAMED_PARAMS) params[name] = nullIfAbsent(p[name]);
+  if (Array.isArray(params['stop'])) params['stop'] = [...new Set((params['stop'] as unknown[]).map(String))].sort(codeUnitCompare);
+  if (p.extra !== undefined && Object.keys(p.extra).length > 0) params['extra'] = p.extra;
+  return {
+    recipe: RECIPE_2,
+    model: i.model,
+    provider: i.provider,
+    messages: i.messages.map((m) => ({ role: m.role, content: typeof m.content === 'string' ? [{ type: 'text', text: m.content }] : m.content })),
+    tools: i.tools ?? [],
+    toolChoice: nullIfAbsent(i.toolChoice),
+    responseSchema: nullIfAbsent(i.responseSchema),
+    params,
+  };
+}
+
+export function cacheKey2(i: KeyInputs): string {
+  return createHash('sha256').update(canonicalJSON(keyPreimage(i)), 'utf8').digest('hex');
+}
+
+/**
+ * The inputs the `conformance-llm-cache-key` fixture pins (conformance/fixtures.md
+ * §The LLM cache-key fixture): the host's conformance mock is provider
+ * `conformance-mock`, model `conformance-mock-1`; the node sends one user message,
+ * no tools, no toolChoice, no responseSchema, and exactly the parameters in the
+ * run's `inputs.request.params`.
+ */
+export const FIXTURE = 'conformance-llm-cache-key';
+export const NODE_ID = 'llm-call';
+export const FIXTURE_PROVIDER = 'conformance-mock';
+export const FIXTURE_MODEL = 'conformance-mock-1';
+export function fixtureInputs(prompt: string, params: NonNullable<KeyInputs['params']>): KeyInputs {
+  return { model: FIXTURE_MODEL, provider: FIXTURE_PROVIDER, messages: [{ role: 'user', content: prompt }], params };
+}
+
+// ── Judges. Each returns findings and asserts nothing; the scenario frames them with req(). ──
+
+export interface Finding { readonly ok: boolean; readonly message: string }
+const f = (ok: boolean, message: string): Finding => ({ ok, message });
+
+/** The `cacheKey` member of the fixture node's provider-call record on GET /runs/{runId}/effects, or undefined. */
+export interface LedgerKey { readonly recipe?: unknown; readonly digest?: unknown }
+
+export function readLedgerKey(projection: unknown, nodeId: string): LedgerKey | undefined | 'no-record' {
+  const effects = (projection as { effects?: unknown } | null)?.effects;
+  if (!Array.isArray(effects)) return 'no-record';
+  const mine = effects.filter((e) => (e as { nodeId?: unknown } | null)?.nodeId === nodeId);
+  if (mine.length === 0) return 'no-record';
+  const withKey = mine.find((e) => (e as { cacheKey?: unknown }).cacheKey !== undefined) as { cacheKey?: LedgerKey } | undefined;
+  return withKey?.cacheKey;
+}
+
+const HEX64 = /^[0-9a-f]{64}$/;
+
+export function judgeRecorded(key: LedgerKey | undefined): Finding[] {
+  return [
+    f(key !== undefined, 'the provider-call record MUST carry cacheKey when replay.llmCacheKeyRecipe is advertised'),
+    f(key?.recipe === RECIPE_2, `cacheKey.recipe MUST be "${RECIPE_2}" (got ${JSON.stringify(key?.recipe)})`),
+    f(typeof key?.digest === 'string' && HEX64.test(key.digest), `cacheKey.digest MUST be 64 lowercase hex characters (got ${JSON.stringify(key?.digest)})`),
+  ];
+}
+
+/** Two invocations that differ only in one named parameter MUST NOT share a key. */
+export function judgeParamsInKey(a: LedgerKey | undefined, b: LedgerKey | undefined): Finding[] {
+  return [f(typeof a?.digest === 'string' && typeof b?.digest === 'string' && a.digest !== b.digest, `invocations differing only in maxTokens MUST have different keys (got ${String(a?.digest)} twice)`)];
+}
+
+/** The same inputs MUST give the same key. */
+export function judgeStable(a: LedgerKey | undefined, b: LedgerKey | undefined): Finding[] {
+  return [f(typeof a?.digest === 'string' && a.digest === b?.digest, `identical invocations MUST have the same key (got ${String(a?.digest)} and ${String(b?.digest)})`)];
+}
+
+/** The host's key MUST equal the recipe computed from the inputs the fixture pins. */
+export function judgePortable(key: LedgerKey | undefined, expected: KeyInputs): Finding[] {
+  const want = cacheKey2(expected);
+  return [f(key?.digest === want, `cacheKey.digest MUST equal recipe 2 over the fixture's inputs: expected ${want}, got ${String(key?.digest)} (preimage ${canonicalJSON(keyPreimage(expected))})`)];
+}

package/src/scenarios/v2-replay-llm-cache-key.test.ts

@@ -0,0 +1,160 @@
+/**
+ * v2 — LLM cache key recipe 2 (RFC 0260; the rules are the
+ * `replay.llmCacheKeyRecipe` facet description in `spec/v2/facets/replay.schema.json`
+ * and the `cacheKey` description in `schemas/v2/effect-ledger-projection.schema.json`).
+ *
+ * Server-free (always on):
+ *   1. `0260.shape` — the effect-ledger record admits `cacheKey: {recipe, digest}`
+ *      with a closed recipe vocabulary and a 64-hex digest, and refuses anything else.
+ *
+ * Host legs, unaided through the `conformance-llm-cache-key` fixture: its node makes
+ * one `ctx.callAI` call through the host's conformance mock with the run's
+ * `inputs.request` (prompt and params) unchanged. The suite reads the call's record
+ * on `GET /runs/{runId}/effects` (idempotency.md §Witness), which is a normative
+ * observation path, so no seam is needed:
+ *   2. `0260.key-recorded`  — the record carries `cacheKey` with recipe `openwop-llm-key-2`
+ *   3. `0260.params-in-key` — runs differing only in `maxTokens` have different digests
+ *   4. `0260.key-stable`    — two identical runs have the same digest
+ *   5. `0260.key-portable`  — the digest equals recipe 2 recomputed by the suite
+ *                             (lib/llm-cache-key-2.ts) over the inputs the fixture pins
+ *
+ * Dispositions: `replay.llmCacheKeyRecipe` not advertised, `idempotency` absent, or the
+ * fixture not listed ⇒ `inapplicable`. A run that cannot be created, read or finished,
+ * or a ledger with no record for the node ⇒ `blocked`.
+ *
+ * @see RFCS/0260-llm-cache-key-recipe-2.md
+ * @see spec/v2/core/replay.md §Suppression (the cache key for LLM-calling nodes)
+ * @see conformance/fixtures.md §The LLM cache-key fixture
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, v2RefValidator } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { projectBoundId } from '../lib/bound-id.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { scaledTimeoutMs } from '../lib/polling.js';
+import {
+  RECIPE_2, FIXTURE, NODE_ID, fixtureInputs, readLedgerKey,
+  judgeRecorded, judgeParamsInKey, judgeStable, judgePortable, type Finding, type LedgerKey, type NamedParam,
+} from '../lib/llm-cache-key-2.js';
+
+const DOC = 'replay facet llmCacheKeyRecipe + effect-ledger-projection cacheKey (RFC 0260)';
+const R = (slug: string): string => `openwop.requirement.0260.${slug}`;
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+const PROMPT = 'Say ok.';
+const PARAMS_A: Partial<Record<NamedParam, unknown>> = { maxTokens: 16, temperature: 0 };
+const PARAMS_B: Partial<Record<NamedParam, unknown>> = { maxTokens: 32, temperature: 0 };
+
+type Skip = readonly ['inapplicable' | 'blocked', string];
+const isRec = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+const assertAll = (id: string, fs: readonly Finding[]): void => { for (const x of fs) expect(x.ok, req(id, DOC, x.message)).toBe(true); };
+
+let disc: Promise<Record<string, unknown> | null> | undefined;
+const discovery = (): Promise<Record<string, unknown> | null> => (disc ??= v2Discovery().catch(() => null));
+
+async function gate(): Promise<Skip | null> {
+  const doc = await discovery();
+  if (!doc) return ['blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0'];
+  const replay = doc['replay'];
+  if (!isRec(replay) || replay['llmCacheKeyRecipe'] !== RECIPE_2) return ['inapplicable', `the host does not advertise replay.llmCacheKeyRecipe "${RECIPE_2}" (absent ⇒ the RFC 0041 recipe, opt-in per RFC 0260)`];
+  if (!isRec(doc['idempotency'])) return ['inapplicable', 'the host does not advertise idempotency, so it serves no effect ledger to read the key from'];
+  if (!isFixtureAdvertised(FIXTURE)) return ['inapplicable', `the host does not advertise fixture ${FIXTURE}`];
+  return null;
+}
+
+async function terminal(runId: string): Promise<string | null> {
+  const deadline = Date.now() + scaledTimeoutMs(30_000);
+  for (;;) {
+    const snap = await http(() => driver.get(`/runs/${projectBoundId(runId)}`));
+    const status = String((snap?.json as { status?: unknown } | undefined)?.status ?? '');
+    if (TERMINAL.has(status)) return status;
+    if (Date.now() > deadline) return null;
+    await new Promise((r) => setTimeout(r, 250));
+  }
+}
+
+/** One fixture run with these params, and the key its provider-call record carries. Asserts nothing. */
+async function keyed(params: Partial<Record<NamedParam, unknown>>): Promise<{ skip: Skip } | { key: LedgerKey | undefined }> {
+  const created = await http(() => driver.post('/runs', { workflowId: FIXTURE, inputs: { request: { prompt: PROMPT, params } } }));
+  const runId = (created?.json as { runId?: unknown } | undefined)?.runId;
+  if (created === null || created.status !== 201 || typeof runId !== 'string') return { skip: ['blocked', `POST /runs {workflowId: ${FIXTURE}} answered ${created?.status ?? 'nothing'} ${readErrorCode(created?.json) ?? ''}`.trim()] };
+  const status = await terminal(runId);
+  if (status !== 'completed') return { skip: ['blocked', `the ${FIXTURE} run ended ${status ?? 'not at all within the timeout'}, so its provider call is not on record`] };
+  const ledger = await http(() => driver.get(`/runs/${projectBoundId(runId)}/effects`));
+  if (ledger === null || ledger.status !== 200) return { skip: ['blocked', `GET /runs/{runId}/effects answered ${ledger?.status ?? 'nothing'} — idempotency.md §Witness owns that contract`] };
+  const key = readLedgerKey(ledger.json, NODE_ID);
+  if (key === 'no-record') return { skip: ['blocked', `the effect ledger has no record for node ${NODE_ID}: the host did not record the provider call as an effect (idempotency.md §Composition)`] };
+  return { key };
+}
+
+const memo = new Map<string, ReturnType<typeof keyed>>();
+const once = (name: 'a' | 'a2' | 'b'): ReturnType<typeof keyed> => {
+  let p = memo.get(name);
+  if (!p) { p = keyed(name === 'b' ? PARAMS_B : PARAMS_A); memo.set(name, p); }
+  return p;
+};
+
+describe('v2 RFC 0260 — cacheKey wire shape (server-free)', () => {
+  it('the effect-ledger record admits cacheKey {recipe, digest} and refuses anything else', () => {
+    const v = v2RefValidator('effect-ledger-projection.schema.json');
+    const base = { effectId: 'acme/0123456789abcdef', nodeId: 'llm-call', attempt: 1, keying: 'activity-recipe', state: 'completed', at: '2026-11-13T00:00:00Z' };
+    const doc = (rec: Record<string, unknown>) => ({ runId: 'acme/0123456789abcdef', effects: [rec] });
+    const digest = 'f1714d7aa2abf5994dd375f66aac14514b1c2439f203a6171dc6053c59f54402';
+    expect(v(doc(base)).ok, req(R('shape'), DOC, 'a record without cacheKey MUST validate (the facet is opt-in)')).toBe(true);
+    expect(v(doc({ ...base, cacheKey: { recipe: RECIPE_2, digest } })).ok, req(R('shape'), DOC, 'cacheKey {recipe: openwop-llm-key-2, digest: 64 hex} MUST validate')).toBe(true);
+    expect(v(doc({ ...base, cacheKey: { recipe: 'spec-rfc-0041', digest } })).ok, req(R('shape'), DOC, 'an unregistered recipe MUST fail')).toBe(false);
+    expect(v(doc({ ...base, cacheKey: { recipe: RECIPE_2, digest: digest.toUpperCase() } })).ok, req(R('shape'), DOC, 'an uppercase or short digest MUST fail')).toBe(false);
+    expect(v(doc({ ...base, cacheKey: { recipe: RECIPE_2 } })).ok, req(R('shape'), DOC, 'digest is REQUIRED')).toBe(false);
+    expect(v(doc({ ...base, cacheKey: { recipe: RECIPE_2, digest, preimage: '{}' } })).ok, req(R('shape'), DOC, 'cacheKey is closed: a preimage member MUST fail')).toBe(false);
+  });
+});
+
+describe('v2 RFC 0260 — recipe 2 on the effect ledger (host)', () => {
+  it('a host advertising replay.llmCacheKeyRecipe also advertises idempotency', async () => {
+    const doc = await discovery();
+    if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 JSON under OpenWOP-Version: 2.0');
+    const replay = doc['replay'];
+    if (!isRec(replay) || replay['llmCacheKeyRecipe'] === undefined) return softSkip('inapplicable', 'the host does not advertise replay.llmCacheKeyRecipe');
+    expect(isRec(doc['idempotency']), req(R('implies-idempotency'), DOC, 'a host advertising replay.llmCacheKeyRecipe MUST advertise idempotency: the effect ledger is where the key is recorded')).toBe(true);
+  });
+
+  it('the provider-call record carries cacheKey with recipe openwop-llm-key-2', async () => {
+    const g = await gate();
+    if (g) return softSkip(...g);
+    const a = await once('a');
+    if ('skip' in a) return softSkip(...a.skip);
+    assertAll(R('key-recorded'), judgeRecorded(a.key));
+  }, 120_000);
+
+  it('two runs that differ only in maxTokens have different keys', async () => {
+    const g = await gate();
+    if (g) return softSkip(...g);
+    const a = await once('a');
+    if ('skip' in a) return softSkip(...a.skip);
+    const b = await once('b');
+    if ('skip' in b) return softSkip(...b.skip);
+    assertAll(R('params-in-key'), judgeParamsInKey(a.key, b.key));
+  }, 120_000);
+
+  it('two identical runs have the same key', async () => {
+    const g = await gate();
+    if (g) return softSkip(...g);
+    const a = await once('a');
+    if ('skip' in a) return softSkip(...a.skip);
+    const a2 = await once('a2');
+    if ('skip' in a2) return softSkip(...a2.skip);
+    assertAll(R('key-stable'), judgeStable(a.key, a2.key));
+  }, 120_000);
+
+  it('the key equals recipe 2 recomputed over the inputs the fixture pins', async () => {
+    const g = await gate();
+    if (g) return softSkip(...g);
+    const a = await once('a');
+    if ('skip' in a) return softSkip(...a.skip);
+    assertAll(R('key-portable'), judgePortable(a.key, fixtureInputs(PROMPT, PARAMS_A)));
+  }, 120_000);
+});

package/src/scenarios/v2-telemetry-export.test.ts

@@ -0,0 +1,181 @@
+/**
+ * v2 — the `telemetry` family: a host exports OTLP traces (RFC 0262; the rules
+ * are `spec/v2/core/telemetry.md`, the facets `spec/v2/facets/telemetry.schema.json`).
+ *
+ * Server-free (always on):
+ *   1. `0262.shape` — the generated `telemetry` record requires `otlp` with a
+ *      non-empty `protocols` from the closed transport vocabulary; the optional
+ *      `genAiSemconv` is a semver string.
+ *
+ * Host legs — gated on the `telemetry` family record AND on the suite's OTLP
+ * collector (`OPENWOP_OTEL_COLLECTOR=true`, the host's exporter pointed at it
+ * with `OTEL_EXPORTER_OTLP_ENDPOINT`). The host calls the suite, so a host in
+ * another network namespace records `blocked`, not a failure.
+ *   2. `0262.run-span` — a `conformance-noop` run exports an `openwop.run` span
+ *      carrying its `openwop.run_id` and `openwop.workflow_id`.
+ *   3. `0262.node-span` — the same run exports an `openwop.node.<typeId>` span
+ *      carrying `openwop.node_id`, `openwop.node_type` and a non-negative
+ *      `openwop.node_attempt`.
+ *   4. `0262.traceparent-continued` — a run created with a suite-minted
+ *      `traceparent` exports its spans under that `traceId`.
+ *   5. `0262.no-secret-in-spans` — after an `openwop-smoke-byok-roundtrip` run,
+ *      no captured span name, attribute or resource attribute carries the store
+ *      canary (digest detector, plus the plaintext when the operator supplies
+ *      `OPENWOP_CANARY_SECRET_VALUE`; `lib/secret-scan.ts`).
+ *   6. `0262.gen-ai-attributes` — gated on `telemetry.genAiSemconv` and the
+ *      `conformance-callai-attempt-accounting` fixture: the model-call span
+ *      carries `gen_ai.operation.name`, a provider attribute, `gen_ai.request.model`
+ *      and both usage-token attributes.
+ *
+ * A host leg whose run exported NO span records `blocked`: an empty export is
+ * not a pass, so a host that advertises the family and exports nothing cannot
+ * certify (RFC 0262 R2).
+ *
+ * @see RFCS/0262-telemetry-family.md
+ * @see spec/v2/core/telemetry.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { familyAdvertised, v2Discovery, v2RefValidator } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { getCollector, waitForRunSpans, type CapturedSpan } from '../lib/otel-collector.js';
+import { digestDetector, findSecretDigest, leaks, valueDetector, type SecretDetector, type Surface } from '../lib/secret-scan.js';
+
+/**
+ * Callback-shaped: the host exports OTLP to the suite's collector.
+ * Unwitnessable when the host is in a separate network namespace — see
+ * `../lib/host-callback.ts`. Not host non-conformance.
+ */
+export const REQUIRES_HOST_CALLBACK = "the host exports OTLP traces to the suite's collector";
+
+const DOC = 'spec/v2/core/telemetry.md (RFC 0262)';
+const R = (slug: string): string => `openwop.requirement.0262.${slug}`;
+const NOOP = 'conformance-noop';
+const BYOK = 'openwop-smoke-byok-roundtrip';
+const CALLAI = 'conformance-callai-attempt-accounting';
+
+type Skip = { skip: ['inapplicable' | 'blocked', string] };
+const skipped = (s: Skip): undefined => softSkip(s.skip[0], s.skip[1]);
+const isRec = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+
+/** The family record, or why the host legs do not bind. */
+async function gate(fixture: string): Promise<Skip | { record: Record<string, unknown> }> {
+  if (!(await v2Discovery())) return { skip: ['blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 under OpenWOP-Version: 2.0'] };
+  const record = await familyAdvertised('telemetry');
+  if (record === null) return { skip: ['inapplicable', 'the telemetry family is not advertised — no export claim'] };
+  if (!getCollector()) return { skip: ['blocked', 'the suite OTLP collector is not running (set OPENWOP_OTEL_COLLECTOR=true and point the host exporter at it)'] };
+  if (!isFixtureAdvertised(fixture)) return { skip: ['inapplicable', `fixture ${fixture} is not advertised`] };
+  return { record };
+}
+
+/** Start a run, wait for it to settle, then wait for its exported spans. */
+async function exportedRun(body: Record<string, unknown>, headers?: Record<string, string>): Promise<Skip | { runId: string; created: OpenWOPResponse; spans: readonly CapturedSpan[] }> {
+  const created = await http(() => driver.post('/runs', body, headers ? { headers } : {}));
+  const runId = isRec(created?.json) ? created.json['runId'] : undefined;
+  if (created === null || created.status !== 201 || typeof runId !== 'string') return { skip: ['blocked', `POST /runs (${String(body['workflowId'])}) answered ${created?.status ?? 'nothing'} ${readErrorCode(created?.json) ?? ''}`.trim()] };
+  try { await pollUntilTerminal(runId, { timeoutMs: 20_000 }); } catch { return { skip: ['blocked', `run ${runId} did not settle within 20 s`] }; }
+  const spans = await waitForRunSpans(runId, { timeoutMs: 8_000, minCount: 2 });
+  if (spans.length === 0) return { skip: ['blocked', `the collector captured no span carrying openwop.run_id ${runId} — the host advertised telemetry but nothing arrived (an empty export is not a pass)`] };
+  return { runId, created, spans };
+}
+
+let noopRun: ReturnType<typeof exportedRun> | undefined;
+const noop = (): ReturnType<typeof exportedRun> => {
+  if (!noopRun) { getCollector()?.reset(); noopRun = exportedRun({ workflowId: NOOP }); }
+  return noopRun;
+};
+
+function spanSurfaces(spans: readonly CapturedSpan[]): Surface[] {
+  return spans.map((s) => ({
+    name: `span ${s.name}`,
+    text: JSON.stringify({ name: s.name, attributes: Object.fromEntries(s.attributes), resource: Object.fromEntries(s.resourceAttributes) }),
+  }));
+}
+
+describe('v2 RFC 0262 — telemetry facet shape (server-free)', () => {
+  it('the telemetry record requires otlp.protocols from the closed transports; genAiSemconv is semver', () => {
+    const v = v2RefValidator('capabilities.schema.json#/properties/telemetry');
+    const base = { status: 'experimental', since: '2.0', witness: 'witnessable-gated' };
+    expect(v({ ...base, otlp: { protocols: ['http/protobuf'] } }).ok, req(R('shape'), DOC, 'a record with otlp.protocols MUST validate')).toBe(true);
+    expect(v({ ...base, otlp: { protocols: ['grpc', 'http/json'] }, genAiSemconv: '1.37.0' }).ok, req(R('shape'), DOC, 'genAiSemconv as semver MUST validate')).toBe(true);
+    expect(v({ ...base }).ok, req(R('shape'), DOC, 'otlp is REQUIRED')).toBe(false);
+    expect(v({ ...base, otlp: { protocols: [] } }).ok, req(R('shape'), DOC, 'protocols MUST be non-empty')).toBe(false);
+    expect(v({ ...base, otlp: { protocols: ['zipkin'] } }).ok, req(R('shape'), DOC, 'an unknown transport MUST fail')).toBe(false);
+    expect(v({ ...base, otlp: { protocols: ['grpc'] }, genAiSemconv: 'latest' }).ok, req(R('shape'), DOC, 'a non-semver genAiSemconv MUST fail')).toBe(false);
+  });
+});
+
+describe('v2 RFC 0262 — OTLP export (host, telemetry-gated)', () => {
+  it('a run exports an openwop.run span with its run and workflow ids', async () => {
+    const g = await gate(NOOP);
+    if ('skip' in g) return skipped(g);
+    const r = await noop();
+    if ('skip' in r) return skipped(r);
+    const run = r.spans.find((s) => s.name === 'openwop.run' || s.name.startsWith('openwop.run.'));
+    expect(run, req(R('run-span'), DOC, 'every run MUST produce a span named openwop.run carrying openwop.run_id')).toBeDefined();
+    expect(run?.attributes.get('openwop.workflow_id'), req(R('run-span'), DOC, 'the run span MUST carry openwop.workflow_id')).toBe(NOOP);
+  });
+
+  it('each node execution exports an openwop.node.<typeId> span with its node attributes', async () => {
+    const g = await gate(NOOP);
+    if ('skip' in g) return skipped(g);
+    const r = await noop();
+    if ('skip' in r) return skipped(r);
+    const node = r.spans.find((s) => s.name.startsWith('openwop.node.'));
+    expect(node, req(R('node-span'), DOC, 'every node execution MUST produce a span named openwop.node.<typeId>')).toBeDefined();
+    expect(typeof node?.attributes.get('openwop.node_id'), req(R('node-span'), DOC, 'the node span MUST carry openwop.node_id')).toBe('string');
+    const type = node?.attributes.get('openwop.node_type');
+    expect(typeof type === 'string' && node?.name === `openwop.node.${type}`, req(R('node-span'), DOC, 'the node span MUST carry openwop.node_type, and its name MUST be openwop.node.<typeId>')).toBe(true);
+    const attempt = node?.attributes.get('openwop.node_attempt');
+    expect(typeof attempt === 'number' && Number.isInteger(attempt) && attempt >= 0, req(R('node-span'), DOC, 'openwop.node_attempt MUST be a non-negative integer')).toBe(true);
+  });
+
+  it('a run created with a traceparent exports its spans in that trace', async () => {
+    const g = await gate(NOOP);
+    if ('skip' in g) return skipped(g);
+    const traceId = '0af7651916cd43dd8448eb211c80319c';
+    const r = await exportedRun({ workflowId: NOOP }, { traceparent: `00-${traceId}-b7ad6b7169203331-01` });
+    if ('skip' in r) return skipped(r);
+    const inTrace = r.spans.filter((s) => s.traceId.toLowerCase() === traceId);
+    expect(inTrace.length, req(R('traceparent-continued'), DOC, 'a run created with a valid W3C traceparent MUST emit its spans in that trace')).toBe(r.spans.length);
+  });
+
+  it('no exported span carries the resolved store secret', async () => {
+    const g = await gate(BYOK);
+    if ('skip' in g) return skipped(g);
+    if (!(await familyAdvertised('secrets'))) return softSkip('inapplicable', 'the secrets family is not advertised, so the store-canary fixture binds nothing');
+    const r = await exportedRun({ workflowId: BYOK });
+    if ('skip' in r) return skipped(r);
+    const snap = await http(() => driver.get(`/runs/${encodeURIComponent(r.runId)}`));
+    const poll = await http(() => driver.get(`/runs/${encodeURIComponent(r.runId)}/events/poll?timeout=1&streamMode=debug`));
+    const detectors: SecretDetector[] = [];
+    const digest = findSecretDigest([r.created.json, snap?.json, poll?.json]);
+    if (digest !== null) detectors.push(digestDetector(digest.sha256, digest.length));
+    const operator = process.env['OPENWOP_CANARY_SECRET_VALUE'];
+    if (operator && operator.length > 0) detectors.push(valueDetector(operator));
+    if (detectors.length === 0) return softSkip('inapplicable', 'the run surfaced no {secretSha256, secretLength} and OPENWOP_CANARY_SECRET_VALUE is unset — nothing can be recognised as the canary');
+    const found = leaks(spanSurfaces(r.spans), detectors);
+    expect(found, req(R('no-secret-in-spans'), DOC, 'a span name, attribute, event or resource attribute MUST NOT carry a resolved secret')).toEqual([]);
+  });
+
+  it('a host advertising genAiSemconv puts the gen_ai attributes on the model-call span', async () => {
+    const g = await gate(CALLAI);
+    if ('skip' in g) return skipped(g);
+    const version = g.record['genAiSemconv'];
+    if (typeof version !== 'string') return softSkip('inapplicable', 'telemetry.genAiSemconv is not advertised — no GenAI mapping claim');
+    const r = await exportedRun({ workflowId: CALLAI, inputs: { request: { prompt: 'conformance', maxTokens: 64 }, script: [{ kind: 'valid', outputTokens: 5 }] } });
+    if ('skip' in r) return skipped(r);
+    const call = r.spans.find((s) => s.attributes.has('gen_ai.operation.name'));
+    expect(call, req(R('gen-ai-attributes'), DOC, `with genAiSemconv ${version}, each model-call span MUST carry gen_ai.operation.name`)).toBeDefined();
+    const has = (k: string): boolean => call?.attributes.get(k) !== undefined && call?.attributes.get(k) !== null;
+    expect(has('gen_ai.provider.name') || has('gen_ai.system'), req(R('gen-ai-attributes'), DOC, 'the model-call span MUST carry the provider attribute its version names')).toBe(true);
+    expect(has('gen_ai.request.model'), req(R('gen-ai-attributes'), DOC, 'the model-call span MUST carry gen_ai.request.model')).toBe(true);
+    expect(has('gen_ai.usage.input_tokens') && has('gen_ai.usage.output_tokens'), req(R('gen-ai-attributes'), DOC, 'the model-call span MUST carry input and output token usage')).toBe(true);
+  });
+});