@volter/twin-openai 0.1.2 → 2.0.1

package/src/openai-capabilities.ts

@@ -5,30 +5,35 @@
 // `expected:'done'` only on capabilities we genuinely claim, so a broken one shows as a
 // regression. Grow this toward the API's *full* surface every cycle.
 //
-// THE HONEST CARVE-OUTS: `openai.chat.inference` and `openai.embeddings.real_vectors` are the
-// out-of-scope entries — the twin returns a DETERMINISTIC STUB for model generation (no
-// weights) and DETERMINISTIC pseudo-vectors for embeddings, while the protocol envelope (shape/
-// streaming/tool_calls/usage) is faithful. `openai.images.real_pixels` and
-// `openai.files.real_bytes` carve out the binary content. Surfaced here + in README ## Coverage.
+// Every capability is done or todo. A twin is a deterministic, offline model of the vendor's API
+// contract; the labeled stub completion and the deterministic pseudo-vector ARE the twin's
+// answer (see `openai.chat.stub_labeled`, `openai.embeddings.deterministic`), not a shortfall
+// from a "real" one. Every entry here is either done or todo.
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { checkCapabilities, type CapabilityReport, type CapabilitySpec, verifyBoundary, isInfrastructureError, harnessError } from '@volter/twin-tooling';
+import { checkCapabilities, type CapabilityReport, type CapabilitySpec, verifyBoundary, isInfrastructureError, harnessError } from '@volter/world-tooling';
 import { handleOpenAITwinRequest, type OpenAIResponseEnvelope } from './openai-twin.ts';
+import { audioFormat, imageFormat, placeholderPng, wavSeconds } from './openai-media.ts';
+import { createOpenAITwinFetch } from './openai-server.ts';
 import { buildSignedOpenAIWebhook, verifyOpenAIWebhook, OpenAIWebhookVerificationError, computeOpenAIWebhookSignature } from './openai-webhooks.ts';
 import type { SseEvent } from './openai-types.ts';
 
-// (OpenAI is an API-first vendor with no meaningful product UI worth mirroring — ARCHITECTURE.md
+// (OpenAI is an API-first vendor with no meaningful product UI worth mirroring — docs/contributing/architecture.md
 // C1b — so this pack ships no mirror, and there are no UI capabilities to verify.)
 
 // ── API verify: drive REAL requests against a fresh temp root, then assert status/shape ──
-type Step = { m: string; p: string; b?: unknown };
+type Step = { m: string; p: string; b?: unknown; at?: string };
+/** The World instant the checks run at unless a step names one: 2026-01-01, when every model and API family the checks
+ *  use is live on OpenAI's timeline (./openai-models.ts: dall-e until 2026-05-12, the Assistants API until 2026-08-26,
+ *  fine-tuning by a new organization until 2026-05-07). */
+const CHECKS_AT = '2026-01-01T00:00:00.000Z';
 type Body = Record<string, any>;
 
 /** Run a sequence of real OpenAI requests against an isolated root; return all responses. */
 async function withRoot(steps: (h: (s: Step) => Promise<OpenAIResponseEnvelope>) => Promise<boolean>): Promise<boolean> {
   const root = mkdtempSync(join(tmpdir(), 'openai-cap-'));
-  const h = (s: Step) => handleOpenAITwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root });
+  const h = (s: Step) => handleOpenAITwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : s.b instanceof FormData ? s.b : JSON.stringify(s.b), root, occurredAt: s.at ?? CHECKS_AT });
   try {
     return await verifyBoundary('openai.withRoot', () => steps(h));
   } finally {
@@ -41,7 +46,7 @@ function withStream(body: unknown, fn: (events: SseEvent[], final: OpenAIRespons
   return new Promise<boolean>((resolve, reject) => {
     const root = mkdtempSync(join(tmpdir(), 'openai-cap-'));
     const events: SseEvent[] = [];
-    handleOpenAITwinRequest({ method: 'POST', path: bodyPath(body), body: JSON.stringify(body), root, sseSink: (e) => events.push(e) })
+    handleOpenAITwinRequest({ method: 'POST', path: bodyPath(body), body: JSON.stringify(body), root, occurredAt: CHECKS_AT, sseSink: (e) => events.push(e) })
       .then((final) => resolve(fn(events, final)))
       .catch((err) => { if (isInfrastructureError(err)) reject(harnessError('openai.withStream', err)); else resolve(false); })
       .finally(() => rmSync(root, { recursive: true, force: true }));
@@ -51,12 +56,12 @@ function bodyPath(body: unknown): string {
   return body && typeof body === 'object' && 'input' in (body as Record<string, unknown>) ? '/v1/responses' : '/v1/chat/completions';
 }
 
-/** Like withRoot, but the request helper passes request HEADERS through (for auth/rate-limit/
- *  idempotency, which the trusted no-headers withRoot helper deliberately never triggers). */
+/** Like withRoot, but the request helper passes request HEADERS through (for auth and rate-limit,
+ *  which the trusted no-headers withRoot helper deliberately never triggers). */
 type StepH = Step & { headers?: Record<string, string> };
 async function withRootH(steps: (h: (s: StepH) => Promise<OpenAIResponseEnvelope>) => Promise<boolean>): Promise<boolean> {
   const root = mkdtempSync(join(tmpdir(), 'openai-cap-'));
-  const h = (s: StepH) => handleOpenAITwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root, ...(s.headers ? { headers: s.headers } : {}) });
+  const h = (s: StepH) => handleOpenAITwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root, occurredAt: CHECKS_AT, ...(s.headers ? { headers: s.headers } : {}) });
   try {
     return await verifyBoundary('openai.withRootH', () => steps(h));
   } finally {
@@ -67,24 +72,40 @@ async function withRootH(steps: (h: (s: StepH) => Promise<OpenAIResponseEnvelope
 const ok = (r: OpenAIResponseEnvelope) => r.status >= 200 && r.status < 300;
 const id = (r: OpenAIResponseEnvelope) => (r.body as Body)?.id as string;
 const field = (r: OpenAIResponseEnvelope, k: string) => (r.body as Body)?.[k];
+/** A response's text, as the SDKs' `output_text` aggregates it from its message items (the wire carries no `output_text`). */
+const outputText = (r: OpenAIResponseEnvelope): string => (((r.body as Body)?.output ?? []) as Body[]).filter((i) => i.type === 'message').flatMap((i) => (i.content ?? []) as Body[]).filter((c) => c.type === 'output_text').map((c) => String(c.text)).join('');
+
+/** A multipart upload: text fields and one file part of the given bytes. */
+function form(fields: Record<string, string>, name: string, bytes: Uint8Array, filename: string, type: string): FormData {
+  const f = new FormData();
+  for (const [k, v] of Object.entries(fields)) f.append(k, v);
+  f.append(name, new File([bytes as Uint8Array<ArrayBuffer>], filename, { type }));
+  return f;
+}
+/** A tenth of a second of 8 kHz 8-bit mono silence as a WAV file. */
+const SILENT_WAV = (() => {
+  const data = 800;
+  const b = new Uint8Array(44 + data).fill(0x80);
+  const v = new DataView(b.buffer);
+  b.set([...'RIFF'].map((c) => c.charCodeAt(0)), 0);
+  v.setUint32(4, 36 + data, true);
+  b.set([...'WAVEfmt '].map((c) => c.charCodeAt(0)), 8);
+  v.setUint32(16, 16, true); v.setUint16(20, 1, true); v.setUint16(22, 1, true); v.setUint32(24, 8000, true); v.setUint32(28, 8000, true); v.setUint16(32, 1, true); v.setUint16(34, 8, true);
+  b.set([...'data'].map((c) => c.charCodeAt(0)), 36);
+  v.setUint32(40, data, true);
+  return b;
+})();
 
 // ── shorthands (mirror the stripe/anthropic manifests) ──
 const done = (id: string, area: string, title: string, dimension: CapabilitySpec['dimension'], tier: CapabilitySpec['tier'], verify: CapabilitySpec['verify']): CapabilitySpec => ({ id, area, title, dimension, tier, expected: 'done', verify });
 const todo = (id: string, area: string, title: string, dimension: CapabilitySpec['dimension'], tier: CapabilitySpec['tier']): CapabilitySpec => ({ id, area, title, dimension, tier, expected: 'todo' });
-const outOfScope = (id: string, area: string, title: string, dimension: CapabilitySpec['dimension'], tier: CapabilitySpec['tier'], reason: string): CapabilitySpec => ({ id, area, title, dimension, tier, expected: 'todo', outOfScope: reason });
 
 const CHAT = (extra: Record<string, unknown> = {}) => ({ model: 'gpt-4o', messages: [{ role: 'user', content: 'hello twin' }], ...extra });
 
 export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
   // ── THE HONEST CARVE-OUTS ─────────────────────────────────────────────────────────────
-  outOfScope('openai.chat.inference', 'chat', 'Real model inference (generation from model weights)', 'api', 'core',
-    'Out of scope: the twin cannot run the model — chat/responses return a DETERMINISTIC STUB completion (clearly labeled), never real model output. The protocol envelope (shape/streaming/tool_calls/usage) is faithful; only the generated text is a stub.'),
-  outOfScope('openai.embeddings.real_vectors', 'embeddings', 'Real embedding vectors (semantic values)', 'api', 'core',
-    'Out of scope: the twin cannot run the embedding model — /v1/embeddings returns DETERMINISTIC pseudo-vectors seeded from the input hash. The shape, dimensions, and determinism are faithful; the values carry no semantic meaning.'),
-  outOfScope('openai.images.real_pixels', 'images', 'Real image pixels (generated image bytes)', 'api', 'common',
-    'Out of scope: the twin cannot run the image model — /v1/images/generations returns the faithful response shape with a placeholder URL/revised_prompt; no real pixels are produced.'),
-  outOfScope('openai.files.real_bytes', 'files', 'Real opaque file storage of arbitrary bytes', 'api', 'niche',
-    'Out of scope: the twin stores file metadata + supplied text content faithfully, but does not persist arbitrary binary blobs as a real object store would.'),
+  todo('openai.images.served_bytes', 'images', 'Image URLs resolve: the twin serves deterministic placeholder image bytes at the URLs it returns (today they point at the dead twin.invalid host)', 'api', 'common'),
+  todo('openai.files.binary_content', 'files', 'Files: persist and return arbitrary binary content, not only supplied text (a blob store, as the S3 twin already does)', 'api', 'niche'),
 
   // ── Chat Completions (the protocol envelope — faithful) ────────────────────────────────
   done('openai.chat.create', 'chat', 'Chat: create → faithful envelope (id/object/created/model/choices/usage)', 'api', 'core', () =>
@@ -423,7 +444,7 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
   done('openai.responses.stub_labeled', 'responses', 'Responses stub output is clearly labeled (not real output)', 'api', 'core', () =>
     withRoot(async (h) => {
       const r = await h({ m: 'POST', p: '/v1/responses', b: { model: 'gpt-4o', input: 'echo me responses' } });
-      const text = (r.body as Body).output_text as string;
+      const text = outputText(r);
       return ok(r) && text.includes('[twin-stub') && text.includes('echo me responses');
     }),
   ),
@@ -440,11 +461,11 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       return noModel.status === 400 && noInput.status === 400;
     }),
   ),
-  done('openai.responses.streaming', 'responses', 'Responses streaming events (created → output_text.delta → completed → [DONE])', 'api', 'common', () =>
+  done('openai.responses.streaming', 'responses', 'Responses streaming events (created → output_text.delta → completed, no sentinel)', 'api', 'common', () =>
     withStream({ model: 'gpt-4o', input: 'stream responses', stream: true }, (events) => {
       const types = events.filter((e) => !e.done).map((e) => e.data!.type);
-      const doneLast = events[events.length - 1]?.done === true;
-      return types.includes('response.created') && types.includes('response.output_text.delta') && types.includes('response.completed') && doneLast;
+      const completedLast = types[types.length - 1] === 'response.completed' && !events.some((e) => e.done);
+      return types.includes('response.created') && types.includes('response.output_text.delta') && completedLast;
     }),
   ),
   done('openai.responses.retrieve', 'responses', 'Responses: stored by default, retrieve + delete by id (+ 404)', 'api', 'common', () =>
@@ -452,7 +473,7 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       const c = await h({ m: 'POST', p: '/v1/responses', b: { model: 'gpt-4o', input: 'store me' } });
       if (!ok(c)) return false;
       const g = await h({ m: 'GET', p: `/v1/responses/${id(c)}` });
-      if (!ok(g) || id(g) !== id(c) || (g.body as Body).object !== 'response' || (g.body as Body).output_text !== (c.body as Body).output_text) return false;
+      if (!ok(g) || id(g) !== id(c) || (g.body as Body).object !== 'response' || outputText(g) !== outputText(c)) return false;
       const del = await h({ m: 'DELETE', p: `/v1/responses/${id(c)}` });
       if (!ok(del) || (del.body as Body).deleted !== true) return false;
       const after = await h({ m: 'GET', p: `/v1/responses/${id(c)}` });
@@ -463,17 +484,16 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       return after.status === 404 && missing.status === 404 && nsGet.status === 404;
     }),
   ),
-  outOfScope('openai.responses.tools', 'responses', 'Responses built-in tools (web_search/file_search/computer_use)', 'api', 'niche',
-    'Out of scope: the hosted built-in tools (web_search, computer_use, code_interpreter) require live model+infrastructure side effects the twin cannot reproduce offline — faking a web_search result or a computer_use action would fabricate output and violate the honest-stub contract. (User-defined function tools ARE modeled via openai.tools.*.)'),
+  todo('openai.responses.tools', 'responses', 'Responses built-in tools (web_search/file_search/computer_use/code_interpreter): the tool-call envelope with a deterministic, labeled twin-stub result, exactly as chat stubs generation (user-defined function tools are already modeled via openai.tools.*)', 'api', 'niche'),
   done('openai.responses.reasoning', 'responses', 'Responses reasoning items + reasoning.effort (faithful reasoning item shape; labeled stub summary)', 'api', 'niche', () =>
     withRoot(async (h) => {
-      // no reasoning param → no reasoning item, no reasoning_tokens
-      const plain = await h({ m: 'POST', p: '/v1/responses', b: { model: 'o4-mini', input: 'think about this' } });
+      // a model that does not reason → no reasoning item, no reasoning_tokens
+      const plain = await h({ m: 'POST', p: '/v1/responses', b: { model: 'gpt-4o', input: 'think about this' } });
       if (!ok(plain)) return false;
       if ((plain.body as Body).output.some((o: Body) => o.type === 'reasoning')) return false;
-      if ((plain.body as Body).usage.output_tokens_details !== undefined) return false;
-      // reasoning.effort:'high' → a reasoning item (labeled stub) BEFORE the message item + reasoning_tokens
-      const r = await h({ m: 'POST', p: '/v1/responses', b: { model: 'o4-mini', input: 'think about this', reasoning: { effort: 'high' } } });
+      if ((plain.body as Body).usage.output_tokens_details?.reasoning_tokens !== 0) return false;
+      // reasoning.effort:'high' with a summary asked for → a reasoning item (labeled stub summary) BEFORE the message item + reasoning_tokens
+      const r = await h({ m: 'POST', p: '/v1/responses', b: { model: 'o4-mini', input: 'think about this', reasoning: { effort: 'high', summary: 'auto' } } });
       if (!ok(r)) return false;
       const b = r.body as Body;
       const items = b.output as Body[];
@@ -607,7 +627,9 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
   ),
   done('openai.models.delete', 'models', 'Delete a fine-tuned model (job output); base models refuse; 404 unknown', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const job = await h({ m: 'POST', p: '/v1/fine_tuning/jobs', b: { model: 'gpt-4o-mini', training_file: 'file-train' } });
+      const created = await h({ m: 'POST', p: '/v1/fine_tuning/jobs', b: { model: 'gpt-4o-mini', training_file: 'file-train' } });
+      // the model exists once the job has trained: a read observes that
+      const job = await h({ m: 'GET', p: `/v1/fine_tuning/jobs/${id(created)}` });
       const ftModel = (job.body as Body).fine_tuned_model as string;
       // the minted fine-tuned model is retrievable + listed
       const ret = await h({ m: 'GET', p: `/v1/models/${encodeURIComponent(ftModel)}` });
@@ -704,7 +726,10 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       const r = await h({ m: 'POST', p: '/v1/batches', b: { input_file_id: 'file-x', endpoint: '/v1/chat/completions', completion_window: '24h' } });
       if (!ok(r) || (r.body as Body).object !== 'batch' || !String(id(r)).startsWith('batch-')) return false;
       const b = r.body as Body;
-      return b.endpoint === '/v1/chat/completions' && b.status === 'completed' && typeof b.output_file_id === 'string';
+      if (b.endpoint !== '/v1/chat/completions' || b.status !== 'validating' || b.output_file_id !== null) return false;
+      // OpenAI works the batch on its own: a read finds it completed with its output file
+      const g = await h({ m: 'GET', p: `/v1/batches/${id(r)}` });
+      return field(g, 'status') === 'completed' && typeof field(g, 'output_file_id') === 'string';
     }),
   ),
   done('openai.batches.retrieve', 'batches', 'Batches: retrieve by id (+ 404 unknown)', 'api', 'core', () =>
@@ -722,12 +747,16 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       return ok(l) && (l.body as Body).object === 'list' && (l.body as Body).data.length === 1;
     }),
   ),
-  done('openai.batches.cancel', 'batches', 'Batches: cancel sets status cancelled (404 unknown)', 'api', 'common', () =>
+  done('openai.batches.cancel', 'batches', 'Batches: cancel an in-flight batch (cancelling, then cancelled; 409 once done; 404 unknown)', 'api', 'common', () =>
     withRoot(async (h) => {
       const c = await h({ m: 'POST', p: '/v1/batches', b: { input_file_id: 'file-x', endpoint: '/v1/chat/completions', completion_window: '24h' } });
       const cancel = await h({ m: 'POST', p: `/v1/batches/${id(c)}/cancel` });
+      if (!ok(cancel) || field(cancel, 'status') !== 'cancelling') return false;
+      const read = await h({ m: 'GET', p: `/v1/batches/${id(c)}` });
+      if (field(read, 'status') !== 'cancelled') return false;
+      const again = await h({ m: 'POST', p: `/v1/batches/${id(c)}/cancel` });
       const missing = await h({ m: 'POST', p: '/v1/batches/batch-nope/cancel' });
-      return ok(cancel) && field(cancel, 'status') === 'cancelled' && missing.status === 404;
+      return again.status === 409 && missing.status === 404;
     }),
   ),
   done('openai.batches.validation', 'batches', 'Batches: input_file_id/endpoint/completion_window required', 'api', 'common', () =>
@@ -744,17 +773,18 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       // a real, well-formed batch id + object/fields must exist — not merely "both sides undefined".
       if (typeof cid !== 'string' || !cid.startsWith('batch-')) return false;
       const cb = c.body as Body;
-      if (cb.object !== 'batch' || cb.input_file_id !== 'file-x' || cb.status !== 'completed') return false;
+      if (cb.object !== 'batch' || cb.input_file_id !== 'file-x' || cb.status !== 'validating') return false;
       const g1 = await h({ m: 'GET', p: `/v1/batches/${cid}` });
       const g2 = await h({ m: 'GET', p: `/v1/batches/${cid}` });
       // the GET must actually round-trip the persisted resource's real fields (kernel-backed) —
       // not merely a matching-because-undefined id.
       const same = (r: OpenAIResponseEnvelope) => {
         const rb = r.body as Body;
-        return rb.object === 'batch' && rb.input_file_id === cb.input_file_id && rb.endpoint === cb.endpoint &&
-          rb.status === cb.status && rb.output_file_id === cb.output_file_id;
+        return rb.object === 'batch' && rb.input_file_id === cb.input_file_id && rb.endpoint === cb.endpoint;
       };
-      return ok(g1) && ok(g2) && id(g1) === cid && id(g2) === cid && same(g1) && same(g2);
+      // the first read observes the vendor's work; the second reads what it stored
+      return ok(g1) && ok(g2) && id(g1) === cid && id(g2) === cid && same(g1) && same(g2) &&
+        field(g1, 'status') === 'completed' && field(g2, 'status') === 'completed' && field(g2, 'output_file_id') === field(g1, 'output_file_id');
     }),
   ),
 
@@ -764,7 +794,10 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       const r = await h({ m: 'POST', p: '/v1/fine_tuning/jobs', b: { model: 'gpt-4o-mini', training_file: 'file-train' } });
       if (!ok(r) || (r.body as Body).object !== 'fine_tuning.job' || !String(id(r)).startsWith('ftjob-')) return false;
       const b = r.body as Body;
-      return b.model === 'gpt-4o-mini' && b.status === 'succeeded' && String(b.fine_tuned_model).startsWith('ft:');
+      if (b.model !== 'gpt-4o-mini' || b.status !== 'validating_files' || b.fine_tuned_model !== null) return false;
+      // OpenAI trains on its own: a read finds the job succeeded with its model
+      const g = await h({ m: 'GET', p: `/v1/fine_tuning/jobs/${id(r)}` });
+      return field(g, 'status') === 'succeeded' && String(field(g, 'fine_tuned_model')).startsWith('ft:');
     }),
   ),
   done('openai.fine_tuning.retrieve', 'fine_tuning', 'Fine-tuning: retrieve + list jobs', 'api', 'common', () =>
@@ -867,10 +900,10 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       const batch = await h({ m: 'POST', p: `/v1/vector_stores/${id(vs)}/file_batches`, b: { file_ids: ['file-a', 'file-b', 'file-c'] } });
       if (!ok(batch)) return false;
       const bb = batch.body as Body;
-      if (bb.object !== 'vector_store.file_batch' || bb.status !== 'completed' || bb.file_counts?.total !== 3) return false;
-      // retrieve the batch
+      if (bb.object !== 'vector_store.files_batch' || bb.status !== 'in_progress' || bb.file_counts?.total !== 3) return false;
+      // retrieve the batch: the read observes OpenAI's processing done
       const get = await h({ m: 'GET', p: `/v1/vector_stores/${id(vs)}/file_batches/${bb.id}` });
-      if (!ok(get) || (get.body as Body).id !== bb.id) return false;
+      if (!ok(get) || (get.body as Body).id !== bb.id || (get.body as Body).status !== 'completed') return false;
       // list this batch's files
       const files = await h({ m: 'GET', p: `/v1/vector_stores/${id(vs)}/file_batches/${bb.id}/files` });
       if (!ok(files) || ((files.body as Body).data as Body[]).length !== 3) return false;
@@ -900,56 +933,65 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       return r.status === 400 && (r.body as Body).error?.param === 'prompt';
     }),
   ),
-  done('openai.images.edits', 'images', 'Image edits (image+prompt) + variations (image) → faithful response shape', 'api', 'niche', () =>
+  done('openai.images.edits', 'images', 'Image edits (an image file + prompt; base64 PNG from a GPT image model) + variations (a square PNG) → faithful response shape; a text upload refused', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const edit = await h({ m: 'POST', p: '/v1/images/edits', b: { image: 'base.png', prompt: 'add a hat' } });
-      if (!ok(edit) || typeof (edit.body as Body).created !== 'number' || typeof (edit.body as Body).data[0].url !== 'string') return false;
-      const varn = await h({ m: 'POST', p: '/v1/images/variations', b: { image: 'base.png', n: 2 } });
+      const png = placeholderPng({ width: 64, height: 64 }, 'base');
+      const edit = await h({ m: 'POST', p: '/v1/images/edits', b: form({ model: 'gpt-image-1', prompt: 'add a hat' }, 'image', png, 'base.png', 'image/png') });
+      const b64 = (edit.body as Body).data?.[0]?.b64_json;
+      if (!ok(edit) || typeof (edit.body as Body).created !== 'number' || typeof b64 !== 'string' || imageFormat(Uint8Array.from(atob(b64), (c) => c.charCodeAt(0))) !== 'png') return false;
+      const varn = await h({ m: 'POST', p: '/v1/images/variations', b: form({ n: '2' }, 'image', png, 'base.png', 'image/png') });
       if (!ok(varn) || ((varn.body as Body).data as Body[]).length !== 2) return false;
-      // validation: edits require image AND prompt; variations require image
+      // validation: edits require image AND prompt, an image file; variations require a square png
       const noImg = await h({ m: 'POST', p: '/v1/images/edits', b: { prompt: 'x' } });
-      const noPrompt = await h({ m: 'POST', p: '/v1/images/edits', b: { image: 'base.png' } });
-      const varNoImg = await h({ m: 'POST', p: '/v1/images/variations', b: {} });
-      return noImg.status === 400 && noPrompt.status === 400 && varNoImg.status === 400;
+      const noPrompt = await h({ m: 'POST', p: '/v1/images/edits', b: form({ model: 'gpt-image-1' }, 'image', png, 'base.png', 'image/png') });
+      const text = await h({ m: 'POST', p: '/v1/images/edits', b: form({ model: 'gpt-image-1', prompt: 'x' }, 'image', new TextEncoder().encode('PNG-base'), 'base.png', 'image/png') });
+      const wide = await h({ m: 'POST', p: '/v1/images/variations', b: form({}, 'image', placeholderPng({ width: 64, height: 32 }, 'wide'), 'wide.png', 'image/png') });
+      return noImg.status === 400 && noPrompt.status === 400 && text.status === 400 && (text.body as Body).error?.param === 'image' && wide.status === 400;
     }),
   ),
 
   // ── Audio ─────────────────────────────────────────────────────────────────────────────
-  done('openai.audio.transcriptions', 'audio', 'Audio transcriptions: labeled stub transcript, json + verbose_json + text shapes', 'api', 'common', () =>
+  done('openai.audio.transcriptions', 'audio', 'Audio transcriptions: labeled stub transcript of an audio file, json + verbose_json + text shapes; a text upload refused', 'api', 'common', () =>
     withRoot(async (h) => {
-      const j = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { file: 'speech.mp3', model: 'whisper-1' } });
+      const speech = (extra: Record<string, string>) => form({ model: 'whisper-1', ...extra }, 'file', SILENT_WAV, 'speech.wav', 'audio/wav');
+      const j = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: speech({}) });
       if (!ok(j) || typeof (j.body as Body).text !== 'string' || !String((j.body as Body).text).includes('[twin-stub')) return false;
-      const v = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { file: 'speech.mp3', model: 'whisper-1', response_format: 'verbose_json' } });
-      if (!ok(v) || (v.body as Body).task !== 'transcription' || !Array.isArray((v.body as Body).segments)) return false;
-      const t = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { file: 'speech.mp3', model: 'whisper-1', response_format: 'text' } });
+      const v = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: speech({ response_format: 'verbose_json' }) });
+      if (!ok(v) || (v.body as Body).task !== 'transcribe' || !Array.isArray((v.body as Body).segments)) return false;
+      const t = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: speech({ response_format: 'text' }) });
       if (!ok(t) || typeof t.body !== 'string') return false;
       const noFile = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { model: 'whisper-1' } });
-      const noModel = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { file: 'speech.mp3' } });
-      return noFile.status === 400 && (noFile.body as Body).error?.param === 'file' && noModel.status === 400;
+      const noModel = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: form({}, 'file', SILENT_WAV, 'speech.wav', 'audio/wav') });
+      const text = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: form({ model: 'whisper-1' }, 'file', new TextEncoder().encode('M4A-speech'), 'speech.m4a', 'audio/mp4') });
+      return noFile.status === 400 && (noFile.body as Body).error?.param === 'file' && noModel.status === 400 && text.status === 400 && (text.body as Body).error?.param === 'file';
     }),
   ),
   done('openai.audio.translations', 'audio', 'Audio translations: labeled stub, task translation, english language', 'api', 'niche', () =>
     withRoot(async (h) => {
-      const v = await h({ m: 'POST', p: '/v1/audio/translations', b: { file: 'foreign.mp3', model: 'whisper-1', response_format: 'verbose_json' } });
+      const v = await h({ m: 'POST', p: '/v1/audio/translations', b: form({ model: 'whisper-1', response_format: 'verbose_json' }, 'file', SILENT_WAV, 'foreign.wav', 'audio/wav') });
       const noFile = await h({ m: 'POST', p: '/v1/audio/translations', b: { model: 'whisper-1' } });
       return ok(v) && (v.body as Body).task === 'translation' && (v.body as Body).language === 'english' && noFile.status === 400;
     }),
   ),
-  done('openai.audio.speech', 'audio', 'Text-to-speech: deterministic labeled audio payload (+ model/input/voice required)', 'api', 'common', () =>
-    withRoot(async (h) => {
-      const r = await h({ m: 'POST', p: '/v1/audio/speech', b: { model: 'tts-1', input: 'hello world', voice: 'alloy' } });
-      if (!ok(r) || (r.body as Body).object !== 'audio.speech' || typeof (r.body as Body).audio_base64 !== 'string') return false;
-      // deterministic: same input → same payload; decoded marker labels it a stub
-      const r2 = await h({ m: 'POST', p: '/v1/audio/speech', b: { model: 'tts-1', input: 'hello world', voice: 'alloy' } });
-      if ((r.body as Body).audio_base64 !== (r2.body as Body).audio_base64) return false;
-      if (!atob((r.body as Body).audio_base64 as string).includes('[twin-stub-audio]')) return false;
-      const noVoice = await h({ m: 'POST', p: '/v1/audio/speech', b: { model: 'tts-1', input: 'x' } });
-      const noInput = await h({ m: 'POST', p: '/v1/audio/speech', b: { model: 'tts-1', voice: 'alloy' } });
-      return noVoice.status === 400 && (noVoice.body as Body).error?.param === 'voice' && noInput.status === 400;
-    }),
-  ),
-  outOfScope('openai.audio.realtime', 'audio', 'Realtime API (websocket sessions)', 'api', 'niche',
-    'Out of scope: the Realtime API is a stateful bidirectional WebSocket carrying live audio to/from a running speech model — both the transport and the real-time model inference are irreproducible offline. The twin runs no model and the verify() harness is HTTP/offline, so a faithful realtime session cannot be modeled without fabrication.'),
+  done('openai.audio.speech', 'audio', 'Text-to-speech: the audio file itself in the requested format with its Content-Type (mp3 by default, wav), a real file of silence (+ model/input/voice required)', 'api', 'common', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'openai-cap-'));
+    try {
+      return await verifyBoundary('openai.audio.speech', async () => {
+        const fetch = createOpenAITwinFetch({ root });
+        const speak = (b: unknown) => fetch(new Request('https://api.openai.com/v1/audio/speech', { method: 'POST', headers: { authorization: 'Bearer sk-twin', 'content-type': 'application/json' }, body: JSON.stringify(b) }));
+        const mp3 = await speak({ model: 'tts-1', input: 'hello world', voice: 'alloy' });
+        if (mp3.status !== 200 || mp3.headers.get('content-type') !== 'audio/mpeg' || audioFormat(new Uint8Array(await mp3.arrayBuffer())) !== 'mp3') return false;
+        const wav = await speak({ model: 'tts-1', input: 'hello world', voice: 'alloy', response_format: 'wav' });
+        if (wav.headers.get('content-type') !== 'audio/wav' || wavSeconds(new Uint8Array(await wav.arrayBuffer())) !== 1) return false;
+        const noVoice = await speak({ model: 'tts-1', input: 'x' });
+        const noInput = await speak({ model: 'tts-1', voice: 'alloy' });
+        return noVoice.status === 400 && ((await noVoice.json()) as Body).error?.param === 'voice' && noInput.status === 400;
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  }),
+  todo('openai.audio.realtime', 'audio', 'Realtime API: the stateful bidirectional websocket session protocol with deterministic labeled stub audio/text events (the repo serves other non-HTTP wire protocols over the kernel)', 'api', 'niche'),
 
   // ── Assistants (beta) ─────────────────────────────────────────────────────────────────
   done('openai.assistants.crud', 'assistants', 'Assistants: create/retrieve/update/list/delete (+ model required, 404)', 'api', 'niche', () =>
@@ -1010,17 +1052,17 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       const noAsst = await h({ m: 'POST', p: `/v1/threads/${id(t)}/runs`, b: {} });
       const badAsst = await h({ m: 'POST', p: `/v1/threads/${id(t)}/runs`, b: { assistant_id: 'asst-nope' } });
       if (noAsst.status !== 400 || badAsst.status !== 404) return false;
-      // create a run → completed, stub assistant reply appended to the thread
+      // create a run → queued, as OpenAI queues it
       const run = await h({ m: 'POST', p: `/v1/threads/${id(t)}/runs`, b: { assistant_id: id(a) } });
-      if (!ok(run) || !String(id(run)).startsWith('run-') || (run.body as Body).object !== 'thread.run' || (run.body as Body).status !== 'completed') return false;
+      if (!ok(run) || !String(id(run)).startsWith('run-') || (run.body as Body).object !== 'thread.run' || (run.body as Body).status !== 'queued') return false;
       if ((run.body as Body).assistant_id !== id(a) || (run.body as Body).thread_id !== id(t)) return false;
+      // retrieving it observes the run completing
+      const gr = await h({ m: 'GET', p: `/v1/threads/${id(t)}/runs/${id(run)}` });
+      if (!ok(gr) || id(gr) !== id(run) || field(gr, 'status') !== 'completed') return false;
       // the thread now has the user turn + the stub assistant reply
       const msgs = ((await h({ m: 'GET', p: `/v1/threads/${id(t)}/messages` })).body as Body).data as Body[];
       const assistantMsg = msgs.find((mm) => mm.role === 'assistant');
       if (!assistantMsg || !String(assistantMsg.content[0].text.value).includes('[twin-stub')) return false;
-      // retrieve the run + list runs
-      const gr = await h({ m: 'GET', p: `/v1/threads/${id(t)}/runs/${id(run)}` });
-      if (!ok(gr) || id(gr) !== id(run)) return false;
       const lr = await h({ m: 'GET', p: `/v1/threads/${id(t)}/runs` });
       if (((lr.body as Body).data as Body[]).length !== 1) return false;
       // run steps: a message_creation step pointing at the reply message
@@ -1030,9 +1072,12 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       if (sd[0]!.step_details.message_creation.message_id !== assistantMsg.id) return false;
       const gs = await h({ m: 'GET', p: `/v1/threads/${id(t)}/runs/${id(run)}/steps/${sd[0]!.id}` });
       if (!ok(gs) || (gs.body as Body).id !== sd[0]!.id) return false;
-      // cancel
-      const cancel = await h({ m: 'POST', p: `/v1/threads/${id(t)}/runs/${id(run)}/cancel` });
-      if (!ok(cancel) || (cancel.body as Body).status !== 'cancelled') return false;
+      // cancel a fresh run while it is queued → cancelling, then cancelled; a completed run refuses
+      const run2 = await h({ m: 'POST', p: `/v1/threads/${id(t)}/runs`, b: { assistant_id: id(a) } });
+      const cancel = await h({ m: 'POST', p: `/v1/threads/${id(t)}/runs/${id(run2)}/cancel` });
+      if (!ok(cancel) || field(cancel, 'status') !== 'cancelling') return false;
+      if (field(await h({ m: 'GET', p: `/v1/threads/${id(t)}/runs/${id(run2)}` }), 'status') !== 'cancelled') return false;
+      if ((await h({ m: 'POST', p: `/v1/threads/${id(t)}/runs/${id(run)}/cancel` })).status !== 400) return false;
       const badRun = await h({ m: 'GET', p: `/v1/threads/${id(t)}/runs/run-nope` });
       return badRun.status === 404;
     }),
@@ -1074,11 +1119,11 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       if ((upd.body as Body).name !== 'Alpha2') return false;
       const arch = await h({ m: 'POST', p: `/v1/organization/projects/${id(c)}/archive` });
       if (!ok(arch) || (arch.body as Body).status !== 'archived') return false;
-      // archived project hidden by default, visible with include_archived
+      // archived project hidden by default, visible with include_archived; the organization's Default project stays
       const def = ((await h({ m: 'GET', p: '/v1/organization/projects' })).body as Body).data as Body[];
       const withArch = ((await h({ m: 'GET', p: '/v1/organization/projects?include_archived=true' })).body as Body).data as Body[];
       const missing = await h({ m: 'GET', p: '/v1/organization/projects/proj-nope' });
-      return def.length === 0 && withArch.length === 1 && missing.status === 404;
+      return def.length === 1 && def[0]!.name === 'Default project' && withArch.length === 2 && missing.status === 404;
     }),
   ),
   done('openai.admin.api_keys', 'admin', 'Admin: project API keys create (one-time secret) / list / retrieve (redacted) / delete', 'connector', 'niche', () =>
@@ -1103,17 +1148,19 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
   ),
   done('openai.usage.costs', 'admin', 'Usage + costs reporting endpoints computed over REAL recorded usage', 'api', 'niche', () =>
     withRoot(async (h) => {
-      // with no traffic the report is genuinely EMPTY (nothing hardcoded)
-      const empty = await h({ m: 'GET', p: '/v1/organization/usage/completions' });
-      if (!ok(empty) || (empty.body as Body).object !== 'page' || ((empty.body as Body).data as Body[]).length !== 0) return false;
-      const emptyCosts = await h({ m: 'GET', p: '/v1/organization/costs' });
-      if (((emptyCosts.body as Body).data as Body[]).length !== 0) return false;
+      // today, one daily bucket; with no traffic its results are genuinely EMPTY (nothing hardcoded)
+      const day = Date.parse(CHECKS_AT) / 1000;
+      const TODAY = `start_time=${day}&end_time=${day + 86_400}`;
+      const empty = await h({ m: 'GET', p: `/v1/organization/usage/completions?${TODAY}&group_by=model` });
+      if (!ok(empty) || (empty.body as Body).object !== 'page' || ((empty.body as Body).data as Body[]).length !== 1 || ((empty.body as Body).data[0].results as Body[]).length !== 0) return false;
+      const emptyCosts = await h({ m: 'GET', p: `/v1/organization/costs?${TODAY}&group_by=line_item` });
+      if (((emptyCosts.body as Body).data[0].results as Body[]).length !== 0) return false;
       // generate real usage: two chat calls (gpt-4o) + one embeddings call
       const c1 = await h({ m: 'POST', p: '/v1/chat/completions', b: CHAT() });
       const c2 = await h({ m: 'POST', p: '/v1/chat/completions', b: CHAT({ messages: [{ role: 'user', content: 'another prompt entirely' }] }) });
       await h({ m: 'POST', p: '/v1/embeddings', b: { model: 'text-embedding-3-small', input: 'embed me' } });
       // completions usage aggregates the two chat calls under gpt-4o
-      const usage = await h({ m: 'GET', p: '/v1/organization/usage/completions' });
+      const usage = await h({ m: 'GET', p: `/v1/organization/usage/completions?${TODAY}&group_by=model` });
       const buckets = (usage.body as Body).data as Body[];
       if (buckets.length !== 1) return false;
       const results = buckets[0]!.results as Body[];
@@ -1125,11 +1172,11 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       if (gpt4o.input_tokens !== expectedIn || gpt4o.output_tokens !== expectedOut) return false;
       // embeddings usage is filtered out of the completions view, present under embeddings
       if (results.some((r) => r.model.startsWith('text-embedding'))) return false;
-      const emb = await h({ m: 'GET', p: '/v1/organization/usage/embeddings' });
+      const emb = await h({ m: 'GET', p: `/v1/organization/usage/embeddings?${TODAY}&group_by=model` });
       const embResults = ((emb.body as Body).data as Body[])[0]!.results as Body[];
       if (!embResults.some((r) => r.model === 'text-embedding-3-small' && r.object === 'organization.usage.embeddings.result')) return false;
       // costs: a non-zero amount computed from the recorded usage (not hardcoded)
-      const costs = await h({ m: 'GET', p: '/v1/organization/costs' });
+      const costs = await h({ m: 'GET', p: `/v1/organization/costs?${TODAY}&group_by=line_item` });
       const costResults = ((costs.body as Body).data as Body[])[0]!.results as Body[];
       const completionsCost = costResults.find((r) => r.line_item === 'completions');
       if (!completionsCost || completionsCost.object !== 'organization.costs.result' || completionsCost.amount.currency !== 'usd' || !(completionsCost.amount.value > 0)) return false;
@@ -1154,9 +1201,12 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       if (dsc?.type !== 'custom') return false;
       const list = await h({ m: 'GET', p: '/v1/evals' });
       if (!ok(list) || !(list.body as Body).data.some((e: Body) => e.id === evalId)) return false;
-      // kick off a run; assert completed + result_counts + per_model_usage reflects the run model
-      const run = await h({ m: 'POST', p: `/v1/evals/${evalId}/runs`, b: { name: 'run-1', data_source: { type: 'completions', model: 'gpt-4.1', source: { type: 'file_content', content: [] } } } });
-      if (!ok(run) || field(run, 'object') !== 'eval.run' || field(run, 'status') !== 'completed') return false;
+      // kick off a run (queued, as OpenAI queues it); a read observes it graded: completed +
+      // result_counts + per_model_usage reflects the run model
+      const created = await h({ m: 'POST', p: `/v1/evals/${evalId}/runs`, b: { name: 'run-1', data_source: { type: 'completions', model: 'gpt-4.1', source: { type: 'file_content', content: [] } } } });
+      if (!ok(created) || field(created, 'object') !== 'eval.run' || field(created, 'status') !== 'queued') return false;
+      const run = await h({ m: 'GET', p: `/v1/evals/${evalId}/runs/${id(created)}` });
+      if (!ok(run) || field(run, 'status') !== 'completed') return false;
       const rc = field(run, 'result_counts') as Body;
       if (rc.passed !== 1 || rc.total !== 1 || field(run, 'eval_id') !== evalId) return false;
       // the run echoes the model from the request data_source (not a hardcoded default)
@@ -1192,9 +1242,10 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       if (!ok(got) || id(got) !== cid) return false;
       const list = await h({ m: 'GET', p: '/v1/containers' });
       if (!ok(list) || !(list.body as Body).data.some((x: Body) => x.id === cid)) return false;
-      // container file with inline text content → read back metadata + content
-      const cf = await h({ m: 'POST', p: `/v1/containers/${cid}/files`, b: { path: '/mnt/data/a.txt', content: 'hello sandbox' } });
-      if (!ok(cf) || field(cf, 'object') !== 'container.file' || field(cf, 'container_id') !== cid || field(cf, 'bytes') !== 'hello sandbox'.length || field(cf, 'path') !== '/mnt/data/a.txt') return false;
+      // container file from a stored File (the JSON form OpenAI takes) → read back metadata + content
+      const src = await h({ m: 'POST', p: '/v1/files', b: { purpose: 'user_data', filename: 'a.txt', content: 'hello sandbox' } });
+      const cf = await h({ m: 'POST', p: `/v1/containers/${cid}/files`, b: { file_id: id(src) } });
+      if (!ok(cf) || field(cf, 'object') !== 'container.file' || field(cf, 'container_id') !== cid || field(cf, 'bytes') !== 'hello sandbox'.length || field(cf, 'source') !== 'file_id') return false;
       const fid = id(cf);
       const content = await h({ m: 'GET', p: `/v1/containers/${cid}/files/${fid}/content` });
       if (!ok(content) || content.body !== 'hello sandbox') return false;
@@ -1215,36 +1266,42 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
   ),
 
   // ── Background responses (queued → poll → completed | cancel) ──────────────────────────
-  done('openai.responses.background', 'responses', 'Background responses (background:true → queued status + poll + cancel)', 'api', 'niche', () =>
+  done('openai.responses.background', 'responses', 'Background responses (background:true → queued, then completed over time on the World clock + poll + cancel)', 'api', 'niche', () =>
     withRoot(async (h) => {
+      // the World instants of the calls: created, then polled an hour later, when OpenAI's work is done
+      const T = '2026-03-01T00:00:00.000Z';
+      const LATER = '2026-03-01T01:00:00.000Z';
       // background:true → immediate queued response with no output yet
-      const bg = await h({ m: 'POST', p: '/v1/responses', b: { model: 'gpt-4o', input: 'background task A', background: true } });
+      const bg = await h({ m: 'POST', p: '/v1/responses', b: { model: 'gpt-4o', input: 'background task A', background: true }, at: T });
       if (!ok(bg) || field(bg, 'status') !== 'queued' || field(bg, 'background') !== true) return false;
-      if (field(bg, 'output_text') !== null || ((field(bg, 'output') as unknown[]) ?? []).length !== 0) return false;
+      if (((field(bg, 'output') as unknown[]) ?? []).length !== 0) return false;
       const rid = id(bg);
-      // first poll → transitions to completed with the real stub output + usage
-      const poll = await h({ m: 'GET', p: `/v1/responses/${rid}` });
+      // polled at the instant it was made, it is still queued; an hour later it has completed with the stub output + usage
+      const early = await h({ m: 'GET', p: `/v1/responses/${rid}`, at: T });
+      if (!ok(early) || field(early, 'status') !== 'queued') return false;
+      const poll = await h({ m: 'GET', p: `/v1/responses/${rid}`, at: LATER });
       if (!ok(poll) || field(poll, 'status') !== 'completed') return false;
-      const text = field(poll, 'output_text');
-      if (typeof text !== 'string' || !text.includes('[twin-stub')) return false;
+      const text = outputText(poll);
+      if (!text.includes('[twin-stub')) return false;
       // usage must be coherent: total = input + output, and output > 0 (the stub produced text)
       const usage = field(poll, 'usage') as Body;
       if (!usage || typeof usage.output_tokens !== 'number' || usage.output_tokens <= 0) return false;
       if (usage.total_tokens !== usage.input_tokens + usage.output_tokens) return false;
       // the completion is billable: a usage_record was recorded → the usage report is non-empty
-      const report = await h({ m: 'GET', p: '/v1/organization/usage/responses' });
+      const day = Date.parse(T) / 1000;
+      const report = await h({ m: 'GET', p: `/v1/organization/usage/responses?start_time=${day}&end_time=${day + 86_400}`, at: LATER });
       const buckets = (report.body as Body).data as Body[];
-      if (!ok(report) || buckets.length === 0) return false;
+      if (!ok(report) || buckets.length === 0 || (buckets[0]!.results as Body[]).length === 0) return false;
       // a second poll stays completed (idempotent) with the same output text (no re-billing visible)
-      const poll2 = await h({ m: 'GET', p: `/v1/responses/${rid}` });
-      if (field(poll2, 'status') !== 'completed' || field(poll2, 'output_text') !== text) return false;
+      const poll2 = await h({ m: 'GET', p: `/v1/responses/${rid}`, at: LATER });
+      if (field(poll2, 'status') !== 'completed' || outputText(poll2) !== text) return false;
       // cancel a still-queued background response → cancelled
-      const bg2 = await h({ m: 'POST', p: '/v1/responses', b: { model: 'gpt-4o', input: 'background task B', background: true } });
+      const bg2 = await h({ m: 'POST', p: '/v1/responses', b: { model: 'gpt-4o', input: 'background task B', background: true }, at: LATER });
       const rid2 = id(bg2);
-      const cancel = await h({ m: 'POST', p: `/v1/responses/${rid2}/cancel` });
+      const cancel = await h({ m: 'POST', p: `/v1/responses/${rid2}/cancel`, at: LATER });
       if (!ok(cancel) || field(cancel, 'status') !== 'cancelled') return false;
       // negative: cancel an already-completed response → 400; cancel unknown id → 404
-      const reCancel = await h({ m: 'POST', p: `/v1/responses/${rid}/cancel` });
+      const reCancel = await h({ m: 'POST', p: `/v1/responses/${rid}/cancel`, at: LATER });
       const missing = await h({ m: 'POST', p: '/v1/responses/resp-nope/cancel' });
       return reCancel.status === 400 && missing.status === 404;
     }),
@@ -1254,16 +1311,16 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
   done('openai.fine_tuning.pause_resume', 'fine_tuning', 'Fine-tuning job pause / resume — status transitions', 'api', 'niche', () =>
     withRoot(async (h) => {
       const job = await h({ m: 'POST', p: '/v1/fine_tuning/jobs', b: { model: 'gpt-4o-mini', training_file: 'file-twin-1' } });
-      if (!ok(job) || field(job, 'status') !== 'succeeded') return false;
+      if (!ok(job) || field(job, 'status') !== 'validating_files') return false;
       const jid = id(job);
-      // pause → status 'paused'
+      // pause while in flight → status 'paused' (a paused job does not progress on reads)
       const paused = await h({ m: 'POST', p: `/v1/fine_tuning/jobs/${jid}/pause` });
       if (!ok(paused) || field(paused, 'status') !== 'paused') return false;
       const readPaused = await h({ m: 'GET', p: `/v1/fine_tuning/jobs/${jid}` });
       if (field(readPaused, 'status') !== 'paused') return false;
-      // resume → back to 'succeeded', and the persisted state round-trips
+      // resume → queued again; the next read observes it finishing
       const resumed = await h({ m: 'POST', p: `/v1/fine_tuning/jobs/${jid}/resume` });
-      if (!ok(resumed) || field(resumed, 'status') !== 'succeeded') return false;
+      if (!ok(resumed) || field(resumed, 'status') !== 'queued') return false;
       const readResumed = await h({ m: 'GET', p: `/v1/fine_tuning/jobs/${jid}` });
       if (field(readResumed, 'status') !== 'succeeded') return false;
       // negative: resuming the now-succeeded (non-paused) job → 400; pause unknown job → 404
@@ -1375,26 +1432,6 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       return hdrs['x-ratelimit-remaining-requests'] === '0' && typeof hdrs['x-ratelimit-limit-tokens'] === 'string';
     }),
   ),
-  done('openai.protocol.idempotency', 'errors', 'Idempotency-Key header dedup — re-issue replays the same response; a new key → a new result', 'api', 'niche', () =>
-    withRootH(async (h) => {
-      const auth = { authorization: 'Bearer sk-twin-good' };
-      // a mutation (file create) with an Idempotency-Key → re-issue replays the SAME id (no double create)
-      const first = await h({ m: 'POST', p: '/v1/files', b: { purpose: 'batch', filename: 'a.jsonl', content: '{}' }, headers: { ...auth, 'idempotency-key': 'key-A' } });
-      if (!ok(first)) return false;
-      const id1 = (first.body as Body).id as string;
-      const replay = await h({ m: 'POST', p: '/v1/files', b: { purpose: 'batch', filename: 'a.jsonl', content: '{}' }, headers: { ...auth, 'idempotency-key': 'key-A' } });
-      if (!ok(replay) || (replay.body as Body).id !== id1) return false;
-      // the side effect happened ONCE: exactly one file exists
-      const listed = (await h({ m: 'GET', p: '/v1/files', headers: auth })).body as Body;
-      if ((listed.data as Body[]).length !== 1) return false;
-      // a DIFFERENT key → a new, distinct create
-      const second = await h({ m: 'POST', p: '/v1/files', b: { purpose: 'batch', filename: 'a.jsonl', content: '{}' }, headers: { ...auth, 'idempotency-key': 'key-B' } });
-      if (!ok(second) || (second.body as Body).id === id1) return false;
-      const listed2 = (await h({ m: 'GET', p: '/v1/files', headers: auth })).body as Body;
-      // even the replayed body is byte-identical to the first response (full envelope replay)
-      return (listed2.data as Body[]).length === 2 && JSON.stringify(replay.body) === JSON.stringify(first.body);
-    }),
-  ),
   done('openai.protocol.pagination', 'errors', 'Cursor pagination: after/limit + has_more/first_id/last_id across list endpoints', 'api', 'common', () =>
     withRoot(async (h) => {
       // create 3 files; page with limit=2 → has_more + last_id; then after=last_id → final page
@@ -1424,7 +1461,7 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
   ),
   done('openai.connector.pull_map', 'connector', 'Connector pulls + maps real state into the twin (offline, injected client)', 'connector', 'core', async () => {
     const { mapBatch, mapFile, syncOpenAIFromReal } = await import('./openai-connector.ts');
-    const { projectResources } = await import('@volter/twin');
+    const { projectResources } = await import('@volter/world-core');
     const root = mkdtempSync(join(tmpdir(), 'openai-cap-'));
     try {
       const mappedFile = mapFile({ id: 'file-real', purpose: 'batch', bytes: 12, status: 'processed', created_at: 1 });
@@ -1447,31 +1484,6 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       rmSync(root, { recursive: true, force: true });
     }
   }),
-  done('openai.connector.push_confirm', 'connector', 'Connector pushes pending local writes to real + confirms them (offline, injected client)', 'connector', 'core', async () => {
-    const { pushPendingOpenAIActions, openaiRequestForAction } = await import('./openai-connector.ts');
-    const { pendingActions } = await import('@volter/twin');
-    const root = mkdtempSync(join(tmpdir(), 'openai-cap-'));
-    try {
-      const created = await handleOpenAITwinRequest({ method: 'POST', path: '/v1/batches', body: JSON.stringify({ input_file_id: 'file-x', endpoint: '/v1/chat/completions', completion_window: '24h' }), root, occurredAt: '2026-06-15T00:00:00Z' });
-      if (created.status !== 200) return false;
-      if (pendingActions('openai', root).length === 0) return false;
-      const createReq = openaiRequestForAction({ operation: 'batch.create', subject: { type: 'batch', id: 'batch-twin-1' } });
-      const cancelReq = openaiRequestForAction({ operation: 'batch.cancel', subject: { type: 'batch', id: 'batch-twin-1' } });
-      const delReq = openaiRequestForAction({ operation: 'file.delete', subject: { type: 'file', id: 'file-twin-1' } });
-      if (createReq.path !== '/v1/batches' || cancelReq.path !== '/v1/batches/batch-twin-1/cancel' || delReq.method !== 'DELETE') return false;
-      const calls: string[] = [];
-      const fake = async (m: 'GET' | 'POST' | 'DELETE', p: string) => { calls.push(`${m} ${p}`); return { id: 'batch-real-1' }; };
-      const res = await pushPendingOpenAIActions(fake, { root, occurredAt: '2026-06-15T00:00:01Z' });
-      if (res.pushed < 1 || calls.length < 1) return false;
-      const after = await pushPendingOpenAIActions(fake, { root, occurredAt: '2026-06-15T00:00:02Z' });
-      return pendingActions('openai', root).length === 0 && after.pushed === 0;
-    } catch (err) {
-      if (isInfrastructureError(err)) throw harnessError('openai.connector.push_confirm', err);
-      return false;
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  }),
   done('openai.connector.unsupported_op_fails', 'connector', 'Connector refuses to silently drop an unsupported push op', 'connector', 'common', async () => {
     const { pushOpenAIAction } = await import('./openai-connector.ts');
     try {
@@ -1484,36 +1496,6 @@ export const OPENAI_CAPABILITIES: CapabilitySpec[] = [
       return false;
     }
   }),
-  done('openai.connector.full_sync', 'connector', 'Connector full bi-directional sync: push pending then pull all collections (idempotent)', 'connector', 'common', async () => {
-    const { fullSyncOpenAI } = await import('./openai-connector.ts');
-    const { pendingActions } = await import('@volter/twin');
-    const root = mkdtempSync(join(tmpdir(), 'openai-cap-'));
-    try {
-      // a local write becomes a pending action
-      const created = await handleOpenAITwinRequest({ method: 'POST', path: '/v1/batches', body: JSON.stringify({ input_file_id: 'file-x', endpoint: '/v1/chat/completions', completion_window: '24h' }), root, occurredAt: '2026-06-15T00:00:00Z' });
-      if (created.status !== 200 || pendingActions('openai', root).length === 0) return false;
-      const calls: string[] = [];
-      const fake = async (m: 'GET' | 'POST' | 'DELETE', p: string) => {
-        calls.push(`${m} ${p}`);
-        if (m === 'GET' && p.startsWith('/v1/files')) return { data: [{ id: 'file-real', purpose: 'batch', bytes: 5, status: 'processed', created_at: 1 }] };
-        if (m === 'GET' && p.startsWith('/v1/batches')) return { data: [{ id: 'batch-real', status: 'completed', created_at: 1, request_counts: { total: 1 } }] };
-        if (m === 'GET') return { data: [] };
-        return { id: 'batch-real-pushed' };
-      };
-      const res = await fullSyncOpenAI(fake, { root, occurredAt: '2026-06-15T00:00:01Z' });
-      // pushed the pending write, observed real state, appended deltas, swept all 4 collections
-      if (res.pushed < 1 || res.deltasAppended < 1 || res.collections < 4) return false;
-      if (pendingActions('openai', root).length !== 0) return false;
-      // idempotent: a second run with no pending + identical real state changes nothing
-      const again = await fullSyncOpenAI(fake, { root, occurredAt: '2026-06-15T00:00:02Z' });
-      return again.pushed === 0 && again.deltasAppended === 0;
-    } catch (err) {
-      if (isInfrastructureError(err)) throw harnessError('openai.connector.full_sync', err);
-      return false;
-    } finally {
-      rmSync(root, { recursive: true, force: true });
-    }
-  }),
 
   // ── Conformance harness ───────────────────────────────────────────────────────────────
   done('openai.conformance.envelopes', 'conformance', 'Offline conformance harness passes (envelope shapes across the surface)', 'connector', 'core', async () => {