mixdog 0.9.168 → 0.9.170

package/README.md

@@ -1,29 +1,25 @@
 # Mixdog
 
 [![npm](https://img.shields.io/npm/v/mixdog)](https://www.npmjs.com/package/mixdog)
-![node](https://img.shields.io/badge/node-%3E%3D22-brightgreen)
+![Node.js ^22.19.0 || >=24.0.0](https://img.shields.io/badge/node-%5E22.19.0%20%7C%7C%20%3E%3D24.0.0-brightgreen)
 ![license](https://img.shields.io/badge/license-Apache--2.0-blue)
 
-## The most efficient harness. The easiest way to use it.
+## More work. Less cost. Less complexity.
 
-Mixdog's goal is simple: make the most efficient AI coding harness the
-easiest to use. Get more work done with the same model and budget, without
-needing to become an expert in agent infrastructure.
+Get more from your models and budget with an efficient AI coding
+harness—and intuitive controls for managing sessions, agents, and your
+entire workflow.
 
-That means more than an easy first run. Advanced capabilities should be easy
-to access, configure, and manage as your work grows—from choosing a model
-to coordinating agents and shaping your own workflows.
-
-- **Efficiency that turns into more work.** Cache-aware context, focused
+- **More work for your budget.** Cache-aware context, focused
   tools, and compaction reduce overhead so more of your budget goes toward
-  the task. The same-model Terminal-Bench comparisons below show comparable
-  or better results with less context and lower priced cost.
-- **Advanced capabilities, within easy reach.** Guided setup and visual
-  controls help you assign models by role, configure workflows, and work
-  with parallel agent sessions without building your own agent stack.
-- **Simple to manage. Flexible when you need it.** Manage providers, agents,
-  workflows, and extensions in one app. Customize agent definitions and
-  operating rules, or add skills, MCP servers, hooks, and plugins as needed.
+  the task. The published same-model Terminal-Bench comparisons below show comparable
+  or better results with smaller contexts and lower costs at the same API rates.
+- **Easy to start. Simple to manage.** Guided setup and visual controls
+  help you choose models, assign agent roles, and configure workflows without
+  becoming an expert in agent infrastructure or building your own stack.
+- **One workspace, your way.** In Desktop, organize parallel sessions with
+  tabs and split panes, customize agents and workflows, and keep token
+  statistics and supported provider limits in view.
 
 Use supported subscription accounts, API keys, or Mixdog's built-in Local Provider.
 Take the same agent beyond code into browsers, Windows apps, documents,
@@ -59,6 +55,37 @@ mixdog
 First run guides you through provider authentication, model selection, and
 workflow setup.
 
+## One workspace for your sessions and agents
+
+Run multiple AI sessions side by side and manage your agents in Desktop.
+Combine tabs and split panes, customize how you work, and keep token usage
+and supported provider limits in view.
+
+- **Multiple sessions, manageable agents.** Keep separate tasks in separate
+  sessions and work on them in parallel. Manage agent definitions, assign
+  models by role, and configure workflows in one app instead of assembling
+  your own agent stack.
+- **Tabs and split panes—together.** Use tabs to organize sessions and split
+  panes to follow several side by side. Each pane can hold its own tabs, so
+  you do not have to choose between quick switching and a simultaneous view.
+- **Make the workspace your own.** Visual controls put layout, providers,
+  models, agent rules, workflows, and extensions within easy reach. The model
+  picker shows pricing, context limits, and capability metadata to help you
+  choose—not just a list of model names.
+- **See where your tokens go.** Usage statistics break down token totals by
+  provider and model, including input, output, cache hits, and cache hit rate,
+  with trends and cost figures. Subscription values use list prices; API
+  costs may be estimates. Neither is an invoice.
+- **Keep remaining usage in sight.** The usage panel brings supported
+  providers' quota windows and reset times together, reducing trips to
+  separate account dashboards. Available figures depend on the provider.
+- **Less window switching.** Chat, a Monaco code editor, Git, terminals, and
+  a file explorer share one workspace, keeping the conversation close to the
+  files and changes you are working on.
+- **Pick up on another screen.** Continue the same live session from Desktop,
+  TUI, or a paired browser on your computer or phone, without starting a
+  separate conversation.
+
 ## Benchmarks
 
 Terminal-Bench 2.1 — same model, same 89 tasks, same official verifier, with
@@ -100,16 +127,80 @@ task checksums, and the usage snapshots behind every cost figure — alongside
 the harness, presets, and metric scripts that recompute each number above:
 [`benchmarks/terminal-bench-2.1/`](benchmarks/terminal-bench-2.1/).
 
+## Less overhead. More budget for the work.
+
+Mixdog reduces the overhead of repeatedly sending context, re-explaining
+requirements, and rediscovering prior work. Focused tools keep unnecessary
+text out of the prompt, while provider-aware caching reuses stable input.
+
+Compaction keeps long conversations manageable with a handoff for continuing
+the task. Optional idle-time compaction reduces the history resent after
+long breaks, when provider caches may have expired. Approved memory and
+past-work retrieval help carry earlier decisions and requirements forward
+without loading the entire conversation archive into every prompt.
+
+You do not have to use the same high-cost model for every role. Choose models
+by role and workflow to focus your budget on the work that needs them.
+
+The benchmarks above measure single-model, single-session runs without
+personal memory, sub-agent delegation, or helper-model lookups. Their cost
+figures already account for cache usage; savings in ongoing work depend on
+the provider, workload, and configuration.
+
+## How Mixdog keeps context lean
+
+Efficiency comes from several layers working together, not just a shorter
+prompt or a larger context window:
+
+1. **Lightweight system instructions** — continuously refined rules keep
+   operating guidance focused without repeating the same policy.
+2. **Purpose-built tools** — scoped queries, batched calls, and bounded
+   results retrieve the evidence a task needs instead of dumping whole files.
+3. **Built-in ast-grep and code graphs** — parsed symbols, signatures, calls,
+   and imports answer structural questions without repeated text searches.
+4. **Provider-aware caching** — stable prompt layers and provider-specific
+   cache controls help reuse context that has already been processed.
+5. **Structured compaction** — a task handoff, the latest request, and a
+   bounded execution history keep long sessions moving.
+6. **Idle-time context reduction** — configurable automatic compaction
+   reduces the context sent after long idle gaps, when caches may be cold.
+7. **On-demand prompt loading** — skill bodies and deferred tool schemas
+   load when needed; stable instructions stay separate from changing state.
+8. **Database-backed long-term memory** — retrieve relevant history instead
+   of injecting the whole archive into every session.
+9. **Tool-result reduction** — repeated results become short references,
+   while large outputs can be saved separately and returned as previews.
+
+Caching can reduce repeated processing and input cost, but cached tokens
+still count toward the model's context limit. Compaction, selective retrieval,
+and output reduction reduce the amount of context the model needs. See
+[Context efficiency](docs/context-efficiency.md) for the mechanisms,
+implementation references, and limits.
+
 ## What you can do
 
 ### Build, test, and review
 
-Search repositories with text and symbol-aware tools, edit files, run tests
+Search repositories with text and AST-based tools, edit files, run tests
 and background commands, and review changes. Desktop brings the agent together
 with a Monaco editor, Git, terminals, and a file explorer. Use workflows and
 role-specific models to organize work, and extend the toolset with MCP
 servers, skills, hooks, and plugins.
 
+**Code graph.** Inspect exports, signatures, and nested members; locate
+declarations and references; trace calls and imports; and assess which files
+a change may affect. Call relationships come from parsed call sites rather than
+text matches, and identifier references exclude comment-only mentions.
+The native engine embeds tree-sitter and ast-grep, parses 31 languages, and
+extracts symbols and imports for 24. Capabilities vary by language; this is
+structural navigation, not a replacement for a compiler's type analysis.
+
+**Code Tidy.** Install the built-in capability to format, lint, and check
+structural rules through the agent. It respects project configuration and
+uses project-local, system-installed, or supported managed engines.
+Fixes are previewed without changing files unless explicitly applied. See
+[Code Tidy](docs/code-tidy.md) for engine setup and rule coverage.
+
 The GitHub integration manages repositories, issues, pull requests and reviews,
 Actions, releases, and notifications. Source Control commits use a manually
 entered summary and optional description; there is no built-in AI commit-message
@@ -118,11 +209,18 @@ operations and permission requirements.
 
 ### Keep longer work moving
 
-Resume saved chats, recall prior work through local semantic and lexical
-search, and retain project-scoped preferences across sessions. Compaction
-keeps long conversations manageable. For an explicitly requested longer-running
-objective, **Goals** track completion conditions and tasks, support time limits
-and automatic continuation, and let you pause or resume the work.
+Resume saved chats and recall prior work through local semantic and lexical
+search. Long-term memory separates searchable conversation history (`recall`)
+from approved shared or project-scoped preferences (`memory`); generated
+conversation summaries do not become standing instructions.
+
+Compaction keeps long conversations manageable while retaining the latest
+request and the context needed to continue. Configurable idle-time compaction
+can also reduce input cost when resuming after a long idle period, when the
+provider's cache may have expired.
+For an explicitly requested longer-running objective, **Goals** track
+completion conditions and tasks, support time limits and automatic
+continuation, and let you pause or resume the work.
 
 ### Work beyond the repository
 
@@ -135,8 +233,12 @@ and automatic continuation, and let you pause or resume the work.
   `browser_devtools`.
 - **Computer Use on Windows** — operate native apps through accessibility,
   screenshots, OCR, keyboard, and pointer input with guarded execution.
+  An overlay provides Stop and Resume controls.
 - **Documents** — create and edit Word, Excel, and PowerPoint files, work
-  with PDFs, and inspect rendered previews and document quality checks.
+  with PDFs, and review rendered previews alongside automated checks.
+  Use portable OOXML editing without Microsoft Office, or Microsoft Office
+  automation on Windows. Rendering and spreadsheet recalculation depend on
+  the available engines. See [Office runtime](src/runtime/office/README.md).
 - **Image and video Studio** — generate and edit images, generate short video
   clips, and keep the results in a persistent local gallery. Continue a clip
   by using its last frame as the reference for a new generation; this carries
@@ -247,7 +349,7 @@ diagnostics remain on stderr.
 /inherit      carry this conversation into a new session on the current model
 /compact      compact older conversation context
 /goal         start, inspect, pause, or resume a durable session Goal
-/autoclear    manage idle-time context clearing
+/autoclear    manage idle-time context compaction
 /context      inspect the current context surface
 /usage        show provider quota and balance
 /providers    configure provider authentication
@@ -300,6 +402,7 @@ The workspace includes:
 - Split panes for parallel, independently routed agent sessions
 - Live session handoff between the TUI, desktop windows, and paired browsers
 - Monaco editor, LSP integration, diffs, and turn-by-turn edit review
+- Built-in code graph navigation and installable Code Tidy checks and fixes
 - Git staging, commits with manually entered messages, and branches
 - GitHub repositories, issues, pull requests, reviews, Actions, releases,
   and notifications
@@ -313,7 +416,7 @@ The workspace includes:
   progress and controls
 - Voice dictation with an optional local transcription runtime
 - Extensions hub with guided setup for Git & GitHub, Memory, Browser Use,
-  Computer Use, Office, Local Provider, and voice
+  Computer Use, Office, Code Tidy, Local Provider, and voice
 - Provider setup, usage, git identity, and remote pairing settings
 
 In **Extensions**, the **Plugin** tab manages integrations and built-in
@@ -344,6 +447,23 @@ Useful environment variables:
 - `MIXDOG_MODE=ship|dev` — select shipping or development diagnostics.
 - `MIXDOG_DIAGNOSTICS=1` — force diagnostic trace and log output.
 
+## Core technology
+
+| Layer | Stack |
+| --- | --- |
+| Shared agent runtime | Node.js and ECMAScript modules, shared by CLI and Desktop |
+| Terminal UI | React and Ink |
+| Desktop workspace | Electron, React, TypeScript, Monaco, and xterm.js |
+| Native code tools | Rust, tree-sitter, and embedded ast-grep for parsing, structural queries, and rule-based checks |
+| Browser automation | Chromium and the Chrome DevTools Protocol (CDP) |
+| Long-term memory | Managed local PostgreSQL with pgvector and full-text search |
+| Documents | Portable OOXML and PDF tooling, plus Microsoft Office automation on Windows |
+
+These components serve different roles: native tools analyze code, database
+retrieval keeps historical context selective, and provider-specific caching
+reduces repeated model processing. See [Context efficiency](docs/context-efficiency.md)
+for how they work with prompt management and compaction.
+
 ## Development
 
 ```bash
@@ -379,7 +499,7 @@ Main directories:
 src/            CLI, TUI, runtime, workflows, agents, and rules
 apps/desktop/   cross-platform desktop app
 apps/relay/     remote web app and relay
-native/         native process, search, patch, and support binaries
+native/         native process, search, graph, patch, and support binaries
 scripts/        tests, diagnostics, benchmarks, and build scripts
 benchmarks/     reproducible benchmark harnesses, results, and raw artifacts
 src/vendor/     vendored runtime components

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.168",
+  "version": "0.9.170",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",

package/scripts/agent-lead-e2e-probe.mjs

@@ -79,20 +79,21 @@ try {
   const toolEvents = [];
   const askOptions = {
     onAssistantToolCallObserved: (call) => toolEvents.push({ kind: 'call', name: call?.name || call?.tool || '?' }),
-    onToolResult: (message) => toolEvents.push({
-      kind: 'result',
-      name: message?.name || message?.tool || '?',
-      preview: String(message?.content ?? message?.output ?? '').slice(0, 200),
-    }),
+    onToolResult: (message) =>
+      toolEvents.push({
+        kind: 'result',
+        name: message?.name || message?.tool || '?',
+        preview: String(message?.content ?? message?.output ?? '').slice(0, 200),
+      }),
   };
   const ask1 = await runtime.ask(
-    'Delegate one task via the agent tool. If `agent` is not directly callable, first call '
-    + `load_tool with names=['agent'] to activate it. Then call agent with exactly type=spawn, agent=${WORKER_AGENT} and prompt `
-    + "'Read package.json in the current repo and reply with exactly the value of its name field, one word, nothing else.' "
-    + 'Do NOT set provider/model/effort (routing decides). Do not use read/grep/shell yourself. '
-    + 'After the spawn tool call returns, reply with exactly: SPAWNED. '
-    + 'Only if activating AND calling the agent tool both fail, reply exactly: AGENT_UNAVAILABLE',
-    askOptions,
+    'Delegate one task via the agent tool. If `agent` is not directly callable, first call ' +
+      `load_tool with names=['agent'] to activate it. Then call agent with exactly type=spawn, agent=${WORKER_AGENT} and prompt ` +
+      "'Read package.json in the current repo and reply with exactly the value of its name field, one word, nothing else.' " +
+      'Do NOT set provider/model/effort (routing decides). Do not use read/grep/shell yourself. ' +
+      'After the spawn tool call returns, reply with exactly: SPAWNED. ' +
+      'Only if activating AND calling the agent tool both fail, reply exactly: AGENT_UNAVAILABLE',
+    askOptions
   );
   const spawnReply = String(ask1?.result?.content || '');
   process.stdout.write(`turn1 tools: ${JSON.stringify(toolEvents)}\n`);
@@ -111,45 +112,71 @@ try {
     scope = status.agentScope || scope;
     const workers = status.agentWorkers || [];
     if (!sawWorkerRow && workers.length > 0) sawWorkerRow = workers[0];
-    terminalJob = (status.agentJobs || []).find(
-      (job) => /completed|failed|cancelled/i.test(String(job.status)),
-    ) || null;
+    terminalJob =
+      (status.agentJobs || []).find((job) => /completed|failed|cancelled/i.test(String(job.status))) || null;
     if (!terminalJob) await sleep(300);
   }
-  process.stdout.write(`final status surface: ${JSON.stringify({
-    workers: lastStatus?.agentWorkers || [],
-    jobs: lastStatus?.agentJobs || [],
-  }).slice(0, 1_500)}\n`);
-  check(Boolean(sawWorkerRow), 'worker visible on the session agent status surface',
-    sawWorkerRow ? `tag=${sawWorkerRow.tag} stage=${sawWorkerRow.stage}` : 'never appeared');
+  process.stdout.write(
+    `final status surface: ${JSON.stringify({
+      workers: lastStatus?.agentWorkers || [],
+      jobs: lastStatus?.agentJobs || [],
+    }).slice(0, 1_500)}\n`
+  );
+  check(
+    Boolean(sawWorkerRow),
+    'worker visible on the session agent status surface',
+    sawWorkerRow ? `tag=${sawWorkerRow.tag} stage=${sawWorkerRow.stage}` : 'never appeared'
+  );
   check(Boolean(terminalJob), 'agent job reached a terminal state');
-  check(terminalJob?.status === 'completed', 'agent job completed without error',
-    `status=${terminalJob?.status} error=${terminalJob?.error || 'none'}`);
-  check(Boolean(terminalJob?.provider && terminalJob?.model), 'routing rules resolved the worker route',
-    `agent=${terminalJob?.agent} route=${terminalJob?.provider}/${terminalJob?.model} preset=${terminalJob?.preset || '-'}`);
-  check(scope?.sessionId === runtime.id, 'agent status surface is scoped to the owner session',
-    `scope=${JSON.stringify(scope)} lead=${runtime.id}`);
+  check(
+    terminalJob?.status === 'completed',
+    'agent job completed without error',
+    `status=${terminalJob?.status} error=${terminalJob?.error || 'none'}`
+  );
+  check(
+    Boolean(terminalJob?.provider && terminalJob?.model),
+    'routing rules resolved the worker route',
+    `agent=${terminalJob?.agent} route=${terminalJob?.provider}/${terminalJob?.model} preset=${terminalJob?.preset || '-'}`
+  );
+  check(
+    scope?.sessionId === runtime.id,
+    'agent status surface is scoped to the owner session',
+    `scope=${JSON.stringify(scope)} lead=${runtime.id}`
+  );
   await sleep(500);
-  check(notifications.length > 0, 'owner received the completion notification',
-    `count=${notifications.length}`);
+  check(notifications.length > 0, 'owner received the completion notification', `count=${notifications.length}`);
 
   // Mirror the surface's notification injection into the next Lead turn.
-  const notifText = notifications.map((event) => {
-    try { return typeof event === 'string' ? event : JSON.stringify(event); } catch { return String(event); }
-  }).join('\n').slice(0, 4_000);
+  const notifText = notifications
+    .map((event) => {
+      try {
+        return typeof event === 'string' ? event : JSON.stringify(event);
+      } catch {
+        return String(event);
+      }
+    })
+    .join('\n')
+    .slice(0, 4_000);
   const ask2 = await runtime.ask(
-    `Agent completion notification:\n${notifText}\n\n`
-    + 'Reply with exactly: WORKER_SAID=<the worker\'s one-word answer from the notification>',
-    {},
+    `Agent completion notification:\n${notifText}\n\n` +
+      "Reply with exactly: WORKER_SAID=<the worker's one-word answer from the notification>",
+    {}
   );
   const finalReply = String(ask2?.result?.content || '');
-  check(/WORKER_SAID=\s*mixdog/i.test(finalReply), 'Lead surfaced the worker result',
-    finalReply.slice(0, 160));
+  check(/WORKER_SAID=\s*mixdog/i.test(finalReply), 'Lead surfaced the worker result', finalReply.slice(0, 160));
 
   process.stdout.write(`verdict: ${failures.length === 0 ? 'PASS' : `FAIL (${failures.join('; ')})`}\n`);
   process.exitCode = failures.length === 0 ? 0 : 1;
 } finally {
-  try { await runtime?.stop?.('lead-e2e-probe-exit'); } catch { /* teardown */ }
-  try { rmSync(ROOT, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }); } catch { /* temp */ }
+  try {
+    await runtime?.stop?.('lead-e2e-probe-exit');
+  } catch {
+    /* teardown */
+  }
+  try {
+    rmSync(ROOT, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  } catch {
+    /* temp */
+  }
 }
 process.exit(process.exitCode || 0);

package/scripts/agent-turn-trace-probe.mjs

@@ -52,31 +52,36 @@ const mgr = await import('../src/runtime/agent/orchestrator/session/manager.mjs'
 const { createStandaloneAgent } = await import('../src/standalone/agent-tool.mjs');
 const { ensureDaemon, readSessionDiscovery, shutdownDaemon } = await import('../src/standalone/session-client.mjs');
 
-function sleep(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 try {
   await ensureDaemon({ cwd: REPO, log: () => {} });
   const agent = createStandaloneAgent({ cfgMod, reg, mgr, dataDir: join(ROOT, 'data-probe'), cwd: REPO });
   const t0 = Date.now();
-  const out = await agent.execute({
-    type: 'spawn',
-    agent: 'worker',
-    provider: PROVIDER,
-    model: MODEL,
-    effort: EFFORT,
-    tag: 'turn-trace',
-    cwd: REPO,
-    prompt: [
-      'Execute these steps strictly IN ORDER, exactly ONE tool call per assistant message',
-      '(never batch two calls in one message — this measures sequential rounds):',
-      '1) read package.json',
-      '2) read README.md (first 40 lines)',
-      '3) run the shell command: node -v',
-      '4) read apps/desktop/package.json',
-      '5) grep the string "createSessionRuntimeHost" under src/standalone (files list only)',
-      'Then reply with one line: DONE <package name> <node version>. Do not edit anything.',
-    ].join('\n'),
-  }, { invocationSource: 'model-tool', cwd: REPO });
+  const out = await agent.execute(
+    {
+      type: 'spawn',
+      agent: 'worker',
+      provider: PROVIDER,
+      model: MODEL,
+      effort: EFFORT,
+      tag: 'turn-trace',
+      cwd: REPO,
+      prompt: [
+        'Execute these steps strictly IN ORDER, exactly ONE tool call per assistant message',
+        '(never batch two calls in one message — this measures sequential rounds):',
+        '1) read package.json',
+        '2) read README.md (first 40 lines)',
+        '3) run the shell command: node -v',
+        '4) read apps/desktop/package.json',
+        '5) grep the string "createSessionRuntimeHost" under src/standalone (files list only)',
+        'Then reply with one line: DONE <package name> <node version>. Do not edit anything.',
+      ].join('\n'),
+    },
+    { invocationSource: 'model-tool', cwd: REPO }
+  );
   const id = String(out).match(/agent task: (\S+)/)?.[1];
   if (!id) throw new Error(`no task id: ${out}`);
   let last = '';
@@ -86,41 +91,68 @@ try {
     await sleep(500);
   }
   process.stdout.write(`wall=${((Date.now() - t0) / 1000).toFixed(1)}s\n--- result ---\n${last.slice(0, 400)}\n`);
-  try { agent.closeAll('turn-trace probe end'); } catch { /* teardown */ }
+  try {
+    agent.closeAll('turn-trace probe end');
+  } catch {
+    /* teardown */
+  }
 
   // The runtime worker flushes its local trace buffer on a short timer.
   await sleep(9_000);
   const rows = existsSync(TRACE_PATH)
-    ? readFileSync(TRACE_PATH, 'utf8').split('\n').filter(Boolean).flatMap((line) => {
-      try { return [JSON.parse(line)]; } catch { return []; }
-    })
+    ? readFileSync(TRACE_PATH, 'utf8')
+        .split('\n')
+        .filter(Boolean)
+        .flatMap((line) => {
+          try {
+            return [JSON.parse(line)];
+          } catch {
+            return [];
+          }
+        })
     : [];
   process.stdout.write(`--- trace (${rows.length} rows) ---\n`);
   for (const row of rows) {
     if (row.kind === 'loop') {
-      process.stdout.write(`[loop] iter=${row.iteration ?? row.payload?.iteration} send=${row.send_ms ?? row.payload?.send_ms}ms`
-        + ` preSend=${row.pre_send_ms ?? row.payload?.pre_send_ms}ms toolResume=${row.tool_resume_ms ?? row.payload?.tool_resume_ms}ms`
-        + ` msgs=${row.message_count ?? row.payload?.message_count}\n`);
+      process.stdout.write(
+        `[loop] iter=${row.iteration ?? row.payload?.iteration} send=${row.send_ms ?? row.payload?.send_ms}ms` +
+          ` preSend=${row.pre_send_ms ?? row.payload?.pre_send_ms}ms toolResume=${row.tool_resume_ms ?? row.payload?.tool_resume_ms}ms` +
+          ` msgs=${row.message_count ?? row.payload?.message_count}\n`
+      );
     } else if (row.kind === 'sse') {
       process.stdout.write(`[sse] ttft=${row.ttft_ms}ms streamTotal=${row.stream_total_ms}ms\n`);
     } else if (row.kind === 'turn_timing') {
-      process.stdout.write(`[turn] status=${row.status} ttft=${row.ttft_ms}ms e2eTtft=${row.end_to_end_ttft_ms}ms`
-        + ` queue=${row.queue_ms}ms route=${row.route_ms}ms preflight=${row.preflight_ms}ms provider=${row.provider_ms}ms\n`);
+      process.stdout.write(
+        `[turn] status=${row.status} ttft=${row.ttft_ms}ms e2eTtft=${row.end_to_end_ttft_ms}ms` +
+          ` queue=${row.queue_ms}ms route=${row.route_ms}ms preflight=${row.preflight_ms}ms provider=${row.provider_ms}ms\n`
+      );
     } else if (row.kind === 'usage_raw') {
-      process.stdout.write(`[usage] iter=${row.iteration} input=${row.input_tokens} cached=${row.cached_tokens}`
-        + ` cacheWrite=${row.cache_write_tokens} uncached=${row.uncached_input_tokens} output=${row.output_tokens}`
-        + ` chain=${row.chain_continuous ?? '-'}\n`);
+      process.stdout.write(
+        `[usage] iter=${row.iteration} input=${row.input_tokens} cached=${row.cached_tokens}` +
+          ` cacheWrite=${row.cache_write_tokens} uncached=${row.uncached_input_tokens} output=${row.output_tokens}` +
+          ` chain=${row.chain_continuous ?? '-'}\n`
+      );
     } else if (row.kind === 'tool') {
       const p = row.payload || row;
-      process.stdout.write(`[tool] ${row.tool || row.tool_name || p.tool || p.tool_name || ''}`
-        + ` ${row.duration_ms ?? row.tool_ms ?? p.duration_ms ?? p.tool_ms ?? '?'}ms\n`);
+      process.stdout.write(
+        `[tool] ${row.tool || row.tool_name || p.tool || p.tool_name || ''}` +
+          ` ${row.duration_ms ?? row.tool_ms ?? p.duration_ms ?? p.tool_ms ?? '?'}ms\n`
+      );
     } else {
       process.stdout.write(`[${row.kind}] ${JSON.stringify(row).slice(0, 220)}\n`);
     }
   }
 } finally {
-  try { await shutdownDaemon(readSessionDiscovery()); } catch { /* teardown */ }
+  try {
+    await shutdownDaemon(readSessionDiscovery());
+  } catch {
+    /* teardown */
+  }
   await sleep(300);
-  try { rmSync(ROOT, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }); } catch { /* temp */ }
+  try {
+    rmSync(ROOT, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  } catch {
+    /* temp */
+  }
 }
 process.exit(0);