@yanlinglabs/winter-conformance 0.0.2

package/dist/index-v0zvhx0z.js

@@ -0,0 +1,1576 @@
+import {
+  normalizeTrace2
+} from "./index-z5gwvsfh.js";
+
+// src/official/fetch.ts
+import { createHash } from "node:crypto";
+
+// src/bun-required.ts
+function brandedInstanceOf(brand) {
+  return (candidate) => typeof candidate === "object" && candidate !== null && (brand in candidate);
+}
+var BUN_REQUIRED_BRAND = Symbol.for("@yanlinglabs/winter-conformance:BunRequiredError");
+
+class BunRequiredError2 extends Error {
+  name = "BunRequiredError";
+  [BUN_REQUIRED_BRAND] = true;
+  static [Symbol.hasInstance] = brandedInstanceOf(BUN_REQUIRED_BRAND);
+  functionName;
+  bunApi;
+  constructor(functionName, bunApi, detail) {
+    super(`${functionName}() requires the Bun runtime: it uses ${bunApi}, which has no Node equivalent this package implements. ${detail}`);
+    this.functionName = functionName;
+    this.bunApi = bunApi;
+  }
+}
+function hasBunRuntime2() {
+  return typeof globalThis.Bun !== "undefined";
+}
+function requireBunRuntime2(functionName, bunApi, detail) {
+  if (!hasBunRuntime2())
+    throw new BunRequiredError2(functionName, bunApi, detail);
+}
+
+// src/official/fetch.ts
+import { mkdirSync, mkdtempSync, writeFileSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var CHECKSUM_MISMATCH_BRAND = Symbol.for("@yanlinglabs/winter-conformance:ChecksumMismatchError");
+var OFFICIAL_COMPAT_UNAVAILABLE_BRAND = Symbol.for("@yanlinglabs/winter-conformance:OfficialCompatUnavailableError");
+
+class ChecksumMismatchError2 extends Error {
+  [CHECKSUM_MISMATCH_BRAND] = true;
+  static [Symbol.hasInstance] = brandedInstanceOf(CHECKSUM_MISMATCH_BRAND);
+  constructor(message) {
+    super(message);
+    this.name = "ChecksumMismatchError";
+  }
+}
+
+class OfficialCompatUnavailableError2 extends Error {
+  [OFFICIAL_COMPAT_UNAVAILABLE_BRAND] = true;
+  static [Symbol.hasInstance] = brandedInstanceOf(OFFICIAL_COMPAT_UNAVAILABLE_BRAND);
+  constructor(message) {
+    super(message);
+    this.name = "OfficialCompatUnavailableError";
+  }
+}
+var CHECKSUMS_URL = new URL("../../compat/anthropic/0.3.250/checksums.json", import.meta.url);
+var cachedChecksums;
+function getChecksums2() {
+  if (cachedChecksums !== undefined)
+    return cachedChecksums;
+  let raw;
+  try {
+    raw = readFileSync(CHECKSUMS_URL, "utf8");
+  } catch (e) {
+    if (e?.code === "ENOENT") {
+      throw new OfficialCompatUnavailableError2("official upstream fetch needs the repository checkout; the published package does not ship compat/");
+    }
+    throw e;
+  }
+  cachedChecksums = JSON.parse(raw);
+  return cachedChecksums;
+}
+function verifyDigest2(bytes, expected) {
+  const actual = createHash("sha256").update(bytes).digest("hex");
+  if (actual !== expected)
+    throw new ChecksumMismatchError2(`expected ${expected}, got ${actual}`);
+}
+function verifySha512Integrity2(bytes, expectedIntegrity) {
+  const prefix = "sha512-";
+  if (!expectedIntegrity.startsWith(prefix)) {
+    throw new Error(`unsupported integrity format (expected a "${prefix}" SRI string): ${expectedIntegrity}`);
+  }
+  const expectedBase64 = expectedIntegrity.slice(prefix.length);
+  const actualBase64 = createHash("sha512").update(bytes).digest("base64");
+  if (actualBase64 !== expectedBase64) {
+    throw new ChecksumMismatchError2(`expected ${expectedIntegrity}, got ${prefix}${actualBase64}`);
+  }
+}
+function resolveCacheDir2(cacheDir) {
+  if (cacheDir !== undefined) {
+    mkdirSync(cacheDir, { recursive: true });
+    return { dir: cacheDir, ownedDir: false };
+  }
+  return { dir: mkdtempSync(join(tmpdir(), "winter-upstream-")), ownedDir: true };
+}
+async function fetchAndVerifyUpstream2(opts = {}) {
+  const checksums = getChecksums2();
+  const res = await fetch(checksums.tarballUrl);
+  if (!res.ok)
+    throw new Error(`upstream fetch failed: ${res.status} ${res.statusText}`);
+  const bytes = new Uint8Array(await res.arrayBuffer());
+  verifyDigest2(bytes, checksums.wrapperTarballSha256);
+  verifySha512Integrity2(bytes, checksums.wrapperTarballIntegrity);
+  const { dir, ownedDir } = resolveCacheDir2(opts.cacheDir);
+  const tarballPath = join(dir, "claude-agent-sdk-0.3.250.tgz");
+  writeFileSync(tarballPath, bytes);
+  return { tarballPath, sha256: checksums.wrapperTarballSha256, ownedDir };
+}
+// src/official/capture.ts
+import { mkdtempSync as mkdtempSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, rmSync, readdirSync, statSync } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname, join as join2 } from "node:path";
+var CANNED_TEXT_RESPONSE = {
+  id: "msg_capture_canned_01",
+  type: "message",
+  role: "assistant",
+  model: "claude-sonnet-4-5-20250929",
+  content: [{ type: "text", text: "echo: hi" }],
+  stop_reason: "end_turn",
+  stop_sequence: null,
+  usage: { input_tokens: 10, output_tokens: 5 }
+};
+function cannedToolUseResponse(readTargetPath) {
+  return {
+    id: "msg_capture_canned_tooluse_01",
+    type: "message",
+    role: "assistant",
+    model: "claude-sonnet-4-5-20250929",
+    content: [{ type: "tool_use", id: "toolu_capture_01", name: "Read", input: { file_path: readTargetPath } }],
+    stop_reason: "tool_use",
+    stop_sequence: null,
+    usage: { input_tokens: 10, output_tokens: 5 }
+  };
+}
+var CANNED_TEXT_AFTER_TOOL_RESPONSE = {
+  id: "msg_capture_canned_02",
+  type: "message",
+  role: "assistant",
+  model: "claude-sonnet-4-5-20250929",
+  content: [{ type: "text", text: "capture: tool round complete" }],
+  stop_reason: "end_turn",
+  stop_sequence: null,
+  usage: { input_tokens: 12, output_tokens: 6 }
+};
+function requestAlreadySawToolResult(body) {
+  try {
+    const messages = body.messages;
+    if (!Array.isArray(messages))
+      return false;
+    for (const m of messages) {
+      const content = m.content;
+      if (Array.isArray(content) && content.some((block) => block.type === "tool_result"))
+        return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function installOfficialSdk(cleanups) {
+  const { tarballPath, ownedDir } = await fetchAndVerifyUpstream2();
+  if (ownedDir)
+    cleanups.push(() => rmSync(dirname(tarballPath), { recursive: true, force: true }));
+  const npmPrefix = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-"));
+  cleanups.push(() => rmSync(npmPrefix, { recursive: true, force: true }));
+  const install = Bun.spawn(["npm", "install", "--no-save", "--ignore-scripts", "--prefix", npmPrefix, tarballPath], { stdout: "pipe", stderr: "pipe" });
+  const installOut = await new Response(install.stdout).text() + await new Response(install.stderr).text();
+  if (await install.exited !== 0) {
+    throw new Error(`npm install --prefix ${npmPrefix} failed:
+${installOut}`);
+  }
+  const officialPkgDir = join2(npmPrefix, "node_modules", "@anthropic-ai", "claude-agent-sdk");
+  const officialPkgJson = JSON.parse(readFileSync2(join2(officialPkgDir, "package.json"), "utf8"));
+  if (!officialPkgJson.main)
+    throw new Error('installed @anthropic-ai/claude-agent-sdk package.json has no "main" field');
+  const entryPath = join2(officialPkgDir, officialPkgJson.main);
+  return await import(entryPath);
+}
+async function runPlainQueryCapture(officialSdk) {
+  const cleanups = [];
+  let server;
+  try {
+    const claudeConfigDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-config-"));
+    cleanups.push(() => rmSync(claudeConfigDir, { recursive: true, force: true }));
+    const homeDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-home-"));
+    cleanups.push(() => rmSync(homeDir, { recursive: true, force: true }));
+    const fixtureCwd = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-cwd-"));
+    cleanups.push(() => rmSync(fixtureCwd, { recursive: true, force: true }));
+    let requestCount = 0;
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      fetch(req) {
+        requestCount++;
+        const url = new URL(req.url);
+        console.error(`[loopback A] #${requestCount} ${req.method} ${url.pathname}${url.search} host=${req.headers.get("host")}`);
+        return new Response(JSON.stringify(CANNED_TEXT_RESPONSE), { status: 200, headers: { "content-type": "application/json" } });
+      }
+    });
+    console.error(`
+=== Scenario A: plain query ===`);
+    console.error(`[capture A] loopback listening on ${server.url.href} (the ONLY endpoint the official runtime is given)`);
+    console.error(`[capture A] CLAUDE_CONFIG_DIR=${claudeConfigDir} HOME=${homeDir} (both fresh mkdtemp — never the real ~/.claude or the real user home)`);
+    const entries = [];
+    let thrown;
+    try {
+      const q = officialSdk.query({
+        prompt: "hi",
+        options: {
+          model: "sonnet",
+          cwd: fixtureCwd,
+          settingSources: [],
+          env: {
+            ANTHROPIC_BASE_URL: server.url.href.replace(/\/$/, ""),
+            ANTHROPIC_API_KEY: "test",
+            CLAUDE_CONFIG_DIR: claudeConfigDir,
+            HOME: homeDir
+          }
+        }
+      });
+      for await (const msg of q) {
+        entries.push({ sequence: entries.length, direction: "runtime-to-host", kind: msg.type === "system" ? `system/${msg.subtype}` : msg.type, payload: msg });
+      }
+    } catch (e) {
+      thrown = e;
+    }
+    console.error(`[capture A] official runtime made ${requestCount} request(s) to the loopback; ${entries.length} message(s) yielded`);
+    if (thrown)
+      console.error(`[capture A] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    console.log(`
+--- Scenario A normalized trace ---`);
+    console.log(JSON.stringify(normalizeTrace2(entries), null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+async function runInitToolsCapture(officialSdk) {
+  const cleanups = [];
+  let server;
+  try {
+    const claudeConfigDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-config-c-"));
+    cleanups.push(() => rmSync(claudeConfigDir, { recursive: true, force: true }));
+    const homeDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-home-c-"));
+    cleanups.push(() => rmSync(homeDir, { recursive: true, force: true }));
+    const fixtureCwd = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-cwd-c-"));
+    cleanups.push(() => rmSync(fixtureCwd, { recursive: true, force: true }));
+    let requestCount = 0;
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      fetch(req) {
+        requestCount++;
+        const url = new URL(req.url);
+        console.error(`[loopback C] #${requestCount} ${req.method} ${url.pathname}${url.search} host=${req.headers.get("host")}`);
+        return new Response(JSON.stringify(CANNED_TEXT_RESPONSE), { status: 200, headers: { "content-type": "application/json" } });
+      }
+    });
+    console.error(`
+=== Scenario C: official default system/init.tools ===`);
+    console.error(`[capture C] loopback listening on ${server.url.href} (the ONLY endpoint the official runtime is given)`);
+    console.error(`[capture C] CLAUDE_CONFIG_DIR=${claudeConfigDir} HOME=${homeDir} (both fresh mkdtemp — never the real ~/.claude or the real user home)`);
+    const entries = [];
+    let thrown;
+    try {
+      const q = officialSdk.query({
+        prompt: "hi",
+        options: {
+          model: "sonnet",
+          cwd: fixtureCwd,
+          settingSources: [],
+          env: {
+            ANTHROPIC_BASE_URL: server.url.href.replace(/\/$/, ""),
+            ANTHROPIC_API_KEY: "test",
+            CLAUDE_CONFIG_DIR: claudeConfigDir,
+            HOME: homeDir
+          }
+        }
+      });
+      for await (const msg of q) {
+        entries.push({ sequence: entries.length, direction: "runtime-to-host", kind: msg.type === "system" ? `system/${msg.subtype}` : msg.type, payload: msg });
+      }
+    } catch (e) {
+      thrown = e;
+    }
+    console.error(`[capture C] official runtime made ${requestCount} request(s) to the loopback; ${entries.length} message(s) yielded`);
+    if (thrown)
+      console.error(`[capture C] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    const normalized = normalizeTrace2(entries);
+    const initEntry = normalized.find((e) => e.kind === "system/init");
+    const officialTools = initEntry ? initEntry.payload.tools : undefined;
+    console.log(`
+--- Scenario C normalized trace ---`);
+    console.log(JSON.stringify(normalized, null, 2));
+    console.log(`
+--- Scenario C: the official runtime's own default system/init.tools list (compare by eye against Winter's own default buildAdvertisedSet output) ---`);
+    console.log(JSON.stringify(officialTools ?? "(no system/init message observed)", null, 2));
+    if (Array.isArray(officialTools)) {
+      console.error(`[capture C] official default advertised set has ${officialTools.length} name(s) -- see the printed list above for the exact names (WS-06 §6 obligation 1/4: report-only, never asserted as a count anywhere in the committed test suite)`);
+    }
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+async function runPermissionsAndHooksCapture(officialSdk) {
+  const cleanups = [];
+  let server;
+  try {
+    const claudeConfigDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-config-b-"));
+    cleanups.push(() => rmSync(claudeConfigDir, { recursive: true, force: true }));
+    const homeDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-home-b-"));
+    cleanups.push(() => rmSync(homeDir, { recursive: true, force: true }));
+    const fixtureCwd = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-cwd-b-"));
+    cleanups.push(() => rmSync(fixtureCwd, { recursive: true, force: true }));
+    const readTargetDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-readtarget-"));
+    cleanups.push(() => rmSync(readTargetDir, { recursive: true, force: true }));
+    const readTargetPath = join2(readTargetDir, "capture-dummy.txt");
+    writeFileSync2(readTargetPath, `winter capture fixture -- not real data
+`);
+    let requestCount = 0;
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        const url = new URL(req.url);
+        let sawToolResult = false;
+        try {
+          const bodyText = await req.clone().text();
+          sawToolResult = bodyText.length > 0 && requestAlreadySawToolResult(JSON.parse(bodyText));
+        } catch {}
+        console.error(`[loopback B] #${requestCount} ${req.method} ${url.pathname}${url.search} host=${req.headers.get("host")} sawToolResult=${sawToolResult}`);
+        const body = sawToolResult ? CANNED_TEXT_AFTER_TOOL_RESPONSE : cannedToolUseResponse(readTargetPath);
+        return new Response(JSON.stringify(body), { status: 200, headers: { "content-type": "application/json" } });
+      }
+    });
+    console.error(`
+=== Scenario B: canUseTool + includeHookEvents + PreToolUse (observer) + SessionEnd ===`);
+    console.error(`[capture B] loopback listening on ${server.url.href} (the ONLY endpoint the official runtime is given)`);
+    console.error(`[capture B] CLAUDE_CONFIG_DIR=${claudeConfigDir} HOME=${homeDir} (both fresh mkdtemp); read target=${readTargetPath} (fresh mkdtemp, dummy content, never read for real)`);
+    let canUseToolCallCount = 0;
+    let canUseToolFieldSet = [];
+    let canUseToolPrintableSnapshot = {};
+    let sessionEndHookRan = false;
+    const preToolUseHookInvocations = [];
+    const entries = [];
+    let thrown;
+    try {
+      const q = officialSdk.query({
+        prompt: "please read the capture fixture file",
+        options: {
+          model: "sonnet",
+          cwd: fixtureCwd,
+          settingSources: [],
+          includeHookEvents: true,
+          env: {
+            ANTHROPIC_BASE_URL: server.url.href.replace(/\/$/, ""),
+            ANTHROPIC_API_KEY: "test",
+            CLAUDE_CONFIG_DIR: claudeConfigDir,
+            HOME: homeDir
+          },
+          canUseTool: async (toolName, input, opts) => {
+            canUseToolCallCount++;
+            canUseToolFieldSet = Object.keys(opts);
+            canUseToolPrintableSnapshot = {
+              toolName,
+              input,
+              ...Object.fromEntries(Object.entries(opts).map(([k, v]) => [k, k === "signal" ? `<${typeof v}>` : v]))
+            };
+            return { behavior: "deny", message: "capture: denied by canUseTool (Task 13 official capture)" };
+          },
+          hooks: {
+            PreToolUse: [
+              {
+                hooks: [
+                  async (input) => {
+                    preToolUseHookInvocations.push(input);
+                    return {};
+                  }
+                ]
+              }
+            ],
+            SessionEnd: [
+              {
+                hooks: [
+                  async () => {
+                    sessionEndHookRan = true;
+                    return {};
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      });
+      for await (const msg of q) {
+        entries.push({ sequence: entries.length, direction: "runtime-to-host", kind: msg.type === "system" ? `system/${msg.subtype}` : msg.type, payload: msg });
+      }
+    } catch (e) {
+      thrown = e;
+    }
+    console.error(`[capture B] official runtime made ${requestCount} request(s) to the loopback; ${entries.length} message(s) yielded`);
+    if (thrown)
+      console.error(`[capture B] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    console.error(`[capture B] canUseTool invoked ${canUseToolCallCount} time(s); PreToolUse hook invoked ${preToolUseHookInvocations.length} time(s); SessionEnd hook body ran: ${sessionEndHookRan}`);
+    const normalized = normalizeTrace2(entries);
+    const lifecycleKinds = normalized.map((e) => e.kind).filter((k) => k.startsWith("system/hook_"));
+    console.error(`[capture B] lifecycle-family messages observed on the stream: ${lifecycleKinds.length ? lifecycleKinds.join(", ") : "(none)"}`);
+    console.log(`
+--- Scenario B normalized trace ---`);
+    console.log(JSON.stringify(normalized, null, 2));
+    console.log(`
+--- Scenario B: canUseTool's received field set (WS-07 §7.1 comparison) ---`);
+    console.log(JSON.stringify(canUseToolFieldSet, null, 2));
+    console.log(`
+--- Scenario B: canUseTool's received values (signal recorded by type only) ---`);
+    console.log(JSON.stringify(canUseToolPrintableSnapshot, null, 2));
+    console.log(`
+--- Scenario B: Carry 3 (WS-17 capture-note) signals ---`);
+    console.log(JSON.stringify({ sessionEndHookBodyRan: sessionEndHookRan, lifecycleMessagesObserved: lifecycleKinds }, null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+function schemaShapeOnly(schema, insidePropertiesMap = false) {
+  if (Array.isArray(schema))
+    return schema.map((v) => schemaShapeOnly(v));
+  if (schema === null || typeof schema !== "object")
+    return schema;
+  const out = {};
+  for (const [k, v] of Object.entries(schema)) {
+    if (!insidePropertiesMap && (k === "description" || k === "title" || k === "$comment"))
+      continue;
+    out[k] = schemaShapeOnly(v, k === "properties");
+  }
+  return out;
+}
+function capturedToolsFrom(body) {
+  const tools = body.tools;
+  if (!Array.isArray(tools))
+    return;
+  const names = tools.map((t) => String(t.name));
+  const agent = tools.find((t) => {
+    const n = t.name;
+    return n === "Agent" || n === "Task";
+  });
+  return { names, agentSchema: agent === undefined ? undefined : schemaShapeOnly(agent.input_schema) };
+}
+async function runAdvertisedSchemaCapture(officialSdk) {
+  const cleanups = [];
+  let server;
+  try {
+    const claudeConfigDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-config-d-"));
+    cleanups.push(() => rmSync(claudeConfigDir, { recursive: true, force: true }));
+    const homeDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-home-d-"));
+    cleanups.push(() => rmSync(homeDir, { recursive: true, force: true }));
+    const fixtureCwd = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-cwd-d-"));
+    cleanups.push(() => rmSync(fixtureCwd, { recursive: true, force: true }));
+    let captured;
+    let requestCount = 0;
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        const url = new URL(req.url);
+        console.error(`[loopback D] #${requestCount} ${req.method} ${url.pathname}${url.search}`);
+        try {
+          const body = await req.json();
+          if (captured === undefined)
+            captured = capturedToolsFrom(body);
+        } catch {}
+        return new Response(JSON.stringify(CANNED_TEXT_RESPONSE), { status: 200, headers: { "content-type": "application/json" } });
+      }
+    });
+    console.error(`
+=== Scenario D: the live request's advertised tools[] (WS-09 §8.5 ground truth; WS-10 §17 OQ1) ===`);
+    console.error(`[capture D] loopback ${server.url.href}; CLAUDE_CONFIG_DIR=${claudeConfigDir} HOME=${homeDir} (both fresh mkdtemp)`);
+    let thrown;
+    try {
+      const q = officialSdk.query({
+        prompt: "hi",
+        options: {
+          model: "sonnet",
+          cwd: fixtureCwd,
+          settingSources: [],
+          env: {
+            ANTHROPIC_BASE_URL: server.url.href.replace(/\/$/, ""),
+            ANTHROPIC_API_KEY: "test",
+            CLAUDE_CONFIG_DIR: claudeConfigDir,
+            HOME: homeDir
+          }
+        }
+      });
+      for await (const _msg of q) {}
+    } catch (e) {
+      thrown = e;
+    }
+    if (thrown)
+      console.error(`[capture D] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    console.log(`
+--- Scenario D: every tool NAME in the live request's tools[] ---`);
+    console.log(JSON.stringify(captured?.names ?? "(no completions request body with a tools[] array was observed)", null, 2));
+    console.log(`
+--- Scenario D: the Agent/Task tool's own input_schema (SHAPE ONLY -- descriptions stripped) ---`);
+    console.log(JSON.stringify(captured?.agentSchema ?? "(no Agent/Task tool present in the advertised set)", null, 2));
+    const agentProps = Object.keys(captured?.agentSchema?.properties ?? {});
+    console.log(`
+--- Scenario D verdicts ---`);
+    console.log(JSON.stringify({
+      "WS-10 §17 OQ1 -- is `name` advertised on Agent in a DEFAULT session?": agentProps.length === 0 ? "(no Agent schema captured)" : agentProps.includes("name"),
+      "Agent input_schema property names": agentProps,
+      "SendMessage advertised?": captured?.names.includes("SendMessage") ?? "(unknown)",
+      "ListAgents advertised?": captured?.names.includes("ListAgents") ?? "(unknown)",
+      "ToolSearch advertised?": captured?.names.includes("ToolSearch") ?? "(unknown)",
+      "WaitForMcpServers advertised?": captured?.names.includes("WaitForMcpServers") ?? "(unknown)",
+      "MCP bridge tools advertised?": (captured?.names ?? []).filter((n) => n.startsWith("ListMcpResources") || n.startsWith("ReadMcpResource") || n === "RefreshMcpTools")
+    }, null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+async function runMcpOutputCapCapture(officialSdk, maxOutputTokens) {
+  const label = maxOutputTokens === undefined ? "default" : `MAX_MCP_OUTPUT_TOKENS=${maxOutputTokens}`;
+  const cleanups = [];
+  let server;
+  try {
+    const claudeConfigDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-config-e-"));
+    cleanups.push(() => rmSync(claudeConfigDir, { recursive: true, force: true }));
+    const homeDir = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-home-e-"));
+    cleanups.push(() => rmSync(homeDir, { recursive: true, force: true }));
+    const fixtureCwd = mkdtempSync2(join2(tmpdir2(), "winter-official-capture-cwd-e-"));
+    cleanups.push(() => rmSync(fixtureCwd, { recursive: true, force: true }));
+    const HUGE = "winterfiller ".repeat(30000);
+    const sdkAny = officialSdk;
+    if (typeof sdkAny.createSdkMcpServer !== "function" || typeof sdkAny.tool !== "function") {
+      console.log(`
+--- Scenario E (${label}): SKIPPED -- the installed package does not export createSdkMcpServer/tool ---`);
+      return;
+    }
+    const bigTool = sdkAny.tool("bigoutput", "returns a very large payload", {}, async () => ({
+      content: [{ type: "text", text: HUGE }]
+    }));
+    const mcpServer = sdkAny.createSdkMcpServer({ name: "capfixture", version: "1.0.0", tools: [bigTool] });
+    let toolResultTexts = [];
+    let requestCount = 0;
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        let body;
+        try {
+          body = await req.json();
+        } catch {
+          return new Response(JSON.stringify(CANNED_TEXT_RESPONSE), { status: 200, headers: { "content-type": "application/json" } });
+        }
+        const messages = body.messages ?? [];
+        for (const m of messages) {
+          const content = m.content;
+          if (!Array.isArray(content))
+            continue;
+          for (const block of content) {
+            if (block.type !== "tool_result")
+              continue;
+            const c = block.content;
+            const text = typeof c === "string" ? c : Array.isArray(c) ? c.map((b) => String(b.text ?? "")).join("") : "";
+            if (text.length > 0)
+              toolResultTexts.push(text);
+          }
+        }
+        if (requestAlreadySawToolResult(body)) {
+          return new Response(JSON.stringify(CANNED_TEXT_AFTER_TOOL_RESPONSE), { status: 200, headers: { "content-type": "application/json" } });
+        }
+        return new Response(JSON.stringify({
+          id: "msg_capture_mcp_01",
+          type: "message",
+          role: "assistant",
+          model: "claude-sonnet-4-5-20250929",
+          content: [{ type: "tool_use", id: "toolu_capture_mcp_01", name: "mcp__capfixture__bigoutput", input: {} }],
+          stop_reason: "tool_use",
+          stop_sequence: null,
+          usage: { input_tokens: 10, output_tokens: 5 }
+        }), { status: 200, headers: { "content-type": "application/json" } });
+      }
+    });
+    console.error(`
+=== Scenario E (${label}): MAX_MCP_OUTPUT_TOKENS default + truncation (WS-09 §12 OQ1) ===`);
+    console.error(`[capture E/${label}] loopback ${server.url.href}; payload sent by the fixture server: ${HUGE.length} chars`);
+    let thrown;
+    try {
+      const q = officialSdk.query({
+        prompt: "call the big tool",
+        options: {
+          model: "sonnet",
+          cwd: fixtureCwd,
+          settingSources: [],
+          allowedTools: ["mcp__capfixture__bigoutput"],
+          permissionMode: "bypassPermissions",
+          mcpServers: { capfixture: mcpServer },
+          env: {
+            ANTHROPIC_BASE_URL: server.url.href.replace(/\/$/, ""),
+            ANTHROPIC_API_KEY: "test",
+            CLAUDE_CONFIG_DIR: claudeConfigDir,
+            HOME: homeDir,
+            ...maxOutputTokens !== undefined ? { MAX_MCP_OUTPUT_TOKENS: maxOutputTokens } : {}
+          }
+        }
+      });
+      for await (const _msg of q) {}
+    } catch (e) {
+      thrown = e;
+    }
+    if (thrown)
+      console.error(`[capture E/${label}] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    const longest = toolResultTexts.reduce((a, b) => b.length > a.length ? b : a, "");
+    console.log(`
+--- Scenario E (${label}) ---`);
+    console.log(JSON.stringify({
+      "payload chars the fixture server returned": HUGE.length,
+      "tool_result blocks observed": toolResultTexts.length,
+      "longest tool_result chars the runtime forwarded": longest.length,
+      truncated: longest.length > 0 && longest.length < HUGE.length,
+      "head (first 300 chars)": longest.slice(0, 300),
+      "tail (last 300 chars)": longest.slice(-300)
+    }, null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+function makeScenarioDirs(tag, cleanups) {
+  const claudeConfigDir = mkdtempSync2(join2(tmpdir2(), `winter-official-capture-config-${tag}-`));
+  cleanups.push(() => rmSync(claudeConfigDir, { recursive: true, force: true }));
+  const homeDir = mkdtempSync2(join2(tmpdir2(), `winter-official-capture-home-${tag}-`));
+  cleanups.push(() => rmSync(homeDir, { recursive: true, force: true }));
+  const fixtureCwd = mkdtempSync2(join2(tmpdir2(), `winter-official-capture-cwd-${tag}-`));
+  cleanups.push(() => rmSync(fixtureCwd, { recursive: true, force: true }));
+  return { claudeConfigDir, homeDir, fixtureCwd };
+}
+function hermeticEnv(dirs, baseUrl, extra = {}) {
+  return {
+    ANTHROPIC_BASE_URL: baseUrl.replace(/\/$/, ""),
+    ANTHROPIC_API_KEY: "test",
+    CLAUDE_CONFIG_DIR: dirs.claudeConfigDir,
+    HOME: dirs.homeDir,
+    ...extra
+  };
+}
+async function drainWithDeadline(q, entries, label, deadlineMs, ac) {
+  let deadlineHit = false;
+  const timer = setTimeout(() => {
+    deadlineHit = true;
+    console.error(`[${label}] WALL-CLOCK DEADLINE ${deadlineMs}ms reached — aborting the run`);
+    ac?.abort();
+  }, deadlineMs);
+  let thrown;
+  try {
+    for await (const msg of q) {
+      entries.push({
+        sequence: entries.length,
+        direction: "runtime-to-host",
+        kind: msg.type === "system" ? `system/${msg.subtype}` : msg.type,
+        payload: msg
+      });
+    }
+  } catch (e) {
+    thrown = e;
+  } finally {
+    clearTimeout(timer);
+  }
+  return { thrown, deadlineHit };
+}
+function describeThrown(thrown) {
+  if (thrown === undefined)
+    return;
+  if (thrown instanceof Error) {
+    return { class: thrown.constructor.name, name: thrown.name, message: thrown.message };
+  }
+  return { class: typeof thrown, value: String(thrown) };
+}
+function sseResponse(events) {
+  const body = events.map((e) => `event: ${e.event}
+data: ${JSON.stringify(e.data)}
+
+`).join("");
+  return new Response(body, {
+    status: 200,
+    headers: { "content-type": "text/event-stream", "cache-control": "no-cache" }
+  });
+}
+function jsonResponse(body, status = 200, headers = {}) {
+  return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json", ...headers } });
+}
+var CAPTURE_STREAM_SIGNATURE = "WinterCaptureFakeThinkingSignature0123456789ABCDEF";
+function messagesShape(body) {
+  const messages = body.messages;
+  if (!Array.isArray(messages))
+    return "(no messages array)";
+  return messages.map((m) => {
+    const rec = m;
+    const content = rec.content;
+    if (typeof content === "string")
+      return { role: rec.role, content: `<string:${content.length} chars>` };
+    if (!Array.isArray(content))
+      return { role: rec.role, content: typeof content };
+    return {
+      role: rec.role,
+      blocks: content.map((b) => {
+        const block = b;
+        const out = { type: block.type };
+        if (block.type === "thinking") {
+          out.hasSignature = Object.prototype.hasOwnProperty.call(block, "signature");
+          out.signatureIsTheCannedOne = block.signature === CAPTURE_STREAM_SIGNATURE;
+          out.thinkingChars = typeof block.thinking === "string" ? block.thinking.length : null;
+        }
+        if (block.type === "redacted_thinking")
+          out.hasData = Object.prototype.hasOwnProperty.call(block, "data");
+        if (block.type === "tool_use")
+          out.name = block.name;
+        if (block.type === "tool_result") {
+          out.contentKind = Array.isArray(block.content) ? "blocks" : typeof block.content;
+          if (Array.isArray(block.content))
+            out.blockTypes = block.content.map((c) => c.type);
+        }
+        if (block.type === "image")
+          out.sourceType = block.source?.type;
+        return out;
+      })
+    };
+  });
+}
+function requestEnvelopeShape(body) {
+  const rec = body;
+  return {
+    model: rec.model,
+    stream: rec.stream,
+    max_tokens: rec.max_tokens,
+    thinking: rec.thinking,
+    topLevelKeys: Object.keys(rec).sort(),
+    toolCount: Array.isArray(rec.tools) ? rec.tools.length : null
+  };
+}
+function streamTurn1Events(readTargetPath, withSignature) {
+  const model = "claude-sonnet-4-5-20250929";
+  const evs = [];
+  evs.push({
+    event: "message_start",
+    data: {
+      type: "message_start",
+      message: {
+        id: "msg_capture_stream_01",
+        type: "message",
+        role: "assistant",
+        model,
+        content: [],
+        stop_reason: null,
+        stop_sequence: null,
+        usage: { input_tokens: 11, output_tokens: 1 }
+      }
+    }
+  });
+  evs.push({
+    event: "content_block_start",
+    data: {
+      type: "content_block_start",
+      index: 0,
+      content_block: withSignature ? { type: "thinking", thinking: "", signature: "" } : { type: "thinking", thinking: "" }
+    }
+  });
+  evs.push({ event: "ping", data: { type: "ping" } });
+  evs.push({
+    event: "content_block_delta",
+    data: { type: "content_block_delta", index: 0, delta: { type: "thinking_delta", thinking: "winter capture: weighing two options" } }
+  });
+  if (withSignature) {
+    evs.push({
+      event: "content_block_delta",
+      data: { type: "content_block_delta", index: 0, delta: { type: "signature_delta", signature: CAPTURE_STREAM_SIGNATURE } }
+    });
+  }
+  evs.push({ event: "content_block_stop", data: { type: "content_block_stop", index: 0 } });
+  evs.push({ event: "content_block_start", data: { type: "content_block_start", index: 1, content_block: { type: "text", text: "" } } });
+  evs.push({ event: "content_block_delta", data: { type: "content_block_delta", index: 1, delta: { type: "text_delta", text: "reading the " } } });
+  evs.push({ event: "content_block_delta", data: { type: "content_block_delta", index: 1, delta: { type: "text_delta", text: "capture fixture" } } });
+  evs.push({ event: "content_block_stop", data: { type: "content_block_stop", index: 1 } });
+  evs.push({
+    event: "content_block_start",
+    data: { type: "content_block_start", index: 2, content_block: { type: "tool_use", id: "toolu_capture_stream_01", name: "Read", input: {} } }
+  });
+  evs.push({
+    event: "content_block_delta",
+    data: { type: "content_block_delta", index: 2, delta: { type: "input_json_delta", partial_json: '{"file_path": ' } }
+  });
+  evs.push({
+    event: "content_block_delta",
+    data: { type: "content_block_delta", index: 2, delta: { type: "input_json_delta", partial_json: `${JSON.stringify(readTargetPath)}}` } }
+  });
+  evs.push({ event: "content_block_stop", data: { type: "content_block_stop", index: 2 } });
+  evs.push({
+    event: "message_delta",
+    data: { type: "message_delta", delta: { stop_reason: "tool_use", stop_sequence: null }, usage: { output_tokens: 42 } }
+  });
+  evs.push({ event: "message_stop", data: { type: "message_stop" } });
+  return evs;
+}
+function streamTurn2Events() {
+  const model = "claude-sonnet-4-5-20250929";
+  return [
+    {
+      event: "message_start",
+      data: {
+        type: "message_start",
+        message: { id: "msg_capture_stream_02", type: "message", role: "assistant", model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 20, output_tokens: 1 } }
+      }
+    },
+    { event: "content_block_start", data: { type: "content_block_start", index: 0, content_block: { type: "text", text: "" } } },
+    { event: "content_block_delta", data: { type: "content_block_delta", index: 0, delta: { type: "text_delta", text: "capture: stream round complete" } } },
+    { event: "content_block_stop", data: { type: "content_block_stop", index: 0 } },
+    { event: "message_delta", data: { type: "message_delta", delta: { stop_reason: "end_turn", stop_sequence: null }, usage: { output_tokens: 9 } } },
+    { event: "message_stop", data: { type: "message_stop" } }
+  ];
+}
+async function runStreamEventCapture(officialSdk, withSignature) {
+  const label = withSignature ? "signed" : "unsigned";
+  const cleanups = [];
+  let server;
+  try {
+    const dirs = makeScenarioDirs(`f-${label}`, cleanups);
+    const readTargetPath = join2(dirs.fixtureCwd, "capture-stream-fixture.txt");
+    writeFileSync2(readTargetPath, `winter capture fixture -- not real data
+`);
+    let requestCount = 0;
+    const envelopes = [];
+    const messageShapes = [];
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        const url = new URL(req.url);
+        let body;
+        try {
+          body = await req.json();
+        } catch {
+          console.error(`[loopback F/${label}] #${requestCount} ${req.method} ${url.pathname} (non-JSON body)`);
+          return jsonResponse(CANNED_TEXT_RESPONSE);
+        }
+        envelopes.push(requestEnvelopeShape(body));
+        messageShapes.push(messagesShape(body));
+        const sawToolResult = requestAlreadySawToolResult(body);
+        const wantsStream = body.stream === true;
+        console.error(`[loopback F/${label}] #${requestCount} ${req.method} ${url.pathname} stream=${wantsStream} sawToolResult=${sawToolResult}`);
+        if (!wantsStream)
+          return jsonResponse(sawToolResult ? CANNED_TEXT_AFTER_TOOL_RESPONSE : CANNED_TEXT_RESPONSE);
+        return sseResponse(sawToolResult ? streamTurn2Events() : streamTurn1Events(readTargetPath, withSignature));
+      }
+    });
+    console.error(`
+=== Scenario F (${label}): includePartialMessages over text + thinking + tool_use ===`);
+    console.error(`[capture F/${label}] loopback ${server.url.href}; CLAUDE_CONFIG_DIR=${dirs.claudeConfigDir} HOME=${dirs.homeDir} (fresh mkdtemp)`);
+    const entries = [];
+    const ac = new AbortController;
+    const q = officialSdk.query({
+      prompt: "please read the capture fixture file",
+      options: {
+        model: "sonnet",
+        cwd: dirs.fixtureCwd,
+        settingSources: [],
+        includePartialMessages: true,
+        thinking: { type: "enabled", budgetTokens: 1024 },
+        permissionMode: "bypassPermissions",
+        abortController: ac,
+        env: hermeticEnv(dirs, server.url.href)
+      }
+    });
+    const { thrown, deadlineHit } = await drainWithDeadline(q, entries, `capture F/${label}`, 120000, ac);
+    console.error(`[capture F/${label}] ${requestCount} loopback request(s); ${entries.length} message(s) yielded; deadlineHit=${deadlineHit}`);
+    if (thrown)
+      console.error(`[capture F/${label}] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    const normalized = normalizeTrace2(entries);
+    const streamEvents = entries.map((e) => e.payload).filter((p) => p.type === "stream_event");
+    console.log(`
+--- Scenario F (${label}) normalized trace ---`);
+    console.log(JSON.stringify(normalized, null, 2));
+    console.log(`
+--- Scenario F (${label}): the raw stream_event list, in order (event.type / delta.type / index) ---`);
+    console.log(JSON.stringify(streamEvents.map((p, i) => {
+      const ev = p.event;
+      const delta = ev?.delta;
+      const cb = ev?.content_block;
+      return {
+        i,
+        eventType: ev?.type,
+        index: ev?.index,
+        deltaType: delta?.type,
+        contentBlockType: cb?.type,
+        parent_tool_use_id: p.parent_tool_use_id,
+        hasUuid: typeof p.uuid === "string",
+        hasSessionId: typeof p.session_id === "string",
+        ttft_ms: p.ttft_ms,
+        user_message_uuid: p.user_message_uuid === undefined ? "(absent)" : "(present)"
+      };
+    }), null, 2));
+    console.log(`
+--- Scenario F (${label}): every stream_event's own top-level key set (union) ---`);
+    console.log(JSON.stringify([...new Set(streamEvents.flatMap((p) => Object.keys(p)))].sort(), null, 2));
+    console.log(`
+--- Scenario F (${label}): request envelope shapes (item (c) wire spelling of ThinkingConfig) ---`);
+    console.log(JSON.stringify(envelopes, null, 2));
+    console.log(`
+--- Scenario F (${label}): request messages SHAPE ONLY (item (f) — does the thinking block survive replay?) ---`);
+    console.log(JSON.stringify(messageShapes, null, 2));
+    console.log(`
+--- Scenario F (${label}) verdicts ---`);
+    console.log(JSON.stringify({
+      "stream_event frames observed": streamEvents.length,
+      "distinct event.type values, in first-seen order": [...new Set(streamEvents.map((p) => p.event?.type))],
+      "did a ping reach the consumer?": streamEvents.some((p) => p.event?.type === "ping"),
+      "frames carrying user_message_uuid": streamEvents.filter((p) => p.user_message_uuid !== undefined).length,
+      "frames carrying ttft_ms": streamEvents.filter((p) => p.ttft_ms !== undefined).length,
+      "completed assistant frames": entries.filter((e) => e.payload.type === "assistant").length,
+      "query() threw": describeThrown(thrown) ?? false,
+      deadlineHit
+    }, null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+async function runRetryCapture(officialSdk, policy) {
+  const cleanups = [];
+  let server;
+  const failingPostsBeforeSuccess = 2;
+  try {
+    const dirs = makeScenarioDirs(`g-${policy}`, cleanups);
+    let requestCount = 0;
+    let postCount = 0;
+    const requestLog = [];
+    const t0 = Date.now();
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        const n = requestCount;
+        let body;
+        try {
+          body = await req.json();
+        } catch {
+          body = {};
+        }
+        const model = body.model;
+        requestLog.push({ n, model, atMs: Date.now() - t0 });
+        const url = new URL(req.url);
+        const isPost = req.method === "POST";
+        if (isPost)
+          postCount++;
+        console.error(`[loopback G/${policy}] #${n} (POST #${isPost ? postCount : "-"}) ${req.method} ${url.pathname} model=${JSON.stringify(model)} t+${Date.now() - t0}ms`);
+        if (policy === "overloaded-then-ok") {
+          if (isPost && postCount <= failingPostsBeforeSuccess)
+            return jsonResponse({ type: "error", error: { type: "overloaded_error", message: "capture: synthetic overload" } }, 529);
+          return jsonResponse(CANNED_TEXT_RESPONSE);
+        }
+        if (policy === "ratelimit-then-ok") {
+          if (isPost && postCount <= failingPostsBeforeSuccess) {
+            return jsonResponse({ type: "error", error: { type: "rate_limit_error", message: "capture: synthetic rate limit" } }, 429, {
+              "retry-after": "2",
+              "anthropic-ratelimit-requests-limit": "1000",
+              "anthropic-ratelimit-requests-remaining": "0",
+              "anthropic-ratelimit-requests-reset": new Date(Date.now() + 2000).toISOString(),
+              "anthropic-ratelimit-unified-status": "rejected",
+              "anthropic-ratelimit-unified-reset": new Date(Date.now() + 2000).toISOString()
+            });
+          }
+          return jsonResponse(CANNED_TEXT_RESPONSE);
+        }
+        return jsonResponse({ type: "error", error: { type: "overloaded_error", message: "capture: synthetic persistent overload" } }, 529);
+      }
+    });
+    console.error(`
+=== Scenario G (${policy}): api_retry / rate_limit_event / fallback ===`);
+    console.error(`[capture G/${policy}] loopback ${server.url.href}; CLAUDE_CONFIG_DIR=${dirs.claudeConfigDir} HOME=${dirs.homeDir} (fresh mkdtemp)`);
+    const entries = [];
+    const ac = new AbortController;
+    const q = officialSdk.query({
+      prompt: "hi",
+      options: {
+        model: "sonnet",
+        cwd: dirs.fixtureCwd,
+        settingSources: [],
+        abortController: ac,
+        ...policy === "persistent-overloaded" ? { fallbackModel: "haiku" } : {},
+        env: hermeticEnv(dirs, server.url.href)
+      }
+    });
+    const { thrown, deadlineHit } = await drainWithDeadline(q, entries, `capture G/${policy}`, 180000, ac);
+    console.error(`[capture G/${policy}] ${requestCount} loopback request(s); ${entries.length} message(s) yielded; deadlineHit=${deadlineHit}`);
+    if (thrown)
+      console.error(`[capture G/${policy}] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    const payloads = entries.map((e) => e.payload);
+    const retries = payloads.filter((p) => p.type === "system" && p.subtype === "api_retry");
+    const rateLimits = payloads.filter((p) => p.type === "rate_limit_event");
+    const refusals = payloads.filter((p) => p.type === "system" && (p.subtype === "model_refusal_fallback" || p.subtype === "model_refusal_no_fallback"));
+    const results = payloads.filter((p) => p.type === "result");
+    console.log(`
+--- Scenario G (${policy}) normalized trace ---`);
+    console.log(JSON.stringify(normalizeTrace2(entries), null, 2));
+    console.log(`
+--- Scenario G (${policy}): every api_retry frame, verbatim ---`);
+    console.log(JSON.stringify(retries, null, 2));
+    console.log(`
+--- Scenario G (${policy}): every rate_limit_event frame ---`);
+    console.log(JSON.stringify(rateLimits.length > 0 ? rateLimits : "(none observed)", null, 2));
+    const prosefreeRefusals = refusals.map((r) => {
+      const out = { ...r };
+      for (const k of ["content", "api_refusal_explanation"]) {
+        const v = out[k];
+        if (typeof v === "string")
+          out[k] = `<${v.length} chars, withheld: vendor prose>`;
+      }
+      return out;
+    });
+    console.log(`
+--- Scenario G (${policy}): every refusal/fallback frame (prose fields as lengths) ---`);
+    console.log(JSON.stringify(prosefreeRefusals.length > 0 ? prosefreeRefusals : "(none observed)", null, 2));
+    console.log(`
+--- Scenario G (${policy}): the model on each outgoing request, with arrival times ---`);
+    console.log(JSON.stringify(requestLog, null, 2));
+    console.log(`
+--- Scenario G (${policy}) verdicts ---`);
+    console.log(JSON.stringify({
+      "api_retry frames": retries.length,
+      "attempt / max_retries / retry_delay_ms / error_status / error": retries.map((r) => ({
+        attempt: r.attempt,
+        max_retries: r.max_retries,
+        retry_delay_ms: r.retry_delay_ms,
+        error_status: r.error_status,
+        error: r.error
+      })),
+      "rate_limit_event frames": rateLimits.length,
+      "refusal/fallback frames": refusals.map((r) => r.subtype),
+      "distinct models the loopback was asked for": [...new Set(requestLog.map((r) => String(r.model)))],
+      "result subtype / is_error": results.map((r) => ({ subtype: r.subtype, is_error: r.is_error, api_error_status: r.api_error_status, terminal_reason: r.terminal_reason })),
+      "query() threw": describeThrown(thrown) ?? false,
+      deadlineHit
+    }, null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+function findFileRecursive(root, predicate, depth = 0) {
+  if (depth > 6)
+    return [];
+  const out = [];
+  let names;
+  try {
+    names = readdirSync(root);
+  } catch {
+    return out;
+  }
+  for (const name of names) {
+    const full = join2(root, name);
+    let isDir = false;
+    try {
+      isDir = statSync(full).isDirectory();
+    } catch {
+      continue;
+    }
+    if (isDir)
+      out.push(...findFileRecursive(full, predicate, depth + 1));
+    else if (predicate(name, full))
+      out.push(full);
+  }
+  return out;
+}
+function sha256OfFile(path) {
+  return createHash2("sha256").update(readFileSync2(path)).digest("hex");
+}
+function sha256AtPath(path) {
+  try {
+    return sha256OfFile(path);
+  } catch {
+    return "(ABSENT AT ITS OWN PATH — ASSERTION FAILED)";
+  }
+}
+function countLinesAtPath(path) {
+  try {
+    return readFileSync2(path, "utf8").split(`
+`).filter((l) => l.trim().length > 0).length;
+  } catch {
+    return -1;
+  }
+}
+async function runNeighborFileProbe(officialSdk) {
+  const cleanups = [];
+  let server;
+  try {
+    const dirs = makeScenarioDirs("h", cleanups);
+    const sessionId = "0192f4c8-6f21-7c3a-9d55-1b8e2a7c40d1";
+    const marker = `WINTER-PROVIDER-STATE-MARKER-${createHash2("sha256").update(sessionId).digest("hex").slice(0, 32)}`;
+    let requestCount = 0;
+    let markerSeenInAnyRequestBody = false;
+    const requestPaths = [];
+    let bulkyReplies = false;
+    const BULK_TEXT = "winter capture filler sentence for the compaction threshold. ".repeat(700);
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        const url = new URL(req.url);
+        requestPaths.push(`${req.method} ${url.pathname}`);
+        let raw = "";
+        try {
+          raw = await req.clone().text();
+        } catch {}
+        if (raw.includes(marker))
+          markerSeenInAnyRequestBody = true;
+        console.error(`[loopback H] #${requestCount} ${req.method} ${url.pathname} bodyBytes=${raw.length} markerPresent=${raw.includes(marker)}`);
+        if (!bulkyReplies)
+          return jsonResponse(CANNED_TEXT_RESPONSE);
+        return jsonResponse({
+          ...CANNED_TEXT_RESPONSE,
+          content: [{ type: "text", text: BULK_TEXT }],
+          usage: { input_tokens: 12000, output_tokens: 12000 }
+        });
+      }
+    });
+    console.error(`
+=== Scenario H: WS-17 probe (a) — neighbour-file survival across resume ===`);
+    console.error(`[capture H] loopback ${server.url.href}; CLAUDE_CONFIG_DIR=${dirs.claudeConfigDir} HOME=${dirs.homeDir} cwd=${dirs.fixtureCwd} (all fresh mkdtemp, REUSED across runs)`);
+    const entries1 = [];
+    const ac1 = new AbortController;
+    const r1 = await drainWithDeadline(officialSdk.query({
+      prompt: "hi from run one",
+      options: { model: "sonnet", cwd: dirs.fixtureCwd, settingSources: [], sessionId, abortController: ac1, env: hermeticEnv(dirs, server.url.href) }
+    }), entries1, "capture H/run1", 120000, ac1);
+    const init1 = entries1.map((e) => e.payload).find((p) => p.type === "system" && p.subtype === "init");
+    console.error(`[capture H] run 1: ${entries1.length} message(s); session_id on init = ${String(init1?.session_id)}`);
+    if (r1.thrown)
+      console.error(`[capture H] run 1 threw: ${r1.thrown instanceof Error ? r1.thrown.stack ?? r1.thrown.message : String(r1.thrown)}`);
+    const observedSessionId = typeof init1?.session_id === "string" ? init1.session_id : sessionId;
+    const transcripts = findFileRecursive(dirs.claudeConfigDir, (name) => name === `${observedSessionId}.jsonl`);
+    console.error(`[capture H] transcript search under <CLAUDE_CONFIG_DIR> found ${transcripts.length} match(es)`);
+    if (transcripts.length === 0) {
+      console.log(`
+--- Scenario H: NOT CAPTURABLE — no <sessionId>.jsonl transcript was written under <CLAUDE_CONFIG_DIR> after run 1 ---`);
+      console.log(JSON.stringify({ observedSessionId, filesUnderConfigDir: findFileRecursive(dirs.claudeConfigDir, () => true).map((f) => f.replace(dirs.claudeConfigDir, "<CLAUDE_CONFIG_DIR>")) }, null, 2));
+      return;
+    }
+    const transcriptPath = transcripts[0];
+    const projectDir = dirname(transcriptPath);
+    const namesBefore = readdirSync(projectDir).sort();
+    const sidecarPath = join2(projectDir, `${observedSessionId}.provider-state.jsonl`);
+    const sidecarLines = [
+      { type: "provider-state", kind: "origin", sessionId: observedSessionId, anchorUuid: "00000000-0000-4000-8000-000000000001", provider: "winter-capture", model: "winter-capture-model", family: "capture", itemIndex: 0, marker, payload: {} },
+      { type: "provider-state", kind: "native-state", sessionId: observedSessionId, anchorUuid: "00000000-0000-4000-8000-000000000001", itemIndex: 1, marker, payload: { opaque: marker } },
+      { type: "provider-state", kind: "summary", sessionId: observedSessionId, anchorUuid: "00000000-0000-4000-8000-000000000001", itemIndex: 2, marker, payload: { text: "capture-only summary" } }
+    ];
+    writeFileSync2(sidecarPath, sidecarLines.map((l) => JSON.stringify(l)).join(`
+`) + `
+`);
+    const sidecarSha256Before = sha256AtPath(sidecarPath);
+    const sidecarBytesBefore = readFileSync2(sidecarPath).length;
+    const transcriptLinesBefore = countLinesAtPath(transcriptPath);
+    console.error(`[capture H] sidecar written beside the transcript: ${sidecarBytesBefore} bytes, sha256=${sidecarSha256Before}`);
+    const entries2 = [];
+    let r2 = { thrown: undefined, deadlineHit: false };
+    const appendTurns = 6;
+    bulkyReplies = true;
+    for (let turn = 0;turn < appendTurns; turn++) {
+      const ac2 = new AbortController;
+      const r = await drainWithDeadline(officialSdk.query({
+        prompt: `hi from append turn ${turn + 1}`,
+        options: { model: "sonnet", cwd: dirs.fixtureCwd, settingSources: [], resume: observedSessionId, abortController: ac2, env: hermeticEnv(dirs, server.url.href) }
+      }), entries2, `capture H/run2.${turn + 1}`, 120000, ac2);
+      if (r.thrown !== undefined)
+        r2 = { thrown: r.thrown, deadlineHit: r2.deadlineHit || r.deadlineHit };
+      else
+        r2 = { thrown: r2.thrown, deadlineHit: r2.deadlineHit || r.deadlineHit };
+      if (r.thrown)
+        console.error(`[capture H] append turn ${turn + 1} threw: ${r.thrown instanceof Error ? r.thrown.stack ?? r.thrown.message : String(r.thrown)}`);
+    }
+    const init2 = entries2.map((e) => e.payload).find((p) => p.type === "system" && p.subtype === "init");
+    const sidecarSha256AfterResume = sha256AtPath(sidecarPath);
+    const transcriptLinesAfterResume = countLinesAtPath(transcriptPath);
+    console.error(`[capture H] after ${appendTurns} append turns: transcript ${transcriptLinesBefore} -> ${transcriptLinesAfterResume} lines; sidecar sha256=${sidecarSha256AfterResume}`);
+    const entries3 = [];
+    const ac3 = new AbortController;
+    const r3 = await drainWithDeadline(officialSdk.query({
+      prompt: "/compact",
+      options: { model: "sonnet", cwd: dirs.fixtureCwd, settingSources: [], resume: observedSessionId, abortController: ac3, env: hermeticEnv(dirs, server.url.href) }
+    }), entries3, "capture H/run3", 120000, ac3);
+    const payloads3 = entries3.map((e) => e.payload);
+    if (r3.thrown)
+      console.error(`[capture H] run 3 (/compact) threw: ${r3.thrown instanceof Error ? r3.thrown.stack ?? r3.thrown.message : String(r3.thrown)}`);
+    const sidecarSha256After = sha256AtPath(sidecarPath);
+    const sidecarFoundElsewhere = findFileRecursive(dirs.claudeConfigDir, (name) => name === `${observedSessionId}.provider-state.jsonl`).map((f) => f.replace(dirs.claudeConfigDir, "<CLAUDE_CONFIG_DIR>"));
+    const namesAfter = readdirSync(projectDir).sort();
+    let transcriptParses = true;
+    let transcriptLinesAfter = 0;
+    try {
+      for (const line of readFileSync2(transcriptPath, "utf8").split(`
+`)) {
+        if (line.trim().length === 0)
+          continue;
+        JSON.parse(line);
+        transcriptLinesAfter++;
+      }
+    } catch {
+      transcriptParses = false;
+      transcriptLinesAfter = -1;
+    }
+    console.log(`
+--- Scenario H: WS-17 probe (a) verdicts (R6-7 / R6-7a) ---`);
+    console.log(JSON.stringify({
+      sessionIdRequested: sessionId,
+      sessionIdObservedOnInit: observedSessionId,
+      "run 2 resumed the same session": init2?.session_id === observedSessionId,
+      transcriptPath: transcriptPath.replace(dirs.claudeConfigDir, "<CLAUDE_CONFIG_DIR>"),
+      sidecarPath: sidecarPath.replace(dirs.claudeConfigDir, "<CLAUDE_CONFIG_DIR>"),
+      appendTurnsDriven: appendTurns,
+      "ASSERTION 1 — sidecar sha256 unchanged": sidecarSha256Before === sidecarSha256After,
+      "ASSERTION 1a — unchanged after the resume+append half alone": sidecarSha256Before === sidecarSha256AfterResume,
+      sidecarSha256Before,
+      sidecarSha256AfterResume,
+      sidecarSha256After,
+      transcriptLinesAfterResume,
+      sidecarBytesBefore,
+      sidecarBytesAfter: (() => {
+        try {
+          return readFileSync2(sidecarPath).length;
+        } catch {
+          return null;
+        }
+      })(),
+      "sidecar found elsewhere under <CLAUDE_CONFIG_DIR> (diagnostic only — never rescues the assertion)": sidecarFoundElsewhere.length === 1 && sidecarFoundElsewhere[0]?.endsWith(`${observedSessionId}.provider-state.jsonl`) && sidecarSha256After.startsWith("(") === false ? "(at its own path, as expected)" : sidecarFoundElsewhere,
+      "ASSERTION 2 — marker absent from EVERY request body": !markerSeenInAnyRequestBody,
+      "ASSERTION 3 — transcript still parses as JSONL": transcriptParses,
+      transcriptLinesBefore,
+      transcriptLinesAfter,
+      "transcript grew across resume": transcriptLinesAfter > transcriptLinesBefore,
+      "project dir file NAMES before the resume": namesBefore,
+      "project dir file NAMES after the resume + compact": namesAfter,
+      "names added": namesAfter.filter((n) => !namesBefore.includes(n)),
+      "names removed": namesBefore.filter((n) => !namesAfter.includes(n)),
+      "run 3 (/compact): message kinds": payloads3.map((p) => p.type === "system" ? `system/${p.subtype}` : p.type),
+      "run 3 (/compact): a compact_boundary frame appeared": payloads3.some((p) => p.type === "system" && p.subtype === "compact_boundary"),
+      "run 3 threw": describeThrown(r3.thrown) ?? false,
+      "loopback saw": requestPaths,
+      "deadlines hit (run1/run2/run3)": [r1.deadlineHit, r2.deadlineHit, r3.deadlineHit]
+    }, null, 2));
+    console.log(`
+--- Scenario H: run 2 normalized trace ---`);
+    console.log(JSON.stringify(normalizeTrace2(entries2), null, 2));
+    console.log(`
+--- Scenario H: run 3 (/compact) normalized trace ---`);
+    console.log(JSON.stringify(normalizeTrace2(entries3), null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+async function runFailureShapeCapture(officialSdk, variant) {
+  const cleanups = [];
+  let server;
+  try {
+    const dirs = makeScenarioDirs(`i-${variant}`, cleanups);
+    let requestCount = 0;
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      fetch(req) {
+        requestCount++;
+        const url = new URL(req.url);
+        console.error(`[loopback I/${variant}] #${requestCount} ${req.method} ${url.pathname}`);
+        if (variant === "unknown-model") {
+          return jsonResponse({ type: "error", error: { type: "not_found_error", message: "capture: synthetic unknown model" } }, 404);
+        }
+        return jsonResponse(CANNED_TEXT_RESPONSE);
+      }
+    });
+    console.error(`
+=== Scenario I (${variant}): the failure shape ===`);
+    console.error(`[capture I/${variant}] loopback ${server.url.href}; CLAUDE_CONFIG_DIR=${dirs.claudeConfigDir} HOME=${dirs.homeDir} (fresh mkdtemp)`);
+    const fullEnv = hermeticEnv(dirs, server.url.href);
+    const env = { ...fullEnv };
+    if (variant === "no-key") {
+      delete env.ANTHROPIC_API_KEY;
+      console.error(`[capture I/no-key] the child env is EXACTLY ${JSON.stringify(Object.keys(env).sort())} — no API key of any kind`);
+    }
+    const entries = [];
+    const ac = new AbortController;
+    const q = officialSdk.query({
+      prompt: "hi",
+      options: {
+        model: variant === "unknown-model" ? "definitely-not-a-model" : "sonnet",
+        cwd: dirs.fixtureCwd,
+        settingSources: [],
+        abortController: ac,
+        env
+      }
+    });
+    const { thrown, deadlineHit } = await drainWithDeadline(q, entries, `capture I/${variant}`, 90000, ac);
+    const payloads = entries.map((e) => e.payload);
+    const init = payloads.find((p) => p.type === "system" && p.subtype === "init");
+    const auth = payloads.filter((p) => p.type === "auth_status");
+    const results = payloads.filter((p) => p.type === "result");
+    console.error(`[capture I/${variant}] ${requestCount} loopback request(s); ${entries.length} message(s) yielded; deadlineHit=${deadlineHit}`);
+    console.log(`
+--- Scenario I (${variant}) normalized trace ---`);
+    console.log(JSON.stringify(normalizeTrace2(entries), null, 2));
+    console.log(`
+--- Scenario I (${variant}) verdicts ---`);
+    console.log(JSON.stringify({
+      "messages yielded": entries.length,
+      "loopback requests": requestCount,
+      "system/init observed": init !== undefined,
+      "init.apiKeySource": init?.apiKeySource ?? "(no init frame)",
+      "init.model": init?.model ?? "(no init frame)",
+      "auth_status frames": auth.length,
+      "auth_status payloads": auth.length > 0 ? auth : "(none)",
+      "result frames": results.map((r) => ({
+        subtype: r.subtype,
+        is_error: r.is_error,
+        api_error_status: r.api_error_status,
+        terminal_reason: r.terminal_reason,
+        num_turns: r.num_turns,
+        total_cost_usd: r.total_cost_usd,
+        "result string length": typeof r.result === "string" ? r.result.length : null
+      })),
+      "query() threw": describeThrown(thrown) ?? false,
+      deadlineHit
+    }, null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+async function runModelControlCapture(officialSdk) {
+  const cleanups = [];
+  let server;
+  try {
+    const dirs = makeScenarioDirs("j", cleanups);
+    let requestCount = 0;
+    const requestPaths = [];
+    const modelsAsked = [];
+    let releaseGate = () => {};
+    const gate = new Promise((resolve) => {
+      releaseGate = resolve;
+    });
+    const gateTimer = setTimeout(() => releaseGate(), 60000);
+    cleanups.push(() => clearTimeout(gateTimer));
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        const url = new URL(req.url);
+        requestPaths.push(`${req.method} ${url.pathname}`);
+        try {
+          modelsAsked.push((await req.json()).model);
+        } catch {
+          modelsAsked.push(null);
+        }
+        console.error(`[loopback J] #${requestCount} ${req.method} ${url.pathname} model=${JSON.stringify(modelsAsked[modelsAsked.length - 1])} (holding behind the control-call gate)`);
+        await gate;
+        return jsonResponse(CANNED_TEXT_RESPONSE);
+      }
+    });
+    console.error(`
+=== Scenario J: supportedModels() / setModel() ===`);
+    console.error(`[capture J] loopback ${server.url.href}; CLAUDE_CONFIG_DIR=${dirs.claudeConfigDir} HOME=${dirs.homeDir} (fresh mkdtemp)`);
+    const entries = [];
+    const ac = new AbortController;
+    const q = officialSdk.query({
+      prompt: "hi",
+      options: { model: "sonnet", cwd: dirs.fixtureCwd, settingSources: [], abortController: ac, env: hermeticEnv(dirs, server.url.href) }
+    });
+    const drained = drainWithDeadline(q, entries, "capture J", 120000, ac);
+    const withTimeout = async (p, ms) => {
+      let timer;
+      try {
+        const value = await Promise.race([
+          p,
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`capture J: control call timed out after ${ms}ms`)), ms);
+          })
+        ]);
+        return { ok: true, value };
+      } catch (e) {
+        return { ok: false, error: e };
+      } finally {
+        if (timer !== undefined)
+          clearTimeout(timer);
+      }
+    };
+    const modelsResult = typeof q.supportedModels === "function" ? await withTimeout(q.supportedModels(), 45000) : { ok: false, error: new Error("supportedModels is not a function on the returned query") };
+    const setModelResult = typeof q.setModel === "function" ? await withTimeout(q.setModel("haiku"), 45000) : { ok: false, error: new Error("setModel is not a function on the returned query") };
+    const accountResult = typeof q.accountInfo === "function" ? await withTimeout(q.accountInfo(), 45000) : { ok: false, error: new Error("accountInfo is not a function on the returned query") };
+    releaseGate();
+    const { thrown, deadlineHit } = await drained;
+    const models = modelsResult.ok ? modelsResult.value : [];
+    console.error(`[capture J] ${requestCount} loopback request(s); ${entries.length} message(s) yielded; deadlineHit=${deadlineHit}`);
+    if (thrown)
+      console.error(`[capture J] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    console.log(`
+--- Scenario J: supportedModels() return shape ---`);
+    console.log(JSON.stringify(modelsResult.ok ? {
+      isArray: Array.isArray(models),
+      count: Array.isArray(models) ? models.length : null,
+      "union of row key names": Array.isArray(models) ? [...new Set(models.flatMap((m) => Object.keys(m)))].sort() : null,
+      "every row, prose stripped": Array.isArray(models) ? models.map((m) => {
+        const row = m;
+        return {
+          ...row,
+          displayName: typeof row.displayName === "string" ? `<${row.displayName.length} chars>` : row.displayName,
+          description: typeof row.description === "string" ? `<${row.description.length} chars>` : row.description
+        };
+      }) : null
+    } : { threw: describeThrown(modelsResult.error) }, null, 2));
+    console.log(`
+--- Scenario J: setModel("haiku") outcome ---`);
+    console.log(JSON.stringify(setModelResult.ok ? { resolved: true, value: setModelResult.value } : { threw: describeThrown(setModelResult.error) }, null, 2));
+    console.log(`
+--- Scenario J: accountInfo() outcome (item (d) — the account surface a query() stream never carries) ---`);
+    console.log(JSON.stringify(accountResult.ok ? { resolved: true, "key names present": Object.keys(accountResult.value ?? {}).sort() } : { threw: describeThrown(accountResult.error) }, null, 2));
+    console.log(`
+--- Scenario J verdicts ---`);
+    console.log(JSON.stringify({
+      "every request path the loopback saw": requestPaths,
+      "the model on each request (did setModel take effect on the wire?)": modelsAsked,
+      "did any /v1/models request reach the loopback?": requestPaths.some((p) => p.includes("/models")),
+      "system/init.model": entries.map((e) => e.payload).find((p) => p.type === "system" && p.subtype === "init")?.model ?? "(no init frame)",
+      "query() threw": describeThrown(thrown) ?? false,
+      deadlineHit
+    }, null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+async function runCostCapture(officialSdk) {
+  const cleanups = [];
+  let server;
+  const fakeModel = "winter-capture-fake-model-1";
+  try {
+    const dirs = makeScenarioDirs("k", cleanups);
+    let requestCount = 0;
+    const modelsAsked = [];
+    server = Bun.serve({
+      port: 0,
+      hostname: "127.0.0.1",
+      async fetch(req) {
+        requestCount++;
+        let body = {};
+        try {
+          body = await req.json();
+        } catch {}
+        modelsAsked.push(body.model);
+        const url = new URL(req.url);
+        console.error(`[loopback K] #${requestCount} ${req.method} ${url.pathname} model=${JSON.stringify(body.model)}`);
+        return jsonResponse({
+          id: "msg_capture_cost_01",
+          type: "message",
+          role: "assistant",
+          model: fakeModel,
+          content: [{ type: "text", text: "echo: cost" }],
+          stop_reason: "end_turn",
+          stop_sequence: null,
+          usage: { input_tokens: 17, output_tokens: 5, cache_read_input_tokens: 3, cache_creation_input_tokens: 2 }
+        });
+      }
+    });
+    console.error(`
+=== Scenario K: total_cost_usd / modelUsage / costBasis for a fake model id ===`);
+    console.error(`[capture K] loopback ${server.url.href}; CLAUDE_CONFIG_DIR=${dirs.claudeConfigDir} HOME=${dirs.homeDir} (fresh mkdtemp)`);
+    const entries = [];
+    const ac = new AbortController;
+    const q = officialSdk.query({
+      prompt: "hi",
+      options: { model: fakeModel, cwd: dirs.fixtureCwd, settingSources: [], abortController: ac, env: hermeticEnv(dirs, server.url.href) }
+    });
+    const { thrown, deadlineHit } = await drainWithDeadline(q, entries, "capture K", 90000, ac);
+    const payloads = entries.map((e) => e.payload);
+    const result = payloads.find((p) => p.type === "result");
+    const modelUsage = result?.modelUsage ?? {};
+    console.error(`[capture K] ${requestCount} loopback request(s); ${entries.length} message(s) yielded; deadlineHit=${deadlineHit}`);
+    if (thrown)
+      console.error(`[capture K] query() threw: ${thrown instanceof Error ? thrown.stack ?? thrown.message : String(thrown)}`);
+    console.log(`
+--- Scenario K normalized trace ---`);
+    console.log(JSON.stringify(normalizeTrace2(entries), null, 2));
+    console.log(`
+--- Scenario K verdicts ---`);
+    console.log(JSON.stringify({
+      "option model / response model / models the loopback was asked for": { option: fakeModel, response: fakeModel, requested: modelsAsked },
+      "system/init.model": payloads.find((p) => p.type === "system" && p.subtype === "init")?.model ?? "(no init frame)",
+      "result subtype / is_error": { subtype: result?.subtype, is_error: result?.is_error },
+      total_cost_usd: result?.total_cost_usd,
+      "modelUsage KEYS": Object.keys(modelUsage),
+      "modelUsage rows": modelUsage,
+      "costBasis per row": Object.fromEntries(Object.entries(modelUsage).map(([k, v]) => [k, v.costBasis ?? "(absent)"])),
+      "usage (NonNullableUsage) key names — the only pinned way to learn them": Object.keys(result?.usage ?? {}).sort(),
+      usage: result?.usage,
+      "query() threw": describeThrown(thrown) ?? false,
+      deadlineHit
+    }, null, 2));
+  } finally {
+    server?.stop(true);
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+async function runCapture2() {
+  requireBunRuntime2("runCapture", "Bun.spawn and Bun.serve", "It installs the pinned official SDK into a throwaway npm prefix and drives it against loopback fakes. Run the capture under Bun (`bun run scripts/capture-official-golden.ts`); the GOLDENS it produces are plain JSON and are readable from Node.");
+  const only = (process.env.RUN_OFFICIAL_CAPTURE_ONLY ?? "").split(",").map((s) => s.trim().toUpperCase()).filter((s) => s.length > 0);
+  const want = (letter) => only.length === 0 || only.includes(letter);
+  const cleanups = [];
+  try {
+    const officialSdk = await installOfficialSdk(cleanups);
+    if (want("A"))
+      await runPlainQueryCapture(officialSdk);
+    if (want("B"))
+      await runPermissionsAndHooksCapture(officialSdk);
+    if (want("C"))
+      await runInitToolsCapture(officialSdk);
+    if (want("D"))
+      await runAdvertisedSchemaCapture(officialSdk);
+    if (want("E")) {
+      await runMcpOutputCapCapture(officialSdk, undefined);
+      await runMcpOutputCapCapture(officialSdk, "100");
+    }
+    if (want("F")) {
+      await runStreamEventCapture(officialSdk, true);
+      await runStreamEventCapture(officialSdk, false);
+    }
+    if (want("G")) {
+      await runRetryCapture(officialSdk, "overloaded-then-ok");
+      await runRetryCapture(officialSdk, "ratelimit-then-ok");
+      await runRetryCapture(officialSdk, "persistent-overloaded");
+    }
+    if (want("H"))
+      await runNeighborFileProbe(officialSdk);
+    if (want("I")) {
+      await runFailureShapeCapture(officialSdk, "no-key");
+      await runFailureShapeCapture(officialSdk, "unknown-model");
+    }
+    if (want("J"))
+      await runModelControlCapture(officialSdk);
+    if (want("K"))
+      await runCostCapture(officialSdk);
+  } finally {
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+}
+export { BunRequiredError2, hasBunRuntime2, requireBunRuntime2, ChecksumMismatchError2, OfficialCompatUnavailableError2, getChecksums2, verifyDigest2, verifySha512Integrity2, resolveCacheDir2, fetchAndVerifyUpstream2, runCapture2 };