mixdog 0.9.173 → 0.9.174

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.173",
+  "version": "0.9.174",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -78,7 +78,7 @@
     "test:session-transport": "node --test \"scripts/session-transport/*.test.mjs\" scripts/daemon-bootstrap-test.mjs src/runtime/shared/child-spawn-remote.test.mjs src/standalone/session-runtime-agent-control-client.test.mjs src/standalone/session-runtime-dispatch-cancel.test.mjs src/standalone/session-runtime-host-factory.test.mjs src/standalone/session-runtime-inline-host.test.mjs src/standalone/session-runtime-provider-cooldown.test.mjs src/standalone/session-runtime-shard-host.test.mjs src/standalone/session-runtime-shard-router.test.mjs",
     "test:session": "node --test scripts/runtime-turn-contract-test.mjs scripts/session-save-fault-store.slow.test.mjs scripts/turn-review-revert.slow.test.mjs src/runtime/shared/tool-surface.test.mjs src/runtime/bridge-clients.test.mjs src/runtime/browser-bridge/action-schema.test.mjs src/runtime/computer-bridge/client-semantic-error.test.mjs src/runtime/agent/orchestrator/session/tool-envelope.test.mjs src/runtime/agent/orchestrator/session/eager-dispatch.test.mjs",
     "test:quick": "npm run test:session && npm run test:session-transport && npm run test:desktop-main --prefix apps/desktop",
-    "test:office": "node --test scripts/run-office-live-tests.test.mjs src/runtime/office/office-runtime-contract.test.mjs src/runtime/office/office-runtime-com.test.mjs src/runtime/office/office-runtime-portable.test.mjs src/runtime/office/xlsx-formula-audit.test.mjs src/runtime/office/xlsx-portable-snapshot.test.mjs src/runtime/office/office-runtime-pdf.test.mjs src/runtime/office/office-runtime-design.test.mjs src/runtime/office/office-assurance.test.mjs src/runtime/office/office-design-aesthetics.test.mjs src/runtime/office/portable-authoring.test.mjs src/runtime/office/slide-quality.test.mjs src/runtime/office/authoring/pptx-brief.test.mjs src/runtime/office/authoring/pptx-receipt.test.mjs src/runtime/office/quality/render-air.test.mjs src/runtime/office/quality/pptx-deck-rubric.test.mjs && npm run test:office-approval --prefix apps/desktop",
+    "test:office": "node --test scripts/run-office-live-tests.test.mjs src/runtime/office/office-runtime-contract.test.mjs src/runtime/office/office-runtime-com.test.mjs src/runtime/office/office-runtime-portable.slow.test.mjs src/runtime/office/xlsx-formula-audit.test.mjs src/runtime/office/xlsx-portable-snapshot.test.mjs src/runtime/office/office-runtime-pdf.slow.test.mjs src/runtime/office/office-runtime-design.test.mjs src/runtime/office/office-assurance.slow.test.mjs src/runtime/office/office-design-aesthetics.test.mjs src/runtime/office/portable-authoring.slow.test.mjs src/runtime/office/slide-quality.test.mjs src/runtime/office/authoring/pptx-brief.test.mjs src/runtime/office/authoring/pptx-receipt.test.mjs src/runtime/office/quality/render-air.test.mjs src/runtime/office/quality/pptx-deck-rubric.test.mjs && npm run test:office-approval --prefix apps/desktop",
     "test:office:live": "node scripts/run-office-live-tests.mjs",
     "test:office:preview": "node --test src/runtime/office/office-render-preview.test.mjs",
     "test:office:review": "node --test src/runtime/office/pptx-independent-review.test.mjs src/runtime/office/pptx-chart-styling.test.mjs",

package/scripts/build-tui.mjs

@@ -7,13 +7,14 @@
  * ESM bundle at src/tui/dist/index.mjs.
  *
  * What is bundled vs external:
- *   - bundled: our JSX only.
- *   - external: React and Mixdog's patched Ink runtime dependency.
+ *   - bundled: our JSX and the local modules it imports, plus Mixdog's patched
+ *     Ink with its whole dependency tree (see bundleInkPlugin).
+ *   - external: React and every package our own code imports.
  *
  * Run:  node scripts/build-tui.mjs   (or `npm run build:tui`)
  */
 import { build } from 'esbuild';
-import { dirname, join } from 'node:path';
+import { dirname, isAbsolute, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
@@ -41,6 +42,30 @@ const sessionClientExternalPlugin = {
   },
 };
 
+// Ink's ESM build is ~500 small files (es-toolkit alone is ~430), and loading
+// them one by one cost ~150 ms of every TUI start, so Ink and everything it
+// imports are bundled. React stays external so Ink's reconciler and our
+// components share one React instance; packages our own code imports stay
+// external. Ink's optional React DevTools bridge (DEV=true) is left out: it
+// would pull ws and the uninstalled react-devtools-core into the bundle.
+const bundleInkPlugin = {
+  name: 'mixdog-bundle-ink',
+  setup(build) {
+    build.onResolve({ filter: /^[^./]/ }, ({ path, importer, kind }) => {
+      if (kind === 'entry-point' || isAbsolute(path)) return undefined;
+      if (path === 'react' || path.startsWith('react/')) return { path, external: true };
+      if (path === 'ink' || /[\\/]node_modules[\\/]/.test(importer)) return undefined;
+      return { path, external: true };
+    });
+    build.onResolve({ filter: /^\.\/devtools\.js$/ }, ({ importer }) =>
+      /[\\/]node_modules[\\/]ink[\\/]/.test(importer)
+        ? { path: 'ink-devtools', namespace: 'mixdog-omitted' }
+        : undefined
+    );
+    build.onLoad({ filter: /.*/, namespace: 'mixdog-omitted' }, () => ({ contents: '' }));
+  },
+};
+
 await build({
   entryPoints: [join(SRC, 'index.jsx')],
   outfile: join(SRC, 'dist', 'index.mjs'),
@@ -49,11 +74,9 @@ await build({
   platform: 'node',
   target: 'node22',
   jsx: 'automatic',
-  // Keep package imports external like the original CLI flow. Local shared
-  // helpers are bundled so relative paths stay valid from src/tui/dist/.
-  // Process shutdown stays external so the CLI and checked-in TUI bundle use
-  // the same process-global lifecycle state.
-  packages: 'external',
+  // Local shared helpers are bundled so relative paths stay valid from
+  // src/tui/dist/. Process shutdown stays external so the CLI and checked-in
+  // TUI bundle use the same process-global lifecycle state.
   // Bundled CJS helpers (e.g. src/lib/mixdog-debug.cjs) compile to esbuild's
   // __require shim, which throws "Dynamic require of ..." in plain ESM.
   // Provide a real module-scope require so those requires resolve at runtime.
@@ -73,7 +96,7 @@ await build({
     '../../runtime/channels/lib/voice-runtime-fetcher.mjs',
     '../../runtime/channels/lib/whisper-server.mjs',
   ],
-  plugins: [sharedRuntimeExternalPlugin, sessionClientExternalPlugin],
+  plugins: [sharedRuntimeExternalPlugin, sessionClientExternalPlugin, bundleInkPlugin],
   logLevel: 'info',
 });
 

package/scripts/computer-task-cost-report.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
+import { percentile, sortedFinite } from './lib/trace-stats.mjs';
 
 function arg(name, fallback) {
   const prefix = `--${name}=`;
@@ -14,23 +15,15 @@ function load(path) {
   return JSON.parse(readFileSync(resolve(path), 'utf8'));
 }
 
-function percentile(values, fraction) {
-  const sorted = values
-    .map(Number)
-    .filter(Number.isFinite)
-    .sort((a, b) => a - b);
-  if (sorted.length === 0) return 0;
-  return sorted[Math.max(0, Math.ceil(sorted.length * fraction) - 1)];
-}
-
 function fixed(value, digits = 2) {
   return Number(Number(value || 0).toFixed(digits));
 }
 
 function distribution(values) {
+  const sorted = sortedFinite(values.map(Number));
   return {
-    p50: percentile(values, 0.5),
-    p95: percentile(values, 0.95),
+    p50: percentile(sorted, 50),
+    p95: percentile(sorted, 95),
   };
 }
 

package/scripts/graph-parity.mjs

@@ -6,6 +6,7 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { pathToFileURL } from 'node:url';
+import { median, sortedFinite } from './lib/trace-stats.mjs';
 
 const USAGE = `usage: node scripts/graph-parity.mjs --old <binary> --new <binary> [--root <dir>] [--files <rel>...] [--json <out>] [--kind-map <path.json>] [--tokens] [--allow-new-languages <ids>] [--max-symbol-loss N] [--max-import-diff N] [--max-token-loss N] [--max-time-ratio 1.10] [--runs 3]
        node scripts/graph-parity.mjs --old-jsonl <file> --new-jsonl <file> [thresholds...]`;
@@ -227,13 +228,6 @@ function asStr(v) {
   return typeof v === 'string' ? v : '';
 }
 
-function median(values) {
-  const s = [...values].sort((a, b) => a - b);
-  if (!s.length) return 0;
-  const mid = Math.floor(s.length / 2);
-  return s.length % 2 ? s[mid] : (s[mid - 1] + s[mid]) / 2;
-}
-
 function normalizeSymbol(s) {
   return {
     name: String(s?.name ?? ''),
@@ -1018,7 +1012,7 @@ async function runTimedWalks(bin, root, runs) {
     times.push(result.ms);
     last = result;
   }
-  return { times, medianMs: median(times), stdout: last.stdout };
+  return { times, medianMs: median(sortedFinite(times)), stdout: last.stdout };
 }
 
 function kindMapError(message) {

package/scripts/lib/changed-tests.mjs

@@ -0,0 +1,104 @@
+// `--changed`: the test files whose relative references reach a file that
+// differs from HEAD (tracked edits and untracked files). The graph is read from
+// source text — `import … from`, `export … from`, `import()`, `require()` and
+// `new URL(…, import.meta.url)` with a './' or '../' path — so an asset a module
+// finds another way (a path joined at run time, a skill's markdown) is not an
+// edge; those changed files are reported back as unreached so the caller can
+// add a path filter for them.
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, posix, relative } from 'node:path';
+
+// A module names what it loads by a relative path in four ways: a static or
+// re-exporting import, a dynamic import(), require(), and a file URL resolved
+// against import.meta.url (a spawned worker, a fixture script, a PowerShell source).
+const RELATIVE_IMPORT =
+  /(?:\bimport\s*(?:[^'"()]*?\bfrom\s*)?|\bexport\s+[^'"()]*?\bfrom\s*|\bimport\s*\(\s*|\brequire\s*\(\s*|\bnew\s+URL\s*\(\s*)['"](\.{1,2}\/[^'"]+)['"]/g;
+const SUFFIXES = ['', '.mjs', '.js', '.ts', '.tsx', '.mts', '.cjs', '/index.mjs', '/index.js', '/index.ts'];
+const SOURCE = /\.(?:mjs|cjs|js|ts|tsx|mts)$/;
+
+const toPosix = (path) => path.replaceAll('\\', '/');
+
+function gitLines(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8' })
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+/** Paths relative to cwd that differ from HEAD, plus untracked ones. */
+export function changedFiles(cwd = process.cwd()) {
+  const tracked = gitLines(['diff', '--name-only', '--relative', 'HEAD'], cwd);
+  const untracked = gitLines(['ls-files', '--others', '--exclude-standard'], cwd);
+  return [...new Set([...tracked, ...untracked].map(toPosix))].sort();
+}
+
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// The module a relative specifier names, relative to cwd, or '' when no file
+// answers it (a generated or missing module is simply not an edge).
+function resolveImport(cwd, fromFile, specifier) {
+  const base = join(cwd, dirname(fromFile), specifier);
+  for (const suffix of SUFFIXES) {
+    const candidate = `${base}${suffix}`;
+    if (isFile(candidate)) return toPosix(relative(cwd, candidate));
+  }
+  return '';
+}
+
+export function createImportGraph(cwd = process.cwd()) {
+  const edges = new Map();
+  return (file) => {
+    if (edges.has(file)) return edges.get(file);
+    let text = '';
+    if (SOURCE.test(file) && existsSync(join(cwd, file))) text = readFileSync(join(cwd, file), 'utf8');
+    const targets = new Set();
+    for (const match of text.matchAll(RELATIVE_IMPORT)) {
+      const target = resolveImport(cwd, file, match[1]);
+      if (target) targets.add(posix.normalize(target));
+    }
+    const list = [...targets];
+    edges.set(file, list);
+    return list;
+  };
+}
+
+/**
+ * The test files that reach a changed file through static imports, and the
+ * changed files no selected or unselected test reaches.
+ */
+export function selectChangedTests(testFiles, changed, cwd = process.cwd(), importsOf = createImportGraph(cwd)) {
+  const changedSet = new Set(changed.map(toPosix));
+  // Every module the tests import, with who imports it: reachability then runs
+  // backwards from the changed files, which stays exact through import cycles.
+  const seen = new Set();
+  const importers = new Map();
+  const stack = testFiles.map(toPosix);
+  while (stack.length) {
+    const file = stack.pop();
+    if (seen.has(file)) continue;
+    seen.add(file);
+    for (const target of importsOf(file)) {
+      if (!importers.has(target)) importers.set(target, []);
+      importers.get(target).push(file);
+      if (!seen.has(target)) stack.push(target);
+    }
+  }
+  const affected = new Set();
+  const queue = [...changedSet].filter((file) => seen.has(file));
+  while (queue.length) {
+    const file = queue.pop();
+    if (affected.has(file)) continue;
+    affected.add(file);
+    queue.push(...(importers.get(file) || []));
+  }
+  const selected = testFiles.filter((file) => affected.has(toPosix(file)));
+  const unreached = [...changedSet].filter((file) => !seen.has(file) && existsSync(join(cwd, file)));
+  return { selected, unreached };
+}

package/scripts/lib/cli-args.mjs

@@ -0,0 +1,43 @@
+// Argv reading shared by the scripts/ CLIs (bench, diag and smoke runners).
+// `--name value` and `--name=value` are equivalent; a missing option yields
+// the caller's fallback. `argv` is a seam for tests only — callers keep
+// reading the live process arguments.
+export function argValue(name, fallback = null, argv = process.argv) {
+  const index = argv.indexOf(name);
+  if (index >= 0 && index + 1 < argv.length) return argv[index + 1];
+  const prefix = `${name}=`;
+  const hit = argv.find((arg) => arg.startsWith(prefix));
+  return hit ? hit.slice(prefix.length) : fallback;
+}
+
+export function hasFlag(name, argv = process.argv) {
+  return argv.includes(name);
+}
+
+// The non-flag entries of `argv` (user arguments only, e.g.
+// process.argv.slice(2)). A bare `--name` consumes the next entry as its
+// value unless it is in `booleanFlags`; `--name=value` consumes nothing.
+export function positionalArgs(argv, booleanFlags) {
+  return argv.filter((arg, index) => {
+    if (arg.startsWith('--')) return false;
+    const prev = index > 0 ? argv[index - 1] : '';
+    return !(prev.startsWith('--') && !prev.includes('=') && !booleanFlags.has(prev));
+  });
+}
+
+// A numeric option that keeps a deliberate 0 (or negative): only a missing,
+// blank or non-numeric value takes the fallback.
+export function numArg(name, fallback, argv = process.argv) {
+  const raw = argValue(name, null, argv);
+  if (raw == null || raw.trim() === '') return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+// A positive-integer option: a missing, non-numeric or non-positive value
+// keeps the fallback, so a typo degrades to the documented default instead of
+// silently running with NaN.
+export function intArg(name, fallback, argv = process.argv) {
+  const parsed = Number.parseInt(argValue(name, String(fallback), argv), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}

package/scripts/lib/cli-args.test.mjs

@@ -0,0 +1,64 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { argValue, hasFlag, intArg, numArg, positionalArgs } from './cli-args.mjs';
+
+test('argValue reads both the separated and the joined option form', () => {
+  const argv = ['node', 'bench.mjs', '--model', 'opus', '--round=3', '--trailing'];
+  assert.equal(argValue('--model', null, argv), 'opus');
+  assert.equal(argValue('--round', null, argv), '3');
+  assert.equal(argValue('--missing', null, argv), null);
+  assert.equal(argValue('--missing', 'fallback', argv), 'fallback');
+  // An explicit `undefined` fallback takes the parameter default, so a
+  // missing option always reads as null rather than undefined.
+  assert.equal(argValue('--missing', undefined, argv), null);
+});
+
+test('argValue falls back when the separated form has no value left', () => {
+  assert.equal(argValue('--save', 'default', ['node', 'bench.mjs', '--save']), 'default');
+  // An empty joined value is a value, not a missing option.
+  assert.equal(argValue('--save', 'default', ['node', 'bench.mjs', '--save=']), '');
+  // The next argument is taken verbatim, even when it looks like a flag.
+  assert.equal(argValue('--save', null, ['node', 'bench.mjs', '--save', '--json']), '--json');
+});
+
+test('hasFlag reports presence only', () => {
+  const argv = ['node', 'bench.mjs', '--json', '--limit=5'];
+  assert.equal(hasFlag('--json', argv), true);
+  assert.equal(hasFlag('--limit', argv), false);
+  assert.equal(hasFlag('--quiet', argv), false);
+});
+
+test('intArg accepts positive integers and keeps the fallback otherwise', () => {
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '5']), 5);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit=12']), 12);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs']), 30);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', 'abc']), 30);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '0']), 30);
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '-4']), 30);
+  // parseInt stops at the first non-digit, as the CLIs have always accepted.
+  assert.equal(intArg('--limit', 30, ['node', 'diag.mjs', '--limit', '7x']), 7);
+});
+
+test('numArg keeps a deliberate 0 and falls back only on missing or non-numeric values', () => {
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '0']), 0);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget=0']), 0);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '2500']), 2500);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', '0.5']), 0.5);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs']), 16000);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget=']), 16000);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget', 'lots']), 16000);
+  assert.equal(numArg('--budget', 16000, ['node', 'bench.mjs', '--budget']), 16000);
+});
+
+test('positionalArgs never lets a boolean flag or a joined value swallow a positional', () => {
+  const booleans = new Set(['--render']);
+  assert.deepEqual(positionalArgs(['--render', 'deck.js', 'deck.pptx', '--mode', 'auto'], booleans), [
+    'deck.js',
+    'deck.pptx',
+  ]);
+  assert.deepEqual(positionalArgs(['--mode=auto', 'deck.js', 'deck.pptx'], booleans), ['deck.js', 'deck.pptx']);
+  assert.deepEqual(positionalArgs(['deck.js', '--out', 'result.json', 'deck.pptx', '--render'], booleans), [
+    'deck.js',
+    'deck.pptx',
+  ]);
+});

package/scripts/lib/embedding-model-bench-core.mjs

@@ -344,10 +344,3 @@ export function aggregateScoredRows(rows) {
   }
   return { overall: aggregate(rows), byLanguage };
 }
-
-export function percentile(values, ratio) {
-  if (!Array.isArray(values) || values.length === 0) return 0;
-  const sorted = [...values].sort((left, right) => left - right);
-  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * ratio) - 1));
-  return sorted[index];
-}

package/scripts/lib/run-node-tests.mjs

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { appendFile, mkdtemp, readFile, rm } from 'node:fs/promises';
+import { appendFile, mkdtemp, readdir, readFile, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { FAILURE_RECORDS_ENV } from './test-failure-records.mjs';
@@ -16,6 +16,29 @@ export const ARG_BUDGET = process.platform === 'win32' ? 30_000 : 1_000_000;
 // An argument costs its own characters plus the separator and its quotes.
 const argCost = (arg) => arg.length + 3;
 
+// Full logs are kept for reading after the run; older ones are stale.
+const TEST_LOG_PREFIX = 'mixdog-test-output-';
+const TEST_LOG_RETENTION_MS = 3 * 24 * 60 * 60 * 1000;
+
+async function pruneStaleTestLogs(root) {
+  let names = [];
+  try {
+    names = await readdir(root);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - TEST_LOG_RETENTION_MS;
+  for (const name of names) {
+    if (!name.startsWith(TEST_LOG_PREFIX)) continue;
+    const path = join(root, name);
+    try {
+      if ((await stat(path)).mtimeMs < cutoff) await rm(path, { recursive: true, force: true });
+    } catch {
+      /* another run may own or be removing it */
+    }
+  }
+}
+
 // Batches keep the file order Node was given; a single path larger than the
 // budget still gets its own batch rather than being dropped. An empty list
 // stays one batch: Node's own discovery is what an argument-less run means.
@@ -75,11 +98,16 @@ export async function runNodeTests(
   fileArgs,
   { argBudget = ARG_BUDGET, coverage = false, rerunFailed = 0 } = {}
 ) {
-  const logPath = join(await mkdtemp(join(tmpdir(), 'mixdog-test-output-')), 'full.log');
+  await pruneStaleTestLogs(tmpdir());
+  const logPath = join(await mkdtemp(join(tmpdir(), TEST_LOG_PREFIX)), 'full.log');
   console.error(`Full test log: ${logPath}`);
   // Failure records live outside the log directory: the log directory holds
   // exactly one merged log, and these records are an internal artifact.
   const failureDir = await mkdtemp(join(tmpdir(), 'mixdog-test-failures-'));
+  // Test processes get a private temp root that is removed after the run, so
+  // every fixture directory a test forgets to delete goes with it instead of
+  // piling up in the system temp directory.
+  const scratchDir = await mkdtemp(join(tmpdir(), 'mixdog-test-scratch-'));
   const runArgs = [
     ...nodeArgs,
     `--test-reporter=${SUMMARY_REPORTER}`,
@@ -97,6 +125,9 @@ export async function runNodeTests(
   // already budgeted, and a third reporter would warn about listeners.
   const childEnv = (recordsPath) => ({
     ...process.env,
+    TEMP: scratchDir,
+    TMP: scratchDir,
+    TMPDIR: scratchDir,
     [FAILURE_RECORDS_ENV]: recordsPath,
     ...(coverageDir ? { NODE_V8_COVERAGE: coverageDir } : {}),
   });
@@ -142,6 +173,8 @@ export async function runNodeTests(
   process.exitCode = status;
 
   await rm(failureDir, { recursive: true, force: true });
+  // A process a test left running may still hold a file; what it holds stays.
+  await rm(scratchDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }).catch(() => {});
   if (coverageDir) {
     const { reportCoverage } = await import('./coverage.mjs');
     await reportCoverage(coverageDir);

package/scripts/lib/trace-stats.mjs

@@ -0,0 +1,38 @@
+// Latency statistics shared by the scripts/ CLIs and benches. Nearest-rank
+// percentiles: p50 of an even-sized sample is the lower middle sample, never
+// an interpolated value, so a reported number is always one the run actually
+// produced. An empty sample reports null rather than a zero that would read
+// as a real measurement.
+
+// `p` is a percent (0-100); `sorted` must already be ascending.
+export function percentile(sorted, p) {
+  if (sorted.length === 0) return null;
+  const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
+  return sorted[index];
+}
+
+// The nearest-rank p50 of an ascending sample.
+export function median(sorted) {
+  return percentile(sorted, 50);
+}
+
+// The finite number samples in ascending order, as a new array; anything
+// else (NaN, Infinity, null, strings) is dropped, never coerced.
+export function sortedFinite(values) {
+  return values.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
+}
+
+export function stats(nums) {
+  const arr = sortedFinite(nums);
+  if (arr.length === 0) return null;
+  const sum = arr.reduce((a, b) => a + b, 0);
+  return {
+    n: arr.length,
+    sum,
+    avg: Math.round(sum / arr.length),
+    p50: percentile(arr, 50),
+    p90: percentile(arr, 90),
+    p99: percentile(arr, 99),
+    max: arr[arr.length - 1],
+  };
+}

package/scripts/lib/trace-stats.test.mjs

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { median, percentile, sortedFinite, stats } from './trace-stats.mjs';
+
+test('percentile picks the nearest rank of an ascending sample', () => {
+  const sorted = [10, 20, 30, 40];
+  assert.equal(percentile(sorted, 50), 20);
+  assert.equal(percentile(sorted, 90), 40);
+  assert.equal(percentile(sorted, 99), 40);
+  assert.equal(percentile([5], 50), 5);
+  assert.equal(percentile([], 50), null);
+  // Rank 0 and below clamp to the first sample, never to undefined.
+  assert.equal(percentile(sorted, 0), 10);
+});
+
+test('median is the nearest-rank p50: the lower middle sample, null when empty', () => {
+  assert.equal(median([10, 20, 30, 40]), 20);
+  assert.equal(median([10, 20, 30]), 20);
+  assert.equal(median([7]), 7);
+  assert.equal(median([]), null);
+});
+
+test('percentile is nearest-rank, not floor(n*p) index truncation', () => {
+  // floor(n*p) indexing reports 20 for p50 of [10,20] and 20 for p95 of 1..20.
+  assert.equal(percentile([10, 20], 50), 10);
+  assert.equal(
+    percentile(
+      Array.from({ length: 20 }, (_, i) => i + 1),
+      95
+    ),
+    19
+  );
+});
+
+test('sortedFinite sorts a copy and drops non-finite entries without coercing them', () => {
+  const input = [3, null, '2', Number.NaN, 1, undefined, Number.NEGATIVE_INFINITY];
+  assert.deepEqual(sortedFinite(input), [1, 3]);
+  assert.equal(input[0], 3);
+});
+
+test('stats summarizes finite samples and reports null for an empty set', () => {
+  assert.deepEqual(stats([30, 10, 20]), { n: 3, sum: 60, avg: 20, p50: 20, p90: 30, p99: 30, max: 30 });
+  assert.equal(stats([]), null);
+  assert.equal(stats([Number.NaN, Number.POSITIVE_INFINITY]), null);
+});
+
+test('stats drops non-finite samples and leaves the caller array untouched', () => {
+  const input = [3, Number.NaN, 1, Number.POSITIVE_INFINITY, 2];
+  assert.deepEqual(stats(input), { n: 3, sum: 6, avg: 2, p50: 2, p90: 3, p99: 3, max: 3 });
+  assert.deepEqual(input, [3, Number.NaN, 1, Number.POSITIVE_INFINITY, 2]);
+});
+
+test('stats rounds the average, matching the reported millisecond columns', () => {
+  assert.equal(stats([1, 2]).avg, 2);
+  assert.equal(stats([1, 1, 2]).avg, 1);
+});

package/scripts/llm-trace-summary.mjs

@@ -3,19 +3,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import { parseSince } from './lib/parse-since.mjs';
-
-function argValue(name, fallback = null) {
-  const idx = process.argv.indexOf(name);
-  if (idx >= 0 && idx + 1 < process.argv.length) return process.argv[idx + 1];
-  const pref = `${name}=`;
-  const hit = process.argv.find((arg) => arg.startsWith(pref));
-  return hit ? hit.slice(pref.length) : fallback;
-}
-
-function intArg(name, fallback) {
-  const n = Number.parseInt(argValue(name, String(fallback)), 10);
-  return Number.isFinite(n) && n > 0 ? n : fallback;
-}
+import { argValue, intArg } from './lib/cli-args.mjs';
+import { stats } from './lib/trace-stats.mjs';
 
 const pathArg = argValue('--path', null);
 const dataDir = argValue('--data-dir', null);
@@ -94,27 +83,6 @@ function values(rows, name) {
   return rows.map((row) => numberField(row, name)).filter((n) => n != null);
 }
 
-function percentile(sorted, p) {
-  if (sorted.length === 0) return null;
-  const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
-  return sorted[idx];
-}
-
-function stats(nums) {
-  const arr = nums.filter((n) => Number.isFinite(n)).sort((a, b) => a - b);
-  if (arr.length === 0) return null;
-  const sum = arr.reduce((a, b) => a + b, 0);
-  return {
-    n: arr.length,
-    sum,
-    avg: Math.round(sum / arr.length),
-    p50: percentile(arr, 50),
-    p90: percentile(arr, 90),
-    p99: percentile(arr, 99),
-    max: arr[arr.length - 1],
-  };
-}
-
 function formatStats(s) {
   if (!s) return 'n=0';
   return `n=${s.n} avg=${s.avg}ms p50=${s.p50}ms p90=${s.p90}ms p99=${s.p99}ms max=${s.max}ms`;

package/scripts/native-tool-download.mjs

@@ -32,6 +32,11 @@ export const NATIVE_TOOL_PLATFORM_KEYS = Object.freeze([
   'win32-x64',
 ]);
 
+/** Platforms a native tool release may add beyond the required set. A host
+ *  whose manifest lacks one runs the asset platformKeyCandidates falls back to
+ *  (Windows on ARM runs win32-x64 under emulation). */
+export const OPTIONAL_NATIVE_TOOL_PLATFORM_KEYS = Object.freeze(['win32-arm64']);
+
 /** Released asset name. */
 export function nativeToolAssetName(kind, target) {
   const suffix = target.platform === 'win32' ? '.exe' : '';