@openwop/openwop-conformance 1.1.1 → 1.3.0

package/src/scenarios/search-bm25-roundtrip.test.ts

@@ -0,0 +1,92 @@
+/**
+ * search-bm25-roundtrip — RFC 0018 advertisement-shape verification + behavioral placeholders.
+ *
+ * Status: ACTIVE (advertisement-shape). RFC 0018 promoted to `Active`
+ * 2026-05-17. The matching `capabilities.searchIndex` 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: index then query returns relevant documents.
+ *
+ * @see RFCS/0018-*.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>)["searchIndex"] : undefined;
+  return (final && typeof final === 'object' ? (final as Record<string, unknown>) : null);
+}
+
+describe('search-bm25-roundtrip: advertisement shape (RFC 0018)', () => {
+  it('capabilities.searchIndex 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 §searchIndex',
+        'capabilities.searchIndex.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: 'search', op, args });
+}
+
+describe('search-bm25-roundtrip: behavioral (RFC 0018 §A.searchIndex)', () => {
+  it('index 3 docs → query for a distinguishing keyword returns the matching doc as top hit', async () => {
+    const probe = await call('query', { index: '__probe__', q: 'hello' });
+    if (probe.status === 404) return; // seam not exposed
+    const index = `idx-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const idx = await call('index', {
+      index,
+      docs: [
+        { id: 'doc-1', fields: { title: 'Database engines for vector search', body: 'Pinecone Qdrant Weaviate Milvus pgvector' } },
+        { id: 'doc-2', fields: { title: 'Workflow orchestration patterns', body: 'durable runs interrupts replay event log' } },
+        { id: 'doc-3', fields: { title: 'Distributed systems primer', body: 'consensus Paxos Raft leader election' } },
+      ],
+    });
+    expect(idx.status).toBe(200);
+
+    // Query for a distinguishing keyword → doc-2 MUST be top-ranked.
+    const q = await call('query', { index, q: 'durable workflow runs', k: 3 });
+    expect(q.status).toBe(200);
+    const body = q.json as { hits?: Array<{ id: string; score: number }> };
+    expect(Array.isArray(body.hits) && body.hits.length > 0).toBe(true);
+    expect(
+      body.hits![0]!.id,
+      driver.describe('RFC 0018 §A.searchIndex', 'query for the doc\'s distinguishing tokens MUST return that doc as top-1'),
+    ).toBe('doc-2');
+    // Top hit's score MUST be strictly greater than any tied below-rank.
+    if (body.hits!.length > 1) {
+      expect(body.hits![0]!.score >= body.hits![1]!.score).toBe(true);
+    }
+  });
+
+  it('k limit caps the result set', async () => {
+    const probe = await call('query', { index: '__probe__', q: 'hello' });
+    if (probe.status === 404) return;
+    const index = `idx-k-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const docs = Array.from({ length: 5 }, (_, i) => ({ id: `d-${i}`, fields: { body: 'apple orange banana' } }));
+    await call('index', { index, docs });
+    const q = await call('query', { index, q: 'apple', k: 2 });
+    const body = q.json as { hits?: unknown[] };
+    expect(
+      Array.isArray(body.hits) && body.hits.length <= 2,
+      driver.describe('RFC 0018 §A.searchIndex', 'query MUST return at most k hits'),
+    ).toBe(true);
+  });
+});

package/src/scenarios/spec-corpus-validity.test.ts

@@ -69,7 +69,23 @@ import {
 // ── Helpers ─────────────────────────────────────────────────────────────
 
 function listJsonFiles(dir: string): string[] {
-  return readdirSync(dir).filter((f) => f.endsWith('.json'));
+  // Recurse into subdirectories so e.g. `schemas/envelopes/*.schema.json`
+  // appears as `envelopes/<file>` to match the README's path-prefixed
+  // table entries. Preserves the non-recursive-relative-output contract
+  // for files directly under `dir`.
+  const out: string[] = [];
+  const walk = (subPath: string): void => {
+    const fullPath = subPath === '' ? dir : `${dir}/${subPath}`;
+    for (const entry of readdirSync(fullPath, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        walk(subPath === '' ? entry.name : `${subPath}/${entry.name}`);
+      } else if (entry.isFile() && entry.name.endsWith('.json')) {
+        out.push(subPath === '' ? entry.name : `${subPath}/${entry.name}`);
+      }
+    }
+  };
+  walk('');
+  return out;
 }
 
 function listScenarioTestFiles(dir: string): string[] {

package/src/scenarios/sql-injection-rejection.test.ts

@@ -0,0 +1,84 @@
+/**
+ * sql-injection-rejection — RFC 0018 §C + SECURITY/invariants.yaml
+ * `sql-parametric-only`.
+ *
+ * Status: ACTIVE (advertisement + behavioral). The host's SQL surface
+ * MUST treat parameter values as literal data, not SQL fragments. We
+ * verify by binding an injection-shape string as a parameter and
+ * confirming it returns no rows (parametric binding turns it into a
+ * literal value comparison rather than an OR-true).
+ *
+ * @see RFCS/0018-host-sql-vector-search-capability.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>)["sql"] : undefined;
+  return (final && typeof final === 'object' ? (final as Record<string, unknown>) : null);
+}
+
+async function call(op: string, args: Record<string, unknown>) {
+  return driver.post('/v1/host/sample/test/surface', { tenantId: 'tenant-a', surface: 'sql', op, args });
+}
+
+describe('sql-injection-rejection: advertisement shape (RFC 0018)', () => {
+  it('capabilities.sql is either absent or a well-formed object', async () => {
+    const cap = await readCap();
+    if (cap === null) return;
+    expect(
+      typeof cap.supported,
+      driver.describe(
+        'capabilities.schema.json §sql',
+        'capabilities.sql.supported MUST be a boolean when present',
+      ),
+    ).toBe('boolean');
+  });
+});
+
+describe('sql-injection-rejection: behavioral (RFC 0018 §C)', () => {
+  it('parametric SELECT with bound user input rejects injection-shape strings as data', async () => {
+    const cap = await readCap();
+    if (!cap || cap.supported !== true) return;
+
+    const create = await call('execute', {
+      sql: `CREATE TABLE IF NOT EXISTS sql_inj_t (id TEXT PRIMARY KEY, body TEXT)`,
+      params: [],
+    });
+    if (create.status === 404) return;
+    await call('execute', { sql: `INSERT OR REPLACE INTO sql_inj_t VALUES (?, ?)`, params: ['k1', 'ok'] });
+
+    // Parametric round-trip MUST succeed.
+    const okRes = await call('query', {
+      sql: `SELECT body FROM sql_inj_t WHERE id = ?`,
+      params: ['k1'],
+    });
+    expect(okRes.status).toBe(200);
+    const okBody = okRes.json as { rows?: Array<Record<string, unknown>> };
+    expect(okBody.rows?.[0]?.body, 'parametric round-trip MUST return stored value').toBe('ok');
+
+    // Injection-shape input MUST be bound as a literal value, not SQL.
+    const attack = `' OR '1'='1`;
+    const attackRes = await call('query', {
+      sql: `SELECT body FROM sql_inj_t WHERE id = ?`,
+      params: [attack],
+    });
+    expect(attackRes.status).toBe(200);
+    const attackBody = attackRes.json as { rows?: Array<Record<string, unknown>> };
+    expect(
+      Array.isArray(attackBody.rows) ? attackBody.rows.length : -1,
+      driver.describe(
+        'SECURITY/invariants.yaml sql-parametric-only',
+        'parametric binding MUST treat injection-shape input as a literal value, not SQL',
+      ),
+    ).toBe(0);
+  });
+});

package/src/scenarios/sql-transaction-atomicity.test.ts

@@ -0,0 +1,95 @@
+/**
+ * sql-transaction-atomicity — RFC 0018 advertisement-shape verification + behavioral placeholders.
+ *
+ * Status: ACTIVE (advertisement-shape). RFC 0018 promoted to `Active`
+ * 2026-05-17. The matching `capabilities.sql` 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: transactions MUST be atomic; partial failure rolls back.
+ *
+ * @see RFCS/0018-*.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>)["sql"] : undefined;
+  return (final && typeof final === 'object' ? (final as Record<string, unknown>) : null);
+}
+
+describe('sql-transaction-atomicity: advertisement shape (RFC 0018)', () => {
+  it('capabilities.sql 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 §sql',
+        'capabilities.sql.supported MUST be a boolean when present',
+      ),
+    ).toBe('boolean');
+  });
+
+  it('transactions is a boolean when set', async () => {
+    const cap = await readCap();
+    if (!cap || cap.supported !== true) return;
+    const subParts = ["transactions"];
+    let sub: unknown = cap;
+    for (const p of subParts) {
+      if (sub && typeof sub === 'object') sub = (sub as Record<string, unknown>)[p];
+      else { sub = undefined; break; }
+    }
+    if (sub === undefined) return; // optional sub-field
+    expect(
+      typeof sub,
+      driver.describe(
+        'RFC 0018 §A',
+        'sql.transactions MUST be 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: 'sql', op, args });
+}
+
+describe('sql-transaction-atomicity: behavioral (RFC 0018 §B.sql — transaction atomicity)', () => {
+  it('transaction with N statements where N-th fails → earlier writes MUST roll back', async () => {
+    const probe = await call('execute', { sql: 'CREATE TABLE IF NOT EXISTS atomicity_probe (id TEXT PRIMARY KEY)', params: [] });
+    if (probe.status === 404) return;
+    const table = `t_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    await call('execute', { sql: `CREATE TABLE ${table} (id INTEGER PRIMARY KEY, val TEXT)`, params: [] });
+
+    const txnRes = await call('transaction', {
+      statements: [
+        { sql: `INSERT INTO ${table}(id, val) VALUES (?, ?)`, params: [1, 'one'] },
+        { sql: `INSERT INTO ${table}(id, val) VALUES (?, ?)`, params: [2, 'two'] },
+        { sql: `INSERT INTO ${table}(id, val) VALUES (?, ?)`, params: [1, 'duplicate'] }, // PK violation
+      ],
+    });
+    expect(
+      txnRes.status >= 400 && txnRes.status < 500,
+      driver.describe('RFC 0018 §B.sql', 'transaction with failing statement MUST surface as 4xx'),
+    ).toBe(true);
+
+    const queryRes = await call('query', { sql: `SELECT id, val FROM ${table}`, params: [] });
+    expect(queryRes.status).toBe(200);
+    const body = queryRes.json as { rows?: unknown[] };
+    expect(
+      Array.isArray(body.rows) && body.rows.length === 0,
+      driver.describe('RFC 0018 §B.sql', 'rows from earlier statements in a failed transaction MUST NOT be visible'),
+    ).toBe(true);
+  });
+});

package/src/scenarios/stream-subscribe-from-beginning.test.ts

@@ -0,0 +1,103 @@
+/**
+ * stream-subscribe-from-beginning — RFC 0017 advertisement-shape verification + behavioral placeholders.
+ *
+ * Status: ACTIVE (advertisement-shape). RFC 0017 promoted to `Active`
+ * 2026-05-17. The matching `capabilities.queueBus` 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: Stream subscribers with fromBeginning=true receive records published before subscription.
+ *
+ * @see RFCS/0017-*.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>)["queueBus"] : undefined;
+  return (final && typeof final === 'object' ? (final as Record<string, unknown>) : null);
+}
+
+describe('stream-subscribe-from-beginning: advertisement shape (RFC 0017)', () => {
+  it('capabilities.queueBus 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 §queueBus',
+        'capabilities.queueBus.supported MUST be a boolean when present',
+      ),
+    ).toBe('boolean');
+  });
+
+  it('stream.supported is a boolean when set', async () => {
+    const cap = await readCap();
+    if (!cap || cap.supported !== true) return;
+    const subParts = ["stream","supported"];
+    let sub: unknown = cap;
+    for (const p of subParts) {
+      if (sub && typeof sub === 'object') sub = (sub as Record<string, unknown>)[p];
+      else { sub = undefined; break; }
+    }
+    if (sub === undefined) return; // optional sub-field
+    expect(
+      typeof sub,
+      driver.describe(
+        'RFC 0017 §A',
+        'queueBus.stream.supported MUST be 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: 'queueBus', op, args });
+}
+
+describe('stream-subscribe-from-beginning: behavioral (RFC 0017 §A stream.fromBeginning)', () => {
+  it('streamPublish 5 records then streamSubscribe({fromBeginning:true}) MUST surface all 5 in the snapshot', async () => {
+    const probe = await call('streamSubscribe', { stream: '__probe__', fromBeginning: true });
+    if (probe.status === 404) return; // seam not exposed
+    const stream = `s-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    for (let i = 1; i <= 5; i++) {
+      const r = await call('streamPublish', { stream, record: { seq: i, value: `rec-${i}` } });
+      expect(r.status).toBe(200);
+    }
+    const sub = await call('streamSubscribe', { stream, fromBeginning: true });
+    expect(sub.status).toBe(200);
+    const body = sub.json as { records?: Array<{ payload?: { seq?: number } }>; fromBeginningSnapshot?: boolean };
+    expect(
+      Array.isArray(body.records) && body.records.length === 5,
+      driver.describe('RFC 0017 §A.stream.fromBeginning', 'subscribe with fromBeginning:true MUST return ALL records previously published on the stream'),
+    ).toBe(true);
+    // Order MUST be preserved (publish-order = sequential on the same stream).
+    const seqs = body.records!.map((r) => r.payload?.seq);
+    expect(seqs).toEqual([1, 2, 3, 4, 5]);
+    expect(body.fromBeginningSnapshot).toBe(true);
+  });
+
+  it('streamSubscribe({fromBeginning:false}) MUST NOT include pre-subscribe records (live-tail semantics)', async () => {
+    const probe = await call('streamSubscribe', { stream: '__probe__', fromBeginning: true });
+    if (probe.status === 404) return;
+    const stream = `s-live-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    await call('streamPublish', { stream, record: { v: 'before' } });
+    const sub = await call('streamSubscribe', { stream, fromBeginning: false });
+    const body = sub.json as { records?: unknown[]; fromBeginningSnapshot?: boolean };
+    expect(
+      Array.isArray(body.records) && body.records.length === 0,
+      driver.describe('RFC 0017 §A.stream.fromBeginning', 'subscribe with fromBeginning:false MUST omit pre-subscribe records'),
+    ).toBe(true);
+    expect(body.fromBeginningSnapshot).toBe(false);
+  });
+});

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

@@ -0,0 +1,170 @@
+/**
+ * RFC 0022 §B — `core.subWorkflow` `inputMapping` seeding (HVMAP-2).
+ * Normative reference: RFCS/0022-dispatch-input-output-mapping.md §B
+ *   + spec/v1/node-packs.md §"`core.subWorkflow` contract" (post-RFC-0022).
+ *
+ * Verifies that when a `core.subWorkflow` config carries `inputMapping`,
+ * the host seeds the child run's initial variable bag with
+ * `parentVariables[parentKey]` projections AFTER the child's
+ * `variables[].defaultValue` fold (so `inputMapping` overrides matching
+ * defaults). Verified end-to-end against the Postgres reference host on
+ * 2026-05-18 alongside the RFC's `Active` promotion.
+ *
+ * Capability-gated: skips when host doesn't advertise
+ * `capabilities.subWorkflow.inputMapping: true`. Fixture-gated: requires
+ * `conformance-subworkflow-input-mapping` + the matching child fixture.
+ *
+ * @see RFCS/0022-dispatch-input-output-mapping.md §B
+ * @see spec/v1/node-packs.md §"`core.subWorkflow` contract"
+ */
+
+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-subworkflow-input-mapping';
+const CHILD = 'conformance-subworkflow-input-mapping-child';
+const SKIP = !isFixtureAdvertised(PARENT) || !isFixtureAdvertised(CHILD);
+
+interface RunEvent {
+  readonly type: string;
+  readonly nodeId?: string;
+  readonly payload?: { outputs?: { childRunId?: string } } & Record<string, unknown>;
+}
+
+interface RunSnapshot {
+  readonly status: string;
+  readonly variables?: Record<string, unknown>;
+}
+
+describe.skipIf(SKIP)('subworkflow-input-mapping: parent → child variable seeding (RFC 0022 §B)', () => {
+  it('HVMAP-2: inputMapping seeds child variables, overrides defaultValue, child reads parent projection', async () => {
+    // Parent fixture declares currentPrdId='prd-1' as its defaultValue.
+    // The parent's `core.subWorkflow` node carries
+    // `inputMapping: { receivedPrdId: 'currentPrdId' }`. Child fixture
+    // declares `receivedPrdId.defaultValue='baked-in'` — the mapping
+    // MUST override that default per RFC 0022 §B.
+    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 §B',
+      'parent run MUST reach terminal `completed` once the child finishes',
+    )).toBe('completed');
+
+    // Locate the child run via the parent's event log.
+    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 subwfCompleted = events.find(
+      (e) => e.type === 'node.completed' && e.nodeId === 'subwf-call',
+    );
+    expect(subwfCompleted, driver.describe(
+      'spec/v1/node-packs.md §"`core.subWorkflow` contract"',
+      'parent event log MUST contain `node.completed` for the subwf-call node',
+    )).toBeDefined();
+    const childRunId = subwfCompleted?.payload?.outputs?.childRunId;
+    expect(typeof childRunId).toBe('string');
+
+    // Inspect the child run's final variables — receivedPrdId MUST be
+    // the parent's projection ("prd-1"), NOT the child's defaultValue
+    // ("baked-in").
+    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(
+      'spec/v1/node-packs.md §"`core.subWorkflow` contract"',
+      'child run MUST reach terminal `completed`',
+    )).toBe('completed');
+    const childVars = childSnapshot.variables ?? {};
+    expect(childVars.receivedPrdId, driver.describe(
+      'RFCS/0022-dispatch-input-output-mapping.md §B',
+      'child `receivedPrdId` MUST be parent\'s `currentPrdId` projection ("prd-1"), overriding the child\'s defaultValue "baked-in"',
+    )).toBe('prd-1');
+  });
+
+  it('HVMAP-2-unset: parent.currentPrdId unset → child receivedPrdId MUST surface as `undefined`', async () => {
+    const PARENT_NO_DEFAULT = 'conformance-subworkflow-input-mapping-no-default';
+    if (!isFixtureAdvertised(PARENT_NO_DEFAULT) || !isFixtureAdvertised(CHILD)) return; // 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 subwfCompleted = events.find(
+      (e) => e.type === 'node.completed' && e.nodeId === 'subwf-call',
+    );
+    if (!subwfCompleted) return;
+    const childRunId = subwfCompleted.payload?.outputs?.childRunId;
+
+    const childRes = await driver.get(`/v1/runs/${encodeURIComponent(childRunId!)}`);
+    const child = childRes.json as RunSnapshot;
+    const vars = child.variables ?? {};
+    const v = vars.receivedPrdId;
+    // Note: the spec says `undefined` (NOT null). On the wire, `undefined`
+    // serializes as either key-absent or the child's own defaultValue fold
+    // ("baked-in"). The MUST-NOT is `null`. Per RFC 0022 §B, inputMapping
+    // override happens AFTER defaultValue fold, so when the projection is
+    // undefined the child's defaultValue should remain.
+    expect(
+      v === 'baked-in' || v === undefined || !('receivedPrdId' in vars),
+      driver.describe(
+        'RFCS/0022-dispatch-input-output-mapping.md §B',
+        'unset parent variable MUST surface as undefined-or-defaultValue-fallback (NOT null)',
+      ),
+    ).toBe(true);
+    expect(v).not.toBe(null);
+  });
+
+  it.todo(
+    'HVMAP-2-no-midrun-propagation: child mid-run; parent updates currentPrdId; child receivedPrdId MUST remain at seeded value (one-shot fold per §B normative bullet). DEFERRED — requires (1) a multi-step child fixture that suspends mid-run on a clarification gate, plus (2) a parent path that mutates `currentPrdId` AFTER the child is suspended. The reference workflow-engine has no parallel-execution model that lets the parent run a separate "mutate-var" node WHILE the subwf-call is blocked on the child; this needs either a new sample-namespaced `POST /v1/host/sample/test/runs/:runId/variables` seam OR a workflow primitive that splits the parent into a fan-out branch that mutates concurrently. Tracked under Phase 3 of the test-coverage plan as a separate "run-state mutation seam" task.',
+  );
+
+});
+
+describe('subworkflow-input-mapping: registration refusal (RFC 0022 §C HVMAP-2-refusal)', () => {
+  it('host with subWorkflow.inputMapping toggled OFF MUST refuse non-empty inputMapping at registration', async () => {
+    if (!(await isToggleAvailable())) return; // seam not exposed — soft-skip
+    await setHostCapability('subWorkflow.inputMapping', false);
+    try {
+      const workflow = {
+        workflowId: `hvmap-2-refusal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        nodes: [
+          {
+            nodeId: 'subwf-1',
+            typeId: 'core.subWorkflow',
+            config: {
+              childWorkflowId: 'some-child',
+              inputMapping: { receivedPrdId: 'currentPrdId' }, // 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 subWorkflow.inputMapping MUST be refused when capability 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: "subWorkflow.inputMapping"',
+        ),
+      ).toBe('subWorkflow.inputMapping');
+    } finally {
+      await resetHostCapabilities();
+    }
+  });
+});

package/src/scenarios/table-cross-tenant-isolation.test.ts

@@ -0,0 +1,65 @@
+/**
+ * table-cross-tenant-isolation — RFC 0016 §B point 1.
+ *
+ * Status: ACTIVE (advertisement + behavioral). Asserts that rows inserted
+ * under tenant A MUST NOT appear in queries under tenant B against the
+ * same table+filter.
+ *
+ * @see RFCS/0016-host-table-storage-capability.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>)["tableStorage"] : undefined;
+  return (final && typeof final === 'object' ? (final as Record<string, unknown>) : null);
+}
+
+async function call(tenantId: string, op: string, args: Record<string, unknown>) {
+  return driver.post('/v1/host/sample/test/surface', { tenantId, surface: 'table', op, args });
+}
+
+describe('table-cross-tenant-isolation: advertisement shape (RFC 0016)', () => {
+  it('capabilities.tableStorage is either absent or a well-formed object', async () => {
+    const cap = await readCap();
+    if (cap === null) return;
+    expect(
+      typeof cap.supported,
+      driver.describe(
+        'capabilities.schema.json §tableStorage',
+        'capabilities.tableStorage.supported MUST be a boolean when present',
+      ),
+    ).toBe('boolean');
+  });
+});
+
+describe('table-cross-tenant-isolation: behavioral (RFC 0016 §B point 1)', () => {
+  it('insert under tenant A → query under tenant B returns 0 rows', async () => {
+    const cap = await readCap();
+    if (!cap || cap.supported !== true) return;
+    const table = `xtenant_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+
+    const insertRes = await call('tenant-a', 'insert', {
+      table,
+      row: { id: 'r1', body: 'from-A' },
+    });
+    if (insertRes.status === 404) return; // seam not exposed
+    expect(insertRes.status, 'insert MUST succeed').toBe(200);
+
+    const queryRes = await call('tenant-b', 'query', { table, filter: {} });
+    expect(queryRes.status).toBe(200);
+    const body = queryRes.json as { rows?: unknown[] };
+    expect(
+      Array.isArray(body.rows) ? body.rows.length : -1,
+      driver.describe('RFC 0016 §B point 1', 'tenant B MUST see 0 rows in tenant A table'),
+    ).toBe(0);
+  });
+});