mixdog 0.9.173 → 0.9.174

package/scripts/office/author-deck.mjs

@@ -6,18 +6,12 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { executeOfficeTool } from '../../src/runtime/office/index.mjs';
 import { isAdvisoryOfficeIssue } from '../../src/runtime/office/quality/quality-pipeline.mjs';
+import { argValue, hasFlag, positionalArgs } from '../lib/cli-args.mjs';
 
 const value = (result) => JSON.parse(result.content[0].text);
-const argv = process.argv.slice(2);
-const flag = (name) => {
-  const at = argv.indexOf(name);
-  return at >= 0 ? argv[at + 1] : null;
-};
-const positional = argv.filter(
-  (arg, index) =>
-    !arg.startsWith('--') && !(index > 0 && argv[index - 1].startsWith('--') && !['--render'].includes(argv[index - 1]))
-);
-const [scriptPath, deckPath] = positional;
+// Flags that take no value; every other bare `--flag` consumes the next entry.
+const BOOLEAN_FLAGS = new Set(['--render']);
+const [scriptPath, deckPath] = positionalArgs(process.argv.slice(2), BOOLEAN_FLAGS);
 if (!scriptPath || !deckPath) {
   console.error(
     'usage: node scripts/office/author-deck.mjs <script.js> <deck.pptx> [--mode portable|auto] [--render] [--critique critique.json] [--out result.json]'
@@ -26,7 +20,7 @@ if (!scriptPath || !deckPath) {
 }
 const cwd = resolve('.');
 const script = await readFile(scriptPath, 'utf8');
-const mode = flag('--mode') || 'portable';
+const mode = argValue('--mode') || 'portable';
 const authored = value(
   await executeOfficeTool({ action: 'author', path: deckPath, script, mode, overwrite: true, render: false }, { cwd })
 );
@@ -52,7 +46,7 @@ const result = {
   authored: { kit: authored.kit, nativeGradients: authored.nativeGradients || 0, bytes: authored.bytes },
   issues,
 };
-if (argv.includes('--render') || flag('--critique')) {
+if (hasFlag('--render') || argValue('--critique')) {
   const rendered = value(await executeOfficeTool({ action: 'render', session }, { cwd }));
   result.render = {
     output: rendered.output,
@@ -67,7 +61,7 @@ if (argv.includes('--render') || flag('--critique')) {
   if (rendered.contactSheet?.path) console.log(`  contact sheet: ${rendered.contactSheet.path}`);
   if (rendered.receipt?.deck?.rhythm) console.log(`  rhythm: ${JSON.stringify(rendered.receipt.deck.rhythm)}`);
 }
-const critiquePath = flag('--critique');
+const critiquePath = argValue('--critique');
 if (critiquePath) {
   const critique = JSON.parse(await readFile(critiquePath, 'utf8'));
   const finalized = value(
@@ -86,7 +80,7 @@ if (critiquePath) {
 } else {
   await executeOfficeTool({ action: 'close', session, save: false }, { cwd }).catch(() => {});
 }
-const out = flag('--out');
+const out = argValue('--out');
 if (out) await writeFile(out, JSON.stringify(result, null, 2));
 let exitCode = 0;
 if (critiquePath && !result.finalize?.ok) exitCode = 3;

package/scripts/patch-replay.mjs

@@ -11,17 +11,7 @@ import { homedir, tmpdir } from 'node:os';
 import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.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((a) => a.startsWith(pref));
-  return hit ? hit.slice(pref.length) : fallback;
-}
-function hasFlag(name) {
-  return process.argv.includes(name);
-}
+import { argValue, hasFlag } from './lib/cli-args.mjs';
 
 function replayDir() {
   if (process.env.MIXDOG_PATCH_REPLAY_DIR) return resolve(process.env.MIXDOG_PATCH_REPLAY_DIR);

package/scripts/perf/transcript-runtime-probe.mjs

@@ -16,6 +16,7 @@ import {
 import { readTopLevelLifecycleRecord } from '../../src/runtime/agent/orchestrator/session/lifecycle-scan.mjs';
 import { createCanonicalSessionReader } from '../../src/runtime/agent/orchestrator/session/store/canonical-reader.mjs';
 import { yieldToRenderer } from '../../src/tui/session/render-timing.mjs';
+import { median, sortedFinite } from '../lib/trace-stats.mjs';
 
 const directory = mkdtempSync(join(tmpdir(), 'mixdog-transcript-perf-'));
 const messages = Array.from({ length: 1000 }, (_, i) => ({
@@ -28,7 +29,6 @@ writeFileSync(target, raw);
 const currentReader = createCanonicalSessionReader();
 const oldReader = () => readTopLevelLifecycleRecord(readFileSync(target, 'utf8'));
 const currentFloors = (value) => Math.max(denseTokenFloor(value), structuredTokenFloor(value));
-const median = (values) => [...values].sort((a, b) => a - b)[Math.floor(values.length / 2)];
 const timed = async (name, action, repetitions = 5) => {
   const samples = [];
   for (let i = 0; i < repetitions; i++) {
@@ -37,7 +37,7 @@ const timed = async (name, action, repetitions = 5) => {
     await action();
     samples.push(performance.now() - start);
   }
-  return { name, medianMs: +median(samples).toFixed(3), samplesMs: samples.map((n) => +n.toFixed(3)) };
+  return { name, medianMs: +median(sortedFinite(samples)).toFixed(3), samplesMs: samples.map((n) => +n.toFixed(3)) };
 };
 const results = [];
 results.push(

package/scripts/pptx-kit-index.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// Builds the pptx skill's helper index (references/kit-index.md) from the code the runtime runs before every deck
+// script: kit.md, charts.md, and pictures.md. The model reads the index — each helper's signature and the guidance
+// written above it — instead of every helper's body; the bodies stay where they are, and run.
+//   node scripts/pptx-kit-index.mjs          rewrite the index
+//   node scripts/pptx-kit-index.mjs --check  exit 1 when the index is stale
+import { readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { parse } from 'acorn';
+
+const REFERENCES = resolve(dirname(fileURLToPath(import.meta.url)), '../src/defaults/skills/pptx/references');
+export const KIT_INDEX_PATH = join(REFERENCES, 'kit-index.md');
+// Which prose of a source travels with its helpers: kit.md and charts.md are read only through the index, so their
+// rules come along whole; pictures.md is still read on its own trigger, so only its headings mark where helpers sit.
+const SOURCES = [
+  { file: 'kit.md', prose: 'all' },
+  { file: 'charts.md', prose: 'all' },
+  { file: 'pictures.md', prose: 'headings' },
+];
+// A statement this short says its whole meaning (a constant, a one-line arrow); a longer one gives its first line.
+const WHOLE_STATEMENT = 240;
+
+const propertyName = (property) =>
+  property.type === 'Property' ? String(property.key.name ?? property.key.value ?? '') : property.type === 'SpreadElement' ? '…' : '';
+
+// The keys an object literal offers a script, one level into object-valued keys ("body: { x, y, w, h }"). A table of
+// like entries (STYLES: an id per style, each with the same fields) reads as its ids and the fields each carries.
+function objectShape(node) {
+  const properties = node.properties.filter((property) => propertyName(property));
+  const nested = properties.filter((property) => property.value?.type === 'ObjectExpression');
+  if (properties.length >= 4 && nested.length === properties.length) {
+    const fields = [...new Set(nested.flatMap((property) => property.value.properties.map(propertyName)))].filter(Boolean);
+    return `{ ${properties.map(propertyName).join(', ')} } each { ${fields.join(', ')} }`;
+  }
+  const keys = properties.map((property) =>
+    property.value?.type === 'ObjectExpression'
+      ? `${propertyName(property)}: { ${property.value.properties.map(propertyName).filter(Boolean).join(', ')} }`
+      : propertyName(property)
+  );
+  return `{ ${keys.join(', ')} }`;
+}
+
+// What a function hands back when it returns an object literal (zones() → Z, typeScale() → TYPE): the body is
+// elided, and without its shape the script had to open the file to learn Z.foot.takeaway or TYPE.poster.
+function returnedShape(fn) {
+  const shapes = [];
+  const visit = (node) => {
+    if (!node || typeof node.type !== 'string') return;
+    if (node !== fn.body && /Function/.test(node.type)) return;
+    if (node.type === 'ReturnStatement' && node.argument?.type === 'ObjectExpression') shapes.push(objectShape(node.argument));
+    for (const value of Object.values(node)) {
+      if (Array.isArray(value)) value.forEach(visit);
+      else if (value && typeof value === 'object' && typeof value.type === 'string') visit(value);
+    }
+  };
+  visit(fn.body);
+  return shapes.length ? ` // returns ${shapes[shapes.length - 1]}` : '';
+}
+
+function declarationSummary(source, node) {
+  const text = source.slice(node.start, node.end);
+  if (node.type === 'FunctionDeclaration' || node.type === 'ClassDeclaration') {
+    const shape = node.type === 'FunctionDeclaration' ? returnedShape(node) : '';
+    return `${source.slice(node.start, node.body.start).trimEnd()} { … }${shape}`;
+  }
+  if (text.length <= WHOLE_STATEMENT) return text;
+  if (node.type === 'VariableDeclaration') {
+    return node.declarations
+      .map((declarator) => {
+        const init = declarator.init;
+        const head = `${node.kind} ${source.slice(declarator.id.start, declarator.id.end)}`;
+        if (init && (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression')) {
+          return `${head} = ${source.slice(init.start, init.body.start).trimEnd()} …;`;
+        }
+        if (init?.type === 'ObjectExpression') return `${head} = ${objectShape(init)};`;
+        return `${head} = ${source.slice(init?.start ?? declarator.end, declarator.end).split('\n')[0]} …;`;
+      })
+      .join('\n');
+  }
+  return `${text.split('\n')[0]} …`;
+}
+
+function summarizeCode(code) {
+  const comments = [];
+  const program = parse(code, {
+    ecmaVersion: 'latest',
+    sourceType: 'script',
+    allowAwaitOutsideFunction: true,
+    allowReturnOutsideFunction: true,
+    onComment: comments,
+  });
+  const lines = [];
+  let cursor = 0;
+  const pushComments = (until) => {
+    for (const comment of comments) {
+      if (comment.start < cursor || comment.end > until) continue;
+      lines.push(code.slice(comment.start, comment.end));
+    }
+  };
+  for (const node of program.body) {
+    pushComments(node.start);
+    lines.push(declarationSummary(code, node));
+    cursor = node.end;
+  }
+  pushComments(code.length);
+  return lines.join('\n');
+}
+
+function summarizeFile({ file, prose }) {
+  const text = readFileSync(join(REFERENCES, file), 'utf8');
+  const parts = text.split(/^```[^\n]*\n?/m);
+  const output = [];
+  parts.forEach((part, index) => {
+    if (index % 2) {
+      output.push('```js', summarizeCode(part).trimEnd(), '```');
+      return;
+    }
+    const kept = prose === 'all' ? part.trim() : part.split('\n').filter((line) => /^#{1,3} /.test(line)).join('\n');
+    if (kept) output.push(kept.replace(/^# /m, '## '));
+  });
+  return [`# ${file}`, ...output].join('\n\n');
+}
+
+export function buildKitIndex() {
+  return [
+    '# Kit index',
+    '',
+    'Generated from `kit.md`, `charts.md`, and `pictures.md` by `scripts/pptx-kit-index.mjs`; do not edit it by hand.',
+    'The runtime runs every code block of those three files before the script. Here each helper keeps its signature,',
+    'its defaults, and the guidance written above it; a body reads as `{ … }`. Open the helper in its own file only to',
+    'redefine it or when a default this index does not state decides the page.',
+    '',
+    ...SOURCES.map((source) => summarizeFile(source)),
+    '',
+  ].join('\n');
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const next = buildKitIndex();
+  if (process.argv.includes('--check')) {
+    const current = (() => {
+      try {
+        return readFileSync(KIT_INDEX_PATH, 'utf8');
+      } catch {
+        return '';
+      }
+    })();
+    if (current !== next) {
+      console.error('references/kit-index.md is stale: run node scripts/pptx-kit-index.mjs');
+      process.exit(1);
+    }
+  } else {
+    writeFileSync(KIT_INDEX_PATH, next);
+    console.log(`wrote ${KIT_INDEX_PATH} (${next.length} chars)`);
+  }
+}

package/scripts/prepare-native-assets.mjs

@@ -4,6 +4,7 @@ import { chmod, copyFile, mkdir, mkdtemp, rename, rm } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
+import { platformKeyCandidates } from '../src/runtime/shared/native-asset.mjs';
 import { NATIVE_TOOL_FILENAMES, packageNativeToolsDir } from '../src/runtime/shared/native-tool-paths.mjs';
 import { ensureGraphBinary } from '../src/runtime/agent/orchestrator/tools/graph-binary-fetcher.mjs';
 import { ensurePatchBinary } from '../src/runtime/agent/orchestrator/tools/patch-binary-fetcher.mjs';
@@ -31,13 +32,10 @@ export async function prepareRequiredNativeAssets({
   arch = process.arch,
 } = {}) {
   const platformKey = nativeAssetPlatformKey(platform, arch);
-  if (!NATIVE_ASSET_PLATFORMS.includes(platformKey)) {
-    const guidance =
-      platformKey === 'win32-arm64'
-        ? ' Windows ARM64 Node.js is not supported; use x64 Node.js under Windows x64 emulation.'
-        : '';
+  // Windows on ARM runs the x64 assets under its built-in emulation.
+  if (!platformKeyCandidates(platform, arch).some((key) => NATIVE_ASSET_PLATFORMS.includes(key))) {
     throw new Error(
-      `native assets are not published for ${platformKey}; supported: ${NATIVE_ASSET_PLATFORMS.join(', ')}.${guidance}`
+      `native assets are not published for ${platformKey}; supported: ${NATIVE_ASSET_PLATFORMS.join(', ')}.`
     );
   }
   const root = resolve(String(packageRoot || ''));

package/scripts/routing-corpus.mjs

@@ -8,17 +8,7 @@ import { homedir } from 'node:os';
 import { basename, resolve, win32 } from 'node:path';
 import { resolvePluginData } from '../src/runtime/shared/plugin-paths.mjs';
 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((a) => a.startsWith(pref));
-  return hit ? hit.slice(pref.length) : fallback;
-}
-function hasFlag(name) {
-  return process.argv.includes(name);
-}
+import { argValue, hasFlag } from './lib/cli-args.mjs';
 
 function defaultTracePath() {
   const data = process.env.MIXDOG_DATA_DIR || resolvePluginData() || resolve(homedir(), '.mixdog', 'data');

package/scripts/session-diag.mjs

@@ -3,21 +3,10 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import { parseSince } from './lib/parse-since.mjs';
+import { argValue, intArg } from './lib/cli-args.mjs';
+import { stats } from './lib/trace-stats.mjs';
 import { isInclusiveProvider } from '../src/runtime/shared/llm/cost.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;
-}
-
 const pathArg = argValue('--path', null);
 const dataDir = argValue('--data-dir', null);
 const sinceArg = argValue('--since', null);
@@ -86,27 +75,6 @@ function values(nums) {
   return nums.filter((n) => Number.isFinite(n));
 }
 
-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 = values(nums).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 mean(nums) {
   const arr = values(nums);
   if (arr.length === 0) return null;

package/scripts/suite-health.mjs

@@ -12,6 +12,8 @@ export const WORKSPACES = [
   {
     dir: '.',
     exclusions: {
+      test: 'the release gate runtime job runs the default lane on every gated push',
+      'test:slow': 'the release gate runtime-slow job runs it on every gated push',
       'smoke:all': 'aggregate; its components run individually',
       'smoke:loop': 'long-running local endurance harness',
       'smoke:loop:final': 'endurance-harness gate, needs hours of loop data',
@@ -24,6 +26,8 @@ export const WORKSPACES = [
   {
     dir: 'apps/desktop',
     exclusions: {
+      test: 'the release gate desktop-tests fast leg runs it on every gated push',
+      'test:slow': 'the release gate desktop-tests slow leg runs it on every gated push',
       'test:all': 'aggregate of the fast, slow, and live lanes',
       'test:live': 'needs built artifacts; the packaging workflow owns it',
       'test:daemon:e2e': 'needs the built daemon; the release gate desktop job owns it',

package/scripts/test.mjs

@@ -27,9 +27,14 @@ const FILE_LANES = ['fast', 'slow', 'live', 'electron'];
 const LANES = [...FILE_LANES, 'all'];
 
 export const USAGE = `Usage: node scripts/test.mjs [--lane ${LANES.join('|')}] [--exclude-lane <lane>]...
-                             [--rerun-failed <n>] [--list] [--coverage]
+                             [--rerun-failed <n>] [--list] [--coverage] [--changed]
                              [--import <spec>]... [--test-*]... [filter...]
   filter          substring of a file path; only matching files run.
+  --changed       only the selected files whose relative references (import,
+                  import(), require(), new URL(…, import.meta.url)) reach a file
+                  that differs from HEAD (edits and untracked files). A changed
+                  file no test references (a path joined at run time) is listed,
+                  so a path filter can add its tests.
   --lane          fast (default) also covers the electron lane, so a plain run
                   keeps testing it; --lane electron runs those files alone.
   --exclude-lane  drop one lane from the selection, repeatable. Electron and
@@ -84,6 +89,7 @@ export function parseArgs(argv) {
     // were, so nothing downstream can branch on coverage, lane exclusion or
     // re-runs by accident.
     else if (arg === '--coverage') options.coverage = true;
+    else if (arg === '--changed') options.changed = true;
     else if (arg === '--help' || arg === '-h') options.help = true;
     else if (arg === '--exclude-lane') options.excludeLanes = [...(options.excludeLanes ?? []), argv[++index]];
     else if (arg.startsWith('--exclude-lane='))
@@ -144,7 +150,31 @@ async function main() {
     console.log(USAGE);
     return;
   }
-  const files = selectTestFiles(await discoverTestFiles(), options);
+  const discovered = await discoverTestFiles();
+  let files = selectTestFiles(discovered, options);
+  if (options.changed) {
+    // Loaded only for --changed, so a plain run imports nothing it does not use.
+    const { changedFiles, selectChangedTests } = await import('./lib/changed-tests.mjs');
+    // The graph spans every discovered test, so "no test imports it" means none
+    // in this package; the lane and filters then narrow what actually runs.
+    const { selected, unreached: everywhere } = selectChangedTests(discovered, changedFiles());
+    const reaching = new Set(selected);
+    files = files.filter((file) => reaching.has(file));
+    // Another workspace package's files belong to that package's own run.
+    const unreached = everywhere.filter(
+      (file) =>
+        ROOTS.some((root) => (root === '.' ? !file.includes('/') : file.startsWith(`${root}/`))) &&
+        (options.filters.length === 0 || options.filters.some((filter) => file.includes(filter)))
+    );
+    if (unreached.length) {
+      console.error(`--changed: no test imports ${unreached.length} changed file(s); add a path filter for them:`);
+      for (const file of unreached) console.error(`  ${file}`);
+    }
+    if (!files.length) {
+      console.error(`--changed: no ${options.lane} test file matching the filters reaches a changed file`);
+      return;
+    }
+  }
   if (options.list) {
     for (const file of files) console.log(`${laneOf(file).padEnd(5)} ${file}`);
     return;

package/scripts/tidy/sync-engines-manifest.mjs

@@ -8,9 +8,9 @@
  *
  * clang-format source: the npm `clang-format` 1.8.0 tarball only ships
  * win32 / linux_x64 / darwin_x64. muttleyxd/clang-tools-static-binaries
- * clang-format-20 adds darwin-arm64 but still has no linux-arm64. The
- * four available platforms use muttleyxd so every host runs the same
- * clang-format major; linux-arm64 is omitted.
+ * clang-format-20 adds darwin-arm64 but still has no linux-arm64, so the
+ * four platforms it covers use muttleyxd and linux-arm64 takes the same
+ * major from the PyPI `clang-format` manylinux aarch64 wheel.
  */
 import { createHash } from 'node:crypto';
 import { createWriteStream } from 'node:fs';
@@ -79,7 +79,7 @@ const ENGINES = Object.freeze([
     languages: ['c', 'cpp', 'objc', 'java', 'csharp'],
     homepage: 'https://clang.llvm.org/docs/ClangFormat.html',
     resolve: 'clang-format-major',
-    binNames: [],
+    binNames: ['clang-format'],
     assets: {},
   },
   {
@@ -245,13 +245,38 @@ function githubHeaders() {
   return headers;
 }
 
-function downloadHeaders() {
+/** The GitHub token travels only to GitHub; other asset hosts get none. */
+function downloadHeaders(url) {
   const headers = { 'User-Agent': 'mixdog-tidy-engines-sync' };
   const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
-  if (token) headers.Authorization = `Bearer ${token}`;
+  if (token && new URL(url).hostname === 'github.com') headers.Authorization = `Bearer ${token}`;
   return headers;
 }
 
+/** The newest PyPI `clang-format` manylinux aarch64 wheel of one major. */
+async function clangFormatWheel(major) {
+  const response = await fetch('https://pypi.org/pypi/clang-format/json', {
+    headers: { 'User-Agent': 'mixdog-tidy-engines-sync' },
+    signal: AbortSignal.timeout(60_000),
+  });
+  if (!response.ok) throw new Error(`PyPI ${response.status} for clang-format`);
+  const index = await response.json();
+  const versions = Object.keys(index.releases || {})
+    .filter((version) => /^\d+\.\d+\.\d+$/.test(version) && Number(version.split('.')[0]) === major)
+    .sort((left, right) => {
+      const a = left.split('.').map(Number);
+      const b = right.split('.').map(Number);
+      return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+    });
+  for (const version of versions.reverse()) {
+    const wheel = (index.releases[version] || []).find(
+      (file) => file.packagetype === 'bdist_wheel' && !file.yanked && /manylinux_\d+_\d+_aarch64/.test(file.filename)
+    );
+    if (wheel) return { name: wheel.filename, url: wheel.url, size: wheel.size || 0 };
+  }
+  return null;
+}
+
 async function githubJson(url) {
   const response = await fetch(url, { headers: githubHeaders(), redirect: 'follow' });
   if (!response.ok) {
@@ -311,7 +336,7 @@ function clangFormatAssets(release) {
   for (const [platform, name] of Object.entries(map)) {
     assets[platform] = { match: (candidate) => candidate === name };
   }
-  return { version: `${major}.0.0`, assets, missing: ['linux-arm64'] };
+  return { version: `${major}.0.0`, assets };
 }
 
 function findAsset(release, spec, ctx) {
@@ -417,7 +442,7 @@ function pickBinPath(entries, binNames, fallback) {
 
 async function downloadAsset(url, dest) {
   const response = await fetch(url, {
-    headers: downloadHeaders(),
+    headers: downloadHeaders(url),
     redirect: 'follow',
     signal: AbortSignal.timeout(300_000),
   });
@@ -474,16 +499,24 @@ async function resolveEngine(engine, pinTag) {
   let version;
   let assetSpecs = engine.assets;
   const omitted = [];
+  const provided = new Map();
   if (engine.resolve === 'clang-format-major') {
     const picked = clangFormatAssets(release);
     version = picked.version;
     assetSpecs = picked.assets;
-    omitted.push(...picked.missing);
+    const wheel = await clangFormatWheel(Number.parseInt(version, 10));
+    if (wheel) {
+      provided.set('linux-arm64', { platform: 'linux-arm64', ...wheel, archive: 'zip', apiSize: wheel.size });
+    }
   } else {
     version = toSemver(engine.versionFromTag ? engine.versionFromTag(tag) : tag);
   }
   const resolved = [];
   for (const platform of PLATFORMS) {
+    if (provided.has(platform)) {
+      resolved.push(provided.get(platform));
+      continue;
+    }
     const spec = assetSpecs[platform];
     if (!spec) {
       omitted.push(platform);

package/scripts/tool-failures.mjs

@@ -4,14 +4,7 @@ import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import { parseSince } from './lib/parse-since.mjs';
 import { classifyToolFailure } from '../src/runtime/agent/orchestrator/agent-trace-format.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;
-}
+import { argValue } from './lib/cli-args.mjs';
 
 const limit = Math.max(1, Number.parseInt(argValue('--limit', '40'), 10) || 40);
 const dataDir = argValue('--data-dir', null);

package/scripts/tool-stress.mjs

@@ -17,6 +17,7 @@ import { executePatchTool } from '../src/runtime/agent/orchestrator/tools/patch.
 import { normalizeToolEnvelope } from '../src/runtime/agent/orchestrator/session/tool-envelope.mjs';
 import { warmNativeSpawnServer } from '../src/runtime/agent/orchestrator/tools/lib/native-spawn-client.mjs';
 import { warmNativeSearchServer } from '../src/runtime/agent/orchestrator/tools/builtin/native-search-client.mjs';
+import { percentile, sortedFinite } from './lib/trace-stats.mjs';
 
 if (!process.argv.includes('--unsafe-live')) {
   console.error(
@@ -57,12 +58,6 @@ async function timed(tool, expectRe, fn) {
   }
 }
 
-function pct(list, p) {
-  if (!list.length) return 0;
-  const sorted = [...list].sort((a, b) => a - b);
-  return sorted[Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length))];
-}
-
 const tmp = mkdtempSync(join(tmpdir(), 'mixdog-tool-stress-'));
 const t0 = Date.now();
 let prewarmMs = 0;
@@ -259,11 +254,12 @@ let errTotal = 0;
 let warmTailPass = true;
 for (const [tool, s] of [...stats.entries()].sort()) {
   errTotal += s.errs.length;
-  const p95 = pct(s.lat, 95);
+  const lat = sortedFinite(s.lat);
+  const p95 = percentile(lat, 95);
   if (['grep', 'glob', 'find', 'list', 'read'].includes(tool) && p95 > 150) warmTailPass = false;
   console.log(
     `${tool.padEnd(14)} n=${String(s.n).padStart(3)} errs=${s.errs.length}` +
-      ` p50=${pct(s.lat, 50)}ms p95=${p95}ms max=${Math.max(...s.lat)}ms`
+      ` p50=${percentile(lat, 50)}ms p95=${p95}ms max=${Math.max(...s.lat)}ms`
   );
   for (const e of s.errs.slice(0, 3)) console.log(`  ! ${e}`);
 }