simt-dev 0.7.0 → 0.7.1

package/src/ci/workflow.mjs

@@ -167,7 +167,7 @@ function checkoutFull() {
  *  to. The own gate also varies the platforms and the Node versions, because this
  *  package is the one whose floor and whose ADR-012 claim have to hold on more than
  *  the minimum. */
-function skeleton(name, steps, { matrix = null } = {}) {
+function skeleton(name, steps, { matrix = null, timeoutMinutes = 5, gateMain = false } = {}) {
   const axes = matrix
     ? Object.entries(matrix)
         .map(([axis, values]) => `        ${axis}: [${values.map((v) => `'${v}'`).join(', ')}]`)
@@ -182,9 +182,22 @@ function skeleton(name, steps, { matrix = null } = {}) {
   // it is written escaped, the same way the `concurrency` line below spells its own two.
   const runner = matrix?.os ? '\${{ matrix.os }}' : 'ubuntu-latest';
   const job = matrix?.node ? '\${{ matrix.os }} node \${{ matrix.node }}' : name;
-  return `name: ${name}
-
-# Pull requests only, and that is a decision rather than a default.
+  // Two trigger blocks, because the two copies answer different questions. An
+  // adopting repository merges through pull requests, which is where its gate runs.
+  // This repository merges locally, so a merge never opens a pull request: without a
+  // push trigger the commit that lands on `main` is the one no gate ever ran on
+  // (review 0003 Q57). Each block ships only in the copy whose claim it states.
+  const trigger = gateMain
+    ? `# Pull requests ask whether a change may merge; a push to \`main\` asks whether
+# what already merged is sound. This repository merges locally, so a merge never
+# opens a pull request — without the second trigger the commit that lands on
+# \`main\` is the one no gate ran on.
+on:
+  pull_request:
+  push:
+    branches: [main]
+`
+    : `# Pull requests only, and that is a decision rather than a default.
 #
 # A gate that runs on every push re-runs itself for every commit that pushes a
 # branch forward, including the ones nobody asked it about, and its verdict has to
@@ -194,7 +207,10 @@ function skeleton(name, steps, { matrix = null } = {}) {
 # on \`main\` is whatever CI the repository already has there.
 on:
   pull_request:
+`;
+  return `name: ${name}
 
+${trigger}
 # Read-only is enough to check a repo, and a gate job does not need to write to it.
 permissions:
   contents: read
@@ -207,7 +223,7 @@ jobs:
   check:
     name: ${job}
     runs-on: ${runner}
-${strategy}    timeout-minutes: 5
+${strategy}    timeout-minutes: ${timeoutMinutes}
     steps:
 ${steps}`;
 }
@@ -268,7 +284,7 @@ export function renderWorkflow({ own = false, npm = true, manager = null, versio
         '      - name: tests',
         '        run: npm test',
         '      - name: skill registry lint',
-        '        run: node bin/simt.mjs graph lint',
+        '        run: npm run lint',
         '      - name: the gate copy in this repo is current',
         // The drift this exception exists to prevent, checked where it would be caught.
         // Without it a template change lands with the copy still describing the old
@@ -282,7 +298,14 @@ export function renderWorkflow({ own = false, npm = true, manager = null, versio
       // sentence was false in the one repository that could have made it true, and no
       // check read it - the package declares `os` for npm to enforce, and nothing here
       // ever ran a test on a second platform.
-      { matrix: { os: ['ubuntu-latest', 'macos-latest'], node: [floor, '24', '26'] } },
+      // The slowest leg (macOS, full suite plus the registry lint) ran 4 min 28 s
+      // against a 5-minute timeout, so the timeout that was meant to bound a hang
+      // was about to fail a passing run instead. 15 leaves the hang bounded and the
+      // run alone; the sharding that would make it short again is Q92, not this row.
+      //
+      // `gateMain` because this repository merges locally: `pull_request` alone left
+      // the one commit that reached `main` ungated (review 0003 Q57).
+      { matrix: { os: ['ubuntu-latest', 'macos-latest'], node: [floor, '24', '26'] }, timeoutMinutes: 15, gateMain: true },
     )}\n`;
   }
 

package/src/cli.mjs

@@ -0,0 +1,45 @@
+// The CLI proper, imported by `bin/simt.mjs` after the runtime floor is checked.
+//
+// It lives here rather than in `bin/` because a static import in the entry point is
+// evaluated before the entry point's own code: the version check could not run first,
+// and an old Node failed inside the module graph instead of saying which version it
+// needed (review 0003 Q54).
+
+import { parse, rawJsonFlag } from './argv.mjs';
+import { EXIT, fail, jsonFailMode, jsonIndentDefault } from './output/index.mjs';
+
+try {
+  const argv = process.argv.slice(2);
+  const parsed = parse(argv);
+  if (!parsed.ok) {
+    // The flags do not exist yet, so the JSON mode is read off the raw words:
+    // a parse failure under `--json` is a JSON document on stdout, not text on
+    // stderr with an empty stdout (Q11, ADR-070 ruling 4).
+    jsonFailMode(rawJsonFlag(argv));
+    process.exit(fail(parsed.error.message, parsed.error.code));
+  }
+  const { flags, positional } = parsed.value;
+
+  // Set before anything can fail: `no command given` under `--json` is a JSON
+  // document too, and a failure that prints as text with an empty stdout breaks
+  // the same ruling the parse failure above honours (Q11, ADR-070 ruling 4).
+  jsonIndentDefault(flags.pretty === true);
+  jsonFailMode(flags.json === true);
+
+  // No arguments at all is a usage error, not a silent help dump: an agent that
+  // ran the wrong thing should be told so rather than handed 40 lines of prose.
+  if (positional.length === 0 && !flags.help && !flags.version) {
+    process.exit(fail('no command given', EXIT.USAGE));
+  }
+
+  const { dispatch } = await import('./commands/index.mjs');
+  const code = (await dispatch(argv)) ?? EXIT.OK;
+  // Assigned, not forced: a large document on stdout (a `--json --diff` over a
+  // skill-sized body exceeds the 64 KiB pipe buffer) is still draining when the
+  // command resolves, and `process.exit()` cuts it — exit 0 with half a JSON
+  // document on stdout. Letting the loop empty first makes the exit honest
+  // (plan 0003 R50; the S10 contract asserts the document parses).
+  process.exitCode = code;
+} catch (error) {
+  process.exit(fail(error?.message ?? String(error), EXIT.FAIL));
+}

package/src/commands/agent.mjs

@@ -27,9 +27,10 @@ import {
   rendered,
   writeAgentPlan,
 } from '../agents/render.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function agentsCommand(sub, args, flags) {
-  const root = flags.root ?? args[0] ?? process.cwd();
+  const root = commandRoot(flags, args);
   if (sub === 'install') return installAgents(root, flags);
   if (sub === 'status') return agentsStatus(root, flags);
   return fail(`unknown agents subcommand ${sub}`, EXIT.USAGE, `run: ${CLI} agents status`);
@@ -102,7 +103,6 @@ async function installAgents(root, flags) {
         '',
         `PLAN     nothing written; apply with: ${CLI} agents install --yes`,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
@@ -135,7 +135,6 @@ async function installAgents(root, flags) {
       '',
       `WROTE    ${written.length} agent file(s)`,
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   // After the report: the report says what, the diff shows it (R50).
   emitDiffs(diffs, flags);
@@ -193,7 +192,7 @@ async function agentsStatus(root, flags) {
     lines.push('', 'problems:');
     for (const p of problems) lines.push(`  ${p}`);
   }
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return problems.length === 0 ? EXIT.OK : EXIT.FAIL;
 }
 

package/src/commands/agenthook.mjs

@@ -44,6 +44,7 @@ import {
   installedIn,
   rendered,
 } from '../agenthooks/render.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function agentHookCommand(args, flags) {
   const event = args[0];
@@ -77,7 +78,7 @@ export async function agentHookCommand(args, flags) {
   // dynamic import that only this event opens.
   if (event === 'prompt-submit') {
     const { deliverPrompt } = await import('../agenthooks/prompt.mjs');
-    const delivered = await deliverPrompt(row, payload);
+    const delivered = await deliverPrompt(row, payload, { root: flags.root });
     if (delivered.skipped) {
       note(`note     ${id}: no packet delivered (${delivered.skipped})`);
       return EXIT.OK;
@@ -167,7 +168,7 @@ export async function agentHookCommand(args, flags) {
 }
 
 export async function agentHooksCommand(sub, args, flags) {
-  const root = flags.root ?? args[0] ?? process.cwd();
+  const root = commandRoot(flags, args);
   if (sub === 'install') return installHooks(root, flags);
   if (sub === 'status') return hooksStatus(root, flags);
   return fail(`unknown agent-hooks subcommand ${sub}`, EXIT.USAGE, `run: ${CLI} agent-hooks status`);
@@ -286,7 +287,6 @@ async function installHooks(root, flags) {
           ? `REFUSED  ${refused.length} config file(s) could not be read; nothing written`
           :        `PLAN     nothing written; apply with: ${CLI} agent-hooks install --yes`,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
@@ -350,7 +350,6 @@ async function installHooks(root, flags) {
       '',
       `WROTE    ${written.length} hooks file(s)${shimWritten ? ' and the shim' : ''}; each one runs the ${AGENT_HOOK_SHIM} shim before the tool call`,
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   // After the report: the report says what, the diff shows it (R50).
   emitDiffs(diffs, flags);
@@ -448,7 +447,7 @@ async function hooksStatus(root, flags) {
     lines.push('', 'problems:');
     for (const p of problems) lines.push(`  ${p}`);
   }
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return problems.length === 0 ? EXIT.OK : EXIT.FAIL;
 }
 

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;
 }
 
@@ -243,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;
 }
 
@@ -256,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;
@@ -302,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';
@@ -353,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, {
@@ -390,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;
 }
 
@@ -405,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 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 = [
@@ -424,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;