mixdog 0.9.168 → 0.9.169

package/README.md

@@ -17,7 +17,7 @@ to coordinating agents and shaping your own workflows.
 - **Efficiency that turns into more work.** 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.
+  or better results with smaller contexts and lower costs at the same API rates.
 - **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.
@@ -100,16 +100,60 @@ 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/).
 
+## 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 +162,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 +186,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 +302,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 +355,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 +369,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 +400,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 +452,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.169",
   "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);

package/scripts/audit-usage-ledger.mjs

@@ -12,12 +12,12 @@ import { usageStatsSnapshot } from '../src/standalone/usage-stats-model.mjs';
 const options = process.argv.slice(2);
 const ledgerArg = options.find((arg) => arg.startsWith('--ledger='))?.slice(9);
 if (!ledgerArg || !isAbsolute(ledgerArg) || !/\.sqlite$/i.test(ledgerArg)) {
-    throw new Error('Supply an exact absolute --ledger=<file.sqlite> path');
+  throw new Error('Supply an exact absolute --ledger=<file.sqlite> path');
 }
 for (const arg of options) {
-    if (!arg.startsWith('--ledger=') && !['--reattribute-xai-to-grok', '--apply'].includes(arg)) {
-        throw new Error(`Unknown argument: ${arg}`);
-    }
+  if (!arg.startsWith('--ledger=') && !['--reattribute-xai-to-grok', '--apply'].includes(arg)) {
+    throw new Error(`Unknown argument: ${arg}`);
+  }
 }
 const source = resolve(ledgerArg);
 const auditRoot = join(dirname(source), 'audits');
@@ -26,61 +26,116 @@ const workspace = mkdtempSync(join(auditRoot, 'usage-'));
 const raw = join(workspace, 'original-files');
 mkdirSync(raw);
 for (const suffix of ['', '-wal', '-shm']) {
-    try { copyFileSync(source + suffix, join(raw, basename(source) + suffix)); }
-    catch (error) { if (!suffix || error.code !== 'ENOENT') throw error; }
+  try {
+    copyFileSync(source + suffix, join(raw, basename(source) + suffix));
+  } catch (error) {
+    if (!suffix || error.code !== 'ENOENT') throw error;
+  }
 }
 const snapshotPath = join(workspace, 'backup.sqlite');
 const original = new DatabaseSync(source, { readOnly: true });
-try { await backup(original, snapshotPath); } finally { original.close(); }
+try {
+  await backup(original, snapshotPath);
+} finally {
+  original.close();
+}
 const workingPath = join(workspace, 'working.sqlite');
 copyFileSync(snapshotPath, workingPath);
 const throughTs = Date.now();
 const providerOverrides = options.includes('--reattribute-xai-to-grok') ? { xai: 'grok-oauth' } : {};
 const summarize = (ledger) => {
-    const stats = usageStatsSnapshot({ rollup: ledger.rollup(), now: throughTs, source: 'all' });
-    const sum = (rows, key) => rows.reduce((n, row) => n + Number(row[key] || 0), 0);
-    for (const key of ['turns', 'input', 'output', 'cacheRead', 'cacheWrite', 'costKnownTurns']) {
-        assert.equal(sum(stats.providers, key), stats.totals[key], `provider sum: ${key}`);
-    }
-    for (const rows of [stats.providers, stats.daily]) {
-        assert.ok(Math.abs(sum(rows, 'costUsd') - stats.totals.costUsd) <= rows.length * 0.000001 + 0.000001, 'cost sum');
-        assert.equal(sum(rows, 'tokens'), stats.totals.tokens, 'token sum');
-        assert.equal(sum(rows, 'turns'), stats.totals.turns, 'record sum');
-    }
-    assert.ok(Math.abs(stats.totals.costBilled + stats.totals.costEstimated - stats.totals.costUsd) < 0.000002, 'cost categories');
-    assert.ok(stats.totals.costKnownTurns <= stats.totals.turns, 'price coverage');
-    for (const p of stats.providers) {
-        assert.equal(sum(p.models, 'turns'), p.turns, `model sum: ${p.provider}`);
-    }
-    return {
-        integrity: usageLedgerIntegrity(ledger.db), totals: stats.totals,
-        providers: stats.providers.map(({ provider, providerKind, turns, tokens, costUsd, costUnpricedTurns }) =>
-            ({ provider, providerKind, turns, tokens, costUsd, costUnpricedTurns })),
-    };
+  const stats = usageStatsSnapshot({ rollup: ledger.rollup(), now: throughTs, source: 'all' });
+  const sum = (rows, key) => rows.reduce((n, row) => n + Number(row[key] || 0), 0);
+  for (const key of ['turns', 'input', 'output', 'cacheRead', 'cacheWrite', 'costKnownTurns']) {
+    assert.equal(sum(stats.providers, key), stats.totals[key], `provider sum: ${key}`);
+  }
+  for (const rows of [stats.providers, stats.daily]) {
+    assert.ok(Math.abs(sum(rows, 'costUsd') - stats.totals.costUsd) <= rows.length * 0.000001 + 0.000001, 'cost sum');
+    assert.equal(sum(rows, 'tokens'), stats.totals.tokens, 'token sum');
+    assert.equal(sum(rows, 'turns'), stats.totals.turns, 'record sum');
+  }
+  assert.ok(
+    Math.abs(stats.totals.costBilled + stats.totals.costEstimated - stats.totals.costUsd) < 0.000002,
+    'cost categories'
+  );
+  assert.ok(stats.totals.costKnownTurns <= stats.totals.turns, 'price coverage');
+  for (const p of stats.providers) {
+    assert.equal(sum(p.models, 'turns'), p.turns, `model sum: ${p.provider}`);
+  }
+  return {
+    integrity: usageLedgerIntegrity(ledger.db),
+    totals: stats.totals,
+    providers: stats.providers.map(({ provider, providerKind, turns, tokens, costUsd, costUnpricedTurns }) => ({
+      provider,
+      providerKind,
+      turns,
+      tokens,
+      costUsd,
+      costUnpricedTurns,
+    })),
+  };
 };
 const working = new UsageLedger(workingPath);
 let before, preview, after;
 try {
-    assert.deepEqual(working.db.prepare('PRAGMA quick_check').all().map((r) => r.quick_check), ['ok']);
-    before = summarize(working);
-    preview = repairUsageLedger(working, { throughTs, providerOverrides });
-    after = summarize(working);
-    assert.deepEqual(before.integrity, after.integrity);
-} finally { working.close(); }
-const report = { source, workspace, backup: snapshotPath, throughTs, providerOverrides, before, preview, after, applied: false };
+  assert.deepEqual(
+    working.db
+      .prepare('PRAGMA quick_check')
+      .all()
+      .map((r) => r.quick_check),
+    ['ok']
+  );
+  before = summarize(working);
+  preview = repairUsageLedger(working, { throughTs, providerOverrides });
+  after = summarize(working);
+  assert.deepEqual(before.integrity, after.integrity);
+} finally {
+  working.close();
+}
+const report = {
+  source,
+  workspace,
+  backup: snapshotPath,
+  throughTs,
+  providerOverrides,
+  before,
+  preview,
+  after,
+  applied: false,
+};
 writeFileSync(join(workspace, 'report.json'), JSON.stringify(report, null, 2));
 if (options.includes('--apply')) {
-    const live = new UsageLedger(source);
-    try {
-        // The transaction repairs only the bounded history. Concurrent new
-        // requests are retained and indexed too; no database file is replaced.
-        report.appliedRepair = repairUsageLedger(live, { throughTs, providerOverrides });
-        report.live = summarize(live);
-        assert.deepEqual(live.db.prepare('PRAGMA quick_check').all().map((r) => r.quick_check), ['ok']);
-        report.applied = true;
-    } finally { live.close(); }
-    writeFileSync(join(workspace, 'report.json'), JSON.stringify(report, null, 2));
+  const live = new UsageLedger(source);
+  try {
+    // The transaction repairs only the bounded history. Concurrent new
+    // requests are retained and indexed too; no database file is replaced.
+    report.appliedRepair = repairUsageLedger(live, { throughTs, providerOverrides });
+    report.live = summarize(live);
+    assert.deepEqual(
+      live.db
+        .prepare('PRAGMA quick_check')
+        .all()
+        .map((r) => r.quick_check),
+      ['ok']
+    );
+    report.applied = true;
+  } finally {
+    live.close();
+  }
+  writeFileSync(join(workspace, 'report.json'), JSON.stringify(report, null, 2));
 }
-console.log(JSON.stringify({ workspace, backup: snapshotPath, applied: report.applied,
-    preview, ...(report.appliedRepair ? { appliedRepair: report.appliedRepair } : {}),
-    totals: (report.live || after).totals, providers: (report.live || after).providers }, null, 2));
+console.log(
+  JSON.stringify(
+    {
+      workspace,
+      backup: snapshotPath,
+      applied: report.applied,
+      preview,
+      ...(report.appliedRepair ? { appliedRepair: report.appliedRepair } : {}),
+      totals: (report.live || after).totals,
+      providers: (report.live || after).providers,
+    },
+    null,
+    2
+  )
+);

package/scripts/build-tui.mjs

@@ -73,10 +73,7 @@ await build({
     '../../runtime/channels/lib/voice-runtime-fetcher.mjs',
     '../../runtime/channels/lib/whisper-server.mjs',
   ],
-  plugins: [
-    sharedRuntimeExternalPlugin,
-    sessionClientExternalPlugin,
-  ],
+  plugins: [sharedRuntimeExternalPlugin, sessionClientExternalPlugin],
   logLevel: 'info',
 });