@openwop/openwop-conformance 1.1.1 → 1.3.0

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

@@ -0,0 +1,73 @@
+/**
+ * cache-ttl-expiry — RFC 0019 advertisement-shape verification + behavioral placeholders.
+ *
+ * Status: ACTIVE (advertisement-shape). RFC 0019 promoted to `Active`
+ * 2026-05-17. The matching `capabilities.cache` block has landed in
+ * `schemas/capabilities.schema.json`. This scenario asserts the advertisement
+ * shape against any host that boots the conformance suite, and keeps the
+ * deeper behavioral assertions as `it.todo()` until a reference host wires
+ * a test seam.
+ *
+ * Summary: Cache TTL honored with at most 1-second drift.
+ *
+ * @see RFCS/0019-*.md
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+
+interface DiscoveryDoc {
+  capabilities?: Record<string, unknown>;
+}
+
+async function readCap(): Promise<Record<string, unknown> | null> {
+  const res = await driver.get('/.well-known/openwop');
+  const body = res.json as DiscoveryDoc | undefined;
+  const top = body?.capabilities as Record<string, unknown> | undefined;
+  const final = (top && typeof top === 'object') ? (top as Record<string, unknown>)["cache"] : undefined;
+  return (final && typeof final === 'object' ? (final as Record<string, unknown>) : null);
+}
+
+describe('cache-ttl-expiry: advertisement shape (RFC 0019)', () => {
+  it('capabilities.cache is either absent or a well-formed object', async () => {
+    const cap = await readCap();
+    if (cap === null) return; // host doesn't advertise — skip
+    expect(
+      typeof cap.supported,
+      driver.describe(
+        'capabilities.schema.json §cache',
+        'capabilities.cache.supported MUST be a boolean when present',
+      ),
+    ).toBe('boolean');
+  });
+});
+
+async function call(op: string, args: Record<string, unknown>) {
+  return driver.post('/v1/host/sample/test/surface', { tenantId: 'tenant-a', surface: 'cache', op, args });
+}
+
+describe('cache-ttl-expiry: behavioral (RFC 0019 §B point 2 — 1s TTL drift)', () => {
+  it('put with ttlSeconds=2 → hit within window; miss after expiry', async () => {
+    const probe = await call('get', { key: '__cache-probe__' });
+    if (probe.status === 404) return;
+    const key = `c-ttl-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const putRes = await call('put', { key, value: 'evicts-soon', ttlSeconds: 2 });
+    expect(putRes.status).toBe(200);
+
+    const within = await call('get', { key });
+    const withinBody = within.json as { value?: unknown; found?: boolean };
+    expect(
+      withinBody.value,
+      driver.describe('RFC 0019 §B point 2', 'cache get within TTL MUST return the stored value'),
+    ).toBe('evicts-soon');
+
+    await new Promise((r) => setTimeout(r, 3000));
+
+    const after = await call('get', { key });
+    const afterBody = after.json as { value?: unknown; found?: boolean };
+    expect(
+      afterBody.found,
+      driver.describe('RFC 0019 §B point 2', 'cache get after TTL expiry MUST surface as found:false (≤1s drift)'),
+    ).toBe(false);
+  });
+});

package/src/scenarios/dispatch-cross-worker-handoff.test.ts

@@ -0,0 +1,129 @@
+/**
+ * RFC 0022 §A + §D — `core.dispatch` sequential cross-worker handoff (HVMAP-1c).
+ * Normative reference: RFCS/0022-dispatch-input-output-mapping.md §A + §D
+ *
+ * Verifies that under `fanOutPolicy: 'sequential'` (v1.x default), the
+ * output mapping of child N MUST be visible to child N+1's input mapping
+ * within the same dispatch loop — they share the parent variable bag.
+ * The scenario routes child-a's `output` variable through the parent's
+ * `sharedVar` slot via per-worker mappings, then child-b reads it back
+ * as `inputs.input`. Verified end-to-end against the Postgres reference
+ * host on 2026-05-18 alongside the supervisor-mock extension (RFC 0022
+ * §"Unresolved questions" #6) that lets fixtures drive multi-worker
+ * `OrchestratorDecision` sequences.
+ *
+ * Capability-gated: skips when host doesn't advertise
+ * `capabilities.agents.dispatchMapping: true`. Fixture-gated: requires
+ * `conformance-dispatch-cross-worker-handoff` + the two child fixtures.
+ *
+ * @see RFCS/0022-dispatch-input-output-mapping.md §A + §D
+ * @see schemas/dispatch-config.schema.json #/properties/perWorker*
+ * @see examples/hosts/postgres/src/server.ts (core.dispatch executor)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+
+const PARENT = 'conformance-dispatch-cross-worker-handoff';
+const CHILD_A = 'conformance-dispatch-cross-worker-handoff-child-a';
+const CHILD_B = 'conformance-dispatch-cross-worker-handoff-child-b';
+const SKIP =
+  !isFixtureAdvertised(PARENT) ||
+  !isFixtureAdvertised(CHILD_A) ||
+  !isFixtureAdvertised(CHILD_B);
+
+interface RunEvent {
+  readonly type: string;
+  readonly nodeId?: string;
+  readonly payload?: { childRunId?: string; childWorkflowId?: string } & Record<string, unknown>;
+}
+
+interface RunSnapshot {
+  readonly status: string;
+  readonly inputs?: Record<string, unknown>;
+  readonly variables?: Record<string, unknown>;
+}
+
+describe.skipIf(SKIP)('dispatch-cross-worker-handoff: sequential child→parent→child variable flow (RFC 0022 §A + §D)', () => {
+  it('HVMAP-1c: child-a writes via perWorkerOutputMappings; child-b reads via perWorkerInputMappings; shared parent bag is the handoff channel', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: PARENT });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
+
+    const parentTerminal = (await pollUntilTerminal(parentRunId)) as RunSnapshot;
+    expect(parentTerminal.status, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §D',
+      'parent run MUST reach terminal `completed` once both children finish sequentially',
+    )).toBe('completed');
+
+    // Parent's sharedVar MUST be 'hello' — set by child-a's outputMapping.
+    const parentVars = parentTerminal.variables ?? {};
+    expect(parentVars.sharedVar, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §A',
+      'parent `sharedVar` MUST be child-a\'s `output` projection ("hello") via perWorkerOutputMappings',
+    )).toBe('hello');
+
+    // Locate child-b via the parent's `node.dispatched` events.
+    const eventsRes = await driver.get(`/v1/runs/${encodeURIComponent(parentRunId)}/events`);
+    expect(eventsRes.status).toBe(200);
+    const events = ((eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? []);
+    const dispatchedB = events.find(
+      (e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD_B,
+    );
+    expect(dispatchedB, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §D',
+      'parent event log MUST contain a `node.dispatched` event for child-b after child-a completes (sequential fan-out)',
+    )).toBeDefined();
+    const childBRunId = dispatchedB?.payload?.childRunId;
+    expect(typeof childBRunId).toBe('string');
+
+    // Child-b's inputs MUST reflect child-a's output (via the shared
+    // parent variable bag's sharedVar).
+    const childBSnapshotRes = await driver.get(`/v1/runs/${encodeURIComponent(childBRunId!)}`);
+    expect(childBSnapshotRes.status).toBe(200);
+    const childBSnapshot = childBSnapshotRes.json as RunSnapshot;
+    expect(childBSnapshot.status).toBe('completed');
+    const childBInputs = childBSnapshot.inputs ?? {};
+    expect(childBInputs.input, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §A + §D',
+      'child-b `inputs.input` MUST be parent\'s `sharedVar` ("hello") — written by child-a, read by child-b via shared parent variable bag',
+    )).toBe('hello');
+  });
+
+  it('HVMAP-1c-override: per-worker mapping overrides default mapping per §A effectiveInputMapping precedence', async () => {
+    const PARENT_OVERRIDE = 'conformance-dispatch-per-worker-override';
+    if (!isFixtureAdvertised(PARENT_OVERRIDE)) return; // fixture not seeded — soft-skip
+    const create = await driver.post('/v1/runs', { workflowId: PARENT_OVERRIDE });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
+    await pollUntilTerminal(parentRunId);
+
+    const eventsRes = await driver.get(`/v1/runs/${encodeURIComponent(parentRunId)}/events`);
+    const events = ((eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? []);
+    const dispatchedA = events.find((e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD_A);
+    const dispatchedB = events.find((e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD_B);
+    if (!dispatchedA || !dispatchedB) return;
+
+    const childARes = await driver.get(`/v1/runs/${encodeURIComponent(dispatchedA.payload!.childRunId!)}`);
+    const childBRes = await driver.get(`/v1/runs/${encodeURIComponent(dispatchedB.payload!.childRunId!)}`);
+    const childAInputs = (childARes.json as { inputs?: Record<string, unknown> }).inputs ?? {};
+    const childBInputs = (childBRes.json as { inputs?: Record<string, unknown> }).inputs ?? {};
+
+    expect(
+      childAInputs.input,
+      driver.describe(
+        'RFCS/0022-dispatch-input-output-mapping.md §A',
+        'child-a uses the DEFAULT inputMapping; input MUST come from parent.defaultX',
+      ),
+    ).toBe('default-x-value');
+    expect(
+      childBInputs.input,
+      driver.describe(
+        'RFCS/0022-dispatch-input-output-mapping.md §A',
+        'child-b uses the per-worker OVERRIDE; input MUST come from parent.sharedVar (NOT defaultX)',
+      ),
+    ).toBe('shared-value');
+  });
+});

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

@@ -0,0 +1,163 @@
+/**
+ * RFC 0022 §A — `core.dispatch` `inputMapping` projection (HVMAP-1a).
+ * Normative reference: RFCS/0022-dispatch-input-output-mapping.md §A
+ *
+ * Verifies that when a `core.dispatch` config carries `inputMapping`, the
+ * host builds child inputs by projecting parent variables before invoking
+ * each `nextWorkerIds[i]` child. Per §A: `childInputs[childKey] =
+ * parentVariables.get(parentKey)`. Verified end-to-end against the
+ * Postgres reference host on 2026-05-18 alongside the supervisor-mock
+ * extension that lets fixtures drive `OrchestratorDecision` sequences
+ * (RFC 0022 §"Unresolved questions" #6 — `mockDispatchPlan` config on
+ * `core.orchestrator.supervisor`).
+ *
+ * Capability-gated: skips when host doesn't advertise
+ * `capabilities.agents.dispatchMapping: true`. Fixture-gated: requires
+ * `conformance-dispatch-input-mapping` + the matching child fixture.
+ *
+ * @see RFCS/0022-dispatch-input-output-mapping.md §A
+ * @see schemas/dispatch-config.schema.json #/properties/inputMapping
+ * @see examples/hosts/postgres/src/server.ts (core.dispatch executor)
+ */
+
+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 { setHostCapability, resetHostCapabilities, isToggleAvailable } from '../lib/host-toggle.js';
+
+const PARENT = 'conformance-dispatch-input-mapping';
+const CHILD = 'conformance-dispatch-input-mapping-child';
+const SKIP = !isFixtureAdvertised(PARENT) || !isFixtureAdvertised(CHILD);
+
+interface RunEvent {
+  readonly type: string;
+  readonly nodeId?: string;
+  readonly payload?: { childRunId?: string; childWorkflowId?: string } & Record<string, unknown>;
+}
+
+interface RunSnapshot {
+  readonly status: string;
+  readonly inputs?: Record<string, unknown>;
+  readonly variables?: Record<string, unknown>;
+}
+
+describe.skipIf(SKIP)('dispatch-input-mapping: parent → child variable projection (RFC 0022 §A)', () => {
+  it('HVMAP-1a: inputMapping projects parent variables into child inputs', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: PARENT });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
+
+    const parentTerminal = (await pollUntilTerminal(parentRunId)) as RunSnapshot;
+    expect(parentTerminal.status, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §A',
+      'parent run MUST reach terminal `completed` once the dispatch loop terminates',
+    )).toBe('completed');
+
+    // Locate the child run via the parent's `node.dispatched` event.
+    const eventsRes = await driver.get(`/v1/runs/${encodeURIComponent(parentRunId)}/events`);
+    expect(eventsRes.status).toBe(200);
+    const events = ((eventsRes.json as { events?: RunEvent[] } | undefined)?.events ?? []);
+    const dispatched = events.find(
+      (e) => e.type === 'node.dispatched' && e.payload?.childWorkflowId === CHILD,
+    );
+    expect(dispatched, driver.describe(
+      'RFCS/0007-dispatch.md §D',
+      'parent event log MUST contain a `node.dispatched` event naming the child workflow',
+    )).toBeDefined();
+    const childRunId = dispatched?.payload?.childRunId;
+    expect(typeof childRunId).toBe('string');
+
+    // The child's inputs_json (surfaced as `inputs` on GET /v1/runs)
+    // MUST contain the parent's `parentName` projected onto `childGreeting`
+    // per the dispatch config's inputMapping.
+    const childSnapshotRes = await driver.get(`/v1/runs/${encodeURIComponent(childRunId!)}`);
+    expect(childSnapshotRes.status).toBe(200);
+    const childSnapshot = childSnapshotRes.json as RunSnapshot;
+    expect(childSnapshot.status, driver.describe(
+      'RFCS/0007-dispatch.md',
+      'child run MUST reach terminal `completed`',
+    )).toBe('completed');
+    const childInputs = childSnapshot.inputs ?? {};
+    expect(childInputs.childGreeting, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §A',
+      'child `inputs.childGreeting` MUST be parent\'s `parentName` projection ("Alice") per inputMapping',
+    )).toBe('Alice');
+  });
+
+  it('HVMAP-1a-null: parent variable unset → child input surfaces as `undefined` per §A', async () => {
+    const PARENT_NO_DEFAULT = 'conformance-dispatch-input-mapping-no-default';
+    if (!isFixtureAdvertised(PARENT_NO_DEFAULT) || !isFixtureAdvertised(CHILD)) return; // fixture not seeded — soft-skip
+    const create = await driver.post('/v1/runs', { workflowId: PARENT_NO_DEFAULT });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
+    await pollUntilTerminal(parentRunId);
+
+    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 === CHILD,
+    );
+    if (!dispatched) return; // host doesn't emit node.dispatched — soft-skip
+    const childRunId = dispatched.payload?.childRunId;
+
+    const childRes = await driver.get(`/v1/runs/${encodeURIComponent(childRunId!)}`);
+    const child = childRes.json as RunSnapshot;
+    // Per RFC 0022 §A: an unset parent variable MUST surface as `undefined`.
+    // On the wire, `undefined` becomes either omitted from the JSON object
+    // OR explicit `null`; the spec REJECTS the latter. We accept either
+    // "key absent" or "key === undefined" but FAIL on `null`.
+    const inputs = child.inputs ?? {};
+    const v = inputs.childGreeting;
+    expect(
+      v === undefined || !('childGreeting' in inputs),
+      driver.describe(
+        'RFCS/0022-dispatch-input-output-mapping.md §A',
+        'unset parent variable projection MUST surface as undefined (NOT null, NOT a default placeholder)',
+      ),
+    ).toBe(true);
+    expect(v).not.toBe(null);
+  });
+
+});
+
+describe('dispatch-input-mapping: registration refusal (RFC 0022 §C HVMAP-1a-refusal)', () => {
+  it('host with agents.dispatchMapping toggled OFF MUST refuse non-empty inputMapping at registration', async () => {
+    if (!(await isToggleAvailable())) return; // seam not exposed — soft-skip
+    await setHostCapability('agents.dispatchMapping', false);
+    try {
+      const workflow = {
+        workflowId: `hvmap-1a-refusal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        nodes: [
+          {
+            nodeId: 'dispatch-1',
+            typeId: 'core.dispatch',
+            config: {
+              nextWorkerIds: ['child-a'],
+              inputMapping: { childInput: 'parentVar' }, // non-empty — refusal trigger
+            },
+          },
+        ],
+      };
+      const res = await driver.post('/v1/host/sample/workflows', workflow);
+      expect(
+        res.status,
+        driver.describe(
+          'RFCS/0022-dispatch-input-output-mapping.md §C',
+          'workflow with non-empty inputMapping MUST be refused when capabilities.agents.dispatchMapping is not advertised',
+        ),
+      ).toBe(400);
+      const body = res.json as { error?: string; details?: { requiredCapability?: string } };
+      expect(body.error).toBe('validation_error');
+      expect(
+        body.details?.requiredCapability,
+        driver.describe(
+          'RFCS/0022-dispatch-input-output-mapping.md §C',
+          'refusal MUST surface requiredCapability: "agents.dispatchMapping"',
+        ),
+      ).toBe('agents.dispatchMapping');
+    } finally {
+      await resetHostCapabilities();
+    }
+  });
+});

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

@@ -0,0 +1,155 @@
+/**
+ * RFC 0022 §A — `core.dispatch` `outputMapping` harvesting (HVMAP-1b).
+ * Normative reference: RFCS/0022-dispatch-input-output-mapping.md §A
+ *
+ * Verifies that when a `core.dispatch` config carries `outputMapping` and
+ * a child reaches terminal `completed`, the host projects child variables
+ * back into parent variables: `parentVariables.set(parentKey, childVariables[childKey])`.
+ * Failed / cancelled children MUST skip the mapping; the parent's variable
+ * stays at its pre-dispatch state for that child. Verified end-to-end
+ * against the Postgres reference host on 2026-05-18.
+ *
+ * Capability-gated: skips when host doesn't advertise
+ * `capabilities.agents.dispatchMapping: true`. Fixture-gated: requires
+ * `conformance-dispatch-output-mapping` + the matching child fixture.
+ *
+ * @see RFCS/0022-dispatch-input-output-mapping.md §A
+ * @see schemas/dispatch-config.schema.json #/properties/outputMapping
+ * @see examples/hosts/postgres/src/server.ts (core.dispatch executor)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { driver } from '../lib/driver.js';
+import { pollUntilTerminal } from '../lib/polling.js';
+import { isFixtureAdvertised } from '../lib/fixtures.js';
+
+const PARENT = 'conformance-dispatch-output-mapping';
+const CHILD = 'conformance-dispatch-output-mapping-child';
+const SKIP = !isFixtureAdvertised(PARENT) || !isFixtureAdvertised(CHILD);
+
+interface RunSnapshot {
+  readonly status: string;
+  readonly variables?: Record<string, unknown>;
+}
+
+describe.skipIf(SKIP)('dispatch-output-mapping: child → parent variable harvest (RFC 0022 §A)', () => {
+  it('HVMAP-1b: outputMapping harvests child variables into parent variables on terminal completed', async () => {
+    const create = await driver.post('/v1/runs', { workflowId: PARENT });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
+
+    const parentTerminal = (await pollUntilTerminal(parentRunId)) as RunSnapshot;
+    expect(parentTerminal.status, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §A',
+      'parent run MUST reach terminal `completed` once the dispatch loop terminates',
+    )).toBe('completed');
+
+    // Parent's `parentResult` MUST equal child's `childOutcome` ("done")
+    // per the dispatch config's outputMapping = { parentResult: 'childOutcome' }.
+    // Child declares childOutcome.defaultValue='done' so the value is
+    // present in the child's variables_json at terminal time.
+    const parentVars = parentTerminal.variables ?? {};
+    expect(parentVars.parentResult, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §A',
+      'parent `parentResult` MUST be child\'s `childOutcome` projection ("done") per outputMapping',
+    )).toBe('done');
+  });
+
+});
+
+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');
+  });
+});
+
+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');
+  });
+});