@openwop/openwop-conformance 1.2.0 → 1.3.0

package/src/scenarios/dispatch-output-mapping.test.ts

@@ -55,11 +55,101 @@ describe.skipIf(SKIP)('dispatch-output-mapping: child → parent variable harves
     )).toBe('done');
   });
 
-  it.todo(
-    'HVMAP-1b-failed: child terminates with `failed` status; outputMapping MUST be skipped; parent variables stay at pre-dispatch state for that child. Requires a child fixture that fails deterministically.',
-  );
+});
+
+interface RunEvent { readonly type: string; readonly nodeId?: string; readonly payload?: { childRunId?: string; childWorkflowId?: string } & Record<string, unknown>; }
+
+/** Register a parent workflow that dispatches to a specific child fixture
+ *  with outputMapping. Returns the registered parent's workflowId.
+ *  The parent declares `parentResult` with a sentinel default so the
+ *  test can verify it stayed at the sentinel (NOT overwritten by
+ *  outputMapping) when the child terminates non-completed. */
+async function registerParent(childFixtureId: string): Promise<string | null> {
+  const workflowId = `hvmap-1b-${childFixtureId.replace(/[^a-zA-Z0-9_.-]/g, '-')}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const def = {
+    workflowId,
+    nodes: [
+      {
+        nodeId: 'supervisor',
+        typeId: 'core.orchestrator.supervisor',
+        config: {
+          mockDispatchPlan: [
+            { kind: 'next-worker', nextWorkerIds: [childFixtureId] },
+            { kind: 'terminate', reason: 'goal-reached' },
+          ],
+        },
+      },
+      {
+        nodeId: 'dispatch',
+        typeId: 'core.dispatch',
+        config: {
+          askUserRouting: 'auto',
+          workerDispatchModel: 'child-run',
+          fanOutPolicy: 'sequential',
+          outputMapping: { parentResult: 'childOutcome' },
+        },
+      },
+    ],
+  };
+  const res = await driver.post('/v1/host/sample/workflows', def);
+  if (res.status !== 201) return null;
+  return workflowId;
+}
+
+describe.skipIf(!isFixtureAdvertised('conformance-dispatch-deterministic-fail-child'))('dispatch-output-mapping: HVMAP-1b-failed (RFC 0022 §B)', () => {
+  it('child terminates `failed` → outputMapping MUST be skipped; parent.parentResult stays at sentinel', async () => {
+    const parentId = await registerParent('conformance-dispatch-deterministic-fail-child');
+    if (!parentId) return; // workflow-register seam not exposed — soft-skip
+    const create = await driver.post('/v1/runs', { workflowId: parentId });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
+    const terminal = (await pollUntilTerminal(parentRunId)) as RunSnapshot & { variables?: Record<string, unknown> };
+    // Parent reaches some terminal state (completed if it tolerates failed children + supervisor terminates; failed if not).
+    // Either way, parentResult MUST NOT be overwritten with the child's "this-should-not-be-harvested" sentinel.
+    const parentVars = terminal.variables ?? {};
+    expect(
+      parentVars.parentResult,
+      driver.describe(
+        'RFCS/0022-dispatch-input-output-mapping.md §B',
+        'outputMapping MUST be SKIPPED when child terminates failed; parent variable MUST NOT be overwritten',
+      ),
+    ).not.toBe('this-should-not-be-harvested');
+  });
+});
 
-  it.todo(
-    'HVMAP-1b-cancelled: child terminates with `cancelled` status; outputMapping MUST be skipped; parent variables stay at pre-dispatch state for that child. Requires a child fixture that supports external cancellation.',
-  );
+describe.skipIf(!isFixtureAdvertised('conformance-dispatch-cancellable-child'))('dispatch-output-mapping: HVMAP-1b-cancelled (RFC 0022 §B)', () => {
+  it('child terminates `cancelled` → outputMapping MUST be skipped; parent.parentResult stays at sentinel', async () => {
+    const parentId = await registerParent('conformance-dispatch-cancellable-child');
+    if (!parentId) return; // soft-skip
+    const create = await driver.post('/v1/runs', { workflowId: parentId });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
+
+    // Poll for the node.dispatched event so we can cancel the child mid-flight.
+    const start = Date.now();
+    let childRunId: string | undefined;
+    while (Date.now() - start < 10_000) {
+      const eventsRes = await driver.get(`/v1/runs/${encodeURIComponent(parentRunId)}/events`);
+      const events = ((eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? []);
+      const dispatched = events.find((e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === 'conformance-dispatch-cancellable-child');
+      if (dispatched?.payload?.childRunId) {
+        childRunId = dispatched.payload.childRunId;
+        break;
+      }
+      await new Promise((r) => setTimeout(r, 250));
+    }
+    if (!childRunId) return; // dispatch didn't surface child run id — soft-skip
+    const cancelRes = await driver.post(`/v1/runs/${encodeURIComponent(childRunId)}/cancel`, { reason: 'hvmap-1b-cancelled test' });
+    expect(cancelRes.status === 200 || cancelRes.status === 202).toBe(true);
+
+    const terminal = (await pollUntilTerminal(parentRunId)) as RunSnapshot & { variables?: Record<string, unknown> };
+    const parentVars = terminal.variables ?? {};
+    expect(
+      parentVars.parentResult,
+      driver.describe(
+        'RFCS/0022-dispatch-input-output-mapping.md §B',
+        'outputMapping MUST be SKIPPED when child terminates cancelled; parent variable MUST NOT be overwritten',
+      ),
+    ).not.toBe('this-should-not-be-harvested');
+  });
 });

package/src/scenarios/fixtures-gating.test.ts

@@ -18,7 +18,7 @@
  * @see RFCS/0003-fixture-gating.md
  */
 
-import { describe, it, expect, beforeEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import {
   isFixtureAdvertised,
   setAdvertisedFixtures,
@@ -26,6 +26,7 @@ import {
   isFixtureCacheReady,
   __resetForTests,
 } from '../lib/fixtures.js';
+import { isScenarioOptedOut } from '../lib/env.js';
 
 beforeEach(() => {
   __resetForTests();
@@ -135,3 +136,140 @@ describe('fixtures: __resetForTests', () => {
     expect(getAdvertisedFixtures()).toBe(null);
   });
 });
+
+describe('fixtures: OPENWOP_OPTED_OUT_FIXTURES env filtering', () => {
+  // The opt-out predicate is re-read inside setAdvertisedFixtures() on
+  // every call, so mutating process.env between cases (and re-calling
+  // setAdvertisedFixtures) re-evaluates the parse. afterEach restores
+  // the original env so other suites aren't affected.
+  const ORIGINAL = process.env.OPENWOP_OPTED_OUT_FIXTURES;
+  afterEach(() => {
+    if (ORIGINAL === undefined) delete process.env.OPENWOP_OPTED_OUT_FIXTURES;
+    else process.env.OPENWOP_OPTED_OUT_FIXTURES = ORIGINAL;
+  });
+
+  it('exact id is filtered out of the advertised set', () => {
+    process.env.OPENWOP_OPTED_OUT_FIXTURES = 'conformance-dispatch-input-mapping';
+    setAdvertisedFixtures({
+      fixtures: ['conformance-noop', 'conformance-dispatch-input-mapping'],
+    });
+    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-dispatch-input-mapping')).toBe(false);
+  });
+
+  it('trailing-* glob filters every matching id', () => {
+    process.env.OPENWOP_OPTED_OUT_FIXTURES = 'conformance-dispatch-*';
+    setAdvertisedFixtures({
+      fixtures: [
+        'conformance-noop',
+        'conformance-dispatch-input-mapping',
+        'conformance-dispatch-output-mapping',
+        'conformance-dispatch-cross-worker-handoff',
+      ],
+    });
+    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-dispatch-input-mapping')).toBe(false);
+    expect(isFixtureAdvertised('conformance-dispatch-output-mapping')).toBe(false);
+    expect(isFixtureAdvertised('conformance-dispatch-cross-worker-handoff')).toBe(false);
+  });
+
+  it('exact + glob entries mix in one env value', () => {
+    process.env.OPENWOP_OPTED_OUT_FIXTURES =
+      'conformance-dispatch-*,conformance-subworkflow-input-mapping';
+    setAdvertisedFixtures({
+      fixtures: [
+        'conformance-noop',
+        'conformance-dispatch-input-mapping',
+        'conformance-subworkflow-input-mapping',
+        'conformance-subworkflow-parent',
+      ],
+    });
+    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-dispatch-input-mapping')).toBe(false);
+    expect(isFixtureAdvertised('conformance-subworkflow-input-mapping')).toBe(false);
+    // subworkflow-parent is NOT subworkflow-input-mapping — exact match required.
+    expect(isFixtureAdvertised('conformance-subworkflow-parent')).toBe(true);
+  });
+
+  it('non-matching opt-out entries leave the advertised set intact', () => {
+    process.env.OPENWOP_OPTED_OUT_FIXTURES = 'conformance-nonexistent';
+    setAdvertisedFixtures({ fixtures: ['conformance-noop'] });
+    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(getAdvertisedFixtures()?.size).toBe(1);
+  });
+
+  it('empty / whitespace-only entries are ignored', () => {
+    process.env.OPENWOP_OPTED_OUT_FIXTURES = ', ,conformance-noop, ,';
+    setAdvertisedFixtures({ fixtures: ['conformance-noop', 'conformance-delay'] });
+    expect(isFixtureAdvertised('conformance-noop')).toBe(false);
+    expect(isFixtureAdvertised('conformance-delay')).toBe(true);
+  });
+
+  it('unset env behaves identically to no filtering', () => {
+    delete process.env.OPENWOP_OPTED_OUT_FIXTURES;
+    setAdvertisedFixtures({ fixtures: ['conformance-noop', 'conformance-delay'] });
+    expect(getAdvertisedFixtures()?.size).toBe(2);
+  });
+
+  it('whitespace-only env behaves identically to unset', () => {
+    process.env.OPENWOP_OPTED_OUT_FIXTURES = '   ';
+    setAdvertisedFixtures({ fixtures: ['conformance-noop'] });
+    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+  });
+
+  it('env is re-read on each setAdvertisedFixtures call (no memoization)', () => {
+    process.env.OPENWOP_OPTED_OUT_FIXTURES = 'conformance-noop';
+    setAdvertisedFixtures({ fixtures: ['conformance-noop', 'conformance-delay'] });
+    expect(isFixtureAdvertised('conformance-noop')).toBe(false);
+
+    // Mutate env and re-set — the new env value MUST take effect.
+    process.env.OPENWOP_OPTED_OUT_FIXTURES = 'conformance-delay';
+    setAdvertisedFixtures({ fixtures: ['conformance-noop', 'conformance-delay'] });
+    expect(isFixtureAdvertised('conformance-noop')).toBe(true);
+    expect(isFixtureAdvertised('conformance-delay')).toBe(false);
+  });
+});
+
+describe('env: OPENWOP_OPTED_OUT_SCENARIOS predicate', () => {
+  const ORIGINAL = process.env.OPENWOP_OPTED_OUT_SCENARIOS;
+  afterEach(() => {
+    if (ORIGINAL === undefined) delete process.env.OPENWOP_OPTED_OUT_SCENARIOS;
+    else process.env.OPENWOP_OPTED_OUT_SCENARIOS = ORIGINAL;
+  });
+
+  it('unset env → every scenario id returns false', () => {
+    delete process.env.OPENWOP_OPTED_OUT_SCENARIOS;
+    expect(isScenarioOptedOut('otel-trace-propagation-subworkflow')).toBe(false);
+    expect(isScenarioOptedOut('any-scenario')).toBe(false);
+  });
+
+  it('exact scenario id match returns true', () => {
+    process.env.OPENWOP_OPTED_OUT_SCENARIOS = 'otel-trace-propagation-subworkflow';
+    expect(isScenarioOptedOut('otel-trace-propagation-subworkflow')).toBe(true);
+    expect(isScenarioOptedOut('otel-trace-propagation')).toBe(false);
+  });
+
+  it('CSV with multiple ids matches each entry exactly', () => {
+    process.env.OPENWOP_OPTED_OUT_SCENARIOS = 'scenario-a,scenario-b,scenario-c';
+    expect(isScenarioOptedOut('scenario-a')).toBe(true);
+    expect(isScenarioOptedOut('scenario-b')).toBe(true);
+    expect(isScenarioOptedOut('scenario-c')).toBe(true);
+    expect(isScenarioOptedOut('scenario-d')).toBe(false);
+  });
+
+  it('whitespace around entries is tolerated', () => {
+    process.env.OPENWOP_OPTED_OUT_SCENARIOS = '  scenario-a , scenario-b  ';
+    expect(isScenarioOptedOut('scenario-a')).toBe(true);
+    expect(isScenarioOptedOut('scenario-b')).toBe(true);
+  });
+
+  it('env is re-read on each call (no memoization)', () => {
+    process.env.OPENWOP_OPTED_OUT_SCENARIOS = 'scenario-a';
+    expect(isScenarioOptedOut('scenario-a')).toBe(true);
+    expect(isScenarioOptedOut('scenario-b')).toBe(false);
+
+    process.env.OPENWOP_OPTED_OUT_SCENARIOS = 'scenario-b';
+    expect(isScenarioOptedOut('scenario-a')).toBe(false);
+    expect(isScenarioOptedOut('scenario-b')).toBe(true);
+  });
+});

package/src/scenarios/kv-ttl-expiry.test.ts

@@ -42,6 +42,37 @@ describe('kv-ttl-expiry: advertisement shape (RFC 0015)', () => {
   });
 });
 
-describe('kv-ttl-expiry: behavioral assertions (placeholders — need host test seam)', () => {
-  it.todo("set with ttl=2 → get at t+1 returns the value; get at t+3 returns not-found");
+async function call(op: string, args: Record<string, unknown>) {
+  return driver.post('/v1/host/sample/test/surface', { tenantId: 'tenant-a', surface: 'kv', op, args });
+}
+
+describe('kv-ttl-expiry: behavioral (RFC 0015 §B point 3 — 1s TTL drift)', () => {
+  it('set with ttlSeconds=2 → get before expiry returns value; get after expiry returns found:false', async () => {
+    const probe = await call('get', { key: '__ttl-probe__' });
+    if (probe.status === 404) return; // host doesn't expose the seam
+    const key = `ttl-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const setRes = await call('set', { key, value: 'expires-soon', ttlSeconds: 2 });
+    expect(setRes.status).toBe(200);
+
+    // Read within the window
+    const within = await call('get', { key });
+    expect(within.status).toBe(200);
+    const withinBody = within.json as { value?: unknown; found?: boolean };
+    expect(
+      withinBody.value,
+      driver.describe('RFC 0015 §B point 3', 'get within TTL window MUST return the stored value'),
+    ).toBe('expires-soon');
+    expect(withinBody.found).toBe(true);
+
+    // Wait past expiry (2s TTL + 1s drift allowance per RFC 0015 §B point 3)
+    await new Promise((r) => setTimeout(r, 3000));
+
+    const after = await call('get', { key });
+    expect(after.status).toBe(200);
+    const afterBody = after.json as { value?: unknown; found?: boolean };
+    expect(
+      afterBody.found,
+      driver.describe('RFC 0015 §B point 3', 'get after TTL expiry MUST surface as found:false (≤1s drift)'),
+    ).toBe(false);
+  });
 });

package/src/scenarios/otel-trace-propagation-subworkflow.test.ts

@@ -23,6 +23,10 @@
  *   - Host doesn't advertise `capabilities.observability`.
  *   - `conformance-subworkflow-parent` fixture not advertised (host
  *     doesn't implement `core.subWorkflow`).
+ *   - `OPENWOP_OPTED_OUT_SCENARIOS` contains
+ *     `otel-trace-propagation-subworkflow` — host claims
+ *     observability + subWorkflow but explicitly does NOT propagate
+ *     traceparent across the dispatch boundary.
  *
  * @see spec/v1/observability.md §"Trace context propagation"
  * @see spec/v1/node-packs.md §`core.subWorkflow`
@@ -33,9 +37,11 @@ import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
 import { pollUntilTerminal } from '../lib/polling.js';
 import { isFixtureAdvertised } from '../lib/fixtures.js';
+import { isScenarioOptedOut } from '../lib/env.js';
 import { getCollector, waitForRunSpans } from '../lib/otel-collector.js';
 
 const PARENT_FIXTURE = 'conformance-subworkflow-parent';
+const SCENARIO_ID = 'otel-trace-propagation-subworkflow';
 
 interface RunEvent {
   type: string;
@@ -64,6 +70,19 @@ async function isObservabilityAdvertised(): Promise<boolean> {
 
 describe('otel-trace-propagation-subworkflow: traceparent threads parent → child via core.subWorkflow', () => {
   it('child run spans inherit the parent run\'s inbound traceId', async () => {
+    if (isScenarioOptedOut(SCENARIO_ID)) {
+      // Host operator has declared this scenario opted-out via
+      // `OPENWOP_OPTED_OUT_SCENARIOS`. Used when the host advertises
+      // `conformance-subworkflow-parent` (correctly — non-OTel
+      // subworkflow scenarios pass) AND observability (for audit-log
+      // integrity), but doesn't propagate traceparent across the
+      // `core.subWorkflow` dispatch boundary. Fixture-opt-out would
+      // be too coarse (kills passing non-OTel subworkflow tests);
+      // capability-opt-out would lie about observability claims.
+      // eslint-disable-next-line no-console
+      console.warn(`[${SCENARIO_ID}] scenario opted out via OPENWOP_OPTED_OUT_SCENARIOS; skipping`);
+      return;
+    }
     if (!getCollector()) {
       // eslint-disable-next-line no-console
       console.warn('[otel-trace-propagation-subworkflow] collector not started; skipping');