simt-dev 0.6.3 → 0.7.1

package/src/commands/pack.mjs

@@ -28,6 +28,7 @@ import {
 } from '../packs/manage.mjs';
 import { readManifest } from '../projection/manifest.mjs';
 import { diffField, emitDiffs } from '../diff.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function packCommand(sub, args, flags) {
   if (sub === 'new') return packNew(args, flags);
@@ -40,9 +41,13 @@ export async function packCommand(sub, args, flags) {
  * Where a lint or publish resolves its pack: the positional directory, the
  * `--root`, or the working directory. `hooks` reads the same three in the same
  * order, so the two commands cannot disagree about which directory was meant.
+ *
+ * The positional wins, as this always said it did. The code read `--root` first,
+ * so `pack lint .simt/packs/a --root ../b` judged `b` while the prose and the
+ * command's own usage promised `a` (review 0003 Q58).
  */
 function packDir(args, flags) {
-  return resolve(flags.root ?? args[0] ?? process.cwd());
+  return resolve(args[0] ?? commandRoot(flags));
 }
 
 /**
@@ -98,7 +103,7 @@ async function packNew(args, flags) {
     return fail(sourceProblem, EXIT.USAGE, 'a pack source names where the bytes come from: `npm:<package>` or `git+https://…`');
   }
 
-  const dir = join(resolve(flags.root ?? process.cwd()), name);
+  const dir = join(resolve(commandRoot(flags)), name);
   const files = scaffoldPack({ name, source });
   const { apply, dryRun } = writeMode(flags);
   // A scaffold always creates into a directory that must not exist, so every
@@ -129,7 +134,6 @@ async function packNew(args, flags) {
         '',
         dryRun ? 'DRY-RUN  no files written' : `PLAN     nothing written; apply with: ${CLI} pack new ${name} --source ${source} --yes`,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
@@ -149,7 +153,6 @@ async function packNew(args, flags) {
       '',
       `WROTE    ${files.length} scaffold file(s); write the rule, then: ${CLI} pack lint ${dir}`,
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   // After the report: the report says what, the diff shows it (R50).
   emitDiffs(diffs, flags);
@@ -187,7 +190,7 @@ async function packLint(args, flags) {
     lines.push(`                        remedy: ${f.remedy}`);
   }
   lines.push('', ok ? 'PASSED   the pack is well-formed' : `FAILED   ${findings.length} finding(s)`);
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return ok ? EXIT.OK : EXIT.FAIL;
 }
 
@@ -247,7 +250,7 @@ async function packPublish(args, flags) {
   } else {
     lines.push('', `FAILED   ${result.findings.length} finding(s)`);
   }
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   if (result.ok && apply && result.published) {
     note(`note     never committed or pushed by this tool (ADR-001); the registry now has the bytes, the repos still need vendoring`);
   }

package/src/commands/plan.mjs

@@ -3,12 +3,13 @@ import { EXIT, emit, emitJson, fail, isJson, writeMode } from '../output/index.m
 import { formatCounts, planDone, planNext, planStatus } from '../plan/index.mjs';
 import { diffField, emitDiffs } from '../diff.mjs';
 import { CLI } from '../name.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 // Preview unless --yes, and --dry-run wins even then. A tracker row marked done
 // for a commit that was never written is a claim the next reader will believe.
 
 export async function planCommand(sub, args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   if (sub === 'status') return runStatus(root, flags);
   if (sub === 'next') return runNext(root, args[0] ?? null, flags);
   if (sub === 'done') {
@@ -35,7 +36,7 @@ async function runStatus(root, flags) {
   }
   lines.push('', `total    ${formatCounts(result.totals, result.stateOrder) || '-'}`);
   lines.push(`ready    ${result.ready}`);
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -55,7 +56,7 @@ async function runNext(root, id, flags) {
         lines.push(`  ${row.id}  ${row.doc}  depends on: ${row.dependsOn || '(none)'}${unknown}`);
       }
     }
-    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    emit(lines.join('\n'));
     return EXIT.OK;
   }
   const next = result.next;
@@ -68,7 +69,7 @@ async function runNext(root, id, flags) {
     '',
     next.section || '(no section for this id)',
   ];
-  emit(head.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(head.join('\n'));
   return EXIT.OK;
 }
 
@@ -104,7 +105,7 @@ async function runDone(root, id, sha, flags) {
   }
   if (result.evidenceRecorded) lines.push(`evidence ${result.sha}${result.test ? `  test: ${result.test}` : ''}`);
   else if (result.evidenceNote) lines.push(`note     ${result.evidenceNote}`);
-  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/plugin.mjs

@@ -1,4 +1,4 @@
-// simt plugin <claude|gemini|cursor> --out <dir> [--yes]
+// simt plugin <claude|gemini|cursor|opencode> --out <dir> [--yes]
 //
 // Build one harness package from the same tables `agent-hooks install` writes into a
 // repository, so a package and a repository install cannot drift apart. A dry run prints
@@ -10,6 +10,7 @@ import { EXIT, emit, emitJson, fail, isJson, writeMode } from '../output/index.m
 import { CLI } from '../name.mjs';
 import { buildPackage, PLUGIN_KINDS } from '../plugins.mjs';
 import { diffField, emitDiffs } from '../diff.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function pluginCommand(args, flags) {
   const kind = args[0];
@@ -27,7 +28,7 @@ export async function pluginCommand(args, flags) {
   }
 
   const { apply } = writeMode(flags);
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   const plan = await buildPackage(kind, { root, out, apply });
 
   // The `--diff` pairs: the generated files, created or refreshed (R50). The
@@ -68,7 +69,6 @@ export async function pluginCommand(args, flags) {
         ? `WROTE    ${plan.files.length} generated file(s) plus the runtime`
         : `PLAN     nothing written; apply with: ${CLI} plugin ${kind} --out ${out} --yes`,
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   // After the report: the report says what, the diff shows it (R50).
   emitDiffs(diffs, flags);

package/src/commands/prbody.mjs

@@ -12,9 +12,10 @@
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
 import { buildPrBody, renderPrBody } from '../prbody.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function prBodyCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   if (args.length > 0) {
     return fail(`pr-body takes no positional arguments`, EXIT.USAGE, `run: ${CLI} pr-body [--base <ref>]`);
   }
@@ -36,10 +37,9 @@ export async function prBodyCommand(args, flags) {
         verdict: report.verdict,
         unreviewed: report.unreviewed,
       },
-      { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.OK;
   }
-  emit(renderPrBody(report), { maxBytes: flags.maxBytes ?? 0 });
+  emit(renderPrBody(report));
   return EXIT.OK;
 }

package/src/commands/repoindex.mjs

@@ -7,10 +7,11 @@ import { execFile } from 'node:child_process';
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
 import { JSONL_FILE, SQLITE_FILE, reindex } from '../index/store.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function indexCommand(args, flags) {
   if (args.length > 0) return fail(`unknown index argument ${args[0]}`, EXIT.USAGE, `run: ${CLI} index`);
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   let result;
   try {
     result = await reindex(root, {
@@ -31,7 +32,7 @@ export async function indexCommand(args, flags) {
   const ignored = await isIgnored(root, file);
   const payload = { ok: true, command: 'index', root, file, ignored, ...result };
   if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    emitJson(payload);
     return EXIT.OK;
   }
   const lines = [
@@ -39,13 +40,14 @@ export async function indexCommand(args, flags) {
     `files    ${result.files}`,
     `updated  ${result.updated}`,
     `removed  ${result.removed}`,
+    `skipped  ${result.skipped ?? 0}`,
     `symbols  ${result.symbols}`,
     `edges    ${result.edges}`,
     `ms       ${result.ms}`,
   ];
   if (result.parsers === 'missing') lines.push('note     index.parsers did not load, so the built-in extractors ran');
   if (!ignored) lines.push(`note     ${file} is not gitignored, and the cache is not meant to be committed`);
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 

package/src/commands/review.mjs

@@ -23,7 +23,7 @@ export async function reviewCommand(args, flags, commands = []) {
   if (typeof result === 'number') return result;
 
   if (isJson(flags)) {
-    emitJson(result, { maxBytes: flags.maxBytes ?? 0 });
+    emitJson(result);
     return EXIT.OK;
   }
 
@@ -60,6 +60,6 @@ export async function reviewCommand(args, flags, commands = []) {
   }
   if (result.metric) lines.push(`metric    ${result.metric.note}`);
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }

package/src/commands/rules.mjs

@@ -15,12 +15,17 @@
 // reviewer needs and exactly the fact an empty output would hide.
 
 import { readdir } from 'node:fs/promises';
+import { repoContext } from '../context.mjs';
 import { join } from 'node:path';
+import { renderDecisionsIndex } from '../decisions/index-doc.mjs';
+import { commitJournal, journaledWriteFile } from '../journal.mjs';
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { loadRules, select } from '../projection/project.mjs';
 import { loadMdcRules } from '../projection/mdc.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
-import { byId, citations, loadDecisions, redactEstate } from '../decisions/index.mjs';
+import { byId, citations, loadDecisionsCached, redactEstate } from '../decisions/index.mjs';
+import { DECISIONS_DIR } from '../decisions/index.mjs';
+import { decisionsDir } from '../decisions/dir.mjs';
 import { nearMatches } from '../resolve/near.mjs';
 import { CLI } from '../name.mjs';
 
@@ -47,8 +52,8 @@ function sorted(rules) {
   return [...rules].sort((a, b) => a.id.localeCompare(b.id));
 }
 
-async function load(root) {
-  const rules = await loadRules(root ?? null);
+async function load(root, ctx = repoContext(root)) {
+  const rules = await ctx.rules();
   const broken = rules.filter((r) => r.error);
   return { rules: [...rules, ...(await loadPerSurfaceRules())], broken };
 }
@@ -151,12 +156,12 @@ export async function listCommand(args, flags) {
     if (locals.length > 0) lines.push('', `local profiles come from ${locals.map((r) => r.source).join(', ')}`);
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return broken.length === 0 ? EXIT.OK : EXIT.FAIL;
 }
 
-async function selectionFor(rules, root) {
-  const { stack, facts } = await fingerprint(root);
+async function selectionFor(rules, root, ctx = repoContext(root)) {
+  const { stack, facts } = await ctx.fingerprint();
   const { selected, notes } = select(rules, stack, facts);
   return { selected: new Set(selected.map((r) => r.id)), notes };
 }
@@ -175,21 +180,44 @@ function rulesFailure(message, remedy, exitCode) {
   throw Object.assign(new Error(message), { remedy, exitCode });
 }
 
+/**
+ * The merged decision index: the package's shipped records underlay the
+ * repository's own, which win on an id collision (review 0003 Q34).
+ *
+ * Before this, a consumer with its own ADR-001/002 read `rules why core` as
+ * settled by *their* ADR-001 while the package's ADR-003…009 — the ones the
+ * shipped rules actually cite — reported MISSING. The overlay keeps both
+ * visible: every decision carries which layer it came from, so a same-number
+ * collision reads as two records, never as one answer wearing the wrong title.
+ *
+ * @returns {{ok: boolean, decisions: object[], errors: string[], origins: Record<string,'repo'|'package'>}}
+ */
 async function loadDecisionsFor(root, all) {
-  const localDir = root ? join(root, 'docs', 'decisions') : null;
-  const hasLocal = localDir
-    ? (await readdir(localDir).catch(() => [])).some((n) => /^ADR-\d{3,}-.*\.md$/i.test(n))
-    : false;
-  return loadDecisions({
-    all,
-    ...(hasLocal ? { dir: localDir } : {}),
-  });
+  // Q55: one resolution (manifest key, then detection) and the shared cache,
+  // so `rules why` answers from the repository's own records without re-parsing
+  // every record on every call. No root means the package's own records.
+  const pkg = await loadDecisionsCached({ root, dir: DECISIONS_DIR, all });
+  if (!root) return { ...pkg, origins: Object.fromEntries(pkg.decisions.map((d) => [d.id, 'package'])) };
+  const relDir = await decisionsDir(root);
+  const absDir = join(root, relDir);
+  const hasLocal = (await readdir(absDir).catch(() => [])).some((n) => /^ADR-\d{3,}-.*\.md$/i.test(n));
+  if (!hasLocal) return { ...pkg, origins: Object.fromEntries(pkg.decisions.map((d) => [d.id, 'package'])) };
+  const local = await loadDecisionsCached({ root, dir: absDir, all });
+  const merged = new Map(pkg.decisions.map((d) => [d.id, d]));
+  const origins = Object.fromEntries(pkg.decisions.map((d) => [d.id, 'package']));
+  for (const d of local.decisions) {
+    merged.set(d.id, d);
+    origins[d.id] = 'repo';
+  }
+  return { ok: pkg.ok && local.ok, decisions: [...merged.values()], errors: [...pkg.errors, ...local.errors], origins };
 }
 
 /** The catalogue both surfaces answer from: every rule, its decisions, and the selection. */
-export async function rulesCatalogue(root, { selectFor = null } = {}) {
-  const { rules, broken } = await load(root);
-  const selection = selectFor ? await selectionFor(rules, selectFor) : null;
+export async function rulesCatalogue(root, { selectFor = null, ctx = null } = {}) {
+  const { rules, broken } = await load(root, ctx ?? repoContext(root));
+  // `selectFor` is a different repository: the caller asked for the catalogue here and
+  // the selection there, so it gets its own context rather than this repository answer.
+  const selection = selectFor ? await selectionFor(rules, selectFor, repoContext(selectFor)) : null;
   return {
     rules: sorted(rules).map((r) => ({
       id: r.id,
@@ -213,24 +241,26 @@ export async function rulesCatalogue(root, { selectFor = null } = {}) {
  * The provenance facts for one rule or one decision record, in the shape the
  * JSON documents carry. Text renders from the same facts; nothing re-derives.
  */
-export async function rulesWhyFacts(root, what, { all = false } = {}) {
-  const { rules } = await load(root);
+export async function rulesWhyFacts(root, what, { all = false, ctx = null } = {}) {
+  const { rules } = await load(root, ctx ?? repoContext(root));
   if (/^ADR-\d{3,}$/i.test(what)) {
     const id = what.toUpperCase();
-    const { ok, decisions, errors } = await loadDecisionsFor(root, all);
+    const { ok, decisions, errors, origins } = await loadDecisionsFor(root, all);
     if (!ok) {
       rulesFailure(errors[0], 'the decision records must be readable for provenance to work', EXIT.CONFIG);
     }
-    const record = decisions.find((x) => x.id === id);
+    const record = decisions.find((x) => x.id === id) ?? null;
     // Was 'list them with: ls docs/decisions/' - a path relative to simt-dev's own
     // tree, which resolves to nothing in the repo the reader is standing in. The
-    // remedy must be a command they can run.
-    if (!record) rulesFailure(`no decision record ${id}`, `list the known decisions with: ${CLI} rules list`, EXIT.USAGE);
+    // remedy must be a command they can run (Q34: the decisions list, not the
+    // rules list - the reader asked about a decision, not a rule).
+    if (!record) rulesFailure(`no decision record ${id}`, `list the known decisions with: ${CLI} rules decisions`, EXIT.USAGE);
     const replacement = record.supersededBy ? decisions.find((x) => x.id === record.supersededBy) : null;
     return {
       direction: 'decision',
       id,
-      adr: record,
+      adr: { ...record, origin: origins[id] ?? 'package' },
+      origins,
       supersededBy: replacement ? { id: replacement.id, title: replacement.title } : null,
       inForce: replacement
         ? { id: replacement.id, status: replacement.status, summary: replacement.summary }
@@ -247,7 +277,7 @@ export async function rulesWhyFacts(root, what, { all = false } = {}) {
       EXIT.USAGE,
     );
   }
-  const { ok, decisions, errors } = await loadDecisionsFor(root, all);
+  const { ok, decisions, errors, origins } = await loadDecisionsFor(root, all);
   if (!ok) {
     rulesFailure(errors[0], 'the decision records must be readable for provenance to work', EXIT.CONFIG);
   }
@@ -261,9 +291,10 @@ export async function rulesWhyFacts(root, what, { all = false } = {}) {
     title: rule.title ?? null,
     source: rule.source,
     origin: rule.origin,
-    adrs: cited.map((c) => index.get(c) ?? { id: c, missing: true }),
+    adrs: cited.map((c) => (index.has(c) ? { ...index.get(c), origin: origins[c] ?? 'package' } : { id: c, missing: true })),
     uncited: cited.length === 0,
     others: others.map((r) => r.id),
+    origins,
   };
 }
 
@@ -286,7 +317,7 @@ export async function showCommand(args, flags) {
 
   const adrs = citations(rule.body);
   if (isJson(flags)) {
-    emitJson({ ok: !rule.error, ...rule, adrs }, { maxBytes: flags.maxBytes ?? 0 });
+    emitJson({ ok: !rule.error, ...rule, adrs });
     return rule.error ? EXIT.FAIL : EXIT.OK;
   }
 
@@ -303,7 +334,6 @@ export async function showCommand(args, flags) {
       '',
       rule.body,
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   return rule.error ? EXIT.FAIL : EXIT.OK;
 }
@@ -344,17 +374,18 @@ function ruleDirection(facts, flags) {
       '  this rule cites no decision, so nothing settles it and nothing can overturn it.',
       '  Either cite the ADR that produced it, or accept that it is this repo\'s own policy.',
     );
-    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    emit(lines.join('\n'));
     return EXIT.OK;
   }
 
   lines.push('', `settled by ${facts.adrs.length} decision${facts.adrs.length === 1 ? '' : 's'}`);
   for (const d of facts.adrs) {
     if (d.missing) {
-      lines.push(`  ${d.id}  MISSING - the rule cites it, but this installation has no record of it`);
+      lines.push(`  ${d.id}  MISSING - the rule cites it, but neither this repo nor this installation has a record of it`);
+      lines.push(`          remedy: list the known decisions with: ${CLI} rules decisions`);
       continue;
     }
-    lines.push(`  ${d.id}  ${d.title}`);
+    lines.push(`  ${d.id}  [${d.origin ?? 'package'}]  ${d.title}`);
     lines.push(`          ${d.status}`);
     if (d.supersededBy) {
       // Never print a reversed ruling as if it were current.
@@ -368,7 +399,7 @@ function ruleDirection(facts, flags) {
     lines.push('', `shares a decision with ${facts.others.join(', ')}`);
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -379,6 +410,7 @@ function adrDirection(facts, flags) {
   const lines = [
     `${d.id} - ${d.title}`,
     '',
+    `origin    ${d.origin ?? 'package'}${d.origin === 'repo' ? ' (this repository overlays the shipped record of the same number)' : ''}`,
     `status    ${d.status}`,
     `restates  ${restates.length > 0 ? restates.join(', ') : '(no rule cites it)'}`,
   ];
@@ -458,8 +490,67 @@ function adrDirection(facts, flags) {
     );
   }
 
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   // A superseded record is not a failure; it is the supersession rule working.
   // The caller asked a question and got a true answer.
   return EXIT.OK;
+}
+
+// --- decisions ------------------------------------------------------------------
+
+/**
+ * `simt rules decisions`: every known decision record, both layers.
+ *
+ * The shipped records underlay the repository's own, which win on a number
+ * collision (review 0003 Q34). The column that matters is `origin`: a reader in
+ * a consumer repository must be able to tell the package's ADR-001 from their
+ * own, because they are two records that happen to share a number.
+ */
+export async function decisionsCommand(args, flags) {
+  const root = flags.root ?? null;
+  const { ok, decisions, errors, origins } = await loadDecisionsFor(root, flags.all === true);
+  if (!ok) {
+    return fail(errors[0], EXIT.CONFIG, 'the decision records must be readable to list them');
+  }
+  const rows = [...decisions]
+    .sort((a, b) => Number(a.id.replace(/^ADR-/i, '')) - Number(b.id.replace(/^ADR-/i, '')))
+    .map((d) => ({
+      id: d.id,
+      title: d.title,
+      status: d.status,
+      origin: origins[d.id] ?? 'package',
+      supersededBy: d.supersededBy ?? null,
+      file: d.file,
+    }));
+
+  // The index is output, not authorship (review 0003 Q91): the table is rendered from
+  // the same records this command lists, so a new ADR cannot leave it behind. The
+  // write is journaled like every other repo-file write, so `undo` restores the old
+  // table - the index is not internal state even though it is generated.
+  if (flags.yes === true) {
+    const rootDir = root ?? process.cwd();
+    const journal = [];
+    await journaledWriteFile(rootDir, journal, join(rootDir, 'docs', 'decisions-index.md'), renderDecisionsIndex(rows));
+    await commitJournal(rootDir, 'rules decisions', journal);
+    emit(`wrote docs/decisions-index.md (${rows.length} decisions)`);
+    return EXIT.OK;
+  }
+
+  if (isJson(flags)) {
+    emitJson({ ok: true, command: 'rules decisions', root, decisions: rows });
+    return EXIT.OK;
+  }
+
+  const repo = rows.filter((r) => r.origin === 'repo').length;
+  const lines = [
+    `${rows.length} decisions${root && repo > 0 ? ` (${repo} from this repo overlay the shipped set)` : ''}`,
+    '',
+    'id       origin   title',
+  ];
+  for (const r of rows) {
+    const head = r.status.length > 80 ? `${r.status.slice(0, 80)}...` : r.status;
+    lines.push(`${r.id.padEnd(8)}  ${r.origin.padEnd(7)}  ${r.title} — ${head}`);
+  }
+  emit(lines.join('\n'));
+  return EXIT.OK;
 }

package/src/commands/shared.mjs

@@ -189,7 +189,7 @@ export async function sharedPlanCommand(_args, flags) {
     if (over !== null) lines.push(`warn     ${over}`);
   }
   lines.push(`nothing written; re-run with: ${CLI} shared install --yes`);
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }
 
@@ -306,7 +306,6 @@ export async function sharedInstallCommand(_args, flags) {
         `manifest ${manifests.map((m) => `${m.action}:${basename(m.root)}`).join(' ')}`,
         dryRun ? 'dry-run  nothing written' : `nothing written; re-run with: ${CLI} shared install --yes`,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
@@ -354,7 +353,7 @@ export async function sharedInstallCommand(_args, flags) {
     if (over !== null) lines.push(`warn     ${over}`);
   }
   lines.push(`verify   ${CLI} doctor  reports the copy as current, and ${CLI} tokens --repos --root . reports what is left`);
-  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;