@openwop/openwop-conformance 1.2.0 → 1.4.0

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

@@ -1,12 +1,12 @@
 /**
- * search-bm25-roundtrip — RFC 0018 advertisement-shape verification + behavioral placeholders.
+ * search-bm25-roundtrip — RFC 0018 advertisement-shape verification + behavioral roundtrip.
  *
- * 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.
+ * Status: ACTIVE (advertisement-shape + behavioral). 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
+ * exercises the behavioral surface through the `/v1/host/sample/test/surface`
+ * seam (soft-skip with HTTP 404 on hosts that don't expose it).
  *
  * Summary: index then query returns relevant documents.
  *
@@ -42,6 +42,51 @@ describe('search-bm25-roundtrip: advertisement shape (RFC 0018)', () => {
   });
 });
 
-describe('search-bm25-roundtrip: behavioral assertions (placeholders — need host test seam)', () => {
-  it.todo("index 3 docs → query returns relevance-ranked hits");
+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

@@ -408,12 +408,20 @@ function stripFencedCodeBlocks(markdown: string): string {
   return markdown.replace(/```[\s\S]*?```/g, '');
 }
 
+function stripInlineCodeSpans(markdown: string): string {
+  // Strip double-backtick spans first so the inner segment of a span
+  // containing a literal backtick (``foo `bar` baz``) doesn't get
+  // mis-stripped by the single-backtick pass, leaving stray openers
+  // that could pair with later backticks elsewhere in the file.
+  return markdown.replace(/``[^`\n]+``/g, '').replace(/`[^`\n]*`/g, '');
+}
+
 function extractLocalMarkdownLinks(markdown: string): string[] {
   const links: string[] = [];
   const re = /!?\[[^\]\n]*\]\(([^)\n]+)\)/g;
   let m: RegExpExecArray | null;
 
-  while ((m = re.exec(stripFencedCodeBlocks(markdown))) !== null) {
+  while ((m = re.exec(stripInlineCodeSpans(stripFencedCodeBlocks(markdown)))) !== null) {
     let raw = (m[1] ?? '').trim();
     raw = raw.replace(/\s+"[^"]*"$/, '').trim();
     if (raw.startsWith('<') && raw.endsWith('>')) raw = raw.slice(1, -1);
@@ -444,6 +452,21 @@ describe('spec-corpus: JSON Schemas compile under Ajv2020', () => {
   const ajv = new Ajv2020({ allErrors: true, strict: false });
   addFormats(ajv);
 
+  // Pre-register every schema with the Ajv instance so cross-file `$ref`s
+  // resolve regardless of compile order. Without this, a cross-ref from
+  // an alphabetically-earlier file (e.g. capabilities.schema.json) to a
+  // later one (e.g. prompt-kind.schema.json) fails with "can't resolve
+  // reference." `addSchema` only registers — it doesn't compile — so
+  // per-file compilation errors still surface in their own `it()` below.
+  for (const file of schemaFiles) {
+    try {
+      ajv.addSchema(readJson(join(SCHEMAS_DIR, file)) as Record<string, unknown>);
+    } catch {
+      // Bad schemas surface in the per-file `compile()` below; swallow
+      // here so registration order doesn't short-circuit reporting.
+    }
+  }
+
   it('finds at least three schemas (workflow-definition, run-event, suspend-request)', () => {
     expect(schemaFiles.length).toBeGreaterThanOrEqual(3);
     expect(schemaFiles).toContain('workflow-definition.schema.json');
@@ -459,8 +482,9 @@ describe('spec-corpus: JSON Schemas compile under Ajv2020', () => {
         `https://openwop.dev/spec/v1/${file}`,
       );
       expect(typeof schema['title']).toBe('string');
-      // Compile — throws on structural issues.
-      const validate = ajv.compile(schema);
+      // `compile` uses the schemas registered by `addSchema` above to
+      // resolve cross-file `$ref`s — throws on structural issues.
+      const validate = ajv.getSchema(schema['$id'] as string) ?? ajv.compile(schema);
       expect(typeof validate).toBe('function');
     });
   }
@@ -1240,9 +1264,10 @@ describe.skipIf(FIXTURES_DOC_PATH === null)('spec-corpus: fixtures.json catalog
   // FIXTURES_DOC_PATH is non-null here — assertion narrows for TS.
   const fixturesDocPath = FIXTURES_DOC_PATH as string;
   const PACK_MANIFEST_FIXTURES_DIR = join(FIXTURES_DIR, 'pack-manifests');
-  // Top-level workflow fixtures + pack-manifest fixtures from the
-  // sub-directory. Both are documented in fixtures.md so the regex scan
-  // below MUST cover both.
+  const PROMPT_TEMPLATE_FIXTURES_DIR = join(FIXTURES_DIR, 'prompt-templates');
+  // Top-level workflow fixtures + pack-manifest fixtures + prompt-
+  // template fixtures from their respective sub-directories. All are
+  // documented in fixtures.md so the regex scan below MUST cover them.
   const fixtureJsonFiles = [
     ...readdirSync(FIXTURES_DIR)
       .filter((f) => f.endsWith('.json'))
@@ -1250,6 +1275,9 @@ describe.skipIf(FIXTURES_DOC_PATH === null)('spec-corpus: fixtures.json catalog
     ...readdirSync(PACK_MANIFEST_FIXTURES_DIR)
       .filter((f) => f.endsWith('.json'))
       .map((f) => f.replace(/\.json$/, '')),
+    ...readdirSync(PROMPT_TEMPLATE_FIXTURES_DIR)
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => f.replace(/\.json$/, '')),
   ].sort();
 
   it('every fixture id mentioned in fixtures.md has a corresponding JSON', () => {

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

@@ -1,12 +1,12 @@
 /**
- * sql-transaction-atomicity — RFC 0018 advertisement-shape verification + behavioral placeholders.
+ * sql-transaction-atomicity — RFC 0018 advertisement-shape verification + behavioral roundtrip.
  *
- * Status: ACTIVE (advertisement-shape). RFC 0018 promoted to `Active`
- * 2026-05-17. The matching `capabilities.sql` block has landed in
+ * Status: ACTIVE (advertisement-shape + behavioral). 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.
+ * shape against any host that boots the conformance suite, and exercises the
+ * behavioral surface through the `/v1/host/sample/test/surface` seam
+ * (soft-skip with HTTP 404 on hosts that don't expose it).
  *
  * Summary: transactions MUST be atomic; partial failure rolls back.
  *
@@ -61,6 +61,35 @@ describe('sql-transaction-atomicity: advertisement shape (RFC 0018)', () => {
   });
 });
 
-describe('sql-transaction-atomicity: behavioral assertions (placeholders — need host test seam)', () => {
-  it.todo("transaction with N statements where N-th fails → no rows from earlier statements visible");
+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

@@ -1,12 +1,12 @@
 /**
- * stream-subscribe-from-beginning — RFC 0017 advertisement-shape verification + behavioral placeholders.
+ * stream-subscribe-from-beginning — RFC 0017 advertisement-shape verification + behavioral roundtrip.
  *
- * 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.
+ * Status: ACTIVE (advertisement-shape + behavioral). 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
+ * exercises the behavioral surface through the `/v1/host/sample/test/surface`
+ * seam (soft-skip with HTTP 404 on hosts that don't expose it).
  *
  * Summary: Stream subscribers with fromBeginning=true receive records published before subscription.
  *
@@ -61,6 +61,43 @@ describe('stream-subscribe-from-beginning: advertisement shape (RFC 0017)', () =
   });
 });
 
-describe('stream-subscribe-from-beginning: behavioral assertions (placeholders — need host test seam)', () => {
-  it.todo("publish 5 records then subscribe(fromBeginning=true) → consumer receives all 5");
+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

@@ -20,8 +20,9 @@
 
 import { describe, it, expect } from 'vitest';
 import { driver } from '../lib/driver.js';
-import { pollUntilTerminal } from '../lib/polling.js';
+import { pollUntilTerminal, pollUntilStatus } 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';
@@ -86,15 +87,150 @@ describe.skipIf(SKIP)('subworkflow-input-mapping: parent → child variable seed
     )).toBe('prd-1');
   });
 
-  it.todo(
-    'HVMAP-2-unset: parent.currentPrdId unset; child receivedPrdId MUST surface as `undefined` (NOT omitted, NOT `null`). Requires a second parent fixture variant that omits currentPrdId\'s defaultValue.',
-  );
+  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);
+  });
+
+  // HVMAP-2-no-midrun-propagation: `inputMapping` is a one-shot fold at
+  // child-dispatch time. Once the parent's mapping has projected
+  // `currentPrdId → receivedPrdId` and the child has been spawned, any
+  // mid-run mutation to the parent's `currentPrdId` MUST NOT propagate
+  // into the already-seeded child bag. The harness uses the sample-only
+  // test seam `POST /v1/host/sample/test/runs/:runId/variables` (gated
+  // on `OPENWOP_TEST_SEAM_ENABLED=true`; soft-skip when the seam is not
+  // exposed) to mutate the parent's variable bag WHILE the child is
+  // suspended on a `core.approvalGate`, then resolves the gate and reads
+  // the child's terminal `receivedPrdId` variable.
+  const MID_RUN_PARENT = 'conformance-subworkflow-mid-run-mutation';
+  const MID_RUN_CHILD = 'conformance-subworkflow-mid-run-mutation-child';
+  const CHILD_GATE_NODE = 'child-gate';
 
-  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). Requires a multi-step child that suspends + a parent path that mutates.',
-  );
+  it('HVMAP-2-no-midrun-propagation: parent mid-run mutation MUST NOT propagate into the seeded child', async () => {
+    if (!isFixtureAdvertised(MID_RUN_PARENT) || !isFixtureAdvertised(MID_RUN_CHILD)) return; // fixture not seeded — soft-skip
+    if (!(await isToggleAvailable())) return; // sample test seam not exposed — soft-skip
+
+    const create = await driver.post('/v1/runs', { workflowId: MID_RUN_PARENT });
+    expect(create.status).toBe(201);
+    const parentRunId = (create.json as { runId: string }).runId;
 
-  it.todo(
-    'HVMAP-2-refusal: host advertises core.subWorkflow surface but NOT capabilities.subWorkflow.inputMapping: true; workflow with non-empty inputMapping MUST fail registration with validation_error + details.requiredCapability === "subWorkflow.inputMapping". Requires a host-capability-toggle hook in the conformance harness.',
-  );
+    // Wait for the parent to spawn the child and the child to reach
+    // `waiting-approval`. The parent's status mirrors the child's
+    // suspended kind via the dispatcher's parent-suspends-while-child-
+    // suspends contract (interrupt-profiles.md §openwop-interrupt-
+    // cascade-cancel).
+    await pollUntilStatus(parentRunId, 'waiting-approval', { timeoutMs: 15_000 });
+
+    // Find the child runId via the parent snapshot's `childRuns[]`
+    // projection (interrupt-profiles.md §openwop-interrupt-cascade-cancel).
+    const parentSnap = await driver.get(`/v1/runs/${encodeURIComponent(parentRunId)}`);
+    const parentJson = parentSnap.json as { childRuns?: Array<{ runId: string; status: string }> };
+    const childRunId = parentJson.childRuns?.[0]?.runId;
+    expect(childRunId, driver.describe(
+      'fixtures.md conformance-subworkflow-mid-run-mutation',
+      'parent snapshot MUST surface the spawned child runId via childRuns[]',
+    )).toBeDefined();
+
+    // Mutate the parent's `currentPrdId` WHILE the child is suspended.
+    // The mutation MUST NOT propagate per RFC 0022 §B (one-shot fold).
+    const mutate = await driver.post(
+      `/v1/host/sample/test/runs/${encodeURIComponent(parentRunId)}/variables`,
+      { variables: { currentPrdId: 'mutated-id' } },
+    );
+    expect(mutate.status).toBe(200);
+
+    // Resolve the child's approval gate so it terminates.
+    const resolve = await driver.post(
+      `/v1/runs/${encodeURIComponent(childRunId!)}/interrupts/${encodeURIComponent(CHILD_GATE_NODE)}`,
+      { resumeValue: { action: 'accept' } },
+    );
+    expect(resolve.status).toBeGreaterThanOrEqual(200);
+    expect(resolve.status).toBeLessThan(300);
+
+    const childTerminal = (await pollUntilTerminal(childRunId!)) as RunSnapshot;
+    expect(childTerminal.status).toBe('completed');
+
+    // The §B one-shot-fold assertion: the child's terminal
+    // `receivedPrdId` MUST still equal the dispatch-time fold value
+    // (`seeded-id`), NOT the post-mutation parent value (`mutated-id`).
+    expect(
+      childTerminal.variables?.receivedPrdId,
+      driver.describe(
+        'RFCS/0022-dispatch-input-output-mapping.md §B',
+        'mid-run parent mutation MUST NOT propagate; child receivedPrdId stays at dispatch-time fold',
+      ),
+    ).toBe('seeded-id');
+  });
+
+});
+
+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-cursor-pagination.test.ts

@@ -1,12 +1,12 @@
 /**
- * table-cursor-pagination — RFC 0016 advertisement-shape verification + behavioral placeholders.
+ * table-cursor-pagination — RFC 0016 advertisement-shape verification + behavioral roundtrip.
  *
- * Status: ACTIVE (advertisement-shape). RFC 0016 promoted to `Active`
- * 2026-05-17. The matching `capabilities.tableStorage` 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.
+ * Status: ACTIVE (advertisement-shape + behavioral). RFC 0016 promoted to
+ * `Active` 2026-05-17. The matching `capabilities.tableStorage` block has
+ * landed in `schemas/capabilities.schema.json`. This scenario asserts the
+ * advertisement shape against any host that boots the conformance suite, and
+ * exercises the behavioral surface through the `/v1/host/sample/test/surface`
+ * seam (soft-skip with HTTP 404 on hosts that don't expose it).
  *
  * Summary: query MUST support filter + cursor pagination.
  *
@@ -42,6 +42,44 @@ describe('table-cursor-pagination: advertisement shape (RFC 0016)', () => {
   });
 });
 
-describe('table-cursor-pagination: behavioral assertions (placeholders — need host test seam)', () => {
-  it.todo("first page returns N rows + nextCursor; second page resumes; final page returns nextCursor=null");
+async function call(op: string, args: Record<string, unknown>) {
+  return driver.post('/v1/host/sample/test/surface', { tenantId: 'tenant-a', surface: 'table', op, args });
+}
+
+describe('table-cursor-pagination: behavioral (RFC 0016 §B point 3)', () => {
+  it('first page returns N rows + nextCursor; second page resumes; final page returns nextCursor:null', async () => {
+    const probe = await call('query', { table: '__probe__', limit: 1 });
+    if (probe.status === 404) return; // seam not exposed
+    const table = `pag-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    // Seed 5 rows with deterministic ids so cursor ordering is testable.
+    for (let i = 1; i <= 5; i++) {
+      await call('insert', { table, row: { id: `row-${i.toString().padStart(2, '0')}`, n: i } });
+    }
+    // Page 1: limit=2
+    const p1 = await call('query', { table, limit: 2 });
+    const b1 = p1.json as { rows?: Array<{ id: string }>; nextCursor?: string | null };
+    expect(Array.isArray(b1.rows) && b1.rows.length === 2).toBe(true);
+    expect(
+      typeof b1.nextCursor === 'string' && b1.nextCursor.length > 0,
+      driver.describe('RFC 0016 §B point 3', 'first page MUST surface nextCursor when more results remain'),
+    ).toBe(true);
+
+    // Page 2: cursor from page 1, limit=2
+    const p2 = await call('query', { table, limit: 2, cursor: b1.nextCursor });
+    const b2 = p2.json as { rows?: Array<{ id: string }>; nextCursor?: string | null };
+    expect(b2.rows?.length).toBe(2);
+    expect(
+      b2.rows![0]!.id > b1.rows![1]!.id,
+      driver.describe('RFC 0016 §B point 3', 'second page MUST resume AFTER the last id of the previous page'),
+    ).toBe(true);
+
+    // Page 3: final page — only 1 row left, nextCursor MUST be null
+    const p3 = await call('query', { table, limit: 2, cursor: b2.nextCursor });
+    const b3 = p3.json as { rows?: Array<{ id: string }>; nextCursor?: string | null };
+    expect(b3.rows?.length).toBe(1);
+    expect(
+      b3.nextCursor,
+      driver.describe('RFC 0016 §B point 3', 'final page (no more results) MUST surface nextCursor: null'),
+    ).toBe(null);
+  });
 });

package/src/scenarios/table-schema-enforcement.test.ts

@@ -1,12 +1,12 @@
 /**
- * table-schema-enforcement — RFC 0016 advertisement-shape verification + behavioral placeholders.
+ * table-schema-enforcement — RFC 0016 advertisement-shape verification + behavioral roundtrip.
  *
- * Status: ACTIVE (advertisement-shape). RFC 0016 promoted to `Active`
- * 2026-05-17. The matching `capabilities.tableStorage` 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.
+ * Status: ACTIVE (advertisement-shape + behavioral). RFC 0016 promoted to
+ * `Active` 2026-05-17. The matching `capabilities.tableStorage` block has
+ * landed in `schemas/capabilities.schema.json`. This scenario asserts the
+ * advertisement shape against any host that boots the conformance suite, and
+ * exercises the behavioral surface through the `/v1/host/sample/test/surface`
+ * seam (soft-skip with HTTP 404 on hosts that don't expose it).
  *
  * Summary: Subsequent rows MUST conform to the schema established on first insert.
  *
@@ -42,6 +42,43 @@ describe('table-schema-enforcement: advertisement shape (RFC 0016)', () => {
   });
 });
 
-describe('table-schema-enforcement: behavioral assertions (placeholders — need host test seam)', () => {
-  it.todo("first insert declares schema; subsequent insert with wrong column type is rejected");
+async function call(op: string, args: Record<string, unknown>) {
+  return driver.post('/v1/host/sample/test/surface', { tenantId: 'tenant-a', surface: 'table', op, args });
+}
+
+describe('table-schema-enforcement: behavioral (RFC 0016 §B point 2)', () => {
+  it('first insert declares schema; subsequent insert with wrong column type is rejected', async () => {
+    const probe = await call('insert', { table: '__probe__', row: { id: 'probe-0' } });
+    if (probe.status === 404) return; // seam not exposed
+    const table = `sch-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    // First insert — declares the schema from this row's columns.
+    const first = await call('insert', {
+      table,
+      row: { id: 'row-1', name: 'alice', count: 42, active: true },
+    });
+    expect(first.status).toBe(200);
+
+    // Second insert — matching schema; MUST succeed.
+    const second = await call('insert', {
+      table,
+      row: { id: 'row-2', name: 'bob', count: 7, active: false },
+    });
+    expect(second.status).toBe(200);
+
+    // Third insert — `count` declared as number; sending a string MUST be rejected.
+    const bad = await call('insert', {
+      table,
+      row: { id: 'row-3', name: 'mallory', count: 'oops-a-string', active: true },
+    });
+    expect(
+      bad.status >= 400 && bad.status < 500,
+      driver.describe('RFC 0016 §B point 2', 'type-divergent insert MUST be rejected with 4xx'),
+    ).toBe(true);
+    const body = bad.json as { error?: { code?: string } | string };
+    const code = typeof body.error === 'string' ? body.error : body.error?.code;
+    expect(
+      code,
+      driver.describe('RFC 0016 §B point 2', 'rejection MUST carry the table_schema_violation error code'),
+    ).toBe('table_schema_violation');
+  });
 });