@openwop/openwop-conformance 1.2.0 → 1.3.0

package/src/scenarios/replay-llm-cache-key.test.ts

@@ -1,35 +1,176 @@
 /**
- * Cross-host LLM cache-key parity (replay.md §"LLM cache-key recipe").
+ * LLM cache-key recipe — `replay.md §"LLM cache-key recipe"` §A + §B.
  *
- * Verifies that two OpenWOP-compliant hosts replaying the same LLM
- * provider request compute the same cache key. The recipe is normative
- * (replay.md §B): canonical JSON of `(provider, model, messages, tools,
- * temperature, topP, topK, responseFormat)` → SHA-256 → lowercase hex.
+ * Verifies that an OpenWOP host computes the LLM cache key per the
+ * normative recipe: SHA-256 over RFC 8785 JCS-canonicalized JSON of
+ * the closed set of recipe fields (`provider, model, messages, tools,
+ * temperature, topP, topK, responseFormat`).
  *
- * Status: PLACEHOLDER. As of 2026-05-11, neither reference host
- * (`examples/hosts/in-memory/`, `examples/hosts/sqlite/`) implements
- * LLM-calling nodes — both execute only `core.noop` / `core.delay` /
- * `core.approvalGate` fixtures. This scenario lands as `it.todo()` so
- * the contract surface is tracked; assertions land when the first
- * reference host ships an LLM-call node.
+ * The single-host assertions drive the env-gated test seam at
+ * `POST /v1/host/sample/test/llm-cache-key` and recompute the expected
+ * key locally per the recipe, asserting equality. Non-recipe fields
+ * (`max_tokens`, `stop`, `stream`, `seed`, etc.) MUST NOT influence
+ * the key — per §A.
  *
- * What the live scenario WILL exercise (when implemented):
- *   1. Boot host A against `OPENWOP_BASE_URL`.
- *   2. Boot host B against `OPENWOP_BASE_URL_B`.
- *   3. Submit the same workflow + inputs (an LLM-calling fixture).
- *   4. Read each host's emitted `node.completed.payload.cacheKey` (or
- *      equivalent debug-bundle surface).
- *   5. Assert the two hex strings are equal.
+ * The cross-host assertion (two hosts compute the same key) stays
+ * deferred — it requires `OPENWOP_BASE_URL_B` for a second-host probe,
+ * which is operator-supplied and outside this scenario file's scope.
  *
  * @see spec/v1/replay.md §"LLM cache-key recipe"
  */
 
-import { describe, it } from 'vitest';
+import { describe, it, expect } from 'vitest';
+import { createHash } from 'node:crypto';
+import { driver } from '../lib/driver.js';
 
-describe('replay-llm-cache-key: cross-host determinism (placeholder)', () => {
-  it.todo(
-    'two hosts replaying the same LLM provider request compute the same cache key (replay.md §D)',
-  );
-  it.todo('LLM cache key is computed via SHA-256 of canonical JSON per replay.md §B');
-  it.todo('cache key omits non-recipe fields (max_tokens, stop, stream, seed, etc.) per replay.md §A');
+/** Mirror of the reference impl's `canonicalize` so the conformance
+ *  scenario can recompute the expected cache key locally and assert
+ *  equality with what the host returns. RFC 8785 JCS-style:
+ *  sorted-keys, no whitespace, preserve array order. */
+function canonicalize(value: unknown): string {
+  if (value === null) return 'null';
+  if (typeof value === 'boolean' || typeof value === 'number') return JSON.stringify(value);
+  if (typeof value === 'string') return JSON.stringify(value);
+  if (Array.isArray(value)) return '[' + value.map((v) => canonicalize(v)).join(',') + ']';
+  if (typeof value === 'object') {
+    const obj = value as Record<string, unknown>;
+    const keys = Object.keys(obj).sort();
+    return '{' + keys.map((k) => `${JSON.stringify(k)}:${canonicalize(obj[k])}`).join(',') + '}';
+  }
+  return JSON.stringify(value);
+}
+
+function projectRecipe(raw: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = { provider: raw.provider, model: raw.model, messages: raw.messages };
+  if (Array.isArray(raw.tools) && raw.tools.length > 0) {
+    out.tools = [...(raw.tools as Array<{ name: string }>)].sort((a, b) => a.name.localeCompare(b.name));
+  }
+  if (typeof raw.temperature === 'number') out.temperature = raw.temperature;
+  if (typeof raw.topP === 'number') out.topP = raw.topP;
+  if (typeof raw.topK === 'number') out.topK = raw.topK;
+  if (raw.responseFormat && typeof raw.responseFormat === 'object') out.responseFormat = raw.responseFormat;
+  return out;
+}
+
+function expectedCacheKey(input: Record<string, unknown>): string {
+  return createHash('sha256').update(canonicalize(projectRecipe(input)), 'utf8').digest('hex');
+}
+
+async function callSeam(input: Record<string, unknown>): Promise<{ status: number; cacheKey?: string }> {
+  const res = await driver.post('/v1/host/sample/test/llm-cache-key', input);
+  const cacheKey = (res.json as { cacheKey?: string }).cacheKey;
+  return cacheKey !== undefined ? { status: res.status, cacheKey } : { status: res.status };
+}
+
+describe('replay-llm-cache-key: SHA-256-over-JCS recipe (replay.md §B)', () => {
+  it('host cache key MUST equal locally-recomputed SHA-256 over canonical JSON', async () => {
+    const input = {
+      provider: 'anthropic',
+      model: 'claude-3-5-sonnet-20240620',
+      messages: [
+        { role: 'system' as const, content: 'You are a helpful assistant.' },
+        { role: 'user' as const, content: 'What is 2+2?' },
+      ],
+      temperature: 0.7,
+    };
+    const result = await callSeam(input);
+    if (result.status === 404) return; // seam not exposed
+    expect(result.status).toBe(200);
+    expect(
+      result.cacheKey,
+      driver.describe('replay.md §B', 'host cache key MUST be lowercase-hex SHA-256 of the canonical recipe JSON'),
+    ).toBe(expectedCacheKey(input));
+  });
+
+  it('cache key MUST be 64 lowercase-hex characters (SHA-256 output shape)', async () => {
+    const result = await callSeam({
+      provider: 'openai',
+      model: 'gpt-4',
+      messages: [{ role: 'user', content: 'hi' }],
+    });
+    if (result.status === 404) return;
+    expect(result.cacheKey).toMatch(/^[0-9a-f]{64}$/);
+  });
+});
+
+describe('replay-llm-cache-key: non-recipe fields are EXCLUDED (replay.md §A)', () => {
+  it('max_tokens / stop / stream / seed / metadata / user MUST NOT influence the cache key', async () => {
+    const base = {
+      provider: 'openai',
+      model: 'gpt-4',
+      messages: [{ role: 'user', content: 'unit test' }],
+      temperature: 0.5,
+    };
+    const baseResult = await callSeam(base);
+    if (baseResult.status === 404) return;
+
+    // All these non-recipe fields MUST NOT affect the cache key per §A.
+    const noisy = {
+      ...base,
+      max_tokens: 1000,
+      stop: ['STOP'],
+      stream: true,
+      seed: 42,
+      metadata: { traceId: 'abcd' },
+      user: 'unit-test-user',
+    };
+    const noisyResult = await callSeam(noisy);
+    expect(
+      noisyResult.cacheKey,
+      driver.describe(
+        'replay.md §A',
+        'cache key MUST be invariant under non-recipe field changes (max_tokens, stop, stream, seed, metadata, user)',
+      ),
+    ).toBe(baseResult.cacheKey);
+  });
+
+  it('changing a recipe field (temperature) MUST yield a different cache key', async () => {
+    const baseInput = {
+      provider: 'openai',
+      model: 'gpt-4',
+      messages: [{ role: 'user', content: 'diversity-probe' }],
+      temperature: 0.0,
+    };
+    const hotInput = { ...baseInput, temperature: 1.0 };
+    const baseResult = await callSeam(baseInput);
+    if (baseResult.status === 404) return;
+    const hotResult = await callSeam(hotInput);
+    expect(
+      baseResult.cacheKey === hotResult.cacheKey,
+      driver.describe('replay.md §A', 'changing a recipe field MUST yield a different cache key (no false collisions)'),
+    ).toBe(false);
+  });
+});
+
+describe('replay-llm-cache-key: cross-host parity (replay.md §D)', () => {
+  it('two hosts compute the same cache key for the same input (when OPENWOP_BASE_URL_B is configured)', async () => {
+    const otherBaseUrl = process.env.OPENWOP_BASE_URL_B;
+    if (!otherBaseUrl || otherBaseUrl.length === 0) return; // second host not configured — soft-skip
+    const input = {
+      provider: 'anthropic',
+      model: 'claude-3-5-sonnet-20240620',
+      messages: [
+        { role: 'system' as const, content: 'cross-host parity probe' },
+        { role: 'user' as const, content: 'compute the same key' },
+      ],
+      temperature: 0.5,
+    };
+    const a = await callSeam(input);
+    if (a.status === 404) return; // host A doesn't expose the seam
+    const otherApiKey = process.env.OPENWOP_API_KEY_B ?? process.env.OPENWOP_API_KEY ?? '';
+    // Issue the second probe directly via fetch since the driver is bound to
+    // OPENWOP_BASE_URL. Authorization mirrors the suite's default.
+    const resB = await fetch(`${otherBaseUrl.replace(/\/$/, '')}/v1/host/sample/test/llm-cache-key`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${otherApiKey}` },
+      body: JSON.stringify(input),
+    });
+    if (resB.status === 404) return; // host B doesn't expose the seam
+    expect(resB.status).toBe(200);
+    const b = (await resB.json()) as { cacheKey?: string };
+    expect(
+      a.cacheKey,
+      driver.describe('replay.md §D', 'two compliant hosts MUST compute byte-identical cache keys for the same recipe input'),
+    ).toBe(b.cacheKey);
+  });
 });

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

@@ -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/sql-transaction-atomicity.test.ts

@@ -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

@@ -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

@@ -22,6 +22,7 @@ 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';
@@ -86,15 +87,84 @@ 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);
 
-  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.',
-  );
+    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-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.',
+    '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-cursor-pagination.test.ts

@@ -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

@@ -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');
+  });
 });

package/src/scenarios/vector-knn-roundtrip.test.ts

@@ -42,7 +42,47 @@ describe('vector-knn-roundtrip: advertisement shape (RFC 0018)', () => {
   });
 });
 
-describe('vector-knn-roundtrip: behavioral assertions (placeholders — need host test seam)', () => {
-  it.todo("upsert 10 vectors → query with one of them returns it as top-1");
-  it.todo("topK respects the configured limit");
+async function call(op: string, args: Record<string, unknown>) {
+  return driver.post('/v1/host/sample/test/surface', { tenantId: 'tenant-a', surface: 'vector', op, args });
+}
+
+describe('vector-knn-roundtrip: behavioral (RFC 0018 §A.vectorStore)', () => {
+  it('upsert 10 vectors → query with one of them returns it as the top match', async () => {
+    const probe = await call('query', { namespace: '__probe__', vector: [1, 0], topK: 1 });
+    if (probe.status === 404) return; // seam not exposed
+    const namespace = `knn-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const items = Array.from({ length: 10 }, (_, i) => ({
+      id: `vec-${i}`,
+      vector: [Math.cos((i * Math.PI) / 5), Math.sin((i * Math.PI) / 5)],
+    }));
+    const upsertRes = await call('upsert', { namespace, items });
+    expect(upsertRes.status).toBe(200);
+
+    const queryRes = await call('query', { namespace, vector: items[3]!.vector, topK: 1 });
+    expect(queryRes.status).toBe(200);
+    const body = queryRes.json as { matches?: Array<{ id?: string; score?: number }> };
+    expect(Array.isArray(body.matches), 'matches MUST be an array').toBe(true);
+    expect(body.matches!.length).toBeGreaterThan(0);
+    expect(
+      body.matches![0]!.id,
+      driver.describe('RFC 0018 §A.vectorStore', 'query with an indexed vector MUST return it as the top match'),
+    ).toBe('vec-3');
+  });
+
+  it('topK respects the configured limit', async () => {
+    const probe = await call('query', { namespace: '__probe__', vector: [1, 0], topK: 1 });
+    if (probe.status === 404) return;
+    const namespace = `topk-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const items = Array.from({ length: 8 }, (_, i) => ({
+      id: `t-${i}`,
+      vector: [i / 10, 1 - i / 10],
+    }));
+    await call('upsert', { namespace, items });
+    const r3 = await call('query', { namespace, vector: [0.5, 0.5], topK: 3 });
+    const body = r3.json as { matches?: unknown[] };
+    expect(
+      Array.isArray(body.matches) && body.matches.length <= 3,
+      driver.describe('RFC 0018 §A.vectorStore', 'query MUST return at most topK matches'),
+    ).toBe(true);
+  });
 });