@openwop/openwop-conformance 2.40.3 → 2.41.0

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-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';

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

@@ -57,6 +57,8 @@ import { req } from '../lib/requirement-ids.js';
 import { era2Gate, seedEra2Log, v1FixtureLog } from '../lib/era2-seed.js';
 import { SCHEMAS_DIR } from '../lib/paths.js';
 
+export const REQUIRES_HOST_CALLBACK = 'the host POSTs a webhook delivery to the suite-owned scoped receiver behind OPENWOP_WEBHOOK_RECEIVER_URL';
+
 const ID = 'openwop.requirement.0171.webhook-delivery-shape';
 const DOC = 'spec/v2/core/webhooks.md §Delivery';
 const FIXTURE = 'conformance-noop';

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

@@ -37,6 +37,8 @@ import { blockedDespiteAssertions, softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 import { retryWaitCapMs, retryWaitFor, windowClosedNote } from '../lib/webhook-retry-window.js';
 
+export const REQUIRES_HOST_CALLBACK = 'the host POSTs and retries webhook deliveries to the suite-owned scoped receiver behind OPENWOP_WEBHOOK_RECEIVER_URL';
+
 const FIXTURE = 'conformance-noop';
 const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
 

package/src/scenarios/v2-webhook-unregister-stops-delivery.test.ts

@@ -46,6 +46,8 @@ import { blockedDespiteAssertions, softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
 import { retryWaitCapMs, retryWaitFor } from '../lib/webhook-retry-window.js';
 
+export const REQUIRES_HOST_CALLBACK = 'the host POSTs and retries webhook deliveries to the suite-owned scoped receiver behind OPENWOP_WEBHOOK_RECEIVER_URL';
+
 const ID = 'openwop.requirement.0215.unregister-stops-delivery';
 const DOC = 'webhooks.md §Durability (RFC 0215 §B)';
 const FIXTURE = 'conformance-noop';

package/src/scenarios/webhook-signed-delivery.test.ts

@@ -113,6 +113,8 @@ import { discoverOwnedTenant } from '../lib/webhook-receiver.js';
 import { absenceIsUnmeasured, noDeliveryCause, startScopedReceiver, type ScopedReceiver } from '../lib/scoped-receiver.js';
 import { req } from '../lib/requirement-ids.js';
 
+export const REQUIRES_HOST_CALLBACK = 'the host POSTs a signed webhook delivery to the suite-owned scoped receiver behind OPENWOP_WEBHOOK_RECEIVER_URL';
+
 interface DeliveredRequest {
   readonly headers: Record<string, string>;
   readonly body: string;