@volter/twin-togetherai 0.1.0

package/src/togetherai-capabilities.ts

@@ -0,0 +1,1315 @@
+// Together AI capability manifest — the EXPECTED REAL-PRODUCT SURFACE (the target), authored
+// top-down from what the Together API actually does — NOT from what this twin has built. The
+// denominator was enumerated from TWO first-party sources, both read on 2026-09-16:
+//   • Together's own published OpenAPI spec (api.together.xyz/openapi.json, captured to
+//     test-fixtures/togetherai-openapi.yaml): 141 paths / 156 operations — the /v1 inference
+//     half (chat/completions, completions, embeddings, models, files, fine-tunes, rerank,
+//     images, audio, batches, whoami) AND the v2 management half (endpoints, deployments,
+//     compute, rl, videos, evaluation, queue, tci) this pack models the INFERENCE half of;
+//   • `together-ai@0.53.0` (Stainless-generated from Together's own spec): the model unions,
+//     the SDK-only upload flow (302 redirect + x-together-file-id), whoami, and the
+//     TOGETHER_BASE_URL/TOGETHER_API_KEY/TOGETHER_PROJECT_ID env contract.
+// Most entries start as `todo` and coverage reads LOW until the twin truly reaches 100% of the
+// API. `verify()` (required to count as done) is ground truth; `expected:'done'` only on
+// capabilities we genuinely claim, so a broken one shows as a regression.
+//
+// There are NO carve-outs. A twin is a deterministic, offline model of the vendor's API contract:
+// where the vendor runs a model, the twin returns a DETERMINISTIC labeled stub, and that stub IS
+// the twin's answer, not a shortfall from a "real" one. The protocol envelope (shape/streaming/
+// tool_calls/usage/prompt array) is faithful. Every entry here is either done or todo.
+//
+// TIERING (§6 rule 3, per the groq pack's corrected reading): `core` = "first-week-of-every-
+// integration". Week-one Together integrations are chat completions (+ the OpenAI-compatible
+// spine) and nothing else, so `core` is reserved for the chat/streaming/tools/errors/auth spine
+// plus the conformance and connector-pull backbone. Embeddings/rerank/images/audio, the Batch
+// API (files + batches), fine-tunes and whoami are specialist surfaces tiered `common`. The v2
+// management half (endpoints/deployments/compute/rl/videos/evaluation/queue/tci) is `edge` —
+// real Together surface, out of this pack's served scope, filed honestly as todo.
+//
+// (Together is an API-first vendor — app.together.ai is a console, not where the work happens —
+// so this pack ships NO mirror and has NO UI capabilities.)
+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/world-tooling';
+import { pendingActions, projectResources } from '@volter/world-core';
+import { handleTogetheraiTwinRequest, handleTogetheraiUploadDoor, type TogetheraiResponseEnvelope } from './togetherai-twin.ts';
+import {
+  externalIdFor,
+  fullSyncTogetherai,
+  liveTogetheraiExecute,
+  pullTogetheraiState,
+  pushTogetheraiAction,
+  pushPendingTogetheraiActions,
+  syncTogetheraiFromReal,
+  togetheraiRequestForAction,
+  unpushableReason,
+  type TogetheraiExecute,
+} from './togetherai-connector.ts';
+import type { SseEvent } from './togetherai-types.ts';
+
+// ── API verify: drive REAL requests against a fresh temp root, then assert status/shape ──
+type Step = { m: string; p: string; b?: unknown };
+type Body = Record<string, any>;
+
+/** Run a sequence of real Together requests against an isolated root; return all responses. */
+async function withRoot(steps: (h: (s: Step) => Promise<TogetheraiResponseEnvelope>, root: string) => Promise<boolean>): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'togetherai-cap-'));
+  const h = (s: Step) => handleTogetheraiTwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root });
+  try {
+    // `root` is handed to the steps too, so a verify can inspect the LOG (projectResources /
+    // pendingActions) and not merely the responses — the difference between proving "the reply
+    // did not change" and proving "nothing was written" (§9 round two).
+    return await verifyBoundary('togetherai.withRoot', () => steps(h, root));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+/** Like withRoot, but the request helper passes request HEADERS through (for auth / the
+ *  deterministic 429 / 402 / 503 triggers, which the trusted no-headers helper never fires). */
+type StepH = Step & { headers?: Record<string, string> };
+async function withRootH(steps: (h: (s: StepH) => Promise<TogetheraiResponseEnvelope>) => Promise<boolean>): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'togetherai-cap-'));
+  const h = (s: StepH) => handleTogetheraiTwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root, ...(s.headers ? { headers: s.headers } : {}) });
+  try {
+    return await verifyBoundary('togetherai.withRootH', () => steps(h));
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+/** Collect the streaming SSE events for a chat request against an isolated root. */
+function withStream(body: unknown, fn: (events: SseEvent[], final: TogetheraiResponseEnvelope) => boolean): Promise<boolean> {
+  return new Promise<boolean>((resolve, reject) => {
+    const root = mkdtempSync(join(tmpdir(), 'togetherai-cap-'));
+    const events: SseEvent[] = [];
+    handleTogetheraiTwinRequest({ method: 'POST', path: '/v1/chat/completions', body: JSON.stringify(body), root, sseSink: (e) => events.push(e) })
+      .then((final) => resolve(fn(events, final)))
+      .catch((err) => { if (isInfrastructureError(err)) reject(harnessError('togetherai.withStream', err)); else resolve(false); })
+      .finally(() => rmSync(root, { recursive: true, force: true }));
+  });
+}
+
+/** A connector verify against an isolated root, with the injected fake executor the test builds. */
+async function withConnectorRoot(id: string, fn: (root: string) => Promise<boolean>): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'togetherai-cap-'));
+  try {
+    return await fn(root);
+  } catch (err) {
+    if (isInfrastructureError(err)) throw harnessError(id, err);
+    return false;
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
+const ok = (r: TogetheraiResponseEnvelope) => r.status >= 200 && r.status < 300;
+const rid = (r: TogetheraiResponseEnvelope) => (r.body as Body)?.id as string;
+const errType = (r: TogetheraiResponseEnvelope) => (r.body as Body)?.error?.type as string;
+const status = (r: TogetheraiResponseEnvelope) => r.status;
+
+// ── shorthands (mirror the groq/openai 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 CHAT_PATH = '/v1/chat/completions';
+const CHAT = (extra: Record<string, unknown> = {}) => ({ model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', messages: [{ role: 'user', content: 'hello twin' }], ...extra });
+const WEATHER_TOOL = { type: 'function', function: { name: 'get_weather', parameters: { type: 'object', properties: { city: { type: 'string' }, days: { type: 'integer' } } } } };
+const TIME_TOOL = { type: 'function', function: { name: 'get_time', parameters: { type: 'object', properties: { tz: { type: 'string' } } } } };
+
+/** Seed a batch-api file and a batch over it. Returns the batch id. */
+async function seedBatch(h: (s: Step) => Promise<TogetheraiResponseEnvelope>): Promise<string | null> {
+  const f = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'batch-api', filename: 'in.jsonl', content: '{"custom_id":"a"}' } });
+  if (!ok(f)) return null;
+  const b = await h({ m: 'POST', p: '/v1/batches', b: { input_file_id: rid(f), endpoint: '/v1/chat/completions' } });
+  return ok(b) ? ((b.body as Body).job?.id as string) ?? null : null;
+}
+
+export const TOGETHERAI_CAPABILITIES: CapabilitySpec[] = [
+  // ── chat ────────────────────────────────────────────────────────────────────
+  done('togetherai.chat.basic', 'chat', 'POST /v1/chat/completions answers a labeled stub completion with Together envelope (choices, prompt array, usage)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return b.object === 'chat.completion' && Array.isArray(b.choices) && b.choices.length === 1
+        && b.choices[0].message.role === 'assistant'
+        && typeof b.choices[0].message.content === 'string'
+        && String(b.choices[0].message.content).includes('[twin-stub:')
+        && Array.isArray(b.prompt) && b.prompt.length === 0
+        && typeof b.usage?.prompt_tokens === 'number' && typeof b.usage?.completion_tokens === 'number'
+        && typeof b.created === 'number' && typeof b.model === 'string';
+    })),
+  done('togetherai.chat.echo_prompt', 'chat', "echo:true returns Together's REQUIRED prompt array with the echoed prompt", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ echo: true }) });
+      if (!ok(r)) return false;
+      const prompt = (r.body as Body).prompt;
+      return Array.isArray(prompt) && prompt.length === 1 && typeof prompt[0].text === 'string'
+        && String(prompt[0].text).includes('hello twin');
+    })),
+  done('togetherai.chat.missing_model', 'chat', 'a chat request without model is a 400 invalid_request_error', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const { model: _m, ...noModel } = CHAT();
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: noModel });
+      return status(r) === 400 && errType(r) === 'invalid_request_error';
+    })),
+  done('togetherai.chat.missing_messages', 'chat', 'a chat request without messages is a 400', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo' } });
+      return status(r) === 400 && errType(r) === 'invalid_request_error';
+    })),
+  done('togetherai.chat.n_range', 'chat', "Together's n is 1..128 (OpenAI-compatible freedom Groq lacks): 129 is a 400, n:3 answers 3 choices", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const over = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ n: 129 }) });
+      if (status(over) !== 400 || errType(over) !== 'invalid_request_error') return false;
+      const three = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ n: 3 }) });
+      if (!ok(three)) return false;
+      const choices = (three.body as Body).choices;
+      return Array.isArray(choices) && choices.length === 3 && choices[0].index === 0 && choices[2].index === 2;
+    })),
+  done('togetherai.chat.logprobs_range', 'chat', "Together's logprobs is an INTEGER 0..20 (not OpenAI's boolean): 21 is a 400", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const over = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ logprobs: 21 }) });
+      if (status(over) !== 400) return false;
+      const okReq = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ logprobs: 5 }) });
+      return ok(okReq);
+    })),
+  done('togetherai.chat.context_behavior_enum', 'chat', "context_length_exceeded_behavior is a closed enum {truncate,error}; anything else is a 400", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const bad = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ context_length_exceeded_behavior: 'shrink' }) });
+      if (status(bad) !== 400) return false;
+      const good = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ context_length_exceeded_behavior: 'truncate' }) });
+      return ok(good);
+    })),
+  done('togetherai.chat.reasoning_effort', 'chat', "reasoning_effort {low,medium,high} surfaces a reasoning field on the assistant message; an off-enum value 400s", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const bad = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ reasoning_effort: 'maximum' }) });
+      if (status(bad) !== 400) return false;
+      const good = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ reasoning_effort: 'high' }) });
+      if (!ok(good)) return false;
+      const msg = (good.body as Body).choices[0].message;
+      return typeof msg.reasoning === 'string' && msg.reasoning.includes('[twin-stub:');
+    })),
+  done('togetherai.chat.compliance_const', 'chat', "compliance is a const 'hipaa' on Together's schema — another value is a 400", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const bad = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ compliance: 'gdpr' }) });
+      if (status(bad) !== 400) return false;
+      const good = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ compliance: 'hipaa' }) });
+      return ok(good);
+    })),
+  done('togetherai.chat.accepted_ignored', 'chat', "OpenAI fields Together ACCEPTS BUT IGNORES (service_tier, store, metadata, prediction) do not change the answer", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const plain = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      const decorated = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ service_tier: 'flex', store: true, metadata: { k: 'v' }, prediction: { content: 'x' } }) });
+      return ok(plain) && ok(decorated)
+        && (plain.body as Body).choices[0].message.content === (decorated.body as Body).choices[0].message.content;
+    })),
+  done('togetherai.chat.flat_model_404', 'chat', "a flat OpenAI-style model id Together does not serve (gpt-4o) is a 404, not a stub", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ model: 'gpt-4o' }) });
+      return status(r) === 404 && errType(r) === 'invalid_request_error';
+    })),
+  done('togetherai.chat.non_chat_model_404', 'chat', "asking an embedding/rerank/image/speech model to chat is a 404", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ model: 'WhereIsAI/UAE-Large-V1' }) });
+      return status(r) === 404;
+    })),
+  done('togetherai.chat.stop_truncates', 'chat', "stop sequences truncate the completion at the EARLIEST occurrence across the list", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ stop: ['zzz', 'deterministic'] }) });
+      if (!ok(r)) return false;
+      const content = String((r.body as Body).choices[0].message.content);
+      return !content.includes('deterministic') && content.length > 0;
+    })),
+  done('togetherai.chat.max_tokens_length', 'chat', "a max_tokens below the stub length truncates and reports finish_reason:'length'; a NON-INTEGER max_tokens is a 400", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 5 }) });
+      if (!ok(r) || (r.body as Body).choices[0].finish_reason !== 'length') return false;
+      const bad = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 'five' }) });
+      return status(bad) === 400 && errType(bad) === 'invalid_request_error';
+    })),
+
+  // ── context length (Together's own 403) ─────────────────────────────────────
+  done('togetherai.chat.context_403', 'chat', "input + max_tokens beyond the model window answers Together's 403 context-length error (NOT 400/413)", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 200_000 }) });
+      return status(r) === 403 && errType(r) === 'invalid_request_error'
+        && String((r.body as Body).error.message).includes('maximum context length');
+    })),
+  done('togetherai.chat.context_truncate', 'chat', "context_length_exceeded_behavior:'truncate' caps max_tokens to the window instead of 403", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 200_000, context_length_exceeded_behavior: 'truncate' }) });
+      // The capability is the AVOIDANCE: with truncate, an over-window request answers 200 where
+      // the default answers 403. (The deterministic stub's completion is far shorter than the
+      // window even after the cap, so `finish_reason:'length'` is not part of this contract.)
+      return ok(r) && Array.isArray((r.body as Body).choices);
+    })),
+
+  // ── tools ───────────────────────────────────────────────────────────────────
+  done('togetherai.tools.first_tool_called', 'tools', 'with tools, the stub deterministically calls the first tool with schema-typed placeholder arguments', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL, TIME_TOOL] }) });
+      if (!ok(r)) return false;
+      const msg = (r.body as Body).choices[0].message;
+      return (r.body as Body).choices[0].finish_reason === 'tool_calls'
+        && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0
+        // The FIRST call is the first tool in the list, with schema-typed placeholder arguments
+        // (parallel:true calls every tool; the first call is still the first-listed one).
+        && msg.tool_calls[0].function.name === 'get_weather'
+        && msg.tool_calls[0].function.arguments.includes('"city"');
+    })),
+  done('togetherai.tools.tool_choice_none', 'tools', "tool_choice:'none' forbids the tool call and answers text", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL], tool_choice: 'none' }) });
+      return ok(r) && (r.body as Body).choices[0].finish_reason === 'stop'
+        && !(r.body as Body).choices[0].message.tool_calls;
+    })),
+  done('togetherai.tools.tool_choice_named', 'tools', "a named tool_choice {function:{name}} forces THAT tool; an off-enum STRING tool_choice and a named tool_choice WITHOUT function.name are each a 400", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL, TIME_TOOL], tool_choice: { function: { name: 'get_time' } } }) });
+      if (!ok(r) || (r.body as Body).choices[0].message.tool_calls?.[0]?.function.name !== 'get_time') return false;
+      const badEnum = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL], tool_choice: 'sometimes' }) });
+      if (status(badEnum) !== 400) return false;
+      const noName = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL], tool_choice: { function: {} } }) });
+      return status(noName) === 400 && errType(noName) === 'invalid_request_error';
+    })),
+  done('togetherai.tools.parallel_default', 'tools', "parallel_tool_calls defaults true: every provided tool is called; false calls exactly one", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const all = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL, TIME_TOOL] }) });
+      const one = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL, TIME_TOOL], parallel_tool_calls: false }) });
+      return ok(all) && ok(one)
+        && (all.body as Body).choices[0].message.tool_calls.length === 2
+        && (one.body as Body).choices[0].message.tool_calls.length === 1;
+    })),
+  done('togetherai.tools.legacy_functions', 'tools', "Together's DEPRECATED functions param answers the DEPRECATED function_call shape with finish_reason:'function_call'", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ functions: [{ name: 'get_weather', parameters: { type: 'object', properties: { city: { type: 'string' } } } }] }) });
+      if (!ok(r)) return false;
+      const choice = (r.body as Body).choices[0];
+      return choice.finish_reason === 'function_call' && choice.message.function_call?.name === 'get_weather';
+    })),
+  done('togetherai.tools.tool_result_turn', 'tools', "a tool result turn (role:'tool' with tool_call_id) is accepted and answered", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', messages: [
+        { role: 'assistant', tool_calls: [{ id: 'call_x', type: 'function', function: { name: 'get_weather', arguments: '{}' } }] },
+        { role: 'tool', tool_call_id: 'call_x', content: 'sunny' },
+      ] } });
+      return ok(r) && typeof (r.body as Body).choices[0].message.content === 'string';
+    })),
+
+  // ── structured outputs ──────────────────────────────────────────────────────
+  done('togetherai.structured.json_object', 'structured_outputs', "response_format json_object answers valid JSON", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'json_object' } }) });
+      if (!ok(r)) return false;
+      const content = String((r.body as Body).choices[0].message.content);
+      try { JSON.parse(content); return true; } catch { return false; }
+    })),
+  done('togetherai.structured.json_schema_name_required', 'structured_outputs', "Together's json_schema REQUIRES json_schema.name (≤64, [a-zA-Z0-9_-]) — an omission is a 400", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const noName = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'json_schema', json_schema: { schema: { type: 'object', properties: { a: { type: 'string' } } } } } }) });
+      if (status(noName) !== 400) return false;
+      const badName = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'json_schema', json_schema: { name: 'bad name!', schema: {} } } }) });
+      if (status(badName) !== 400) return false;
+      const good = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'json_schema', json_schema: { name: 'my-schema_1', schema: { type: 'object', properties: { a: { type: 'string' } } } } } }) });
+      if (!ok(good)) return false;
+      try { JSON.parse(String((good.body as Body).choices[0].message.content)); return true; } catch { return false; }
+    })),
+  done('togetherai.structured.response_format_bad_type', 'structured_outputs', "an unknown response_format.type is a 400", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'xml' } }) });
+      return status(r) === 400;
+    })),
+
+  // ── completions (legacy text) ───────────────────────────────────────────────
+  done('togetherai.completions.basic', 'chat', 'POST /v1/completions answers object:text.completion with the REQUIRED prompt array + usage', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/completions', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', prompt: 'Once upon a time' } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return b.object === 'text.completion' && Array.isArray(b.prompt) && b.prompt.length === 1
+        && typeof b.choices[0].text === 'string' && typeof b.usage.total_tokens === 'number';
+    })),
+  done('togetherai.completions.missing_prompt', 'chat', 'a completion without prompt is a 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/completions', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo' } });
+      return status(r) === 400;
+    })),
+  done('togetherai.completions.non_chat_model_404', 'chat', 'asking an embedding model to complete text is a 404, never a stub', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/completions', b: { model: 'BAAI/bge-large-en-v1.5', prompt: 'x' } });
+      return status(r) === 404 && errType(r) === 'invalid_request_error';
+    })),
+  done('togetherai.completions.max_tokens_truncates', 'chat', "a max_tokens below the stub length truncates the text and reports finish_reason:'length'; a non-integer max_tokens is a 400", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/completions', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', prompt: 'x', max_tokens: 5 } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      if (b.choices[0].finish_reason !== 'length' || b.choices[0].text.length === 0) return false;
+      const bad = await h({ m: 'POST', p: '/v1/completions', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', prompt: 'x', max_tokens: 2.5 } });
+      return status(bad) === 400 && errType(bad) === 'invalid_request_error';
+    })),
+
+  // ── streaming ───────────────────────────────────────────────────────────────
+  done('togetherai.stream.chunk_sequence', 'streaming', "stream:true emits role chunk → content chunks → finish_reason chunk → usage tail → [DONE], every chunk carrying Together's nullable usage+warnings", 'api', 'core', () =>
+    withStream(CHAT({ stream: true }), (events, final) => {
+      if (!ok(final)) return false;
+      const data = events.filter((e) => !e.done).map((e) => e.data as Body);
+      if (!data.length) return false;
+      if (data.some((c) => c.object !== 'chat.completion.chunk')) return false;
+      if (!data.every((c) => 'usage' in c && 'warnings' in c)) return false;
+      const first = data[0];
+      if (first.choices?.[0]?.delta?.role !== 'assistant') return false;
+      const withFinish = data.filter((c) => c.choices?.[0]?.finish_reason);
+      if (withFinish.length !== 1 || withFinish[0].choices[0].finish_reason !== 'stop') return false;
+      const tail = data[data.length - 1];
+      if (!Array.isArray(tail.choices) || tail.choices.length !== 0) return false;
+      if (typeof tail.usage?.total_tokens !== 'number') return false;
+      return events[events.length - 1].done === true;
+    })),
+  done('togetherai.stream.tools_stream', 'streaming', 'a tool-call completion streams tool_calls deltas then the finish_reason chunk', 'api', 'core', () =>
+    withStream(CHAT({ stream: true, tools: [WEATHER_TOOL] }), (events) => {
+      const data = events.filter((e) => !e.done).map((e) => e.data as Body);
+      const toolChunks = data.filter((c) => c.choices?.[0]?.delta?.tool_calls);
+      const finish = data.find((c) => c.choices?.[0]?.finish_reason);
+      return toolChunks.length >= 2 && finish?.choices[0].finish_reason === 'tool_calls';
+    })),
+  done('togetherai.stream.pre_stream_refusal', 'streaming', 'a pre-stream failure (missing messages) answers its REAL 400 on the stream request — never a 200 event-stream refusal', 'api', 'core', () =>
+    withStream({ model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', stream: true }, (_events, final) => status(final) === 400 && errType(final) === 'invalid_request_error')),
+  done('togetherai.stream.reasoning_chunk', 'streaming', 'a reasoning_effort request streams the reasoning delta before content', 'api', 'core', () =>
+    withStream(CHAT({ stream: true, reasoning_effort: 'high' }), (events) => {
+      const data = events.filter((e) => !e.done).map((e) => e.data as Body);
+      const reasoningIdx = data.findIndex((c) => c.choices?.[0]?.delta?.reasoning);
+      const contentIdx = data.findIndex((c) => c.choices?.[0]?.delta?.content);
+      return reasoningIdx >= 0 && contentIdx > reasoningIdx;
+    })),
+  done('togetherai.stream.completions_stream', 'streaming', 'the LEGACY /v1/completions streams too: per-piece token chunks then the finish chunk carrying the usage (finish_reason at the chunk TOP level, per the SDK CompletionChunk)', 'api', 'common', () =>
+    new Promise<boolean>((resolve, reject) => {
+      const root = mkdtempSync(join(tmpdir(), 'togetherai-cap-'));
+      const events: SseEvent[] = [];
+      handleTogetheraiTwinRequest({ method: 'POST', path: '/v1/completions', body: JSON.stringify({ model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', prompt: 'x', stream: true }), root, sseSink: (e) => events.push(e) })
+        .then((final) => {
+          const data = events.filter((e) => !e.done).map((e) => e.data as Body);
+          const finish = data.find((c) => c.finish_reason);
+          resolve(ok(final) && data.length >= 2 && data.every((c) => c.object === 'completion.chunk')
+            && finish?.finish_reason === 'stop' && typeof finish.usage?.total_tokens === 'number'
+            && events[events.length - 1].done === true);
+        })
+        .catch((err) => { if (isInfrastructureError(err)) reject(harnessError('togetherai.stream.completions_stream', err)); else resolve(false); })
+        .finally(() => rmSync(root, { recursive: true, force: true }));
+    })),
+
+  // ── embeddings ──────────────────────────────────────────────────────────────
+  done('togetherai.embeddings.basic', 'embeddings', 'POST /v1/embeddings answers deterministic L2-normalized vectors with the documented dimensionality and NO usage key', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/embeddings', b: { model: 'WhereIsAI/UAE-Large-V1', input: 'hello twin' } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      if (b.object !== 'list' || b.model !== 'WhereIsAI/UAE-Large-V1') return false;
+      if ('usage' in b) return false; // Together's EmbeddingsResponse has no usage key
+      const vec = b.data[0].embedding as number[];
+      if (b.data[0].object !== 'embedding' || vec.length !== 1024) return false;
+      const norm = Math.sqrt(vec.reduce((s: number, v: number) => s + v * v, 0));
+      return Math.abs(norm - 1) < 1e-6;
+    })),
+  done('togetherai.embeddings.batch_deterministic', 'embeddings', 'an array input answers one embedding per element, index-aligned and deterministic across calls', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const b1 = await h({ m: 'POST', p: '/v1/embeddings', b: { model: 'BAAI/bge-base-en-v1.5', input: ['a', 'b'] } });
+      const b2 = await h({ m: 'POST', p: '/v1/embeddings', b: { model: 'BAAI/bge-base-en-v1.5', input: ['a', 'b'] } });
+      if (!ok(b1) || !ok(b2)) return false;
+      const d1 = (b1.body as Body).data;
+      const d2 = (b2.body as Body).data;
+      return d1.length === 2 && d1[0].index === 0 && d1[1].index === 1
+        && d1[0].embedding.length === 768 && JSON.stringify(d1) === JSON.stringify(d2);
+    })),
+  done('togetherai.embeddings.wrong_model', 'embeddings', 'a chat model on /v1/embeddings is a 404', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/embeddings', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', input: 'x' } });
+      return status(r) === 404;
+    })),
+
+  // ── rerank (Together-native) ────────────────────────────────────────────────
+  done('togetherai.rerank.basic', 'rerank', 'POST /v1/rerank answers Together-native {object:rerank, results:[{index,relevance_score,document}]} with a deterministic order', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/rerank', b: { model: 'Salesforce/Llama-Rank-v1', query: 'q', documents: ['alpha', 'beta', 'gamma'] } });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      if (b.object !== 'rerank' || !Array.isArray(b.results) || b.results.length !== 3) return false;
+      const idxs = b.results.map((x: Body) => x.index).sort((a: number, c: number) => a - c);
+      if (JSON.stringify(idxs) !== '[0,1,2]') return false;
+      return b.results.every((x: Body) => typeof x.relevance_score === 'number');
+    })),
+  done('togetherai.rerank.top_n', 'rerank', 'top_n truncates the results; return_documents:false omits the document text', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const top = await h({ m: 'POST', p: '/v1/rerank', b: { model: 'Salesforce/Llama-Rank-v1', query: 'q', documents: ['a', 'b', 'c'], top_n: 2 } });
+      if (!ok(top) || (top.body as Body).results.length !== 2) return false;
+      const bare = await h({ m: 'POST', p: '/v1/rerank', b: { model: 'Salesforce/Llama-Rank-v1', query: 'q', documents: ['a', 'b'], return_documents: false } });
+      return ok(bare) && (bare.body as Body).results.every((x: Body) => !('document' in x));
+    })),
+  done('togetherai.rerank.missing_documents', 'rerank', 'a rerank without documents is a 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/rerank', b: { model: 'Salesforce/Llama-Rank-v1', query: 'q' } });
+      return status(r) === 400;
+    })),
+
+  // ── images ──────────────────────────────────────────────────────────────────
+  done('togetherai.images.basic', 'images', 'POST /v1/images/generations answers a labeled stub image (url or b64_json discriminated); output_format defaults to jpeg (the SDK documents "Defaults to `jpeg`") and an off-enum value is a 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      // The stub label carries the format, base64-encoded inside the data: URL — decode to read it.
+      const labelOf = (u: unknown) => Buffer.from(String(u).replace(/^data:[^,]*,/, ''), 'base64').toString('utf8');
+      const r = await h({ m: 'POST', p: '/v1/images/generations', b: { model: 'black-forest-labs/FLUX.1-schnell', prompt: 'a cat' } });
+      if (!ok(r)) return false;
+      const d = (r.body as Body).data;
+      if (!(Array.isArray(d) && d.length === 1 && d[0].type === 'url' && typeof d[0].url === 'string'
+        && d[0].url.startsWith('data:') && labelOf(d[0].url).includes('jpeg image stub'))) return false;
+      // The default is jpeg, NOT png: the label names it, and an off-enum output_format is a 400.
+      const png = await h({ m: 'POST', p: '/v1/images/generations', b: { model: 'black-forest-labs/FLUX.1-schnell', prompt: 'a cat', output_format: 'png' } });
+      if (!ok(png) || !labelOf((png.body as Body).data[0].url).includes('png image stub')) return false;
+      const bad = await h({ m: 'POST', p: '/v1/images/generations', b: { model: 'black-forest-labs/FLUX.1-schnell', prompt: 'a cat', output_format: 'webp' } });
+      return status(bad) === 400 && errType(bad) === 'invalid_request_error';
+    })),
+  done('togetherai.images.b64_and_count', 'images', "response_format 'base64' (Together's enum, not OpenAI's b64_json) returns base64 bodies; n answers n images", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/images/generations', b: { model: 'black-forest-labs/FLUX.1-schnell', prompt: 'a cat', response_format: 'base64', n: 2 } });
+      if (!ok(r)) return false;
+      const d = (r.body as Body).data;
+      if (d.length !== 2 || !d.every((x: Body) => x.type === 'b64_json' && typeof x.b64_json === 'string')) return false;
+      // OpenAI's value is refused, not accepted (the OpenAI-compatibility line: Together's image
+      // API is its own).
+      const openaiValue = await h({ m: 'POST', p: '/v1/images/generations', b: { model: 'black-forest-labs/FLUX.1-schnell', prompt: 'a cat', response_format: 'b64_json' } });
+      return openaiValue.status === 400;
+    })),
+  done('togetherai.images.wrong_model', 'images', 'a chat model on /v1/images/generations is a 404', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/images/generations', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', prompt: 'x' } });
+      return status(r) === 404;
+    })),
+
+  // ── audio ───────────────────────────────────────────────────────────────────
+  done('togetherai.audio.speech', 'audio', 'POST /v1/audio/speech answers a labeled stub body for a closed 3-model speech union; a chat model 404s', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/audio/speech', b: { model: 'cartesia/sonic', input: 'hello', voice: 'female' } });
+      if (!ok(r) || typeof r.body !== 'string' || !String(r.body).includes('[twin-stub:')) return false;
+      const bad = await h({ m: 'POST', p: '/v1/audio/speech', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', input: 'hello', voice: 'female' } });
+      return status(bad) === 404;
+    })),
+  done('togetherai.audio.speech_validations', 'audio', 'speech without input or voice is a 400; an off-union response_format is a 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const noVoice = await h({ m: 'POST', p: '/v1/audio/speech', b: { model: 'cartesia/sonic', input: 'hello' } });
+      if (status(noVoice) !== 400) return false;
+      const badFormat = await h({ m: 'POST', p: '/v1/audio/speech', b: { model: 'cartesia/sonic', input: 'hello', voice: 'female', response_format: 'aac' } });
+      return status(badFormat) === 400;
+    })),
+  done('togetherai.audio.transcriptions', 'audio', 'POST /v1/audio/transcriptions answers json/text/verbose_json stub transcripts seeded from the audio reference', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const j = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { model: 'cartesia/sonic', file: 'clip.wav' } });
+      if (!ok(j) || String((j.body as Body).text).includes('clip.wav') === false) return false;
+      const t = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { model: 'cartesia/sonic', file: 'clip.wav', response_format: 'text' } });
+      if (!ok(t) || typeof t.body !== 'string') return false;
+      const v = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { model: 'cartesia/sonic', file: 'clip.wav', response_format: 'verbose_json' } });
+      const vb = v.body as Body;
+      return ok(v) && vb.task === 'transcribe' && typeof vb.duration === 'number' && Array.isArray(vb.segments);
+    })),
+  done('togetherai.audio.translations', 'audio', 'POST /v1/audio/translations mirrors transcriptions with task:translate', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/audio/translations', b: { model: 'cartesia/sonic', url: 'https://example.com/a.wav', response_format: 'verbose_json' } });
+      return ok(r) && (r.body as Body).task === 'translate';
+    })),
+  done('togetherai.audio.requires_source', 'audio', 'a transcription with neither file nor url is a 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/audio/transcriptions', b: { model: 'cartesia/sonic' } });
+      return status(r) === 400;
+    })),
+
+  // ── models (static catalog) ─────────────────────────────────────────────────
+  done('togetherai.models.list_bare_array', 'models', 'GET /v1/models answers a BARE ARRAY of ModelInfo (id/object/created/type REQUIRED), not an OpenAI list envelope', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: '/v1/models' });
+      if (!ok(r) || !Array.isArray(r.body)) return false;
+      const list = r.body as Body[];
+      return list.length > 0 && list.every((m) => typeof m.id === 'string' && m.object === 'model' && typeof m.created === 'number' && typeof m.type === 'string');
+    })),
+  done('togetherai.models.retrieve_slashed_id', 'models', 'GET /v1/models/:id resolves ids containing slashes (Together model ids are org/model)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: '/v1/models/meta-llama/Llama-3.3-70B-Instruct-Turbo' });
+      if (!ok(r) || (r.body as Body).id !== 'meta-llama/Llama-3.3-70B-Instruct-Turbo') return false;
+      const missing = await h({ m: 'GET', p: '/v1/models/nope/none' });
+      return status(missing) === 404;
+    })),
+
+  // ── whoami ──────────────────────────────────────────────────────────────────
+  done('togetherai.whoami', 'whoami', 'GET /v1/whoami answers the WhoamiResponse identity (api_key_id/project/organization ids)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: '/v1/whoami' });
+      if (!ok(r)) return false;
+      const b = r.body as Body;
+      return typeof b.api_key_id === 'string' && typeof b.project_id === 'string' && typeof b.organization_id === 'string';
+    })),
+  done('togetherai.protocol.non_v1_404', 'protocol', "everything Together's inference API serves hangs off /v1 — a path outside it (and any unknown /v1 route) is a 404 naming the prefix, never a stub", 'api', 'core', () =>
+    withRoot(async (h) => {
+      const outside = await h({ m: 'GET', p: '/v2/models' });
+      if (status(outside) !== 404 || !String((outside.body as Body).error.message).includes('/v1')) return false;
+      const root_ = await h({ m: 'GET', p: '/' });
+      if (status(root_) !== 404) return false;
+      const unknownV1 = await h({ m: 'GET', p: '/v1/zzz_nope' });
+      return status(unknownV1) === 404 && errType(unknownV1) === 'invalid_request_error';
+    })),
+
+  // ── files (stateful; Together-native shape) ─────────────────────────────────
+  done('togetherai.files.create_list_get', 'files', "POST /v1/files/upload (the spec's create) makes a file with Together purposes, GET lists {data:[...]}, GET :id retrieves the FileResponse with Processed/FileType; an explicit file_type is honored and an off-set one is a 400", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const c = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 'train.jsonl', content: '{"x":1}' } });
+      if (!ok(c)) return false;
+      const fb = c.body as Body;
+      if (fb.object !== 'file' || fb.Processed !== true || fb.FileType !== 'jsonl') return false;
+      // An explicit file_type overrides the filename's extension (§9 round two, R2-D3: the old
+      // OR-condition silently discarded it).
+      const explicit = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'batch-api', filename: 'mislabeled.jsonl', file_type: 'csv', content: 'a,b' } });
+      if (!ok(explicit) || (explicit.body as Body).FileType !== 'csv') return false;
+      // An off-set file_type is a 400 (Together's FileType is the closed {csv,jsonl,parquet}).
+      const invalid = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'batch-api', filename: 'doc.docx', file_type: 'docx', content: 'x' } });
+      if (invalid.status !== 400) return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if (!ok(list) || !Array.isArray((list.body as Body).data) || (list.body as Body).data.length !== 2) return false;
+      const one = await h({ m: 'GET', p: `/v1/files/${fb.id}` });
+      return ok(one) && (one.body as Body).filename === 'train.jsonl';
+    })),
+  done('togetherai.files.purposes_closed', 'files', "Together's FilePurpose is a closed set {fine-tune,eval,batch-api} — OpenAI's 'batch' purpose is a 400", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const openai = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'batch', filename: 'x.jsonl', content: '{}' } });
+      if (status(openai) !== 400) return false;
+      const evalOk = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'eval', filename: 'e.jsonl', content: '{}' } });
+      const batchOk = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'batch-api', filename: 'b.jsonl', content: '{}' } });
+      return ok(evalOk) && ok(batchOk);
+    })),
+  done('togetherai.files.delete', 'files', 'DELETE /v1/files/:id removes the file from the list, a re-GET 404s, and DELETE of an UNKNOWN id is a 404 (never a fake success)', 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const missing = await h({ m: 'DELETE', p: '/v1/files/file_nope' });
+      if (status(missing) !== 404) return false;
+      const c = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 'gone.jsonl', content: 'x' } });
+      if (!ok(c)) return false;
+      const fid = rid(c);
+      const del = await h({ m: 'DELETE', p: `/v1/files/${fid}` });
+      if (!ok(del) || (del.body as Body).deleted !== true) return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      const gone = await h({ m: 'GET', p: `/v1/files/${fid}` });
+      if (status(gone) !== 404) return false;
+      // Nothing was written beyond the delete itself: the create + delete pair, the delete last.
+      const actions = pendingActions('togetherai', root);
+      return actions.length === 2 && actions[1].operation === 'file.delete';
+    })),
+  done('togetherai.files.upload_multipart', 'files', "the spec's POST /v1/files/upload (multipart) creates the file", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 'up.jsonl', content: '{"a":1}' } });
+      return ok(r) && (r.body as Body).filename === 'up.jsonl';
+    })),
+  done('togetherai.files.malformed_escape_404', 'files', 'GET /v1/files/%zz — a malformed percent-escape — answers the vendor 404, not an internal error', 'api', 'common', () =>
+    // HOLLOW BY METHOD (2026-09-16 sweep): the behavior is a try/catch, and the sweep's two
+    // families (GUARD `if (…)`→false, PROPERTY `key: v,`→undefined) cannot reach a try/catch —
+    // no mechanical mutation lands. Hand-walked instead: deleting the try/catch (decSafe becomes
+    // a bare decodeURIComponent) reddens THIS cell — the pin is live, just outside the sweep's
+    // grammar.
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: '/v1/files/%zz' });
+      return status(r) === 404 && errType(r) === 'invalid_request_error';
+    })),
+  done('togetherai.files.no_json_create', 'files', "the spec has NO JSON create at POST /v1/files (GET only there) — a JSON or EMPTY body answers the vendor's 400 naming the real doors, and mints nothing", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const json = await h({ m: 'POST', p: '/v1/files', b: { purpose: 'batch-api', filename: 'x.jsonl', content: '{}' } });
+      if (status(json) !== 400 || errType(json) !== 'invalid_request_error') return false;
+      const empty = await h({ m: 'POST', p: '/v1/files', b: '' });
+      if (status(empty) !== 400) return false;
+      // The refusal MINTS NOTHING: no stored file, no action.
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  // ── EMPTY/PARTIAL REQUESTS ON EVERY WRITE DOOR (the §9 round-three CLASS fix) ──────────────
+  // One titled claim per door: a request lacking the resource's required parts answers the
+  // vendor's 4xx envelope and stores NOTHING (no row, no action). A required field must never be
+  // defaulted into existence — the round-three blocker was exactly that default (`purpose` →
+  // 'fine-tune', `filename` → 'upload.jsonl') minting a file from a bodyless POST. Each verify
+  // asserts status + envelope AND the unchanged store, so removing the guard reddens it.
+  done('togetherai.files.upload_empty_400', 'files', "POST /v1/files/upload with NO body answers the vendor's 400 ('purpose' is a required property) and stores nothing — the required parts are never defaulted (the round-three class fix)", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/files/upload', b: undefined });
+      if (status(r) !== 400 || errType(r) !== 'invalid_request_error') return false;
+      if (!String((r.body as Body)?.error?.message).includes("'purpose'")) return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.upload_empty_json_400', 'files', "POST /v1/files/upload with an EMPTY JSON object answers the vendor's 400 and stores nothing", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/files/upload', b: {} });
+      if (status(r) !== 400 || errType(r) !== 'invalid_request_error') return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.upload_no_filename_400', 'files', "POST /v1/files/upload with a purpose but NO file/filename part (a multipart without its file part, adapted) answers the vendor's 400 ('filename' is a required property) and stores nothing — filename is never defaulted to 'upload.jsonl'", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', content: '{}' } });
+      if (status(r) !== 400 || errType(r) !== 'invalid_request_error') return false;
+      if (!String((r.body as Body)?.error?.message).includes("'filename'")) return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.upload_no_purpose_400', 'files', "POST /v1/files/upload with a filename but NO purpose answers the vendor's 400 and stores nothing — purpose is never defaulted to 'fine-tune'", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/files/upload', b: { filename: 'x.jsonl', content: '{}' } });
+      if (status(r) !== 400 || errType(r) !== 'invalid_request_error') return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.sdk_flow_missing_name_400', 'files', "the SDK redirect flow with purpose in the query but NO file_name answers the vendor's 400 and stores nothing — the 302 is never minted for a half-specified flow", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/files?purpose=fine-tune&file_type=jsonl', b: '' });
+      if (status(r) !== 400 || errType(r) !== 'invalid_request_error') return false;
+      if (!String((r.body as Body)?.error?.message).includes("'filename'")) return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.sdk_flow_missing_purpose_400', 'files', "the SDK redirect flow with file_name in the query but NO purpose answers the vendor's 400 and stores nothing", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/files?file_name=rows.jsonl&file_type=jsonl', b: '' });
+      if (status(r) !== 400 || errType(r) !== 'invalid_request_error') return false;
+      if (!String((r.body as Body)?.error?.message).includes("'purpose'")) return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.sdk_flow_empty_query_400', 'files', "POST /v1/files with an EMPTY query and empty body answers the vendor's 400 naming the real doors and stores nothing", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/files', b: '' });
+      if (status(r) !== 400 || errType(r) !== 'invalid_request_error') return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.upload_door_unknown_id_404', 'files', "PUT /twin/upload/<id> for an UNKNOWN file id answers 404 and stores nothing — the bytes door refuses an object that does not exist", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const put = await handleTogetheraiUploadDoor({ method: 'PUT', path: '/twin/upload/file_nope', body: 'bytes', root });
+      if (status(put) !== 404) return false;
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.sdk_redirect_flow', 'files', "the together-ai SDK's own upload flow: POST /v1/files?<params> answers 302 + Location + x-together-file-id, and the PUT fills the bytes", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/files?file_name= sdk.jsonl&file_type=jsonl&purpose=fine-tune', b: '' });
+      if (status(r) !== 302) return false;
+      const loc = r.headers?.location;
+      const fid = r.headers?.['x-together-file-id'];
+      if (typeof loc !== 'string' || typeof fid !== 'string' || !fid) return false;
+      // The PUT lands on the twin-only /twin/upload door (kept out of the /v1 manifest on
+      // purpose); drive THAT handler directly — the /v1 router 404s the door by design, and the
+      // door itself answers a non-PUT with the same 404.
+      const wrongMethod = await handleTogetheraiUploadDoor({ method: 'GET', path: loc, root });
+      if (status(wrongMethod) !== 404) return false;
+      const put = await handleTogetheraiUploadDoor({ method: 'PUT', path: loc, body: 'the actual bytes', root });
+      if (!ok(put)) return false;
+      const one = await h({ m: 'GET', p: `/v1/files/${fid}` });
+      const b = one.body as Body;
+      return ok(one) && b.bytes === 'the actual bytes'.length;
+    })),
+  done('togetherai.files.content_download', 'files', 'GET /v1/files/:id/content returns the stored bytes', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const c = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'eval', filename: 'e.jsonl', content: 'BODY123' } });
+      if (!ok(c)) return false;
+      const r = await h({ m: 'GET', p: `/v1/files/${rid(c)}/content` });
+      return ok(r) && r.body === 'BODY123';
+    })),
+
+  // ── batches (stateful, Together-native shapes) ──────────────────────────────
+  done('togetherai.batches.create_201_wrapped', 'batches', 'POST /v1/batches answers 201 with BatchJobWithWarning {job} — NOT an OpenAI 200 batch object', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const bid = await seedBatch(h);
+      if (!bid) return false;
+      return bid.startsWith('batch_twin_');
+    })),
+  done('togetherai.batches.list_bare_array', 'batches', 'GET /v1/batches answers a BARE ARRAY of BatchJob (Together schema), not {object:list,data}', 'api', 'common', () =>
+    withRoot(async (h) => {
+      if (!(await seedBatch(h))) return false;
+      const r = await h({ m: 'GET', p: '/v1/batches' });
+      if (!ok(r) || !Array.isArray(r.body)) return false;
+      const b = (r.body as Body[])[0];
+      return b.status === 'VALIDATING' && b.endpoint === '/v1/chat/completions' && typeof b.input_file_id === 'string';
+    })),
+  done('togetherai.batches.endpoints_closed', 'batches', "Together's batch endpoint is a closed 3-set {chat/completions, audio/transcriptions, audio/translations} — OpenAI's /v1/embeddings endpoint is a 400", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const f = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'batch-api', filename: 'in.jsonl', content: '{}' } });
+      if (!ok(f)) return false;
+      const openai = await h({ m: 'POST', p: '/v1/batches', b: { input_file_id: rid(f), endpoint: '/v1/embeddings' } });
+      if (status(openai) !== 400) return false;
+      const audio = await h({ m: 'POST', p: '/v1/batches', b: { input_file_id: rid(f), endpoint: '/v1/audio/transcriptions' } });
+      return ok(audio);
+    })),
+  done('togetherai.batches.missing_file_404', 'batches', 'a batch over an unknown input_file_id is a 404 (never a fake success)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: '/v1/batches', b: { input_file_id: 'file_nope', endpoint: '/v1/chat/completions' } });
+      return status(r) === 404;
+    })),
+  done('togetherai.batches.empty_request_400', 'batches', "POST /v1/batches with NO body (and with an empty JSON object) answers the vendor's 400 ('input_file_id' is a required property) and stores nothing", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const empty = await h({ m: 'POST', p: '/v1/batches', b: undefined });
+      if (status(empty) !== 400 || errType(empty) !== 'invalid_request_error') return false;
+      if (!String((empty.body as Body)?.error?.message).includes("'input_file_id'")) return false;
+      const obj = await h({ m: 'POST', p: '/v1/batches', b: {} });
+      if (status(obj) !== 400) return false;
+      const half = await h({ m: 'POST', p: '/v1/batches', b: { endpoint: '/v1/chat/completions' } });
+      if (status(half) !== 400) return false;
+      const list = (await h({ m: 'GET', p: '/v1/batches' })).body as Body[];
+      if (!Array.isArray(list) || list.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.batches.cancel', 'batches', 'POST /v1/batches/:id/cancel moves the job to CANCELLED; cancelling again is a 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const bid = await seedBatch(h);
+      if (!bid) return false;
+      const c = await h({ m: 'POST', p: `/v1/batches/${bid}/cancel` });
+      if (!ok(c) || (c.body as Body).status !== 'CANCELLED') return false;
+      const again = await h({ m: 'POST', p: `/v1/batches/${bid}/cancel` });
+      return status(again) === 400;
+    })),
+  done('togetherai.batches.cancel_unknown_404', 'batches', 'POST /v1/batches/:id/cancel for an UNKNOWN batch answers 404 and stores nothing', 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/batches/batch_nope/cancel' });
+      if (status(r) !== 404) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.batches.progression_todo', 'batches', 'the asynchronous VALIDATING→IN_PROGRESS→COMPLETED progression is NOT simulated (a GET that writes would break the read contract) — filed as todo', 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const bid = await seedBatch(h);
+      if (!bid) return false;
+      // Seeding itself writes (batch.create); the read contract is about the GET.
+      const seeded = pendingActions('togetherai', root).length;
+      const before = await h({ m: 'GET', p: `/v1/batches/${bid}` });
+      if (!ok(before) || (before.body as Body).status !== 'VALIDATING') return false;
+      // A read must not write: no NEW pending actions after the GET.
+      return pendingActions('togetherai', root).length === seeded;
+    })),
+
+  // ── fine-tunes (stateful, Together-native) ──────────────────────────────────
+  done('togetherai.finetunes.create', 'fine_tuning', 'POST /v1/fine-tunes creates a job over a fine-tune-purpose file; a wrong-purpose file is a 400 and an unknown file a 404', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const good = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 't.jsonl', content: '{}' } });
+      if (!ok(good)) return false;
+      const ft = await h({ m: 'POST', p: '/v1/fine-tunes', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: rid(good) } });
+      if (!ok(ft) || (ft.body as Body).status !== 'pending') return false;
+      const evalFile = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'eval', filename: 'e.jsonl', content: '{}' } });
+      const wrong = await h({ m: 'POST', p: '/v1/fine-tunes', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: rid(evalFile) } });
+      if (status(wrong) !== 400) return false;
+      const missing = await h({ m: 'POST', p: '/v1/fine-tunes', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: 'file_nope' } });
+      return status(missing) === 404;
+    })),
+  done('togetherai.finetunes.empty_request_400', 'fine_tuning', "POST /v1/fine-tunes with NO body (and with an empty JSON object) answers the vendor's 400 ('model' is a required property) and stores nothing", 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const empty = await h({ m: 'POST', p: '/v1/fine-tunes', b: undefined });
+      if (status(empty) !== 400 || errType(empty) !== 'invalid_request_error') return false;
+      if (!String((empty.body as Body)?.error?.message).includes("'model'")) return false;
+      const obj = await h({ m: 'POST', p: '/v1/fine-tunes', b: {} });
+      if (status(obj) !== 400) return false;
+      const half = await h({ m: 'POST', p: '/v1/fine-tunes', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo' } });
+      if (status(half) !== 400) return false;
+      const list = (await h({ m: 'GET', p: '/v1/fine-tunes' })).body as Body[];
+      if (!Array.isArray(list) || list.length !== 0) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.finetunes.cancel_unknown_404', 'fine_tuning', 'POST /v1/fine-tunes/:id/cancel for an UNKNOWN job answers 404 and stores nothing', 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'POST', p: '/v1/fine-tunes/ft_nope/cancel' });
+      if (status(r) !== 404) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.finetunes.delete_unknown_404', 'fine_tuning', 'DELETE /v1/fine-tunes/:id for an UNKNOWN job answers 404 and stores nothing', 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'DELETE', p: '/v1/fine-tunes/ft_nope' });
+      if (status(r) !== 404) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.files.delete_unknown_404_noop', 'files', 'DELETE /v1/files/:id for an UNKNOWN file answers 404 and stores nothing (already asserted positively in togetherai.files.delete; this is the unchanged-store half of the door contract)', 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const r = await h({ m: 'DELETE', p: '/v1/files/file_nope' });
+      if (status(r) !== 404) return false;
+      return pendingActions('togetherai', root).length === 0;
+    })),
+  done('togetherai.finetunes.list_get_cancel_delete', 'fine_tuning', 'list / GET :id retrieves the stored job / cancel (status→cancel_requested, terminal states refused) / delete', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const f = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 't.jsonl', content: '{}' } });
+      if (!ok(f)) return false;
+      const ft = await h({ m: 'POST', p: '/v1/fine-tunes', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: rid(f) } });
+      if (!ok(ft)) return false;
+      const ftid = rid(ft);
+      const list = await h({ m: 'GET', p: '/v1/fine-tunes' });
+      if (!ok(list) || !(list.body as Body[]).some((x) => x.id === ftid)) return false;
+      // GET /v1/fine-tunes/{id} reads the STORED job back (read-back, not just a 200): a handler
+      // that lost the route answers the router's not-found and this fails.
+      const one = await h({ m: 'GET', p: `/v1/fine-tunes/${ftid}` });
+      if (!ok(one) || (one.body as Body).id !== ftid || (one.body as Body).status !== 'pending') return false;
+      const missing = await h({ m: 'GET', p: '/v1/fine-tunes/ft_nope' });
+      if (status(missing) !== 404) return false;
+      const cancel = await h({ m: 'POST', p: `/v1/fine-tunes/${ftid}/cancel` });
+      if (!ok(cancel) || (cancel.body as Body).status !== 'cancel_requested') return false;
+      const again = await h({ m: 'POST', p: `/v1/fine-tunes/${ftid}/cancel` });
+      if (status(again) !== 400) return false;
+      const del = await h({ m: 'DELETE', p: `/v1/fine-tunes/${ftid}` });
+      // Together's fine-tune delete answers {message} (fine-tuning.d.ts:1073), not {id, deleted}.
+      if (!ok(del) || typeof (del.body as Body).message !== 'string') return false;
+      // A DELETE of an UNKNOWN fine-tune is a 404, never a fake success.
+      const delMissing = await h({ m: 'DELETE', p: '/v1/fine-tunes/ft_nope' });
+      return status(delMissing) === 404 && errType(delMissing) === 'invalid_request_error';
+    })),
+  done('togetherai.finetunes.aux_endpoints', 'fine_tuning', 'estimate-price (the SDK\'s discriminated union: an AvailableEstimate whose token counts derive from the stored file\'s content, train_file_invalid over an unknown one) / preview (tokenized rows over the sampled file, 404 over an unknown one) / events + checkpoints (derived from the stored job\'s status; an unknown job 404s) / models/limits (the FinetuneModelLimits shape for a known chat model, 404 otherwise)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      // An unknown training_file → UnavailableEstimate with the vendor's train_file_invalid reason.
+      const unknown = await h({ m: 'POST', p: '/v1/fine-tunes/estimate-price', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: 'file_nope' } });
+      if (!ok(unknown)) return false;
+      const u = unknown.body as Body;
+      if (u.estimation_available !== false || u.unavailable_reason !== 'train_file_invalid') return false;
+      // A real file → AvailableEstimate whose token counts DERIVE from the stored content:
+      // two JSONL rows of 3 tokens each estimate 6 train tokens (n_epochs omitted → 1), so a
+      // handler that answers zeros or ignores the file loses the read-back.
+      const made = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 'est.jsonl', content: '{"text":"r"}\n{"text":"s"}\n' } });
+      if (!ok(made)) return false;
+      const fid = (made.body as Body).id as string;
+      const price = await h({ m: 'POST', p: '/v1/fine-tunes/estimate-price', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: fid } });
+      if (!ok(price)) return false;
+      const p = price.body as Body;
+      if (p.estimation_available !== true || typeof p.estimated_total_price !== 'number' || p.estimated_total_price <= 0) return false;
+      if (p.estimated_train_token_count !== 6) return false;
+      // More epochs scale the estimate — the same read-back, a second way.
+      const price3 = await h({ m: 'POST', p: '/v1/fine-tunes/estimate-price', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: fid, n_epochs: 3 } });
+      if (!ok(price3) || (price3.body as Body).estimated_train_token_count !== 18) return false;
+      // Preview over the SAME file: vendor's FineTunePreviewResponse — rows carrying
+      // input_ids/labels/num_tokens, max_seq_length from the model's context length.
+      const prev = await h({ m: 'POST', p: '/v1/fine-tunes/preview', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: fid } });
+      if (!ok(prev)) return false;
+      const pv = prev.body as Body;
+      if (pv.max_seq_length !== 131_072 || pv.model !== 'meta-llama/Llama-3.3-70B-Instruct-Turbo' || !Array.isArray(pv.rows) || pv.rows.length !== 2) return false;
+      const row = pv.rows[0] as Body;
+      if (!Array.isArray(row.input_ids) || row.input_ids.length === 0 || !Array.isArray(row.labels) || typeof row.num_tokens !== 'number') return false;
+      const prevUnknown = await h({ m: 'POST', p: '/v1/fine-tunes/preview', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: 'file_nope' } });
+      if (status(prevUnknown) !== 404) return false;
+      // events + checkpoints over a REAL job: a pending job has no events (the vendor's job has
+      // not started) and no checkpoints (none produced); cancelling files the lifecycle events
+      // the stored status grounds; a still-running job yields NO fabricated checkpoint.
+      const ft = await h({ m: 'POST', p: '/v1/fine-tunes', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: fid } });
+      if (!ok(ft)) return false;
+      const ftid = (ft.body as Body).id as string;
+      const ev0 = await h({ m: 'GET', p: `/v1/fine-tunes/${ftid}/events` });
+      if (!ok(ev0) || (ev0.body as Body).data.length !== 0) return false;
+      const cp0 = await h({ m: 'GET', p: `/v1/fine-tunes/${ftid}/checkpoints` });
+      if (!ok(cp0) || (cp0.body as Body).data.length !== 0) return false;
+      const cancel = await h({ m: 'POST', p: `/v1/fine-tunes/${ftid}/cancel` });
+      if (!ok(cancel)) return false;
+      const ev1 = await h({ m: 'GET', p: `/v1/fine-tunes/${ftid}/events` });
+      if (!ok(ev1)) return false;
+      const data = (ev1.body as Body).data as Body[];
+      if (!(data.some((e) => e.type === 'job_start') && data.some((e) => e.type === 'cancel_requested'))) return false;
+      if (data.some((e) => e.object !== 'fine-tune-event')) return false;
+      const evUnknown = await h({ m: 'GET', p: '/v1/fine-tunes/ft_nope/events' });
+      if (status(evUnknown) !== 404) return false;
+      const cpUnknown = await h({ m: 'GET', p: '/v1/fine-tunes/ft_nope/checkpoints' });
+      if (status(cpUnknown) !== 404) return false;
+      // models/limits: the FinetuneModelLimits shape for a KNOWN chat model — the read-backs
+      // name the model and carry the vendor's REQUIRED keys; an unknown model is a 404 and a
+      // MISSING model_name is the vendor's 400 (model_name is REQUIRED, fine-tuning.d.ts:1798).
+      const limits = await h({ m: 'GET', p: '/v1/fine-tunes/models/limits?model_name=meta-llama/Llama-3.3-70B-Instruct-Turbo' });
+      if (!ok(limits)) return false;
+      const lm = limits.body as Body;
+      if (lm.model_name !== 'meta-llama/Llama-3.3-70B-Instruct-Turbo' || typeof lm.max_num_epochs !== 'number'
+        || typeof lm.lora_training?.max_rank !== 'number' || typeof lm.max_seq_length_sft !== 'number') return false;
+      const limitsUnknown = await h({ m: 'GET', p: '/v1/fine-tunes/models/limits?model_name=nope' });
+      if (status(limitsUnknown) !== 404) return false;
+      const limitsMissing = await h({ m: 'GET', p: '/v1/fine-tunes/models/limits' });
+      if (status(limitsMissing) !== 400 || errType(limitsMissing) !== 'invalid_request_error') return false;
+      // estimate-price with NEITHER required param is a 400; preview's guards: a missing model /
+      // training_file is a 400, an unknown one a 404, and a non-fine-tunable (image) model a 404.
+      const priceMissing = await h({ m: 'POST', p: '/v1/fine-tunes/estimate-price', b: {} });
+      if (status(priceMissing) !== 400) return false;
+      // fine-tuning.d.ts:1691 pins training_file as REQUIRED: a model-only request is a 400, never an estimate
+      const priceModelOnly = await h({ m: 'POST', p: '/v1/fine-tunes/estimate-price', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo' } });
+      if (status(priceModelOnly) !== 400 || errType(priceModelOnly) !== 'invalid_request_error') return false;
+      // create refuses an unknown base model the way preview and models/limits already do
+      const ftUnknownModel = await h({ m: 'POST', p: '/v1/fine-tunes', b: { model: 'not-a-real-model', training_file: fid } });
+      if (status(ftUnknownModel) !== 404) return false;
+      const prevNoModel = await h({ m: 'POST', p: '/v1/fine-tunes/preview', b: { training_file: fid } });
+      if (status(prevNoModel) !== 400) return false;
+      const prevNoFile = await h({ m: 'POST', p: '/v1/fine-tunes/preview', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo' } });
+      if (status(prevNoFile) !== 400) return false;
+      const prevImageModel = await h({ m: 'POST', p: '/v1/fine-tunes/preview', b: { model: 'black-forest-labs/FLUX.1-schnell', training_file: fid } });
+      if (status(prevImageModel) !== 404) return false;
+      // The dataset_format is DETECTED from the sampled rows (fine-tuning.d.ts:158,
+      // check-file.mjs column map): {text:…} rows are 'general'; {messages:…} rows are
+      // 'conversation'; {prompt,completion} rows are 'instruction'.
+      const conv = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 'conv.jsonl', content: '{"messages":[{"role":"user","content":"hi"}]}\n' } });
+      if (!ok(conv)) return false;
+      const prevConv = await h({ m: 'POST', p: '/v1/fine-tunes/preview', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: rid(conv) } });
+      if (!ok(prevConv) || (prevConv.body as Body).dataset_format !== 'conversation') return false;
+      const inst = await h({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 'inst.jsonl', content: '{"prompt":"q","completion":"a"}\n' } });
+      if (!ok(inst)) return false;
+      const prevInst = await h({ m: 'POST', p: '/v1/fine-tunes/preview', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: rid(inst) } });
+      if (!ok(prevInst) || (prevInst.body as Body).dataset_format !== 'instruction') return false;
+      return (prev.body as Body).dataset_format === 'general';
+    })),
+
+  // ── auth (modeled 401) ──────────────────────────────────────────────────────
+  done('togetherai.auth.missing_key_401', 'auth', 'a request with an auth surface but no credential is a 401 (Together: "A missing or invalid API key")', 'api', 'core', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'GET', p: '/v1/models', headers: {} });
+      return status(r) === 401 && errType(r) === 'invalid_request_error';
+    })),
+  done('togetherai.auth.invalid_key_401', 'auth', "the invalid-key sentinel answers 401; any other bearer key is accepted", 'api', 'core', () =>
+    withRootH(async (h) => {
+      const bad = await h({ m: 'GET', p: '/v1/models', headers: { authorization: 'Bearer twin_invalid' } });
+      if (status(bad) !== 401) return false;
+      const good = await h({ m: 'GET', p: '/v1/models', headers: { authorization: 'Bearer any-real-shaped-key' } });
+      return ok(good);
+    })),
+  done('togetherai.auth.trusted_calls_ungated', 'auth', 'in-process trusted calls (no headers, no apiKey) are NOT auth-gated', 'api', 'core', () =>
+    withRoot(async (h) => {
+      // Reads a real value back: a dead handler answering 200 {} must fail this too.
+      const r = await h({ m: 'GET', p: '/v1/models' });
+      return ok(r) && Array.isArray((r.body as Body)) && (r.body as Body[]).some((m) => m.id === 'meta-llama/Llama-3.3-70B-Instruct-Turbo');
+    })),
+
+  // ── rate limits / faults (deterministic triggers) ───────────────────────────
+  done('togetherai.rate.force_429', 'rate_limits', "x-twin-force-rate-limit answers Together's 429 (dynamic_request_limited) with x-ratelimit-reset", 'api', 'core', () =>
+    withRootH(async (h) => {
+      // Headers present → the auth gate runs; the trigger must pass a credential to reach it.
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: 'Bearer key_twin', 'x-twin-force-rate-limit': '1' } });
+      return status(r) === 429 && errType(r) === 'dynamic_request_limited'
+        && r.headers?.['x-ratelimit-reset'] === '60';
+    })),
+  done('togetherai.rate.force_402', 'rate_limits', "x-twin-force-spending-limit answers Together's 402 monthly spending limit", 'api', 'common', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: 'Bearer key_twin', 'x-twin-force-spending-limit': '1' } });
+      return status(r) === 402;
+    })),
+  done('togetherai.rate.force_503', 'rate_limits', "x-twin-force-engine-overloaded answers Together's 503 engine_overloaded", 'api', 'common', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: 'Bearer key_twin', 'x-twin-force-engine-overloaded': 'true' } });
+      return status(r) === 503 && errType(r) === 'engine_overloaded';
+    })),
+
+  // ── read-only (D3) ──────────────────────────────────────────────────────────
+  // EVERY write door, not only the /v1 router: the /twin/upload bytes door is driven by the
+  // server OUTSIDE handleTogetheraiTwinRequest (togetherai-server.ts calls
+  // handleTogetheraiUploadDoor directly), so a verify that only drove the router left that door
+  // writing on a --read-only server (§9 round three, defect 2). Each door is driven against a
+  // SEEDED resource so the 405 (not a 404) proves the guard — and the store count is asserted
+  // unchanged after every refusal.
+  done('togetherai.readonly.rejected', 'conformance', 'a readOnly twin rejects EVERY write door — both /v1 create doors, all four cancel/delete doors AND the twin-only PUT /twin/upload bytes door — with the vendor-shaped 405 while reads still answer', 'api', 'core', () =>
+    withRoot(async (h, root) => {
+      const ro = (s: Step) => handleTogetheraiTwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root, readOnly: true });
+      // Reads still answer.
+      const read = await ro({ m: 'GET', p: '/v1/models' });
+      if (!ok(read)) return false;
+      // The two create doors.
+      const upload = await ro({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'eval', filename: 'x.jsonl', content: '{}' } });
+      if (status(upload) !== 405) return false;
+      const sdkFlow = await ro({ m: 'POST', p: '/v1/files?file_name=x.jsonl&purpose=eval', b: '' });
+      if (status(sdkFlow) !== 405) return false;
+      // Seed the stateful objects the remaining doors mutate (seeded WRITABLE, before the
+      // read-only pass — the root is the same, so the seeds are real rows).
+      const seed = (s: Step) => handleTogetheraiTwinRequest({ method: s.m, path: s.p, body: s.b === undefined ? undefined : JSON.stringify(s.b), root });
+      const f = await seed({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'batch-api', filename: 'in.jsonl', content: '{}' } });
+      if (!ok(f)) return false;
+      const fid = rid(f);
+      const b = await seed({ m: 'POST', p: '/v1/batches', b: { input_file_id: fid, endpoint: '/v1/chat/completions' } });
+      if (!ok(b)) return false;
+      const bid = (b.body as Body).job?.id as string;
+      const ftSeed = await seed({ m: 'POST', p: '/v1/files/upload', b: { purpose: 'fine-tune', filename: 't.jsonl', content: '{}' } });
+      if (!ok(ftSeed)) return false;
+      const ft = await seed({ m: 'POST', p: '/v1/fine-tunes', b: { model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: rid(ftSeed) } });
+      if (!ok(ft)) return false;
+      const ftid = rid(ft);
+      // The four cancel/delete doors over SEEDED objects: a 404 here would mean the seed failed,
+      // not that the guard held.
+      const cancels = [
+        await ro({ m: 'POST', p: `/v1/batches/${bid}/cancel` }),
+        await ro({ m: 'POST', p: `/v1/fine-tunes/${ftid}/cancel` }),
+        await ro({ m: 'DELETE', p: `/v1/files/${fid}` }),
+        await ro({ m: 'DELETE', p: `/v1/fine-tunes/${ftid}` }),
+      ];
+      if (!cancels.every((r) => status(r) === 405)) return false;
+      // The twin-only bytes door, driven through its OWN handler (the path the server takes).
+      const put = await handleTogetheraiUploadDoor({ method: 'PUT', path: `/twin/upload/${fid}`, body: 'bytes', root, readOnly: true });
+      if (status(put) !== 405) return false;
+      // Nothing was written by any refusal: the store holds exactly the four seeds.
+      const list = await h({ m: 'GET', p: '/v1/files' });
+      if ((list.body as Body).data.length !== 2) return false;
+      const batches = (await h({ m: 'GET', p: '/v1/batches' })).body as Body[];
+      if (batches.length !== 1 || batches[0].status !== 'VALIDATING') return false;
+      const fts = (await h({ m: 'GET', p: '/v1/fine-tunes' })).body as Body[];
+      if (fts.length !== 1 || fts[0].status !== 'pending') return false;
+      const bytes = await h({ m: 'GET', p: `/v1/files/${fid}/content` });
+      return bytes.body === '{}';
+    })),
+
+  // ── connector ───────────────────────────────────────────────────────────────
+  done('togetherai.connector.pull_maps', 'connector', 'pull maps real Models/Files/Batches to sync resources (bare-array and {data} list shapes both accepted)', 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.pull_maps', async () => {
+      const calls: Array<{ method: string; path: string }> = [];
+      const execute: TogetheraiExecute = async (method, path) => {
+        const out: { [k: string]: unknown; data?: any } = { data: undefined };
+        calls.push({ method, path });
+        if (path === '/v1/models') out.data = [{ id: 'm2', object: 'model', created: 1, type: 'chat' }];
+        else if (path === '/v1/files') out.data = [{ id: 'f2', object: 'file', bytes: 5, created_at: 2, filename: 'f', purpose: 'fine-tune', Processed: true, FileType: 'jsonl' }];
+        else if (path === '/v1/batches') out.data = [{ id: 'b2', object: 'batch', endpoint: '/v1/chat/completions', input_file_id: 'f2', status: 'STATUS_COMPLETED', created_at: new Date(0).toISOString() }];
+        else throw new Error(`unexpected ${path}`);
+        return out;
+      };
+      const state = await pullTogetheraiState(execute);
+      if (state.length !== 3) return false;
+      if (calls.length !== 3 || !calls.every((c) => c.method === 'GET')) return false;
+      const model = state.find((r) => r.type === 'model');
+      const file = state.find((r) => r.type === 'file');
+      const batch = state.find((r) => r.type === 'batch');
+      return model?.id === 'm2' && file?.id === 'f2' && (file.fields as Body).Processed === true && batch?.id === 'b2';
+    })),
+  done('togetherai.connector.pull_error_throws', 'connector', 'a refused pull throws (an error envelope is NOT an empty account)', 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.pull_error_throws', async () => {
+      const execute: TogetheraiExecute = async () => ({ error: { message: 'dynamic_request_limited', type: 'dynamic_request_limited' } });
+      try {
+        await pullTogetheraiState(execute);
+        return false;
+      } catch (e) {
+        return e instanceof Error && e.message.includes('dynamic_request_limited');
+      }
+    })),
+  done('togetherai.connector.sync_noop_on_repeat', 'connector', 'syncing identical real state twice appends deltas once and nothing the second time', 'connector', 'core', () =>
+    // HOLLOW BY METHOD (2026-09-16 sweep): the "second identical sync appends 0" half is owned by
+    // the KERNEL's shadow-diff (world-core observe.ts foldResources — unchanged fields append
+    // nothing), not by a pack line; the sweep only mutates <pack>-twin/-connector/-stub. Hand-walked:
+    // every neuterable pack-side line (the fold call's `at`/`batch` keys, the resource map) either
+    // breaks the FIRST-sync half too or leaves the cell green — no pack line owns the repeat-noop
+    // alone. The pin still fails when sync stops working at all (the first-sync assertions).
+    withConnectorRoot('togetherai.connector.sync_noop_on_repeat', async (root) => {
+      // One row per collection (the fold observes models+files+batches — three collections, three
+      // observed rows), identical across the two syncs.
+      const execute: TogetheraiExecute = async (_method, path) => {
+        if (path === '/v1/models') return { data: [{ id: 'm2', object: 'model', created: 1, type: 'chat' }] };
+        if (path === '/v1/files') return { data: [] };
+        if (path === '/v1/batches') return { data: [] };
+        throw new Error(`unexpected ${path}`);
+      };
+      const first = await syncTogetheraiFromReal(execute, { root, occurredAt: '2026-09-16T00:00:01Z' });
+      const second = await syncTogetheraiFromReal(execute, { root, occurredAt: '2026-09-16T00:00:02Z' });
+      return first.observed === 1 && first.deltasAppended === 1 && second.observed === 1 && second.deltasAppended === 0;
+    })),
+  done('togetherai.connector.push_batch_create', 'connector', 'a local batch create pushes POST /v1/batches with a VENDOR-RESOLVED input_file_id and records the vendor id (nested job.id accepted)', 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.push_batch_create', async (root) => {
+      // A batch create references a file; file.create is UNPUSHABLE, so a file's vendor id exists
+      // at the twin only through a PULL (the fold observes the vendor's row under the vendor's own
+      // id — it does not alias a locally-minted row). Pull a vendor file first, then create the
+      // batch through the handler against it.
+      const pulled = await syncTogetheraiFromReal(async (_m, path) => {
+        if (path === '/v1/models') return { data: [] };
+        if (path === '/v1/files') return { data: [{ id: 'file-real-1', object: 'file', bytes: 14, created_at: 2, filename: 'in.jsonl', purpose: 'batch-api', Processed: true, FileType: 'jsonl' }] };
+        if (path === '/v1/batches') return { data: [] };
+        throw new Error(`unexpected ${path}`);
+      }, { root, occurredAt: '2026-09-16T00:00:00Z' });
+      if (pulled.observed !== 1) return false;
+      const created = await handleTogetheraiTwinRequest({ method: 'POST', path: '/v1/batches', body: JSON.stringify({ input_file_id: 'file-real-1', endpoint: '/v1/chat/completions' }), root, occurredAt: '2026-09-16T00:00:01Z' });
+      if (!ok(created)) return false;
+      const pending = pendingActions('togetherai', root).filter((a) => a.subject.type === 'batch');
+      if (pending.length !== 1) return false;
+      const calls: Array<{ method: string; path: string; body?: unknown }> = [];
+      const execute: TogetheraiExecute = async (method, path, body) => {
+        calls.push({ method, path, body });
+        return { job: { id: 'b-real-1' } };
+      };
+      // The push sends the file's VENDOR id (the pulled row's own id) — never a twin mint.
+      const pushed = await pushPendingTogetheraiActions(execute, { root, occurredAt: '2026-09-16T00:00:02Z' });
+      if (pushed.pushed !== 1 || calls.length !== 1) return false;
+      if (calls[0].method !== 'POST' || calls[0].path !== '/v1/batches') return false;
+      const sent = (calls[0].body ?? {}) as Body;
+      if (sent.input_file_id !== 'file-real-1' || sent.endpoint !== '/v1/chat/completions') return false;
+      // …and the vendor's answer is recorded as the batch's external id, so a later cancel
+      // addresses b-real-1, never the twin's mint.
+      const batch = projectResources('togetherai', root).find((r) => r.type === 'batch');
+      return batch?._external_id === 'b-real-1';
+    })),
+  done('togetherai.connector.push_batch_local_file_refused', 'connector', 'a batch create over a locally-minted file (no pull, no vendor id) is REFUSED, never sent with the twin\'s own id', 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.push_batch_local_file_refused', async (root) => {
+      // Seed a LOCAL file create (unpushable — no vendor id can ever be recorded for it) and a
+      // batch over it. The push must refuse the batch rather than send `file_twin_1` at the vendor.
+      const seeded = await handleTogetheraiTwinRequest({ method: 'POST', path: '/v1/files/upload', body: JSON.stringify({ purpose: 'batch-api', filename: 'in.jsonl', content: '{"text":"row"}' }), root, occurredAt: '2026-09-16T00:00:00Z' });
+      if (!ok(seeded)) return false;
+      const created = await handleTogetheraiTwinRequest({ method: 'POST', path: '/v1/batches', body: JSON.stringify({ input_file_id: rid(seeded), endpoint: '/v1/chat/completions' }), root, occurredAt: '2026-09-16T00:00:01Z' });
+      if (!ok(created)) return false;
+      if (pendingActions('togetherai', root).filter((a) => a.subject.type === 'batch').length !== 1) return false;
+      const calls: Array<{ method: string; path: string; body?: unknown }> = [];
+      const execute: TogetheraiExecute = async (method, path, body) => {
+        calls.push({ method, path, body });
+        return { job: { id: 'b-real-1' } };
+      };
+      const refused = await pushPendingTogetheraiActions(execute, { root, occurredAt: '2026-09-16T00:00:02Z' });
+      if (refused.pushed !== 0 || calls.length !== 0) return false;
+      if (!refused.refused.some((r) => r.operation === 'batch.create' && r.reason.includes('input_file_id'))) return false;
+      // Skip-and-report: the batch stays pending, so a later pull CAN still resolve it.
+      return pendingActions('togetherai', root).some((a) => a.subject.type === 'batch');
+    })),
+  done('togetherai.connector.push_addresses_vendor_id', 'connector', "a cancel of a PUSHED resource addresses the vendor by the recorded external id — never the twin's own mint", 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.push_addresses_vendor_id', async (root) => {
+      // Pull a vendor file (the only way a file gets a vendor id), create a batch over it through
+      // the handler, push: the create confirms and records `b-real-9` as the batch's external id.
+      const pulled = await syncTogetheraiFromReal(async (_m, path) => {
+        if (path === '/v1/models') return { data: [] };
+        if (path === '/v1/files') return { data: [{ id: 'file-real-9', object: 'file', bytes: 14, created_at: 2, filename: 'in.jsonl', purpose: 'batch-api', Processed: true, FileType: 'jsonl' }] };
+        if (path === '/v1/batches') return { data: [] };
+        throw new Error(`unexpected ${path}`);
+      }, { root, occurredAt: '2026-09-16T00:00:00Z' });
+      if (pulled.observed !== 1) return false;
+      const created = await handleTogetheraiTwinRequest({ method: 'POST', path: '/v1/batches', body: JSON.stringify({ input_file_id: 'file-real-9', endpoint: '/v1/chat/completions' }), root, occurredAt: '2026-09-16T00:00:01Z' });
+      if (!ok(created)) return false;
+      const calls: Array<{ method: string; path: string }> = [];
+      const execute: TogetheraiExecute = async (method, path) => {
+        calls.push({ method, path });
+        return method === 'POST' ? { job: { id: 'b-real-9' } } : {};
+      };
+      const first = await pushPendingTogetheraiActions(execute, { root, occurredAt: '2026-09-16T00:00:02Z' });
+      if (first.pushed !== 1) return false;
+      const batch = projectResources('togetherai', root).find((r) => r.type === 'batch');
+      if (!batch || batch._external_id !== 'b-real-9') return false;
+      // Cancel the pushed batch: the wire must address b-real-9, never the twin's mint.
+      const cancelled = await handleTogetheraiTwinRequest({ method: 'POST', path: `/v1/batches/${String(batch.id)}/cancel`, root, occurredAt: '2026-09-16T00:00:03Z' });
+      if (!ok(cancelled)) return false;
+      const before = calls.length;
+      const second = await pushPendingTogetheraiActions(execute, { root, occurredAt: '2026-09-16T00:00:04Z' });
+      if (second.pushed !== 1) return false;
+      const cancelCall = calls.slice(before).find((c) => c.path.includes('/cancel'));
+      return cancelCall !== undefined && cancelCall.path === '/v1/batches/b-real-9/cancel';
+    })),
+  done('togetherai.connector.unpushable_file_create', 'connector', "file.create is REFUSED with a reason (the 302-redirect upload is not expressible in JSON) — skip-and-report, never confirmed", 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.unpushable_file_create', async (root) => {
+      const reason = unpushableReason('file.create');
+      if (reason === null) return false;
+      // Seed a REAL local file create through the handler so there is a pending action to refuse.
+      const seeded = await handleTogetheraiTwinRequest({ method: 'POST', path: '/v1/files/upload', body: JSON.stringify({ purpose: 'batch-api', filename: 'up.jsonl', content: '{"text":"row"}' }), root, occurredAt: '2026-09-16T00:00:00Z' });
+      if (!ok(seeded)) return false;
+      const pending = pendingActions('togetherai', root).filter((a) => a.subject.type === 'file');
+      if (pending.length !== 1) return false;
+      const execute: TogetheraiExecute = async () => { throw new Error('must not be called'); };
+      const pushed = await pushPendingTogetheraiActions(execute, { root, occurredAt: '2026-09-16T00:00:01Z' });
+      // Skipped-and-reported: not confirmed, stays pending, named in `refused`.
+      return pushed.pushed === 0 && pushed.refused.length === 1 && pushed.refused[0].reason.length > 0
+        && pendingActions('togetherai', root).some((a) => a.subject.type === 'file');
+    })),
+  done('togetherai.connector.local_id_never_addressed', 'connector', 'a locally-minted subject with no recorded external id is refused, never guessed at', 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.local_id_never_addressed', async () => {
+      try {
+        togetheraiRequestForAction({ operation: 'file.delete', subject: { type: 'file', id: 'file_twin_1' } });
+        return false;
+      } catch (e) {
+        return e instanceof Error && e.message.includes('refusing to address');
+      }
+    })),
+  done('togetherai.connector.full_sync', 'connector', 'fullSync pushes then pulls; re-running with nothing pending and identical state is a no-op', 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.full_sync', async (root) => {
+      // The fixture CARRIES a pending pushable action (§9 round two, R2-D1: a push half over an
+      // empty pending queue is vacuous — it proves nothing about the push). A finetune over the
+      // pulled file pushes POST /v1/fine-tunes inside the first sync's push half.
+      let files = [{ id: 'f-real', object: 'file', bytes: 3, created_at: 1, filename: 'f', purpose: 'fine-tune', Processed: true, FileType: 'jsonl' }];
+      const pushedCreates: Array<{ method: string; path: string }> = [];
+      const execute: TogetheraiExecute = async (method, path, body) => {
+        const out: { [k: string]: unknown; data?: any } = { data: undefined };
+        if (path === '/v1/files') { out.data = files; if (method !== 'GET') out.id = 'f-real-2'; }
+        else if (path === '/v1/fine-tunes') { pushedCreates.push({ method, path }); return { id: 'ft-real-1' }; }
+        else if (path === '/v1/batches' || path === '/v1/models') out.data = [];
+        else throw new Error(`unexpected ${method} ${path}`);
+        return out;
+      };
+      // Pull first so the file exists with its vendor id, then create the finetune locally.
+      const seed = await syncTogetheraiFromReal(execute, { root, occurredAt: '2026-09-16T00:00:00Z' });
+      if (seed.observed < 1) return false;
+      const created = await handleTogetheraiTwinRequest({ method: 'POST', path: '/v1/fine-tunes', body: JSON.stringify({ model: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', training_file: 'f-real' }), root, occurredAt: '2026-09-16T00:00:01Z' });
+      if (!ok(created)) return false;
+      const first = await fullSyncTogetherai(execute, { root, occurredAt: '2026-09-16T00:00:02Z' });
+      if (first.pushed !== 1 || pushedCreates.length !== 1 || pushedCreates[0].path !== '/v1/fine-tunes') return false;
+      const ftRow = projectResources('togetherai', root).find((r) => r.type === 'finetune');
+      if (!ftRow || ftRow._external_id !== 'ft-real-1') return false;
+      const second = await fullSyncTogetherai(execute, { root, occurredAt: '2026-09-16T00:00:03Z' });
+      return second.deltasAppended === 0 && second.pushed === 0;
+    })),
+  done('togetherai.connector.live_guard_path', 'connector', 'liveTogetheraiExecute refuses an unmodeled path BEFORE charging the budget', 'connector', 'core', () =>
+    withConnectorRoot('togetherai.connector.live_guard_path', async () => {
+      let fetched = 0;
+      const exec = liveTogetheraiExecute('sk_twin_test', 'https://api.together.xyz', { fetchImpl: (async () => { fetched += 1; throw new Error('should not fetch'); }) as unknown as typeof fetch });
+      try {
+        await exec('GET', '/v2/endpoints');
+        return false;
+      } catch (e) {
+        return fetched === 0 && e instanceof Error && e.message.includes('unmodeled path');
+      }
+    })),
+  done('togetherai.connector.live_guard_budget', 'connector', 'liveTogetheraiExecute charges the budget before the fetch and refuses when the ceiling says stop', 'connector', 'core', () =>
+    // HOLLOW BY METHOD (2026-09-16 sweep): the owning line — `const reservation =
+    // budget.checkBudget(weight);` — is a const declaration, unreachable by the sweep's GUARD and
+    // PROPERTY families. Hand-walked: replacing the call with a constant reservation (charging
+    // nothing) reddens THIS cell — the 11th call succeeds when the ceiling check is skipped, so
+    // `count() === 10` fails. The pin is live, just outside the sweep's grammar.
+    withConnectorRoot('togetherai.connector.live_guard_budget', async (root) => {
+      let fetched = 0;
+      const count = () => fetched;
+      // An ISOLATED ledger under this verify's own root: the default ledger path is shared across
+      // the process, so another test's charges would make this verify order-dependent (§9 round
+      // one, S1).
+      const exec = liveTogetheraiExecute('sk_twin_test', 'https://api.together.xyz', {
+        fetchImpl: (async () => { fetched += 1; return new Response(JSON.stringify({ id: 'm' }), { status: 200 }); }) as unknown as typeof fetch,
+        budgetOptions: { path: join(root, 'budget-ledger.json') },
+      });
+      try { await exec('POST', '/v1/chat/completions', { model: 'm' }); } catch { return false; }
+      if (count() !== 1) return false;
+      // inference weight 6: after 10 calls the 60-unit window is exhausted → the 11th refuses.
+      for (let i = 0; i < 9; i++) {
+        try { await exec('POST', '/v1/chat/completions', { model: 'm' }); } catch { return false; }
+      }
+      try {
+        await exec('POST', '/v1/chat/completions', { model: 'm' });
+        return false; // the 11th must have been refused
+      } catch {
+        return count() === 10;
+      }
+    })),
+
+  // ── v2 management half — real Together surface, out of the served scope ─────
+  todo('togetherai.endpoints.crud', 'endpoints', 'v2 endpoints (create/list/get/update/delete + hardware + clusters/availability-zones)', 'api', 'niche'),
+  todo('togetherai.endpoints.deployments', 'endpoints', 'deployments + rollouts + ab/shadow experiments + adapters', 'api', 'niche'),
+  todo('togetherai.compute.clusters', 'compute', 'compute clusters/regions/storage + remediations', 'api', 'niche'),
+  todo('togetherai.videos', 'videos', 'video generation (v2 base URL)', 'api', 'niche'),
+  todo('togetherai.evaluation', 'evaluation', 'evaluation runs + model-list', 'api', 'niche'),
+  todo('togetherai.queue', 'queue', 'queue submit/status/cancel/clear/metrics', 'api', 'niche'),
+  todo('togetherai.tci', 'tci', 'tci execute + sessions', 'api', 'niche'),
+  todo('togetherai.rl', 'models', 'rl model-resources + training-sessions + operations (v2 management half)', 'api', 'niche'),
+  todo('togetherai.audio.websocket', 'audio', '/v1/audio/speech/websocket (realtime speech)', 'api', 'niche'),
+  todo('togetherai.finetunes.metrics', 'fine_tuning', '/v1/fine-tunes/{id}/metrics + download-tokenized-dataset + /finetune/download', 'api', 'niche'),
+  todo('togetherai.models.upload', 'models', 'POST /v1/models (upload a custom model) + /v1/models/{id}/events', 'api', 'niche'),
+  todo('togetherai.billing', 'usage', '/v1/billing/usage', 'api', 'niche'),
+  // Together's error ENVELOPE behavior as a first-class area (the {message,type} two-key body
+  // every 4xx/5xx carries, and its status table) — the per-status cases live in their areas.
+  todo('togetherai.errors.envelope', 'errors', 'the vendor error envelope {message,type[,param,code]} across every 4xx/5xx (consistency sweep)', 'api', 'core'),
+  todo('togetherai.usage.endpoints', 'usage', 'the v2 usage/reporting endpoints (model usage, balances)', 'api', 'niche'),
+  todo('togetherai.batches.progression', 'batches', 'the asynchronous batch status progression (VALIDATING→IN_PROGRESS→COMPLETED) — needs a write-on-tick design that keeps GETs read-only', 'api', 'common'),
+  todo('togetherai.connector.pull_finetunes', 'connector', 'the connector pulls no finetune collection (COLLECTIONS covers model/file/batch) — a finetune created at the vendor never mirrors in', 'connector', 'common'),
+  todo('togetherai.finetunes.progression', 'fine_tuning', 'the asynchronous fine-tune status progression (pending→running→completed) — same constraint as batches', 'api', 'common'),
+  todo('togetherai.files.finetune_validation', 'files', 'fine-tune file VALIDATION (format checks + validation_report on the FileResponse)', 'api', 'common'),
+];
+
+export const TOGETHERAI_AREAS = [
+  'audio', 'auth', 'batches', 'chat', 'compute', 'conformance', 'connector', 'embeddings',
+  'endpoints', 'errors', 'evaluation', 'files', 'fine_tuning', 'images', 'models', 'protocol', 'queue',
+  'rate_limits', 'rerank', 'streaming', 'structured_outputs', 'tools', 'tci', 'usage', 'videos', 'whoami',
+] as const;
+
+export function togetheraiCapabilities(): Promise<CapabilityReport> {
+  return checkCapabilities('togetherai', TOGETHERAI_CAPABILITIES);
+}