@openwop/openwop-conformance 2.44.9 → 2.45.1

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

@@ -37,7 +37,7 @@ import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { pollUntilStatus, pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 
 const FIXTURE =
   (isFixtureAdvertised('conformance-cancellable') && 'conformance-cancellable') ||
@@ -77,8 +77,13 @@ async function eventTypes(runId: string): Promise<string[]> {
   return Array.isArray(events) ? events.map((e) => String((e as { type?: unknown }).type)) : [];
 }
 
-describe.skipIf(SKIP)('pause/resume: running → paused → running → terminal', () => {
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!FIXTURE) ? ['blocked', `no candidate fixture for this scenario is advertised`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe('pause/resume: running → paused → running → terminal', () => {
   it('pause transitions to paused; resume returns the run to running', async () => {
+    if (SKIP) return softSkip(...GATE_WHY);
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
       // 3 s, not 30 s: the resumed node.started is a FRESH attempt (runs.md
@@ -125,8 +130,9 @@ describe.skipIf(SKIP)('pause/resume: running → paused → running → terminal
   });
 });
 
-describe.skipIf(SKIP)('pause/resume: :resume on a non-paused run returns 409', () => {
+describe('pause/resume: :resume on a non-paused run returns 409', () => {
   it('resuming a running (not paused) run returns 409 with details.runStatus', async () => {
+    if (SKIP) return softSkip(...GATE_WHY);
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
       inputs: { delayMs: 30_000 },
@@ -159,8 +165,9 @@ describe.skipIf(SKIP)('pause/resume: :resume on a non-paused run returns 409', (
   });
 });
 
-describe.skipIf(SKIP)('pause/resume: a second :pause is 409 without a matching Idempotency-Key and 202 with one', () => {
+describe('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 () => {
+    if (SKIP) return softSkip(...GATE_WHY);
     const create = await driver.post('/v1/runs', {
       workflowId: FIXTURE!,
       inputs: { delayMs: 30_000 },
@@ -220,8 +227,9 @@ describe.skipIf(SKIP)('pause/resume: a second :pause is 409 without a matching I
   });
 });
 
-describe.skipIf(SKIP)('pause/resume: :pause on a terminal run returns 409', () => {
+describe('pause/resume: :pause on a terminal run returns 409', () => {
   it(':pause on a completed/cancelled/failed run MUST return 409', async () => {
+    if (SKIP) return softSkip(...GATE_WHY);
     const create = await driver.post('/v1/runs', {
       workflowId: 'conformance-noop',
     });
@@ -244,8 +252,9 @@ describe.skipIf(SKIP)('pause/resume: :pause on a terminal run returns 409', () =
   });
 });
 
-describe.skipIf(SKIP)('pause/resume: drain-current-node lets the executing node reach a terminal first', () => {
+describe('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 () => {
+    if (SKIP) return softSkip(...GATE_WHY);
     // 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
@@ -283,8 +292,9 @@ describe.skipIf(SKIP)('pause/resume: drain-current-node lets the executing node
   });
 });
 
-describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
+describe('pause/resume: :pause-during-suspend race', () => {
   it(':pause MUST NOT silently override an active interrupt suspend', async () => {
+    if (SKIP) return softSkip(...GATE_WHY);
     // If the host seeds an approval fixture, drive a suspend then attempt
     // :pause. The expected behavior is that :pause either (a) noops with
     // 409 because the run is already waiting-approval (not in a pausable
@@ -339,8 +349,9 @@ describe.skipIf(SKIP)('pause/resume: :pause-during-suspend race', () => {
 // `capabilities.md` §`runs.pauseResume`. When a host advertises
 // `drainPolicies[]`, each advertised value MUST be accepted with 202.
 // Skips entirely when no advertisement is present.
-describe.skipIf(SKIP)('pause/resume: drainPolicy discrimination per capabilities advertisement', () => {
+describe('pause/resume: drainPolicy discrimination per capabilities advertisement', () => {
   it('every drainPolicy advertised by the host is accepted on :pause', async () => {
+    if (SKIP) return softSkip(...GATE_WHY);
     const disco = await driver.get('/.well-known/openwop');
     const drainPolicies =
       capabilityFamily<{ pauseResume?: { drainPolicies?: string[] } }>(disco.json, 'runs')

package/src/scenarios/prompt-all-four-kinds-events.test.ts

@@ -36,7 +36,7 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 
 const WORKFLOW_ID = 'conformance-prompt-all-four-kinds';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
@@ -79,8 +79,14 @@ async function readAllEvents(runId: string): Promise<RunEventDoc[]> {
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
-describe.skipIf(SKIP_NO_FIXTURE || HTTP_SKIP)('prompt-all-four-kinds-events: each PromptKind dispatches end-to-end (RFC 0027 §A)', () => {
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!process.env.OPENWOP_BASE_URL) ? ['inapplicable', `no target: OPENWOP_BASE_URL is unset`] as const : 
+  (!isFixtureAdvertised(WORKFLOW_ID)) ? ['blocked', `the \`${WORKFLOW_ID}\` fixture is not advertised`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe('prompt-all-four-kinds-events: each PromptKind dispatches end-to-end (RFC 0027 §A)', () => {
   it('emits agent.promptResolved + prompt.composed for system, user, schema-hint, and few-shot kinds', async () => {
+    if (SKIP_NO_FIXTURE || HTTP_SKIP) return softSkip(...GATE_WHY);
     const d = await readDiscovery();
     if (!behaviorGate('prompts-supported', promptsSupported(d))) return;
 
@@ -171,6 +177,7 @@ describe.skipIf(SKIP_NO_FIXTURE || HTTP_SKIP)('prompt-all-four-kinds-events: eac
   });
 
   it('emits the first agent.promptResolved before the first prompt.composed (resolution-precedes-composition ordering)', async () => {
+    if (SKIP_NO_FIXTURE || HTTP_SKIP) return softSkip(...GATE_WHY);
     const d = await readDiscovery();
     if (!behaviorGate('prompts-supported', promptsSupported(d))) return;
     const create = await driver.post('/v1/runs', { workflowId: WORKFLOW_ID });

package/src/scenarios/prompt-end-to-end-events.test.ts

@@ -36,7 +36,7 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { behaviorGate } from '../lib/behavior-gate.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 
 const WORKFLOW_ID = 'conformance-prompt-end-to-end';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
@@ -82,8 +82,14 @@ async function readAllEvents(runId: string): Promise<RunEventDoc[]> {
 
 const HTTP_SKIP = !process.env.OPENWOP_BASE_URL;
 
-describe.skipIf(SKIP_NO_FIXTURE || HTTP_SKIP)('prompt-end-to-end-events: real dispatch emits agent.promptResolved + prompt.composed (RFC 0027/0029)', () => {
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!process.env.OPENWOP_BASE_URL) ? ['inapplicable', `no target: OPENWOP_BASE_URL is unset`] as const : 
+  (!isFixtureAdvertised(WORKFLOW_ID)) ? ['blocked', `the \`${WORKFLOW_ID}\` fixture is not advertised`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe('prompt-end-to-end-events: real dispatch emits agent.promptResolved + prompt.composed (RFC 0027/0029)', () => {
   it('emits agent.promptResolved with chain[].applied: true for layer "node" when systemPromptRef is set on node.config', async () => {
+    if (SKIP_NO_FIXTURE || HTTP_SKIP) return softSkip(...GATE_WHY);
     const d = await readDiscovery();
     if (!behaviorGate('prompts-supported', promptsSupported(d))) return;
 
@@ -136,6 +142,7 @@ describe.skipIf(SKIP_NO_FIXTURE || HTTP_SKIP)('prompt-end-to-end-events: real di
   });
 
   it('emits prompt.composed with sha256:<hex64> hash + non-empty composed body for system-kind template', async () => {
+    if (SKIP_NO_FIXTURE || HTTP_SKIP) return softSkip(...GATE_WHY);
     const d = await readDiscovery();
     if (!behaviorGate('prompts-supported', promptsSupported(d))) return;
 
@@ -182,6 +189,7 @@ describe.skipIf(SKIP_NO_FIXTURE || HTTP_SKIP)('prompt-end-to-end-events: real di
   });
 
   it('emits agent.promptResolved before prompt.composed (causal ordering)', async () => {
+    if (SKIP_NO_FIXTURE || HTTP_SKIP) return softSkip(...GATE_WHY);
     const d = await readDiscovery();
     if (!behaviorGate('prompts-supported', promptsSupported(d))) return;
     const create = await driver.post('/v1/runs', { workflowId: WORKFLOW_ID });

package/src/scenarios/replay-fork-arbitrary.test.ts

@@ -30,7 +30,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
-import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions, type SoftSkipKind } from '../lib/soft-skip.js';
 import { forkDeclined } from '../lib/fork-availability.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
@@ -119,10 +119,15 @@ function structuralShape(
   }));
 }
 
-describe.skipIf(SKIP_NO_MULTI)(
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!isFixtureAdvertised(MULTI_NODE_WORKFLOW_ID)) ? ['blocked', `the \`${MULTI_NODE_WORKFLOW_ID}\` fixture is not advertised`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe(
   'replay-fork-arbitrary: fork from mid-range fromSeq in replay mode reaches terminal',
   () => {
     it('mid-fromSeq replay fork produces a new run that reaches `completed`', async (ctx) => {
+    if (SKIP_NO_MULTI) return softSkip(...GATE_WHY);
       const replay = await fetchReplayCapability();
       if (replay?.supported !== true) {
         softSkip('inapplicable', "host does not advertise `replay.supported: true` — the replay contract does not apply to it");
@@ -197,12 +202,13 @@ describe.skipIf(SKIP_NO_MULTI)(
   },
 );
 
-describe.skipIf(SKIP_NO_MULTI)(
+describe(
   'replay-fork-arbitrary: two replay forks at the same mid-range fromSeq yield identical event shape',
   () => {
     it(
       'mid-fromSeq determinism — same source + same fromSeq → identical post-fork events (modulo IDs + timestamps)',
       async (ctx) => {
+    if (SKIP_NO_MULTI) return softSkip(...GATE_WHY);
         const replay = await fetchReplayCapability();
         if (replay?.supported !== true) {
           ctx.skip();
@@ -294,10 +300,11 @@ describe.skipIf(SKIP_NO_MULTI)(
   },
 );
 
-describe.skipIf(SKIP_NO_MULTI)(
+describe(
   'replay-fork-arbitrary: fork from mid-range fromSeq in branch mode reaches terminal with overlay',
   () => {
     it('mid-fromSeq branch fork with empty overlay produces a new run that reaches `completed`', async (ctx) => {
+    if (SKIP_NO_MULTI) return softSkip(...GATE_WHY);
       const replay = await fetchReplayCapability();
       if (replay?.supported !== true) {
         softSkip('inapplicable', "host does not advertise `replay.supported: true` — the replay contract does not apply to it");

package/src/scenarios/restart-during-run.test.ts

@@ -37,6 +37,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { spawnHost, type SpawnedHost } from '../lib/multiProcess.js';
 import { req } from '../lib/requirement-ids.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 
 const HOST_PACKAGE_DIR =
   process.env.OPENWOP_RESTART_DURING_RUN_HOST_DIR ?? 'examples/hosts/sqlite';
@@ -78,12 +79,17 @@ afterEach(async () => {
   }
 });
 
-describe.skipIf(!RUN_THIS_SCENARIO)(
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!RUN_THIS_SCENARIO) ? ['skipped', `the operator did not opt in (OPENWOP_RUN_RESTART_DURING_RUN=1)`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe(
   'restart-during-run: SIGKILL + same-port restart resumes orphaned run',
   () => {
     it(
       'mid-run SIGKILL on the host process; restart at the same port + DB resumes to terminal',
       async () => {
+    if (!RUN_THIS_SCENARIO) return softSkip(...GATE_WHY);
         workdir = mkdtempSync(join(tmpdir(), 'openwop-restart-during-run-'));
         const dbPath = join(workdir, 'openwop-host.sqlite');
 

package/src/scenarios/secret-leakage-otel-attribute.test.ts

@@ -58,7 +58,7 @@ import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { capabilityFamily } from '../lib/discovery-capabilities.js';
 import { getCollector, waitForRunSpans } from '../lib/otel-collector.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 
 /**
  * Callback-shaped: the host exports OTLP spans to the suite's collector, which scans them for the BYOK canary.
@@ -102,10 +102,16 @@ async function startByokRun(): Promise<string | null> {
   return (create.json as { runId: string }).runId;
 }
 
-describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!process.env.OPENWOP_BASE_URL) ? ['inapplicable', `no target: OPENWOP_BASE_URL is unset`] as const : 
+  (!isFixtureAdvertised(BYOK_WORKFLOW_ID)) ? ['blocked', `the \`${BYOK_WORKFLOW_ID}\` fixture is not advertised`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe(
   'secret-leakage-otel-attribute: OTel span scrape (RFC 0034 §B)',
   () => {
     it('NO OTel span attribute MUST contain the BYOK canary plaintext for a run that resolved it', async (ctx) => {
+    if (HTTP_SKIP || FIXTURE_SKIP) return softSkip(...GATE_WHY);
       if (!CANARY_VALUE) {
         ctx.skip();
         return softSkip('blocked', 'precondition not met — `!CANARY_VALUE` returned early (seam, prior step, or fixture unavailable)');
@@ -171,10 +177,11 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
   },
 );
 
-describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
+describe(
   'secret-leakage-debug-bundle-otel: debug-bundle export scrape (RFC 0034 §B)',
   () => {
     it('NO debug-bundle field MUST contain the BYOK canary plaintext for a run that resolved it', async (ctx) => {
+    if (HTTP_SKIP || FIXTURE_SKIP) return softSkip(...GATE_WHY);
       if (!CANARY_VALUE) {
         ctx.skip();
         return softSkip('blocked', 'precondition not met — `!CANARY_VALUE` returned early (seam, prior step, or fixture unavailable)');
@@ -216,7 +223,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
   },
 );
 
-describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
+describe(
   'secret-leakage-otel-attribute: real OTLP export scrape (collector-side)',
   () => {
     // Distinct from the scrape-seam probe above: this asserts against what
@@ -228,6 +235,7 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
     // attributes" gap. Gated on the in-process collector being active
     // (`OPENWOP_OTEL_COLLECTOR=true` + the host configured to export to it).
     it('NO real-exported OTel span/metric attribute MUST contain the BYOK canary plaintext', async (ctx) => {
+    if (HTTP_SKIP || FIXTURE_SKIP) return softSkip(...GATE_WHY);
       const collector = getCollector();
       if (!collector || !CANARY_VALUE) {
         ctx.skip();
@@ -267,10 +275,11 @@ describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
   },
 );
 
-describe.skipIf(HTTP_SKIP || FIXTURE_SKIP)(
+describe(
   'secret-leakage-otel-attribute: advertisement-shape probe (RFC 0034 §A)',
   () => {
     it('when secrets.supported is true, observability.testSeams advertisements MUST be boolean if present', async (ctx) => {
+    if (HTTP_SKIP || FIXTURE_SKIP) return softSkip(...GATE_WHY);
       const d = await readDiscovery();
       if (capabilityFamily<{ supported?: unknown }>(d, 'secrets')?.supported !== true) {
         ctx.skip();

package/src/scenarios/stream-text-fixture.test.ts

@@ -32,7 +32,7 @@
  */
 
 import { describe, it, expect } from 'vitest';
-import { softSkip } from '../lib/soft-skip.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 import { driver, type OpenWOPResponse } from '../lib/driver.js';
 import { subscribe } from '../lib/sse.js';
 import { pollUntilTerminal } from '../lib/polling.js';
@@ -87,8 +87,13 @@ async function isStreamTextMockAdvertised(): Promise<boolean> {
   return Array.isArray(testing?.mockProviders) && testing.mockProviders.includes('stream-text');
 }
 
-describe.skipIf(SKIP_NO_FIXTURE)('stream-text-fixture: messages-mode fold through the stream-text mock (F1)', () => {
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!isFixtureAdvertised(FIXTURE_ID)) ? ['blocked', `the \`${FIXTURE_ID}\` fixture is not advertised`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe('stream-text-fixture: messages-mode fold through the stream-text mock (F1)', () => {
   it('delivers the mocked tokens in order, terminates with isLast + meta, and server-closes', async () => {
+    if (SKIP_NO_FIXTURE) return softSkip(...GATE_WHY);
     if (!(await isStreamTextMockAdvertised())) {
       // eslint-disable-next-line no-console
       console.warn(
@@ -191,6 +196,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('stream-text-fixture: messages-mode fold throug
   });
 
   it('an unknown mockProvider.id is rejected with 400 unsupported_mock_provider', async () => {
+    if (SKIP_NO_FIXTURE) return softSkip(...GATE_WHY);
     if (!(await isStreamTextMockAdvertised())) {
       // eslint-disable-next-line no-console
       console.warn('[stream-text-fixture] stream-text mock not advertised; skipping negative leg');

package/src/scenarios/streamReconnect.test.ts

@@ -22,7 +22,7 @@ import { subscribe, type SseEvent } from '../lib/sse.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { req } from '../lib/requirement-ids.js';
-import { softSkip, blockedDespiteAssertions } from '../lib/soft-skip.js';
+import { softSkip, blockedDespiteAssertions, type SoftSkipKind } from '../lib/soft-skip.js';
 
 const WORKFLOW_ID = 'conformance-cancellable';
 const SKIP_NO_FIXTURE = !isFixtureAdvertised(WORKFLOW_ID);
@@ -50,10 +50,15 @@ function getSeq(event: SseEvent): number | null {
   return null;
 }
 
-describe.skipIf(SKIP_NO_FIXTURE)('stream-reconnect: Last-Event-ID resume per spec/v1/stream-modes.md', () => {
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!isFixtureAdvertised(WORKFLOW_ID)) ? ['blocked', `the \`${WORKFLOW_ID}\` fixture is not advertised`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe('stream-reconnect: Last-Event-ID resume per spec/v1/stream-modes.md', () => {
   it(
     'reconnect with Last-Event-ID resumes without loss or duplication',
     async () => {
+    if (SKIP_NO_FIXTURE) return softSkip(...GATE_WHY);
       // Phase 1: kick off a long-running run.
       const create = await driver.post('/v1/runs', {
         workflowId: WORKFLOW_ID,
@@ -119,6 +124,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('stream-reconnect: Last-Event-ID resume per spe
   it(
     'reconnect with Last-Event-ID equal to terminal seq closes immediately',
     async () => {
+    if (SKIP_NO_FIXTURE) return softSkip(...GATE_WHY);
       // Quick run, observe terminal seq, then attempt a reconnect after
       // terminal — server SHOULD close immediately with no events.
       const create = await driver.post('/v1/runs', { workflowId: 'conformance-noop' });

package/src/scenarios/subworkflow.test.ts

@@ -21,6 +21,7 @@ import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
 import { req } from '../lib/requirement-ids.js';
+import { softSkip, type SoftSkipKind } from '../lib/soft-skip.js';
 
 const PARENT_WORKFLOW_ID = 'conformance-subworkflow-parent';
 const CHILD_WORKFLOW_ID = 'conformance-subworkflow-child';
@@ -44,8 +45,14 @@ interface RunEvent {
   readonly payload?: unknown;
 }
 
-describe.skipIf(SKIP_NO_FIXTURE)('subworkflow: conformance-subworkflow-parent dispatches child + completes', () => {
+/** Why the gate below holds, as RFC 0148 §A names it (openwop#1686: a describe-level skip recorded no disposition). */
+const GATE_WHY: readonly [SoftSkipKind, string] =
+  (!isFixtureAdvertised(PARENT_WORKFLOW_ID)) ? ['blocked', `the \`${PARENT_WORKFLOW_ID}\` fixture is not advertised`] as const : 
+  (!isFixtureAdvertised(CHILD_WORKFLOW_ID)) ? ['blocked', `the \`${CHILD_WORKFLOW_ID}\` fixture is not advertised`] as const : ['blocked', 'the gate held for no named reason'] as const;
+
+describe('subworkflow: conformance-subworkflow-parent dispatches child + completes', () => {
   it('parent run reaches terminal completed and child variable is propagated via outputMapping', async () => {
+    if (SKIP_NO_FIXTURE) return softSkip(...GATE_WHY);
     const create = await driver.post('/v1/runs', { workflowId: PARENT_WORKFLOW_ID });
     expect(create.status).toBe(201);
     const parentRunId = (create.json as { runId: string }).runId;
@@ -68,6 +75,7 @@ describe.skipIf(SKIP_NO_FIXTURE)('subworkflow: conformance-subworkflow-parent di
   });
 
   it('child run is created with parent linkage fields and reaches terminal completed', async () => {
+    if (SKIP_NO_FIXTURE) return softSkip(...GATE_WHY);
     const create = await driver.post('/v1/runs', { workflowId: PARENT_WORKFLOW_ID });
     const parentRunId = (create.json as { runId: string }).runId;
 

package/src/scenarios/v2-cors-preflight.test.ts

@@ -0,0 +1,141 @@
+/**
+ * `headers.md` §Cross-origin preflight — a host that grants an origin admits
+ * what a conforming browser client sends (suite 2.45.0, target major 2;
+ * openwop#1763; self-gated on the host's own grant).
+ *
+ * A browser client MUST send `OpenWOP-Version` and `OpenWOP-Client-Version` on
+ * every request (versioning.md §1.3, §1.5), `Authorization` on an
+ * authenticated operation and `Content-Type: application/json` with a body.
+ * None of them is CORS-safelisted, so the browser preflights. When the host
+ * grants the origin but leaves one out of `Access-Control-Allow-Headers`, the
+ * browser never sends the request: the operation is unreachable from that
+ * origin and the host's logs show nothing. Both production hosts shipped that
+ * outage with explicit lists: openwop-app on `OpenWOP-Version` (2026-09-18) and
+ * both on `OpenWOP-Client-Version` at the SDK 2.5.0 release (RFC 0219 G8).
+ *
+ * The admitted set per operation comes from `spec/v2/path-manifest.json`, which
+ * `derive-v2-api.py` writes from `api/v2/openapi.yaml`: the declared header
+ * parameters, plus `Authorization` when authenticated and `Content-Type` when
+ * the operation takes a body. For each operation the leg sends
+ * `OPTIONS <path>` (path parameters filled with a placeholder) with `Origin`,
+ * `Access-Control-Request-Method` and `Access-Control-Request-Headers`, and
+ * reads the answer the way the Fetch standard's CORS-preflight check does:
+ *
+ *   - granted: `Access-Control-Allow-Origin` is the origin or `*`. Anything
+ *     else and the host does not serve that origin: that operation is not
+ *     judged (a host MAY grant no origin at all; the rule is conditional).
+ *   - method: a CORS-safelisted method (GET, HEAD, POST) is admitted without
+ *     listing; any other must be listed, or `*` when credentials are not
+ *     allowed. Compared case-sensitively, as Fetch does.
+ *   - headers: every requested name listed (case-insensitive), or `*` when
+ *     credentials are not allowed, and `*` never admits `authorization`.
+ *
+ * The row passes when at least one operation was granted and every granted one
+ * admits its set, fails when any granted one does not (naming the operation and
+ * the missing names), and is `inapplicable` when no operation was granted. The
+ * origin is `OPENWOP_CORS_ORIGIN` (default `https://conformance.invalid`): a
+ * host with an allowlist is inapplicable at the default, and its operator sets
+ * an allowlisted origin to be witnessed. A pass carries an `observed:` detail.
+ *
+ * @see spec/v2/core/headers.md §Cross-origin preflight
+ */
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadEnv } from '../lib/env.js';
+import { v2Discovery } from '../lib/v2.js';
+import { softSkip } from '../lib/soft-skip.js';
+import { req } from '../lib/requirement-ids.js';
+import { noteObservation } from '../lib/row-observation.js';
+import { SCHEMAS_DIR } from '../lib/paths.js';
+
+const ID = 'openwop.requirement.headers.cors-preflight-admits';
+const DOC = 'spec/v2/core/headers.md §Cross-origin preflight';
+const ORIGIN_ENV = 'OPENWOP_CORS_ORIGIN';
+const DEFAULT_ORIGIN = 'https://conformance.invalid';
+/** Fetch standard: a CORS-safelisted method passes the preflight method check without being listed. */
+const SAFELISTED_METHODS = new Set(['GET', 'HEAD', 'POST']);
+const PLACEHOLDER = 'conformance-cors-probe';
+
+interface ManifestOp { readonly method: string; readonly path: string; readonly operationId: string; readonly requestHeaders?: readonly string[]; readonly authenticated?: boolean; readonly requestBody?: boolean }
+interface Preflight { readonly status: number | null; readonly allowOrigin: string | null; readonly allowMethods: string | null; readonly allowHeaders: string | null; readonly allowCredentials: string | null }
+
+function operations(): ManifestOp[] | null {
+  try {
+    const manifest = JSON.parse(readFileSync(join(SCHEMAS_DIR, '..', 'spec', 'v2', 'path-manifest.json'), 'utf8')) as { operations?: ManifestOp[] };
+    const ops = manifest.operations ?? [];
+    return ops.length > 0 && ops.every((o) => Array.isArray(o.requestHeaders) && typeof o.authenticated === 'boolean' && typeof o.requestBody === 'boolean') ? ops : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The names a conforming browser client puts in Access-Control-Request-Headers for this operation, lowercased. */
+export function requestedHeaders(op: ManifestOp): string[] {
+  const names = new Set((op.requestHeaders ?? []).map((h) => h.toLowerCase()));
+  if (op.authenticated === true) names.add('authorization');
+  if (op.requestBody === true) names.add('content-type');
+  return [...names].sort();
+}
+
+const tokens = (v: string | null): string[] => (v ?? '').split(',').map((t) => t.trim()).filter((t) => t.length > 0);
+
+/** What the preflight answer fails to admit, per the Fetch standard's CORS-preflight check; empty when it admits everything. */
+export function unadmitted(op: ManifestOp, p: Preflight): { method: string | null; headers: string[] } {
+  const credentials = p.allowCredentials === 'true';
+  const methods = tokens(p.allowMethods);
+  const methodOk = SAFELISTED_METHODS.has(op.method) || methods.includes(op.method) || (!credentials && methods.includes('*'));
+  const listed = new Set(tokens(p.allowHeaders).map((h) => h.toLowerCase()));
+  const star = !credentials && listed.has('*');
+  const headers = requestedHeaders(op).filter((h) => !listed.has(h) && !(star && h !== 'authorization'));
+  return { method: methodOk ? null : op.method, headers };
+}
+
+async function preflight(baseUrl: string, op: ManifestOp, origin: string): Promise<Preflight> {
+  const path = op.path.replace(/\{[^}]+\}/g, PLACEHOLDER);
+  try {
+    const res = await fetch(`${baseUrl.replace(/\/$/, '')}${path}`, {
+      method: 'OPTIONS',
+      headers: { Origin: origin, 'Access-Control-Request-Method': op.method, 'Access-Control-Request-Headers': requestedHeaders(op).join(',') },
+    });
+    await res.arrayBuffer().catch(() => undefined);
+    const h = res.headers;
+    return { status: res.status, allowOrigin: h.get('access-control-allow-origin'), allowMethods: h.get('access-control-allow-methods'), allowHeaders: h.get('access-control-allow-headers'), allowCredentials: h.get('access-control-allow-credentials') };
+  } catch {
+    return { status: null, allowOrigin: null, allowMethods: null, allowHeaders: null, allowCredentials: null };
+  }
+}
+
+describe('headers.md §Cross-origin preflight (self-gated on the host granting the origin)', () => {
+  it('every operation a granted origin preflights admits its method and every request header the contract declares for it', async () => {
+    if (!(await v2Discovery())) return softSkip('blocked', 'v2 discovery unreachable');
+    const ops = operations();
+    if (ops === null) return softSkip('blocked', 'spec/v2/path-manifest.json carries no per-operation requestHeaders / authenticated / requestBody (a corpus older than openwop#1763), so the admitted sets cannot be derived');
+    const origin = process.env[ORIGIN_ENV]?.trim() || DEFAULT_ORIGIN;
+    const { baseUrl } = loadEnv();
+
+    const granted: string[] = [];
+    const failures: string[] = [];
+    for (const op of ops) {
+      const p = await preflight(baseUrl, op, origin);
+      if (p.allowOrigin !== origin && p.allowOrigin !== '*') continue;
+      granted.push(op.operationId);
+      const miss = unadmitted(op, p);
+      if (miss.method !== null || miss.headers.length > 0) {
+        const parts = [
+          ...(miss.method === null ? [] : [`method ${miss.method} not in Access-Control-Allow-Methods (${JSON.stringify(p.allowMethods)})`]),
+          ...(miss.headers.length === 0 ? [] : [`${miss.headers.join(', ')} not in Access-Control-Allow-Headers (${JSON.stringify(p.allowHeaders)}${p.allowCredentials === 'true' ? ', credentials allowed so * admits nothing' : ''})`]),
+        ];
+        failures.push(`${op.operationId} (${op.method} ${op.path}): ${parts.join('; ')}`);
+      }
+    }
+    noteObservation(`origin ${origin}: ${granted.length}/${ops.length} operation(s) granted, ${failures.length} not admitting their set`);
+    if (granted.length === 0) {
+      return softSkip('inapplicable', `no operation's preflight granted origin ${origin} (Access-Control-Allow-Origin neither it nor *): the host does not serve that origin cross-origin, which is host policy. An operator whose host allowlists origins sets ${ORIGIN_ENV} to one of them to be witnessed`);
+    }
+    expect(
+      failures,
+      req(ID, DOC, `a host that grants an origin MUST admit, per operation, its method and every request header api/v2/openapi.yaml declares for it, Authorization when authenticated and Content-Type with a body; a browser that is refused never sends the request. ${failures.length} of ${granted.length} granted operation(s) do not: ${failures.join(' | ')}`),
+    ).toEqual([]);
+  });
+});

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

@@ -21,10 +21,13 @@ import { gateFamily, 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';
+import { walkRunList, type FetchPage, type RunListPage, type WalkResult } from '../lib/run-list-walk.js';
 
 const DOC = 'spec/v2/core/runs.md §List';
 const NOOP_WORKFLOW_ID = 'conformance-noop';
 const MAX_PAGES = 50;
+/** Pages still followed after the created runs are seen, so a host-minted cursor is exercised. */
+const TAIL_PAGES = 2;
 
 async function http(fn: () => Promise<OpenWOPResponse>): Promise<OpenWOPResponse | null> {
   try { return await fn(); } catch { return null; }
@@ -40,22 +43,16 @@ async function createRun(): Promise<{ runId: string } | { reason: string }> {
 
 function tenantOf(runId: string): string { return runId.slice(0, runId.indexOf('/')); }
 
-type Page = { runs?: unknown; nextCursor?: unknown };
-
-/** Walk the list from the first page, collecting run ids, until the last page or MAX_PAGES. */
-async function walk(query: string, maxPageSize: number): Promise<{ ids: string[]; pages: Page[]; reason?: string }> {
-  const ids: string[] = []; const pages: Page[] = []; let cursor: string | undefined;
-  for (let i = 0; i < MAX_PAGES; i++) {
+/** The newest-first, stop-when-found walk (`lib/run-list-walk.ts`) over this host's `GET /runs`. */
+async function walk(query: string, maxPageSize: number, want: string[]): Promise<WalkResult> {
+  const fetchPage: FetchPage = async (cursor) => {
     const q = `${query}${query ? '&' : '?'}limit=${maxPageSize}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ''}`;
     const res = await http(() => driver.get(`/runs${q}`));
-    if (res === null) return { ids, pages, reason: `GET /runs${q} unreachable (fetch failed)` };
-    if (res.status !== 200) return { ids, pages, reason: `GET /runs${q} answered ${res.status} ${readErrorCode(res.json) ?? ''}` };
-    const page = res.json as Page; pages.push(page);
-    for (const r of Array.isArray(page.runs) ? page.runs : []) { const id = (r as { runId?: unknown }).runId; if (typeof id === 'string') ids.push(id); }
-    if (typeof page.nextCursor !== 'string') break;
-    cursor = page.nextCursor;
-  }
-  return { ids, pages };
+    if (res === null) return { reason: `GET /runs${q} unreachable (fetch failed)` };
+    if (res.status !== 200) return { reason: `GET /runs${q} answered ${res.status} ${readErrorCode(res.json) ?? ''}` };
+    return { page: res.json as RunListPage };
+  };
+  return walkRunList(fetchPage, { want, maxPages: MAX_PAGES, tailPages: TAIL_PAGES });
 }
 
 describe('RFC 0182 — run-list (gated on runList)', () => {
@@ -68,7 +65,7 @@ describe('RFC 0182 — run-list (gated on runList)', () => {
     const a = await createRun(); if ('reason' in a) return softSkip('blocked', a.reason);
     const b = await createRun(); if ('reason' in b) return softSkip('blocked', b.reason);
     const tenant = tenantOf(a.runId);
-    const walked = await walk('', maxPageSize);
+    const walked = await walk('', maxPageSize, [a.runId, b.runId]);
     if (walked.reason && walked.pages.length === 0) return softSkip('blocked', walked.reason);
     const validate = v2Validator('run-list-response');
     for (const page of walked.pages) {
@@ -77,6 +74,7 @@ describe('RFC 0182 — run-list (gated on runList)', () => {
       expect((page.runs as unknown[]).length <= maxPageSize, req('openwop.requirement.0182.run-list.tenant-scoped', DOC, `a page MUST NOT exceed the advertised runList.maxPageSize (${maxPageSize}); got ${(page.runs as unknown[]).length}`)).toBe(true);
     }
     expect(walked.ids.includes(a.runId) && walked.ids.includes(b.runId), req('openwop.requirement.0182.run-list.tenant-scoped', DOC, `a run the caller just created MUST appear in its unfiltered list — created ${a.runId} and ${b.runId}; walked ${walked.ids.length} id(s) over ${walked.pages.length} page(s)${walked.reason ? ` (${walked.reason})` : ''}`)).toBe(true);
+    expect(walked.ids.indexOf(b.runId) < walked.ids.indexOf(a.runId), req('openwop.requirement.0182.run-list.tenant-scoped', DOC, `the list MUST be newest first — ${b.runId} was created after ${a.runId}, so it MUST be listed before it`)).toBe(true);
     const foreign = walked.ids.filter((id) => tenantOf(id) !== tenant);
     expect(foreign, req('openwop.requirement.0182.run-list.tenant-scoped', 'spec/v2/core/identity.md §5', `every runId in the list MUST carry the caller's tenant segment (${tenant}) — the list is tenant-scoped by construction; found ${foreign.length} other(s): ${foreign.slice(0, 3).join(', ')}`)).toEqual([]);
   });
@@ -98,7 +96,7 @@ describe('RFC 0182 — run-list (gated on runList)', () => {
     if (!filters.includes('workflowId')) return softSkip('inapplicable', 'runList.filters does not name workflowId — the filter leg has no obligation');
     const maxPageSize = typeof fam['maxPageSize'] === 'number' ? fam['maxPageSize'] : 1;
     const c = await createRun(); if ('reason' in c) return softSkip('blocked', c.reason);
-    const walked = await walk(`?workflowId=${encodeURIComponent(NOOP_WORKFLOW_ID)}`, maxPageSize);
+    const walked = await walk(`?workflowId=${encodeURIComponent(NOOP_WORKFLOW_ID)}`, maxPageSize, [c.runId]);
     if (walked.reason && walked.pages.length === 0) return softSkip('blocked', walked.reason);
     const others = walked.pages.flatMap((p) => (Array.isArray(p.runs) ? p.runs : [])).filter((r) => (r as { workflowId?: unknown }).workflowId !== NOOP_WORKFLOW_ID);
     expect(others.length, req('openwop.requirement.0182.run-list.filter-exact', DOC, `a workflowId filter MUST be exact — every listed run's workflowId MUST equal ${NOOP_WORKFLOW_ID}; found ${others.length} other(s)`)).toBe(0);