mixdog 1.4.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "private": false,
   "type": "module",
   "description": "Open-source coding agent that matches Codex on Terminal-Bench 2.1 with 63% fewer tokens.",

package/scripts/check-voice-runtime-inputs.mjs

@@ -0,0 +1,25 @@
+// Release Gate guard for the immutable voice runtime release. Deploy reuses the
+// published runtime only while the build-input hash of the checkout matches it,
+// so a change to any hash input (scripts/voice-runtime-config.json, the build
+// scripts and workflow, generate-voice-runtime-manifest.mjs) without a
+// runtimeVersion bump fails here on push instead of stopping a live Deploy.
+// A formatter pass that only re-indents those files counts as a change.
+// Run it on a Linux checkout: the hash covers the files as checked out there.
+import { readFile } from 'node:fs/promises';
+
+import {
+  VOICE_RUNTIME_VERSION,
+  assertVoiceRuntimeManifestIdentity,
+  compareSemver,
+} from './generate-voice-runtime-manifest.mjs';
+
+const bundled = JSON.parse(
+  await readFile(new URL('../src/runtime/channels/data/voice-runtime-manifest.json', import.meta.url), 'utf8')
+);
+
+if (compareSemver(VOICE_RUNTIME_VERSION, bundled.version) > 0) {
+  console.log(`voice runtime ${VOICE_RUNTIME_VERSION} is not released yet; Deploy builds it`);
+} else {
+  await assertVoiceRuntimeManifestIdentity(bundled);
+  console.log(`voice runtime ${bundled.version} build inputs match the published runtime`);
+}

package/scripts/gate-local.mjs

@@ -21,6 +21,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { gateTestBudget, runGateLegs } from './lib/gate-scheduler.mjs';
+import { pruneStaleTempDirs, removeTempDirSync } from './lib/stale-temp.mjs';
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const started = Date.now();
@@ -47,8 +48,15 @@ if (build.status !== 0) {
   process.exit(1);
 }
 
-const logDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mixdog-gate-local-'));
-const resourceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mixdog-gate-resources-'));
+// Each run owns its log directory, so concurrent runs never touch each other's
+// logs and the paths the summary prints stay valid after any outcome. Log
+// directories are kept until they go stale; a resources directory a killed
+// run left behind goes the same way. Both are swept at start.
+const LOG_PREFIX = 'mixdog-gate-local-';
+const RESOURCE_PREFIX = 'mixdog-gate-resources-';
+pruneStaleTempDirs([LOG_PREFIX, RESOURCE_PREFIX]);
+const logDir = fs.mkdtempSync(path.join(os.tmpdir(), LOG_PREFIX));
+const resourceDir = fs.mkdtempSync(path.join(os.tmpdir(), RESOURCE_PREFIX));
 const budget = gateTestBudget();
 // weight: relative worker share, roughly each leg's measured duration x its 3 workers
 // (runtime ~440s, runtime-slow ~545s, desktop fast ~390s, desktop slow ~280s).
@@ -66,6 +74,7 @@ function runCmd(cmd, logFd, concurrency) {
     const child = spawn(cmd, {
       cwd: root,
       shell: true,
+      windowsHide: true,
       stdio: ['ignore', logFd, logFd],
       env: {
         ...process.env,
@@ -99,7 +108,7 @@ try {
   await runLeg(legs.at(-1), budget);
   await runGateLegs(legs.slice(0, -1), budget, runLeg);
 } finally {
-  fs.rmSync(resourceDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  removeTempDirSync(resourceDir);
 }
 
 console.log('\n=== gate:local summary ===');

package/scripts/latest-guard.mjs

@@ -17,10 +17,20 @@ function report(text) {
 }
 
 function openIssue(repo, body) {
-  const existing = JSON.parse(gh([
-    'issue', 'list', '--repo', repo, '--state', 'open', '--search', `"${ISSUE_TITLE}" in:title`,
-    '--json', 'number,title',
-  ])).find((issue) => issue.title === ISSUE_TITLE);
+  const existing = JSON.parse(
+    gh([
+      'issue',
+      'list',
+      '--repo',
+      repo,
+      '--state',
+      'open',
+      '--search',
+      `"${ISSUE_TITLE}" in:title`,
+      '--json',
+      'number,title',
+    ])
+  ).find((issue) => issue.title === ISSUE_TITLE);
   if (existing) {
     gh(['issue', 'comment', String(existing.number), '--repo', repo, '--body', body]);
     return `commented on issue #${existing.number}`;
@@ -44,11 +54,13 @@ export function main(repo = process.env.GITHUB_REPOSITORY) {
   const problem = `GitHub Latest was \`${actual ?? 'none'}\` but the newest published app release is \`${expected.tag_name}\`.`;
   gh(['release', 'edit', expected.tag_name, '--repo', repo, '--latest']);
   const repaired = currentLatestTag(repo);
-  const outcome = repaired === expected.tag_name
-    ? `Set Latest back to \`${expected.tag_name}\`.`
-    : `Could not set Latest to \`${expected.tag_name}\`; it is now \`${repaired ?? 'none'}\`.`;
-  const detail = `${problem}\n${outcome}\n\nWorkflow run: ${process.env.GITHUB_SERVER_URL ?? ''}/${repo}/actions/runs/${process.env.GITHUB_RUN_ID ?? ''}\n`
-    + 'Check which release or workflow published a non-app release without `--latest=false` / `make_latest: false`.';
+  const outcome =
+    repaired === expected.tag_name
+      ? `Set Latest back to \`${expected.tag_name}\`.`
+      : `Could not set Latest to \`${expected.tag_name}\`; it is now \`${repaired ?? 'none'}\`.`;
+  const detail =
+    `${problem}\n${outcome}\n\nWorkflow run: ${process.env.GITHUB_SERVER_URL ?? ''}/${repo}/actions/runs/${process.env.GITHUB_RUN_ID ?? ''}\n` +
+    'Check which release or workflow published a non-app release without `--latest=false` / `make_latest: false`.';
   report(`## Latest release guard\n${detail}`);
   try {
     report(`Issue: ${openIssue(repo, detail)}.`);

package/scripts/lib/isolated-test-env.mjs

@@ -2,15 +2,20 @@
 // evaluates imports in order) so the data/home dirs resolve to a scratch dir
 // before any module under test reads them, even under plain `node --test` from a
 // shell that exports the signed-in profile's MIXDOG_DATA_DIR.
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { registerOwnedTempDir } from './scoped-temp.mjs';
+import { pruneStaleTempDirs, removeTempDirSync } from './stale-temp.mjs';
 
-const root = mkdtempSync(join(tmpdir(), 'mixdog-test-profile-'));
+// The exit handler below never runs for a killed process, so each start sweeps
+// what earlier killed processes left.
+const PREFIX = 'mixdog-test-profile-';
+pruneStaleTempDirs([PREFIX]);
+const root = mkdtempSync(join(tmpdir(), PREFIX));
+registerOwnedTempDir(root);
 process.env.MIXDOG_DATA_DIR = join(root, 'data');
 process.env.MIXDOG_HOME = join(root, 'home');
 process.on('exit', () => {
-  try {
-    rmSync(root, { recursive: true, force: true });
-  } catch {}
+  removeTempDirSync(root);
 });

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

@@ -1,8 +1,9 @@
 import { spawn } from 'node:child_process';
-import { appendFile, mkdtemp, readdir, readFile, rm, stat } from 'node:fs/promises';
+import { appendFile, mkdtemp, readFile, rm } from 'node:fs/promises';
 import { availableParallelism, tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
+import { pruneStaleTempDirs } from './stale-temp.mjs';
 import { FAILURE_RECORDS_ENV, spawnLedgerPath } from './test-failure-records.mjs';
 import { classifyRerunOutcomes, formatFailureSummary } from './test-failure-summary.mjs';
 
@@ -20,28 +21,14 @@ const HEAP_FLAG = /^--(?:max-old-space-size|max-semi-space-size)=\d+$/;
 // 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.
+// A green run removes its log directory; a failed run keeps it (the failure
+// summary points at it) until the start-of-run prune finds it stale. The
+// failure and scratch directories are removed when their run ends, so only a
+// killed runner leaves them for that same prune.
 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 */
-    }
-  }
-}
+const TEST_FAILURES_PREFIX = 'mixdog-test-failures-';
+const TEST_SCRATCH_PREFIX = 'mixdog-test-scratch-';
+export const RUNNER_TEMP_PREFIXES = [TEST_LOG_PREFIX, TEST_FAILURES_PREFIX, TEST_SCRATCH_PREFIX];
 
 // 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
@@ -331,14 +318,14 @@ function spawnBatch(args, env, { files, ledger, scratchDir, timeoutMs }) {
 // rm's own maxRetries re-walks the tree on every nested retry, so one held
 // file a few directories down multiplied its delay into hours. Each pass here
 // is a single bounded walk.
-async function removeScratch(dir) {
+async function removeTempDir(dir) {
   for (let attempt = 1; ; attempt += 1) {
     try {
       await rm(dir, { recursive: true, force: true });
       return;
     } catch (error) {
       if (attempt === 5) {
-        console.error(`Test scratch left behind (${error.code}): ${dir}`);
+        console.error(`Test temp dir left behind (${error.code}): ${dir}`);
         return;
       }
       await delay(200 * attempt);
@@ -372,21 +359,37 @@ async function readFailureRecords(path) {
 // log can still name what failed.
 //
 // `testTimeoutMs` is the per-file --test-timeout default (see testTimeoutArg).
-export async function runNodeTests(
-  nodeArgs,
-  fileArgs,
-  { argBudget = ARG_BUDGET, coverage = false, rerunFailed = 0, testTimeoutMs = DEFAULT_TEST_TIMEOUT_MS } = {}
-) {
-  await pruneStaleTestLogs(tmpdir());
-  const logPath = join(await mkdtemp(join(tmpdir(), TEST_LOG_PREFIX)), 'full.log');
+export async function runNodeTests(nodeArgs, fileArgs, options = {}) {
+  pruneStaleTempDirs(RUNNER_TEMP_PREFIXES);
+  const outputDir = await mkdtemp(join(tmpdir(), TEST_LOG_PREFIX));
+  const logPath = join(outputDir, '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-'));
+  const failureDir = await mkdtemp(join(tmpdir(), TEST_FAILURES_PREFIX));
   // 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 scratchDir = await mkdtemp(join(tmpdir(), TEST_SCRATCH_PREFIX));
+  let status = 1;
+  try {
+    status = await executeRun(nodeArgs, fileArgs, options, { logPath, failureDir, scratchDir });
+  } finally {
+    await removeTempDir(failureDir);
+    // Leftover processes are already killed; what a process outside the run
+    // still holds stays behind.
+    await removeTempDir(scratchDir);
+    // A throw keeps the log too: the run did not pass.
+    if (status === 0) await removeTempDir(outputDir);
+  }
+}
+
+async function executeRun(
+  nodeArgs,
+  fileArgs,
+  { argBudget = ARG_BUDGET, coverage = false, rerunFailed = 0, testTimeoutMs = DEFAULT_TEST_TIMEOUT_MS },
+  { logPath, failureDir, scratchDir }
+) {
   // The explicit entry also accepts Node options alongside its file paths.
   const concurrencyArg = testConcurrencyArg([...nodeArgs, ...fileArgs]);
   const timeoutArg = testTimeoutArg([...nodeArgs, ...fileArgs], process.env, testTimeoutMs);
@@ -509,10 +512,6 @@ export async function runNodeTests(
     status = 0;
   process.exitCode = status;
 
-  await rm(failureDir, { recursive: true, force: true });
-  // Leftover processes are already killed; what a process outside the run
-  // still holds stays behind.
-  await removeScratch(scratchDir);
   if (coverageDir) {
     const { reportCoverage } = await import('./coverage.mjs');
     await reportCoverage(coverageDir);
@@ -520,4 +519,5 @@ export async function runNodeTests(
   }
   // Last line of the run, after every reporter and the coverage report.
   process.stdout.write(`\n${formatFailureSummary({ failed, flaky, rerunFailed, hung, exitCode: status })}`);
+  return status;
 }

package/scripts/lib/scoped-temp.d.mts

@@ -0,0 +1,16 @@
+export function makeTempDirSync(prefix: string): string;
+export function registerOwnedTempDir(dir: string): string;
+export function redirectSystemTemp(prefix?: string): string;
+export function removeTempDirSync(dir: string): void;
+export function removeTempDir(dir: string): Promise<void>;
+export function tempDirFor(t: { after(fn: () => unknown): void }, prefix: string): string;
+export interface ScopedTempDir {
+  path: string;
+  join(...parts: string[]): string;
+  remove(): Promise<void>;
+  removeSync(): void;
+  [Symbol.asyncDispose](): Promise<void>;
+  [Symbol.dispose](): void;
+}
+export function scopedTempDir(prefix: string): ScopedTempDir;
+export function withTempDir<T>(prefix: string, fn: (dir: string) => T | Promise<T>): Promise<T>;

package/scripts/lib/scoped-temp.mjs

@@ -0,0 +1,123 @@
+// Scoped scratch directories for tests: every directory this module creates is
+// named `mixdog-<prefix>-*` in the system temp dir and is removed whether the
+// test passed or failed. Removal retries a bounded number of times, because on
+// Windows a just-closed file or a just-exited child can hold a path for a
+// moment (EBUSY / EPERM / ENOTEMPTY).
+//
+// Pick the narrowest scope that fits the test:
+//   tempDirFor(t, prefix)            removed after the node:test context `t`
+//   scopedTempDir(prefix)            `.path` + dispose; use `await using` on
+//                                    Node 24+, or `try { } finally { await d.remove() }`
+//   withTempDir(prefix, fn)          removed when `fn` settles
+//   makeTempDirSync(prefix)          removed by removeTempDirSync, and always swept at
+//                                    process exit (a late write may recreate it)
+// Close anything holding files inside the directory (sqlite handles, servers,
+// child processes) before the removal runs.
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { removeTempDirSync as removeDirWithRetrySync } from './stale-temp.mjs';
+
+const live = new Set();
+let exitHookInstalled = false;
+
+function directoryPrefix(prefix) {
+  const bare = String(prefix)
+    .replace(/^mixdog-/, '')
+    .replace(/-+$/, '');
+  return `mixdog-${bare}-`;
+}
+
+function removeAllAtExit() {
+  for (const dir of live) removeDirWithRetrySync(dir);
+}
+
+function installExitHook() {
+  if (exitHookInstalled) return;
+  exitHookInstalled = true;
+  process.on('exit', removeAllAtExit);
+  // A module under test may add its own exit handler (a final flush can
+  // recreate its directory), so keep this one the last to run.
+  process.on('newListener', (event, listener) => {
+    if (event !== 'exit' || listener === removeAllAtExit) return;
+    queueMicrotask(() => {
+      process.removeListener('exit', removeAllAtExit);
+      process.on('exit', removeAllAtExit);
+    });
+  });
+}
+
+/** Creates `mixdog-<prefix>-*` in the system temp dir; removed at process exit unless removed sooner. */
+export function makeTempDirSync(prefix) {
+  const dir = mkdtempSync(join(tmpdir(), directoryPrefix(prefix)));
+  live.add(dir);
+  installExitHook();
+  return dir;
+}
+
+/**
+ * Registers a directory its creator made as test-owned, so it is swept again
+ * as the last exit step (a late write by the code under test can recreate it
+ * after the creator's own exit handler ran). Only an exact `mixdog-*` child of
+ * the system temp dir is accepted; nothing is ever inferred from an env var.
+ */
+export function registerOwnedTempDir(dir) {
+  const resolved = resolve(dir);
+  const same = (a, b) => (process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b);
+  if (!basename(resolved).startsWith('mixdog-') || !same(dirname(resolved), resolve(tmpdir()))) {
+    throw new Error(`refusing to own a directory outside the system temp root: ${dir}`);
+  }
+  live.add(resolved);
+  installExitHook();
+  return resolved;
+}
+/**
+ * For code under test that makes its own mixdog-* directories in the system
+ * temp dir: points TEMP/TMP/TMPDIR at one scoped directory for the rest of the
+ * process, so everything created there is removed with it at exit.
+ */
+export function redirectSystemTemp(prefix = 'temp-root') {
+  const dir = makeTempDirSync(prefix);
+  process.env.TEMP = dir;
+  process.env.TMP = dir;
+  process.env.TMPDIR = dir;
+  return dir;
+}
+
+export function removeTempDirSync(dir) {
+  if (!removeDirWithRetrySync(dir)) process.stderr.write(`scratch folder ${dir} could not be removed\n`);
+}
+
+export async function removeTempDir(dir) {
+  removeTempDirSync(dir);
+}
+
+/** A directory removed after the node:test context (test or suite) `t` finishes, pass or fail. */
+export function tempDirFor(t, prefix) {
+  const dir = makeTempDirSync(prefix);
+  t.after(() => removeTempDir(dir));
+  return dir;
+}
+
+/** A directory with `.path`, `join()` and `remove()`; also `await using` / `using` disposable. */
+export function scopedTempDir(prefix) {
+  const path = makeTempDirSync(prefix);
+  return {
+    path,
+    join: (...parts) => join(path, ...parts),
+    remove: () => removeTempDir(path),
+    removeSync: () => removeTempDirSync(path),
+    [Symbol.asyncDispose]: () => removeTempDir(path),
+    [Symbol.dispose]: () => removeTempDirSync(path),
+  };
+}
+
+/** Runs `fn(dir)` with a fresh directory and removes it when `fn` settles. */
+export async function withTempDir(prefix, fn) {
+  const dir = makeTempDirSync(prefix);
+  try {
+    return await fn(dir);
+  } finally {
+    await removeTempDir(dir);
+  }
+}

package/scripts/lib/stale-temp.mjs

@@ -0,0 +1,44 @@
+// Temp dirs a test run or the local gate owns. A normal exit removes them, but
+// a killed process runs no exit handler, so each run starts by sweeping what an
+// earlier killed run left behind.
+import { lstatSync, readdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// How long a kept test log stays readable; also what counts as a leftover.
+export const STALE_TEMP_MS = 3 * 24 * 60 * 60 * 1000;
+
+// rmSync retries the lock errors itself (EBUSY, EPERM, ENOTEMPTY, ...) a
+// bounded number of times per entry before it throws. Returns whether the
+// directory is gone; a held file leaves it for the next start-of-run sweep.
+export function removeTempDirSync(dir) {
+  try {
+    rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Removes every directory in `root` whose name starts with one of `prefixes`
+// and whose mtime is older than `maxAgeMs`.
+export function pruneStaleTempDirs(prefixes, { root = tmpdir(), maxAgeMs = STALE_TEMP_MS, now = Date.now() } = {}) {
+  let names = [];
+  try {
+    names = readdirSync(root);
+  } catch {
+    return;
+  }
+  const cutoff = now - maxAgeMs;
+  for (const name of names) {
+    if (!prefixes.some((prefix) => name.startsWith(prefix))) continue;
+    const path = join(root, name);
+    try {
+      // lstat: a link or a plain file that merely matches the prefix is not ours to remove.
+      const info = lstatSync(path);
+      if (info.isDirectory() && info.mtimeMs < cutoff) removeTempDirSync(path);
+    } catch {
+      /* another run may own or be removing it */
+    }
+  }
+}

package/scripts/post-release-check.mjs

@@ -215,12 +215,7 @@ export function getReleaseByTag(repo, tag, run = gh) {
  * rethrown, so an API outage fails the job instead of silently skipping
  * verification of a release that may be public.
  */
-export async function detectPublished({
-  fetchRelease,
-  sleep = defaultSleep,
-  attempts = 5,
-  firstDelayMs = 2000,
-}) {
+export async function detectPublished({ fetchRelease, sleep = defaultSleep, attempts = 5, firstDelayMs = 2000 }) {
   let delay = firstDelayMs;
   for (let attempt = 1; ; attempt++) {
     try {

package/scripts/pptx-kit-index.mjs

@@ -22,7 +22,11 @@ const SOURCES = [
 const WHOLE_STATEMENT = 240;
 
 const propertyName = (property) =>
-  property.type === 'Property' ? String(property.key.name ?? property.key.value ?? '') : property.type === 'SpreadElement' ? '…' : '';
+  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.
@@ -30,7 +34,9 @@ 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);
+    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) =>
@@ -48,7 +54,8 @@ function returnedShape(fn) {
   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));
+    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);
@@ -116,7 +123,13 @@ function summarizeFile({ file, prose }) {
       output.push('```js', summarizeCode(part).trimEnd(), '```');
       return;
     }
-    const kept = prose === 'all' ? part.trim() : part.split('\n').filter((line) => /^#{1,3} /.test(line)).join('\n');
+    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');

package/scripts/suite-health.mjs

@@ -59,6 +59,13 @@ export function selectSuiteScripts(scripts, exclusions) {
   return names.filter((name) => !(name in exclusions));
 }
 
+const lastLines = (text) =>
+  String(text || '')
+    .trim()
+    .split('\n')
+    .slice(-25)
+    .join('\n');
+
 function runSweep() {
   const failures = [];
   const reportLines = [];
@@ -79,7 +86,9 @@ function runSweep() {
         reportLines.push(`- ${label}: OK (${seconds}s)`);
         console.log(`${label}: OK (${seconds}s)`);
       } else {
-        const tail = `${child.stdout || ''}\n${child.stderr || ''}`.trim().split('\n').slice(-25).join('\n');
+        // Tail each stream on its own: a long stderr (cargo build chatter) must
+        // not push the test failure summary on stdout out of the report.
+        const tail = `${lastLines(child.stdout)}\n${lastLines(child.stderr)}`.trim();
         failures.push(`- ${label}: FAILED (${seconds}s)\n\n\`\`\`\n${tail}\n\`\`\``);
         reportLines.push(`- ${label}: FAILED (${seconds}s)`);
         console.error(`${label}: FAILED (${seconds}s)\n${tail}`);

package/scripts/test-data-dir.mjs

@@ -1,19 +1,22 @@
 // Side-effect module: import FIRST in tests that touch the read-snapshot store.
 // Points the Mixdog data dir at a per-run temp dir before snapshot-store.mjs
 // resolves SNAPSHOT_DIR at module load, so tests never write to the real one.
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { registerOwnedTempDir } from './lib/scoped-temp.mjs';
+import { pruneStaleTempDirs, removeTempDirSync } from './lib/stale-temp.mjs';
 
 if (!process.env.MIXDOG_TEST_DATA_DIR_OWNED) {
-  const dir = mkdtempSync(join(tmpdir(), 'mixdog-test-data-'));
+  // The exit handler never runs for a killed process, so each start sweeps
+  // what earlier killed processes left.
+  const prefix = 'mixdog-test-data-';
+  pruneStaleTempDirs([prefix]);
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  registerOwnedTempDir(dir);
   process.env.MIXDOG_DATA_DIR = dir;
   process.env.MIXDOG_TEST_DATA_DIR_OWNED = '1';
   process.on('exit', () => {
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      /* best effort */
-    }
+    removeTempDirSync(dir);
   });
 }

package/src/app.mjs

@@ -24,6 +24,10 @@ export { parseHeadlessExecCommand };
  * running behavior will NOT match the tree, so warn loudly.
  */
 function warnWhenTuiBundleStale(bundle) {
+  // Only a source checkout can drift from its bundle: src/tui/dev is left out
+  // of the npm package, and an npm install stamps every file with its own
+  // extraction time, so the mtime comparison below would misfire there.
+  if (!existsSync(join(__dirname, 'tui', 'dev', 'jit-rebuild.mjs'))) return;
   try {
     const bundleMtime = statSync(bundle).mtimeMs;
     const hotSources = [

package/src/defaults/shipped-history.json

@@ -114,6 +114,7 @@
       "3f5915d27c7659ad82cdbda064acfbfa",
       "4e6134d60ee5c54c2888e874653bcdad",
       "4ecd89b0c07ad8a81aa1f84882cf1b00",
+      "88ac40e616f4c181583c35e591c32952",
       "899529696b7d6d3373ae83a76976ab48",
       "8d343d0a406fd5817b7fd98a3ac47010",
       "a1b73ce404125d3ce0a5762e4a1e1555",
@@ -163,6 +164,7 @@
     "simple.md": [
       "07c197ff8f20e24c65d844cd91711216",
       "16d8b5e7757001c614dae62f18f63aa1",
+      "2d33871a37ab8672ea550c6bfb4ba64d",
       "56b61d99f3179018f65b530d9b1491d7",
       "6e1749aa66d4416cadad4bcd26eb807a",
       "75ca4c5ec12866b2052a6d08b023759d",
@@ -180,6 +182,7 @@
       "00085086a7649ec6631f5cf0a3bbbf60",
       "08eee52328524eb032fd14f342742c41",
       "25a6744e7591ea5597abbda008d123fe",
+      "2e536962f4ff0b8f8028141050c7e7ab",
       "43eeb0b9c5792f08f2223c76846926cb",
       "4ab5316454013712cedb25d9b75f4e43",
       "4f042de090d853ed38aaa82b88d301ac",
@@ -232,6 +235,7 @@
       "8236330f56f27dd283bda6da1239285d",
       "8bc93c9320b83de81baa8cf242af5c0b",
       "8fe64c8f6d81bee2120134adf0d6a471",
+      "9d5afe7dfa82ea3f4c627f71ccdca331",
       "9e7a48df5065f5073bbab6f9db3e4061",
       "b46617cc619e09c35b6bad8f6177e722",
       "c2b0c50791e358064e22be87bdab4707",
@@ -329,6 +333,7 @@
       "48247c1645fd94aad7711082d4512c49",
       "4f94016363acccd788a724a2d414744e",
       "56e474f78faafae39aebe921ccff112d",
+      "5bd2e944160a64669a3e2f09466590b3",
       "60a1e22fd0c32aa283c64a2cc05b7889",
       "6358ad25dd07a2f92ad65c249a4f360b",
       "7fb12aeb07b79ae113c0deb0a90c6da7",