@volter/twin-moonshot 0.1.0

package/src/moonshot-capabilities.ts

@@ -0,0 +1,1220 @@
+// Moonshot capability manifest — the EXPECTED REAL-PRODUCT SURFACE (the target), authored
+// top-down from what the Moonshot Platform API actually does — NOT from what this twin has
+// built. The denominator was enumerated from FIRST-PARTY sources, all read 2026-09-16:
+//   • Moonshot's own OpenAPI 3.1.0 document (https://platform.kimi.ai/docs/openapi.json —
+//     19 operations / 69 schemas): every request schema's parameter union, per-request model
+//     enum, required fields and documented 400s. This is what fixed the three inference
+//     protocols (OpenAI-compatible /v1/chat/completions + /v1/responses, Anthropic-compatible
+//     /anthropic/v1/messages), the closed thinking/reasoning_effort sets, the batch
+//     completion_window grammar, the files purposes, and the balance envelope;
+//   • platform.kimi.ai/docs/{overview,api-reference,errors,models,pricing/limits,
+//     guides/context-caching}: the error-type table, the tier limits (RPM 3 at Tier 0), the
+//     model table (context windows, retired ids), and the context-caching semantics behind
+//     the usage split.
+// 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/reasoning) 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". For Moonshot that is the chat-completions + streaming + tools + errors + auth
+// spine plus the conformance and connector-pull backbone. The Responses and Messages surfaces
+// (kimi-k3 only, newer), files/batches (batch workloads), the token/signature/web-search
+// helpers, and balance are `common`. Single-field refinements are `niche`.
+//
+// (Moonshot is an API-first vendor — platform.moonshot.cn's console is a keys/usage 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 { handleMoonshotTwinRequest, messagesSignature, MESSAGES_PREFIX, MOONSHOT_API_PREFIX, type MoonshotResponseEnvelope } from './moonshot-twin.ts';
+import {
+  fullSyncMoonshot,
+  moonshotRequestForAction,
+  pullMoonshotState,
+  pushMoonshotAction,
+  pushPendingMoonshotActions,
+  syncMoonshotFromReal,
+  type MoonshotExecute,
+} from './moonshot-connector.ts';
+import { MoonshotBudget, MoonshotBudgetError, MOONSHOT_BUDGET_CEILING, MOONSHOT_CALL_WEIGHTS, MOONSHOT_RATE_BUDGET_WINDOW_MS, moonshotBudgetPath, moonshotCallWeight } from './moonshot-budget.ts';
+import type { MessagesSseEvent, SseEvent } from './moonshot-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 Moonshot requests against an isolated root; return all responses. */
+async function withRoot(steps: (h: (s: Step) => Promise<MoonshotResponseEnvelope>, root: string) => Promise<boolean>): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'moonshot-cap-'));
+  const h = (s: Step) => handleMoonshotTwinRequest({ 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('moonshot.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/503 triggers, and the signature headers). */
+type StepH = Step & { headers?: Record<string, string> };
+async function withRootH(steps: (h: (s: StepH) => Promise<MoonshotResponseEnvelope>) => Promise<boolean>): Promise<boolean> {
+  const root = mkdtempSync(join(tmpdir(), 'moonshot-cap-'));
+  const h = (s: StepH) => handleMoonshotTwinRequest({ 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('moonshot.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: MoonshotResponseEnvelope) => boolean): Promise<boolean> {
+  return new Promise<boolean>((resolve, reject) => {
+    const root = mkdtempSync(join(tmpdir(), 'moonshot-cap-'));
+    const events: SseEvent[] = [];
+    handleMoonshotTwinRequest({ method: 'POST', path: `${MOONSHOT_API_PREFIX}/chat/completions`, body: JSON.stringify({ ...(body as Body), stream: true }), root, sseSink: (e) => events.push(e) })
+      .then((final) => resolve(fn(events, final)))
+      .catch((err) => { if (isInfrastructureError(err)) reject(harnessError('moonshot.withStream', err)); else resolve(false); })
+      .finally(() => rmSync(root, { recursive: true, force: true }));
+  });
+}
+
+/** Collect the named-event SSE frames (Messages / Responses grammar) for a request. */
+function withNamedStream(path: string, body: unknown, fn: (events: MessagesSseEvent[], final: MoonshotResponseEnvelope) => boolean): Promise<boolean> {
+  return new Promise<boolean>((resolve, reject) => {
+    const root = mkdtempSync(join(tmpdir(), 'moonshot-cap-'));
+    const events: MessagesSseEvent[] = [];
+    handleMoonshotTwinRequest({ method: 'POST', path, body: JSON.stringify({ ...(body as Body), stream: true }), root, messagesSseSink: (e) => events.push(e) })
+      .then((final) => resolve(fn(events, final)))
+      .catch((err) => { if (isInfrastructureError(err)) reject(harnessError('moonshot.withNamedStream', 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(), 'moonshot-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: MoonshotResponseEnvelope) => r.status >= 200 && r.status < 300;
+const id = (r: MoonshotResponseEnvelope) => (r.body as Body)?.id as string;
+const errType = (r: MoonshotResponseEnvelope) => (r.body as Body)?.error?.type as string;
+
+// ── shorthands (mirror the groq manifest) ──
+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 = `${MOONSHOT_API_PREFIX}/chat/completions`;
+const MESSAGES_PATH = `${MESSAGES_PREFIX}/messages`;
+const CHAT = (extra: Record<string, unknown> = {}) => ({ model: 'kimi-k3', messages: [{ role: 'user', content: 'hello twin' }], ...extra });
+const K26 = (extra: Record<string, unknown> = {}) => ({ model: 'kimi-k2.6', 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' } } } } };
+
+/** Seed a batch-purpose file and a batch over it. Returns the batch id (or null). */
+async function seedBatch(h: (s: Step) => Promise<MoonshotResponseEnvelope>): Promise<string | null> {
+  const f = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/files`, b: { purpose: 'batch', filename: 'in.jsonl', content: '{"custom_id":"a"}' } });
+  if (!ok(f)) return null;
+  const b = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/batches`, b: { input_file_id: id(f), endpoint: '/v1/chat/completions', completion_window: '24h' } });
+  return ok(b) ? id(b) : null;
+}
+
+/** A recording fake executor: `calls` is the ground truth a connector verify reads. */
+function fakeExecute(reply: (method: string, path: string) => unknown = () => ({ data: [] })): { execute: MoonshotExecute; calls: string[]; bodies: Array<Record<string, unknown> | undefined> } {
+  const calls: string[] = [];
+  // The BODY is recorded too: a push verify that asserts only method+path cannot see a payload
+  // that would 400 at the real vendor (§9 round one, groq finding 6).
+  const bodies: Array<Record<string, unknown> | undefined> = [];
+  const execute: MoonshotExecute = async (method, path, body) => {
+    calls.push(`${method} ${path}`);
+    bodies.push(body);
+    return reply(method, path) as Awaited<ReturnType<MoonshotExecute>>;
+  };
+  return { execute, calls, bodies };
+}
+
+export const MOONSHOT_CAPABILITIES: CapabilitySpec[] = [
+  // ── Planned gaps ──────────────────────────────────────────────────────────────────────
+  todo('moonshot.chat.per_request_response_ids', 'chat', 'Chat ids are unique per request: `id` is derived from a hash of (messages, model) today, so two identical calls share one id', 'api', 'niche'),
+  todo('moonshot.batches.cancellation_settles', 'batches', 'Batch cancel eventually settles cancelling→cancelled asynchronously (the twin stops at `cancelling`; settling on a READ would break the read-only contract)', 'api', 'niche'),
+  todo('moonshot.connector.push_file_create', 'connector', 'Connector: push a local file create (real POST /v1/files is multipart with the file body; the JSON executor cannot express it)', 'connector', 'niche'),
+  todo('moonshot.connector.unpushable_actions_drain', 'connector', 'Connector: a permanently-unpushable action can be acknowledged so `pendingActions` can reach empty again', 'connector', 'niche'),
+
+  // ── Chat Completions (the protocol envelope — faithful) ────────────────────────────────
+  done('moonshot.chat.create', 'chat', 'Chat: create → faithful envelope (id/object/created/model/choices/usage with cached_tokens)', '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;
+      if (b.object !== 'chat.completion' || b.model !== 'kimi-k3' || typeof b.created !== 'number') return false;
+      if (!String(b.id).startsWith('chatcmpl-twin-')) return false;
+      const c = b.choices?.[0];
+      if (!c || c.message?.role !== 'assistant' || typeof c.message?.content !== 'string' || c.finish_reason !== 'stop') return false;
+      const u = b.usage;
+      return typeof u?.prompt_tokens === 'number' && u.prompt_tokens > 0
+        && u.total_tokens === u.prompt_tokens + u.completion_tokens
+        && typeof u.cached_tokens === 'number';
+    }),
+  ),
+  done('moonshot.chat.stub_labeled', 'chat', 'Stub completion is clearly labeled as a twin stub (not real output)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      const text = (r.body as Body).choices?.[0]?.message?.content as string;
+      return ok(r) && typeof text === 'string' && text.includes('[twin-stub:kimi-k3]') && text.includes('hello twin');
+    }),
+  ),
+  done('moonshot.chat.validation', 'chat', 'Chat validation (model required + known, messages required + non-empty, roles closed set)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const noModel = await h({ m: 'POST', p: CHAT_PATH, b: { messages: [{ role: 'user', content: 'x' }] } });
+      const unknown = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ model: 'moonshot-v1-8k' }) });
+      const noMsg = await h({ m: 'POST', p: CHAT_PATH, b: { model: 'kimi-k3' } });
+      const empty = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ messages: [] }) });
+      const badRole = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ messages: [{ role: 'chef', content: 'x' }] }) });
+      return [noModel, unknown, noMsg, empty, badRole].every((r) => r.status === 400 && errType(r) === 'invalid_request_error')
+        && String((unknown.body as Body).error.message).includes('moonshot-v1-8k');
+    }),
+  ),
+  done('moonshot.chat.deterministic', 'chat', 'Chat: an identical request replays byte-identically (serve-path determinism)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const a = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      const b = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      if (!ok(a) || !ok(b)) return false;
+      const ba = a.body as Body;
+      // A real, populated envelope — not merely "equal because both are undefined".
+      if (typeof ba.id !== 'string' || !ba.id.startsWith('chatcmpl-twin-')) return false;
+      if (typeof ba.usage?.total_tokens !== 'number') return false;
+      return JSON.stringify(a.body) === JSON.stringify(b.body);
+    }),
+  ),
+  done('moonshot.chat.max_completion_tokens', 'chat', 'Chat: max_completion_tokens (and the max_tokens alias) cap the OUTPUT — finish_reason length AND usage.completion_tokens counts what was emitted; 0 is a 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const long = [{ role: 'user', content: 'please produce a long answer that exceeds one token' }];
+      const a = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_completion_tokens: 1, messages: long }) });
+      const b = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_tokens: 1, messages: long }) });
+      const bad = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ max_completion_tokens: 0 }) });
+      if (!ok(a) || !ok(b) || bad.status !== 400) return false;
+      for (const r of [a, b]) {
+        const body = r.body as Body;
+        if (body.choices[0].finish_reason !== 'length') return false;
+        // THE CAP IS APPLIED, not merely reported: the emitted text fits the cap and
+        // completion_tokens counts the emitted content (+ reasoning) — usage that counts
+        // uncapped content while claiming the cap was the round-two finding.
+        const msg = body.choices[0].message;
+        const emitted = String(msg.content ?? '').length + String(msg.reasoning_content ?? '').length;
+        if (body.usage.completion_tokens * 4 < emitted) return false;
+      }
+      return true;
+    }),
+  ),
+  done('moonshot.chat.context_window_overflow', 'chat', 'Chat: input + max_completion_tokens beyond the model context window is a 400 invalid_request_error', 'api', 'common', () =>
+    withRoot(async (h) => {
+      // kimi-k2.6's window is 262,144; a max_completion_tokens over it must refuse.
+      const over = await h({ m: 'POST', p: CHAT_PATH, b: K26({ max_completion_tokens: 300_000 }) });
+      const fits = await h({ m: 'POST', p: CHAT_PATH, b: K26({ max_completion_tokens: 1000 }) });
+      return over.status === 400 && errType(over) === 'invalid_request_error'
+        && String((over.body as Body).error.message).includes('context window') && ok(fits);
+    }),
+  ),
+  done('moonshot.chat.stop', 'chat', "Chat: stop truncates at the EARLIEST hit; the closed limits (≤5 entries, ≤32 bytes each) are enforced", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const one = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ stop: 'Echoing' }) });
+      const many = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ stop: ['Echoing', 'deterministic'] }) });
+      const tooMany = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ stop: ['a', 'b', 'c', 'd', 'e', 'f'] }) });
+      const tooLong = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ stop: 'x'.repeat(33) }) });
+      const t1 = (one.body as Body).choices[0].message.content as string;
+      const t2 = (many.body as Body).choices[0].message.content as string;
+      return ok(one) && ok(many) && tooMany.status === 400 && tooLong.status === 400
+        && !t1.includes('Echoing') && !t2.includes('deterministic') && !t2.includes('Echoing') && t2.length < t1.length;
+    }),
+  ),
+  done('moonshot.chat.multi_turn', 'chat', 'Chat: multi-turn user/assistant history accepted and echoed from the last user turn', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ messages: [{ role: 'user', content: 'first question' }, { role: 'assistant', content: 'reply' }, { role: 'user', content: 'second question' }] }) });
+      const text = (r.body as Body).choices?.[0]?.message?.content as string;
+      return ok(r) && text.includes('second question') && !text.includes('first question');
+    }),
+  ),
+  done('moonshot.chat.system_message', 'chat', 'Chat: system messages count toward prompt_tokens', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const without = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      const withSys = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ messages: [{ role: 'system', content: 'You are a careful, verbose assistant.' }, { role: 'user', content: 'hello twin' }] }) });
+      return ok(without) && ok(withSys) && (withSys.body as Body).usage.prompt_tokens > (without.body as Body).usage.prompt_tokens;
+    }),
+  ),
+  done('moonshot.chat.vision_gating', 'chat', 'Chat: image_url parts accepted on the vision models (kimi-k3, kimi-k2.6) and refused on kimi-k2.7-code', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const img = [{ role: 'user', content: [{ type: 'text', text: 'what is this' }, { type: 'image_url', image_url: { url: 'https://example.test/cat.png' } }] }];
+      const k3 = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ messages: img }) });
+      const k26 = await h({ m: 'POST', p: CHAT_PATH, b: K26({ messages: img }) });
+      const k27 = await h({ m: 'POST', p: CHAT_PATH, b: { model: 'kimi-k2.7-code', messages: img } });
+      return ok(k3) && ok(k26) && k27.status === 400
+        && String((k27.body as Body).error.message).includes('does not support image input');
+    }),
+  ),
+  done('moonshot.chat.dynamic_tool_message', 'chat', "Chat: kimi-k3's dynamic tool loading — a system message with `tools` and no content — is accepted; the same shape on any other role is a 400", 'api', 'niche', () =>
+    withRoot(async (h) => {
+      const good = await h({ m: 'POST', p: CHAT_PATH, b: { model: 'kimi-k3', messages: [{ role: 'system', tools: [WEATHER_TOOL] }, { role: 'user', content: 'hi' }] } });
+      const bad = await h({ m: 'POST', p: CHAT_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', tools: [WEATHER_TOOL] }, { role: 'user', content: 'hi' }] } });
+      return ok(good) && bad.status === 400
+        && String((bad.body as Body).error.message).includes("must use the 'system' role");
+    }),
+  ),
+  done('moonshot.chat.logprobs', 'chat', "Chat: logprobs/top_logprobs are real Moonshot surface — accepted (0..20), but top_logprobs without logprobs:true is a 400", 'api', 'niche', () =>
+    withRoot(async (h) => {
+      // Moonshot's OpenAPI DECLARES logprobs + top_logprobs (0..20) on chat — unlike Groq,
+      // which 400s them. The documented coupling: "logprobs must be set to true when
+      // top_logprobs is used".
+      const okLp = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ logprobs: true, top_logprobs: 5 }) });
+      const orphan = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ top_logprobs: 5 }) });
+      const range = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ logprobs: true, top_logprobs: 21 }) });
+      return ok(okLp) && orphan.status === 400 && range.status === 400
+        && String((orphan.body as Body).error.message).includes("'logprobs' must be set to true");
+    }),
+  ),
+  done('moonshot.chat.prompt_cache_key', 'chat', "Chat: prompt_cache_key is LOAD-BEARING (context caching) — with a key and a >256-token prompt the usage carries a cached_tokens split; without one the cache is cold (0)", 'api', 'niche', () =>
+    withRoot(async (h) => {
+      // Moonshot's context caching is keyed by prompt_cache_key: a request WITHOUT one has no
+      // cache namespace to hit, so cached_tokens stays 0 however long the prompt is. The long
+      // prompt (>256 tokens) crosses the documented threshold, so the split's presence/absence
+      // is attributable to the key alone — a parse-only acceptance (deleting it reddened
+      // nothing) was the round-two finding.
+      const long = 'please cache this prompt '.repeat(120);
+      const keyed = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ prompt_cache_key: 'cache-1', messages: [{ role: 'user', content: long }] }) });
+      const keyless = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ messages: [{ role: 'user', content: long }] }) });
+      const kb = keyed.body as Body;
+      const lb = keyless.body as Body;
+      return ok(keyed) && ok(keyless)
+        && typeof kb.usage?.cached_tokens === 'number' && kb.usage.cached_tokens > 0
+        && lb.usage?.cached_tokens === 0;
+    }),
+  ),
+  done('moonshot.chat.reasoning_effort', 'chat', "Chat: reasoning_effort is kimi-k3-only with the closed set ('low'|'high'|'max') — any other model is a 400", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const low = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ reasoning_effort: 'low' }) });
+      const badVal = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ reasoning_effort: 'medium' }) });
+      const wrongModel = await h({ m: 'POST', p: CHAT_PATH, b: K26({ reasoning_effort: 'low' }) });
+      return ok(low) && badVal.status === 400 && wrongModel.status === 400
+        && String((wrongModel.body as Body).error.message).includes('not a parameter of kimi-k2.6');
+    }),
+  ),
+  done('moonshot.chat.thinking', 'chat', "Chat: the thinking object is per-model — kimi-k2.6 accepts {type:'enabled'|'disabled', keep:'all'|null}; kimi-k2.7-code rejects type 'disabled'; kimi-k3 has no thinking parameter", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const k26off = await h({ m: 'POST', p: CHAT_PATH, b: K26({ thinking: { type: 'disabled' } }) });
+      const k26on = await h({ m: 'POST', p: CHAT_PATH, b: K26({ thinking: { type: 'enabled', keep: 'all' } }) });
+      const k27off = await h({ m: 'POST', p: CHAT_PATH, b: { model: 'kimi-k2.7-code', messages: [{ role: 'user', content: 'x' }], thinking: { type: 'disabled' } } });
+      const k3 = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ thinking: { type: 'enabled' } }) });
+      return ok(k26off) && ok(k26on) && k27off.status === 400 && k3.status === 400;
+    }),
+  ),
+  done('moonshot.chat.reasoning_content', 'chat', 'Chat: thinking mode surfaces reasoning_content on the assistant message; thinking disabled does not', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const k3 = await h({ m: 'POST', p: CHAT_PATH, b: CHAT() });
+      const k3Msg = (k3.body as Body).choices[0].message;
+      const off = await h({ m: 'POST', p: CHAT_PATH, b: K26({ thinking: { type: 'disabled' } }) });
+      const offMsg = (off.body as Body).choices[0].message;
+      return ok(k3) && ok(off)
+        && typeof k3Msg.reasoning_content === 'string' && k3Msg.reasoning_content.includes('[twin-stub:kimi-k3]')
+        && !('reasoning_content' in offMsg);
+    }),
+  ),
+  done('moonshot.chat.tool_calls', 'chat', 'Chat: tool_calls envelope (function name + schema-shaped JSON arguments), tool_choice none/named honored', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL] }) });
+      const c = (r.body as Body).choices[0];
+      if (!ok(r) || c.finish_reason !== 'tool_calls') return false;
+      const tc = c.message.tool_calls?.[0];
+      if (tc?.type !== 'function' || tc.function?.name !== 'get_weather') return false;
+      const args = JSON.parse(tc.function.arguments);
+      if (!args || typeof args !== 'object') return false;
+      const none = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL], tool_choice: 'none' }) });
+      const named = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL], tool_choice: { type: 'function', function: { name: 'get_weather' } } }) });
+      const namedTc = (named.body as Body).choices[0].message.tool_calls?.[0];
+      return none.status === 200 && (none.body as Body).choices[0].finish_reason === 'stop'
+        && ok(named) && namedTc?.function?.name === 'get_weather';
+    }),
+  ),
+  done('moonshot.chat.tool_name_validation', 'chat', "Chat: tool function names must match the documented regex ^[a-zA-Z_][a-zA-Z0-9-_]{0,127}$ (the leading-digit boundary is pinned; the 128-char boundary is enforced by the same regex)", 'api', 'niche', () =>
+    withRoot(async (h) => {
+      const bad = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [{ type: 'function', function: { name: '9bad name', parameters: {} } }] }) });
+      const good = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ tools: [WEATHER_TOOL] }) });
+      return bad.status === 400 && ok(good);
+    }),
+  ),
+  done('moonshot.chat.structured_outputs', 'chat', "Chat: response_format json_object / json_schema (name + schema required) yield JSON stub content; an unknown type is a 400", 'api', 'common', () =>
+    withRoot(async (h) => {
+      const jo = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'json_object' } }) });
+      const js = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'json_schema', json_schema: { name: 'out', schema: { type: 'object', properties: { city: { type: 'string' } } } } } }) });
+      const noSchema = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'json_schema', json_schema: { name: 'out' } } }) });
+      const unknown = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ response_format: { type: 'yaml' } }) });
+      const joText = (jo.body as Body).choices[0].message.content as string;
+      const jsText = (js.body as Body).choices[0].message.content as string;
+      return ok(jo) && ok(js) && noSchema.status === 400 && unknown.status === 400
+        && JSON.parse(joText) && typeof JSON.parse(jsText) === 'object' && (JSON.parse(jsText) as Body).city !== undefined;
+    }),
+  ),
+  done('moonshot.chat.tool_result_turn', 'chat', 'Chat: a role:"tool" result turn is accepted and counted into the prompt', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({
+        messages: [
+          { role: 'user', content: 'weather?' },
+          { role: 'assistant', content: null, tool_calls: [{ id: 'call_1', type: 'function', function: { name: 'get_weather', arguments: '{"city":"Paris"}' } }] },
+          { role: 'tool', tool_call_id: 'call_1', content: '{"temp":21}' },
+        ],
+      }) });
+      const bare = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ messages: [{ role: 'user', content: 'weather?' }] }) });
+      return ok(r) && (r.body as Body).usage.prompt_tokens > (bare.body as Body).usage.prompt_tokens;
+    }),
+  ),
+
+  // ── Streaming (the OpenAI-compatible grammar) ──────────────────────────────────────────
+  done('moonshot.streaming.chunk_sequence', 'streaming', 'Streaming: role delta → reasoning delta → content deltas → finish_reason chunk → [DONE]', 'api', 'core', () =>
+    withStream(CHAT(), (events) => {
+      if (events.length < 4 || !events[events.length - 1]!.done) return false;
+      const first = events[0]!.data as Body;
+      if (first?.choices?.[0]?.delta?.role !== 'assistant') return false;
+      if (first.object !== 'chat.completion.chunk') return false;
+      const deltas = events.filter((e) => !e.done && ((e.data as Body)?.choices?.[0]?.delta?.content));
+      if (!deltas.length) return false;
+      const finish = events.find((e) => !e.done && (e.data as Body)?.choices?.[0]?.finish_reason);
+      return !!finish && (finish.data as Body).choices[0].finish_reason === 'stop';
+    }),
+  ),
+  done('moonshot.streaming.usage_tail_chunk', 'streaming', "Streaming: Moonshot's usage tail — a FINAL chunk with empty choices[] carrying the whole usage object", 'api', 'core', () =>
+    withStream(CHAT(), (events) => {
+      const tail = events[events.length - 2]?.data as Body | undefined;
+      return !!tail && Array.isArray(tail.choices) && tail.choices.length === 0
+        && typeof tail.usage?.total_tokens === 'number';
+    }),
+  ),
+  done('moonshot.streaming.tool_call_deltas', 'streaming', 'Streaming: tool_calls stream as deltas — id+name frame then arguments frame', 'api', 'common', () =>
+    withStream(CHAT({ tools: [WEATHER_TOOL] }), (events) => {
+      const idFrame = events.find((e) => !e.done && (e.data as Body)?.choices?.[0]?.delta?.tool_calls?.[0]?.id);
+      const argsFrame = events.find((e) => !e.done && (e.data as Body)?.choices?.[0]?.delta?.tool_calls?.[0]?.function?.arguments);
+      return !!idFrame && !!argsFrame
+        && (idFrame.data as Body).choices[0].delta.tool_calls[0].function.name === 'get_weather';
+    }),
+  ),
+  done('moonshot.streaming.reasoning_delta', 'streaming', 'Streaming: reasoning_content streams as its own delta before content', 'api', 'common', () =>
+    withStream(CHAT(), (events) => {
+      const rIdx = events.findIndex((e) => !e.done && (e.data as Body)?.choices?.[0]?.delta?.reasoning_content);
+      const cIdx = events.findIndex((e) => !e.done && (e.data as Body)?.choices?.[0]?.delta?.content);
+      return rIdx >= 0 && cIdx > rIdx;
+    }),
+  ),
+
+  // ── Responses (/v1/responses — kimi-k3 only) ───────────────────────────────────────────
+  done('moonshot.responses.create', 'responses', 'Responses: create → the Responses envelope (object response, output items, usage with cached-token details); kimi-k2.x refused', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/responses`, b: { model: 'kimi-k3', input: 'hello twin' } });
+      const b = r.body as Body;
+      if (!ok(r) || b.object !== 'response' || b.status !== 'completed' || !Array.isArray(b.output)) return false;
+      if (!b.output.some((o: Body) => o.type === 'message') || !b.output.some((o: Body) => o.type === 'reasoning')) return false;
+      if (typeof b.usage?.total_tokens !== 'number' || typeof b.usage?.input_tokens_details?.cached_tokens !== 'number') return false;
+      const k26 = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/responses`, b: { model: 'kimi-k2.6', input: 'x' } });
+      return k26.status === 400 && String((k26.body as Body).error.message).includes('kimi-k3');
+    }),
+  ),
+  done('moonshot.responses.reasoning_effort', 'responses', "Responses: reasoning.effort with the closed set ('low'|'high'|'max')", 'api', 'niche', () =>
+    withRoot(async (h) => {
+      const low = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/responses`, b: { model: 'kimi-k3', input: 'x', reasoning: { effort: 'low' } } });
+      const bad = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/responses`, b: { model: 'kimi-k3', input: 'x', reasoning: { effort: 'medium' } } });
+      return ok(low) && bad.status === 400;
+    }),
+  ),
+  done('moonshot.responses.max_output_tokens', 'responses', 'Responses: max_output_tokens caps the OUTPUT — status incomplete with reason max_output_tokens, usage.output_tokens counts what was emitted (never above the cap), and a tight cap still emits a non-empty output with output_tokens > 0', 'api', 'niche', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/responses`, b: { model: 'kimi-k3', input: 'produce a long answer please', max_output_tokens: 4 } });
+      const b = r.body as Body;
+      if (!ok(r) || b.status !== 'incomplete' || b.incomplete_details?.reason !== 'max_output_tokens') return false;
+      // THE CAP IS APPLIED, not merely reported: usage counts the emitted (truncated) output —
+      // an output_tokens still above the cap contradicts the envelope's own claim.
+      if (!(typeof b.usage?.output_tokens === 'number' && b.usage.output_tokens <= 4 && b.usage.output_tokens > 0)) return false;
+      if (!Array.isArray(b.output) || b.output.length === 0) return false; // never an empty output
+      // output_tokens_details.reasoning_tokens counts the REASONING items only — reporting the
+      // whole output_tokens as reasoning (the round-three finding) claimed every text token was
+      // reasoning too.
+      const reasoning = (b.output as Body[]).filter((o) => o.type === 'reasoning')
+        .reduce((n, o) => n + (o.summary as Body[]).reduce((m, s) => m + Math.ceil(String(s.text ?? '').length / 4), 0), 0);
+      return b.usage.output_tokens_details?.reasoning_tokens === reasoning;
+    }),
+  ),
+  done('moonshot.responses.streaming', 'responses', 'Responses streaming: response.created → output_item.added/done per item → response.completed, sequence_number from 0', 'api', 'common', () =>
+    withNamedStream(`${MOONSHOT_API_PREFIX}/responses`, { model: 'kimi-k3', input: 'x' }, (events) => {
+      const names = events.filter((e) => !e.done).map((e) => e.event ?? '');
+      if (names[0] !== 'response.created' || !names.includes('response.in_progress')) return false;
+      if (!names.includes('response.output_item.added') || !names.includes('response.output_item.done')) return false;
+      if (names[names.length - 1] !== 'response.completed') return false;
+      const seqs = events.filter((e) => !e.done).map((e) => (e.data as Body)?.sequence_number);
+      return seqs[0] === 0 && seqs.every((s, i) => s === i);
+    }),
+  ),
+
+  // ── Anthropic-compatible Messages (/anthropic/v1/messages — kimi-k3 only) ──────────────
+  done('moonshot.messages.create', 'messages', 'Messages: create → the Anthropic-compatible envelope (type message, content blocks, stop_reason, usage) with a thinking block first; max_tokens TRUNCATES the emitted content — usage counts it, the message keeps at least one block with output_tokens > 0', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'hello twin' }], max_tokens: 500 } });
+      const b = r.body as Body;
+      if (!ok(r) || b.type !== 'message' || b.role !== 'assistant' || !Array.isArray(b.content)) return false;
+      if (b.content[0]?.type !== 'thinking' || !b.content.some((c: Body) => c.type === 'text')) return false;
+      if (b.stop_reason !== 'end_turn' || typeof b.usage?.input_tokens !== 'number') return false;
+      // max_tokens REQUIRED (Anthropic grammar).
+      const noMax = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }] } });
+      if (noMax.status !== 400) return false;
+      // THE CAP IS APPLIED, not merely reported: with a tight cap the emitted content shrinks to
+      // fit, usage.output_tokens counts what was emitted, and the message is NEVER empty —
+      // Anthropic never returns a zero-block assistant message, so output_tokens 0 / content []
+      // at a small cap (the round-three finding) is a lie about what the model produced. Thinking
+      // counts toward the cap (Moonshot: output_tokens "including reasoning tokens"), so the
+      // tightest caps truncate the leading thinking block — text is asserted present wherever the
+      // budget actually reaches the text block.
+      for (const cap of [200, 30, 2]) {
+        const capped = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'produce a long answer please' }], max_tokens: cap } });
+        const cb = capped.body as Body;
+        if (!ok(capped)) return false;
+        // The stub's whole answer fits in 200 — only the tighter caps truncate.
+        if (cb.stop_reason !== (cap >= 200 ? 'end_turn' : 'max_tokens')) return false;
+        if (typeof cb.usage?.output_tokens !== 'number' || cb.usage.output_tokens <= 0 || cb.usage.output_tokens > cap) return false;
+        if (!Array.isArray(cb.content) || cb.content.length === 0) return false;
+        const text = (cb.content as Body[]).find((c: Body) => c.type === 'text')?.text ?? '';
+        if (cap === 30 && !text) return false; // the budget reaches the text block — it must be there
+      }
+      // Boundary walk (round-four review): a cap that lands exactly on a block boundary, or on a
+      // tool_use, must ship a PREFIX — never the whole next block under stop_reason max_tokens.
+      // Every cap 20..26 emits <= cap tokens and reports exactly what it emitted.
+      const est = (t: string) => Math.max(1, Math.ceil(t.length / 4));
+      for (const cap of [20, 21, 22, 23, 24, 25, 26]) {
+        const r = await h({ m: 'POST', p: '/anthropic/v1/messages', b: { model: 'kimi-k3', max_tokens: cap, messages: [{ role: 'user', content: 'weather?' }] } });
+        const blocks = ((r.body as Body).content ?? []) as Array<{ type: string; text?: string; thinking?: string }>;
+        const emitted = blocks.reduce((n, b) => n + est(b.text ?? b.thinking ?? ''), 0);
+        if (r.status !== 200 || blocks.length === 0 || emitted > cap || (r.body as Body).usage?.output_tokens !== emitted) return false;
+        if ((r.body as Body).stop_reason === 'max_tokens' && emitted > cap) return false;
+      }
+      const tooled = await h({ m: 'POST', p: '/anthropic/v1/messages', b: { model: 'kimi-k3', max_tokens: 25, messages: [{ role: 'user', content: 'weather?' }], tools: [{ name: 'get_weather', description: 'w', input_schema: { type: 'object', properties: {} } }] } });
+      const tb = ((tooled.body as Body).content ?? []) as Array<{ type: string }>;
+      if ((tooled.body as Body).stop_reason === 'max_tokens' && tb.some((b) => b.type === 'tool_use')) return false;
+      return true;
+    }),
+  ),
+  done('moonshot.messages.tool_use', 'messages', 'Messages: tools + tool_choice are REAL surface — any/auto yield a tool_use block (toolu_ id), a named {type:tool} call is honored, none suppresses, a follow-up tool_result turn answers end_turn text, and tool_choice without tools / a bad name / a named tool missing from tools are 400s', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const WEATHER = { type: 'custom', name: 'get_weather', input_schema: { type: 'object', properties: { city: { type: 'string' } } } };
+      const any = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'weather?' }], max_tokens: 500, tools: [WEATHER], tool_choice: { type: 'any' } } });
+      const ab = any.body as Body;
+      const toolUse = (ab.content as Body[])?.find((c: Body) => c.type === 'tool_use');
+      if (!ok(any) || ab.stop_reason !== 'tool_use' || !toolUse) return false;
+      if (toolUse.name !== 'get_weather' || typeof toolUse.id !== 'string' || typeof toolUse.input !== 'object') return false;
+      if (!String(toolUse.id).startsWith('toolu_')) return false; // Anthropic's id grammar
+      // A NAMED tool_choice calls THAT tool (the SDK's ToolChoice union; the round-three 400).
+      const named = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'weather?' }], max_tokens: 500, tools: [WEATHER], tool_choice: { type: 'tool', name: 'get_weather' } } });
+      const namedUse = ((named.body as Body).content as Body[])?.find((c: Body) => c.type === 'tool_use');
+      if (!ok(named) || namedUse?.name !== 'get_weather') return false;
+      const none = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 500, tools: [WEATHER], tool_choice: { type: 'none' } } });
+      const nb = none.body as Body;
+      if (!ok(none) || nb.stop_reason !== 'end_turn' || (nb.content as Body[])?.some((c: Body) => c.type === 'tool_use')) return false;
+      // The AGENT LOOP closes: after the tool_result comes back, the next turn answers TEXT with
+      // end_turn — deciding tool_use from tools.length alone made the loop emit tool_use forever.
+      const followUp = await h({ m: 'POST', p: MESSAGES_PATH, b: {
+        model: 'kimi-k3', max_tokens: 500, tools: [WEATHER],
+        messages: [
+          { role: 'user', content: 'weather?' },
+          { role: 'assistant', content: [{ type: 'tool_use', id: String(toolUse.id), name: 'get_weather', input: { city: 'Oslo' } }] },
+          { role: 'user', content: [{ type: 'tool_result', tool_use_id: String(toolUse.id), content: '18°C, clear' }] },
+        ],
+      } });
+      const fb = followUp.body as Body;
+      if (!ok(followUp) || fb.stop_reason !== 'end_turn') return false;
+      if ((fb.content as Body[])?.some((c: Body) => c.type === 'tool_use')) return false;
+      if (!((fb.content as Body[])?.some((c: Body) => c.type === 'text'))) return false;
+      const noTools = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 500, tool_choice: { type: 'any' } } });
+      const badName = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 500, tools: [{ type: 'custom', name: '9bad name', input_schema: {} }] } });
+      // A named choice naming a tool that is NOT in tools is refused (the sibling's rule).
+      const ghost = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 500, tools: [WEATHER], tool_choice: { type: 'tool', name: 'not_offered' } } });
+      return noTools.status === 400 && badName.status === 400 && ghost.status === 400
+        && (noTools.body as Body).type === 'error' && (badName.body as Body).type === 'error' && (ghost.body as Body).type === 'error';
+    }),
+  ),
+  done('moonshot.messages.kimi_k3_only', 'messages', 'Messages: kimi-k2.x refused with the Messages error envelope', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k2.6', messages: [{ role: 'user', content: 'x' }], max_tokens: 10 } });
+      const b = r.body as Body;
+      return r.status === 400 && b.type === 'error' && typeof b.error?.type === 'string' && typeof b.error?.message === 'string';
+    }),
+  ),
+  done('moonshot.messages.system_and_stop', 'messages', 'Messages: top-level system prompt, stop_sequences (≤5, ≤32 bytes) with stop_sequence reported', 'api', 'niche', () =>
+    withRoot(async (h) => {
+      const sys = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', system: 'Be terse.', messages: [{ role: 'user', content: 'hi' }], max_tokens: 500 } });
+      const stop = await h({ 'm': 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'hi' }], max_tokens: 500, stop_sequences: ['Echoing'] } });
+      const tooMany = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 10, stop_sequences: ['1', '2', '3', '4', '5', '6'] } });
+      const b = stop.body as Body;
+      return ok(sys) && ok(stop) && tooMany.status === 400
+        && b.stop_sequence === 'Echoing' && !(b.content.find((c: Body) => c.type === 'text')?.text ?? '').includes('Echoing');
+    }),
+  ),
+  done('moonshot.messages.error_envelope', 'messages', 'Messages errors — including the CROSS-CUTTING ones (401 auth, 429 rate limit, 503 outage, 405 read-only) — answer the Anthropic-compatible envelope {type:error, error:{type,message}} with Anthropic error types, never the /v1 shape', 'api', 'common', () =>
+    withRootH(async (h) => {
+      // The validation 400…
+      const noMax = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }] } });
+      if (noMax.status !== 400) return false;
+      const isAnthropicError = (r: MoonshotResponseEnvelope): boolean => {
+        const b = r.body as Body;
+        return b?.type === 'error' && typeof b.error?.type === 'string' && typeof b.error?.message === 'string'
+          && !('code' in (b.error ?? {}));
+      };
+      if (!isAnthropicError(noMax) || (noMax.body as Body).error?.type !== 'invalid_request_error') return false;
+      // …and every cross-cutting failure BEFORE routing: auth (x-api-key, the SDK's own header),
+      // the two deterministic fault triggers, and the read-only 405 — each of which used to leak
+      // the /v1 envelope regardless of prefix (the round-two finding).
+      const auth = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 10 }, headers: { 'x-api-key': '' } });
+      if (auth.status !== 401 || !isAnthropicError(auth) || (auth.body as Body).error?.type !== 'authentication_error') return false;
+      const rate = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 10 }, headers: { 'x-api-key': 'sk-twin', 'x-twin-force-rate-limit': '1' } });
+      if (rate.status !== 429 || !isAnthropicError(rate) || (rate.body as Body).error?.type !== 'rate_limit_error') return false;
+      const out = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 10 }, headers: { 'x-api-key': 'sk-twin', 'x-twin-force-server-unavailable': '1' } });
+      if (out.status !== 503 || !isAnthropicError(out) || (out.body as Body).error?.type !== 'overloaded_error') return false;
+      const root = mkdtempSync(join(tmpdir(), 'moonshot-cap-ro-'));
+      try {
+        const ro = await handleMoonshotTwinRequest({ method: 'POST', path: MESSAGES_PATH, body: JSON.stringify({ model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 10 }), root, readOnly: true, headers: { 'x-api-key': 'sk-twin' } });
+        if (ro.status !== 405 || !isAnthropicError(ro)) return false;
+      } finally {
+        rmSync(root, { recursive: true, force: true });
+      }
+      return true;
+    }),
+  ),
+  done('moonshot.messages.streaming', 'messages', 'Messages streaming: message_start carries the EMPTY message (content [], stop_reason null, output_tokens 0) → ping → one block at a time → message_delta (stop_reason + final usage) → message_stop (no [DONE])', 'api', 'common', () =>
+    withNamedStream(MESSAGES_PATH, { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 200, stream: true }, (events) => {
+      const names = events.filter((e) => !e.done).map((e) => e.event ?? '');
+      if (names[0] !== 'message_start' || names[names.length - 1] !== 'message_stop') return false;
+      if (!names.includes('content_block_delta') || !names.includes('content_block_stop')) return false;
+      if (!names.includes('message_delta') || !names.includes('ping')) return false;
+      const thinkingDelta = events.find((e) => (e.data as Body)?.delta?.type === 'thinking_delta');
+      if (!thinkingDelta) return false;
+      // THE GRAMMAR: message_start holds an EMPTY message — a complete final message there made
+      // the SDK's own accumulator double every block (the round-three BLOCKER).
+      const start = events.find((e) => e.event === 'message_start')?.data as Body;
+      const msg = start?.message as Body;
+      if (!Array.isArray(msg?.content) || msg.content.length !== 0) return false;
+      if (msg.stop_reason !== null || msg.usage?.output_tokens !== 0) return false;
+      // message_delta carries the final stop_reason and the final output_tokens.
+      const delta = events.find((e) => e.event === 'message_delta')?.data as Body;
+      if (delta?.delta?.stop_reason !== 'end_turn' || (delta?.usage?.output_tokens ?? 0) <= 0) return false;
+      // Every content_block_start index matches a distinct block; no index repeats after its stop.
+      const starts = events.filter((e) => e.event === 'content_block_start').map((e) => (e.data as Body).index);
+      if (new Set(starts).size !== starts.length) return false;
+      return names[names.length - 2] === 'message_delta';
+    }),
+  ),
+
+  // ── Models ─────────────────────────────────────────────────────────────────────────────
+  done('moonshot.models.list', 'models', 'Models: list → the static catalog (kimi-k3, kimi-k2.7-code, kimi-k2.7-code-highspeed, kimi-k2.6)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/models` });
+      const data = (r.body as Body).data as Body[];
+      const ids = data.map((m) => m.id).sort();
+      return ok(r) && (r.body as Body).object === 'list'
+        && JSON.stringify(ids) === JSON.stringify(['kimi-k2.6', 'kimi-k2.7-code', 'kimi-k2.7-code-highspeed', 'kimi-k3']);
+    }),
+  ),
+  done('moonshot.models.retired_absent', 'models', 'Models: retired ids (moonshot-v1-*, kimi-latest, kimi-k2) are NOT served — a stale client must fail here like it fails at the vendor', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/models` });
+      const ids = ((r.body as Body).data as Body[]).map((m) => m.id);
+      if (ids.some((i) => i.startsWith('moonshot-v1') || i === 'kimi-latest' || i.startsWith('kimi-k2-'))) return false;
+      const old = await h({ m: 'POST', p: CHAT_PATH, b: CHAT({ model: 'moonshot-v1-8k' }) });
+      return old.status === 400;
+    }),
+  ),
+  todo('moonshot.models.retrieve', 'models', "Models: retrieve by id — Moonshot's own OpenAPI declares NO /v1/models/{model} operation (the served 200 was a 200 for an unmodeled route, the round-two finding); the twin now 404s like the vendor, and this entry records the gap until the vendor publishes the operation", 'api', 'core'),
+
+  // ── Files (stateful) ───────────────────────────────────────────────────────────────────
+  done('moonshot.files.create', 'files', 'Files: create → a stateful File object (purpose closed set, status ready)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/files`, b: { purpose: 'batch', filename: 'in.jsonl', content: '{"custom_id":"a"}' } });
+      const b = r.body as Body;
+      if (!ok(r) || b.object !== 'file' || b.purpose !== 'batch' || b.status !== 'ready' || typeof b.bytes !== 'number') return false;
+      if (!String(b.id).startsWith('file_twin_')) return false;
+      const badPurpose = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/files`, b: { purpose: 'fine-tune', filename: 'x', content: 'x' } });
+      return badPurpose.status === 400 && String((badPurpose.body as Body).error.message).includes('purpose');
+    }),
+  ),
+  done('moonshot.files.list_retrieve', 'files', 'Files: list + retrieve round-trip; unknown id 404', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const f = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/files`, b: { purpose: 'file-extract', filename: 'doc.txt', content: 'hello' } });
+      const list = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/files` });
+      const one = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/files/${id(f)}` });
+      const miss = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/files/file_does_not_exist` });
+      return ok(f) && ok(list) && (list.body as Body).object === 'list'
+        && ((list.body as Body).data as Body[]).some((x) => x.id === id(f))
+        && ok(one) && (one.body as Body).filename === 'doc.txt' && miss.status === 404;
+    }),
+  ),
+  done('moonshot.files.content', 'files', 'Files: content returns the stored bytes verbatim', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const f = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/files`, b: { purpose: 'batch', filename: 'in.jsonl', content: '{"custom_id":"a"}\n{"custom_id":"b"}' } });
+      const c = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/files/${id(f)}/content` });
+      return ok(c) && c.body === '{"custom_id":"a"}\n{"custom_id":"b"}';
+    }),
+  ),
+  done('moonshot.files.delete_id_ratchets', 'files', 'Files: delete → {deleted:true}; the id is never re-minted after delete (dirty-state proof)', 'api', 'common', () =>
+    withRoot(async (h, root) => {
+      const f = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/files`, b: { purpose: 'batch', filename: 'one.jsonl', content: 'x' } });
+      const del = await h({ m: 'DELETE', p: `${MOONSHOT_API_PREFIX}/files/${id(f)}` });
+      if (!ok(del) || (del.body as Body).deleted !== true) return false;
+      // The tombstoned row keeps its id: a recreate must mint the NEXT number, never this one.
+      const f2 = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/files`, b: { purpose: 'batch', filename: 'two.jsonl', content: 'x' } });
+      const after = projectResources('moonshot', root).filter((r) => r.type === 'file');
+      return ok(f2) && id(f2) !== id(f) && after.filter((r) => r.id === id(f)).length === 1;
+    }),
+  ),
+  done('moonshot.files.pulled_content_refused', 'files', 'Files: a PULLED file (metadata only — the vendor list endpoint returns no content) answers 501 on /content instead of a fake empty 200', 'api', 'common', () =>
+    withConnectorRoot('moonshot.files.pulled_content_refused', async (root) => {
+      const { execute } = fakeExecute((m, p) => {
+        if (p === '/v1/files') return { data: [{ id: 'file_real_1', object: 'file', bytes: 3, created_at: 1, filename: 'real.jsonl', purpose: 'batch', status: 'ready' }] };
+        return { data: [] };
+      });
+      const pulled = await syncMoonshotFromReal(execute, { root, occurredAt: '2026-06-15T00:00:00Z' });
+      if (pulled.observed < 1) return false;
+      const c = await handleMoonshotTwinRequest({ method: 'GET', path: `${MOONSHOT_API_PREFIX}/files/file_real_1/content`, root });
+      return c.status === 501 && errType(c) === 'server_error' && String((c.body as Body).error.message).includes('holds no content');
+    }),
+  ),
+
+  // ── Batches (stateful) ─────────────────────────────────────────────────────────────────
+  done('moonshot.batches.create', 'batches', 'Batches: create over a batch-purpose file → a stateful Batch (endpoint closed set, completion_window 12h–7d, expires_at derived)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const bid = await seedBatch(h);
+      if (!bid) return false;
+      const b = (await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/batches/${bid}` })).body as Body;
+      if (b.status !== 'validating' || b.endpoint !== '/v1/chat/completions') return false;
+      if (typeof b.expires_at !== 'number' || b.expires_at <= b.created_at) return false;
+      // The closed sets: endpoint and window.
+      const badEndpoint = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/batches`, b: { input_file_id: 'file_twin_1', endpoint: '/v1/embeddings', completion_window: '24h' } });
+      const badWindow = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/batches`, b: { input_file_id: 'file_twin_1', endpoint: '/v1/chat/completions', completion_window: '6h' } });
+      return badEndpoint.status === 400 && badWindow.status === 400;
+    }),
+  ),
+  done('moonshot.batches.file_validation', 'batches', 'Batches: input_file_id must reference an existing, batch-purpose file', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const missing = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/batches`, b: { input_file_id: 'file_nope', endpoint: '/v1/chat/completions', completion_window: '24h' } });
+      const f = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/files`, b: { purpose: 'file-extract', filename: 'doc.txt', content: 'x' } });
+      const wrongPurpose = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/batches`, b: { input_file_id: id(f), endpoint: '/v1/chat/completions', completion_window: '24h' } });
+      return missing.status === 404 && wrongPurpose.status === 400
+        && String((wrongPurpose.body as Body).error.message).includes("purpose 'batch'");
+    }),
+  ),
+  done('moonshot.batches.list_retrieve_cancel', 'batches', 'Batches: list, retrieve, cancel (cancelling, cancelling_at set, double cancel refused)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const bid = await seedBatch(h);
+      if (!bid) return false;
+      const list = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/batches` });
+      const cancel = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/batches/${bid}/cancel` });
+      const c = cancel.body as Body;
+      const again = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/batches/${bid}/cancel` });
+      return ok(list) && ((list.body as Body).data as Body[]).some((x) => x.id === bid)
+        && ok(cancel) && c.status === 'cancelling' && typeof c.cancelling_at === 'number'
+        && again.status === 400 && String((again.body as Body).error.message).includes('cancelling');
+    }),
+  ),
+
+  // ── Balance (Moonshot's own envelope) ──────────────────────────────────────────────────
+  done('moonshot.balance.envelope', 'balance', 'Balance: GET /v1/users/me/balance answers Moonshot\'s OWN envelope {code,data:{available,voucher,cash},scode,status} — not the OpenAI envelope', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/users/me/balance` });
+      const b = r.body as Body;
+      return ok(r) && b.code === 0 && b.scode === '0x0' && b.status === true
+        && typeof b.data?.available_balance === 'number' && typeof b.data?.voucher_balance === 'number' && typeof b.data?.cash_balance === 'number';
+    }),
+  ),
+
+  // ── Stateless helpers ──────────────────────────────────────────────────────────────────
+  done('moonshot.tokens.estimate', 'tokens', 'Token counting: POST /v1/tokenizers/estimate-token-count → {data:{total_tokens}}, model validated, empty content refused', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tokenizers/estimate-token-count`, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'hello world, estimate me' }] } });
+      const badModel = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tokenizers/estimate-token-count`, b: { model: 'nope', messages: [{ role: 'user', content: 'x' }] } });
+      const empty = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tokenizers/estimate-token-count`, b: { model: 'kimi-k3', messages: [{ role: 'user', content: '' }] } });
+      const b = r.body as Body;
+      return ok(r) && typeof b.data?.total_tokens === 'number' && b.data.total_tokens > 0
+        && badModel.status === 400 && empty.status === 400;
+    }),
+  ),
+  done('moonshot.tokens.matches_chat_usage', 'tokens', 'Token counting: the estimate equals the chat endpoint prompt_tokens for the same input (one tokenizer, two doors)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const messages = [{ role: 'system', content: 'You are terse.' }, { role: 'user', content: 'count these tokens precisely' }];
+      const est = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tokenizers/estimate-token-count`, b: { model: 'kimi-k3', messages } });
+      const chat = await h({ m: 'POST', p: CHAT_PATH, b: { model: 'kimi-k3', messages } });
+      return ok(est) && ok(chat)
+        && (est.body as Body).data.total_tokens === (chat.body as Body).usage.prompt_tokens;
+    }),
+  ),
+  done('moonshot.signatures.verify', 'signatures', 'Signature verify: a tuple recomputing to the twin\'s own signature is valid:true; a wrong/foreign-prefix signature is valid:false; missing fields 400', 'api', 'niche', () =>
+    withRootH(async (h) => {
+      const nonce = 'nonce-abc', ts = 1_786_338_000_123, model = 'kimi-k2.7-code';
+      const sig = messagesSignature(nonce, ts, model);
+      const good = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/signatures/verify`, b: { nonce, timestamp: ts, model, signature: sig } });
+      const wrong = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/signatures/verify`, b: { nonce, timestamp: ts, model, signature: 'reqsigv1_tampered' } });
+      const foreign = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/signatures/verify`, b: { nonce, timestamp: ts, model, signature: 'sig-no-prefix' } });
+      const missing = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/signatures/verify`, b: { nonce, timestamp: ts, model } });
+      return ok(good) && (good.body as Body).valid === true
+        && ok(wrong) && (wrong.body as Body).valid === false
+        && ok(foreign) && (foreign.body as Body).valid === false
+        && missing.status === 400;
+    }),
+  ),
+  done('moonshot.signatures.round_trip', 'signatures', 'Signature round trip: a STREAMED model call carrying X-Msh-Request-Nonce emits Msh-Request-* headers whose signature verifies valid:true; a nonce-less call emits none', 'api', 'niche', () =>
+    withRootH(async (h) => {
+      // The composition the two halves never proved together (§9 round two, F8): the headers
+      // the SERVER-side contract mints (via messagesSignature over the request's nonce and
+      // worldNow) fed back through POST /v1/signatures/verify. Driven through the handler's
+      // SSE door so the same code path the server exercises runs here.
+      const events: unknown[] = [];
+      const signed = await handleMoonshotTwinRequest({
+        method: 'POST', path: CHAT_PATH, body: JSON.stringify(CHAT({ stream: true })),
+        headers: { authorization: 'Bearer sk-twin', 'x-msh-request-nonce': 'rt-nonce-1' },
+        sseSink: (e) => events.push(e),
+      });
+      const ts = signed.headers?.['msh-request-timestamp'];
+      const sig = signed.headers?.['msh-request-signature'];
+      if (!ts || !sig) return false;
+      const check = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/signatures/verify`, b: { nonce: 'rt-nonce-1', timestamp: Number(ts), model: CHAT().model, signature: sig } });
+      if (!ok(check) || (check.body as Body).valid !== true) return false;
+      // A nonce-less streamed call proceeds UNSIGNED (the round-one fix).
+      events.length = 0;
+      const unsigned = await handleMoonshotTwinRequest({
+        method: 'POST', path: CHAT_PATH, body: JSON.stringify(CHAT({ stream: true })),
+        headers: { authorization: 'Bearer sk-twin' },
+        sseSink: (e) => events.push(e),
+      });
+      return events.length > 0 && unsigned.headers?.['msh-request-signature'] === undefined;
+    }),
+  ),
+  done('moonshot.tools.search', 'tools', 'Web search: POST /v1/tools/search → labeled deterministic results, limit 1..20 enforced; include_content:true SERVES page text and the default leaves text empty', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/search`, b: { text_query: 'kimi api limits', limit: 3 } });
+      const badLimit = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/search`, b: { text_query: 'x', limit: 21 } });
+      const noQuery = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/search`, b: {} });
+      const withContent = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/search`, b: { text_query: 'kimi api limits', limit: 2, include_content: true } });
+      const results = (r.body as Body).search_results as Body[];
+      const contentResults = (withContent.body as Body).search_results as Body[];
+      return ok(r) && results.length === 3 && typeof results[0]?.url === 'string' && typeof results[0]?.snippet === 'string'
+        && JSON.stringify(results[0]).includes('[twin-stub]')
+        && results.every((x) => x.text === '')
+        && ok(withContent) && contentResults.length === 2 && contentResults.every((x) => typeof x.text === 'string' && x.text.includes('[twin-stub]'))
+        && badLimit.status === 400 && noQuery.status === 400;
+    }),
+  ),
+  done('moonshot.tools.search_pro', 'tools', 'search_pro: sites (≤5, no whitespace/parens) + time_window (YYYY[-MM[-DD]]) validated; results carry chunks (pinned on the first result)', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/search_pro`, b: { text_query: 'kimi', sites: ['platform.kimi.ai'], time_window: { start: '2026-01', end: '2026-09-16' } } });
+      const badSite = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/search_pro`, b: { text_query: 'x', sites: ['a b'] } });
+      const badWindow = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/search_pro`, b: { text_query: 'x', time_window: { start: 'Jan 2026' } } });
+      const results = (r.body as Body).search_results as Body[];
+      return ok(r) && results.length === 5 && Array.isArray(results[0]?.chunks)
+        && badSite.status === 400 && badWindow.status === 400;
+    }),
+  ),
+  done('moonshot.tools.fetch', 'tools', 'fetch: POST /v1/tools/fetch → labeled deterministic markdown for an http(s) URL; a non-http URL is a 400', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/fetch`, b: { url: 'https://platform.kimi.ai/docs' } });
+      const bad = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/tools/fetch`, b: { url: 'ftp://example.test/x' } });
+      return ok(r) && (r.body as Body).url === 'https://platform.kimi.ai/docs'
+        && typeof (r.body as Body).markdown === 'string' && (r.body as Body).markdown.includes('[twin-stub]')
+        && bad.status === 400;
+    }),
+  ),
+
+  // ── Auth (modeled 401s) ────────────────────────────────────────────────────────────────
+  done('moonshot.auth.missing_key', 'auth', 'Auth: a request carrying headers but no credential → 401 invalid_authentication_error', 'api', 'core', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: {} });
+      return r.status === 401 && errType(r) === 'invalid_authentication_error';
+    }),
+  ),
+  done('moonshot.auth.invalid_key', 'auth', 'Auth: the reserved invalid sentinel → 401 incorrect_api_key_error', 'api', 'core', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: 'Bearer sk_invalid' } });
+      return r.status === 401 && errType(r) === 'incorrect_api_key_error';
+    }),
+  ),
+
+  // ── Errors (the fidelity surface) ──────────────────────────────────────────────────────
+  done('moonshot.errors.envelope_keys', 'errors', 'Errors: every /v1 error carries message+type and ONLY keys Moonshot\'s ErrorResponse declares (message, type, code)', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const DECLARED = new Set(['message', 'type', 'code']);
+      const cases = [
+        await h({ m: 'POST', p: CHAT_PATH, b: { messages: [] } }),
+        await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/models/nope` }),
+        await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/files/file_nope` }),
+        await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/batches`, b: { input_file_id: 'file_nope', endpoint: '/v1/chat/completions', completion_window: '24h' } }),
+      ];
+      return cases.every((r) => {
+        if (r.status < 400) return false;
+        const e = (r.body as Body)?.error;
+        if (typeof e?.message !== 'string' || !e.message || typeof e?.type !== 'string') return false;
+        return Object.keys(e).every((k) => DECLARED.has(k));
+      });
+    }),
+  ),
+  done('moonshot.errors.unknown_route', 'errors', 'Errors: an unmodeled route answers 404 with the vendor message shape — resource_not_found_error under /v1, not_found_error in the Anthropic envelope under /anthropic', 'api', 'core', () =>
+    withRoot(async (h) => {
+      const r = await h({ m: 'GET', p: `${MOONSHOT_API_PREFIX}/fine_tuning/jobs` });
+      const post = await h({ m: 'POST', p: `${MOONSHOT_API_PREFIX}/embeddings`, b: { input: 'x', model: 'kimi-k3' } });
+      if (!(r.status === 404 && errType(r) === 'resource_not_found_error'
+        && String((r.body as Body).error.message).includes('Unknown request URL')
+        && post.status === 404)) return false;
+      // The /anthropic unknown route answers the ANTHROPIC envelope (the round-two router fix
+      // had no verify): a not_found_error inside {type:error, error:{…}}, never the /v1 shape.
+      const anth = await h({ m: 'POST', p: `${MESSAGES_PREFIX}/nope`, b: { model: 'kimi-k3' } });
+      const ab = anth.body as Body;
+      return anth.status === 404 && ab.type === 'error' && ab.error?.type === 'not_found_error'
+        && typeof ab.error?.message === 'string' && !('code' in (ab.error ?? {}));
+    }),
+  ),
+  done('moonshot.errors.rate_limit_429', 'errors', 'Errors: the deterministic rate-limit trigger answers 429 rate_limit_reached_error with the documented X-RateLimit-* header family (the tier table names those three; retry-after is the twin\'s own addition) — and the /anthropic 429 carries the SAME headers in the Anthropic envelope', 'api', 'core', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: 'Bearer sk-twin', 'x-twin-force-rate-limit': '1' } });
+      if (r.status !== 429 || errType(r) !== 'rate_limit_reached_error') return false;
+      const hdrs = r.headers ?? {};
+      if (!(hdrs['retry-after'] === '20' && hdrs['x-ratelimit-limit'] === '3'
+        && hdrs['x-ratelimit-remaining'] === '0' && typeof hdrs['x-ratelimit-reset'] === 'string')) return false;
+      // The re-enveloped /anthropic 429 keeps the headers (dropping them left the documented
+      // SDK blind to the back-off — the round-three finding).
+      const anth = await h({ m: 'POST', p: MESSAGES_PATH, b: { model: 'kimi-k3', messages: [{ role: 'user', content: 'x' }], max_tokens: 10 }, headers: { 'x-api-key': 'sk-twin', 'x-twin-force-rate-limit': '1' } });
+      const ahdrs = anth.headers ?? {};
+      return anth.status === 429 && (anth.body as Body).error?.type === 'rate_limit_error'
+        && ahdrs['retry-after'] === '20' && ahdrs['x-ratelimit-limit'] === '3';
+    }),
+  ),
+  done('moonshot.errors.server_unavailable_503', 'errors', 'Errors: the deterministic outage trigger answers 503 server_unavailable (Moonshot\'s documented type)', 'api', 'common', () =>
+    withRootH(async (h) => {
+      const r = await h({ m: 'POST', p: CHAT_PATH, b: CHAT(), headers: { authorization: 'Bearer sk-twin', 'x-twin-force-server-unavailable': '1' } });
+      return r.status === 503 && errType(r) === 'server_unavailable';
+    }),
+  ),
+  done('moonshot.errors.read_only_405', 'errors', 'Errors: a read-only twin refuses every mutation with a vendor-shaped 405', 'api', 'common', () =>
+    withRoot(async (h) => {
+      const root = mkdtempSync(join(tmpdir(), 'moonshot-cap-ro-'));
+      try {
+        const r = await handleMoonshotTwinRequest({ method: 'POST', path: CHAT_PATH, body: JSON.stringify(CHAT()), root, readOnly: true });
+        return r.status === 405 && errType(r) === 'invalid_request_error';
+      } finally {
+        rmSync(root, { recursive: true, force: true });
+      }
+    }),
+  ),
+
+  // ── Rate budget (the fail-closed client-side guard) ────────────────────────────────────
+  done('moonshot.budget.declaration', 'rate_limits', 'Rate budget: the declaration is armed at module load, prices inference/web-search above reads, and nothing is free', 'connector', 'common', () =>
+    verifyBoundary('moonshot.budget.declaration', () => {
+      // The LITERALS, not the module's own constants: comparing moonshotCallWeight against
+      // MOONSHOT_CALL_WEIGHTS.inference was a tautology (lowering the constant left it green —
+      // the round-two finding). The rule is the grounding, so the rule is asserted: inference
+      // and web-search cost 6, reads cost 2, and inference is strictly ABOVE a read.
+      if (moonshotCallWeight('POST', CHAT_PATH) !== 6) return false;
+      if (moonshotCallWeight('POST', `${MOONSHOT_API_PREFIX}/responses`) !== 6) return false;
+      if (moonshotCallWeight('POST', MESSAGES_PATH) !== 6) return false;
+      if (moonshotCallWeight('POST', `${MOONSHOT_API_PREFIX}/tools/search_pro`) !== 6) return false;
+      if (moonshotCallWeight('GET', `${MOONSHOT_API_PREFIX}/models`) !== 2) return false;
+      if (moonshotCallWeight('POST', `${MOONSHOT_API_PREFIX}/tokenizers/estimate-token-count`) !== 2) return false;
+      if (!(MOONSHOT_CALL_WEIGHTS.inference > MOONSHOT_CALL_WEIGHTS.other)) return false;
+      return MOONSHOT_BUDGET_CEILING > 0;
+    }),
+    // MUTATION-SWEEP NOTE: this cell reads hollow BY METHOD, not by fact — its lines live in
+    // moonshot-budget.ts, outside the sweep's default file set. Hand-walked (round-four review):
+    // deleting the `^POST /anthropic/v1/messages$` rule reddens this cell by name; changing the
+    // inference weight 6 → 3 reddens this cell by name; the module loads either way. The ceiling
+    // VALUE (60) is pinned only as > 0 here and by the arithmetic in
+    // moonshot.budget.throws_at_ceiling; a 10× ceiling change leaves both green — a known weak
+    // pin, not a hollow one.
+  ),
+  done('moonshot.budget.throws_at_ceiling', 'rate_limits', 'Rate budget: charging up to the ceiling is admitted and the call that would EXCEED it throws kind \'ceiling\' naming the spend — the ledger\'s persistence to the key-scoped path is proven in moonshot-budget.test.ts ("Persisted, not remembered")', 'connector', 'common', () =>
+    verifyBoundary('moonshot.budget.throws_at_ceiling', () => {
+      const dir = mkdtempSync(join(tmpdir(), 'moonshot-cap-budget-'));
+      try {
+        // A REAL millisecond epoch clock (a 1_000_000 `now` threw 'clock-invalid' on the FIRST
+        // checkBudget, so the bare catch reported the guard green while never once exercising
+        // the ceiling — the round-three tautology).
+        let t = 1_800_000_000_000;
+        const budget = new MoonshotBudget({ path: join(dir, 'ledger.json'), now: () => t });
+        const fits = Math.floor(MOONSHOT_BUDGET_CEILING / MOONSHOT_CALL_WEIGHTS.inference); // 10
+        for (let i = 0; i < fits; i++) budget.checkBudget(MOONSHOT_CALL_WEIGHTS.inference);
+        // The call that would EXCEED the ceiling is the one that throws — not one before it.
+        let threw: InstanceType<typeof MoonshotBudgetError> | null = null;
+        try {
+          budget.checkBudget(MOONSHOT_CALL_WEIGHTS.inference);
+        } catch (e) {
+          if (e instanceof MoonshotBudgetError) threw = e;
+          else throw e;
+        }
+        if (!threw) return false;
+        if (threw.kind !== 'ceiling' || threw.vendor !== 'moonshot') return false;
+        // The refusal names the arithmetic: spend, ceiling, weight.
+        if (!threw.message.includes(`${MOONSHOT_BUDGET_CEILING}`) || !threw.message.includes(`${MOONSHOT_CALL_WEIGHTS.inference}`)) return false;
+        // The window still rolls: aging the spend out restores the allowance.
+        t += MOONSHOT_RATE_BUDGET_WINDOW_MS + 1;
+        budget.checkBudget(MOONSHOT_CALL_WEIGHTS.inference);
+        return true;
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }),
+  ),
+
+  // ── Scenario scripting (twin-only scaffolding, NOT vendor surface) is deliberately ABSENT ──
+  // from the capability manifest (ADDING_A_TWIN.md: scenario support is kept OUT — it is not
+  // vendor surface) and is gated by src/moonshot-scenario.test.ts instead (the deepinfra/deepseek
+  // precedent).
+
+  // ── Connector (the live-vendor boundary) ───────────────────────────────────────────────
+  done('moonshot.connector.pull', 'connector', 'Connector: pull real Models / Files / Batches / Balance via the injected executor', 'connector', 'core', () =>
+    withConnectorRoot('moonshot.connector.pull', async () => {
+      const { execute, calls } = fakeExecute((m, p) => {
+        if (p === '/v1/models') return { data: [{ id: 'kimi-k3', object: 'model', created: 42, owned_by: 'moonshot' }] };
+        if (p === '/v1/files') return { data: [{ id: 'file_real_1', object: 'file', bytes: 3, created_at: 1, filename: 'real.jsonl', purpose: 'batch', status: 'ready' }] };
+        if (p === '/v1/batches') return { data: [] };
+        if (p === '/v1/users/me/balance') return { code: 0, data: { available_balance: 12.5, voucher_balance: 2, cash_balance: 10.5 }, scode: '0x0', status: true };
+        return { data: [] };
+      });
+      const resources = await pullMoonshotState(execute);
+      // Every modeled collection was REALLY swept — recorded calls, not a return-value tautology.
+      for (const p of ['/v1/models', '/v1/files', '/v1/batches', '/v1/users/me/balance']) {
+        if (!calls.includes(`GET ${p}`)) return false;
+      }
+      const types = new Map(resources.map((r) => [r.type, r]));
+      return types.get('model')?.id === 'kimi-k3'
+        && types.get('file')?.id === 'file_real_1'
+        && types.get('balance')?.id === 'me'
+        && (types.get('balance')?.fields as Body)?.available_balance === 12.5;
+    }),
+  ),
+  done('moonshot.connector.pull_refuses_an_error_envelope', 'connector', 'Connector: a refused pull is NOT an empty account — an error envelope throws instead of folding empty state', 'connector', 'core', () =>
+    withConnectorRoot('moonshot.connector.pull_refuses_an_error_envelope', async () => {
+      const { execute } = fakeExecute(() => ({ error: { message: 'Invalid API key', type: 'invalid_authentication_error' } }));
+      let threw = '';
+      try { await pullMoonshotState(execute); } catch (e) { threw = String((e as Error).message); }
+      return threw.includes('Invalid API key');
+    }),
+  ),
+  done('moonshot.connector.pull_folds_into_the_log', 'connector', 'Connector: pulled state folds into the event log and is SERVED by the API (shadow-diff makes a re-pull a no-op)', 'connector', 'core', () =>
+    withConnectorRoot('moonshot.connector.pull_folds_into_the_log', async (root) => {
+      const before = await handleMoonshotTwinRequest({ method: 'GET', path: `${MOONSHOT_API_PREFIX}/files`, root });
+      if (((before.body as Body).data as Body[]).some((f) => f.id === 'file_real_1')) return false;
+      const { execute } = fakeExecute((m, p) => {
+        if (p === '/v1/files') return { data: [{ id: 'file_real_1', object: 'file', bytes: 3, created_at: 1, filename: 'real.jsonl', purpose: 'batch', status: 'ready' }] };
+        if (p === '/v1/users/me/balance') return { code: 0, data: { available_balance: 12.5, voucher_balance: 2, cash_balance: 10.5 }, scode: '0x0', status: true };
+        return { data: [] };
+      });
+      const first = await syncMoonshotFromReal(execute, { root, occurredAt: '2026-06-15T00:00:00Z' });
+      if (first.observed < 2 || first.deltasAppended < 2) return false;
+      const after = await handleMoonshotTwinRequest({ method: 'GET', path: `${MOONSHOT_API_PREFIX}/files`, root });
+      const row = ((after.body as Body).data as Body[]).find((f) => f.id === 'file_real_1');
+      if (!row || row.filename !== 'real.jsonl') return false;
+      // The balance row is SERVED too — the pulled figure replaces the stub.
+      const bal = await handleMoonshotTwinRequest({ method: 'GET', path: `${MOONSHOT_API_PREFIX}/users/me/balance`, root });
+      if ((bal.body as Body).data?.available_balance !== 12.5) return false;
+      const again = await syncMoonshotFromReal(execute, { root, occurredAt: '2026-06-15T00:01:00Z' });
+      return again.deltasAppended === 0;
+    }),
+  ),
+  done('moonshot.connector.push', 'connector', 'Connector: a pending batch create pushes the right method, path AND payload, and is confirmed exactly once', 'connector', 'core', () =>
+    withConnectorRoot('moonshot.connector.push', async (root) => {
+      const f = await handleMoonshotTwinRequest({ method: 'POST', path: `${MOONSHOT_API_PREFIX}/files`, body: JSON.stringify({ purpose: 'batch', filename: 'local.jsonl', content: 'x' }), root, occurredAt: '2026-06-15T00:00:00Z' });
+      const b = await handleMoonshotTwinRequest({ method: 'POST', path: `${MOONSHOT_API_PREFIX}/batches`, body: JSON.stringify({ input_file_id: id(f), endpoint: '/v1/chat/completions', completion_window: '48h', metadata: { run: 'nightly' } }), root, occurredAt: '2026-06-15T00:00:01Z' });
+      if (!ok(f) || !ok(b)) return false;
+      const pending = pendingActions('moonshot', root).filter((a) => a.subject.type === 'batch');
+      if (pending.length !== 1) return false;
+      const { execute, calls, bodies } = fakeExecute(() => ({ id: 'batch_real_pushed' }));
+      const res = await pushPendingMoonshotActions(execute, { root, occurredAt: '2026-06-15T00:00:02Z' });
+      const batchCall = calls.indexOf('POST /v1/batches');
+      if (batchCall < 0 || res.pushed < 1) return false;
+      // THE PAYLOAD, not just the path: exactly the keys Moonshot's BatchCreateRequest accepts.
+      const sent = bodies[batchCall] as Body;
+      if (!sent || sent.input_file_id !== id(f) || sent.endpoint !== '/v1/chat/completions') return false;
+      if (sent.completion_window !== '48h' || (sent.metadata as Body)?.run !== 'nightly') return false;
+      if ('status' in sent || 'created_at' in sent || 'expires_at' in sent) return false; // derived fields must not be pushed
+      if (!Object.values(res.externalIds).includes('batch_real_pushed')) return false;
+      if (pendingActions('moonshot', root).some((a) => a.subject.type === 'batch')) return false;
+      // The unpushable file create is REPORTED, not silently dropped, and stays pending.
+      if (!res.refused.some((r) => r.operation === 'file.create' && r.reason.includes('multipart'))) return false;
+      if (!pendingActions('moonshot', root).some((a) => a.subject.type === 'file')) return false;
+      // Idempotency: a re-push enacts nothing.
+      const before = calls.length;
+      const again = await pushPendingMoonshotActions(execute, { root, occurredAt: '2026-06-15T00:00:03Z' });
+      return again.pushed === 0 && calls.length === before;
+    }),
+  ),
+  done('moonshot.connector.push_file_create_refused', 'connector', 'Connector: a local file create is REFUSED at push (Moonshot\'s files endpoint is multipart), never faked as JSON', 'connector', 'common', () =>
+    withConnectorRoot('moonshot.connector.push_file_create_refused', async () => {
+      const { execute, calls } = fakeExecute(() => ({ id: 'batch_real' }));
+      // The pushable control FIRST, so a dead connector seam (which makes everything throw)
+      // cannot satisfy this verify with the negative half alone.
+      const good = await pushMoonshotAction(execute, { operation: 'batch.create', subject: { type: 'batch', id: 'batch_twin_1' }, fields: { input_file_id: 'file_twin_1', endpoint: '/v1/chat/completions', completion_window: '24h' } });
+      if (good.externalId !== 'batch_real' || calls.length !== 1) return false;
+      let why = '';
+      try {
+        await pushMoonshotAction(execute, { operation: 'file.create', subject: { type: 'file', id: 'file_twin_1' }, fields: { purpose: 'batch', filename: 'a.jsonl' } });
+      } catch (e) { why = String((e as Error).message); }
+      // Refused with a REASON, and the vendor was never touched.
+      return why.includes('multipart') && calls.length === 1;
+    }),
+  ),
+  done('moonshot.connector.push_refuses_unsupported_op', 'connector', 'Connector: an unpushable operation throws instead of being silently dropped', 'connector', 'common', () =>
+    withConnectorRoot('moonshot.connector.push_refuses_unsupported_op', async () => {
+      const { execute, calls } = fakeExecute(() => ({ id: 'batch_real' }));
+      // The SUPPORTED op must succeed here too, so a dead connector seam (which would make BOTH
+      // calls throw) cannot pass this verify by satisfying only the negative half.
+      const good = await pushMoonshotAction(execute, { operation: 'batch.create', subject: { type: 'batch', id: 'batch_twin_1' }, fields: { input_file_id: 'file_twin_1', endpoint: '/v1/chat/completions', completion_window: '24h' } });
+      if (good.externalId !== 'batch_real' || calls.length !== 1) return false;
+      let threw = false;
+      try {
+        await pushMoonshotAction(execute, { operation: 'batch.update', subject: { type: 'batch', id: 'batch_twin_1' }, fields: {} });
+      } catch (e) {
+        threw = String((e as Error).message).includes('unsupported operation');
+      }
+      // The refused op must not have reached the vendor at all.
+      return threw && calls.length === 1;
+    }),
+  ),
+  done('moonshot.connector.full_sync', 'connector', 'Connector: full sync pushes pending writes then pulls all collections, idempotently', 'connector', 'core', () =>
+    withConnectorRoot('moonshot.connector.full_sync', async (root) => {
+      // Seed a BATCH create (a JSON endpoint the connector can genuinely push); a local FILE
+      // create is deliberately unpushable (moonshot.connector.push_file_create_refused).
+      const f = await handleMoonshotTwinRequest({ method: 'POST', path: `${MOONSHOT_API_PREFIX}/files`, body: JSON.stringify({ purpose: 'batch', filename: 'local.jsonl', content: 'x' }), root, occurredAt: '2026-06-15T00:00:00Z' });
+      await handleMoonshotTwinRequest({ method: 'POST', path: `${MOONSHOT_API_PREFIX}/batches`, body: JSON.stringify({ input_file_id: id(f), endpoint: '/v1/chat/completions', completion_window: '24h' }), root, occurredAt: '2026-06-15T00:00:01Z' });
+      const { execute, calls } = fakeExecute((m, p) => {
+        if (m === 'GET' && p === '/v1/files') return { data: [{ id: 'file_real_1', object: 'file', bytes: 1, created_at: 1, filename: 'real.jsonl', purpose: 'batch', status: 'ready' }] };
+        if (m === 'GET' && p === '/v1/users/me/balance') return { code: 0, data: { available_balance: 1, voucher_balance: 0, cash_balance: 1 }, scode: '0x0', status: true };
+        if (m === 'GET') return { data: [] };
+        return { id: 'batch_real_pushed' };
+      });
+      const res = await fullSyncMoonshot(execute, { root, occurredAt: '2026-06-15T00:00:02Z' });
+      if (res.pushed !== 1 || res.deltasAppended < 1) return false;
+      // Assert the collections were REALLY swept, by the calls the fake recorded — `res.collections`
+      // alone is COLLECTIONS.length returned by the function under test, i.e. a tautology (§9 NIT).
+      for (const p of ['/v1/models', '/v1/files', '/v1/batches', '/v1/users/me/balance']) {
+        if (!calls.includes(`GET ${p}`)) return false;
+      }
+      // The unpushable file create stays pending by design; the batch create is gone.
+      if (pendingActions('moonshot', root).some((a) => a.subject.type === 'batch')) return false;
+      const again = await fullSyncMoonshot(execute, { root, occurredAt: '2026-06-15T00:00:03Z' });
+      return again.pushed === 0 && again.deltasAppended === 0;
+    }),
+  ),
+  done('moonshot.connector.push_request_shape', 'connector', "Connector: ops map to the right method+path, addressed by the VENDOR's id — never the twin's own mint", 'connector', 'common', async () => {
+    // The groq pack's §9 ROUND TWO BLOCKER, back-applied: `batch_twin_1` is the TWIN's mint, a
+    // resource the real account has never heard of; a push addressed by it would 404 at the vendor.
+    const create = moonshotRequestForAction({ operation: 'batch.create', subject: { type: 'batch', id: 'batch_twin_1' } });
+    const cancel = moonshotRequestForAction({ operation: 'batch.cancel', subject: { type: 'batch', id: 'batch_twin_1' } }, 'batch_01j_real');
+    const del = moonshotRequestForAction({ operation: 'file.delete', subject: { type: 'file', id: 'file_twin_1' } }, 'file_01j_real');
+    if (create.method !== 'POST' || create.path !== '/v1/batches') return false;
+    if (cancel.method !== 'POST' || cancel.path !== '/v1/batches/batch_01j_real/cancel') return false;
+    if (del.method !== 'DELETE' || del.path !== '/v1/files/file_01j_real') return false;
+    // A local mint, unresolved, must THROW rather than address the real account.
+    let refusedLocal = '';
+    try { moonshotRequestForAction({ operation: 'batch.cancel', subject: { type: 'batch', id: 'batch_twin_1' } }); } catch (e) { refusedLocal = String((e as Error).message); }
+    let unknownType = false;
+    try { moonshotRequestForAction({ operation: 'model.create', subject: { type: 'model', id: 'm1' } }); } catch { unknownType = true; }
+    return refusedLocal.includes("twin's own id") && unknownType;
+  }),
+  done('moonshot.connector.push_addresses_the_vendor_id', 'connector', "Connector: a pushed create records the vendor's id, and a later cancel/delete uses IT, not the local mint", 'connector', 'core', () =>
+    withConnectorRoot('moonshot.connector.push_addresses_the_vendor_id', async (root) => {
+      const f = await handleMoonshotTwinRequest({ method: 'POST', path: `${MOONSHOT_API_PREFIX}/files`, body: JSON.stringify({ purpose: 'batch', filename: 'in.jsonl', content: 'x' }), root, occurredAt: '2026-06-15T00:00:00Z' });
+      const b = await handleMoonshotTwinRequest({ method: 'POST', path: `${MOONSHOT_API_PREFIX}/batches`, body: JSON.stringify({ input_file_id: id(f), endpoint: '/v1/chat/completions', completion_window: '24h' }), root, occurredAt: '2026-06-15T00:00:01Z' });
+      if (!ok(f) || !ok(b) || !String(id(b)).includes('_twin_')) return false;
+      const { execute, calls } = fakeExecute(() => ({ id: 'batch_01jREAL' }));
+      await pushPendingMoonshotActions(execute, { root, occurredAt: '2026-06-15T00:00:02Z' });
+      if (!calls.includes('POST /v1/batches')) return false;
+      // Now cancel LOCALLY and push again: the request must name the VENDOR's id.
+      await handleMoonshotTwinRequest({ method: 'POST', path: `${MOONSHOT_API_PREFIX}/batches/${id(b)}/cancel`, root, occurredAt: '2026-06-15T00:00:03Z' });
+      const res = await pushPendingMoonshotActions(execute, { root, occurredAt: '2026-06-15T00:00:04Z' });
+      const cancelCall = calls.find((c) => c.endsWith('/cancel'));
+      if (res.pushed !== 1 || cancelCall !== 'POST /v1/batches/batch_01jREAL/cancel') return false;
+      // …and nothing ever addressed the real account by the twin's own mint.
+      if (calls.some((c) => c.includes('_twin_'))) return false;
+      // A subject the vendor never received (the unpushable file) is REFUSED, not guessed at.
+      await handleMoonshotTwinRequest({ method: 'DELETE', path: `${MOONSHOT_API_PREFIX}/files/${id(f)}`, root, occurredAt: '2026-06-15T00:00:05Z' });
+      const after = await pushPendingMoonshotActions(execute, { root, occurredAt: '2026-06-15T00:00:06Z' });
+      return after.pushed === 0 && after.refused.some((r) => r.reason.includes('no vendor id recorded'));
+    }),
+  ),
+  done('moonshot.connector.live_client_refuses_unmodeled_paths', 'connector', 'Connector: the live executor refuses a non-Moonshot path BEFORE any request goes out (the budget guard on modeled calls is proven in moonshot-budget.test.ts)', 'connector', 'common', async () => {
+    const calls: string[] = [];
+    const fetchImpl = (async (url: string) => { calls.push(String(url)); return new Response('{"data":[]}', { status: 200 }); }) as unknown as typeof fetch;
+    const dir = mkdtempSync(join(tmpdir(), 'moonshot-cap-budget-'));
+    try {
+      // The ledger is INJECTED so this never spends against the operator's real ~/.volter/moonshot file.
+      const { liveMoonshotExecute } = await import('./moonshot-connector.ts');
+      const execute = liveMoonshotExecute('sk-fake-never-real', 'https://api.moonshot.test', { fetchImpl, budgetOptions: { path: join(dir, 'ledger.json') } });
+      let threw = false;
+      try { await execute('GET', '/v2/other'); } catch (e) { threw = String((e as Error).message).includes('unmodeled'); }
+      const beforeAllowed = calls.length;
+      if (!threw || beforeAllowed !== 0) return false;
+      await execute('GET', '/v1/models');
+      // The refusal cost the vendor NOTHING, and the modeled path really did go out.
+      return calls.length === beforeAllowed + 1 && calls[0] === 'https://api.moonshot.test/v1/models';
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }),
+  done('moonshot.connector.pulled_models_are_served', 'connector', 'Connector: models observed by a pull are SERVED by GET /models, not just folded into the log', 'connector', 'common', () =>
+    withConnectorRoot('moonshot.connector.pulled_models_are_served', async (root) => {
+      const before = await handleMoonshotTwinRequest({ method: 'GET', path: `${MOONSHOT_API_PREFIX}/models`, root });
+      if (((before.body as Body).data as Body[]).some((m) => m.id === 'kimi-experimental-twin-only')) return false;
+      const { execute } = fakeExecute((m, p) => p === '/v1/models'
+        ? { data: [{ id: 'kimi-experimental-twin-only', object: 'model', created: 42, owned_by: 'moonshot' }] }
+        : p === '/v1/users/me/balance'
+          ? { code: 0, data: { available_balance: 1, voucher_balance: 0, cash_balance: 1 }, scode: '0x0', status: true }
+          : { data: [] });
+      const res = await syncMoonshotFromReal(execute, { root, occurredAt: '2026-06-15T00:00:00Z' });
+      if (res.deltasAppended < 1) return false;
+      const after = await handleMoonshotTwinRequest({ method: 'GET', path: `${MOONSHOT_API_PREFIX}/models`, root });
+      const row = ((after.body as Body).data as Body[]).find((m) => m.id === 'kimi-experimental-twin-only');
+      if (!row || row.owned_by !== 'moonshot') return false;
+      // …without duplicating or shadowing a static catalog row. (The by-id retrieve assertion is
+      // gone: Moonshot's OpenAPI declares no /v1/models/{model} operation — moonshot.models.retrieve
+      // records the gap, and the twin 404s the route like the vendor.)
+      const ids = ((after.body as Body).data as Body[]).map((m) => m.id);
+      return new Set(ids).size === ids.length
+        && ((after.body as Body).data as Body[]).find((m) => m.id === 'kimi-k3')?.owned_by === 'moonshot';
+    }),
+  ),
+
+  // ── Conformance harness ────────────────────────────────────────────────────────────────
+  done('moonshot.conformance.probes', 'conformance', 'Offline conformance harness passes (one real probe per claimed endpoint + the router census + both error envelopes + the three streaming grammars)', 'api', 'core', async () => {
+    const { checkMoonshotConformance } = await import('./moonshot-conformance.ts');
+    const report = await checkMoonshotConformance();
+    return report.ok && report.probes >= 19 && report.checksRun >= 30;
+  }),
+];
+
+// TWIN-87 committed area census — Moonshot's top-level API product areas (docs nav / the
+// OpenAPI's tag structure), authored top-down independent of what a manifest entry happens to
+// already exist for. moonshot-capabilities.test.ts's area-census meta-test (assertAreaCensus)
+// fails the gate if a declared area has zero manifest entries and no named exclusion, OR if a
+// manifest entry's `area` drifts outside this list — so a whole missing area can never hide
+// invisibly.
+export const MOONSHOT_AREAS = [
+  'auth', 'balance', 'batches', 'chat', 'conformance', 'connector', 'errors', 'files',
+  'messages', 'models', 'rate_limits', 'responses', 'signatures', 'streaming',
+  'tokens', 'tools',
+] as const;
+
+export function moonshotCapabilities(): Promise<CapabilityReport> {
+  return checkCapabilities('moonshot', MOONSHOT_CAPABILITIES);
+}