atris 3.61.0 → 3.63.0

package/lib/runner-command.js

@@ -38,10 +38,12 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     efforts: CLAUDE_EFFORTS,
   }),
   // No -m or effort unless the roster pins one: codex then reads its own
-  // ~/.codex/config.toml, which is what the roster view reports.
+  // ~/.codex/config.toml, which is what the roster view reports. Codex runs
+  // only OpenAI models, so a claude model name never reaches it.
   codex: Object.freeze({
     bin: 'codex',
     model: '',
+    ownModelsOnly: true,
     commandTemplate: '{bin} exec {pinnedModelFlag} {pinnedEffortFlag} {prompt}',
     effortFlag: '-c model_reasoning_effort=',
     efforts: Object.freeze(['low', 'medium', 'high', 'xhigh']),
@@ -211,6 +213,19 @@ function resolvePinnedRunnerModel(mission) {
   return explicit || runnerProfileValue('model');
 }
 
+// The model an engine is launched with. An engine that runs only its own
+// vendor's models drops a claude model name (a mission's stored default, a
+// claude env pin) and rides its own default instead.
+function runnerModelFor(engineId, model) {
+  const value = String(model || '').trim();
+  const name = String(engineId || '').trim().toLowerCase();
+  const def = RUNNER_PROFILE_DEFS[RUNNER_PROFILE_ALIASES[name] || name];
+  if (!value || !def || !def.ownModelsOnly) return value;
+  // Required here, not at the top: engine-registry requires this file.
+  const { isClaudeFamilyModel } = require('./engine-registry');
+  return isClaudeFamilyModel(value) ? '' : value;
+}
+
 function resolveClaudeRunnerBin() {
   const env = firstConfiguredEnv(['ATRIS_RUNNER_BIN']);
   if (env) return env;
@@ -265,6 +280,14 @@ function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model
   // The pinned flags take their leading space with them, so an unpinned
   // launch reads exactly like the template without the placeholders.
   template = template.replace(/\s*\{pinnedModelFlag\}/g, pinnedModel ? ` --model ${shellWord(pinnedModel)}` : '');
+  // A model dropped for an engine that cannot run it leaves no gap either,
+  // and a literal "--model {model}", "-m{model}" or a quoted "{model}" goes
+  // with it, quotes and all.
+  if (!model) {
+    template = template
+      .replace(/\s*\{modelFlag\}/g, '')
+      .replace(/\s*(?:--model|-m)(?:\s+|=)?(["']?)\{model\}\1/g, '');
+  }
   // Checked even when the template has no slot, so an engine that cannot
   // take effort refuses instead of running at its default.
   const effortFlag = runnerEffortFlag(effort);
@@ -299,7 +322,18 @@ function buildRunnerCommand({ promptFile, allowedTools, model, effort } = {}) {
   const resolved = resolveClaudeRunnerModel({ model });
   const template = resolveClaudeRunnerCommandTemplate();
   if (template) {
-    return renderRunnerCommandTemplate(template, { promptFile, allowedTools, model: resolved, pinnedModel: resolvePinnedRunnerModel({ model }), effort });
+    // Both the profile and the program that actually runs count: a runner
+    // bin named codex (or a path ending in it) is codex under any profile.
+    const profile = resolveRunnerProfileName();
+    const binName = String(resolveClaudeRunnerBin()).split(/[\\/]/).pop();
+    const modelFor = (value) => runnerModelFor(binName, runnerModelFor(profile, value));
+    return renderRunnerCommandTemplate(template, {
+      promptFile,
+      allowedTools,
+      model: modelFor(resolved),
+      pinnedModel: modelFor(resolvePinnedRunnerModel({ model })),
+      effort,
+    });
   }
   const safePath = String(promptFile).replace(/'/g, "'\\''");
   let cmd = `${shellWord(resolveClaudeRunnerBin())} -p "$(cat '${safePath}')" --model ${shellWord(resolved)}`;
@@ -339,6 +373,7 @@ module.exports = {
   resolveRunnerProfile,
   resolveClaudeRunnerModel,
   resolvePinnedRunnerModel,
+  runnerModelFor,
   resolveClaudeRunnerBin,
   resolveClaudeRunnerCommandTemplate,
   buildRunnerAvailabilityCommand,

package/lib/self-drive.js

@@ -141,6 +141,8 @@ function defaultDependencies() {
     taskDb,
     resolveEngineForRole: require('./engine-registry').resolveEngineForRole,
     dispatchToEngine: require('./fleet').dispatchToEngine,
+    recordDispatchOutcome: require('./fleet').recordDispatchOutcome,
+    clock: Date.now,
     createAgentWorktree: require('../commands/worktree').createAgentWorktree,
   };
 }
@@ -272,7 +274,13 @@ function handleMissionBlocker({ mission, stopReason, workspaceRoot, appendEvent
       agent: engine.id,
       task: `mission-blocker-${String(ref).toLowerCase()}`,
     });
-    deps.dispatchToEngine({
+    const pin = {
+      model: engine.roster_model || '',
+      effort: engine.roster_effort || '',
+      maxSeconds: Number(engine.roster_max_seconds) || 0,
+    };
+    const startedMs = deps.clock();
+    const dispatched = deps.dispatchToEngine({
       task,
       engine: engine.id,
       worktreePath: worktree.path,
@@ -281,14 +289,30 @@ function handleMissionBlocker({ mission, stopReason, workspaceRoot, appendEvent
       ...(engine.roster_effort ? { effort: engine.roster_effort } : {}),
       ...(engine.roster_max_seconds ? { maxSeconds: engine.roster_max_seconds } : {}),
     });
+    // How the engine did goes through the same health and run-record calls
+    // as every other dispatch, so a stalled blocker build benches it.
+    const run = dispatched && typeof dispatched === 'object' && typeof dispatched.then !== 'function'
+      ? deps.recordDispatchOutcome(scopedRoot, {
+        engine: engine.id,
+        pin,
+        startedMs,
+        endedMs: deps.clock(),
+        result: dispatched,
+        job: 'build',
+        task: ref,
+        source: 'mission blocker',
+        member: mission.owner || '',
+      })
+      : null;
     projectTasks(deps.taskDb, db, scopedRoot);
     appendEvent?.('mission_blocker_dispatched', {
       task_id: ref,
       engine: engine.id,
       blocker_class: blockerClass,
       worktree_path: worktree.path,
+      ...(run ? { outcome: run.outcome } : {}),
     });
-    return { taskId: ref, dispatched: true, engine: engine.id, reason: 'dispatched' };
+    return { taskId: ref, dispatched: true, engine: engine.id, reason: 'dispatched', ...(run ? { outcome: run.outcome, ...(run.detail ? { detail: run.detail } : {}) } : {}) };
   } catch (error) {
     return { taskId: ref, dispatched: false, engine: engine.id, reason: error.message || String(error) };
   }

package/lib/state-detection.js

@@ -131,7 +131,7 @@ function getTasksFromDbBucket(atrisDir, bucketName) {
     const taskDb = require('./task-db');
     if (!fs.existsSync(taskDb.getDbPath())) return null;
     const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
-    const rows = taskDb.listTasks(taskDb.open(), { workspaceRoot, limit: 500 });
+    const rows = taskDb.listTasksCached(taskDb.open(), { workspaceRoot, limit: 500 });
     if (!rows.length) return null;
     return rows
       .filter(row => statuses.has(String(row.status || '').toLowerCase()))
@@ -151,7 +151,7 @@ function getTaskCounts(atrisDir) {
     const taskDb = require('./task-db');
     if (fs.existsSync(taskDb.getDbPath())) {
       const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
-      const rows = taskDb.listTasks(taskDb.open(), { workspaceRoot, limit: 500 });
+      const rows = taskDb.listTasksCached(taskDb.open(), { workspaceRoot, limit: 500 });
       if (rows.length) {
         const counts = { backlog: 0, active: 0, review: 0, reviewCertified: 0, source: 'db' };
         for (const row of rows) {
@@ -190,7 +190,7 @@ function getTaskGlance(atrisDir, sampleSize = 3) {
     const taskDb = require('./task-db');
     if (fs.existsSync(taskDb.getDbPath())) {
       const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
-      const rows = taskDb.listTasks(taskDb.open(), { workspaceRoot, limit: 500 });
+      const rows = taskDb.listTasksCached(taskDb.open(), { workspaceRoot, limit: 500 });
       if (rows.length) {
         const glance = {
           backlog: 0, active: 0, review: 0, reviewCertified: 0,

package/lib/task-db.js

@@ -333,10 +333,14 @@ function taskDisplayRef(row, index) {
   return `${workspaceRefPrefix(row && row.workspace_root)}-${Number(index) + 1}`;
 }
 
-function shortestUniqueTaskRef(id, ids, minLength = 8) {
+// normalizedIds: the ids already passed through normalizeTaskRef, so a caller
+// resolving every row of a list normalizes the list once, not once per row.
+function shortestUniqueTaskRef(id, ids, minLength = 8, normalizedIds = null) {
   const normalized = normalizeTaskRef(id);
   if (!normalized) return '';
-  const all = (Array.isArray(ids) ? ids : []).map(normalizeTaskRef).filter(Boolean);
+  const all = Array.isArray(normalizedIds)
+    ? normalizedIds
+    : (Array.isArray(ids) ? ids : []).map(normalizeTaskRef).filter(Boolean);
   for (let length = Math.min(minLength, normalized.length); length <= normalized.length; length += 1) {
     const prefix = normalized.slice(0, length);
     const matches = all.filter(candidate => candidate.startsWith(prefix));
@@ -364,10 +368,11 @@ function withTaskDisplayRefs(rows, refRows = rows) {
     const sorted = [...group]
       .sort((a, b) => (Number(a.created_at || 0) - Number(b.created_at || 0)) || String(a.id || '').localeCompare(String(b.id || '')))
     const ids = sorted.map(row => row && row.id);
+    const normalizedIds = ids.map(normalizeTaskRef).filter(Boolean);
     sorted.forEach((row, index) => {
       refs.set(row.id, {
         display_id: row.display_id || taskDisplayRef(row, index),
-        legacy_ref: row.legacy_ref || shortestUniqueTaskRef(row.id, ids, 8),
+        legacy_ref: row.legacy_ref || shortestUniqueTaskRef(row.id, ids, 8, normalizedIds),
       });
     });
   }
@@ -470,6 +475,35 @@ function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
   }));
 }
 
+// Boot reads the same task list from several places (the TODO buckets and
+// the status glance). Share one read per connection while nothing changed:
+// PRAGMA data_version moves when another connection commits, and
+// total_changes() moves when this connection writes. Callers must treat the
+// rows as read-only.
+const listTasksMemo = new WeakMap();
+
+function listTasksCached(db, opts = {}) {
+  let stamp;
+  try {
+    const version = db.prepare('PRAGMA data_version').get();
+    const changes = db.prepare('SELECT total_changes() AS n').get();
+    stamp = `${Object.values(version || {})[0]}:${changes && changes.n}`;
+  } catch {
+    return listTasks(db, opts);
+  }
+  const key = JSON.stringify([opts.workspaceRoot || '', opts.status || '', opts.claimedBy || '', opts.limit || 0]);
+  let byKey = listTasksMemo.get(db);
+  if (!byKey) {
+    byKey = new Map();
+    listTasksMemo.set(db, byKey);
+  }
+  const hit = byKey.get(key);
+  if (hit && hit.stamp === stamp) return hit.rows;
+  const rows = listTasks(db, opts);
+  byKey.set(key, { stamp, rows });
+  return rows;
+}
+
 function getTask(db, id) {
   if (!id) throw new Error('id required');
   const row = db.prepare(`
@@ -2243,6 +2277,7 @@ module.exports = {
   addTask,
   getTask,
   listTasks,
+  listTasksCached,
   claimTask,
   releaseTask,
   reopenTask,

package/lib/team-lineup.js

@@ -6,6 +6,7 @@
 
 const { engineRunsView, modelLabel } = require('./roster-models');
 const { rosterToolLabel } = require('./engine-registry');
+const { suggestionCount } = require('./roster-suggest');
 
 const BUILT_IN_JOBS = Object.freeze(['build', 'review', 'search']);
 const CLAUDE_FAMILY = Object.freeze(['claude', 'fable', 'haiku']);
@@ -51,6 +52,8 @@ function readLineupSafe(root = process.cwd(), now = new Date()) {
 
 // One boot line: the tool and model that runs each built-in job right now,
 // custom jobs only when all of them still fit. '' when nothing resolves.
+// When the run record suggests a new order for any job, a short marker
+// points at the roster view; only the end of the record is read.
 function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs = null } = {}) {
   let rows = jobs;
   if (!rows) {
@@ -65,9 +68,11 @@ function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs
   const builtIn = ordered.filter((row) => BUILT_IN_JOBS.includes(row.job) && !row.key).map(part).filter(Boolean);
   const custom = ordered.filter((row) => !BUILT_IN_JOBS.includes(row.job) || row.key).map(part).filter(Boolean);
   if (!builtIn.length && !custom.length) return '';
+  const count = suggestionCount(ordered, root, { now });
+  const marker = count ? ` · ${count} suggestion${count === 1 ? '' : 's'} (atris engine roster)` : '';
   const all = [...builtIn, ...custom].join(' · ');
-  if (all.length <= width || !builtIn.length) return all;
-  return builtIn.join(' · ');
+  if (all.length + marker.length <= width || !builtIn.length) return `${all}${marker}`;
+  return `${builtIn.join(' · ')}${marker}`;
 }
 
 function runsText(view) {

package/lib/todo.js

@@ -41,7 +41,7 @@ function dbToShimRow(row) {
 function dbBuckets(workspaceRoot) {
   const taskDb = require('./task-db');
   const db = taskDb.open();
-  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot, limit: 500 }));
+  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasksCached(db, { workspaceRoot, limit: 500 }));
   // Need raw source_key for merge dedup, plus the shim shape for callers.
   const backlog = [];
   const inProgress = [];

package/lib/wish-audit.js

@@ -424,7 +424,7 @@ function policyValidator(root, excludeId = '') {
       .filter((engine) => engine.id !== String(excludeId || ''))
       .sort((a, b) => Number(a.fallback_order) - Number(b.fallback_order)
         || String(a.id).localeCompare(String(b.id)));
-    return ranked.find((engine) => engine.health && engine.health.status === 'ready') || ranked[0] || null;
+    return ranked.find((engine) => engineRegistry.engineReadyAt(engine)) || ranked[0] || null;
   } catch {
     return null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.61.0",
+  "version": "3.63.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {

package/scripts/det/cpu-hotspots.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+// det/cpu-hotspots.js - where does an atris command spend its time?
+// Runs one command under `node --cpu-prof` in a temp profile dir, then prints
+// the total profiled ms, the top self-time hotspots, and the top call chains
+// that end in spawnSync (application frames only, so node internals and
+// node_modules drop out). Optional plain wall-clock runs give a median.
+//
+// Usage:
+//   node scripts/det/cpu-hotspots.js [options] -- <script.js> [args...]
+//   node scripts/det/cpu-hotspots.js --cwd ../repo -- bin/atris.js atris.md
+//   node scripts/det/cpu-hotspots.js --wall 5 --top 15 -- bin/atris.js team
+//
+// Options:
+//   --cwd <dir>     working directory for the profiled command (default: here)
+//   --top <n>       rows per table (default 10)
+//   --wall <n>      also time n unprofiled runs and print the median wall ms
+//   --app <dir>     frames under this dir count as application frames
+//                   (default: the repo that holds this script)
+//   --keep          keep the temp profile dir and print its path
+//   --json          structured output
+//
+// The command's own stdout is discarded; its exit code is reported.
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const DEFAULT_APP_ROOT = path.resolve(__dirname, '..', '..');
+
+function parseArgs(argv) {
+  const opts = { cwd: process.cwd(), top: 10, wall: 0, app: DEFAULT_APP_ROOT, keep: false, json: false, command: [] };
+  const sep = argv.indexOf('--');
+  const head = sep === -1 ? argv : argv.slice(0, sep);
+  opts.command = sep === -1 ? [] : argv.slice(sep + 1);
+  for (let i = 0; i < head.length; i += 1) {
+    const arg = head[i];
+    if (arg === '--cwd') opts.cwd = path.resolve(head[++i] || '.');
+    else if (arg === '--top') opts.top = Math.max(1, Number(head[++i]) || 10);
+    else if (arg === '--wall') opts.wall = Math.max(0, Number(head[++i]) || 0);
+    else if (arg === '--app') opts.app = path.resolve(head[++i] || '.');
+    else if (arg === '--keep') opts.keep = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg === '-h' || arg === '--help') opts.help = true;
+    else opts.command.push(arg);
+  }
+  return opts;
+}
+
+function frameFile(url) {
+  return String(url || '').replace(/^file:\/\//, '');
+}
+
+function isAppFrame(frame, appRoot) {
+  const file = frameFile(frame.url);
+  if (!file || !file.startsWith(appRoot)) return false;
+  return !file.includes(`${path.sep}node_modules${path.sep}`);
+}
+
+function frameLabel(frame, appRoot) {
+  const file = frameFile(frame.url);
+  const rel = appRoot && file.startsWith(appRoot) ? path.relative(appRoot, file) : (file || '(native)');
+  const name = frame.functionName || '(anonymous)';
+  return `${name} ${rel}:${Number(frame.lineNumber) + 1}`;
+}
+
+// Pure core: a parsed .cpuprofile in, tables out. Unit-testable.
+function analyzeProfile(profile, { appRoot = DEFAULT_APP_ROOT, top = 10 } = {}) {
+  const nodes = new Map();
+  const parent = new Map();
+  for (const node of profile.nodes || []) {
+    nodes.set(node.id, node);
+    for (const child of node.children || []) parent.set(child, node.id);
+  }
+  const selfUs = new Map();
+  const samples = profile.samples || [];
+  const deltas = profile.timeDeltas || [];
+  for (let i = 0; i < samples.length; i += 1) {
+    const dt = Math.max(0, Number(deltas[i]) || 0);
+    selfUs.set(samples[i], (selfUs.get(samples[i]) || 0) + dt);
+  }
+  const totalUs = [...selfUs.values()].reduce((a, b) => a + b, 0)
+    || Math.max(0, Number(profile.endTime) - Number(profile.startTime)) || 0;
+
+  const byFrame = new Map();
+  for (const [id, us] of selfUs) {
+    const node = nodes.get(id);
+    if (!node) continue;
+    const label = frameLabel(node.callFrame || {}, appRoot);
+    byFrame.set(label, (byFrame.get(label) || 0) + us);
+  }
+  const hotspots = [...byFrame.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, top)
+    .map(([frame, us]) => ({ frame, ms: Math.round(us / 1000) }));
+
+  // Time under each spawnSync node = self time of every descendant sample.
+  const subtreeUs = new Map();
+  for (const [id, us] of selfUs) {
+    let cur = id;
+    const seen = new Set();
+    while (cur !== undefined && !seen.has(cur)) {
+      seen.add(cur);
+      subtreeUs.set(cur, (subtreeUs.get(cur) || 0) + us);
+      cur = parent.get(cur);
+    }
+  }
+  const chains = new Map();
+  for (const node of nodes.values()) {
+    const fn = node.callFrame && node.callFrame.functionName;
+    if (fn !== 'spawnSync') continue;
+    // Only the outermost spawnSync on a path counts (child_process wraps an
+    // internal spawnSync of the same name).
+    let up = parent.get(node.id);
+    let nested = false;
+    while (up !== undefined) {
+      const upNode = nodes.get(up);
+      if (upNode && upNode.callFrame && upNode.callFrame.functionName === 'spawnSync') { nested = true; break; }
+      up = parent.get(up);
+    }
+    if (nested) continue;
+    const us = subtreeUs.get(node.id) || 0;
+    if (!us) continue;
+    const frames = [];
+    let cur = parent.get(node.id);
+    while (cur !== undefined) {
+      const n = nodes.get(cur);
+      if (n && n.callFrame && isAppFrame(n.callFrame, appRoot)) frames.push(frameLabel(n.callFrame, appRoot));
+      cur = parent.get(cur);
+    }
+    const key = frames.slice(0, 6).join(' < ') || '(no app frames)';
+    chains.set(key, (chains.get(key) || 0) + us);
+  }
+  const spawnTotalUs = [...chains.values()].reduce((a, b) => a + b, 0);
+  const spawnChains = [...chains.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, top)
+    .map(([chain, us]) => ({ chain, ms: Math.round(us / 1000) }));
+  return { total_ms: Math.round(totalUs / 1000), spawn_ms: Math.round(spawnTotalUs / 1000), hotspots, spawn_chains: spawnChains };
+}
+
+function median(values) {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+}
+
+function timeRun(command, cwd, extraArgs = []) {
+  const start = process.hrtime.bigint();
+  const result = spawnSync(process.execPath, [...extraArgs, ...command], { cwd, stdio: ['ignore', 'ignore', 'pipe'], encoding: 'utf8' });
+  const ms = Number(process.hrtime.bigint() - start) / 1e6;
+  return { ms: Math.round(ms), status: result.status, stderr: result.stderr || '' };
+}
+
+function resolveCommand(command) {
+  if (!command.length) return command;
+  const [script, ...rest] = command;
+  const abs = path.isAbsolute(script) ? script : path.resolve(process.cwd(), script);
+  return [fs.existsSync(abs) ? abs : script, ...rest];
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (opts.help || !opts.command.length) {
+    process.stderr.write('usage: node scripts/det/cpu-hotspots.js [--cwd dir] [--top n] [--wall n] [--json] -- <script.js> [args...]\n');
+    return opts.help ? 0 : 2;
+  }
+  const command = resolveCommand(opts.command);
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-cpu-prof-'));
+  const profiled = timeRun(command, opts.cwd, ['--cpu-prof', `--cpu-prof-dir=${dir}`]);
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith('.cpuprofile'))
+    .map((f) => path.join(dir, f))
+    .sort((a, b) => fs.statSync(b).size - fs.statSync(a).size);
+  if (!files.length) {
+    process.stderr.write(`no profile written (exit ${profiled.status})\n${profiled.stderr.slice(0, 800)}`);
+    return 1;
+  }
+  const report = analyzeProfile(JSON.parse(fs.readFileSync(files[0], 'utf8')), { appRoot: opts.app, top: opts.top });
+  report.command = command.join(' ');
+  report.exit_code = profiled.status;
+  report.profiled_wall_ms = profiled.ms;
+  if (opts.wall) {
+    const walls = [];
+    for (let i = 0; i < opts.wall; i += 1) walls.push(timeRun(command, opts.cwd).ms);
+    report.wall_runs_ms = walls;
+    report.wall_median_ms = median(walls);
+  }
+  if (opts.keep) report.profile_dir = dir;
+  else fs.rmSync(dir, { recursive: true, force: true });
+
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return 0;
+  }
+  const out = [];
+  out.push(`command: ${report.command} (exit ${report.exit_code})`);
+  out.push(`profiled: ${report.total_ms} ms cpu profile, ${report.profiled_wall_ms} ms wall, ${report.spawn_ms} ms in spawnSync`);
+  if (opts.wall) out.push(`wall median of ${opts.wall}: ${report.wall_median_ms} ms (${report.wall_runs_ms.join(', ')})`);
+  out.push('');
+  out.push('top self time:');
+  for (const row of report.hotspots) out.push(`  ${String(row.ms).padStart(6)} ms  ${row.frame}`);
+  out.push('');
+  out.push('top spawnSync chains:');
+  if (!report.spawn_chains.length) out.push('  (none)');
+  for (const row of report.spawn_chains) out.push(`  ${String(row.ms).padStart(6)} ms  ${row.chain}`);
+  if (report.profile_dir) out.push('', `profile dir: ${report.profile_dir}`);
+  process.stdout.write(`${out.join('\n')}\n`);
+  return 0;
+}
+
+if (require.main === module) process.exitCode = main();
+
+module.exports = { analyzeProfile, median, parseArgs };