@codedology/code-forge 0.15.1 → 0.15.3

package/src/cli/gates.mjs

@@ -33,11 +33,14 @@
  */
 
 import { realpathSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { writeSafe, redactJSON } from '../util/redact.mjs';
+import { exec } from '../util/exec.mjs';
 import { appendRow } from '../ledger/write.mjs';
 import { loadProjectConfig } from '../config/load.mjs';
+import { customGateMessages, kindGateMessages } from '../config/validate.mjs';
+import { blockKind } from '../decide/escalation.mjs';
 import { detectGates } from '../gates/detect.mjs';
 import { printableGates, scopeFields, testScope, thresholdOf } from '../gates/expand.mjs';
 import { runGates } from '../gates/run.mjs';
@@ -55,6 +58,18 @@ import { checkTranscript } from '../gates/transcript-grep.mjs';
 /** B60: the gate env rule, in the same words as the schema and proof.md. */
 const GATE_ENV_RULE = 'code-forge never prints or records an env value. Gate env is not a secret store. Child output is masked only for values of 8 or more characters.';
 
+/** Per-gate timeout: explicit milliseconds, configured whole seconds, then five minutes.
+ * @param {{flag?: number, config?: Record<string, any> | null}} opts
+ * @returns {number}
+ */
+export function gateTimeoutMs({ flag, config }) {
+  const seconds = config?.gates?.timeout_s;
+  if (config?.gates && Object.hasOwn(config.gates, 'timeout_s') && (!Number.isInteger(seconds) || seconds < 30 || seconds > 7200)) {
+    throw new TypeError('gates.timeout_s must be an integer 30..7200');
+  }
+  return flag ?? (seconds === undefined ? 300000 : seconds * 1000);
+}
+
 /**
  * Auto-detected gates (`detectGates`), overridden per-key by an on-disk `.code-forge.yml`'s
  * `gates.{test,lint,types,format}` when that key is explicitly present — a project that already
@@ -62,17 +77,20 @@ const GATE_ENV_RULE = 'code-forge never prints or records an env value. Gate env
  * A missing/unparseable config file is not an error here: detection alone is a valid answer.
  * @param {string} cwd
  * @param {Record<string, any> | null} configured - the config's `gates` section ({@link configuredGates}).
- * @returns {import('../gates/detect.mjs').DetectedGates}
+ * @returns {import('../gates/detect.mjs').DetectedGates & {custom?: import('../gates/run.mjs').CustomGate[]}}
  */
 function resolveGates(cwd, configured) {
   const detected = detectGates(cwd);
   if (!configured) return detected;
+  const errors = [...customGateMessages(configured.custom), ...kindGateMessages(configured)];
+  if (errors.length > 0) throw new TypeError(errors.join('; '));
   return {
     stack: detected.stack,
     test: 'test' in configured ? configured.test : detected.test,
     lint: 'lint' in configured ? configured.lint : detected.lint,
     types: 'types' in configured ? configured.types : detected.types,
     format: 'format' in configured ? configured.format : detected.format,
+    ...(configured.custom !== undefined ? { custom: configured.custom } : {}),
   };
 }
 
@@ -183,6 +201,30 @@ function realOrResolved(p) {
   }
 }
 
+/** Warn once per dependency-bearing directory, including a linked worktree's main checkout.
+ * @param {string} cwd @param {(line: string) => void} err
+ * @returns {Promise<void>}
+ */
+async function warnMissingDependencies(cwd, err) {
+  const dirs = new Set([realOrResolved(cwd)]);
+  const git = await exec(['git', 'rev-parse', '--show-toplevel', '--git-common-dir'], { cwd, timeoutMs: 5000 });
+  if (git.result === 'ok') {
+    const [top, common] = git.stdout.trimEnd().split('\n');
+    if (top) dirs.add(realOrResolved(top));
+    if (common) dirs.add(realOrResolved(path.dirname(path.resolve(cwd, common))));
+  }
+  for (const dir of dirs) {
+    let manifest;
+    try { manifest = JSON.parse(await readFile(path.join(dir, 'package.json'), 'utf8')); }
+    catch { continue; }
+    const hasDeps = [manifest?.dependencies, manifest?.devDependencies].some((deps) =>
+      deps && typeof deps === 'object' && !Array.isArray(deps) && Object.keys(deps).length > 0);
+    if (!hasDeps) continue;
+    const installed = await stat(path.join(dir, 'node_modules')).then((entry) => entry.isDirectory(), () => false);
+    if (!installed) err(`warn: ${dir} has package.json but no node_modules; run npm ci there first\n`);
+  }
+}
+
 /**
  * B60: the scope fields of a `{test_files}` gate's result (`scope` with `test_count` or `reason`),
  * or none for any other gate.
@@ -218,7 +260,7 @@ export async function runGatesVerb(args, deps = {}) {
       if (!cwdArg.ok) return 2;
       const gates = resolveGates(cwdArg.value, await configuredGates(cwdArg.value));
       // B60: a gate given with env is printed with its variable NAMES (`env_keys`), never the values
-      out(printableGates(gates));
+      out(printableGates({ ...gates, ...(gates.custom ? { custom: gates.custom.map((gate) => printableGates({ gate }).gate) } : {}) }));
       return 0;
     }
 
@@ -232,8 +274,8 @@ export async function runGatesVerb(args, deps = {}) {
         err('gates run: --timeout-ms requires a value\n');
         return 2;
       }
-      const timeoutMs = timeoutFlag.value !== undefined ? Number(timeoutFlag.value) : undefined;
-      if (timeoutMs !== undefined && !(Number.isFinite(timeoutMs) && timeoutMs > 0)) {
+      const flagTimeoutMs = timeoutFlag.value !== undefined ? Number(timeoutFlag.value) : undefined;
+      if (flagTimeoutMs !== undefined && !(Number.isFinite(flagTimeoutMs) && flagTimeoutMs > 0)) {
         err(`gates run: --timeout-ms must be a finite number > 0, got "${timeoutFlag.value}"\n`);
         return 2;
       }
@@ -275,12 +317,15 @@ export async function runGatesVerb(args, deps = {}) {
         cwd = placed.tree.workspace;
       }
       const configured = await configuredGates(placed ? placed.workspace : cwd); // loaded once: the gates and the threshold
+      const timeoutMs = gateTimeoutMs({ flag: flagTimeoutMs, config: { gates: configured } });
       const gates = resolveGates(cwd, configured);
+      await warnMissingDependencies(cwd, err);
       const inTree = placed ? { worktree: placed.tree.path } : {};
       let ran;
+      let message;
       if (runFlag.value !== undefined && blockFlag.value !== undefined) {
         const threshold = thresholdOf(configured?.full_suite_threshold_files);
-        /** @type {typeof gates & {repeatNewTests?: import('../gates/run.mjs').RepeatNewTests, lightTestFiles?: string[]}} */
+        /** @type {typeof gates & {repeatNewTests?: import('../gates/run.mjs').RepeatNewTests, lightTestFiles?: string[], kindGates?: import('../gates/run.mjs').KindGates}} */
         let planned = gates;
         if (configured?.repeat_new_tests !== undefined) {
           const record = await readRun(runFlag.value);
@@ -295,6 +340,14 @@ export async function runGatesVerb(args, deps = {}) {
           throw error;
         });
         const light = block?.kind === 'light';
+        if (block && !light) {
+          const kind = blockKind({ declared: block.kind, owned: block.owned_files });
+          const names = configured?.kinds?.[kind];
+          if (Array.isArray(names)) {
+            planned = { ...planned, kindGates: { kind, names } };
+            if (names.length === 0) message = `0 gates for kind ${kind}`;
+          }
+        }
         if (light) {
           const scope = testScope({ testFiles: block.test_files, owned: block.owned_files, threshold: Infinity });
           const command = planned.test;
@@ -302,16 +355,20 @@ export async function runGatesVerb(args, deps = {}) {
           if (scope.scope !== 'related' || !argv?.includes('{test_files}')) throw new StateError('light-tests', 'light-tests: block tests and a gates.test {test_files} item are required');
           planned = { ...planned, lightTestFiles: scope.files };
         }
-        const guarded = await runGatesGuarded({ runId: runFlag.value, blockId: blockFlag.value, gates: planned, cwd, threshold, changed: light ? false : changed, slug, ...(timeoutMs ? { timeoutMs } : {}) });
+        const guarded = await runGatesGuarded({ runId: runFlag.value, blockId: blockFlag.value, gates: planned, cwd, threshold, changed: light ? false : changed, slug, timeoutMs });
         if (guarded.result === 'proof.busy') {
           out({ result: 'proof.busy', holder: /** @type {{holder: string}} */ (guarded).holder });
           return 1;
         }
         ran = /** @type {{value: {results: any[], allOk: boolean, ledger_slug?: string, files?: Record<string, string>, changed_scope?: import('../gates/expand.mjs').ChangedScope}}} */ (guarded).value;
       } else {
-        ran = await runGates(gates, { cwd, ...(timeoutMs ? { timeoutMs } : {}) });
+        ran = await runGates(gates, { cwd, timeoutMs });
       }
       const { results, allOk } = ran;
+      const durationMs = results.reduce((sum, r) => sum + r.duration_ms, 0);
+      for (const result of results) {
+        if (!result.skipped && result.code === null) err(`${result.gate}: ${result.message}\n`);
+      }
       const repeats = results.find((r) => r.repeats)?.repeats;
 
       const ledgerSlug = slug ?? ran.ledger_slug;
@@ -325,18 +382,27 @@ export async function runGatesVerb(args, deps = {}) {
         for (const result of results) {
           if (!result.skipped && !result.ok) {
             await writeGateRow({ ...owner, event: 'gate.red', gate: result.gate, code: result.code, ...scopeOf(result),
-              ...(result.reason === 'flaky-test' ? { reason: 'flaky-test' } : {}),
+              duration_ms: result.duration_ms, total_duration_ms: durationMs,
+              ...(result.custom ? { custom: true } : {}),
+              ...(result.reason ? { reason: result.reason } : {}),
               ...(result.repeats ? { repeats: result.repeats } : {}) });
           }
         }
         // B60: one scope per run (every `{test_files}` gate shares it), named on gate.done too;
         // without --run/--block that is `scope: full, reason: no_tests`
         const scoped = results.find((r) => r.scope !== undefined);
+        const custom = results.filter((r) => r.custom);
         await writeGateRow({ ...owner, event: 'gate.done', stack: gates.stack, all_ok: allOk,
+          duration_ms: durationMs,
+          results: results.map(({ gate, ok, skipped, duration_ms }) => ({ gate, ok, skipped, duration_ms })),
           ...(ran.changed_scope ? scopeFields(ran.changed_scope) : scoped ? scopeOf(scoped) : {}),
+          ...(custom.length ? {
+            custom: custom.map((r) => ({ name: r.gate, ok: r.ok, evidence_count: r.evidence.length, ...(r.missing ? { missing: r.missing } : {}) })),
+            ...(runFlag.value !== undefined ? { evidence: Object.fromEntries(custom.map((r) => [r.gate, r.evidence])) } : {}),
+          } : {}),
           ...(ran.files ? { files: ran.files } : {}), ...(repeats ? { repeats } : {}) });
       }
-      out({ stack: gates.stack, ...inTree, results, allOk, ...(repeats ? { repeats } : {}) });
+      out({ stack: gates.stack, ...inTree, results, allOk, duration_ms: durationMs, ...(message ? { message } : {}), ...(repeats ? { repeats } : {}) });
       return allOk ? 0 : 1;
     }
 

package/src/cli/help.mjs

@@ -44,5 +44,9 @@ export default async function help(_args, context = {}) {
   for (const verb of verbs) {
     process.stdout.write(`  ${verb}\n`);
   }
+  process.stdout.write('\nBlock usage: code-forge block <verb> --help (or -h).\n');
+  process.stdout.write('  block open --acceptance <file>: JSON/YAML list [{clause, tests}]; tests is a nonempty list of test ids.\n');
+  process.stdout.write('  block open --brief <file>: a file inside the repository, not inline text.\n');
+  process.stdout.write('  Configuration fallback entries must be {provider, model} objects, not model-name strings (optional effort).\n');
   return 0;
 }

package/src/cli/outcome.mjs

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { loadProjectConfig, slugFor } from '../config/load.mjs';
+import { appendRow, readAllRows } from '../ledger/write.mjs';
+import { checkOutcome, sealOutcome } from '../outcome/outcome.mjs';
+import { loadPipeline } from '../pipeline/pipeline.mjs';
+import { withRunLock, writeSigned } from '../state/run.mjs';
+
+const USAGE = 'usage: code-forge outcome seal|check|record <outcome.json> [--root <dir>] [--step <id> (record only)] [--json (check or record)]\n';
+
+/** @param {string} file @param {string} root @param {string | undefined} explicitStep */
+async function recordOutcome(file, root, explicitStep) {
+  const bytes = readFileSync(file);
+  const obj = JSON.parse(bytes.toString('utf8'));
+  const sha256 = createHash('sha256').update(bytes).digest('hex');
+  const pipeline = loadPipeline(root);
+  const step = explicitStep ?? (pipeline.exists && pipeline.ok
+    ? pipeline.pipeline.steps.find((s) => path.resolve(root, s.outcome) === path.resolve(file))?.id
+    : undefined) ?? null;
+  const loaded = await loadProjectConfig(root);
+  if (!loaded.ok && loaded.error !== 'not-found') throw new Error(`project config: ${loaded.message}`);
+  const slug = slugFor(loaded.ok ? loaded.config : {}, root);
+  const rows = await readAllRows(slug);
+  const run = rows.filter((r) => r.event === 'run.start' && typeof r.run === 'string').at(-1)?.run;
+  if (!run) throw new Error('no project run to sign the outcome; start a run first');
+  return withRunLock(run, async () => {
+    const current = await readAllRows(slug);
+    if (current.some((r) => r.event === 'outcome.recorded' && r.sha256 === sha256 && r.step === step)) {
+      return { ok: true, problems: [], already_recorded: true };
+    }
+    const row = await writeSigned(run, (signed) => appendRow(signed, { slug }), {
+      event: 'outcome.recorded', skill: obj.skill, step, status: obj.status, sha256,
+      cost_usd: obj.cost_usd ?? null, minutes: obj.minutes ?? null,
+    });
+    return { ok: true, problems: [], already_recorded: false, row };
+  });
+}
+
+/** @param {string[]} args @returns {Promise<number>} */
+export default async function outcome(args) {
+  const [command, ...rest] = args;
+  let file;
+  let root;
+  let step;
+  let json = false;
+  const usage = () => { process.stderr.write(USAGE); return 2; };
+  if (!['seal', 'check', 'record'].includes(command)) return usage();
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === '--root') {
+      if (root !== undefined || !rest[i + 1] || rest[i + 1].startsWith('-')) return usage();
+      root = rest[++i];
+    } else if (arg === '--step' && command === 'record') {
+      if (step !== undefined || !rest[i + 1] || rest[i + 1].startsWith('-')) return usage();
+      step = rest[++i];
+    } else if (arg === '--json' && command !== 'seal' && !json) {
+      json = true;
+    } else if (arg.startsWith('-') || file !== undefined) {
+      return usage();
+    } else {
+      file = arg;
+    }
+  }
+  if (!file) return usage();
+  let result = command === 'seal' ? sealOutcome(file, { root }) : checkOutcome(file, { root });
+  let alreadyRecorded = false;
+  if (command === 'record' && result.ok) {
+    try {
+      const recorded = await recordOutcome(file, path.resolve(root ?? process.cwd()), step);
+      alreadyRecorded = recorded.already_recorded;
+      result = recorded;
+    } catch (err) {
+      result = { ok: false, problems: [err.message] };
+    }
+  }
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+  } else if (!result.ok) {
+    for (const problem of result.problems) process.stderr.write(`${problem}\n`);
+  } else if (command === 'check') {
+    process.stdout.write('ok\n');
+  } else if (command === 'record') {
+    process.stdout.write(alreadyRecorded ? 'already recorded\n' : 'recorded\n');
+  }
+  return result.ok ? 0 : 1;
+}

package/src/cli/pipeline.mjs

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { loadPipeline, pipelineStatus } from '../pipeline/pipeline.mjs';
+
+const USAGE = 'usage: code-forge pipeline status|next [--json] [--root <dir>]\n';
+
+/** @param {string[]} args @returns {Promise<number>} */
+export default async function pipeline(args) {
+  const [command, ...rest] = args;
+  let root;
+  let json = false;
+  const usage = () => { process.stderr.write(USAGE); return 2; };
+  if (command !== 'status' && command !== 'next') return usage();
+  for (let i = 0; i < rest.length; i += 1) {
+    if (rest[i] === '--root') {
+      if (root !== undefined || !rest[i + 1] || rest[i + 1].startsWith('-')) return usage();
+      root = rest[++i];
+    } else if (rest[i] === '--json' && !json) {
+      json = true;
+    } else {
+      return usage();
+    }
+  }
+  root = path.resolve(root ?? process.cwd());
+  const loaded = loadPipeline(root);
+  if (!loaded.exists) {
+    process.stdout.write(json ? '{"exists":false}\n' : `no code-forge.pipeline.yml in ${root}\n`);
+    return 0;
+  }
+  if (!loaded.ok) {
+    for (const problem of loaded.problems) process.stderr.write(`${problem}\n`);
+    return 1;
+  }
+  const steps = pipelineStatus(root);
+  if (command === 'status') {
+    if (json) {
+      process.stdout.write(`${JSON.stringify({ exists: true, steps })}\n`);
+    } else {
+      for (const step of steps) {
+        process.stdout.write(`${step.id}  ${step.state}  ${step.skill}${step.problem ? `  — ${step.problem}` : ''}\n`);
+      }
+    }
+    return 0;
+  }
+  const states = new Map(steps.map((step) => [step.id, step.state]));
+  const ready = steps.filter((step) => step.state === 'ready').map((step) => step.id);
+  const waiting = loaded.pipeline.steps.filter((step) => states.get(step.id) === 'waiting').map((step) => ({
+    id: step.id, needs: step.needs.filter((id) => states.get(id) !== 'approved'),
+  }));
+  const done = steps.every((step) => step.state === 'approved');
+  if (json) {
+    process.stdout.write(`${JSON.stringify({ exists: true, ready, waiting, done })}\n`);
+  } else if (ready.length > 0) {
+    process.stdout.write(`${ready.join('\n')}\n`);
+  } else if (done) {
+    process.stdout.write('all steps approved\n');
+  } else {
+    process.stdout.write('nothing ready\n');
+    for (const step of waiting) process.stdout.write(`${step.id}  waiting for ${step.needs.join(', ')}\n`);
+  }
+  return 0;
+}

package/src/cli/proof.mjs

@@ -45,7 +45,7 @@ import { redactJSON, writeSafe } from '../util/redact.mjs';
 import { DEFAULT_COPY_UNTRACKED, DEFAULT_LINK_DIRS, buildExport, exportDirFor, recordProof, removeExport } from '../proof/export.mjs';
 import { acquireProofLock, lockHolder, releaseProofLock } from '../proof/lock.mjs';
 import { MECHANISMS, readJournal, restoreJournal, runRedGreen } from '../proof/red-green.mjs';
-import { adapterPrecheck, runnerCovers, runnerHook, runnerTimeoutMs, selectRunner } from '../proof/runners.mjs';
+import { adapterPrecheck, defaultPestRunner, runnerCovers, runnerHook, runnerTimeoutMs, selectRunner } from '../proof/runners.mjs';
 import { tierFor } from '../proof/tiers.mjs';
 import { blockTree } from '../proof/worktree.mjs';
 import { blockFileSet, repoRelativePath } from '../review/gate-check.mjs';
@@ -282,18 +282,17 @@ export async function runProof(args, deps = {}) {
       const file = normalizeTestPath(sep < 0 ? flags.test : flags.test.slice(0, sep));
       const runId = flags.run;
       const record = await readRun(runId);
-      // B87: the runner comes from the run snapshot only, never the live file; no entry matches ⇒
-      // the built-in node:test command, or the refusal
+      const block = record.blocks?.[blockId];
+      if (block?.status !== 'open') throw new StateError('no-block', `block ${blockId} is not open in run ${runId}`);
+      const place = await proofPlace(runId, record, blockId, block);
+      // Explicit commands come from the snapshot; unmatched PHP tests get the Pest default.
       const runners = proofRunners(record);
-      const entry = selectRunner(runners, file);
+      const entry = selectRunner(runners, file) ?? await defaultPestRunner(place.dir, file, testCase);
       const runner = entry === null ? null : (hook(entry, { file, testCase }) ?? null);
       // a matched entry is run by its hook or not at all: never a node:test fallback (no row, no precheck)
       if (entry !== null && runner === null) throw new StateError('usage', `the ${entry.adapter} runner for ${file} has no hook; no proof was run`);
       // exactly one of the two: the built-in argv without a runner, the runner (its own argv) with one
       const how = runner === null || entry === null ? { argv: filteredTestArgv(file, testCase) } : { runner, timeoutMs: runnerTimeoutMs(entry) };
-      const block = record.blocks?.[blockId];
-      if (block?.status !== 'open') throw new StateError('no-block', `block ${blockId} is not open in run ${runId}`);
-      const place = await proofPlace(runId, record, blockId, block);
       await assertTestFile(place.dir, file);
       const writeRow = (/** @type {Record<string, any>} */ row) => appendRow(row, { slug: record.project });
       const config = await configAt(record.workspace);
@@ -327,6 +326,7 @@ export async function runProof(args, deps = {}) {
         test: { file, ...(testCase === undefined ? {} : { case: testCase }), characterization: mechanism === 'assertion-deletion' },
         sources,
         isolation,
+        setup: exp ? config?.proof?.worktree?.setup ?? [] : [],
         print: (line) => err(`${line}\n`),
       });
       // B20: the signed row names what the proof covers — the block gate reads `covers` per
@@ -343,6 +343,7 @@ export async function runProof(args, deps = {}) {
       // values are never shown
       const runnerFields =
         runner === null ? {} : { runner: runner.adapter, failed_tests: red !== null && 'failed_tests' in red ? red.failed_tests : [], env_keys: [...runner.env_keys] };
+      const setupFields = result.reason === 'setup' ? { reason: result.reason, output_tail: result.output_tail } : {};
       await recordProof({
         runId,
         writeRow,
@@ -359,6 +360,7 @@ export async function runProof(args, deps = {}) {
           failed: red?.failed ?? null,
           covers,
           ...runnerFields,
+          ...setupFields,
         },
       });
       out({
@@ -371,6 +373,7 @@ export async function runProof(args, deps = {}) {
         green: result.green ?? null,
         proven,
         ...runnerFields,
+        ...setupFields,
         ...(exp ? { export: { dir: exp.dir, restored: exp.restored, untracked: exp.untracked } } : {}),
       });
       return proven ? 0 : 1;

package/src/cli/report.mjs

@@ -1,8 +1,9 @@
 /**
  * `code-forge report [--slug <slug>] [--json] [--export <dir>]` (plan §6.2, R4). Terminal output
- * only, plus an optional `--export <dir>` that writes the same 15 sections as JSON files. The
- * terminal output ends with the spend per run (B33) and the mode of each run (B59: brief or plan);
- * both are text only, never in `--json` or `--export`. The 14th section, `outside_review` (B66), is
+ * only, plus an optional `--export <dir>` that writes the same sections as JSON files. The
+ * terminal output includes spend per run (B33) and the mode of each run (B59: brief or plan)
+ * before the final specialist_outcomes section. Spend and mode are text only, never in
+ * `--json` or `--export`. The 14th section, `outside_review` (B66), is
  * printed as text lines under its header (`outside review: none`, or one line per PR).
  */
 
@@ -76,11 +77,17 @@ export async function runReport(args, deps = {}) {
     }
 
     for (const [name, data] of Object.entries(sections)) {
-      const body = name === 'outside_review' ? outsideReviewLines(data) : `${JSON.stringify(data, null, 2)}\n`;
+      if (name === 'specialist_outcomes') continue;
+      let body;
+      if (name === 'cost_per_block') body = blockTimeLines(data);
+      else if (name === 'run_time') body = runTimeLines(data);
+      else if (name === 'outside_review') body = outsideReviewLines(data);
+      else body = `${JSON.stringify(data, null, 2)}\n`;
       out(`== ${name} ==\n${body}`);
     }
     out(spendLines(buildSpend(rows)));
     out(modeLines(buildRunModes(rows)));
+    out(`== specialist_outcomes ==\n${specialistOutcomeLines(sections.specialist_outcomes)}`);
     return 0;
   } catch (err_) {
     err(`report: ${err_?.message ?? String(err_)}\n`);
@@ -88,15 +95,55 @@ export async function runReport(args, deps = {}) {
   }
 }
 
+/** @param {{outcomes: any[], total: {count: number, cost_usd: number, minutes: number}}} data */
+function specialistOutcomeLines({ outcomes, total }) {
+  const cost = (/** @type {number | null} */ usd) => usd === null ? '-' : `$${usd.toFixed(4)}`;
+  const lines = ['skill | step | status | cost_usd | minutes'];
+  for (const r of outcomes) lines.push(`${r.skill} | ${r.step ?? '-'} | ${r.status} | ${cost(r.cost_usd)} | ${r.minutes ?? '-'}`);
+  lines.push(`total (${total.count} outcomes): ${cost(total.cost_usd)} | ${total.minutes} minutes`);
+  return `${lines.join('\n')}\n`;
+}
+
+/** @param {number | null} ms @returns {string} */
+function duration(ms) {
+  if (ms === null) return '-';
+  const seconds = Math.floor(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ${seconds % 60}s`;
+  return `${Math.floor(minutes / 60)}h ${minutes % 60}m ${seconds % 60}s`;
+}
+
+/** @param {any[]} blocks @returns {string} */
+function blockTimeLines(blocks) {
+  const lines = ['run | block | USD | wall | human wait | status'];
+  for (const b of blocks) {
+    lines.push(`${b.run ?? 'outside runs'} | ${b.block} | $${b.totalUsd.toFixed(4)} | ${duration(b.wallMs)} | ${duration(b.humanWaitMs)} | ${b.completed ? 'completed' : b.stopped ? 'stopped' : 'open'}`);
+    lines.push(`  level ${b.level ?? '-'} · lane ${b.lane ?? '-'} · coder $${b.coderUsd.toFixed(4)} · review $${b.reviewUsd.toFixed(4)} · S1+S2 $${b.s1s2Usd.toFixed(4)} · facts $${b.factsUsd.toFixed(4)} · other $${b.otherUsd.toFixed(4)} · gates ${duration(b.gateTimeMs ?? null)} · review time ${duration(b.reviewTimeMs ?? null)} · proof ${duration(b.proofTimeMs)} · ${b.unknownUsdSessions} unknown`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+/** @param {{runs: any[], outside_runs?: {usd: number, rows: number}, total: {runs: number, wallMs: number, usd: number, blocks_closed: number}}} data @returns {string} */
+function runTimeLines({ runs, outside_runs, total }) {
+  const lines = ['run | started | ended | wall | USD | closed | stopped'];
+  for (const r of runs) lines.push(`${r.run} | ${r.started ?? '-'} | ${r.open ? 'open' : r.ended ?? '-'} | ${duration(r.wallMs)} | $${r.usd.toFixed(4)} | ${r.blocks_closed} | ${r.blocks_stopped}`);
+  if (outside_runs) lines.push(`outside runs: $${outside_runs.usd.toFixed(4)} (${outside_runs.rows} rows, no wall time)`);
+  lines.push(`total (${total.runs} run${total.runs === 1 ? '' : 's'}): ${duration(total.wallMs)} | $${total.usd.toFixed(4)} | ${total.blocks_closed} closed`);
+  return `${lines.join('\n')}\n`;
+}
+
 /**
- * B33: the running spend per run (open blocks included), after the 15 sections. Unknown-price
+ * B33: the running spend per run (open blocks included), after the sections. Unknown-price
  * sessions are named, never priced.
  * @param {ReturnType<typeof buildSpend>} spend @returns {string}
  */
 export function spendLines({ runs, total }) {
   const unknown = (/** @type {number} */ n) => (n > 0 ? ` · ${n} with unknown price (not counted)` : '');
   const lines = ['spend per run (estimated USD, open blocks included):'];
-  for (const r of runs) lines.push(`  run ${r.run ?? '(none)'}: $${r.usd.toFixed(4)} · ${r.sessions} session(s)${unknown(r.unknown)}`);
+  for (const r of runs.filter((r) => r.run !== null)) lines.push(`  run ${r.run}: $${r.usd.toFixed(4)} · ${r.sessions} session(s)${unknown(r.unknown)}`);
+  const outside = runs.find((r) => r.run === null);
+  if (outside) lines.push(`  outside runs: $${outside.usd.toFixed(4)} · ${outside.sessions} session(s)${unknown(outside.unknown)}`);
   lines.push(`  total: $${total.usd.toFixed(4)} · ${total.sessions} session(s)${unknown(total.unknown)}`);
   return `${lines.join('\n')}\n`;
 }