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

package/src/scenarios/pause-resume.test.ts

@@ -2,17 +2,31 @@
  * Track 13: operator-driven pause/resume (rest-endpoints.md v1.1).
  *
  * Exercises the `POST /v1/runs/{runId}:pause` and `:resume` endpoints
- * against a long-running fixture (`conformance-delay` or `conformance-cancellable`).
+ * against a long-running fixture (`conformance-cancellable` or `conformance-delay`;
+ * both take `inputs.delayMs` — conformance/fixtures.md).
  *
  * Verifies:
- *   1. :pause on a running run transitions to `paused` and emits `run.paused`.
- *   2. :resume on a paused run transitions to `running` and emits `run.resumed`.
- *   3. :pause on a terminal run returns 409 with details.runStatus.
- *   4. :resume on a non-paused run returns 409 with details.runStatus.
+ *   1. :pause (immediate) on a running run transitions to `paused`; :resume
+ *      returns it to `running` and it reaches a terminal.
+ *   2. :resume on a non-paused run returns 409 with details.runStatus.
+ *   3. :pause on an already-paused run returns 409 (details.runStatus paused)
+ *      without a matching Idempotency-Key, and 202 with the cached response
+ *      when the same key is sent — rest-endpoints.md §:pause Idempotency.
+ *   4. :pause on a terminal run returns 409 with details.runStatus.
+ *   5. drain-current-node lets the executing node reach a terminal FIRST:
+ *      node.completed precedes run.paused in the log.
  *
- * Capability gating: skips when the host doesn't advertise
- * `capabilities.runs.pauseResume.supported: true` (when present) AND
- * skips when no long-running fixture is advertised.
+ * rc.53 (2026-09-05): a tier-1 host un-skipping this file found it
+ * contradicting rest-endpoints.md in three places — it expected 200/202 on a
+ * second :pause (the prose says 409 unless the Idempotency-Key matches), it
+ * asserted an error code `conflict` that v1 never named (v1 mandates 409 +
+ * details.runStatus and names only run_terminal for a terminal run), and it
+ * paused a 30 s node under drain-current-node and polled 10 s for `paused`
+ * (drain lets the node finish; a host that yields mid-node under drain is the
+ * non-conforming one). It also sent `delaySeconds`, a field the fixtures do
+ * not define. v1 is frozen; the scenario was the defect in every case.
+ *
+ * Capability gating: skips when no long-running fixture is advertised.
  *
  * @see spec/v1/rest-endpoints.md §pause/resume
  */
@@ -31,35 +45,49 @@ const FIXTURE =
   null;
 
 const SKIP = !FIXTURE;
+const DOC_PAUSE = 'rest-endpoints.md POST /v1/runs/{runId}:pause';
+const DOC_RESUME = 'rest-endpoints.md POST /v1/runs/{runId}:resume';
+
+async function cancel(runId: string): Promise<void> {
+  await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, { reason: 'conformance-cleanup' });
+}
+
+async function eventTypes(runId: string): Promise<string[]> {
+  const res = await driver.get(`/v1/runs/${encodeURIComponent(runId)}/events/poll?timeout=1`);
+  const events = (res.json as { events?: unknown } | null)?.events;
+  return Array.isArray(events) ? events.map((e) => String((e as { type?: unknown }).type)) : [];
+}
 
 describe.skipIf(SKIP)('pause/resume: running → paused → running → terminal', () => {
   it('pause transitions to paused; resume returns the run to running', async () => {
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
-      inputs: { delaySeconds: 30 },
+      // 3 s, not 30 s: the resumed node.started is a FRESH attempt (runs.md
+      // §Pause and resume; rc.52), so a 30 s node resumed at ~60 ms completes
+      // at ~30.2 s — past the suite's 30 s test timeout by construction on
+      // any conforming host. rc.53 shipped 30 s and a tier-1 host measured
+      // exactly that. The pause is `immediate`, issued within ~60 ms of
+      // `running`, so 3 s is ample for the pause to land first.
+      inputs: { delayMs: 3_000 },
     });
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
 
     await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
 
+    // `immediate` snapshots between events, so `paused` is observable within
+    // milliseconds. Under drain-current-node the node would finish first
+    // (rest-endpoints.md); that semantic is witnessed by the drain leg below.
     const pause = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {
       reason: 'conformance-test',
-      drainPolicy: 'drain-current-node',
+      drainPolicy: 'immediate',
     });
     if (pause.status === 404) {
-      // Pause endpoint not yet implemented by the host — surface the skip honestly.
-      // eslint-disable-next-line no-console
-      console.warn(
-        '[pause-resume] host returned 404 for :pause — endpoint not implemented; skipping rest',
-      );
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
       return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early ([pause-resume] host returned 404 for :pause — endpoint not implemented; skipping rest) (seam, prior step, or fixture unavailable)');
     }
-    expect(pause.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running', 
-      'rest-endpoints.md POST /v1/runs/{runId}:pause',
+    expect(pause.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running',
+      DOC_PAUSE,
       ':pause MUST return 202 on a pausable run',
     )).toBe(202);
 
@@ -68,8 +96,8 @@ describe.skipIf(SKIP)('pause/resume: running → paused → running → terminal
     const resume = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:resume`, {
       reason: 'conformance-test',
     });
-    expect(resume.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running', 
-      'rest-endpoints.md POST /v1/runs/{runId}:resume',
+    expect(resume.status, req('openwop.it.pause-resume.pause-transitions-to-paused-resume-returns-the-run-to-running',
+      DOC_RESUME,
       ':resume MUST return 202 on a paused run',
     )).toBe(202);
 
@@ -82,7 +110,7 @@ describe.skipIf(SKIP)('pause/resume: :resume on a non-paused run returns 409', (
   it('resuming a running (not paused) run returns 409 with details.runStatus', async () => {
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
-      inputs: { delaySeconds: 30 },
+      inputs: { delayMs: 30_000 },
     });
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
@@ -91,61 +119,85 @@ describe.skipIf(SKIP)('pause/resume: :resume on a non-paused run returns 409', (
 
     const resume = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:resume`, {});
     if (resume.status === 404) {
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
       return softSkip('blocked', 'precondition not met — `resume.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect(resume.status, req('openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus', 
-      'rest-endpoints.md POST /v1/runs/{runId}:resume',
+    expect(resume.status, req('openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus',
+      DOC_RESUME,
       ':resume on a non-paused run MUST return 409',
     )).toBe(409);
 
+    // v1 mandates the status and details.runStatus; it names no code for
+    // this case (the registry is open — error-envelope.schema.json), so
+    // none is asserted. `run_state_conflict` is the v2 answer (runs.md).
     const body = resume.json as { error?: string; details?: { runStatus?: string } };
-    expect(body.error).toBe('conflict');
-    expect(typeof body.details?.runStatus).toBe('string');
+    expect(typeof body.details?.runStatus, req('openwop.it.pause-resume.resuming-a-running-not-paused-run-returns-409-with-details-runstatus',
+      DOC_RESUME,
+      'the 409 MUST carry details.runStatus with the actual state',
+    )).toBe('string');
 
-    await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-      reason: 'conformance-cleanup',
-    });
+    await cancel(runId);
   });
 });
 
-describe.skipIf(SKIP)('pause/resume: pause is idempotent when already paused', () => {
-  it(':pause on an already-paused run is a no-op (200/202) — idempotent', async () => {
+describe.skipIf(SKIP)('pause/resume: a second :pause is 409 without a matching Idempotency-Key and 202 with one', () => {
+  it(':pause on an already-paused run returns 409 with details.runStatus paused, unless the request carries the original Idempotency-Key', async () => {
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
-      inputs: { delaySeconds: 30 },
+      inputs: { delayMs: 30_000 },
     });
     expect(create.status).toBe(201);
     const runId = (create.json as { runId: string }).runId;
     await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
 
-    const first = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {});
+    const first = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, { drainPolicy: 'immediate' });
     if (first.status === 404) {
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
       return softSkip('blocked', 'precondition not met — `first.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
-    expect([200, 202]).toContain(first.status);
+    expect(first.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      ':pause MUST return 202 on a pausable run',
+    )).toBe(202);
     await pollUntilStatus(runId, 'paused', { timeoutMs: 10_000 });
 
-    // Idempotent second :pause — MUST NOT 409 just because the run is
-    // already paused. 200/202 are both acceptable per the additive
-    // contract; 409 would force callers to read state before calling.
+    // rest-endpoints.md §:pause Idempotency: "a :pause against a run that is
+    // already paused returns 409 (with the existing pause's pausedAt in
+    // details) unless the request carries Idempotency-Key matching the
+    // original pause, in which case the host returns 202 with the cached
+    // response." Until rc.53 this leg asserted 200/202 here, citing an
+    // "additive contract" the prose does not contain.
     const second = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {});
-    expect(
-      [200, 202].includes(second.status),
-      req('openwop.it.pause-resume.pause-on-an-already-paused-run-is-a-no-op-200-202-idempotent', 
-        'rest-endpoints.md POST /v1/runs/{runId}:pause',
-        ':pause on an already-paused run MUST be idempotent (200/202), not 409',
-      ),
-    ).toBe(true);
-
-    await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-      reason: 'conformance-cleanup',
-    });
+    expect(second.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      ':pause on an already-paused run without a matching Idempotency-Key MUST return 409',
+    )).toBe(409);
+    const body = second.json as { details?: { runStatus?: string } };
+    expect(body.details?.runStatus, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      'the 409 MUST carry details.runStatus: paused',
+    )).toBe('paused');
+    await cancel(runId);
+
+    // The keyed form: the same Idempotency-Key on both pauses collapses the
+    // second into the cached 202.
+    const keyed = await driver.post('/v1/runs', { workflowId: FIXTURE!, inputs: { delayMs: 30_000 } });
+    expect(keyed.status).toBe(201);
+    const keyedId = (keyed.json as { runId: string }).runId;
+    await pollUntilStatus(keyedId, 'running', { timeoutMs: 10_000 });
+    const key = `openwop-conformance-pause-${keyedId.replace(/[^A-Za-z0-9._~-]/g, '-')}`.slice(0, 128);
+    const k1 = await driver.post(`/v1/runs/${encodeURIComponent(keyedId)}:pause`, { drainPolicy: 'immediate' }, { headers: { 'Idempotency-Key': key } });
+    expect(k1.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      ':pause with an Idempotency-Key MUST return 202 on a pausable run',
+    )).toBe(202);
+    await pollUntilStatus(keyedId, 'paused', { timeoutMs: 10_000 });
+    const k2 = await driver.post(`/v1/runs/${encodeURIComponent(keyedId)}:pause`, { drainPolicy: 'immediate' }, { headers: { 'Idempotency-Key': key } });
+    expect(k2.status, req('openwop.it.pause-resume.pause-on-an-already-paused-run-returns-409-with-details-runstatus-paused-unless',
+      DOC_PAUSE,
+      'a :pause carrying the original Idempotency-Key MUST return 202 with the cached response, not 409',
+    )).toBe(202);
+    await cancel(keyedId);
   });
 });
 
@@ -160,19 +212,58 @@ describe.skipIf(SKIP)('pause/resume: :pause on a terminal run returns 409', () =
 
     const pause = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {});
     if (pause.status === 404) return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
-    expect(pause.status, req('openwop.it.pause-resume.pause-on-a-completed-cancelled-failed-run-must-return-409', 
-      'rest-endpoints.md POST /v1/runs/{runId}:pause',
+    expect(pause.status, req('openwop.it.pause-resume.pause-on-a-completed-cancelled-failed-run-must-return-409',
+      DOC_PAUSE,
       ':pause on a terminal run MUST return 409',
     )).toBe(409);
 
+    // v1 mandates details.runStatus; `run_terminal` is the one code v1 names
+    // for a mutation on a terminal run (rest-endpoints.md, bulk-cancel), and
+    // the registry is open, so the code is not asserted here.
     const body = pause.json as { error?: string; details?: { runStatus?: string } };
-    expect(body.error).toBe('conflict');
-    // Spec requires `details.runStatus` to disclose the terminal state so
-    // the caller can decide whether to retry or surface the conflict.
     expect(['completed', 'failed', 'cancelled']).toContain(body.details?.runStatus);
   });
 });
 
+describe.skipIf(SKIP)('pause/resume: drain-current-node lets the executing node reach a terminal first', () => {
+  it('under drain-current-node node.completed precedes run.paused in the log', async () => {
+    // A short node: drain has something to wait for that finishes inside the
+    // poll window. A 30 s node under drain pauses after 30 s — that is the
+    // semantic, not a bug (rest-endpoints.md: "lets the executing node reach
+    // a terminal before the run transitions to paused").
+    const create = await driver.post('/v1/runs', {
+      workflowId: FIXTURE!,
+      inputs: { delayMs: 3_000 },
+    });
+    expect(create.status).toBe(201);
+    const runId = (create.json as { runId: string }).runId;
+    await pollUntilStatus(runId, 'running', { timeoutMs: 10_000 });
+
+    const pause = await driver.post(`/v1/runs/${encodeURIComponent(runId)}:pause`, {
+      reason: 'conformance-drain',
+      drainPolicy: 'drain-current-node',
+    });
+    if (pause.status === 404) {
+      await cancel(runId);
+      return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
+    }
+    expect(pause.status, req('openwop.it.pause-resume.under-drain-current-node-node-completed-precedes-run-paused-in-the-log',
+      DOC_PAUSE,
+      ':pause with drainPolicy drain-current-node MUST return 202 (pause requested)',
+    )).toBe(202);
+
+    await pollUntilStatus(runId, 'paused', { timeoutMs: 20_000 });
+    const types = await eventTypes(runId);
+    const done = types.indexOf('node.completed');
+    const paused = types.indexOf('run.paused');
+    expect(done >= 0 && paused > done, req('openwop.it.pause-resume.under-drain-current-node-node-completed-precedes-run-paused-in-the-log',
+      DOC_PAUSE,
+      `drain-current-node MUST let the executing node reach a terminal before the run transitions to paused — node.completed MUST precede run.paused (types: ${types.join(', ')})`,
+    )).toBe(true);
+    await cancel(runId);
+  });
+});
+
 describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
   it(':pause MUST NOT silently override an active interrupt suspend', async () => {
     // If the host seeds an approval fixture, drive a suspend then attempt
@@ -198,18 +289,15 @@ describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
       reason: 'race-test',
     });
     if (pause.status === 404) {
-      // Cleanup.
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
       return softSkip('blocked', 'precondition not met — `pause.status === 404` returned early (seam, prior step, or fixture unavailable)');
     }
 
     // Either rejection (preferred) or stacked-pause is OK; silent override is not.
     if (pause.status === 409) {
       const body = pause.json as { details?: { runStatus?: string } };
-      expect(body.details?.runStatus, req('openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend', 
-        'rest-endpoints.md POST /v1/runs/{runId}:pause',
+      expect(body.details?.runStatus, req('openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend',
+        DOC_PAUSE,
         ':pause-during-suspend MUST surface the active waiting-* status in the conflict envelope',
       )).toMatch(/^waiting-/);
     } else {
@@ -220,13 +308,11 @@ describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
       const status = (snap.json as { status: string }).status;
       expect(
         status === 'paused' || status.startsWith('waiting-'),
-        req('openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend', 'rest-endpoints.md POST /v1/runs/{runId}:pause', ':pause-during-suspend MUST NOT silently discard the active interrupt'),
+        req('openwop.it.pause-resume.pause-must-not-silently-override-an-active-interrupt-suspend', DOC_PAUSE, ':pause-during-suspend MUST NOT silently discard the active interrupt'),
       ).toBe(true);
     }
 
-    await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-      reason: 'conformance-cleanup',
-    });
+    await cancel(runId);
   });
 });
 
@@ -249,7 +335,7 @@ describe.skipIf(SKIP)('pause/resume: drainPolicy discrimination per capabilities
     for (const policy of drainPolicies) {
       const create = await driver.post('/v1/runs', {
         workflowId: FIXTURE!,
-        inputs: { delaySeconds: 30 },
+        inputs: { delayMs: 30_000 },
       });
       expect(create.status).toBe(201);
       const runId = (create.json as { runId: string }).runId;
@@ -260,14 +346,12 @@ describe.skipIf(SKIP)('pause/resume: drainPolicy discrimination per capabilities
         reason: `conformance-drainpolicy-${policy}`,
         drainPolicy: policy,
       });
-      expect(pause.status, req('openwop.it.pause-resume.every-drainpolicy-advertised-by-the-host-is-accepted-on-pause', 
+      expect(pause.status, req('openwop.it.pause-resume.every-drainpolicy-advertised-by-the-host-is-accepted-on-pause',
         'capabilities.md §`runs.pauseResume.drainPolicies` + rest-endpoints.md POST /v1/runs/{runId}:pause',
         `host-advertised drainPolicy='${policy}' MUST be accepted on :pause`,
       )).toBe(202);
 
-      await driver.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
-        reason: 'conformance-cleanup',
-      });
+      await cancel(runId);
     }
   });
 });

package/src/scenarios/v2-advertised-fixtures-exist.test.ts

@@ -3,40 +3,42 @@
  * the host must be able to honour (suite 2.0.0, target major 2; unaided).
  *
  * `fixtures[]` in discovery gates scenarios: `isFixtureAdvertised(id)` decides
- * whether a scenario runs at all. Nothing checked that an advertised id names a
- * fixture the corpus actually defines, or that the host can serve it. A host
- * whose advertised list and seeded set drift apart therefore fails somewhere
- * else entirely — the scenario gated on the missing fixture attempts, fails on
- * a run that cannot be created, and the failure is attributed to that
- * scenario's requirement rather than to the advertisement that was wrong.
+ * whether a scenario runs at all. So a host whose advertised list and seeded set
+ * drift apart fails somewhere else entirely — the scenario gated on the missing
+ * fixture attempts, fails on a run that cannot be created, and the failure is
+ * attributed to that scenario's requirement rather than to the advertisement
+ * that was wrong. That misattribution is what this scenario exists to catch.
  *
- * No host is currently known to exhibit this. A tier-2 host was thought to
- * (46 seeded against 47 advertised) and then verified and retracted it — the
- * count had been eyeballed from an array literal rather than measured, and the
- * two sets are in fact identical. The scenario is kept because the failure mode
- * is a property of the gating mechanism, not of that host: `fixtures[]` decides
- * whether a scenario runs, so a wrong advertisement is charged to whatever runs
- * next. Leg 1 is also the stronger check — an id the corpus catalog does not
- * define is wrong however well a host's own two lists agree with each other.
+ * **This scenario shipped with a second leg that was wrong, and the correction
+ * matters more than the check.** That leg asserted the advertised ids are a
+ * SUBSET of `conformance/fixtures/` — "the vocabulary is closed, so an id the
+ * corpus does not define is a typo or an invention". The vocabulary is not
+ * closed. Host-supplied fixtures are the normal case: dozens of ids the
+ * scenarios gate on are deliberately not shipped, and `v2-approver-enforced`
+ * says so in its own docstring — it needs an approval fixture whose
+ * `approversList` names a principal the suite is not, and records `blocked`
+ * naming it precisely because "no such fixture ships in `conformance/fixtures/`".
  *
- * Two legs, both cheap:
- *   1. the advertised ids are a subset of the corpus fixture catalog — the
- *      vocabulary is closed, so an id the corpus does not define is a typo or
- *      an invention, not a capability;
- *   2. a bounded sample of advertised fixtures is actually creatable, so the
- *      list is a claim about reachable state rather than a wish.
+ * So the leg failed a host for doing exactly what the corpus asks. It was found
+ * by running the suite against the reference host, which advertised two
+ * host-supplied fixtures and was marked non-conformant for it. Set membership
+ * cannot distinguish a typo from a legitimate host fixture, and a check that
+ * cannot tell those apart is not a check — it is a coin flip that happens to
+ * land on "fail" for correct hosts.
+ *
+ * What survives is the leg that was always sound: an advertised fixture MUST be
+ * creatable. That holds whoever defines it, and it is the one that catches the
+ * drift the misattribution comes from.
  *
  * @see spec/v2/core/conformance.md
- * @see conformance/fixtures.md
+ * @see conformance/src/scenarios/v2-approver-enforced.test.ts (a host-supplied fixture, by design)
  */
 
 import { describe, it, expect } from 'vitest';
-import { existsSync, readdirSync } from 'node:fs';
 import { driver, type OpenWOPResponse } from '../lib/driver.js';
 import { v2Discovery } from '../lib/v2.js';
 import { softSkip } from '../lib/soft-skip.js';
 import { req } from '../lib/requirement-ids.js';
-import { FIXTURES_DIR } from '../lib/paths.js';
 
 const ID = 'openwop.requirement.0168.advertised-fixtures-exist';
 const DOC = 'spec/v2/core/conformance.md §Fixtures';
@@ -57,26 +59,6 @@ function advertisedIds(doc: Record<string, unknown>): string[] {
 }
 
 describe('v2-advertised-fixtures-exist (conformance.md §Fixtures)', () => {
-  it('every advertised fixture id is one the corpus defines', async () => {
-    const doc = await v2Discovery().catch(() => null);
-    if (!doc) return softSkip('blocked', 'v2 discovery unreachable');
-    const ids = advertisedIds(doc);
-    if (ids.length === 0) return softSkip('inapplicable', 'the host advertises no fixtures[] — there is no claim to falsify');
-    if (FIXTURES_DIR === null || !existsSync(FIXTURES_DIR)) {
-      return softSkip('blocked', 'the fixture catalog is absent from this layout, so an advertised id cannot be checked against it');
-    }
-    const catalog = new Set(
-      readdirSync(FIXTURES_DIR)
-        .filter((f) => f.endsWith('.json'))
-        .map((f) => f.replace(/\.json$/, '')),
-    );
-    const unknown = ids.filter((id) => !catalog.has(id));
-    expect(
-      unknown,
-      req(ID, DOC, `every id in fixtures[] MUST name a fixture the corpus defines — the vocabulary is closed, so an id the catalog does not carry is a typo or an invention rather than a capability (${unknown.length} unknown of ${ids.length}: ${unknown.slice(0, 5).join(', ')})`),
-    ).toEqual([]);
-  });
-
   it('a sampled advertised fixture is actually creatable, not just listed', async () => {
     const doc = await v2Discovery().catch(() => null);
     if (!doc) return softSkip('blocked', 'v2 discovery unreachable');

package/src/scenarios/v2-advertised-path-space-served.test.ts

@@ -0,0 +1,165 @@
+/**
+ * RFC 0172 §A.1 / `spec/v2/core/versioning.md` §1.2 — a host that advertises
+ * major 2 serves the major-2 PATH SPACE, not just the major-2 discovery
+ * document (suite 2.0.0, target major 2; unaided).
+ *
+ * `v2-version-header-honored` checks that `OpenWOP-Version` is honored or
+ * refused rather than ignored. It probes `/.well-known/openwop`, because that
+ * is the one resource whose representation the header selects. **It therefore
+ * cannot see a host that negotiates correctly on the well-known resource and
+ * has mounted almost none of the rest of the v2 surface.**
+ *
+ * That is not hypothetical. A tier-1 host advertising
+ * `protocolVersions: ["1.1","2.0"]` was found serving **two of fifteen**
+ * top-level segments of the v2 path space: its unversioned mount was a
+ * deliberate allowlist (`['/runs','/interrupts']`, chosen over a blanket
+ * `/v1`-strip because the host serves a large non-`/v1` surface a blanket
+ * rewrite would shadow) and the list was simply incomplete. Every probe used to
+ * call the dual stack live — `protocolVersions`, `preferredVersion`, the
+ * response header, the two differing representations — hits `/.well-known`, so
+ * every one of them passed. `POST /webhooks` under major 2 returned `404` while
+ * `POST /v1/webhooks` returned `201`. The host found this itself by applying
+ * the artifact rule to a scenario it had first classified as a harness defect.
+ *
+ * The discriminator is a PAIR, not a single probe, because "this host does not
+ * implement webhooks at all" and "this host implements webhooks but did not
+ * mount them under major 2" are different facts that a lone `404` cannot
+ * separate:
+ *
+ *   /v1<path> exists  AND  <path> is 404 under major 2  ⇒  the advertisement
+ *   overstates: the surface exists and major 2 does not reach it.
+ *
+ *   both 404  ⇒  the host does not serve that surface in either major. Not this
+ *   scenario's business, and recorded as neither pass nor failure.
+ *
+ * Only parameterless GETs from `spec/v2/path-manifest.json` are probed: they
+ * need no fixture, mutate nothing, and a route that is not mounted answers 404
+ * regardless of auth, so the check is unaided and safe against a live host.
+ *
+ * @see spec/v2/core/versioning.md §1.2
+ * @see RFCS/0172-v2-versioning-and-release.md §A.1
+ */
+
+import { describe, it, expect } from 'vitest';
+import { loadEnv } from '../lib/env.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+
+const ID = 'openwop.requirement.0172.advertised-path-space-served';
+const DOC = 'spec/v2/core/versioning.md §1.2';
+
+/** The well-known resource is the one the HEADER selects; it has no /v1 twin to pair against. */
+const NOT_PAIRABLE = new Set(['/.well-known/openwop']);
+
+interface Probe { readonly status: number | null; readonly version: string | null; readonly html: boolean }
+
+async function get(path: string, major2: boolean): Promise<Probe> {
+  const { baseUrl, apiKey } = loadEnv();
+  const headers: Record<string, string> = { Accept: 'application/json' };
+  if (major2) headers['OpenWOP-Version'] = '2.0';
+  if (apiKey) headers['authorization'] = `Bearer ${apiKey}`;
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, { headers });
+    const ct = res.headers.get('content-type') ?? '';
+    return { status: res.status, version: res.headers.get('openwop-version'), html: /text\/html/i.test(ct) };
+  } catch {
+    return { status: null, version: null, html: false };
+  }
+}
+
+/**
+ * "Reached under major 2" is NOT "any status but 404". A hosting layer in
+ * front of the host answers every unrouted path with `200 text/html` — the
+ * SPA shell — and no `OpenWOP-Version` header, and that satisfied the first
+ * version of this check. Measured 2026-09-05 on a tier-1 host's public origin:
+ * `/.well-known/openwop` and `/v1/**` were rewritten to the backend and every
+ * unversioned major-2 path fell through to `index.html` with a 200, while the
+ * Cloud Run URL one hop behind answered every one correctly. The scenario was
+ * green on production for ten hours because a shell and a mount produced the
+ * same status code. `versioning.md` §1.4 requires `OpenWOP-Version` on every
+ * response; a response without it did not come from the host.
+ */
+function reachedUnderMajor2(p: Probe): boolean {
+  if (p.status === null || p.status === 404) return false;
+  if (p.version === null) return false;
+  if (p.html) return false;
+  return true;
+}
+
+function parameterlessGets(): string[] {
+  try {
+    const manifest = JSON.parse(
+      readFileSync(join(SCHEMAS_DIR, '..', 'spec', 'v2', 'path-manifest.json'), 'utf8'),
+    ) as { operations?: ReadonlyArray<{ method: string; path: string }> };
+    return (manifest.operations ?? [])
+      .filter((o) => o.method === 'GET' && !o.path.includes('{') && !NOT_PAIRABLE.has(o.path))
+      .map((o) => o.path)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+describe('v2-advertised-path-space-served (RFC 0172 §A.1)', () => {
+  it('a host advertising major 2 reaches the surfaces it already serves under /v1', async () => {
+    const { baseUrl } = loadEnv();
+    const bare = await (async () => {
+      try {
+        const res = await fetch(`${baseUrl.replace(/\/$/, '')}/.well-known/openwop`, { headers: { Accept: 'application/json' } });
+        return res.status === 200 ? ((await res.json()) as Record<string, unknown>) : null;
+      } catch {
+        return null;
+      }
+    })();
+    if (!bare) return softSkip('blocked', 'the discovery document is unreadable, so the advertised majors are unknown');
+
+    const versions = Array.isArray(bare['protocolVersions']) ? (bare['protocolVersions'] as unknown[]).map(String) : [];
+    if (!new Set(versions.map((v) => v.split('.')[0])).has('2')) {
+      return softSkip('inapplicable', `the host advertises [${versions.join(', ') || 'no protocolVersions'}] — it does not claim major 2, so there is no path space to hold it to`);
+    }
+
+    const paths = parameterlessGets();
+    if (paths.length === 0) return softSkip('blocked', 'spec/v2/path-manifest.json is unreadable from this layout');
+
+    const overstated: string[] = [];
+    const served: string[] = [];
+    let pairable = 0;
+    for (const path of paths) {
+      const v1 = await get(`/v1${path}`, false);
+      if (v1.status === null) return softSkip('blocked', `the host became unreachable while probing /v1${path}`);
+      // The host does not serve this surface in EITHER major. Legitimate, and a
+      // different question from the one asked here.
+      if (v1.status === 404) continue;
+      pairable += 1;
+
+      const v2 = await get(path, true);
+      if (v2.status === null) return softSkip('blocked', `the host became unreachable while probing ${path}`);
+      // 401/403/422 all answer "this path exists" and count as reached. A 404
+      // does not — and neither does a 200 that did not come from the host: no
+      // OpenWOP-Version header, or an HTML body, is a hosting fallback wearing
+      // a success code (see reachedUnderMajor2).
+      if (!reachedUnderMajor2(v2)) {
+        overstated.push(`${path} (/v1 → ${v1.status}, major 2 → ${v2.status}${v2.version === null ? ', no OpenWOP-Version header' : ''}${v2.html ? ', text/html body' : ''})`);
+      } else {
+        served.push(path);
+      }
+    }
+
+    if (pairable === 0) {
+      return softSkip('inapplicable', 'no parameterless GET in the v2 manifest is served under /v1 either, so there is no pair to compare and the advertisement cannot be checked this way');
+    }
+
+    expect(
+      overstated,
+      req(ID, DOC, `a host advertising major 2 MUST reach, under major 2, the surfaces it already serves under /v1 — advertising the major is a claim about the PATH SPACE and not only about the well-known resource, whose representation the header selects and which therefore passes even when almost nothing else is mounted (${overstated.length} of ${pairable} pairable surface(s) unreachable: ${overstated.slice(0, 6).join('; ')})`),
+    ).toEqual([]);
+
+    expect(
+      served.length,
+      req(ID, DOC, 'at least one non-well-known surface MUST be reachable under major 2, or the advertisement rests entirely on the one resource the header selects'),
+    ).toBeGreaterThan(0);
+  });
+});

package/src/scenarios/v2-assurance-downgrade-audited.test.ts

@@ -39,7 +39,7 @@ async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse
 async function gate(): Promise<{ floor: string } | { kind: 'blocked' | 'inapplicable'; reason: string }> {
   const doc = await discovery();
   if (!doc) return { kind: 'blocked', reason: 'v2 discovery unreachable — /.well-known/openwop did not answer 200 with a JSON body under OpenWOP-Version: 2.0' };
-  if (!seamsProfileAdvertised(doc)) return { kind: 'blocked', reason: 'seams profile not advertised (conformance.seamsProfile !== openwop-conformance-seams-v2) — the assurance floor is seam-gated' };
+  if (!seamsProfileAdvertised(doc)) return { kind: 'inapplicable', reason: 'seams profile not advertised (conformance.seamsProfile !== openwop-conformance-seams-v2) — the assurance floor is seam-gated' };
   const auth = await familyAdvertised('auth');
   const lanes = Array.isArray(auth?.['lanes']) ? (auth['lanes'] as Array<Record<string, unknown>>) : [];
   const workload = lanes.find((l) => l['lane'] === 'workload');