@openwop/openwop-conformance 2.0.0-rc.9 → 2.0.1

package/src/scenarios/v2-poll-cursor-v2.test.ts

@@ -96,6 +96,24 @@ describe('v2 poll-cursor-v2 (RFC 0171 §E.2)', () => {
     if (res === null) return softSkip('blocked', 'GET /runs/{runId}/events/poll?afterSequence= unreachable (fetch failed)');
     expect(res.status, req('openwop.requirement.0171.poll-cursor-v2.after-sequence', DOC, 'afterSequence is an integer ≥ 0 and MUST be accepted')).toBe(200);
     const after = sequences(res.json);
+    // QUIESCENCE (rc.67). The comparison below is between TWO READS of the
+    // same log, and a run whose STATUS is terminal has not necessarily
+    // finished APPENDING — a host emitting trailing or vendor rows can add an
+    // event between the full read above and the cursor read just made. The
+    // assertion then reports an array mismatch and blames the host for a
+    // cursor defect it does not have.
+    //
+    // Measured by a peer host: this leg failed TWICE under a full-suite run
+    // and passed 6/6 in isolation on the same revision — the signature of a
+    // widening window under load, not of a wrong cursor. Re-reading the whole
+    // log now settles which it was: if the log is unchanged, the two reads
+    // straddled a quiet window and the comparison is decidable; if it grew,
+    // the suite could not measure the rule and says so instead of failing.
+    const settled = await poll(r.runId, '');
+    const seqsAfter = settled !== null && settled.status === 200 ? sequences(settled.json) : null;
+    if (seqsAfter === null || seqsAfter.join(',') !== seqs.join(',')) {
+      return softSkip('blocked', `the event log grew while the cursor was being read (before: [${seqs.join(',')}], after: [${seqsAfter?.join(',') ?? 'unreadable'}]) — a run at terminal STATUS is still appending, so the two reads this rule compares do not describe the same log. Re-run against a quiescent log; this is not a cursor defect.`);
+    }
     expect(after.every((s) => s > n), req('openwop.requirement.0171.poll-cursor-v2.after-sequence', DOC, `every returned sequence MUST be > afterSequence (${n}); got [${after.join(', ')}]`)).toBe(true);
     expect(after, req('openwop.requirement.0171.poll-cursor-v2.after-sequence', DOC, 'the cursor is exclusive and the log is not renumbered: afterSequence=first yields exactly the rest of the log')).toEqual(seqs.filter((s) => s > n));
   });

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

@@ -38,7 +38,7 @@ describe('v2 revocation-honored (RFC 0170 §B.3 — seam-gated)', () => {
   it('a revoked next-request credential is refused on the next request with credential_revoked', async () => {
     const doc = await discovery();
     if (!doc) return softSkip('blocked', 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0');
-    if (!seamsProfileAdvertised(doc)) return softSkip('blocked', 'seams profile not advertised (conformance.seamsProfile !== openwop-conformance-seams-v2) — revocation is seam-gated and cannot be observed from the canonical API');
+    if (!seamsProfileAdvertised(doc)) return softSkip('inapplicable', 'seams profile not advertised (conformance.seamsProfile !== openwop-conformance-seams-v2) — revocation is seam-gated and cannot be observed from the canonical API');
     const auth = await familyAdvertised('auth');
     const lanes = Array.isArray(auth?.['lanes']) ? (auth['lanes'] as Array<Record<string, unknown>>) : [];
     const nextRequest = lanes.filter((l) => l['revocation'] === 'next-request').map((l) => String(l['lane']));

package/src/scenarios/v2-run-annotation-not-event.test.ts

@@ -0,0 +1,71 @@
+/**
+ * `spec/v2/core/runs.md` §Annotations, artifacts, eval summary — an annotation
+ * is a live notification, never a run event (suite 2.0.0, target major 2; gated
+ * on `feedback`; one run created).
+ *
+ * `createAnnotation` answers 201 with `schemas/v2/annotation.schema.json`;
+ * `listAnnotations` returns `{ annotations[] }` carrying it (the control — a host
+ * that discards annotations would otherwise pass the next assertion for free);
+ * the run's event log MUST NOT carry it: no `run.annotated` in the poll, and
+ * the event count MUST NOT grow across the create. `runs.md` §Surface says
+ * `501` when `feedback` is unadvertised while the registry has no 501 code but
+ * `credential_unavailable` (finding 4, filed); 501 or 404 records inapplicable.
+ *
+ * @see spec/v2/core/runs.md §Annotations, artifacts, eval summary
+ * @see schemas/v2/annotation-create.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, gateFamily, v2Validator } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-annotation-not-event';
+const DOC = 'spec/v2/core/runs.md §Annotations, artifacts, eval summary';
+const NOOP = 'conformance-noop';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+const enc = (id: string): string => encodeURIComponent(id);
+async function events(runId: string): Promise<Array<{ type?: unknown }> | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1`));
+  const ev = (res?.json as { events?: unknown } | null)?.events;
+  return res?.status === 200 && Array.isArray(ev) ? (ev as Array<{ type?: unknown }>) : null;
+}
+
+describe('v2 run-annotation-not-event (runs.md §Annotations)', () => {
+  it('an annotation is created and listed, and never enters the run\'s event log', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!(await gateFamily('feedback'))) return softSkip('inapplicable', 'feedback family not advertised (gate recorded under openwop.family.feedback) — annotations are gated on feedback (runs.md §Surface)');
+    const created = await http(() => driver.post('/runs', { workflowId: NOOP }));
+    if (created === null) return softSkip('blocked', 'POST /runs unreachable (fetch failed)');
+    const runId = (created.json as { runId?: unknown } | null)?.runId;
+    if (created.status !== 201 || typeof runId !== 'string') return softSkip('blocked', `POST /runs answered ${created.status} ${readErrorCode(created.json) ?? ''}`.trim());
+    const t0 = Date.now();
+    while (Date.now() - t0 < 10_000) { const s = await http(() => driver.get(`/runs/${enc(runId)}`)); if (s?.status === 200 && TERMINAL.has(String((s.json as { status?: unknown }).status))) break; await new Promise((r) => setTimeout(r, 250)); }
+    const before = await events(runId);
+    if (before === null) return softSkip('blocked', 'GET /runs/{runId}/events/poll did not answer 200 before the annotation');
+
+    const ann = await http(() => driver.post(`/runs/${enc(runId)}/annotations`, { signal: { kind: 'label', label: 'conformance' }, note: 'openwop conformance annotation' }));
+    if (ann === null) return softSkip('blocked', 'POST /runs/{runId}/annotations unreachable (fetch failed)');
+    if (ann.status === 501 || ann.status === 404) return softSkip('blocked', `POST /runs/{runId}/annotations answered ${ann.status} although feedback is advertised — the surface is not mounted (an unadvertised feedback answers 404 not_found; 501 is not a registered shape)`);
+    expect(ann.status, req(ID, DOC, `createAnnotation MUST answer 201 — got ${ann.status} ${readErrorCode(ann.json) ?? ''}`.trim())).toBe(201);
+    const check = v2Validator('annotation')(ann.json);
+    expect(check.ok, req(ID, 'schemas/v2/annotation.schema.json', `the 201 body MUST validate: ${check.errors}`)).toBe(true);
+    const annotationId = (ann.json as { annotationId?: unknown } | null)?.annotationId;
+
+    const list = await http(() => driver.get(`/runs/${enc(runId)}/annotations`));
+    if (list === null) return softSkip('blocked', 'GET /runs/{runId}/annotations unreachable (fetch failed)');
+    expect(list.status, req(ID, DOC, `listAnnotations MUST answer 200 — got ${list.status}`)).toBe(200);
+    const rows = (list.json as { annotations?: unknown } | null)?.annotations;
+    expect(Array.isArray(rows) && rows.some((r) => (r as { annotationId?: unknown }).annotationId === annotationId), req(ID, DOC, 'listAnnotations MUST return the annotation just created (the control: a host that discards annotations must not pass the log assertion for free)')).toBe(true);
+
+    const after = await events(runId);
+    if (after === null) return softSkip('blocked', 'GET /runs/{runId}/events/poll did not answer 200 after the annotation');
+    expect(after.some((e) => String(e.type) === 'run.annotated'), req(ID, DOC, 'run.annotated is a live notification and MUST NOT enter the event log')).toBe(false);
+    expect(after.length, req(ID, DOC, `the event log MUST NOT grow across an annotation (${before.length} → ${after.length})`)).toBe(before.length);
+  }, 30_000);
+});

package/src/scenarios/v2-run-bulk-cancel.test.ts

@@ -0,0 +1,91 @@
+/**
+ * `spec/v2/core/runs.md` §Cancel — `bulkCancelRuns` (suite 2.0.0, target major 2;
+ * unaided).
+ *
+ * Legs:
+ *   1. over the cap: 101 syntactically valid tenant-bound ids MUST be refused
+ *      `400 validation_error` with `details.maxRunIds` (creates nothing);
+ *   2. `[own, foreign-tenant, own]` MUST answer `200 { results[] }` in request
+ *      order even when every entry failed; the foreign entry is `ok: false` with
+ *      an error envelope in the entry — never a top-level 403. The prose names
+ *      `run_forbidden` for a run the caller cannot see while identity.md §5 names
+ *      `id_tenant_mismatch` / `not_found` for a foreign tenant segment; the leg
+ *      accepts any of the three and the disagreement is filed (finding 3). An
+ *      own entry on an already-terminal noop is `ok: true` with
+ *      `cancelling | cancelled` or `ok: false` with `run_terminal` (finding 1).
+ *
+ * The foreign id matches the runId grammar, so a 400 on leg 2 is a host defect,
+ * not body validation.
+ *
+ * @see spec/v2/core/runs.md §Cancel
+ * @see spec/v2/core/identity.md §5
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, v2Validator } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-bulk-cancel';
+const DOC = 'spec/v2/core/runs.md §Cancel';
+const NOOP = 'conformance-noop';
+const FOREIGN = 'openwop-conformance-foreign-tenant/foreignopaque0123456789abcdef';
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+async function create(): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', { workflowId: NOOP }));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | null)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs answered ${res.status} ${readErrorCode(res.json) ?? ''} — create refused`.trim() };
+  return { runId };
+}
+interface Entry { runId?: unknown; ok?: unknown; status?: unknown; error?: unknown }
+
+describe('v2 run-bulk-cancel (runs.md §Cancel)', () => {
+  it('101 ids are refused 400 validation_error with details.maxRunIds', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const runIds = Array.from({ length: 101 }, (_, i) => `openwop-conformance-bulk-cap/opaque${String(i).padStart(3, '0')}0123456789abcdef`);
+    const res = await http(() => driver.post('/runs:bulk-cancel', { runIds }));
+    if (res === null) return softSkip('blocked', 'POST /runs:bulk-cancel unreachable (fetch failed)');
+    if (res.status === 404) return softSkip('blocked', 'POST /runs:bulk-cancel answered 404 — bulkCancelRuns is a core operation (runs.md §Surface) and is not mounted');
+    expect(res.status, req(ID, DOC, `over the cap (RECOMMENDED 100) the host MUST answer 400 — got ${res.status}`)).toBe(400);
+    expect(readErrorCode(res.json), req(ID, DOC, 'the refusal MUST be validation_error')).toBe('validation_error');
+    // The v2 envelope is { error: <code>, message, details? } — `details` at the ROOT
+    // (schemas/v2/error-envelope.schema.json). rc.48/rc.49 read `error.details`
+    // and reported a host defect that was this reader's; retracted in rc.50.
+    const max = (res.json as { details?: { maxRunIds?: unknown } } | null)?.details?.maxRunIds;
+    expect(typeof max === 'number' && max >= 1 && max <= 100, req(ID, DOC, `details.maxRunIds MUST state the cap (got ${String(max)})`)).toBe(true);
+  });
+
+  it('results[] come back in request order, each id processed independently, a foreign id refused in its entry and never as a top-level 403', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const a = await create(); if ('reason' in a) return softSkip('blocked', a.reason);
+    const b = await create(); if ('reason' in b) return softSkip('blocked', b.reason);
+    const runIds = [a.runId, FOREIGN, b.runId];
+    const res = await http(() => driver.post('/runs:bulk-cancel', { runIds, reason: 'conformance' }));
+    if (res === null) return softSkip('blocked', 'POST /runs:bulk-cancel unreachable (fetch failed)');
+    if (res.status === 404) return softSkip('blocked', 'POST /runs:bulk-cancel answered 404 — not mounted');
+    expect(res.status, req(ID, DOC, `bulkCancelRuns MUST answer 200 even when entries fail — a foreign id MUST NOT surface as a top-level ${res.status} ${readErrorCode(res.json) ?? ''}`.trim())).toBe(200);
+    const results = (res.json as { results?: unknown } | null)?.results;
+    expect(Array.isArray(results) && results.length === 3, req(ID, DOC, `results[] MUST carry one entry per requested id (got ${Array.isArray(results) ? results.length : typeof results})`)).toBe(true);
+    const entries = results as Entry[];
+    expect(entries.map((e) => e.runId), req(ID, DOC, 'results[] MUST be in request order')).toEqual(runIds);
+    const foreign = entries[1]!;
+    expect(foreign.ok, req(ID, DOC, 'the foreign-tenant entry MUST be ok: false')).toBe(false);
+    // An entry's `error` IS the error envelope (api/v2/openapi.yaml: `$ref error-envelope`):
+    // { error: <code>, message, details? } nested under the entry — so the code is
+    // `entry.error.error`, read the same way as a top-level envelope.
+    const env = v2Validator('error-envelope')(foreign.error);
+    expect(env.ok, req(ID, 'api/v2/openapi.yaml bulkCancelRuns results[].error', `an ok: false entry's error MUST be the error envelope { error: <code>, message, details? } (schemas/v2/error-envelope.schema.json; the OpenAPI $refs it for results[].error) — got ${JSON.stringify(foreign.error)}: ${env.errors}`)).toBe(true);
+    const fcode = String(readErrorCode(foreign.error));
+    expect(['id_tenant_mismatch', 'not_found'].includes(fcode), req(ID, 'spec/v2/core/identity.md §5', `an id whose tenant segment is not the caller's MUST be refused inside the entry with id_tenant_mismatch (or not_found where existence is not leaked) — identity.md §5 applies inside a bulk entry exactly as on a path; run_forbidden is for a same-tenant run the caller may not cancel — got ${fcode}`)).toBe(true);
+    for (const own of [entries[0]!, entries[2]!]) {
+      const okShape = own.ok === true && ['cancelling', 'cancelled'].includes(String(own.status));
+      const terminalShape = own.ok === false && readErrorCode(own.error) === 'run_terminal';
+      expect(okShape || terminalShape, req(ID, DOC, `an own entry MUST be ok: true with cancelling|cancelled, or ok: false run_terminal when the noop already completed — got ${JSON.stringify(own)}`)).toBe(true);
+    }
+  });
+});

package/src/scenarios/v2-run-cancel.test.ts

@@ -0,0 +1,97 @@
+/**
+ * `spec/v2/core/runs.md` §Cancel — `cancelRun` (suite 2.0.0, target major 2).
+ *
+ * Witness class: witnessable — the positive leg is gated on the
+ * `conformance-cancellable` fixture (a run that stays `running` for `delayMs`);
+ * the terminal-run leg is unaided.
+ *
+ * Legs:
+ *   1. cancelling a run that is already terminal — `runs.md` §Cancel is SILENT
+ *      on this case; the registry has `run_terminal` (409) and 200-idempotent is
+ *      the other defensible answer. The leg accepts either, records which, and
+ *      the ambiguity is filed for the prose (rc.48 CHANGELOG, finding 1).
+ *   2. on `conformance-cancellable`: `POST /runs/{runId}/cancel` on a running
+ *      run answers `200 { runId, status: cancelling | cancelled }`; `run.cancelled`
+ *      is in the log within 5 s; the snapshot reads `cancelled`.
+ *
+ * Until rc.48 nothing at major 2 witnessed §Cancel at all — runs.md carried 61
+ * MUSTs and 12 witness sites, every one under §Create.
+ *
+ * @see spec/v2/core/runs.md §Cancel
+ * @see conformance/fixtures.md §conformance-cancellable
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-cancel';
+const DOC = 'spec/v2/core/runs.md §Cancel';
+const NOOP = 'conformance-noop';
+const CANCELLABLE = 'conformance-cancellable';
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+const enc = (id: string): string => encodeURIComponent(id);
+
+async function create(body: Record<string, unknown>): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', body));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | null)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs answered ${res.status} ${readErrorCode(res.json) ?? ''} — create refused`.trim() };
+  return { runId };
+}
+async function statusOf(runId: string): Promise<string | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}`));
+  return res?.status === 200 ? String((res.json as { status?: unknown } | null)?.status ?? '') : null;
+}
+async function waitFor(runId: string, pred: (s: string) => boolean, ms: number): Promise<string | null> {
+  const t0 = Date.now(); let last: string | null = null;
+  while (Date.now() - t0 < ms) { last = await statusOf(runId); if (last !== null && pred(last)) return last; await new Promise((r) => setTimeout(r, 250)); }
+  return last;
+}
+async function eventTypes(runId: string): Promise<string[] | null> {
+  const res = await http(() => driver.get(`/runs/${enc(runId)}/events/poll?timeout=1`));
+  const events = (res?.json as { events?: unknown } | null)?.events;
+  return res?.status === 200 && Array.isArray(events) ? events.map((e) => String((e as { type?: unknown }).type)) : null;
+}
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+describe('v2 run-cancel (runs.md §Cancel)', () => {
+  it('cancelling a terminal run is refused 409 run_terminal', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const c = await create({ workflowId: NOOP });
+    if ('reason' in c) return softSkip('blocked', c.reason);
+    const s = await waitFor(c.runId, (x) => TERMINAL.has(x), 10_000);
+    if (s === null || !TERMINAL.has(s)) return softSkip('blocked', `the noop run did not reach a terminal status within 10 s (last: ${s ?? 'unreadable'})`);
+    const res = await http(() => driver.post(`/runs/${enc(c.runId)}/cancel`, {}));
+    if (res === null) return softSkip('blocked', 'POST /runs/{runId}/cancel unreachable (fetch failed)');
+    const code = readErrorCode(res.json);
+    const status = (res.json as { status?: unknown } | null)?.status;
+    expect(res.status, req(ID, DOC, `a cancel on a run that is already terminal (${s}) MUST be refused 409 run_terminal — got ${res.status} ${code ?? String(status)}; a 200 echoing the terminal state is outside §Cancel's 200 grammar { runId, status: cancelling | cancelled }`)).toBe(409);
+    expect(code, req(ID, DOC, 'the refusal MUST be run_terminal')).toBe('run_terminal');
+  });
+
+  it('cancelling a running run answers 200 with cancelling|cancelled, emits run.cancelled within 5 s, and the snapshot reads cancelled', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    if (!isFixtureAdvertised(CANCELLABLE)) return softSkip('inapplicable', `${CANCELLABLE} fixture not advertised — no run stays running long enough to cancel`);
+    const c = await create({ workflowId: CANCELLABLE, inputs: { delayMs: 15_000 } });
+    if ('reason' in c) return softSkip('blocked', c.reason);
+    const running = await waitFor(c.runId, (x) => x === 'running' || TERMINAL.has(x), 5_000);
+    if (running !== 'running') return softSkip('blocked', `${CANCELLABLE} did not reach running within 5 s (last: ${running ?? 'unreadable'})`);
+    const res = await http(() => driver.post(`/runs/${enc(c.runId)}/cancel`, { reason: 'conformance' }));
+    if (res === null) return softSkip('blocked', 'POST /runs/{runId}/cancel unreachable (fetch failed)');
+    expect(res.status, req(ID, DOC, `cancelRun on a running run MUST answer 200 — got ${res.status} ${readErrorCode(res.json) ?? ''}`.trim())).toBe(200);
+    const body = res.json as { runId?: unknown; status?: unknown } | null;
+    expect(body?.runId, req(ID, DOC, 'the 200 body MUST carry the run\'s runId')).toBe(c.runId);
+    expect(['cancelling', 'cancelled'].includes(String(body?.status)), req(ID, DOC, `status MUST be cancelling or cancelled (got ${String(body?.status)})`)).toBe(true);
+    const final = await waitFor(c.runId, (x) => x === 'cancelled', 5_000);
+    expect(final, req(ID, DOC, `the snapshot MUST read cancelled within 5 s of an accepted cancel (last: ${final ?? 'unreadable'})`)).toBe('cancelled');
+    const types = await eventTypes(c.runId);
+    expect(types?.includes('run.cancelled') ?? false, req(ID, 'spec/v2/core/events.md §run.cancelled', `the log MUST carry run.cancelled once the cascade completes (types: ${(types ?? []).join(', ')})`)).toBe(true);
+  }, 30_000);
+});

package/src/scenarios/v2-run-completed-outputs.test.ts

@@ -0,0 +1,93 @@
+/**
+ * `spec/v2/core/events.md` §Payloads — `run.completed` MUST carry `outputs`
+ * (suite 2.0.0, target major 2; unaided).
+ *
+ * This requirement is one day old, and the reason it needed writing is the
+ * reason this file exists. Both majors' payload schemas NAMED `outputs` on
+ * `runCompleted` and REQUIRED nothing. v1 also left the object open. So a
+ * tier-1 host emitted the singular `output` for its entire life and validated
+ * every time; v2 closing the object caught the EXTRA key — and that is the
+ * only reason anyone looked. Nothing in either major has ever caught an ABSENT
+ * one: a host emitting `run.completed {}` validates in v1 and, until rc.35, in
+ * v2. Seventeen scenario files mention `run.completed`; none read its payload.
+ *
+ * A key that no schema requires and no scenario reads is a requirement that
+ * exists only as a property name — the same shape as `eventLogSchemaVersion`,
+ * which lived in a schema `description` for the life of v1 while two hosts
+ * shipped without it. Asserting the EFFECT (the terminal event of a run that
+ * completed carries an outputs object) is the only form of this check a
+ * permissive emitter cannot satisfy by accident.
+ *
+ * @see spec/v2/core/events.md §Payloads
+ * @see schemas/v2/run-event-payloads.schema.json $defs/runCompleted
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, v2Validator } from '../lib/v2.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0171.run-completed-outputs';
+const DOC = 'spec/v2/core/events.md §Payloads';
+const NOOP_WORKFLOW_ID = 'conformance-noop';
+
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
+  try { return await fn(); } catch { return null; }
+}
+
+async function createRun(): Promise<{ runId: string } | { reason: string }> {
+  try { if (!(await v2Discovery())) return { reason: 'v2 discovery unreachable' }; } catch { return { reason: 'v2 discovery unreachable' }; }
+  const res = await http(() => driver.post('/runs', { workflowId: NOOP_WORKFLOW_ID }));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | undefined)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs {workflowId: ${NOOP_WORKFLOW_ID}} answered ${res.status} ${readErrorCode(res.json) ?? ''} — the smallest valid create was refused (fixture not seeded?)`.trim() };
+  return { runId };
+}
+
+interface Ev { readonly type?: unknown; readonly payload?: unknown }
+
+/** Poll until the terminal event lands. The noop workflow completes in well under a second; the bound is for a slow host, not a slow workflow. */
+async function terminalEvent(runId: string): Promise<{ ev: Ev } | { reason: string }> {
+  let last: string | null = null;
+  for (let i = 0; i < 20; i += 1) {
+    const res = await http(() => driver.get(`/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`));
+    if (res === null) return { reason: 'GET /runs/{runId}/events/poll unreachable (fetch failed)' };
+    if (res.status !== 200) return { reason: `GET /runs/{runId}/events/poll answered ${res.status}` };
+    const events = (res.json as { events?: unknown } | undefined)?.events;
+    if (Array.isArray(events)) {
+      const hit = events.find((e): e is Ev => typeof (e as Ev)?.type === 'string' && (e as Ev).type === 'run.completed');
+      if (hit) return { ev: hit };
+      const failed = events.find((e): e is Ev => typeof (e as Ev)?.type === 'string' && /^run\.(failed|cancelled)$/.test(String((e as Ev).type)));
+      if (failed) return { reason: `the noop run reached ${String(failed.type)} rather than run.completed — nothing to assert outputs on` };
+      last = `${events.length} event(s), none terminal`;
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return { reason: `run.completed never appeared (${last ?? 'no events'}) — the host may not run the noop workflow to completion` };
+}
+
+describe('v2 run-completed-outputs (events.md §Payloads)', () => {
+  it('the run.completed event of a run that completed carries an outputs object', async () => {
+    const c = await createRun();
+    if ('reason' in c) return softSkip('blocked', c.reason);
+    const t = await terminalEvent(c.runId);
+    if ('reason' in t) return softSkip('blocked', t.reason);
+
+    const payload = (t.ev.payload ?? null) as { outputs?: unknown; output?: unknown } | null;
+    expect(
+      payload !== null && typeof payload === 'object',
+      req(ID, DOC, 'run.completed MUST carry a payload object'),
+    ).toBe(true);
+    expect(
+      payload !== null && typeof payload.outputs === 'object' && payload.outputs !== null && !Array.isArray(payload.outputs),
+      req(ID, DOC, `run.completed MUST carry \`outputs\` as an object (an empty object is valid) — a client cannot tell "no outputs" from "outputs not rendered" when the key is absent, and no schema in either major required it until rc.35, which is how a host emitted the singular \`output\` for its whole life. Got keys ${JSON.stringify(payload ? Object.keys(payload) : null)}`),
+    ).toBe(true);
+
+    // The schema now requires it too; assert through the validator so the two
+    // cannot drift apart again without this leg saying which one moved.
+    const r = v2Validator('run-event')(t.ev);
+    expect(r.ok, req(ID, DOC, `the terminal event MUST validate against run-event.schema.json, whose runCompleted payload now requires outputs (${r.errors})`)).toBe(true);
+  });
+});

package/src/scenarios/v2-run-diff-identical.test.ts

@@ -0,0 +1,75 @@
+/**
+ * `spec/v2/core/runs.md` §Diff and ancestry — `diffRun` is a pure function of
+ * the two logs (suite 2.0.0, target major 2; unaided; two runs created, a third
+ * when `conformance-failure` is advertised).
+ *
+ * Identical logs MUST yield `divergedAtSeq: null` and empty `eventDiffs`;
+ * `eventId`, `runId`, `timestamp` and other run-scoped fields MUST be excluded
+ * from the comparison — so two `conformance-noop` runs ARE identical logs.
+ * `diffRun` is OPTIONAL (`404` when absent → inapplicable).
+ *
+ * Controls: the response MUST validate against
+ * `schemas/v2/run-diff-response.schema.json` and echo both ids in `a` / `b`
+ * (a host answering `{}` to any pair fails there); and, when
+ * `conformance-failure` is advertised, a noop-vs-failure diff MUST diverge.
+ * Without that fixture the divergence control records `inapplicable`.
+ *
+ * @see spec/v2/core/runs.md §Diff and ancestry
+ * @see schemas/v2/run-diff-response.schema.json
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver, type OpenWOPResponse } from '../lib/driver.js';
+import { v2Discovery, v2Validator } from '../lib/v2.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { readErrorCode } from '../lib/error-envelope.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+
+const ID = 'openwop.requirement.0170.run-diff-identical';
+const DOC = 'spec/v2/core/runs.md §Diff and ancestry';
+const NOOP = 'conformance-noop';
+const FAILURE = 'conformance-failure';
+const TERMINAL = new Set(['completed', 'failed', 'cancelled']);
+
+async function discovery(): Promise<Record<string, unknown> | null> { try { return await v2Discovery(); } catch { return null; } }
+async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> { try { return await fn(); } catch { return null; } }
+const enc = (id: string): string => encodeURIComponent(id);
+async function createSettled(workflowId: string): Promise<{ runId: string } | { reason: string }> {
+  const res = await http(() => driver.post('/runs', { workflowId }));
+  if (res === null) return { reason: 'POST /runs unreachable (fetch failed)' };
+  const runId = (res.json as { runId?: unknown } | null)?.runId;
+  if (res.status !== 201 || typeof runId !== 'string') return { reason: `POST /runs {workflowId: ${workflowId}} answered ${res.status} ${readErrorCode(res.json) ?? ''}`.trim() };
+  const t0 = Date.now();
+  while (Date.now() - t0 < 10_000) {
+    const s = await http(() => driver.get(`/runs/${enc(runId)}`));
+    if (s?.status === 200 && TERMINAL.has(String((s.json as { status?: unknown }).status))) return { runId };
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return { reason: `${workflowId} run ${runId} did not settle within 10 s` };
+}
+interface Diff { a?: unknown; b?: unknown; divergedAtSeq?: unknown; eventDiffs?: unknown }
+
+describe('v2 run-diff-identical (runs.md §Diff and ancestry)', () => {
+  it('two identical logs diff to divergedAtSeq null and empty eventDiffs, in a response that validates and echoes both ids', async () => {
+    if (!(await discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const a = await createSettled(NOOP); if ('reason' in a) return softSkip('blocked', a.reason);
+    const b = await createSettled(NOOP); if ('reason' in b) return softSkip('blocked', b.reason);
+    const res = await http(() => driver.get(`/runs/${enc(a.runId)}:diff?against=${enc(b.runId)}`));
+    if (res === null) return softSkip('blocked', 'GET /runs/{runId}:diff unreachable (fetch failed)');
+    if (res.status === 404) return softSkip('inapplicable', 'diffRun is OPTIONAL and answered 404 (runs.md §Surface)');
+    expect(res.status, req(ID, DOC, `diffRun MUST answer 200 — got ${res.status} ${readErrorCode(res.json) ?? ''}`.trim())).toBe(200);
+    const check = v2Validator('run-diff-response')(res.json);
+    expect(check.ok, req(ID, 'schemas/v2/run-diff-response.schema.json', `the response MUST validate: ${check.errors}`)).toBe(true);
+    const d = res.json as Diff;
+    expect([d.a, d.b], req(ID, DOC, 'the response MUST name the two runs it compared')).toEqual([a.runId, b.runId]);
+    expect(d.divergedAtSeq, req(ID, DOC, `identical logs MUST yield divergedAtSeq: null (got ${String(d.divergedAtSeq)}) — eventId, runId, timestamp and other run-scoped fields MUST be excluded from the comparison`)).toBeNull();
+    expect(d.eventDiffs, req(ID, DOC, 'identical logs MUST yield empty eventDiffs')).toEqual([]);
+    if (!isFixtureAdvertised(FAILURE)) return softSkip('inapplicable', `${FAILURE} fixture not advertised — the divergence control (a noop-vs-failure diff MUST diverge) cannot run`);
+    const f = await createSettled(FAILURE); if ('reason' in f) return softSkip('blocked', f.reason);
+    const dv = await http(() => driver.get(`/runs/${enc(a.runId)}:diff?against=${enc(f.runId)}`));
+    if (dv === null || dv.status !== 200) return softSkip('blocked', `the divergence control diff answered ${dv?.status ?? 'no response'}`);
+    const x = dv.json as Diff;
+    expect(typeof x.divergedAtSeq === 'number' && Array.isArray(x.eventDiffs) && x.eventDiffs.length > 0, req(ID, DOC, `a noop log and a failure log MUST diverge (divergedAtSeq ${String(x.divergedAtSeq)}, ${Array.isArray(x.eventDiffs) ? x.eventDiffs.length : 0} diff(s)) — the identical-logs pass above is only evidence if a different pair does not also read identical`)).toBe(true);
+  }, 45_000);
+});