@openwop/openwop-conformance 2.40.2 → 2.41.0

package/src/scenarios/context-budget-transcript-bound.test.ts

@@ -16,18 +16,32 @@
  * summarizedRanges }`. The seam is OPTIONAL — the scenario soft-skips on
  * `404`/`405` (the RFC defers reference-host implementation).
  *
- * Asserts, for each iteration the host reports:
+ * Asserts, for each iteration the host reports (the rules live in the pure
+ * checker `lib/context-budget.ts`, whose sabotage cases are self-tests):
  *   1. `tokenCounter` equals the advertised `contextBudget.tokenCounter`.
  *   2. `tokenCount ≤ transcriptTokenBudget` (the per-turn bound).
- *   3. CROSS-CHECK — the harness independently reads the events named in
- *      `eventIds` from the run event-log (`/v1/host/sample/test/runs/:runId/events`)
- *      and confirms every named id is a real persisted event of the run, so the
- *      host's reported accounting is internally consistent (not fabricated).
- *   4. RECENT-TAIL — `eventIds` are a contiguous most-recent suffix of the run's
- *      eligible event-log entries (no older event included while a newer eligible
- *      one is dropped).
- *   5. SUMMARIZED-RANGE — every `summarizedRanges[].summaryRef` has a matching
- *      `context.summarized` event in the run event-log.
+ *   3. RECOUNT (RFC 0111 (b), corrected 2026-09-26) — for `tokenCounter:
+ *      "chars"` the seam MUST return `entries[] { eventId, rendered }` and the
+ *      suite sums the rendered text's code points itself; the sum MUST equal
+ *      `tokenCount`. Other units are advertise-and-attest.
+ *   4. REAL EVENTS — every `eventIds` / `entries[]` id is an event of the run;
+ *      the verbatim entries are `eventIds` in order.
+ *   5. RECENT TAIL — fed events are in log order, none at or after the
+ *      iteration's own `runOrchestrator.decided`, and no eligible event (same
+ *      `(type, nodeId)`) newer than the oldest fed one was dropped.
+ *   6. SUMMARIZED-RANGE — every `summaryRef` has a `context.summarized` event.
+ *   7. PRESSURE — at least one iteration shows the budget acting (an older
+ *      eligible event evicted, or a summarized range). Without it the row
+ *      records `partial-witness:` — a budget of 10^9 is not a witness.
+ *
+ * Both majors (2.41.0). Major 1 gates through `behaviorGate`; major 2 reads the
+ * `multiAgent` record's presence and records `inapplicable` when
+ * `contextBudget` is absent — never a strict-mode failure for a host that does
+ * not claim the capability. The seam is in the seams profile at major 2.
+ * Gated on the LIVE fixture `conformance-context-budget-live` (no mock
+ * decisions): the scripted `conformance-context-budget-multiturn` drives the
+ * supervisor through `mockDecisions`, which is exactly the mock RFC 0111
+ * §Scope forbids from advertising `contextBudget`.
  *
  * Honest non-vacuity ceiling (RFC 0111 §"Conformance seam"): the model-facing
  * prompt is genuinely host-internal, so this proves the host's DECLARED
@@ -47,209 +61,97 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { queryTestEvents } from '../lib/event-log-query.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, seamAbsent } from '../lib/soft-skip.js';
+import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
+import { familyAdvertised, v2Discovery } from '../lib/v2.js';
+import { runsPath } from '../lib/memoryAttribution.js';
+import { checkTranscriptWindow, parseTranscriptWindow, type LogEvent, type TranscriptWindow } from '../lib/context-budget.js';
 
-const FIXTURE = 'conformance-context-budget-multiturn';
+const FIXTURE = 'conformance-context-budget-live';
 const PROFILE = 'openwop-context-budget';
 const MAX_ITERATIONS_PROBED = 16;
+const ID = 'openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi';
 
-interface SummarizationCap {
-  readonly supported?: boolean;
-  readonly strategy?: string;
-  readonly keepLastTurns?: number;
-}
-interface ContextBudgetCap {
-  readonly transcriptTokenBudget?: number;
-  readonly tokenCounter?: string;
-  readonly summarization?: SummarizationCap;
-}
-interface ExecutionModelCap {
-  readonly contextBudget?: ContextBudgetCap;
-}
-interface MultiAgentCap {
-  readonly executionModel?: ExecutionModelCap;
-}
-
-// ── cast-free typed accessors (no `as`) ──────────────────────────────────
 function isRecord(v: unknown): v is Record<string, unknown> {
   return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
-function isString(v: unknown): v is string {
-  return typeof v === 'string';
-}
-function isNumber(v: unknown): v is number {
-  return typeof v === 'number';
-}
-function stringOf(v: unknown): string | undefined {
-  return isString(v) ? v : undefined;
-}
-function numberOf(v: unknown): number | undefined {
-  return isNumber(v) ? v : undefined;
-}
-function stringArrayOf(v: unknown): string[] | undefined {
-  return Array.isArray(v) && v.every(isString) ? v : undefined;
+function recordAt(v: unknown, ...keys: string[]): Record<string, unknown> | undefined {
+  let cur: unknown = v;
+  for (const k of keys) cur = isRecord(cur) ? cur[k] : undefined;
+  return isRecord(cur) ? cur : undefined;
 }
 function runIdOf(v: unknown): string | undefined {
-  return isRecord(v) ? stringOf(v['runId']) : undefined;
-}
-
-interface SummarizedRange {
-  readonly summaryRef: string;
-  readonly replacedTurns: string[];
-}
-interface TranscriptWindow {
-  readonly tokenCounter: string;
-  readonly tokenCount: number;
-  readonly eventIds: string[];
-  readonly summarizedRanges: SummarizedRange[];
-}
-
-function summarizedRangeOf(v: unknown): SummarizedRange | undefined {
-  if (!isRecord(v)) return undefined;
-  const summaryRef = stringOf(v['summaryRef']);
-  const replacedTurns = stringArrayOf(v['replacedTurns']);
-  if (summaryRef === undefined || replacedTurns === undefined) return undefined;
-  return { summaryRef, replacedTurns };
-}
-
-/** Parse the seam response into a typed window — undefined if the shape is wrong. */
-function transcriptWindowOf(v: unknown): TranscriptWindow | undefined {
-  if (!isRecord(v)) return undefined;
-  const tokenCounter = stringOf(v['tokenCounter']);
-  const tokenCount = numberOf(v['tokenCount']);
-  const eventIds = stringArrayOf(v['eventIds']);
-  if (tokenCounter === undefined || tokenCount === undefined || eventIds === undefined) return undefined;
-  const rawRanges = v['summarizedRanges'];
-  const summarizedRanges: SummarizedRange[] = [];
-  if (Array.isArray(rawRanges)) {
-    for (const r of rawRanges) {
-      const parsed = summarizedRangeOf(r);
-      if (parsed === undefined) return undefined; // malformed range → fail loudly via caller
-      summarizedRanges.push(parsed);
-    }
-  }
-  return { tokenCounter, tokenCount, eventIds, summarizedRanges };
+  const r = isRecord(v) ? v['runId'] : undefined;
+  return typeof r === 'string' ? r : undefined;
 }
 
 describe('context-budget-transcript-bound (RFC 0111 §"Context economy")', () => {
   it('bounds the per-turn transcript to transcriptTokenBudget with an internally-consistent, recent-tail accounting', async () => {
-    const ma = await readCapabilityFamily<MultiAgentCap>('multiAgent');
-    const cb = ma?.executionModel?.contextBudget;
-    const budget = numberOf(cb?.transcriptTokenBudget);
-    if (!behaviorGate(PROFILE, budget !== undefined)) return;
-    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early (fixture-gated soft-skip)'); // fixture-gated soft-skip
-
-    const advertisedCounter = stringOf(cb?.tokenCounter);
-    expect(
-      advertisedCounter,
-      req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', 'tokenCounter MUST be advertised when transcriptTokenBudget is present (schema if/then)'),
-    ).toBeDefined();
-
-    // Drive the multi-turn orchestrator run.
-    const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
-    expect(create.status).toBe(201);
+    const major = targetMajor();
+    let cb: Record<string, unknown> | undefined;
+    if (major === 2) {
+      const doc = await v2Discovery();
+      if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+      cb = recordAt(await familyAdvertised('multiAgent'), 'executionModel', 'contextBudget');
+      if (typeof cb?.['transcriptTokenBudget'] !== 'number') return softSkip('inapplicable', 'multiAgent.executionModel.contextBudget.transcriptTokenBudget is not advertised at major 2');
+      if (!seamsProfileAdvertised(doc)) return softSkip('inapplicable', 'the transcript-window seam is in the seams profile — conformance.seamsProfile is not openwop-conformance-seams-v2');
+    } else {
+      cb = recordAt(await readCapabilityFamily<Record<string, unknown>>('multiAgent'), 'executionModel', 'contextBudget');
+      if (!behaviorGate(PROFILE, typeof cb?.['transcriptTokenBudget'] === 'number')) return;
+    }
+    const budget = cb?.['transcriptTokenBudget'];
+    const advertisedCounter = cb?.['tokenCounter'];
+    if (typeof budget !== 'number') return softSkip('inapplicable', 'transcriptTokenBudget not advertised');
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `the live fixture ${FIXTURE} is not advertised — the scripted multiturn fixture drives a mock supervisor, which RFC 0111 §Scope forbids from advertising contextBudget`);
+    expect(typeof advertisedCounter === 'string', req(ID, 'RFC 0111', 'tokenCounter MUST be advertised when transcriptTokenBudget is present (schema if/then)')).toBe(true);
+    if (typeof advertisedCounter !== 'string') return softSkip('blocked', 'contextBudget.tokenCounter is not advertised (the assertion above records the failure)');
+
+    const create = await driver.post(runsPath(), { workflowId: FIXTURE });
+    expect(create.status, req(ID, 'RFC 0111', `POST ${runsPath()} MUST create the live-fixture run`)).toBe(201);
     const runId = runIdOf(create.json);
-    expect(runId, req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', 'POST /v1/runs MUST return a runId')).toBeDefined();
-    if (runId === undefined) return softSkip('blocked', 'precondition not met — `runId === undefined` returned early (seam, prior step, or fixture unavailable)');
+    expect(runId, req(ID, 'RFC 0111', 'the create response MUST carry a runId')).toBeDefined();
+    if (runId === undefined) return softSkip('blocked', 'no runId');
     await pollUntilTerminal(runId);
 
-    // Probe the per-iteration transcript-window seam (OPTIONAL).
     const windows: Array<{ iteration: number; window: TranscriptWindow }> = [];
     for (let iteration = 1; iteration <= MAX_ITERATIONS_PROBED; iteration += 1) {
-      const res = await driver.get(
-        `/v1/host/sample/agent/transcript-window?runId=${encodeURIComponent(runId)}&iteration=${iteration}`,
-      );
+      const res = await driver.get(`/v1/host/sample/agent/transcript-window?runId=${encodeURIComponent(runId)}&iteration=${iteration}`);
       if (res.status === 404 || res.status === 405) {
-        if (iteration === 1) return softSkip('blocked', 'precondition not met — `iteration === 1` returned early (seam unwired — soft-skip the whole scenario) (seam, prior step, or fixture unavailable)'); // seam unwired — soft-skip the whole scenario
-        break; // iterations exhausted
+        if (iteration === 1) return major === 2 ? seamAbsent(`contextBudget is advertised but the transcript-window seam answered ${res.status} (host-sample-test-seams.md §14)`) : softSkip('blocked', `the transcript-window seam answered ${res.status} (host-sample-test-seams.md §14)`);
+        break;
       }
-      if (res.status === 400 || res.status === 422) break; // iteration past the run's last turn
-      expect(
-        res.status === 200,
-        req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'host-sample-test-seams.md §14', 'the transcript-window seam MUST return 200 for a valid iteration'),
-      ).toBe(true);
-      const window = transcriptWindowOf(res.json);
-      expect(
-        window,
-        req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'host-sample-test-seams.md §14', 'the seam MUST return { tokenCounter, tokenCount, eventIds, summarizedRanges }'),
-      ).toBeDefined();
-      if (window === undefined) return softSkip('blocked', 'precondition not met — `window === undefined` returned early (seam, prior step, or fixture unavailable)');
+      if (res.status === 400 || res.status === 422) break;
+      expect(res.status, req(ID, 'host-sample-test-seams.md §14', `iteration ${iteration}: the transcript-window seam MUST return 200 for a valid iteration`)).toBe(200);
+      const window = parseTranscriptWindow(res.json);
+      expect(window, req(ID, 'host-sample-test-seams.md §14', `iteration ${iteration}: the seam MUST return { tokenCounter, tokenCount, eventIds, summarizedRanges, entries? } with a well-formed entries[] when present`)).toBeDefined();
+      if (window === undefined) return softSkip('blocked', `iteration ${iteration}: the seam answer was malformed (the assertion above records the failure)`);
       windows.push({ iteration, window });
     }
+    expect(windows.length, req(ID, 'host-sample-test-seams.md §14', 'a wired transcript-window seam MUST report at least one orchestrator iteration')).toBeGreaterThan(0);
 
-    // Non-vacuity: a wired seam MUST report at least one iteration.
-    expect(windows.length, req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'host-sample-test-seams.md §14', 'a wired transcript-window seam MUST report at least one orchestrator iteration')).toBeGreaterThan(0);
-
-    // Independent event-log read for the cross-check (OPTIONAL seam).
     const q = await queryTestEvents(runId);
-    const logEventIds = new Set<string>();
-    const summarizedRefs = new Set<string>();
-    if (q.ok) {
-      for (const e of q.events) {
-        logEventIds.add(e.eventId);
-        if (e.type === 'context.summarized') {
-          const ref = stringOf(e.payload['summaryRef']);
-          if (ref !== undefined) summarizedRefs.add(ref);
-        }
-      }
-    }
-
+    const log: LogEvent[] | null = q.ok
+      ? q.events.map((e) => ({ eventId: e.eventId, type: e.type, sequence: e.sequence, payload: e.payload, ...(e.nodeId !== undefined ? { nodeId: e.nodeId } : {}) }))
+      : null;
+    const cap = { transcriptTokenBudget: budget, tokenCounter: advertisedCounter };
+    let pressure = false;
     for (const { iteration, window } of windows) {
-      // 1 — tokenCounter agreement.
-      expect(
-        window.tokenCounter,
-        req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', `iteration ${iteration}: seam tokenCounter MUST equal the advertised contextBudget.tokenCounter`),
-      ).toBe(advertisedCounter);
-
-      // 2 — the per-turn token bound.
-      if (budget !== undefined) {
-        expect(
-          window.tokenCount,
-          req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', `iteration ${iteration}: tokenCount MUST NOT exceed transcriptTokenBudget`),
-        ).toBeLessThanOrEqual(budget);
-      }
-
-      // 3 — internal consistency: every named id is a real persisted event.
-      if (q.ok) {
-        for (const id of window.eventIds) {
-          expect(
-            logEventIds.has(id),
-            req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111 §"Conformance seam"', `iteration ${iteration}: eventId "${id}" in the seam accounting MUST be a real persisted run event`),
-          ).toBe(true);
-        }
-      }
-
-      // 4 — recent-tail: ids are unique (no double-count inflating the window).
-      const uniqueIds = new Set(window.eventIds);
-      expect(
-        uniqueIds.size,
-        req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111 §"Conformance seam"', `iteration ${iteration}: eventIds MUST be a tail with no repeated entry`),
-      ).toBe(window.eventIds.length);
-
-      // 5 — every summarized range references a recorded context.summarized event.
-      if (q.ok) {
-        for (const range of window.summarizedRanges) {
-          expect(
-            summarizedRefs.has(range.summaryRef),
-            req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', `iteration ${iteration}: summarizedRanges summaryRef "${range.summaryRef}" MUST have a matching context.summarized event`),
-          ).toBe(true);
-        }
-      }
+      const v = checkTranscriptWindow(iteration, window, cap, log);
+      expect(v.violations, req(ID, 'RFC 0111 §"Conformance seam" (b)/(c), host-sample-test-seams.md §14', `iteration ${iteration}: the host's transcript accounting MUST be within budget, recountable, real, and a recent tail`)).toEqual([]);
+      pressure ||= v.pressure;
     }
 
     // keepLastTurns verbatim — a kept turn is fed verbatim, never inside a summarized range.
-    const keepLastTurns = numberOf(cb?.summarization?.keepLastTurns);
-    if (keepLastTurns !== undefined && keepLastTurns > 0 && windows.length > 0) {
+    const keepLastTurns = recordAt(cb, 'summarization')?.['keepLastTurns'];
+    if (typeof keepLastTurns === 'number' && keepLastTurns > 0) {
       const last = windows[windows.length - 1].window;
-      const summarizedIds = new Set<string>();
-      for (const range of last.summarizedRanges) for (const id of range.replacedTurns) summarizedIds.add(id);
-      const verbatimTail = last.eventIds.slice(Math.max(0, last.eventIds.length - keepLastTurns));
-      for (const id of verbatimTail) {
-        expect(
-          summarizedIds.has(id),
-          req('openwop.it.context-budget-transcript-bound.bounds-the-per-turn-transcript-to-transcripttokenbudget-with-an-internally-consi', 'RFC 0111', `a kept (verbatim) turn "${id}" MUST NOT appear inside a summarized range`),
-        ).toBe(false);
+      const summarizedIds = new Set(last.summarizedRanges.flatMap((r) => r.replacedTurns));
+      for (const id of last.eventIds.slice(Math.max(0, last.eventIds.length - keepLastTurns))) {
+        expect(summarizedIds.has(id), req(ID, 'RFC 0111', `a kept (verbatim) turn "${id}" MUST NOT appear inside a summarized range`)).toBe(false);
       }
     }
+
+    if (log === null) return softSkip('blocked', 'the run event-log seam is unavailable, so the real-event, recent-tail and pressure rules were not measured');
+    if (!pressure) softSkip('inapplicable', `no iteration shows budget pressure — every eligible event fit under transcriptTokenBudget ${budget}, so the bound was never exercised (a budget the run never reaches is not a witness)`);
   });
 });

package/src/scenarios/context-summarization-replay.test.ts

@@ -23,6 +23,15 @@
  * The RFC defers reference-host implementation; the witness comes from a host
  * that runs real orchestrator turns and summarizes.
  *
+ * STRENGTHENED 2.41.0 (the RFC 0111 correction on record, 2026-09-26). Equal
+ * `summaryRef`s prove the fork cited the same artifact; they do not prove the
+ * MODEL saw the same summary. When the transcript-window seam serves
+ * `entries[]` for both runs, the summary texts the host fed on the fork MUST be
+ * the source's, byte for byte — the replay MUST NOT re-summarize, on the text.
+ * Both majors: major 2 reads `summarization` by presence (the v2 schema has no
+ * `supported` seat) and records `inapplicable`, never a strict-mode failure,
+ * when it is absent. Gated on the live fixture `conformance-context-budget-live`.
+ *
  * @see RFCS/0111-context-economy.md
  * @see spec/v1/multi-agent-execution.md §"Context economy (RFC 0111)"
  */
@@ -36,122 +45,113 @@ import { readCapabilityFamily } from '../lib/discovery-capabilities.js';
 import { queryTestEvents, type TestEvent } from '../lib/event-log-query.js';
 import { req } from '../lib/requirement-ids.js';
 import { softSkip } from '../lib/soft-skip.js';
+import { seamsProfileAdvertised, targetMajor } from '../lib/seams.js';
+import { familyAdvertised, v2Discovery } from '../lib/v2.js';
+import { runsPath } from '../lib/memoryAttribution.js';
+import { parseTranscriptWindow, summarizationDeclared, summaryTexts, type LogEvent } from '../lib/context-budget.js';
 
-const FIXTURE = 'conformance-context-budget-multiturn';
+const FIXTURE = 'conformance-context-budget-live';
 const PROFILE = 'openwop-context-summarization';
+const ID = 'openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes';
+const MAX_ITERATIONS_PROBED = 16;
 
-interface SummarizationCap {
-  readonly supported?: boolean;
-}
-interface ContextBudgetCap {
-  readonly summarization?: SummarizationCap;
-}
-interface ExecutionModelCap {
-  readonly contextBudget?: ContextBudgetCap;
-}
-interface MultiAgentCap {
-  readonly executionModel?: ExecutionModelCap;
-}
-
-// ── cast-free typed accessors (no `as`) ──────────────────────────────────
 function isRecord(v: unknown): v is Record<string, unknown> {
   return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
-function isString(v: unknown): v is string {
-  return typeof v === 'string';
-}
-function stringOf(v: unknown): string | undefined {
-  return isString(v) ? v : undefined;
+function recordAt(v: unknown, ...keys: string[]): Record<string, unknown> | undefined {
+  let cur: unknown = v;
+  for (const k of keys) cur = isRecord(cur) ? cur[k] : undefined;
+  return isRecord(cur) ? cur : undefined;
 }
 function stringArrayOf(v: unknown): string[] | undefined {
-  return Array.isArray(v) && v.every(isString) ? v : undefined;
+  return Array.isArray(v) && v.every((x) => typeof x === 'string') ? v : undefined;
 }
 function runIdOf(v: unknown): string | undefined {
-  return isRecord(v) ? stringOf(v['runId']) : undefined;
+  const r = isRecord(v) ? v['runId'] : undefined;
+  return typeof r === 'string' ? r : undefined;
 }
 function replayModesOf(v: unknown): string[] {
-  if (!isRecord(v)) return [];
-  const replay = v['replay'];
-  if (!isRecord(replay)) return [];
-  return stringArrayOf(replay['modes']) ?? [];
+  return stringArrayOf(recordAt(v, 'replay')?.['modes']) ?? [];
 }
-
 /** A summary fingerprint: summaryRef plus the (ordered) replaced-turn ids. */
-function summaryFingerprint(e: TestEvent): string | undefined {
-  const ref = stringOf(e.payload['summaryRef']);
-  const replaced = stringArrayOf(e.payload['replacedTurns']);
-  if (ref === undefined || replaced === undefined) return undefined;
-  return `${ref}::${replaced.join(',')}`;
-}
-
 function summaryFingerprints(events: readonly TestEvent[]): string[] {
   const out: string[] = [];
   for (const e of events) {
     if (e.type !== 'context.summarized') continue;
-    const fp = summaryFingerprint(e);
-    expect(fp, 'a context.summarized event MUST carry summaryRef + replacedTurns').toBeDefined();
-    if (fp !== undefined) out.push(fp);
+    const ref = e.payload['summaryRef'];
+    const replaced = stringArrayOf(e.payload['replacedTurns']);
+    expect(typeof ref === 'string' && replaced !== undefined, req(ID, 'RFC 0111', 'a context.summarized event MUST carry summaryRef + replacedTurns')).toBe(true);
+    if (typeof ref === 'string' && replaced !== undefined) out.push(`${ref}::${replaced.join(',')}`);
   }
   return out.sort();
 }
+const toLog = (events: readonly TestEvent[]): LogEvent[] => events.map((e) => ({ eventId: e.eventId, type: e.type, sequence: e.sequence, payload: e.payload }));
+
+/** The summary texts the host fed across a run's iterations, via the seam; null when the seam or entries[] are not served. */
+async function fedSummaryTexts(runId: string, log: readonly LogEvent[]): Promise<string[] | null> {
+  const out: string[] = [];
+  let served = false;
+  for (let iteration = 1; iteration <= MAX_ITERATIONS_PROBED; iteration += 1) {
+    const res = await driver.get(`/v1/host/sample/agent/transcript-window?runId=${encodeURIComponent(runId)}&iteration=${iteration}`);
+    if (res.status !== 200) break;
+    const w = parseTranscriptWindow(res.json);
+    if (w?.entries === undefined) return null;
+    served = true;
+    out.push(...summaryTexts(w, log));
+  }
+  return served ? out : null;
+}
 
 describe('context-summarization-replay (RFC 0111 §"Replay determinism")', () => {
   it('replay reuses the recorded context.summarized summaryRef — never re-summarizes', async () => {
-    const ma = await readCapabilityFamily<MultiAgentCap>('multiAgent');
-    const summarizationSupported = ma?.executionModel?.contextBudget?.summarization?.supported === true;
-    if (!behaviorGate(PROFILE, summarizationSupported)) return;
-    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!isFixtureAdvertised(FIXTURE)` returned early (fixture-gated soft-skip)'); // fixture-gated soft-skip
+    const major = targetMajor();
+    let wellKnown: unknown;
+    if (major === 2) {
+      const doc = await v2Discovery();
+      if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
+      const cb = recordAt(await familyAdvertised('multiAgent'), 'executionModel', 'contextBudget');
+      if (!summarizationDeclared(cb, 2)) return softSkip('inapplicable', 'multiAgent.executionModel.contextBudget.summarization is not advertised at major 2');
+      if (!seamsProfileAdvertised(doc)) return softSkip('inapplicable', 'the run event-log is read through the seams profile — conformance.seamsProfile is not openwop-conformance-seams-v2');
+      wellKnown = doc;
+    } else {
+      const cb = recordAt(await readCapabilityFamily<Record<string, unknown>>('multiAgent'), 'executionModel', 'contextBudget');
+      if (!behaviorGate(PROFILE, summarizationDeclared(cb, 1))) return;
+      wellKnown = (await driver.get('/.well-known/openwop')).json;
+    }
+    if (!isFixtureAdvertised(FIXTURE)) return softSkip('inapplicable', `the live fixture ${FIXTURE} is not advertised — RFC 0111 §Scope forbids a mock supervisor from advertising contextBudget`);
 
-    // Drive the multi-turn orchestrator run.
-    const create = await driver.post('/v1/runs', { workflowId: FIXTURE });
-    expect(create.status).toBe(201);
+    const create = await driver.post(runsPath(), { workflowId: FIXTURE });
+    expect(create.status, req(ID, 'RFC 0111', `POST ${runsPath()} MUST create the live-fixture run`)).toBe(201);
     const sourceRunId = runIdOf(create.json);
-    expect(sourceRunId, req('openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes', 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'POST /v1/runs MUST return a runId')).toBeDefined();
-    if (sourceRunId === undefined) return softSkip('blocked', 'precondition not met — `sourceRunId === undefined` returned early (seam, prior step, or fixture unavailable)');
+    expect(sourceRunId, req(ID, 'rest-endpoints.md POST /v1/runs', 'the create response MUST carry a runId')).toBeDefined();
+    if (sourceRunId === undefined) return softSkip('blocked', 'no runId');
     await pollUntilTerminal(sourceRunId);
 
-    // Read the recorded summarization records (OPTIONAL event-log seam).
-    const sourceQ = await queryTestEvents(sourceRunId, { type: 'context.summarized' });
-    if (!sourceQ.ok) return softSkip('blocked', 'precondition not met — `!sourceQ.ok` returned early (event-log seam unwired — soft-skip) (seam, prior step, or fixture unavailable)'); // event-log seam unwired — soft-skip
+    const sourceQ = await queryTestEvents(sourceRunId);
+    if (!sourceQ.ok) return softSkip('blocked', 'the run event-log seam is unavailable');
     const sourceFingerprints = summaryFingerprints(sourceQ.events);
     if (sourceFingerprints.length === 0) {
-      // The run did not summarize (budget not exceeded on this host) — nothing
-      // to prove about reuse. Honest soft-skip; not a vacuous pass of the MUST.
-      // eslint-disable-next-line no-console
-      console.warn(`[${PROFILE}] run produced no context.summarized events; replay-reuse leg soft-skipped`);
-      return softSkip('blocked', 'precondition not met — `sourceFingerprints.length === 0` returned early ([…] run produced no context.summarized events; replay-reuse leg soft-skipped) (seam, prior step, or fixture unavailable)');
+      return softSkip('blocked', 'the live run produced no context.summarized event — a host advertising summarization must summarize this fixture for reuse to be observable');
     }
+    if (!replayModesOf(wellKnown).includes('replay')) return softSkip('inapplicable', 'the host advertises no replay fork mode');
 
-    // Only attempt replay when the host advertises the replay fork mode.
-    const wellKnown = await driver.get('/.well-known/openwop');
-    if (!replayModesOf(wellKnown.json).includes('replay')) return softSkip('inapplicable', 'capability or profile not advertised by this host — gate `!replayModesOf(wellKnown.json).includes(\'replay\')` returned early');
-
-    const fork = await driver.post(
-      `/v1/runs/${encodeURIComponent(sourceRunId)}:fork`,
-      { fromSeq: 0, mode: 'replay' },
-    );
-    if (fork.status === 501 || fork.status === 404) return softSkip('blocked', 'precondition not met — `fork.status === 501 || fork.status === 404` returned early (replay not implemented for this run — soft-skip) (seam, prior step, or fixture unavailable)'); // replay not implemented for this run — soft-skip
-    expect(
-      fork.status,
-      req('openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes', 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201'),
-    ).toBe(201);
+    const fork = await driver.post(`${runsPath()}/${encodeURIComponent(sourceRunId)}:fork`, { fromSeq: 0, mode: 'replay' });
+    if (fork.status === 501 || fork.status === 404) return softSkip('blocked', `replay fork answered ${fork.status}`);
+    expect(fork.status, req(ID, 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return 201')).toBe(201);
     const forkRunId = runIdOf(fork.json);
-    expect(forkRunId, req('openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes', 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return a runId')).toBeDefined();
-    if (forkRunId === undefined) return softSkip('blocked', 'precondition not met — `forkRunId === undefined` returned early (seam, prior step, or fixture unavailable)');
+    expect(forkRunId, req(ID, 'rest-endpoints.md POST /v1/runs/{runId}:fork', 'replay fork MUST return a runId')).toBeDefined();
+    if (forkRunId === undefined) return softSkip('blocked', 'no fork runId');
     await pollUntilTerminal(forkRunId);
 
-    const forkQ = await queryTestEvents(forkRunId, { type: 'context.summarized' });
-    if (!forkQ.ok) return softSkip('blocked', 'precondition not met — `!forkQ.ok` returned early (event-log seam unwired for the fork — soft-skip) (seam, prior step, or fixture unavailable)'); // event-log seam unwired for the fork — soft-skip
-    const forkFingerprints = summaryFingerprints(forkQ.events);
+    const forkQ = await queryTestEvents(forkRunId);
+    if (!forkQ.ok) return softSkip('blocked', 'the event-log seam is unavailable for the fork');
+    expect(summaryFingerprints(forkQ.events), req(ID, 'RFC 0111 §"Replay determinism"', 'a replay fork MUST reuse the recorded context.summarized summaryRef (never re-summarize to a different transcript)')).toEqual(sourceFingerprints);
 
-    // The replay MUST reuse the recorded summaries (same summaryRef + replacedTurns),
-    // NOT regenerate them — the direct analogue of RFC 0041 envelope-refusal recovery.
-    expect(
-      forkFingerprints,
-      req('openwop.it.context-summarization-replay.replay-reuses-the-recorded-context-summarized-summaryref-never-re-summarizes', 
-        'RFC 0111 §"Replay determinism"',
-        'a replay fork MUST reuse the recorded context.summarized summaryRef (never re-summarize to a different transcript)',
-      ),
-    ).toEqual(sourceFingerprints);
+    // The model-facing half: the summary TEXT the host fed on the fork.
+    const sourceTexts = await fedSummaryTexts(sourceRunId, toLog(sourceQ.events));
+    const forkTexts = await fedSummaryTexts(forkRunId, toLog(forkQ.events));
+    if (sourceTexts === null || forkTexts === null) return softSkip('inapplicable', 'the transcript-window seam serves no entries[] for these runs, so the model-facing summary text was not compared (summaryRef reuse was)');
+    expect(sourceTexts.length, req(ID, 'RFC 0111 §"Replay determinism"', 'the source run summarized, so its transcript windows MUST carry the summary text it fed')).toBeGreaterThan(0);
+    expect(forkTexts, req(ID, 'RFC 0111 §"Replay determinism"', 'the replay MUST feed the model the recorded summary text, byte for byte — never a re-summarization')).toEqual(sourceTexts);
   });
 });

package/src/scenarios/v2-bound-id-kinds.test.ts

@@ -36,6 +36,8 @@ import { scaledTimeoutMs } from '../lib/polling.js';
 import { req } from '../lib/requirement-ids.js';
 import { projectBoundId, BOUND_ID } from '../lib/bound-id.js';
 
+export const REQUIRES_HOST_CALLBACK = 'the host POSTs a webhook delivery to the suite-owned scoped receiver behind OPENWOP_WEBHOOK_RECEIVER_URL';
+
 const DOC = 'spec/v2/core/identity.md §5 (RFC 0187 §A)';
 const WEBHOOK_ID = 'openwop.requirement.0187.bound-id-kinds.webhook';
 const PER_KIND = 'openwop.requirement.0187.bound-id-kinds.per-kind';

package/src/scenarios/v2-durability-recovery.test.ts

@@ -75,6 +75,8 @@ import { startEffectReceiver, waitForFirstArrival } from '../lib/effect-receiver
 import { watchForResumption, type Observation, type Watch } from '../lib/durability-watch.js';
 import { noteEvidence, parseRecoveryBounds, EVIDENCE_NAME_PATTERN } from '../lib/durability-evidence.js';
 
+export const REQUIRES_HOST_CALLBACK = 'the host makes an outbound effect call to the suite-owned effect receiver (OPENWOP_WEBHOOK_RECEIVER_PORT)';
+
 const FIXTURE = 'conformance-noop';
 const FAILURE_FIXTURE = 'conformance-failure';
 

package/src/scenarios/v2-revocation-honored.test.ts

@@ -11,7 +11,9 @@
  * drives `POST /conformance/seams/sample/auth/credential/{mint,revoke}` (the
  * v1-shaped address `/v1/host/sample/auth/credential/…` through `seamPath()`)
  * with `{ lane }` / `{ lane, credential }` and records `blocked` when the host
- * does not mount it. Windowed lanes (`exp-and-recheck`, `short-lived`, `rebind`)
+ * does not mount it. A mint answer carrying `presentation: { kind: "cookie", name }`
+ * (2.40.3) is presented as `Cookie: <name>=<credential>`, so a cookie-borne
+ * `session` lane is witnessed as its production credential travels; bearer otherwise. Windowed lanes (`exp-and-recheck`, `short-lived`, `rebind`)
  * have no wire-observable "next request" and record `inapplicable`.
  */
 
@@ -48,17 +50,22 @@ describe('v2 revocation-honored (RFC 0170 §B.3 — seam-gated)', () => {
       const minted = await http(() => driver.post(MINT, { lane }));
       if (minted === null) return softSkip('blocked', `${MINT} unreachable (fetch failed)`);
       if (minted.status === 404 || minted.status === 403) return seamAbsent(`${MINT} not mounted (${minted.status}) — the host advertises the seams profile but does not serve the RFC 0170 §B.3 credential mint/revoke seams (api/seams-v2.yaml mintLaneCredential / revokeLaneCredential; host-sample-test-seams.md)`);
-      const credential = (minted.json as { credential?: unknown } | undefined)?.credential;
+      const body = minted.json as { credential?: unknown; presentation?: { kind?: unknown; name?: unknown } } | undefined;
+      const credential = body?.credential;
+      // 2.40.3 — a cookie-borne lane (a `session` lane) is presented the way its
+      // production credential is, `Cookie: <name>=<credential>`. Bearer otherwise.
+      const cookieName = body?.presentation?.kind === 'cookie' && typeof body.presentation.name === 'string' ? body.presentation.name : null;
+      const present = (c: unknown): Record<string, string> => (cookieName ? { Cookie: `${cookieName}=${String(c)}` } : { Authorization: `Bearer ${String(c)}` });
       expect(typeof credential, req('openwop.requirement.0170.revocation-honored', DOC, `the mint seam MUST answer { credential } for lane ${lane}`)).toBe('string');
 
       // Positive control — the minted credential authenticates before revocation.
-      const before = await http(() => driver.get('/runs/openwop-conformance-tenant/revocationprobe0123456789', { authenticated: false, headers: { Authorization: `Bearer ${String(credential)}` } }));
+      const before = await http(() => driver.get('/runs/openwop-conformance-tenant/revocationprobe0123456789', { authenticated: false, headers: present(credential) }));
       expect(before !== null && before.status !== 401, req('openwop.requirement.0170.revocation-honored', DOC, `a freshly minted ${lane} credential MUST authenticate before revocation (got ${before?.status ?? 'no response'})`)).toBe(true);
 
       const revoked = await http(() => driver.post(REVOKE, { lane, credential }));
       expect(revoked !== null && revoked.status < 400, req('openwop.requirement.0170.revocation-honored', DOC, `the revoke seam MUST accept the credential it minted for lane ${lane} (got ${revoked?.status ?? 'no response'})`)).toBe(true);
 
-      const after = await http(() => driver.get('/runs/openwop-conformance-tenant/revocationprobe0123456789', { authenticated: false, headers: { Authorization: `Bearer ${String(credential)}` } }));
+      const after = await http(() => driver.get('/runs/openwop-conformance-tenant/revocationprobe0123456789', { authenticated: false, headers: present(credential) }));
       expect(after?.status, req('openwop.requirement.0170.revocation-honored', DOC, `lane ${lane} MUST refuse a revoked credential on the next request with 401`)).toBe(401);
       expect(readErrorCode(after?.json), req('openwop.requirement.0170.revocation-honored', DOC, `the refusal code MUST be credential_revoked (lane ${lane})`)).toBe('credential_revoked');
     }

package/src/scenarios/v2-terminal-event-once.test.ts

@@ -39,6 +39,8 @@ import { req } from '../lib/requirement-ids.js';
 import { startEffectReceiver, waitForFirstArrival } from '../lib/effect-receiver.js';
 import { terminalShapeViolation, TERMINAL_RUN_EVENTS } from '../lib/terminal-shape.js';
 
+export const REQUIRES_HOST_CALLBACK = 'the host makes an outbound effect call to the suite-owned effect receiver (OPENWOP_WEBHOOK_RECEIVER_PORT)';
+
 const ONCE = 'openwop.requirement.0194.terminal-once';
 const DUP = 'openwop.requirement.0194.terminal-once.duplicate-delivery';
 const DOC = 'spec/v2/core/events.md §The terminal event (RFC 0194 §A)';

package/src/scenarios/v2-webhook-delivery-isolation.test.ts

@@ -55,6 +55,8 @@ import { blockedDespiteAssertions, softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 import { RETRY_WAIT_FLOOR_MS } from '../lib/webhook-retry-window.js';
 
+export const REQUIRES_HOST_CALLBACK = 'the host POSTs webhook deliveries to nine suite-owned subscriptions on the scoped receiver behind OPENWOP_WEBHOOK_RECEIVER_URL, eight of which the suite holds open';
+
 const ID = 'openwop.requirement.0215.no-head-of-line';
 const DOC = 'webhooks.md §Durability (RFC 0215 §A.1, §A.2)';
 const FIXTURE = 'conformance-delay';