mixdog 0.9.172 → 0.9.174

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');
@@ -292,13 +282,11 @@ function toolSequence(sorted, iters) {
     if (it != null) iters.add(it);
     const tool = field(r, 'tool_name') || '?';
     const rawArgs = field(r, 'tool_args');
-    const summaryArgs = rawArgs;
     sequence.push({
       it: it ?? null,
       tool,
       args: argsSummary(tool, rawArgs),
       rawArgs,
-      inspectArgs: summaryArgs,
       argsHash: field(r, 'tool_args_hash'),
       resultKind: field(r, 'result_kind'),
       resultLines: Number(field(r, 'result_lines_est') || 0),

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;
@@ -149,11 +117,6 @@ function inferProviderFromModel(model) {
   return null;
 }
 
-function sessionInclusive(provider) {
-  if (provider) return isInclusiveProvider(provider);
-  return true;
-}
-
 function usageDenom(row, provider) {
   const prompt = numberField(row, 'prompt_tokens');
   const input = numberField(row, 'input_tokens');
@@ -265,7 +228,6 @@ function deriveSessionMeta(rows) {
     model = usage ? field(usage, 'model') : null;
   }
   if (!provider) provider = inferProviderFromModel(model);
-  const inclusive = sessionInclusive(provider);
   const tsList = sorted.map((r) => Number(r.ts || 0)).filter((n) => n > 0);
   const minTs = tsList.length ? Math.min(...tsList) : 0;
   const maxTs = tsList.length ? Math.max(...tsList) : 0;
@@ -292,7 +254,6 @@ function deriveSessionMeta(rows) {
     agent,
     provider,
     model,
-    inclusive,
     minTs,
     maxTs,
     turns,

package/scripts/session-sweep.mjs

@@ -22,8 +22,7 @@
  *
  * This tool NEVER deletes. It only prints a report.
  */
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { getPluginData } from '../src/runtime/agent/orchestrator/config.mjs';
 import { summaryIndexPath, listStoredSessionSummaries } from '../src/runtime/agent/orchestrator/session/store.mjs';
@@ -153,27 +152,9 @@ function fmtTs(ms) {
   }
 }
 
-function main() {
-  const { maxAgeDays, minClosedAgeDays, now } = parseArgs(process.argv.slice(2));
-  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
-  const minClosedAgeMs = minClosedAgeDays * 24 * 60 * 60 * 1000;
-
-  const dir = join(getPluginData(), 'sessions');
-  if (!existsSync(dir)) {
-    process.stdout.write(`[session-sweep] no sessions dir at ${dir}\n`);
-    return;
-  }
-
-  // Authoritative lifecycle rows (read-only). rebuildIfMissing:false so this
-  // report never triggers a summary-index write.
-  const rows = listStoredSessionSummaries({ rebuildIfMissing: false });
-  const rowById = new Map();
-  for (const r of rows) if (r?.id) rowById.set(r.id, r);
-
-  // Disk scan for sizes + mtime fallback. `.hb` sidecar bytes are attributed
-  // to their session so reclaimable bytes reflect the full on-disk footprint.
-  const files = readdirSync(dir);
-  const jsonFiles = files.filter((f) => f.endsWith('.json'));
+// `.hb` sidecar bytes are attributed to their session so reclaimable bytes
+// reflect the full on-disk footprint of a session.
+function collectHbSidecarSizes(dir, files) {
   const hbSizeById = new Map();
   for (const f of files) {
     if (!f.endsWith('.hb')) continue;
@@ -184,7 +165,42 @@ function main() {
       /* ignore */
     }
   }
+  return hbSizeById;
+}
 
+// Authoritative per-file lifecycle via cheap top-level scan; the summary
+// index is stale here (most on-disk files are unindexed), so the file
+// itself — not the index — decides closed/age. Fall back to the index
+// row, then to file mtime, only when the scan can't resolve a field.
+function classifySessionFile({ full, mtimeMs, row, now, maxAgeMs, minClosedAgeMs }) {
+  let scan = null;
+  try {
+    scan = scanTopLevelScalars(readFileSync(full, 'utf-8'));
+  } catch {
+    scan = null;
+  }
+  const closedScan = scan && (scan.closed === true || scan.status === 'closed');
+  const closedRow = row && (row.closed === true || row.status === 'closed');
+  const closed = scan ? !!closedScan : !!closedRow;
+  let updatedAt = scan && Number(scan.updatedAt) > 0 ? Number(scan.updatedAt) : 0;
+  if (!updatedAt && row && Number(row.updatedAt) > 0) updatedAt = Number(row.updatedAt);
+  if (!updatedAt) updatedAt = mtimeMs;
+  const ageMs = now - updatedAt;
+  // Min-closed-age gate: a closed session only qualifies once its close
+  // timestamp (closedAt when present, else updatedAt — markSessionClosed
+  // sets updatedAt=Date.now() at tombstone time) is older than the gate.
+  // Recently-closed sessions may still be resumed, so keep them.
+  const closedAt = scan && Number(scan.closedAt) > 0 ? Number(scan.closedAt) : updatedAt;
+  const closedAge = now - closedAt;
+  const closedQualifies =
+    closed && (minClosedAgeMs <= 0 || (Number.isFinite(closedAt) && closedAt > 0 && closedAge > minClosedAgeMs));
+  const ageOnly = !closed && maxAgeMs > 0 && Number.isFinite(updatedAt) && updatedAt > 0 && ageMs > maxAgeMs;
+  return { scanned: !!scan, closed, updatedAt, closedQualifies, ageOnly };
+}
+
+// Disk scan for sizes + mtime fallback, then the retention verdict per file
+// rolled into the totals the report prints.
+function collectRetention({ dir, jsonFiles, hbSizeById, rowById, now, maxAgeMs, minClosedAgeMs }) {
   let totalFiles = 0;
   let totalBytes = 0;
   const candidates = []; // { id, reason, updatedAt, bytes, inIndex }
@@ -217,44 +233,19 @@ function main() {
     totalBytes += bytes;
 
     const row = rowById.get(id) || null;
-    // Authoritative per-file lifecycle via cheap top-level scan; the summary
-    // index is stale here (most on-disk files are unindexed), so the file
-    // itself — not the index — decides closed/age. Fall back to the index
-    // row, then to file mtime, only when the scan can't resolve a field.
-    let scan = null;
-    try {
-      scan = scanTopLevelScalars(readFileSync(full, 'utf-8'));
-    } catch {
-      scan = null;
-    }
-    if (!scan) scanFailFiles += 1;
-    const closedScan = scan && (scan.closed === true || scan.status === 'closed');
-    const closedRow = row && (row.closed === true || row.status === 'closed');
-    const closed = scan ? !!closedScan : !!closedRow;
-    let updatedAt = scan && Number(scan.updatedAt) > 0 ? Number(scan.updatedAt) : 0;
-    if (!updatedAt && row && Number(row.updatedAt) > 0) updatedAt = Number(row.updatedAt);
-    if (!updatedAt) updatedAt = mtimeMs;
-    const ageMs = now - updatedAt;
-    // Min-closed-age gate: a closed session only qualifies once its close
-    // timestamp (closedAt when present, else updatedAt — markSessionClosed
-    // sets updatedAt=Date.now() at tombstone time) is older than the gate.
-    // Recently-closed sessions may still be resumed, so keep them.
-    const closedAt = scan && Number(scan.closedAt) > 0 ? Number(scan.closedAt) : updatedAt;
-    const closedAge = now - closedAt;
-    const closedQualifies =
-      closed && (minClosedAgeMs <= 0 || (Number.isFinite(closedAt) && closedAt > 0 && closedAge > minClosedAgeMs));
-    const ageOnly = !closed && maxAgeMs > 0 && Number.isFinite(updatedAt) && updatedAt > 0 && ageMs > maxAgeMs;
+    const verdict = classifySessionFile({ full, mtimeMs, row, now, maxAgeMs, minClosedAgeMs });
+    if (!verdict.scanned) scanFailFiles += 1;
 
-    if (closed && !closedQualifies) {
+    if (verdict.closed && !verdict.closedQualifies) {
       closedButFreshCount += 1;
       closedButFreshBytes += bytes;
     }
-    if (!closedQualifies && !ageOnly) continue; // keep
+    if (!verdict.closedQualifies && !verdict.ageOnly) continue; // keep
 
-    const reason = closedQualifies ? 'closed' : 'age';
-    candidates.push({ id, reason, updatedAt, bytes, inIndex: !!row });
+    const reason = verdict.closedQualifies ? 'closed' : 'age';
+    candidates.push({ id, reason, updatedAt: verdict.updatedAt, bytes, inIndex: !!row });
     reclaimBytes += bytes;
-    if (closedQualifies) {
+    if (verdict.closedQualifies) {
       closedCount += 1;
       closedBytes += bytes;
     } else {
@@ -264,6 +255,37 @@ function main() {
   }
 
   candidates.sort((a, b) => (a.updatedAt || 0) - (b.updatedAt || 0));
+  return {
+    totalFiles,
+    totalBytes,
+    candidates,
+    closedCount,
+    ageOnlyCount,
+    closedBytes,
+    ageOnlyBytes,
+    reclaimBytes,
+    scanFailFiles,
+    closedButFreshCount,
+    closedButFreshBytes,
+    fileIds,
+  };
+}
+
+function renderReport({ dir, rows, now, maxAgeDays, minClosedAgeDays, retention }) {
+  const {
+    totalFiles,
+    totalBytes,
+    candidates,
+    closedCount,
+    ageOnlyCount,
+    closedBytes,
+    ageOnlyBytes,
+    reclaimBytes,
+    scanFailFiles,
+    closedButFreshCount,
+    closedButFreshBytes,
+    fileIds,
+  } = retention;
   const oldest = candidates[0] || null;
   const newest = candidates[candidates.length - 1] || null;
   const dropRows = candidates.filter((c) => c.inIndex).length;
@@ -304,7 +326,31 @@ function main() {
   L.push(`index rows after    : ${rebuiltIndexRows}  (= surviving files; rebuild reindexes all remaining)`);
   L.push('');
   L.push('DRY-RUN ONLY — this tool performed no unlink and no disk writes.');
-  process.stdout.write(`${L.join('\n')}\n`);
+  return `${L.join('\n')}\n`;
+}
+
+function main() {
+  const { maxAgeDays, minClosedAgeDays, now } = parseArgs(process.argv.slice(2));
+  const maxAgeMs = maxAgeDays * 24 * 60 * 60 * 1000;
+  const minClosedAgeMs = minClosedAgeDays * 24 * 60 * 60 * 1000;
+
+  const dir = join(getPluginData(), 'sessions');
+  if (!existsSync(dir)) {
+    process.stdout.write(`[session-sweep] no sessions dir at ${dir}\n`);
+    return;
+  }
+
+  // Authoritative lifecycle rows (read-only). rebuildIfMissing:false so this
+  // report never triggers a summary-index write.
+  const rows = listStoredSessionSummaries({ rebuildIfMissing: false });
+  const rowById = new Map();
+  for (const r of rows) if (r?.id) rowById.set(r.id, r);
+
+  const files = readdirSync(dir);
+  const jsonFiles = files.filter((f) => f.endsWith('.json'));
+  const hbSizeById = collectHbSidecarSizes(dir, files);
+  const retention = collectRetention({ dir, jsonFiles, hbSizeById, rowById, now, maxAgeMs, minClosedAgeMs });
+  process.stdout.write(renderReport({ dir, rows, now, maxAgeDays, minClosedAgeDays, retention }));
 }
 
 main();

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

@@ -2,33 +2,82 @@
 // Discovery-based test entry (docs/testing.md). A test file joins the suite
 // by existing; its lane comes from its name, never from a hand-kept list:
 //
-//   *.test.mjs        fast   the default lane; every push, every local run
-//   *.slow.test.mjs   slow   files over ~10s; their own CI job
-//   *.live.test.mjs   live   need a built artifact or a live system
+//   *.test.mjs           fast     the default lane; every push, every local run
+//   *.slow.test.mjs      slow     files over ~10s; their own CI job
+//   *.live.test.mjs      live     need a built artifact or a live system
+//   *.electron.test.mjs  electron need a real Electron or window-capture
+//                                 surface, so two runs of them cannot overlap
 //
-// Usage: node scripts/test.mjs [--lane fast|slow|live|all] [--list]
-//                              [--import <spec>]... [--test-*]... [filter...]
-//   filter   substring of a file path; only matching files run.
-//   --import forwarded to node (desktop passes its test-env and tsx loaders).
-//   --test-* forwarded to node --test (e.g. --test-name-pattern, --test-only).
+// The electron lane rides the default lane (a plain run still covers it) and
+// `--exclude-lane electron` is the explicit opt-out that lets a second run
+// proceed concurrently; `--lane electron` runs those files alone.
 //
-// Runs from the package that invokes it: `src/` and `scripts/` under cwd are
-// the roots, so the root package and apps/desktop share this one entry.
+// Usage — see USAGE below (`node scripts/test.mjs --help`).
+//
+// Runs from the package that invokes it: `src/`, `scripts/`, `lib/`, `deploy/`
+// and the package root itself are searched under cwd, so the root package,
+// apps/desktop and apps/relay share this one entry. A root a package does not
+// have simply yields nothing.
 import { glob } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { runNodeTests } from './lib/run-node-tests.mjs';
 
-const ROOTS = ['src', 'scripts'];
+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] [--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
+                  window-capture tests cannot run twice at once, so a second
+                  concurrent run uses --exclude-lane electron.
+  --rerun-failed <n>  re-run the failed files up to n times (default 0 = off).
+                  A test that passes on a re-run is reported as flaky and,
+                  because the flag was passed, does NOT fail the run; a test
+                  that fails every re-run still exits 1. Without the flag every
+                  failure fails the run, as before.
+  --import        forwarded to node (desktop passes its test-env and tsx loaders).
+  --test-*        forwarded to node --test (e.g. --test-name-pattern, --test-only).
+  --coverage      collect V8 coverage (NODE_V8_COVERAGE, no dependency) and fold
+                  it into .runtime/coverage/coverage.json, which answers "did the
+                  suite execute this function?" — see scripts/coverage-query.mjs.
+                  Selection, lanes, reporting and exit codes are untouched.
+  --list          print the selected files with their lane, run nothing.
+
+Every run ends with a "[failure-summary]" block, printed after all other
+output, naming each failed and flaky test by file and test name; every line of
+it carries that tag, so it survives line filtering.`;
+
+const ROOTS = ['.', 'src', 'scripts', 'lib', 'deploy'];
 const PATTERNS = ['**/*.test.mjs', '**/*-test.mjs'];
+// The package root is searched shallowly: a recursive pattern there would pull
+// every workspace package into the invoking package's suite.
+const ROOT_PATTERNS = ['*.test.mjs', '*-test.mjs'];
 const EXCLUDED_DIRS = new Set(['node_modules', '.runtime', 'out', 'dist', 'target']);
 
 export function laneOf(file) {
   if (/\.live\.test\.mjs$/.test(file)) return 'live';
   if (/\.slow\.test\.mjs$/.test(file)) return 'slow';
+  if (/\.electron\.test\.mjs$/.test(file)) return 'electron';
   return 'fast';
 }
 
+function rerunCount(value) {
+  if (!/^\d+$/.test(String(value))) {
+    throw new Error(`--rerun-failed requires a non-negative integer (got "${value}")`);
+  }
+  return Number(value);
+}
+
 export function parseArgs(argv) {
   const options = { lane: 'fast', list: false, nodeArgs: [], filters: [] };
   for (let index = 0; index < argv.length; index++) {
@@ -36,12 +85,31 @@ export function parseArgs(argv) {
     if (arg === '--lane') options.lane = argv[++index];
     else if (arg.startsWith('--lane=')) options.lane = arg.slice('--lane='.length);
     else if (arg === '--list') options.list = true;
-    else if (arg === '--import') options.nodeArgs.push(arg, argv[++index]);
-    else if (arg.startsWith('--import=') || arg.startsWith('--test-')) options.nodeArgs.push(arg);
+    // Opt-in only: an absent flag leaves the parsed options exactly as they
+    // 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='))
+      options.excludeLanes = [...(options.excludeLanes ?? []), arg.slice('--exclude-lane='.length)];
+    else if (arg === '--rerun-failed') options.rerunFailed = rerunCount(argv[++index]);
+    else if (arg.startsWith('--rerun-failed=')) options.rerunFailed = rerunCount(arg.slice('--rerun-failed='.length));
+    else if (arg === '--import') {
+      const spec = argv[++index];
+      if (spec === undefined) throw new Error('--import requires a value');
+      options.nodeArgs.push(arg, spec);
+    } else if (arg.startsWith('--import=') || arg.startsWith('--test-')) options.nodeArgs.push(arg);
     else options.filters.push(arg.replaceAll('\\', '/'));
   }
-  if (!['fast', 'slow', 'live', 'all'].includes(options.lane)) {
-    throw new Error(`unknown lane "${options.lane}" (fast|slow|live|all)`);
+  if (!LANES.includes(options.lane)) {
+    throw new Error(`unknown lane "${options.lane}" (${LANES.join('|')})`);
+  }
+  for (const lane of options.excludeLanes ?? []) {
+    if (!FILE_LANES.includes(lane)) {
+      throw new Error(`unknown excluded lane "${lane}" (${FILE_LANES.join('|')})`);
+    }
   }
   return options;
 }
@@ -49,30 +117,64 @@ export function parseArgs(argv) {
 export async function discoverTestFiles(cwd = process.cwd()) {
   const files = new Set();
   for (const root of ROOTS) {
-    for await (const entry of glob(
-      PATTERNS.map((pattern) => `${root}/${pattern}`),
-      {
-        cwd,
-        exclude: (path) =>
-          String(path)
-            .split(/[\\/]/)
-            .some((segment) => EXCLUDED_DIRS.has(segment)),
-      }
-    ))
+    for await (const entry of glob(root === '.' ? ROOT_PATTERNS : PATTERNS.map((pattern) => `${root}/${pattern}`), {
+      cwd,
+      exclude: (path) =>
+        String(path)
+          .split(/[\\/]/)
+          .some((segment) => EXCLUDED_DIRS.has(segment)),
+    }))
       files.add(entry.replaceAll('\\', '/'));
   }
   return [...files].sort();
 }
 
-export function selectTestFiles(files, { lane, filters }) {
+// The electron lane rides the default lane so a plain `npm test` keeps
+// covering an Electron/window-capture surface that no other lane owns;
+// `--exclude-lane electron` is the explicit way to drop it.
+export function laneSelected(lane, fileLane) {
+  if (lane === 'all' || lane === fileLane) return true;
+  return lane === 'fast' && fileLane === 'electron';
+}
+
+export function selectTestFiles(files, { lane, filters, excludeLanes = [] }) {
+  const excluded = new Set(excludeLanes);
   return files
-    .filter((file) => lane === 'all' || laneOf(file) === lane)
+    .filter((file) => laneSelected(lane, laneOf(file)) && !excluded.has(laneOf(file)))
     .filter((file) => filters.length === 0 || filters.some((filter) => file.includes(filter)));
 }
 
 async function main() {
   const options = parseArgs(process.argv.slice(2));
-  const files = selectTestFiles(await discoverTestFiles(), options);
+  if (options.help) {
+    console.log(USAGE);
+    return;
+  }
+  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;
@@ -82,16 +184,20 @@ async function main() {
     process.exitCode = 1;
     return;
   }
-  await runNodeTests([
-    ...options.nodeArgs,
-    // node:test `mock.module` (module-boundary stubs such as the pinned fetch
-    // in the browser-document live suite) is still flag-gated on 22/24.
-    '--experimental-test-module-mocks',
-    '--test',
-    // A suite that leaves a handle open (a session runtime closed without
-    // waiting for its children) must not hang the whole run.
-    '--test-force-exit',
-  ], files);
+  await runNodeTests(
+    [
+      ...options.nodeArgs,
+      // node:test `mock.module` (module-boundary stubs such as the pinned fetch
+      // in the browser-document live suite) is still flag-gated on 22/24.
+      '--experimental-test-module-mocks',
+      '--test',
+      // A suite that leaves a handle open (a session runtime closed without
+      // waiting for its children) must not hang the whole run.
+      '--test-force-exit',
+    ],
+    files,
+    { coverage: options.coverage === true, rerunFailed: options.rerunFailed ?? 0 }
+  );
 }
 
 const invoked = process.argv[1] ? resolve(process.argv[1]) : '';