@openwop/openwop-conformance 1.106.1 → 1.124.0

package/src/scenarios/profile-discovery-core-alias.test.ts

@@ -0,0 +1,137 @@
+/**
+ * RFC 0155 §A — `openwop-discovery-core` is the canonical name of the discovery
+ * predicate; `openwop-core` is its deprecated alias for all of v1 and MUST derive
+ * exactly when the canonical name derives.
+ *
+ * Why a scenario for a rename: the predicate is a discovery-payload check and
+ * says nothing about whether a run can be started, suspended, or replayed. A
+ * published certification bundle claimed `openwop-core` while failing six
+ * `interrupt-*` scenarios (RFC 0155 §A's motivating defect) — possible only
+ * because the name did not say what it measured. The rename makes the claim
+ * vocabulary unambiguous; this file makes the alias rule checkable:
+ *
+ *   - both names are in the closed catalog;
+ *   - for ANY payload, the alias derives iff the canonical name derives, and
+ *     `deriveProfiles` emits both or neither (never the alias alone);
+ *   - `profiles.md` states the rename, the alias rule, and the claim
+ *     vocabulary (an unqualified claim means `openwop-core-standard`);
+ *   - (gated) a live host's derived set contains both or neither.
+ *
+ * Server-free except the last leg. Reads `profiles.md` from `V1_DIR` when the
+ * repo layout is present; skips that leg from the published tarball.
+ *
+ * @see spec/v1/profiles.md §"openwop-discovery-core" + §"Claim vocabulary"
+ * @see RFCS/0155-core-profile-and-extension-discipline.md §A
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { driver } from '../lib/driver.js';
+import { PROFILE_NAMES, deriveProfiles, hasProfile, type DiscoveryPayload } from '../lib/profiles.js';
+import { V1_DIR } from '../lib/paths.js';
+
+const CANONICAL = 'openwop-discovery-core';
+const ALIAS = 'openwop-core';
+
+const CORE: DiscoveryPayload = {
+  protocolVersion: '1.0', // MAJOR.MINOR — RFC 0149 §C grammar, not semver
+  supportedEnvelopes: [],
+  schemaVersions: { workflow: 1 },
+  limits: { clarificationRounds: 0, schemaRounds: 0, envelopesPerTurn: 0 },
+};
+
+/** Payloads on both sides of the predicate, so the equivalence leg is not vacuous. */
+const PAYLOADS: ReadonlyArray<readonly [string, DiscoveryPayload]> = [
+  ['minimal core', CORE],
+  ['rich', { ...CORE, supportedEnvelopes: ['clarification.request'], secrets: { supported: true } }],
+  ['empty object', {}],
+  ['wrong major', { ...CORE, protocolVersion: '2.0' }],
+  ['semver not grammar', { ...CORE, protocolVersion: '1.0.0' }],
+  ['missing limits', { protocolVersion: '1.0', supportedEnvelopes: [], schemaVersions: {} }],
+  ['negative limit', { ...CORE, limits: { clarificationRounds: -1, schemaRounds: 0, envelopesPerTurn: 0 } }],
+  ['envelopes not array', { ...CORE, supportedEnvelopes: 'clarification.request' as unknown as string[] }],
+];
+
+describe('RFC 0155 §A — openwop-discovery-core is canonical, openwop-core is its deprecated alias', () => {
+  it('both names are in the closed catalog, canonical first', () => {
+    expect(PROFILE_NAMES).toContain(CANONICAL);
+    expect(PROFILE_NAMES).toContain(ALIAS);
+    expect(
+      PROFILE_NAMES.indexOf(CANONICAL),
+      'the canonical name precedes its alias so derived sets read canonical-first',
+    ).toBeLessThan(PROFILE_NAMES.indexOf(ALIAS));
+  });
+
+  it('the alias derives exactly when the canonical name derives — for payloads on both sides', () => {
+    let trueCount = 0;
+    let falseCount = 0;
+    for (const [label, c] of PAYLOADS) {
+      const canonical = hasProfile(c, CANONICAL);
+      const alias = hasProfile(c, ALIAS);
+      expect(alias, `${label}: hasProfile(alias) MUST equal hasProfile(canonical)`).toBe(canonical);
+      const derived = deriveProfiles(c);
+      expect(
+        derived.includes(ALIAS),
+        `${label}: deriveProfiles MUST emit the alias iff it emits the canonical name (never the alias alone)`,
+      ).toBe(derived.includes(CANONICAL));
+      if (canonical) trueCount++;
+      else falseCount++;
+    }
+    // Non-vacuity: an equivalence over payloads that all derive (or none do)
+    // proves nothing about the other side.
+    expect(trueCount, 'at least one payload MUST derive the predicate').toBeGreaterThan(0);
+    expect(falseCount, 'at least one payload MUST fail the predicate').toBeGreaterThan(0);
+  });
+
+  it('a derived set that carries the alias carries the canonical name immediately before it', () => {
+    const derived = deriveProfiles(CORE);
+    const i = derived.indexOf(CANONICAL);
+    expect(i).toBeGreaterThanOrEqual(0);
+    expect(derived[i + 1], 'alias rides directly beside its canonical name').toBe(ALIAS);
+  });
+});
+
+describe.skipIf(V1_DIR === null)('RFC 0155 §A — profiles.md states the rename and the claim vocabulary', () => {
+  const doc = () => readFileSync(join(V1_DIR as string, 'profiles.md'), 'utf8');
+
+  it('names the canonical profile and marks openwop-core as a deprecated alias', () => {
+    const md = doc();
+    expect(md).toMatch(/###\s+`openwop-discovery-core`\s+\(canonical\)/);
+    expect(md).toMatch(/alias `openwop-core` \(deprecated\)/);
+    expect(md, 'the alias MUST be defined as deriving exactly when the canonical name derives').toMatch(
+      /derives \*\*exactly when\*\* `openwop-discovery-core` derives/,
+    );
+  });
+
+  it('states that an unqualified conformance claim means openwop-core-standard', () => {
+    const md = doc();
+    expect(md).toMatch(/unqualified\*\* "OpenWOP conformant".*\*\*MUST\*\* mean \*\*`openwop-core-standard`\*\*/s);
+    expect(md, 'discovery-only claims MUST say openwop-discovery-core').toMatch(
+      /discovery-only\*\* claim \*\*MUST\*\* say \*\*`openwop-discovery-core`\*\*/,
+    );
+  });
+
+  it('the reference derivation lists the alias beside the canonical name, never alone', () => {
+    const md = doc();
+    const canonicalLine = md.indexOf("'openwop-discovery-core'             if openwop-discovery-core(c)");
+    const aliasLine = md.indexOf("'openwop-core'                       if openwop-discovery-core(c)");
+    expect(canonicalLine).toBeGreaterThan(0);
+    expect(aliasLine).toBeGreaterThan(canonicalLine);
+  });
+});
+
+describe.skipIf(!process.env.OPENWOP_BASE_URL)('RFC 0155 §A — a live host derives both names or neither', () => {
+  it('the discovery payload derives the alias iff it derives the canonical name', async () => {
+    const res = await driver.get('/.well-known/openwop');
+    if (res.status !== 200) return; // discovery is witnessed elsewhere; this leg is about the alias rule
+    const derived = deriveProfiles(res.json as DiscoveryPayload);
+    expect(
+      derived.includes(ALIAS),
+      driver.describe(
+        'profiles.md §"openwop-discovery-core"',
+        'the deprecated alias MUST derive exactly when the canonical name derives — a host is never `openwop-core` without being `openwop-discovery-core`',
+      ),
+    ).toBe(derived.includes(CANONICAL));
+  });
+});

package/src/scenarios/profileDerivation.test.ts

@@ -272,7 +272,8 @@ describe('profiles: deriveProfiles produces the full set', () => {
     };
     const result = deriveProfiles(rich);
     const expected: ProfileName[] = [
-      'openwop-core',
+      'openwop-discovery-core', // RFC 0155 §A canonical name
+      'openwop-core', // deprecated alias — always beside the canonical name, never alone
       'openwop-interrupts',
       'openwop-stream-sse',
       'openwop-stream-poll',

package/src/scenarios/provider-usage.test.ts

@@ -20,6 +20,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { readErrorCode } from '../lib/error-envelope.js';
 import Ajv2020 from 'ajv/dist/2020.js';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -179,8 +180,7 @@ describe('provider-usage: event presence via emit-seam + event-log query (RFC 00
       res.status,
       driver.describe('SECURITY/invariants.yaml provider-usage-no-credential-leak', 'payload with credentialRef-shaped content MUST be refused'),
     ).toBe(400);
-    const body = res.json as { error?: { code?: string } };
-    expect(body.error?.code).toBe('provider_usage_credential_leak');
+    expect(readErrorCode(res.json)).toBe('provider_usage_credential_leak');
     await resetTestSeam();
   });
 });

package/src/scenarios/rate-limit-envelope.test.ts

@@ -21,6 +21,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 
 const ALLOWED_SCOPES = new Set(['tenant', 'route', 'global', 'key']);
@@ -43,7 +44,7 @@ describe('rate-limit-envelope: 429 conforms to canonical shape', () => {
       console.warn(
         '[rate-limit-envelope] no 429 observed within burst; skipping shape assertions',
       );
-      return;
+      return softSkip('blocked', 'precondition not met — `!last || last.status !== 429` returned early (seam, prior step, or fixture unavailable)');
     }
 
     const retryAfter = last.headers.get('retry-after');

package/src/scenarios/registry-public.test.ts

@@ -26,6 +26,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto';
 
 const REGISTRY_BASE = 'https://packs.openwop.dev';
@@ -54,7 +55,7 @@ describe('registry-public: packs.openwop.dev discovery document', () => {
       console.warn(
         '[registry-public] skipped — set OPENWOP_TEST_PUBLIC_REGISTRY=true to enable',
       );
-      return;
+      return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!ENABLED` returned early');
     }
 
     const res = await get('/.well-known/openwop-registry');
@@ -90,7 +91,7 @@ describe('registry-public: packs.openwop.dev discovery document', () => {
 
 describe('registry-public: packs.openwop.dev index', () => {
   it('GET /v1/index.json returns a non-empty pack list with valid name + version shapes', async () => {
-    if (!ENABLED) return;
+    if (!ENABLED) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!ENABLED` returned early');
 
     const res = await get('/v1/index.json');
     expect(res.status).toBe(200);
@@ -119,7 +120,7 @@ describe('registry-public: spec-canonical pack manifests resolve', () => {
 
   for (const { name, version } of KNOWN_PACKS) {
     it(`GET /v1/packs/${name}/-/${version}.json returns a valid manifest`, async () => {
-      if (!ENABLED) return;
+      if (!ENABLED) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!ENABLED` returned early');
 
       const res = await get(`/v1/packs/${name}/-/${version}.json`);
       expect(res.status).toBe(200);
@@ -162,7 +163,7 @@ describe('registry-public: tarball + signature + Ed25519 verify roundtrip', () =
   }
 
   it(`tarball + sig + public key all retrievable, SRI matches, Ed25519 verifies for ${PACK_NAME}@${PACK_VERSION}`, async () => {
-    if (!ENABLED) return;
+    if (!ENABLED) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!ENABLED` returned early');
 
     // 1. Manifest (JSON).
     const manifestRes = await get(`/v1/packs/${PACK_NAME}/-/${PACK_VERSION}.json`);
@@ -213,7 +214,7 @@ describe('registry-public: tarball + signature + Ed25519 verify roundtrip', () =
     // `method=ed25519` — the simpler path. Extending to `manual` would
     // require the tarball extractor from registry/scripts/verify-
     // signatures.mjs which is intentionally out of scope here.
-    if (method !== 'ed25519') return;
+    if (method !== 'ed25519') return softSkip('blocked', 'precondition not met — `method !== \'ed25519\'` returned early (seam, prior step, or fixture unavailable)');
 
     const verified = cryptoVerify(null, tarball.bytes, publicKey, sig.bytes);
     expect(verified, `Ed25519 signature over ${PACK_NAME}@${PACK_VERSION}.tgz MUST verify against ${manifest.signing!.keyId}`)

package/src/scenarios/replay-divergence-at-refusal.test.ts

@@ -45,6 +45,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
+import { softSkip } from '../lib/soft-skip.js';
 import { driver } from '../lib/driver.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
@@ -78,12 +79,12 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: advertisement shape (R
     const d = await readDiscovery();
     if (d === null) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `d === null` returned early (seam, prior step, or fixture unavailable)');
     }
     const rd = capabilityFamily<{ executionModel?: { [k: string]: unknown; crossHostCausation?: Record<string, unknown>; replayDeterminism?: Record<string, unknown> } }>(d, 'multiAgent')?.executionModel?.replayDeterminism;
     if (rd === undefined) {
       ctx.skip(); // optional advertisement — host hasn't opted in
-      return;
+      return softSkip('blocked', 'precondition not met — `rd === undefined` returned early (seam, prior step, or fixture unavailable)');
     }
 
     expect(
@@ -180,7 +181,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
   }
 
   it('Phase 4 host MUST emit replay.divergedAtRefusal + fail with replay_diverged_at_refusal when original=valid + replay=refusal', async (ctx) => {
-    if (!(await gateOnPhase4(ctx))) return;
+    if (!(await gateOnPhase4(ctx))) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await gateOnPhase4(ctx))` returned early');
 
     const NODE_ID = 'structured-call';
     // Original program: valid envelope. Replay program (set after the
@@ -192,7 +193,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     ]);
     if (programStatus === 404) {
       ctx.skip(); // mock-AI program seam not exposed — soft-skip
-      return;
+      return softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(programStatus).toBe(200);
 
@@ -201,7 +202,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     });
     if (createRes.status === 404 || createRes.status === 422) {
       ctx.skip(); // fixture not advertised
-      return;
+      return softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(createRes.status).toBe(201);
     const sourceRunId = (createRes.json as { runId: string }).runId;
@@ -264,7 +265,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
   });
 
   it('Phase 4 host MUST emit replay.divergedAtRefusal + fail with replay_diverged_at_refusal when original=refusal + replay=valid (symmetric case)', async (ctx) => {
-    if (!(await gateOnPhase4(ctx))) return;
+    if (!(await gateOnPhase4(ctx))) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!(await gateOnPhase4(ctx))` returned early');
 
     const NODE_ID = 'structured-call';
     // Symmetric: original=refusal, replay=valid.
@@ -273,7 +274,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     ]);
     if (programStatus === 404) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `programStatus === 404` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(programStatus).toBe(200);
 
@@ -282,7 +283,7 @@ describe.skipIf(HTTP_SKIP)('replay-divergence-at-refusal: behavioral (RFC 0041
     });
     if (createRes.status === 404 || createRes.status === 422) {
       ctx.skip();
-      return;
+      return softSkip('blocked', 'precondition not met — `createRes.status === 404 || createRes.status === 422` returned early (seam, prior step, or fixture unavailable)');
     }
     expect(createRes.status).toBe(201);
     const sourceRunId = (createRes.json as { runId: string }).runId;

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

@@ -20,14 +20,19 @@
  *      portability requirement at the single-host boundary).
  *
  *   2. The emitted key is reproducible offline: locally recomputed
- *      SHA-256-over-RFC-8785-JCS over the canonical recipe MUST equal
+ *      SHA-256-over-RFC-8785-JCS over the canonical **v2** semantic request
+ *      (RFC 0150 §C, `recipe: "openwop-semantic-request-v2"`) MUST equal
  *      the host's emission. This is the load-bearing claim — without
  *      it, the recipe is private host state masquerading as a content-
  *      addressable hash.
  *
- *   3. (Negative) Permuting any non-recipe field (`max_tokens`, `stop`,
- *      `stream`, `seed`, `metadata`, `user`, request IDs, trace context)
- *      MUST NOT shift the key. This is the security boundary: hosts
+ *   3. (Negative) Permuting any transport-only field (`stream`, `metadata`,
+ *      `user`, request IDs, trace context, tenant id, timeout) MUST NOT
+ *      shift the key. (`max_tokens`/`stop`/`seed` were in this list until
+ *      suite 1.109.0; RFC 0150 §C moved them INTO the recipe because each
+ *      changes the completion — see `replay-llm-cache-key.test.ts` for the
+ *      sensitivity legs. Asserting their exclusion here was the suite
+ *      contradicting `semantic-digest-v2.test.ts` in the same package.) This is the security boundary: hosts
  *      that mix non-recipe state into the key leak that state across
  *      the cache boundary, defeating the portability claim and (via
  *      the SR-1 sibling invariant) potentially leaking BYOK plaintexts
@@ -35,7 +40,8 @@
  *
  *   4. (Gated on Phase 4 advertisement.) The host's discovery doc MUST
  *      advertise `replayDeterminism.llmCacheKeyRecipe` matching the
- *      recipe it honors — `spec-rfc-0041` for the canonical recipe,
+ *      recipe it honors — `spec-rfc-0041` for the canonical recipe (which,
+ *      since RFC 0150 §C replaced §A/§B in place, IS the v2 recipe),
  *      `x-host-<host>-<recipe-name>` for vendor variants per
  *      `host-extensions.md` §"Canonical prefixes".
  *
@@ -46,13 +52,13 @@
  *
  * @see RFCS/0041-multi-agent-replay-under-nondeterminism.md §E
  * @see SECURITY/invariants.yaml §replay-llm-cache-key-portable
- * @see spec/v1/replay.md §"LLM cache-key recipe" §A + §B + §D
+ * @see spec/v1/replay.md §"LLM cache-key recipe" §A + §B + §D (v2, RFC 0150 §C)
  * @see conformance/src/scenarios/replay-llm-cache-key.test.ts (the sibling behavioral suite)
  */
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
-import { expectedCacheKey, callCacheKeySeam as callSeam } from '../lib/llm-cache-key-recipe.js';
+import { semanticRequestDigestV2, callCacheKeySeam as callSeam } from '../lib/llm-cache-key-recipe.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
@@ -102,7 +108,7 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: intra-host reproducib
         'SECURITY/invariants.yaml §replay-llm-cache-key-portable + replay.md §B',
         'host cache key MUST be reproducible offline from the recipe alone — no host-internal state',
       ),
-    ).toBe(expectedCacheKey(input));
+    ).toBe(semanticRequestDigestV2(input));
   });
 
   it('two identical probes MUST yield byte-identical keys (intra-host determinism)', async (ctx) => {
@@ -129,7 +135,7 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: intra-host reproducib
 });
 
 describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: non-recipe-field invariance (RFC 0041 §E security boundary)', () => {
-  it('non-recipe fields (request ID, trace context, tenant ID) MUST NOT influence the cache key', async (ctx) => {
+  it('transport-only fields (request ID, trace context, tenant ID) MUST NOT influence the cache key', async (ctx) => {
     const base = {
       provider: 'openai',
       model: 'gpt-4',
@@ -146,20 +152,20 @@ describe.skipIf(HTTP_SKIP)('replay-llm-cache-key-portable: non-recipe-field inva
     // would expose tenant/request state through cache-collision behavior.
     const polluted = {
       ...base,
-      max_tokens: 1000,
-      stop: ['STOP'],
       stream: true,
-      seed: 42,
       metadata: { tenantId: 'tenant-A', traceparent: '00-deadbeef-cafe-01' },
       user: 'user-42',
       'x-request-id': 'req-abc-123',
+      tenantId: 'tenant-A',
+      timeoutMs: 30_000,
+      runId: 'run_123',
     };
     const pollutedResult = await callSeam(polluted);
     expect(
       pollutedResult.cacheKey,
       driver.describe(
         'SECURITY/invariants.yaml §replay-llm-cache-key-portable + replay.md §A',
-        'non-recipe fields (request id, trace context, tenant id) MUST NOT influence the cache key — leaking them defeats the portability invariant',
+        'transport-only fields (request id, trace context, tenant id, run id, timeout) MUST NOT influence the cache key — leaking them defeats the portability invariant',
       ),
     ).toBe(baseResult.cacheKey);
   });

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

@@ -1,30 +1,38 @@
 /**
- * LLM cache-key recipe — `replay.md §"LLM cache-key recipe"` §A + §B.
+ * LLM cache-key recipe — `replay.md §"LLM cache-key recipe"` §A + §B, at the
+ * RFC 0150 §C **v2** semantic request.
  *
- * Verifies that an OpenWOP host computes the LLM cache key per the
- * normative recipe: SHA-256 over RFC 8785 JCS-canonicalized JSON of
- * the closed set of recipe fields (`provider, model, messages, tools,
- * temperature, topP, topK, responseFormat`).
+ * Verifies that an OpenWOP host computes the LLM cache key per the normative
+ * recipe: SHA-256 over RFC 8785 JCS-canonicalized JSON of the v2 canonical
+ * object — `{ recipe: "openwop-semantic-request-v2", provider, model,
+ * request: { messages, tools?, temperature?, topP?, topK?, maxOutputTokens?,
+ * seed?, stop?, responseFormat?, safetySettings? }, providerOptions? }`.
  *
- * The single-host assertions drive the env-gated test seam at
- * `POST /v1/host/sample/test/llm-cache-key` and recompute the expected
- * key locally per the recipe, asserting equality. Non-recipe fields
- * (`max_tokens`, `stop`, `stream`, `seed`, etc.) MUST NOT influence
- * the key — per §A.
+ * **Why this file was rewritten (2026-08-16).** Until suite 1.109.0 it
+ * recomputed the expected key with the *v1* projection and asserted that
+ * `max_tokens / stop / seed` MUST NOT influence the key — while
+ * `semantic-digest-v2.test.ts`, in the same package since `730ff3de`, asserted
+ * that excluding them "is wrong … a wrong hit, not a miss". A host that
+ * implemented the current recipe (openwop-app, ADR 0549 P3) went red here for
+ * being right, and the pinned suite contradicted itself. RFC 0150 §C replaced
+ * v1 in place as a safety-fix; this file now follows it. `stream`, `metadata`,
+ * `user`, request IDs, and trace context remain excluded — they are transport
+ * or bookkeeping and cannot change the completion.
  *
- * The cross-host assertion (two hosts compute the same key) stays
- * deferred — it requires `OPENWOP_BASE_URL_B` for a second-host probe,
- * which is operator-supplied and outside this scenario file's scope.
+ * The single-host assertions drive the seam at
+ * `POST /v1/host/sample/test/llm-cache-key` (`host-sample-test-seams.md` §4)
+ * and recompute the expected key locally, asserting equality. The cross-host
+ * assertion requires `OPENWOP_BASE_URL_B` (operator-supplied).
  *
- * @see spec/v1/replay.md §"LLM cache-key recipe"
+ * @see spec/v1/replay.md §"LLM cache-key recipe" (v2), RFC 0150 §C
  */
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
-import { expectedCacheKey, callCacheKeySeam as callSeam } from '../lib/llm-cache-key-recipe.js';
+import { semanticRequestDigestV2, callCacheKeySeam as callSeam } from '../lib/llm-cache-key-recipe.js';
 
-describe('replay-llm-cache-key: SHA-256-over-JCS recipe (replay.md §B)', () => {
-  it('host cache key MUST equal locally-recomputed SHA-256 over canonical JSON', async () => {
+describe('replay-llm-cache-key: SHA-256-over-JCS recipe, v2 (replay.md §B, RFC 0150 §C)', () => {
+  it('host cache key MUST equal the locally-recomputed v2 semantic-request digest', async () => {
     const input = {
       provider: 'anthropic',
       model: 'claude-3-5-sonnet-20240620',
@@ -39,8 +47,13 @@ describe('replay-llm-cache-key: SHA-256-over-JCS recipe (replay.md §B)', () =>
     expect(result.status).toBe(200);
     expect(
       result.cacheKey,
-      driver.describe('replay.md §B', 'host cache key MUST be lowercase-hex SHA-256 of the canonical recipe JSON'),
-    ).toBe(expectedCacheKey(input));
+      driver.describe(
+        'replay.md §B (RFC 0150 §C)',
+        'host cache key MUST be lowercase-hex SHA-256 of the JCS-canonical v2 semantic request ' +
+          '(stamped `recipe: "openwop-semantic-request-v2"`); a v1 key here is a host that has ' +
+          'not adopted the safety-fix and would return wrong hits for requests differing in seed/stop/max tokens',
+      ),
+    ).toBe(semanticRequestDigestV2(input));
   });
 
   it('cache key MUST be 64 lowercase-hex characters (SHA-256 output shape)', async () => {
@@ -54,8 +67,8 @@ describe('replay-llm-cache-key: SHA-256-over-JCS recipe (replay.md §B)', () =>
   });
 });
 
-describe('replay-llm-cache-key: non-recipe fields are EXCLUDED (replay.md §A)', () => {
-  it('max_tokens / stop / stream / seed / metadata / user MUST NOT influence the cache key', async () => {
+describe('replay-llm-cache-key: transport-only fields are EXCLUDED (replay.md §A, v2)', () => {
+  it('stream / metadata / user / request ids / trace context MUST NOT influence the cache key', async () => {
     const base = {
       provider: 'openai',
       model: 'gpt-4',
@@ -65,22 +78,26 @@ describe('replay-llm-cache-key: non-recipe fields are EXCLUDED (replay.md §A)',
     const baseResult = await callSeam(base);
     if (baseResult.status === 404) return;
 
-    // All these non-recipe fields MUST NOT affect the cache key per §A.
+    // Transport / bookkeeping only. None of these can change what the model
+    // returns, so none may change the key. (`max_tokens`, `stop`, and `seed`
+    // used to be in this list — they CAN change the completion, which is why
+    // RFC 0150 §C moved them into the recipe; see the next describe.)
     const noisy = {
       ...base,
-      max_tokens: 1000,
-      stop: ['STOP'],
       stream: true,
-      seed: 42,
       metadata: { traceId: 'abcd' },
       user: 'unit-test-user',
+      'x-request-id': 'req-123',
+      traceparent: '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01',
+      tenantId: 'tenant-b',
+      timeoutMs: 30_000,
     };
     const noisyResult = await callSeam(noisy);
     expect(
       noisyResult.cacheKey,
       driver.describe(
-        'replay.md §A',
-        'cache key MUST be invariant under non-recipe field changes (max_tokens, stop, stream, seed, metadata, user)',
+        'replay.md §A (v2)',
+        'cache key MUST be invariant under transport-only fields (stream, metadata, user, request ids, trace context, tenant, timeout)',
       ),
     ).toBe(baseResult.cacheKey);
   });
@@ -103,35 +120,91 @@ describe('replay-llm-cache-key: non-recipe fields are EXCLUDED (replay.md §A)',
   });
 });
 
+describe('replay-llm-cache-key: outcome-affecting fields are INCLUDED (RFC 0150 §C — the v2 safety-fix)', () => {
+  const base = {
+    provider: 'openai',
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: 'v2-sensitivity-probe' }],
+    temperature: 0.2,
+  };
+
+  // Each of these fields changes the completion. v1 excluded them, which keyed
+  // two requests that produce DIFFERENT text to the SAME entry — a wrong hit,
+  // not a miss. A host still keying under v1 passes the exclusion leg above and
+  // fails here, which is the point: the two legs together distinguish "drops
+  // transport fields" from "drops the wrong fields".
+  it.each([
+    ['seed', { seed: 42 }, { seed: 43 }],
+    ['stop', { stop: ['STOP'] }, { stop: ['HALT'] }],
+    ['maxOutputTokens', { maxOutputTokens: 100 }, { maxOutputTokens: 1000 }],
+  ])('%s DOES change the cache key', async (_field, a, b) => {
+    const ra = await callSeam({ ...base, ...a });
+    if (ra.status === 404) return;
+    const rb = await callSeam({ ...base, ...b });
+    expect(
+      ra.cacheKey === rb.cacheKey,
+      driver.describe(
+        'replay.md §A (RFC 0150 §C)',
+        `\`${_field}\` decides the completion, so two requests differing only in it MUST NOT share a cache key — ` +
+          'sharing one returns a response the caller never asked for, deterministically',
+      ),
+    ).toBe(false);
+    // And each side MUST equal the locally-recomputed v2 digest, so a host cannot
+    // pass this leg by salting the key with something arbitrary.
+    expect(ra.cacheKey, driver.describe('replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
+      semanticRequestDigestV2({ ...base, ...a }),
+    );
+    expect(rb.cacheKey, driver.describe('replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
+      semanticRequestDigestV2({ ...base, ...b }),
+    );
+  });
+
+  it('providerOptions are carried into the key, not dropped', async () => {
+    const withOpts = { ...base, providerOptions: { 'vendor.openai.logitBias': { '50256': -100 } } };
+    const withOtherOpts = { ...base, providerOptions: { 'vendor.openai.logitBias': { '50256': 100 } } };
+    const r1 = await callSeam(withOpts);
+    if (r1.status === 404) return;
+    const r2 = await callSeam(withOtherOpts);
+    expect(
+      r1.cacheKey === r2.cacheKey,
+      driver.describe(
+        'replay.md §B step 1 (RFC 0150 §C)',
+        'an unknown provider option MUST be carried into `providerOptions` before hashing — a dropped option ' +
+          'that alters output is indistinguishable from one that was never set',
+      ),
+    ).toBe(false);
+    expect(r1.cacheKey, driver.describe('replay.md §B (v2)', 'key MUST equal the v2 digest')).toBe(
+      semanticRequestDigestV2(withOpts),
+    );
+  });
+});
+
 describe('replay-llm-cache-key: cross-host parity (replay.md §D)', () => {
   it('two hosts compute the same cache key for the same input (when OPENWOP_BASE_URL_B is configured)', async () => {
-    const otherBaseUrl = process.env.OPENWOP_BASE_URL_B;
-    if (!otherBaseUrl || otherBaseUrl.length === 0) return; // second host not configured — soft-skip
+    const otherBaseUrl = process.env['OPENWOP_BASE_URL_B'];
+    if (!otherBaseUrl) return; // operator-supplied second host not configured
     const input = {
-      provider: 'anthropic',
-      model: 'claude-3-5-sonnet-20240620',
-      messages: [
-        { role: 'system' as const, content: 'cross-host parity probe' },
-        { role: 'user' as const, content: 'compute the same key' },
-      ],
-      temperature: 0.5,
+      provider: 'openai',
+      model: 'gpt-4',
+      messages: [{ role: 'user', content: 'cross-host parity probe' }],
+      temperature: 0.3,
+      seed: 7,
     };
-    const a = await callSeam(input);
-    if (a.status === 404) return; // host A doesn't expose the seam
-    const otherApiKey = process.env.OPENWOP_API_KEY_B ?? process.env.OPENWOP_API_KEY ?? '';
-    // Issue the second probe directly via fetch since the driver is bound to
-    // OPENWOP_BASE_URL. Authorization mirrors the suite's default.
+    const resA = await callSeam(input);
+    if (resA.status === 404) return;
     const resB = await fetch(`${otherBaseUrl.replace(/\/$/, '')}/v1/host/sample/test/llm-cache-key`, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${otherApiKey}` },
+      headers: { 'content-type': 'application/json' },
       body: JSON.stringify(input),
     });
-    if (resB.status === 404) return; // host B doesn't expose the seam
-    expect(resB.status).toBe(200);
-    const b = (await resB.json()) as { cacheKey?: string };
+    if (resB.status === 404) return;
+    const jsonB = (await resB.json()) as { cacheKey?: string };
     expect(
-      a.cacheKey,
+      jsonB.cacheKey,
       driver.describe('replay.md §D', 'two compliant hosts MUST compute byte-identical cache keys for the same recipe input'),
-    ).toBe(b.cacheKey);
+    ).toBe(resA.cacheKey);
+    expect(resA.cacheKey, driver.describe('replay.md §B (v2)', 'and both MUST equal the v2 digest')).toBe(
+      semanticRequestDigestV2(input),
+    );
   });
 });