@openwop/openwop-conformance 2.40.3 → 2.41.1

package/src/lib/context-budget.ts

@@ -0,0 +1,198 @@
+/**
+ * RFC 0111 — the transcript-window checker, kept pure so its sabotage cases are
+ * self-tests (`context-budget.test.ts`) rather than claims.
+ *
+ * WHY THIS FILE EXISTS (the 2026-09-26 correction on record, COMPATIBILITY.md).
+ * Until suite 2.41.0 `context-budget-transcript-bound` could not fail in the ways
+ * RFC 0111 names:
+ *   (b) "the harness independently … re-computes their token sum" — impossible:
+ *       events are content-free, so the suite had nothing to count. The test
+ *       checked that each id existed, and nothing else.
+ *   (c) "the recent tail" — the test checked only that ids were unique.
+ *   and no check that the budget was ever under PRESSURE, so a host advertising
+ *   a budget of 10^9 passed.
+ * The seam now also returns `entries[] { eventId, rendered }` — the exact text
+ * the host fed the model for each event that iteration — and for
+ * `tokenCounter: "chars"` the suite recounts it itself.
+ *
+ * Definitions this checker applies (host-sample-test-seams.md §14):
+ *   - `chars` is Unicode code points (`[...s].length`), not UTF-16 units or bytes.
+ *   - An event is ELIGIBLE for an iteration's transcript when it shares
+ *     `(type, nodeId)` with an event the host fed verbatim that iteration. The
+ *     RFC's "no older event included while a newer eligible one is dropped"
+ *     never defined "eligible"; keying on the pair (not the type alone) keeps a
+ *     host that feeds only one node's events from being convicted for another
+ *     node's.
+ *   - PRESSURE: the budget did something — an eligible event older than the
+ *     oldest fed one exists, or the window carries a summarized range.
+ */
+
+export interface WindowEntry {
+  readonly eventId: string;
+  readonly rendered: string;
+}
+export interface SummarizedRange {
+  readonly summaryRef: string;
+  readonly replacedTurns: readonly string[];
+}
+export interface TranscriptWindow {
+  readonly tokenCounter: string;
+  readonly tokenCount: number;
+  readonly eventIds: readonly string[];
+  readonly summarizedRanges: readonly SummarizedRange[];
+  readonly entries?: readonly WindowEntry[];
+}
+export interface LogEvent {
+  readonly eventId: string;
+  readonly type: string;
+  readonly sequence: number;
+  readonly nodeId?: string;
+  readonly payload: Record<string, unknown>;
+}
+export interface BudgetCap {
+  readonly transcriptTokenBudget: number;
+  readonly tokenCounter: string;
+}
+export interface WindowVerdict {
+  /** Every broken rule, as a sentence naming the iteration. Empty = consistent. */
+  readonly violations: string[];
+  /** Whether this iteration shows the budget acting (see file docblock). */
+  readonly pressure: boolean;
+  /** Rules that could not be evaluated (no event log). */
+  readonly unmeasured: string[];
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v);
+const stringArrayOf = (v: unknown): string[] | undefined => (Array.isArray(v) && v.every((x) => typeof x === 'string') ? v : undefined);
+
+/** Unicode code points — the `chars` unit. */
+export function charCount(s: string): number {
+  return [...s].length;
+}
+
+/** Parse a seam response; undefined when the required shape is wrong (a malformed optional member is also undefined — it cannot be half-trusted). */
+export function parseTranscriptWindow(v: unknown): TranscriptWindow | undefined {
+  if (!isRecord(v)) return undefined;
+  const tokenCounter = v['tokenCounter'];
+  const tokenCount = v['tokenCount'];
+  const eventIds = stringArrayOf(v['eventIds']);
+  if (typeof tokenCounter !== 'string' || typeof tokenCount !== 'number' || eventIds === undefined) return undefined;
+  const summarizedRanges: SummarizedRange[] = [];
+  const rawRanges = v['summarizedRanges'];
+  if (rawRanges !== undefined) {
+    if (!Array.isArray(rawRanges)) return undefined;
+    for (const r of rawRanges) {
+      if (!isRecord(r) || typeof r['summaryRef'] !== 'string') return undefined;
+      const replacedTurns = stringArrayOf(r['replacedTurns']);
+      if (replacedTurns === undefined) return undefined;
+      summarizedRanges.push({ summaryRef: r['summaryRef'], replacedTurns });
+    }
+  }
+  const rawEntries = v['entries'];
+  if (rawEntries === undefined) return { tokenCounter, tokenCount, eventIds, summarizedRanges };
+  if (!Array.isArray(rawEntries)) return undefined;
+  const entries: WindowEntry[] = [];
+  for (const e of rawEntries) {
+    if (!isRecord(e) || typeof e['eventId'] !== 'string' || typeof e['rendered'] !== 'string') return undefined;
+    entries.push({ eventId: e['eventId'], rendered: e['rendered'] });
+  }
+  return { tokenCounter, tokenCount, eventIds, summarizedRanges, entries };
+}
+
+const eligibilityKey = (e: LogEvent): string => `${e.type}\u0000${e.nodeId ?? ''}`;
+
+/**
+ * Check one iteration's window against the advertised cap and (when available)
+ * the run's event log. `log` null ⇒ the log-dependent rules are reported in
+ * `unmeasured`, never silently passed.
+ */
+export function checkTranscriptWindow(iteration: number, w: TranscriptWindow, cap: BudgetCap, log: readonly LogEvent[] | null): WindowVerdict {
+  const violations: string[] = [];
+  const unmeasured: string[] = [];
+  const at = `iteration ${iteration}`;
+
+  if (w.tokenCounter !== cap.tokenCounter) violations.push(`${at}: seam tokenCounter "${w.tokenCounter}" is not the advertised "${cap.tokenCounter}"`);
+  if (w.tokenCount > cap.transcriptTokenBudget) violations.push(`${at}: tokenCount ${w.tokenCount} exceeds transcriptTokenBudget ${cap.transcriptTokenBudget}`);
+  if (new Set(w.eventIds).size !== w.eventIds.length) violations.push(`${at}: eventIds repeats an entry`);
+
+  // (b) — the recount. Only `chars` is recountable by a black-box harness.
+  if (cap.tokenCounter === 'chars') {
+    if (w.entries === undefined) {
+      violations.push(`${at}: tokenCounter is "chars" but the seam returned no entries[] — the recount (RFC 0111 (b)) cannot run, and for "chars" entries are REQUIRED`);
+    } else {
+      const sum = w.entries.reduce((n, e) => n + charCount(e.rendered), 0);
+      if (sum !== w.tokenCount) violations.push(`${at}: entries[].rendered sum to ${sum} chars but tokenCount is ${w.tokenCount}`);
+    }
+  }
+
+  if (log === null) {
+    unmeasured.push('real-event, entries↔eventIds, summary-range, recent-tail and pressure rules (no event log)');
+    return { violations, pressure: false, unmeasured };
+  }
+
+  const byId = new Map(log.map((e) => [e.eventId, e]));
+  const summarizedByRef = new Map<string, LogEvent>();
+  for (const e of log) {
+    if (e.type !== 'context.summarized') continue;
+    const ref = e.payload['summaryRef'];
+    if (typeof ref === 'string') summarizedByRef.set(ref, e);
+  }
+
+  for (const id of w.eventIds) if (!byId.has(id)) violations.push(`${at}: eventId "${id}" is not an event of this run`);
+  for (const r of w.summarizedRanges) if (!summarizedByRef.has(r.summaryRef)) violations.push(`${at}: summarizedRanges summaryRef "${r.summaryRef}" has no matching context.summarized event`);
+
+  if (w.entries !== undefined) {
+    const verbatim: string[] = [];
+    for (const e of w.entries) {
+      const ev = byId.get(e.eventId);
+      if (ev === undefined) { violations.push(`${at}: entries[] eventId "${e.eventId}" is not an event of this run`); continue; }
+      if (ev.type === 'context.summarized') {
+        const ref = ev.payload['summaryRef'];
+        if (!w.summarizedRanges.some((r) => r.summaryRef === ref)) violations.push(`${at}: summary entry "${e.eventId}" is not listed in summarizedRanges`);
+      } else {
+        verbatim.push(e.eventId);
+      }
+    }
+    if (verbatim.join('\u0000') !== w.eventIds.join('\u0000')) violations.push(`${at}: the verbatim entries[] (${verbatim.length}) are not eventIds (${w.eventIds.length}) in the same order`);
+  }
+
+  // (c) — the recent tail.
+  const fed = w.eventIds.map((id) => byId.get(id)).filter((e): e is LogEvent => e !== undefined);
+  if (fed.length === 0) return { violations, pressure: w.summarizedRanges.length > 0, unmeasured };
+  for (let i = 1; i < fed.length; i += 1) {
+    if (fed[i].sequence <= fed[i - 1].sequence) { violations.push(`${at}: eventIds are not in event-log order`); break; }
+  }
+  const decided = log.find((e) => e.type === 'runOrchestrator.decided' && e.payload['iteration'] === iteration);
+  const cutoff = decided?.sequence ?? Number.POSITIVE_INFINITY;
+  for (const e of fed) if (e.sequence >= cutoff) violations.push(`${at}: eventId "${e.eventId}" (seq ${e.sequence}) is at or after the iteration's own decision (seq ${cutoff})`);
+
+  const keys = new Set(fed.map(eligibilityKey));
+  const fedIds = new Set(fed.map((e) => e.eventId));
+  const replaced = new Set(w.summarizedRanges.flatMap((r) => r.replacedTurns));
+  const minFed = Math.min(...fed.map((e) => e.sequence));
+  const maxBound = Number.isFinite(cutoff) ? cutoff : Math.max(...fed.map((e) => e.sequence)) + 1;
+  let pressure = w.summarizedRanges.length > 0;
+  for (const e of log) {
+    if (!keys.has(eligibilityKey(e)) || fedIds.has(e.eventId)) continue;
+    if (e.sequence > minFed && e.sequence < maxBound && !replaced.has(e.eventId)) {
+      violations.push(`${at}: eligible event "${e.eventId}" (${e.type}, seq ${e.sequence}) was dropped while an older one (seq ${minFed}) was fed — not a recent tail`);
+    }
+    if (e.sequence < minFed) pressure = true;
+  }
+  return { violations, pressure, unmeasured };
+}
+
+/** The summary texts a window fed, in entry order — the model-facing proof of replay reuse. */
+export function summaryTexts(w: TranscriptWindow, log: readonly LogEvent[]): string[] {
+  if (w.entries === undefined) return [];
+  const summaryIds = new Set(log.filter((e) => e.type === 'context.summarized').map((e) => e.eventId));
+  return w.entries.filter((e) => summaryIds.has(e.eventId)).map((e) => e.rendered);
+}
+
+/** v1 reads `summarization.supported: true`; v2 has no `supported` seat — presence of the record is the claim (capabilities.md §2). */
+export function summarizationDeclared(contextBudget: unknown, major: 1 | 2): boolean {
+  if (!isRecord(contextBudget)) return false;
+  const s = contextBudget['summarization'];
+  if (!isRecord(s)) return false;
+  return major === 2 ? true : s['supported'] === true;
+}

package/src/lib/host-callback.ts

@@ -74,9 +74,17 @@
  */
 export const HARNESS_DOUBLE_MODULES: readonly string[] = [
   'a2a-fake-peer',
+  // The two receiver modules whose only job is a server the HOST calls (2.40.4).
+  // They were missing, so `v2-a2a-push-delivery`'s correct declaration read as a
+  // callback it "does not make" and Conformance Soak went red on every run from
+  // #1546 (2026-09-24) on, while eight webhook/effect scenarios that DO take a
+  // host callback declared nothing. `webhook-receiver` stays off the list: it is
+  // mostly verification helpers, and importing it proves nothing.
+  'effect-receiver',
   'mcp-fake-server',
   'oidc-issuer',
   'otel-collector',
+  'scoped-receiver',
 ];
 
 /**

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)`);
   });
 });