muonroi-cli 1.3.4 → 1.4.1

package/src/orchestrator/subagent-compactor.ts

@@ -1,242 +0,0 @@
-/**
- * src/orchestrator/subagent-compactor.ts
- *
- * Phase B3 — in-loop message compaction for the sub-agent `streamText` call.
- *
- * Background:
- *   `wrapToolSetWithCap` (sub-agent-cap.ts) caps the SIZE of any one tool
- *   result and the CUMULATIVE chars of all results returned to the agent in
- *   one invocation. It does NOT prevent the AI SDK from re-sending every
- *   prior tool result on each subsequent round.
- *
- *   Concretely, on round N the prompt sent to the provider contains:
- *     system + user + [assistant tool-call, tool result] x (N-1)
- *
- *   Even with each tool result already trimmed to a few KB, 10+ rounds of
- *   accumulated history pushes billed input tokens into the hundreds of
- *   thousands. Session 7d36a8d94622 logged 324k cumulative input across 12
- *   rounds — the smoking gun for Phase B3.
- *
- * Fix:
- *   AI SDK v6's `streamText` accepts a `prepareStep({ messages, stepNumber })`
- *   callback that fires before each step and lets us return a rewritten
- *   `messages` array for that step. We use it to compact older tool results
- *   into short summary stubs while preserving:
- *     - All system messages verbatim
- *     - The first user message verbatim (the original task)
- *     - The last N tool-call/tool-result turns verbatim (default 3)
- *
- * Strategy details:
- *   A "tool turn" is a contiguous block of assistant messages that end with a
- *   tool-call and the immediately-following tool message(s) that carry the
- *   matching tool-result parts. We keep the trailing `keepLastTurns` turns
- *   intact and rewrite every earlier tool-result part to:
- *     [earlier tool_result for tool=X (id=Y) — N chars elided by sub-agent
- *      compactor; output: <first 200 chars>]
- *
- *   Assistant tool-call parts and free-form assistant text are kept as-is —
- *   the model needs the call shape to maintain coherent self-context, and
- *   text is usually small.
- *
- * Trigger:
- *   Only run when the cumulative char count of all message content exceeds
- *   the threshold (default 80_000 chars). Below the threshold compaction is
- *   a no-op (messages returned by identity).
- *
- * Env overrides:
- *   MUONROI_SUBAGENT_COMPACT_THRESHOLD_CHARS — 20_000..500_000, default 80_000
- *   MUONROI_SUBAGENT_COMPACT_KEEP_LAST       — 1..20,           default 3
- */
-
-import type { ModelMessage } from "ai";
-
-export interface SubAgentCompactorOptions {
-  /** Cumulative message-content char count above which compaction kicks in. */
-  thresholdChars?: number;
-  /** Number of trailing tool turns kept verbatim. */
-  keepLastTurns?: number;
-  /** First-N chars of the elided tool output preserved in the stub. */
-  outputPreviewChars?: number;
-  /**
-   * Label embedded in the stub text. Default "sub-agent" (B3 path). Set to
-   * "top-level" when the top-level orchestrator loop reuses this compactor
-   * (B4). The label is read by the LLM, not by code — it just helps the
-   * model understand which loop elided the content.
-   */
-  label?: string;
-}
-
-export const SUBAGENT_COMPACT_DEFAULT_THRESHOLD = 80_000;
-export const SUBAGENT_COMPACT_DEFAULT_KEEP_LAST = 3;
-const DEFAULT_OUTPUT_PREVIEW_CHARS = 200;
-const DEFAULT_LABEL = "sub-agent";
-
-interface ResolvedOpts {
-  thresholdChars: number;
-  keepLastTurns: number;
-  outputPreviewChars: number;
-  label: string;
-}
-
-function resolveOpts(o: SubAgentCompactorOptions | undefined): ResolvedOpts {
-  return {
-    thresholdChars: o?.thresholdChars ?? SUBAGENT_COMPACT_DEFAULT_THRESHOLD,
-    keepLastTurns: Math.max(0, o?.keepLastTurns ?? SUBAGENT_COMPACT_DEFAULT_KEEP_LAST),
-    outputPreviewChars: o?.outputPreviewChars ?? DEFAULT_OUTPUT_PREVIEW_CHARS,
-    label: o?.label ?? DEFAULT_LABEL,
-  };
-}
-
-/** Approximate char cost of one ModelMessage's content. Mirrors recording.ts. */
-function messageChars(msg: ModelMessage): number {
-  const content = msg.content;
-  if (typeof content === "string") return content.length;
-  if (!Array.isArray(content)) return 0;
-  let n = 0;
-  for (const part of content as ReadonlyArray<Record<string, unknown>>) {
-    const t = part.type as string | undefined;
-    if (t === "text") n += (part.text as string | undefined)?.length ?? 0;
-    else if (t === "reasoning") n += (part.text as string | undefined)?.length ?? 0;
-    else if (t === "tool-call") {
-      const input = part.input;
-      n += typeof input === "string" ? input.length : JSON.stringify(input ?? "").length;
-      n += (part.toolName as string | undefined)?.length ?? 0;
-    } else if (t === "tool-result") {
-      const output = part.output;
-      n += JSON.stringify(output ?? "").length;
-    }
-  }
-  return n;
-}
-
-export function cumulativeMessageChars(messages: ReadonlyArray<ModelMessage>): number {
-  let total = 0;
-  for (const m of messages) total += messageChars(m);
-  return total;
-}
-
-/**
- * Read the textual value out of a `ToolResultPart.output`. Different output
- * shapes (text / json / error-text / execution-denied) all collapse to a
- * single best-effort string for the preview stub.
- */
-function extractOutputPreview(output: unknown): string {
-  if (output === null || output === undefined) return "";
-  if (typeof output === "string") return output;
-  if (typeof output !== "object") return String(output);
-  const o = output as Record<string, unknown>;
-  if (typeof o.value === "string") return o.value;
-  try {
-    return JSON.stringify(o.value ?? o);
-  } catch {
-    return String(o);
-  }
-}
-
-/**
- * Find the index of the first message in the LAST `keepLastTurns` tool turns.
- * A turn boundary lives at every `tool`-role message — that message carries
- * the tool result(s). Returns 0 if there are not enough tool turns to skip
- * (in which case nothing is compacted because the whole tail is "recent").
- */
-function findKeepFromIndex(messages: ReadonlyArray<ModelMessage>, keepLastTurns: number): number {
-  if (keepLastTurns <= 0) return messages.length;
-  const toolMessageIndices: number[] = [];
-  for (let i = 0; i < messages.length; i++) {
-    if (messages[i]?.role === "tool") toolMessageIndices.push(i);
-  }
-  if (toolMessageIndices.length <= keepLastTurns) return messages.length;
-  // We want the FIRST kept turn to start at the assistant message immediately
-  // before the (keepLastTurns)-from-last tool message. Approximate by anchoring
-  // on the tool message itself and stepping back one message to grab the
-  // assistant tool-call that preceded it.
-  const anchor = toolMessageIndices[toolMessageIndices.length - keepLastTurns]!;
-  return Math.max(0, anchor - 1);
-}
-
-/** True iff the message has at least one tool-result part. */
-function isToolResultMessage(msg: ModelMessage): boolean {
-  if (msg.role !== "tool") return false;
-  if (typeof msg.content === "string") return false;
-  if (!Array.isArray(msg.content)) return false;
-  for (const part of msg.content as ReadonlyArray<{ type: string }>) {
-    if (part.type === "tool-result") return true;
-  }
-  return false;
-}
-
-interface ToolResultPartLike {
-  type: "tool-result";
-  toolCallId: string;
-  toolName: string;
-  output: unknown;
-  providerOptions?: unknown;
-}
-
-function rewriteOlderToolMessage(msg: ModelMessage, previewChars: number, label: string): ModelMessage {
-  if (!isToolResultMessage(msg) || !Array.isArray(msg.content)) return msg;
-  const rewritten = (msg.content as ReadonlyArray<Record<string, unknown>>).map((part) => {
-    if (part.type !== "tool-result") return part;
-    const tr = part as unknown as ToolResultPartLike;
-    const rawPreview = extractOutputPreview(tr.output);
-    const fullLen = rawPreview.length;
-    const preview = rawPreview.slice(0, previewChars).replace(/\s+/g, " ").trim();
-    const stub = `[earlier tool_result for tool=${tr.toolName} (id=${tr.toolCallId}) — ${fullLen} chars elided by ${label} compactor; output: ${preview}]`;
-    return {
-      type: "tool-result",
-      toolCallId: tr.toolCallId,
-      toolName: tr.toolName,
-      output: { type: "text", value: stub },
-    } as Record<string, unknown>;
-  });
-  // ModelMessage union narrowing: cast through unknown to satisfy TS without
-  // dragging in the full provider-utils type graph at this layer.
-  return { ...msg, content: rewritten } as unknown as ModelMessage;
-}
-
-/**
- * Compact a sub-agent message array in place-like fashion. Returns a NEW
- * array; the input is not mutated. Below the threshold the original array
- * reference is returned for cheap identity comparison in tests.
- */
-export function compactSubAgentMessages(
-  messages: ReadonlyArray<ModelMessage>,
-  opts: SubAgentCompactorOptions = {},
-): ModelMessage[] {
-  const { thresholdChars, keepLastTurns, outputPreviewChars, label } = resolveOpts(opts);
-  const total = cumulativeMessageChars(messages);
-  if (total < thresholdChars) return messages.slice();
-
-  const keepFrom = findKeepFromIndex(messages, keepLastTurns);
-  // If everything is in the "keep" tail (not enough turns to compact), bail.
-  if (keepFrom <= 0) return messages.slice();
-
-  // Pass through the first user message and all system messages verbatim;
-  // rewrite older tool-result messages; keep the trailing window intact.
-  let firstUserSeen = false;
-  const out: ModelMessage[] = [];
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i]!;
-    if (i >= keepFrom) {
-      out.push(msg);
-      continue;
-    }
-    if (msg.role === "system") {
-      out.push(msg);
-      continue;
-    }
-    if (msg.role === "user" && !firstUserSeen) {
-      out.push(msg);
-      firstUserSeen = true;
-      continue;
-    }
-    if (isToolResultMessage(msg)) {
-      out.push(rewriteOlderToolMessage(msg, outputPreviewChars, label));
-      continue;
-    }
-    // Older assistant text / tool-call shells stay as-is. They are usually
-    // small and the model relies on the call shape for self-consistency.
-    out.push(msg);
-  }
-  return out;
-}

package/src/orchestrator/token-counter.test.ts

@@ -1,69 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { __forceFallbackForTests, countTokens, isTokenizerReady, setProviderHint } from "./token-counter";
-
-describe("token-counter", () => {
-  afterEach(() => {
-    __forceFallbackForTests(false);
-    setProviderHint(null);
-  });
-
-  it("returns 0 for empty input", () => {
-    expect(countTokens("")).toBe(0);
-  });
-
-  it("uses BPE tokenizer when available — code is denser than chars/4", () => {
-    __forceFallbackForTests(false);
-    expect(isTokenizerReady()).toBe(true);
-    // A short code-like string of 20 chars: chars/4 = 5, BPE typically 6–10.
-    const code = "const x = foo(bar);";
-    const bpe = countTokens(code);
-    const heuristic = Math.ceil(code.length / 4);
-    // BPE for code is generally >= heuristic (code uses more, denser tokens).
-    expect(bpe).toBeGreaterThanOrEqual(heuristic - 1);
-    // And it should NOT be a wild over-count.
-    expect(bpe).toBeLessThan(heuristic * 3);
-  });
-
-  it("falls back to chars/4 when forced", () => {
-    __forceFallbackForTests(true);
-    expect(countTokens("hello world")).toBe(Math.ceil("hello world".length / 4));
-    expect(isTokenizerReady()).toBe(false);
-  });
-
-  it("BPE is closer to ground truth on prose vs chars/4", () => {
-    // English prose: chars/4 typically overcounts. BPE gives a smaller number.
-    __forceFallbackForTests(false);
-    const prose = "The quick brown fox jumps over the lazy dog. Repeated several times for a longer sample.";
-    const bpe = countTokens(prose);
-    const heuristic = Math.ceil(prose.length / 4);
-    expect(bpe).toBeLessThan(heuristic);
-  });
-
-  it("applies the deepseek correction multiplier (~+5%) on top of cl100k_base", () => {
-    __forceFallbackForTests(false);
-    const text = "function add(a, b) { return a + b; }".repeat(10);
-
-    setProviderHint(null);
-    const baseline = countTokens(text);
-
-    setProviderHint("deepseek");
-    const adjusted = countTokens(text);
-
-    // Multiplier of 1.05 must round up — adjusted is strictly greater than baseline.
-    expect(adjusted).toBeGreaterThan(baseline);
-    expect(adjusted).toBe(Math.ceil(baseline * 1.05));
-  });
-
-  it("unknown providers get no correction (multiplier = 1)", () => {
-    __forceFallbackForTests(false);
-    const text = "hello world this is some sample text for tokenization";
-
-    setProviderHint(null);
-    const baseline = countTokens(text);
-
-    setProviderHint("some-unknown-provider");
-    const adjusted = countTokens(text);
-
-    expect(adjusted).toBe(baseline);
-  });
-});

package/src/orchestrator/token-counter.ts

@@ -1,81 +0,0 @@
-/**
- * Token counting backed by gpt-tokenizer (o200k_base / cl100k_base BPE) with a
- * chars/4 fallback.
- *
- * The tokenizer is a proxy: not every provider uses these encodings, but for
- * compaction-trigger decisions it is much closer to ground truth than chars/4
- * (which underestimates code by ~25–35% and overestimates prose by ~15–20%).
- *
- * If the import fails for any reason (bundler quirk, runtime issue), we
- * silently fall back so compaction never crashes on a token estimate.
- */
-
-import { encode as encodeCl100k } from "gpt-tokenizer";
-
-let useFallback = false;
-let providerHint: string | null = null;
-
-/**
- * Per-provider correction factors applied on top of cl100k_base BPE counts.
- * cl100k_base is 0% for OpenAI GPT-3.5/4 and a close proxy for tiktoken-family
- * tokenizers. For providers with mildly different vocabularies, a small
- * multiplier compensates for systematic under/over-count.
- *
- * Empirical baselines (English + code; CJK varies more):
- *   deepseek: ~+5%  (similar tiktoken family, slightly larger vocab)
- *
- * Keep this map small and conservative — multipliers > 1.15 indicate the
- * provider really needs its own tokenizer, not a fudge factor.
- */
-const PROVIDER_MULTIPLIER: Record<string, number> = {
-  deepseek: 1.05,
-};
-
-function multiplierFor(provider: string | null): number {
-  if (!provider) return 1;
-  return PROVIDER_MULTIPLIER[provider] ?? 1;
-}
-
-/**
- * Tell the tokenizer which provider is in use. Set once at orchestrator init
- * (or whenever the active provider changes). Defaults to no correction if
- * the provider is unknown.
- */
-export function setProviderHint(provider: string | null | undefined): void {
-  providerHint = provider ?? null;
-}
-
-export function getProviderHint(): string | null {
-  return providerHint;
-}
-
-function fallbackCharCount(text: string): number {
-  return Math.ceil(text.length / 4);
-}
-
-/**
- * Best-effort token count for a single string.
- * Returns 0 for empty input. Falls back to chars/4 if the tokenizer throws.
- */
-export function countTokens(text: string): number {
-  if (!text) return 0;
-  if (useFallback) return fallbackCharCount(text);
-  try {
-    const base = encodeCl100k(text).length;
-    const mult = multiplierFor(providerHint);
-    return mult === 1 ? base : Math.ceil(base * mult);
-  } catch {
-    useFallback = true;
-    return fallbackCharCount(text);
-  }
-}
-
-/** For tests / diagnostics. */
-export function isTokenizerReady(): boolean {
-  return !useFallback;
-}
-
-/** For tests — force the fallback path. */
-export function __forceFallbackForTests(value: boolean): void {
-  useFallback = value;
-}

package/src/orchestrator/tool-utils.ts

@@ -1,214 +0,0 @@
-import type { Plan, ToolCall, ToolResult } from "../types/index";
-import type { ProcessMessageFinishReason, ProcessMessageUsage } from "./agent-options";
-import { asNumber } from "./batch-utils";
-
-export function toToolCall(part: { toolCallId: string; toolName: string; args?: unknown; input?: unknown }): ToolCall {
-  return {
-    id: part.toolCallId,
-    type: "function",
-    function: {
-      name: part.toolName,
-      arguments: JSON.stringify(part.input ?? part.args ?? {}),
-    },
-  };
-}
-
-export function toToolResult(output: unknown): ToolResult {
-  if (output && typeof output === "object" && "success" in output) {
-    const r = output as {
-      success: boolean;
-      output?: string;
-      error?: string;
-      diff?: ToolResult["diff"];
-      plan?: Plan;
-      task?: ToolResult["task"];
-      delegation?: ToolResult["delegation"];
-      backgroundProcess?: ToolResult["backgroundProcess"];
-      media?: ToolResult["media"];
-      computer?: ToolResult["computer"];
-      lspDiagnostics?: ToolResult["lspDiagnostics"];
-    };
-    return {
-      success: r.success,
-      output: r.output,
-      error: r.error ?? (r.success ? undefined : r.output),
-      diff: r.diff,
-      plan: r.plan,
-      task: r.task,
-      delegation: r.delegation,
-      backgroundProcess: r.backgroundProcess,
-      media: r.media,
-      computer: r.computer,
-      lspDiagnostics: r.lspDiagnostics,
-    };
-  }
-  return { success: true, output: String(output) };
-}
-
-export function formatSubagentActivity(toolName: string, args?: unknown): string {
-  const parsed = parseToolArgs(args);
-  if (toolName === "read_file") return `Read ${parsed.path || "file"}`;
-  if (toolName === "lsp") return `LSP ${parsed.operation || "query"} ${parsed.filePath || ""}`.trim();
-  if (toolName === "write_file") return `Write ${parsed.path || "file"}`;
-  if (toolName === "edit_file") return `Edit ${parsed.path || "file"}`;
-  if (toolName === "search_web") return `Web search "${truncate(parsed.query || "", 50)}"`;
-  if (toolName === "search_x") return `X search "${truncate(parsed.query || "", 50)}"`;
-  if (toolName === "generate_image") return `Generate image "${truncate(parsed.prompt || "", 50)}"`;
-  if (toolName === "generate_video") return `Generate video "${truncate(parsed.prompt || "", 50)}"`;
-  if (toolName === "computer_snapshot") return `Snapshot ${parsed.app || "desktop"}`;
-  if (toolName === "computer_screenshot") return "Capture desktop screenshot";
-  if (toolName === "computer_click")
-    return parsed.ref ? `Click ${parsed.ref}` : `Click at ${parsed.x || "?"},${parsed.y || "?"}`;
-  if (toolName === "computer_mouse_move")
-    return parsed.ref ? `Hover ${parsed.ref}` : `Move mouse to ${parsed.x || "?"},${parsed.y || "?"}`;
-  if (toolName === "computer_type") return `Type into ${parsed.ref || "element"}`;
-  if (toolName === "computer_press") return `Press ${parsed.key || "key"}`;
-  if (toolName === "computer_scroll") return `Scroll ${parsed.ref || "element"} ${parsed.direction || "down"}`;
-  if (toolName === "computer_launch") return `Launch ${parsed.app || "app"}`;
-  if (toolName === "computer_list_windows") return `List windows${parsed.app ? ` for ${parsed.app}` : ""}`;
-  if (toolName === "computer_focus_window")
-    return `Focus window ${parsed.window_id || parsed.title || parsed.app || ""}`.trim();
-  if (toolName === "computer_wait") return "Wait for desktop state";
-  if (toolName === "computer_get") return `Read ${parsed.property || "text"} from ${parsed.ref || "element"}`;
-  if (toolName === "bash") return truncate(parsed.command || "Run command", 70);
-  return truncate(`${toolName}`, 70);
-}
-
-export function parseToolArgs(args: unknown): Record<string, string> {
-  if (!args || typeof args !== "object") return {};
-  const result: Record<string, string> = {};
-  for (const [key, value] of Object.entries(args)) {
-    result[key] = typeof value === "string" ? value : JSON.stringify(value);
-  }
-  return result;
-}
-
-export function firstLine(text: string): string {
-  return text.trim().split("\n").find(Boolean)?.trim() || "Task completed.";
-}
-
-export function truncate(text: string, max: number): string {
-  return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
-}
-
-export function notifyObserver<T>(listener: ((payload: T) => void) | undefined, payload: T): void {
-  if (!listener) {
-    return;
-  }
-
-  try {
-    listener(payload);
-  } catch {
-    // Observer failures should never break generation.
-  }
-}
-
-export function combineAbortSignals(...signals: Array<AbortSignal | undefined>): AbortSignal | undefined {
-  const activeSignals = signals.filter((signal): signal is AbortSignal => Boolean(signal));
-  if (activeSignals.length === 0) return undefined;
-  if (activeSignals.length === 1) return activeSignals[0];
-
-  if (typeof AbortSignal.any === "function") {
-    return AbortSignal.any(activeSignals);
-  }
-
-  const controller = new AbortController();
-  for (const signal of activeSignals) {
-    if (signal.aborted) {
-      controller.abort();
-      break;
-    }
-
-    signal.addEventListener("abort", () => controller.abort(), { once: true });
-  }
-
-  return controller.signal;
-}
-
-export function getStepNumber(event: unknown, fallback: number): number {
-  if (event && typeof event === "object" && "stepNumber" in event && typeof event.stepNumber === "number") {
-    return event.stepNumber;
-  }
-  return fallback;
-}
-
-export function getFinishReason(event: unknown): ProcessMessageFinishReason {
-  if (event && typeof event === "object" && "finishReason" in event) {
-    switch (event.finishReason) {
-      case "stop":
-      case "length":
-      case "content-filter":
-      case "tool-calls":
-      case "error":
-      case "other":
-        return event.finishReason;
-    }
-  }
-  return "other";
-}
-
-/**
- * Normalize a streamText `onStepFinish` / `onFinish` event into ProcessMessageUsage.
- *
- * Reads cache metrics from THREE possible locations (in priority order):
- *   1. `event.usage.cachedInputTokens` / `event.usage.inputTokenDetails.*` — AI SDK
- *      v6 standardized fields (set by `@ai-sdk/anthropic`, `@ai-sdk/openai`).
- *   2. `event.providerMetadata.<provider>.*` — provider-specific surface emitted
- *      by `@ai-sdk/deepseek` as `{ deepseek: { promptCacheHitTokens, promptCacheMissTokens } }`
- *      and by `@ai-sdk/openai` as `{ openai: { cachedPromptTokens } }`.
- *   3. `event.usage.raw.*` — legacy escape hatch for raw provider response fields
- *      (`prompt_cache_hit_tokens`, `cache_creation_input_tokens`). Kept for batch
- *      compat with `getBatchUsage`.
- *
- * Phase C1 fix: previously this only read (1) and (3). DeepSeek goes through
- * `@ai-sdk/openai-compatible`, which does NOT populate `usage.raw` AND does NOT
- * populate the standardized fields — its cache metrics live in (2) under the
- * provider id. Without reading providerMetadata, every DeepSeek request recorded
- * `cache_read_tokens=0` even when the API charged the cached-input price, which
- * is what `usage forensics` flagged as "zero cache_creation across deepseek route".
- */
-export function getUsage(event: unknown): ProcessMessageUsage {
-  if (!(event && typeof event === "object")) {
-    return {};
-  }
-  const evt = event as Record<string, unknown>;
-  const usage = evt.usage;
-  if (!usage || typeof usage !== "object") {
-    return {};
-  }
-  const u = usage as Record<string, unknown>;
-  const details = u.inputTokenDetails as Record<string, unknown> | undefined;
-  const raw = u.raw as Record<string, unknown> | undefined;
-
-  // providerMetadata sits on the event, not inside usage. Pull each known
-  // provider bucket separately so a future provider addition is one new const.
-  const pm = evt.providerMetadata as Record<string, unknown> | undefined;
-  const deepseekMeta = pm?.deepseek as Record<string, unknown> | undefined;
-  const openaiMeta = pm?.openai as Record<string, unknown> | undefined;
-
-  // Cache reads: standardized field → deepseek meta → openai meta → raw passthrough.
-  const cacheRead =
-    asNumber(u.cachedInputTokens) ??
-    asNumber(details?.cacheReadTokens) ??
-    asNumber(deepseekMeta?.promptCacheHitTokens) ??
-    asNumber(openaiMeta?.cachedPromptTokens) ??
-    asNumber(raw?.prompt_cache_hit_tokens);
-
-  // Cache writes: only Anthropic exposes this today. DeepSeek's on-disk cache
-  // is write-only-server-side (no charged write), so leaving this undefined for
-  // DeepSeek is correct — do NOT zero-fill (that would mask provider regressions).
-  const cacheCreation = asNumber(details?.cacheWriteTokens) ?? asNumber(raw?.cache_creation_input_tokens);
-
-  // Non-cached input split. DeepSeek reports it directly; for others we leave
-  // undefined and let downstream derive it.
-  const noCacheInput = asNumber(deepseekMeta?.promptCacheMissTokens) ?? asNumber(raw?.prompt_cache_miss_tokens);
-
-  return {
-    inputTokens: typeof u.inputTokens === "number" ? u.inputTokens : undefined,
-    outputTokens: typeof u.outputTokens === "number" ? u.outputTokens : undefined,
-    totalTokens: typeof u.totalTokens === "number" ? u.totalTokens : undefined,
-    cacheReadTokens: cacheRead ?? undefined,
-    cacheCreationTokens: cacheCreation ?? undefined,
-    noCacheInputTokens: noCacheInput ?? undefined,
-  };
-}

package/src/orchestrator/turn-runner-deps.ts

@@ -1,83 +0,0 @@
-// TurnRunnerDepsBase — shared dependency surface extracted from
-// `MessageProcessorDeps` (Phase 12.4) and `BatchTurnRunnerDeps` (Phase 12.5).
-//
-// Both turn-runner modules need the same minimum proxy onto Agent state for
-// compaction, task delegation, and turn bookkeeping. Hoisting that overlap
-// here lets both interfaces declare the relationship explicitly via
-// `interface X extends TurnRunnerDepsBase` instead of duplicating the
-// property list.
-//
-// Pure type module — no runtime code. Adding a member here requires bumping
-// every concrete deps implementation in orchestrator.ts; removing one only
-// affects the concrete implementations that still rely on it.
-
-import type { ModelMessage } from "ai";
-import type { BashTool } from "../tools/bash";
-import type { AgentMode, TaskRequest, ToolResult, UsageSource } from "../types/index";
-import type { LegacyProvider } from "./agent-options";
-import type { CompactionSettings } from "./compaction";
-
-/**
- * Shared base for turn-runner deps surfaces.
- *
- * Holds the properties that are identical across `MessageProcessorDeps`
- * (streaming path) and `BatchTurnRunnerDeps` (batch-API path):
- *   - Read-only state references the turn loop touches
- *   - Compaction delegators (per-turn + post-turn)
- *   - Task/delegation tool callbacks
- *   - Turn bookkeeping (append/discard/recordUsage)
- *   - Common scalar getters/setters (compactedThisTurn, providerOptionsShape)
- *
- * Path-specific members (PIL, hooks, council, batch client, etc.) stay on
- * the concrete deps interfaces.
- */
-export interface TurnRunnerDepsBase {
-  // ---- Read-only state references ---------------------------------------
-  /** Live messages array (mutated by push). */
-  readonly messages: ModelMessage[];
-  readonly bash: BashTool;
-  readonly mode: AgentMode;
-  readonly maxToolRounds: number;
-  readonly schedules: import("../tools/schedule").ScheduleManager;
-  readonly sendTelegramFile: ((filePath: string) => Promise<ToolResult>) | null;
-
-  // ---- Scalar getters / setters -----------------------------------------
-  getCompactedThisTurn(): boolean;
-  setCompactedThisTurn(v: boolean): void;
-  setLastProviderOptionsShape(shape: string | null): void;
-
-  // ---- Compaction behavior delegators -----------------------------------
-  getCompactionSettings(contextWindow?: number): CompactionSettings;
-  compactForContext(
-    provider: LegacyProvider,
-    system: string,
-    contextWindow: number,
-    signal: AbortSignal,
-    settings?: CompactionSettings,
-    overflow?: boolean,
-  ): Promise<boolean>;
-  postTurnCompact(provider: LegacyProvider, system: string, contextWindow: number, signal: AbortSignal): Promise<void>;
-
-  // ---- Task / delegation tool callbacks ---------------------------------
-  runTask(request: TaskRequest, signal?: AbortSignal): Promise<ToolResult>;
-  runDelegation(request: TaskRequest, signal?: AbortSignal): Promise<ToolResult>;
-  readDelegation(id: string): Promise<ToolResult>;
-  listDelegations(): Promise<ToolResult>;
-
-  // ---- Turn bookkeeping --------------------------------------------------
-  appendCompletedTurn(userMessage: ModelMessage, assistantMessages: ModelMessage[]): void;
-  discardAbortedTurn(userMessage: ModelMessage): void;
-  recordUsage(
-    usage:
-      | {
-          totalTokens?: number;
-          inputTokens?: number;
-          outputTokens?: number;
-          cacheReadTokens?: number;
-          cacheCreationTokens?: number;
-        }
-      | undefined,
-    source?: UsageSource,
-    model?: string,
-  ): void;
-}