simt-dev 0.6.3 → 0.7.1

package/src/commands/bench.mjs

@@ -5,11 +5,13 @@
 // default and write artifacts to `.simt/bench/` only when authorised with
 // `--yes` (and not `--dry-run`). `bench report` is read-only.
 
-import { resolve } from 'node:path';
+import { dirname, resolve } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 
 import { CLI } from '../name.mjs';
 import { EXIT, emit, emitJson, fail, isJson, writeMode } from '../output/index.mjs';
 import { DEFAULT_MINE_TARGET, mineTasks } from '../bench/mine.mjs';
+import { buildCorpusDocument, verifyCorpusDocument, writeCorpusDocument } from '../bench/corpus.mjs';
 import { regradeRun, runBench } from '../bench/run.mjs';
 import { buildBenchReport } from '../bench/report.mjs';
 import { formatRecall, measureRecall } from '../index/map.mjs';
@@ -18,14 +20,33 @@ import { runBenchProbes } from '../bench/probes.mjs';
 import { selectRuleVariants } from '../bench/variants.mjs';
 import { criticBench } from '../review/critic.mjs';
 import { listFlag } from './skills.mjs';
+import { commandRoot } from '../repo-root.mjs';
+
+/**
+ * Refuse an authorised bench run that names no harness.
+ *
+ * The default harness is `gold`, which applies the reference patch instead of asking
+ * an agent: a `--yes` run with no harness measured the grader and stored the result as
+ * an arm's evidence (review 0003 Q49). A default cannot be mistaken for a measurement
+ * if there is no default.
+ */
+function requireHarness(flags, command) {
+  if (typeof flags.harness === 'string' && flags.harness.length > 0) return null;
+  return fail(
+    `${command} --yes needs an explicit --harness`,
+    EXIT.USAGE,
+    `pass --harness <name>: an agent adapter such as \`--harness claude\`, or a calibration harness (\`gold\`, \`noop\`)`, 
+  );
+}
 
 export async function benchMineCommand(positional, flags) {
-  const root = resolve(flags.root ?? positional[0] ?? process.cwd());
+  const root = resolve(commandRoot(flags, positional));
   const { dryRun, apply } = writeMode(flags);
 
   const result = await mineTasks(root, {
     apply,
     target: DEFAULT_MINE_TARGET,
+    replace: flags.replace === true,
   });
 
   if (!result.ok) {
@@ -64,7 +85,7 @@ export async function benchMineCommand(positional, flags) {
     for (const task of result.tasks) {
       const subject = task.prompt.split('\n')[0];
       lines.push(
-        `task     ${task.id}  f2p=${task.f2p.length}  p2p=${task.f2p.length}  files=${task.gold.files}  +${task.gold.linesAdded}/-${task.gold.linesRemoved}  ${subject}`,
+        `task     ${task.id}  f2p=${task.f2p.length}  p2p=${task.p2p.length}  files=${task.gold.files}  +${task.gold.linesAdded}/-${task.gold.linesRemoved}  ${subject}`,
       );
     }
   } else {
@@ -75,12 +96,12 @@ export async function benchMineCommand(positional, flags) {
     lines.push(`remedy   run: ${CLI} bench mine --yes`);
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
 export async function benchRunCommand(positional, flags) {
-  const root = resolve(flags.root ?? positional[0] ?? process.cwd());
+  const root = resolve(commandRoot(flags, positional));
   const { dryRun, apply } = writeMode(flags);
 
   if (flags.regrade !== undefined) {
@@ -123,10 +144,15 @@ export async function benchRunCommand(positional, flags) {
         `run      ${run.runId}/${run.task}  arm=${run.arm}  resolved=${run.resolved}  gates=${run.gatesPassed}  reproduced=${run.reproduced}`,
       );
     }
-    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    emit(lines.join('\n'));
     return code;
   }
 
+  if (apply) {
+    const missing = requireHarness(flags, 'bench run');
+    if (missing !== null) return missing;
+  }
+
   const arms = listFlag(flags.arm);
   const tasks = listFlag(flags.task);
   const harness = flags.harness ?? 'gold';
@@ -189,7 +215,7 @@ export async function benchRunCommand(positional, flags) {
     lines.push(`remedy   run: ${CLI} bench run --yes`);
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -217,6 +243,7 @@ export async function benchReportCommand(positional, flags) {
       harness: flags.harness,
       model: flags.model,
       compare: compareItems.length === 2 ? compareItems : null,
+      crossGroup: Boolean(flags.crossGroup),
     });
   } catch (error) {
     return fail(
@@ -242,7 +269,7 @@ export async function benchReportCommand(positional, flags) {
     return EXIT.OK;
   }
 
-  emit(`${report.markdown}\n\n### Map\n\n${formatRecall(mapRecall)}`, { maxBytes: flags.maxBytes ?? 0 });
+  emit(`${report.markdown}\n\n### Map\n\n${formatRecall(mapRecall)}`);
   return EXIT.OK;
 }
 
@@ -255,8 +282,12 @@ async function recallOrUnmeasured(root) {
 }
 
 export async function benchAblateCommand(positional, flags) {
-  const root = resolve(flags.root ?? positional[0] ?? process.cwd());
+  const root = resolve(commandRoot(flags, positional));
   const { dryRun, apply } = writeMode(flags);
+  if (apply) {
+    const missing = requireHarness(flags, 'bench ablate');
+    if (missing !== null) return missing;
+  }
   const harness = flags.harness ?? 'gold';
   const model = flags.model;
   const reps = flags.reps ?? 1;
@@ -301,13 +332,18 @@ export async function benchAblateCommand(positional, flags) {
     lines.push(`remedy   run: ${CLI} bench ablate --yes`);
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
 export async function benchProbesCommand(positional, flags) {
-  const root = resolve(flags.root ?? positional[0] ?? process.cwd());
+  const root = resolve(commandRoot(flags, positional));
   const { dryRun, apply } = writeMode(flags);
+  if (apply) {
+    const missing = requireHarness(flags, 'bench probes');
+    if (missing !== null) return missing;
+  }
+
   const arms = listFlag(flags.arm);
   const probes = listFlag(flags.task);
   const harness = flags.harness ?? 'gold';
@@ -352,13 +388,17 @@ export async function benchProbesCommand(positional, flags) {
     lines.push(`remedy   run: ${CLI} bench probes --yes`);
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
 export async function benchVariantsCommand(positional, flags) {
-  const root = resolve(flags.root ?? positional[0] ?? process.cwd());
+  const root = resolve(commandRoot(flags, positional));
   const { dryRun, apply } = writeMode(flags);
+  if (apply) {
+    const missing = requireHarness(flags, 'bench variants');
+    if (missing !== null) return missing;
+  }
   let result;
   try {
     result = await selectRuleVariants(root, {
@@ -389,7 +429,7 @@ export async function benchVariantsCommand(positional, flags) {
     ),
   ];
   if (!result.applied) lines.push(`remedy   run: ${CLI} bench variants --yes`);
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -404,13 +444,13 @@ export async function benchVariantsCommand(positional, flags) {
 // the row says precision >= 0.8 on >= 30 labelled diffs promotes it to a gate,
 // and until a bench here shows that, every report calls the critic advisory.
 export async function benchCriticCommand(positional, flags, commands = []) {
-  const root = resolve(flags.root ?? positional[0] ?? process.cwd());
-  const labelsPath = flags.labels ?? '.simt/critic-labels.jsonl';
+  const root = resolve(commandRoot(flags, positional));
+  const labelsPath = flags.labels ?? '.simt/local/critic-labels.jsonl';
   const result = await criticBench(root, { labelsPath, flags, commands });
   if (typeof result === 'number') return result;
 
   if (isJson(flags)) {
-    emitJson(result, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    emitJson(result);
     return EXIT.OK;
   }
   const lines = [
@@ -423,6 +463,140 @@ export async function benchCriticCommand(positional, flags, commands = []) {
   ];
   if (result.labelsNote) lines.push(`labels   ${result.labelsNote}`);
   for (const error of result.errors) lines.push(`error    ${error}`);
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
+  return EXIT.OK;
+}
+
+// `simt bench export` / `simt bench import` (review 0003 Q48).
+//
+// The vault is keyed on the repository's root commit and lives outside every
+// checkout. That is what makes it safe as a hidden verifier, and it is also
+// why a clone cannot read the corpus mined on another machine: the committed
+// tasks failed with ENOENT from every other checkout. A sealed document
+// carries the descriptors and both patches for every task in one file, so an
+// export on one machine and an import on another reproduce the corpus
+// exactly, and the seal is checked before a single byte is trusted.
+
+export async function benchExportCommand(positional, flags) {
+  const out = positional[0];
+  if (!out) {
+    return fail(
+      'bench export needs a target file: bench export <corpus.json>',
+      EXIT.USAGE,
+      `export the sealed corpus: ${CLI} bench export corpus.json --yes`,
+    );
+  }
+  const root = resolve(commandRoot(flags));
+  const { dryRun, apply } = writeMode(flags);
+
+  let doc;
+  try {
+    doc = await buildCorpusDocument(root);
+  } catch (error) {
+    return fail(
+      `${root}: ${error.message ?? error}`,
+      EXIT.CONFIG,
+      `mine tasks first: ${CLI} bench mine --yes`,
+    );
+  }
+
+  if (doc.taskCount === 0) {
+    return fail(
+      `${root}: no mined tasks to export`,
+      EXIT.USAGE,
+      `mine tasks first: ${CLI} bench mine --yes`,
+    );
+  }
+
+  if (apply) {
+    const absOut = resolve(out);
+    await mkdir(dirname(absOut), { recursive: true });
+    await writeFile(absOut, `${JSON.stringify(doc, null, 2)}\n`, 'utf8');
+  }
+
+  if (isJson(flags)) {
+    emitJson({
+      ok: true,
+      command: 'bench export',
+      root,
+      dryRun,
+      applied: apply,
+      out: resolve(out),
+      taskCount: doc.taskCount,
+      seal: doc.seal,
+    });
+    return EXIT.OK;
+  }
+
+  const lines = [
+    `bench    export  ${resolve(out)}`,
+    `mode     ${apply ? 'applied' : dryRun ? 'dry-run (writes nothing)' : 'preview (pass --yes to write)'}`,
+    `tasks    ${doc.taskCount}`,
+    `seal     ${doc.seal}`,
+  ];
+  if (!apply) lines.push(`remedy   run: ${CLI} bench export ${out} --yes`);
+  emit(lines.join('\n'));
+  return EXIT.OK;
+}
+
+export async function benchImportCommand(positional, flags) {
+  const file = positional[0];
+  if (!file) {
+    return fail(
+      'bench import needs a corpus file: bench import <corpus.json>',
+      EXIT.USAGE,
+      `import a sealed corpus: ${CLI} bench import corpus.json --yes`,
+    );
+  }
+  const root = resolve(commandRoot(flags));
+  const { dryRun, apply } = writeMode(flags);
+
+  let doc;
+  try {
+    doc = JSON.parse(await readFile(file, 'utf8'));
+  } catch (error) {
+    return fail(
+      `${file}: ${error.message ?? error}`,
+      EXIT.USAGE,
+      `export one with: ${CLI} bench export ${file} --yes`,
+    );
+  }
+
+  const problem = verifyCorpusDocument(doc);
+  if (problem !== null) {
+    return fail(
+      `${file}: ${problem}`,
+      EXIT.CONFIG,
+      `export a fresh corpus: ${CLI} bench export ${file} --yes`,
+    );
+  }
+
+  const result = await writeCorpusDocument(root, doc, { apply });
+
+  if (isJson(flags)) {
+    emitJson({
+      ok: true,
+      command: 'bench import',
+      root,
+      file: resolve(file),
+      dryRun,
+      applied: result.applied,
+      taskCount: result.tasks,
+      tasksDir: result.tasksDir,
+      vaultRoot: result.vaultRoot,
+      seal: doc.seal,
+    });
+    return EXIT.OK;
+  }
+
+  const lines = [
+    `bench    import  ${resolve(file)}`,
+    `mode     ${apply ? 'applied' : dryRun ? 'dry-run (writes nothing)' : 'preview (pass --yes to write)'}`,
+    `imported ${result.tasks} task(s)  seal=${doc.seal}`,
+    `tasks    ${result.tasksDir}`,
+    `vault    ${result.vaultRoot}`,
+  ];
+  if (!apply) lines.push(`remedy   run: ${CLI} bench import ${file} --yes`);
+  emit(lines.join('\n'));
   return EXIT.OK;
 }

package/src/commands/brief.mjs

@@ -19,8 +19,9 @@ import { CLI } from '../name.mjs';
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { DEFAULT_BRIEF_BYTES, explainPacket } from '../brief/packet.mjs';
 import { assembleBrief } from '../brief/assemble.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
-export async function briefCommand(args, flags) {
+export async function briefCommand(args, flags, commands = []) {
   if (args.length > 1) {
     return fail(`brief takes one task, not ${args.length}`, EXIT.USAGE, `run: ${CLI} brief "<task>"`);
   }
@@ -33,11 +34,12 @@ export async function briefCommand(args, flags) {
   }
 
   const result = await assembleBrief({
-    root: flags.root ?? process.cwd(),
+    root: commandRoot(flags),
     task: String(args[0] ?? flags.task ?? ''),
     paths: flags.paths === undefined ? null : flags.paths,
     budget,
     flags,
+    commands,
   });
   if (result.error) return result.error;
   // Unreachable from here — only a delivered brief asks for a cold index to be reported
@@ -67,12 +69,11 @@ export async function briefCommand(args, flags) {
         explain: flags.explain === true ? explainPacket(items, { cut }) : undefined,
         text: packed.text,
       },
-      { pretty: flags.pretty === true, maxBytes: Number(flags.maxBytes ?? 0) || 0 },
     );
     return EXIT.OK;
   }
 
   const body = flags.explain === true ? [packed.text, '', 'EXPLAIN', ...explainPacket(items, { cut })] : [packed.text];
-  emit(body.join('\n'), { maxBytes: Number(flags.maxBytes ?? 0) || 0 });
+  emit(body.join('\n'));
   return EXIT.OK;
 }

package/src/commands/ci.mjs

@@ -27,6 +27,7 @@ import { EXIT, emit, emitJson, isJson, note, writeMode } from '../output/index.m
 import { planWorkflow, renderWorkflow, WORKFLOW_FILE } from '../ci/workflow.mjs';
 import { planDependabot, renderDependabot, DEPENDABOT_FILE } from '../ci/dependabot.mjs';
 import { CLI } from '../name.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 /**
  * The two plans, with the render and the plan-time data each needs kept attached.
@@ -43,7 +44,7 @@ function targets() {
 }
 
 export async function ciCommand(positional, flags) {
-  const root = flags.root ?? positional[0] ?? process.cwd();
+  const root = commandRoot(flags, positional);
   const mode = writeMode(flags);
   const checkOnly = flags.check === true;
 

package/src/commands/compare.mjs

@@ -21,10 +21,10 @@
 
 import { basename, resolve } from 'node:path';
 
-import { EXIT, emit, emitJson, fail, isJson, note } from '../output/index.mjs';
+import { EXIT, fail, note, present } from '../output/index.mjs';
 import { provenanceDigest } from '../projection/project.mjs';
 import { GATES } from '../hooks/gates.mjs';
-import { buildRow, summarise } from '../compare/row.mjs';
+import { buildRows, resolveConcurrency, summarise } from '../compare/row.mjs';
 import { discover } from '../compare/discover.mjs';
 import { learnAcrossEstate, renderLearningLines } from '../compare/learn.mjs';
 import { targetRoot, WORKSPACE_REMEDY } from '../workspace.mjs';
@@ -60,12 +60,13 @@ export async function compareCommand(positional, flags) {
   const expectedSha = await provenanceDigest();
   const context = { expectedSha, gates: new Set(Object.keys(GATES)), gateKinds: GATE_KINDS };
 
-  // Sequential on purpose. 16 fingerprint+region computations each spawn a git
-  // process; running them concurrently produces a burst of subprocesses and no
-  // measurable speedup, because the work is process-spawn bound rather than CPU
-  // bound. Determinism of the output matters more than wall clock on a dashboard.
-  const rows = [];
-  for (const repo of found.repos) rows.push(await buildRow(repo, context));
+  // Parallel with a cap, in discovery order. 16 fingerprint+region computations
+  // each spawn a git process; unbounded parallelism is a burst of subprocesses
+  // with no speedup, and sequential builds are what took 48 s over MCP for 17
+  // repos (review 0003 Q38). The cap keeps the burst bounded while overlapping
+  // the spawn wait; the rows still come back in input order, so two runs diff
+  // cleanly and determinism of the output is untouched.
+  const rows = await buildRows(found.repos, context, { concurrency: resolveConcurrency(flags) });
   const learning = await learnAcrossEstate(found.repos);
 
   const summary = summarise(rows, {
@@ -77,50 +78,50 @@ export async function compareCommand(positional, flags) {
     directories: found.directories.length,
   });
 
-  if (isJson(flags)) {
-    emitJson({
-      ok: !rows.some((r) => r.problems.length > 0),
-      command: 'compare',
-      root: summary.root,
-      shape: summary.shape,
-      source: summary.source,
-      expectedSha: summary.expectedSha,
-      // Spread, not a hand-listed copy. A copy is a second place to forget: a field
-      // added to `summarise` renders in the text output and silently vanishes from
-      // `--json`, which is the combination automation trusts most. That is not
-      // hypothetical — `withOwnHooks` and `staleRuleFiles` both did it, and both
-      // were caught only because a test asserts the two shapes agree.
-      summary: {
-        repos: summary.repos,
-        adopted: summary.adopted,
-        unmanaged: summary.unmanaged,
-        broken: summary.broken,
-        drifted: summary.drifted,
-        current: summary.current,
-        noRegion: summary.noRegion,
-        malformed: summary.malformed,
-        staleRuleFiles: summary.staleRuleFiles,
-        packageRegions: summary.packageRegions,
-        stalePackages: summary.stalePackages,
-        hooksRouted: summary.hooksRouted,
-        withProblems: summary.withProblems,
-        withOwnHooks: summary.withOwnHooks,
-        shas: summary.shas,
-      },
-      rows,
-      learning,
-      worktrees: found.worktrees.map((w) => ({
-        name: w.name,
-        path: w.path,
-        owner: w.ownerName,
-        ownerMatchesDirName: w.ownerMatches,
-      })),
-      directories: found.directories.map((d) => basename(d)),
-    });
+  const payload = {
+    ok: !rows.some((r) => r.problems.length > 0),
+    command: 'compare',
+    root: summary.root,
+    shape: summary.shape,
+    source: summary.source,
+    expectedSha: summary.expectedSha,
+    // Spread, not a hand-listed copy. A copy is a second place to forget: a field
+    // added to `summarise` renders in the text output and silently vanishes from
+    // `--json`, which is the combination automation trusts most. That is not
+    // hypothetical — `withOwnHooks` and `staleRuleFiles` both did it, and both
+    // were caught only because a test asserts the two shapes agree.
+    summary: {
+      repos: summary.repos,
+      adopted: summary.adopted,
+      unmanaged: summary.unmanaged,
+      broken: summary.broken,
+      drifted: summary.drifted,
+      current: summary.current,
+      noRegion: summary.noRegion,
+      malformed: summary.malformed,
+      staleRuleFiles: summary.staleRuleFiles,
+      packageRegions: summary.packageRegions,
+      stalePackages: summary.stalePackages,
+      hooksRouted: summary.hooksRouted,
+      withProblems: summary.withProblems,
+      withOwnHooks: summary.withOwnHooks,
+      shas: summary.shas,
+    },
+    rows,
+    learning,
+    worktrees: found.worktrees.map((w) => ({
+      name: w.name,
+      path: w.path,
+      owner: w.ownerName,
+      ownerMatchesDirName: w.ownerMatches,
+    })),
+    directories: found.directories.map((d) => basename(d)),
+  };
+
+  if (present(payload, () => render(rows, summary, found, learning), flags) === 'json') {
     return rows.some((r) => r.problems.length > 0) ? EXIT.FAIL : EXIT.OK;
   }
 
-  emit(render(rows, summary, found, learning), { maxBytes: flags.maxBytes ?? 0 });
   if (summary.shape === 'repo') {
     note('note     one repository compared; pass --root at a workspace directory to compare its siblings');
   } else if (target.source === 'none') {

package/src/commands/completions.mjs

@@ -5,7 +5,7 @@
 // `$fpath`. A report line above it would be a report line in the user's shell
 // config.
 
-import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { EXIT, fail, present } from '../output/index.mjs';
 import { SHELLS, renderCompletions } from '../completions.mjs';
 
 export async function completionsCommand(args, flags, commands) {
@@ -18,10 +18,6 @@ export async function completionsCommand(args, flags, commands) {
   }
 
   const script = renderCompletions(shell, commands);
-  if (isJson(flags)) {
-    emitJson({ ok: true, command: 'completions', shell, script });
-    return EXIT.OK;
-  }
-  emit(script, { maxBytes: flags.maxBytes ?? 0 });
+  present({ ok: true, command: 'completions', shell, script }, () => script, flags);
   return EXIT.OK;
 }

package/src/commands/decide.mjs

@@ -2,22 +2,24 @@
 // a rulings skeleton, and structured `simt-affects` + `simt-supersedes` frontmatter
 // (plan 0003 R34).
 
-import { join, resolve } from 'node:path';
+import { join } from 'node:path';
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
-import { DECISIONS_DIR } from '../decisions/index.mjs';
+import { decisionsCutoff, decisionsDir } from '../decisions/dir.mjs';
 import { lintDecisions, scaffoldDecision } from '../memory/decide.mjs';
 import { commitJournal } from '../journal.mjs';
 import { diffField, emitDiffs } from '../diff.mjs';
 import { parsePathList } from '../argv.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function decideCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
 
   if (flags.check === true) {
-    const decisionsDir = join(root, 'docs', 'decisions');
-    const allowHistorical = resolve(decisionsDir) === DECISIONS_DIR;
-    const res = await lintDecisions(decisionsDir, { allowHistorical });
+    // Q55: one resolution — the manifest key, then the detected directory —
+    // and the cutoff from the same config, never a hard-coded number or path.
+    const relDir = await decisionsDir(root);
+    const res = await lintDecisions(join(root, relDir), { historicalCutoff: await decisionsCutoff(root) });
 
     if (isJson(flags)) {
       emitJson({
@@ -30,7 +32,7 @@ export async function decideCommand(args, flags) {
     }
 
     if (res.findings.length === 0) {
-      emit('decisions  ok', { maxBytes: flags.maxBytes ?? 0 });
+      emit('decisions  ok');
       return EXIT.OK;
     }
 
@@ -41,7 +43,6 @@ export async function decideCommand(args, flags) {
           ...(f.remedy ? [`  remedy: ${f.remedy}`] : []),
         ])
         .join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.FAIL;
   }
@@ -122,7 +123,7 @@ export async function decideCommand(args, flags) {
         : `would write ${res.relPath}; apply with: ${CLI} decide ${JSON.stringify(res.title)} --yes`,
   ];
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   // After the report: the report says what, the diff shows it (R50).
   emitDiffs(diffs, flags);
   return EXIT.OK;

package/src/commands/distill.mjs

@@ -16,7 +16,7 @@ export async function distillCommand(args, flags) {
   if (typeof result === 'number') return result;
 
   if (isJson(flags)) {
-    emitJson(result, { maxBytes: flags.maxBytes ?? 0 });
+    emitJson(result);
     return EXIT.OK;
   }
 
@@ -27,10 +27,11 @@ export async function distillCommand(args, flags) {
       `engine    ${result.engine}`,
       `budget    ${result.budget} bytes`,
       `citations ${result.citations}`,
-      ...(result.verified === true ? [] : result.faults.map((f) => `unverified ${f}`)),
+      // A cached proposal predates this field; `?? []` keeps the report from crashing on
+      // the file the command wrote one release ago (review 0003 Q52).
+      ...(result.verified === true ? [] : (result.faults ?? []).map((f) => `unverified ${f}`)),
       `proposal  ${result.proposal.path}  (${result.proposal.state}, ${result.proposal.bytes} bytes)`,
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   return EXIT.OK;
 }