simt-dev 0.7.0 → 0.8.0

package/src/commands/compare.mjs

@@ -21,7 +21,7 @@
 
 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 { buildRows, resolveConcurrency, summarise } from '../compare/row.mjs';
@@ -78,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

@@ -10,9 +10,10 @@ 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) {
     // Q55: one resolution — the manifest key, then the detected directory —
@@ -31,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;
     }
 
@@ -42,7 +43,6 @@ export async function decideCommand(args, flags) {
           ...(f.remedy ? [`  remedy: ${f.remedy}`] : []),
         ])
         .join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.FAIL;
   }
@@ -123,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;
 }

package/src/commands/docs.mjs

@@ -0,0 +1,88 @@
+// `simt docs readme` — put the README's command list back in step with the spec.
+//
+// Shape copied from `ci` and `ignore`: the plan is printed first, nothing is written
+// without `--yes`, `--diff` shows the same plan as a unified diff, and `undo` restores
+// it. The rendering itself lives in `src/docs/commands.mjs` so a test can compare the
+// README against it without running this command.
+
+import { join } from 'node:path';
+
+import { EXIT, fail, present, writeMode } from '../output/index.mjs';
+import { CLI } from '../name.mjs';
+import { applyPlan, change } from '../write/plan.mjs';
+import { diffField, emitDiffs, readBefore } from '../diff.mjs';
+import { commandRoot } from '../repo-root.mjs';
+import { BEGIN, END, README_FILE, renderCommandBlock, replaceBlock } from '../docs/commands.mjs';
+
+export async function docsCommand(sub, args, flags) {
+  if (sub !== 'readme') {
+    return fail(`unknown docs page \`${sub}\``, EXIT.USAGE, `run: ${CLI} docs readme`);
+  }
+  const root = commandRoot(flags);
+  const path = join(root, README_FILE);
+
+  let before;
+  try {
+    before = await readBefore(path);
+  } catch (error) {
+    return fail(
+      `${README_FILE} could not be read: ${error.message}`,
+      EXIT.FAIL,
+      `fix the file's permissions, then re-run: ${CLI} docs readme`,
+    );
+  }
+  if (before === null) {
+    return fail(`no ${README_FILE} in ${root}`, EXIT.FAIL, `run this where ${README_FILE} is`);
+  }
+
+  const after = replaceBlock(before, renderCommandBlock());
+  if (after === null) {
+    return fail(
+      `${README_FILE} carries no ${BEGIN} ... ${END} region`,
+      EXIT.FAIL,
+      `put the two marker lines where the command list belongs, then: ${CLI} docs readme --yes`,
+    );
+  }
+
+  const mode = writeMode(flags);
+  const action = after === before ? 'unchanged' : 'write';
+  const payload = {
+    ok: true,
+    command: 'docs',
+    page: 'readme',
+    root,
+    file: README_FILE,
+    action,
+    written: mode.apply && action === 'write',
+  };
+
+  if (action === 'unchanged') {
+    present(payload, () => `current  ${README_FILE}`, flags);
+    return EXIT.OK;
+  }
+
+  const diff = [{ path: README_FILE, before, after }];
+  if (!mode.apply) {
+    // A rehearsal says which flag it is waiting for, because "not written" is the same
+    // sentence for `--dry-run` and for a missing `--yes`, and the two have different fixes.
+    present(
+      { ...payload, ...diffField(diff, flags) },
+      () => `plan  ${README_FILE}: the command list follows the spec${mode.dryRun ? ' (--dry-run)' : ' (re-run with --yes to write)'}`,
+      flags,
+    );
+    emitDiffs(diff, flags);
+    return EXIT.OK;
+  }
+
+  await applyPlan(root, [change({ path, before, after, owner: 'docs readme', reason: 'the command list follows the spec' })], {
+    mode,
+    label: 'docs readme',
+  });
+  present(
+    { ...payload, ...diffField(diff, flags) },
+    () => `write  ${README_FILE}  (${Buffer.byteLength(after)} bytes)`,
+    flags,
+  );
+  emitDiffs(diff, flags);
+  return EXIT.OK;
+}

package/src/commands/doctor.mjs

@@ -22,18 +22,20 @@
 // `--yes` previews: it names what it would apply and lists the rest.
 
 import { join } from 'node:path';
+import { repoContext } from '../context.mjs';
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
 import { CLI, MANIFEST_FILE } from '../name.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
 import { resolveWorkspace } from '../workspace.mjs';
 import { sharedWarning } from './shared.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
-import { manifestPath, readManifest, writeManifest } from '../projection/manifest.mjs';
+import { manifestPath, writeManifest } from '../projection/manifest.mjs';
 import { planManifestRepair } from './sync.mjs';
 import { provenanceDigest } from '../projection/project.mjs';
 import { applyHooksInstall, plannedDiffs, planHooksInstall } from './hooks.mjs';
 import { fileFor } from '../hooks/shim.mjs';
 import { commitJournal, ignoreJournal, journalHygiene, journalIgnoreNext } from '../journal.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 /**
  * One config-health finding: what is wrong, how to fix it, and whether
@@ -47,7 +49,7 @@ import { commitJournal, ignoreJournal, journalHygiene, journalIgnoreNext } from
 // finding creation, before any fix is applied, so the before side is true in
 // preview and in apply alike. Only safe findings carry pairs: an unsafe finding
 // is never applied, so there is no write to preview.
-async function collectFindings(root, { result, ws, shared, withDiffs = false }) {
+async function collectFindings(root, { result, ws, shared, withDiffs = false, ctx }) {
   const findings = [];
   if (result.error) {
     // Nothing else can be asked: classification failed, so every check built on
@@ -63,7 +65,7 @@ async function collectFindings(root, { result, ws, shared, withDiffs = false })
     return findings;
   }
 
-  const { manifest, exists, error: manifestError } = await readManifest(root);
+  const { manifest, exists, error: manifestError } = await ctx.manifest();
   if (manifestError !== null) {
     // An unreadable manifest is a hand-edit, not a repair: re-rendering it
     // would destroy whatever the other tool was saying.
@@ -232,7 +234,10 @@ function findingLines(findings, { fixMode, applying }) {
 //
 // See the module header: classification first, because everything else is a guess without it.
 export async function diagnose(root, args = {}) {
-  const result = await fingerprint(root);
+  // One context for the whole diagnosis, so a caller that already holds one (a UI, a
+  // harness, an MCP request) does not pay for a second fingerprint (review 0003 Q67).
+  const ctx = args.ctx ?? repoContext(root);
+  const result = await ctx.fingerprint();
   // Which source answered the workspace question, and where it looked. A tool
   // that silently fell back to the wrong directory would make every downstream
   // answer confidently wrong, so the answer is reported rather than inferred
@@ -246,7 +251,7 @@ export async function diagnose(root, args = {}) {
   const shared = await sharedWarning(root, result.manifest ?? null, args);
 
   const withDiffs = args.fix === true && args.diff === true;
-  const findings = await collectFindings(root, { result, ws, shared, withDiffs });
+  const findings = await collectFindings(root, { result, ws, shared, withDiffs, ctx });
   // Under `--json` the document is the whole report, so it has to carry both
   // failures the text path reports AND the workspace answer the text prints.
   const failure = result.error
@@ -276,7 +281,7 @@ export function serialisedFindings(findings) {
 }
 
 export async function runDoctor(positional, flags) {
-  const root = flags.root ?? positional[0] ?? process.cwd();
+  const root = commandRoot(flags, positional);
   const { result, ws, shared, findings, failure, code: diagnosisCode } = await diagnose(root, flags);
 
   const fixMode = flags.fix === true;
@@ -344,7 +349,6 @@ export async function runDoctor(positional, flags) {
       ...(shared.declared ? [`shared    ${shared.state}  ${shared.detail}`] : []),
       ...findingLines(findings, { fixMode, applying: mode.apply }),
     ].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   // After the report: the report says what, the diff shows it (R50). Only the
   // fix plan is diffed, so without --fix there is nothing to show.

package/src/commands/evidence.mjs

@@ -6,7 +6,7 @@
 
 import { readFile } from 'node:fs/promises';
 
-import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { EXIT, emit, emitJson, fail, isJson, present } from '../output/index.mjs';
 import { readManifest } from '../projection/manifest.mjs';
 import { CLI, MANIFEST_FILE } from '../name.mjs';
 import {
@@ -17,9 +17,10 @@ import {
   readLedger,
   treeId,
 } from '../ledger/index.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function evidenceCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   if (args[0] === 'check') return checkClaim(root, args[1], flags);
   if (args[0] !== undefined) {
     return fail(`unknown evidence subcommand ${args[0]}`, EXIT.USAGE, `run: ${CLI} evidence`);
@@ -42,7 +43,7 @@ async function showEvidence(root, flags) {
   const mine = entries.filter((e) => e.tree === tree);
   const payload = { ok: errors.length === 0, command: 'evidence', root, tree, entries: mine, errors };
   if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    emitJson(payload);
     return errors.length === 0 ? EXIT.OK : EXIT.FAIL;
   }
   const lines = [`tree     ${tree}`];
@@ -51,7 +52,7 @@ async function showEvidence(root, flags) {
     lines.push(`${e.exit === 0 ? 'pass' : 'fail'}     ${e.cmd}  exit ${e.exit}  ${e.summary}`);
   }
   for (const error of errors) lines.push(`error    ${error}`);
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return errors.length === 0 ? EXIT.OK : EXIT.FAIL;
 }
 
@@ -97,10 +98,6 @@ async function checkClaim(root, file, flags) {
   }
   const detail = 'the message claims a run this tree does not have';
   const remedy = `run the command, then commit, or take the claim out of the message`;
-  if (isJson(flags)) {
-    emitJson({ ...payload, detail, remedy }, { pretty: flags.pretty === true });
-    return mode === 'block' ? EXIT.FAIL : EXIT.OK;
-  }
-  emit(`${mode === 'block' ? 'BLOCKED' : 'WARNING'}  ${detail}\n         remedy: ${remedy}`, { maxBytes: flags.maxBytes ?? 0 });
+  present({ ...payload, detail, remedy }, () => `${mode === 'block' ? 'BLOCKED' : 'WARNING'}  ${detail}\n         remedy: ${remedy}`, flags);
   return mode === 'block' ? EXIT.FAIL : EXIT.OK;
 }

package/src/commands/explain.mjs

@@ -46,7 +46,6 @@ export async function explainCommand(positional, flags) {
   }
   emit(
     [`code     ${code}`, '', row.what, '', `Why: ${row.why}`, '', `Fix: ${row.fix}`, '', `Example: ${row.example}`].join('\n'),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   return EXIT.OK;
 }

package/src/commands/gate.mjs

@@ -7,22 +7,29 @@
 
 import { execFile } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 
-import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { EXIT, emit, emitJson, fail, isJson, present } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
-import { detectTestRunner } from '../bench/mine.mjs';
+import { detectTestRunner } from '../testing/runners.mjs';
 import { compactOutput } from '../index/compact.mjs';
-import { readImportEdges, selectTests } from '../index/gate.mjs';
+import { coverage } from '../index/coverage.mjs';
+import { readImportEdges } from '../index/gate.mjs';
 import { langOf, packageOf } from '../index/store.mjs';
 import { localRel } from '../state.mjs';
+import { commandRoot } from '../repo-root.mjs';
+import { gitPaths } from '../sys/git.mjs';
+import { cmp } from '../util/sort.mjs';
 
 const exec = promisify(execFile);
 
+/** How many raw gate logs the state directory keeps. */
+const RAW_LOG_KEEP = 5;
+
 export async function gateCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   const listed = await tracked(root);
   if (listed.error) return listed.error;
   let changed = args.filter(Boolean);
@@ -38,10 +45,9 @@ export async function gateCommand(args, flags) {
       if (isJson(flags)) {
         emitJson(
           { ok: true, command: 'gate', root, selected: [], unmatched: [], graph: 'resolved', verdict: 'nothing-selected', code: 0 },
-          { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 },
         );
       } else {
-        emit('selected  0\nverdict  nothing-selected', { maxBytes: flags.maxBytes ?? 0 });
+        emit('selected  0\nverdict  nothing-selected');
       }
       return EXIT.OK;
     }
@@ -62,7 +68,7 @@ export async function gateCommand(args, flags) {
   const files = new Set(listed.files);
   for (const file of changed) files.add(file);
   const edges = await readImportEdges(root, files);
-  const selected = selectTests(changed, edges);
+  const selected = coverage({ imports: edges }, changed);
   // Q40: the selection explains itself. `unmatched` names explicit paths the
   // tracked tree does not carry (untracked but present, so the run proceeds);
   // `graph` is `unresolved` when a language has edges but none of them reaches
@@ -74,13 +80,13 @@ export async function gateCommand(args, flags) {
   if (selected.length === 0) {
     const payload = { ok: true, command: 'gate', root, selected, unmatched, graph, verdict: 'nothing-selected', code: 0 };
     if (isJson(flags)) {
-      emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+      emitJson(payload);
       return EXIT.OK;
     }
     const lines = ['selected  0', 'verdict  nothing-selected'];
     if (unmatched.length > 0) lines.push(`unmatched  ${unmatched.join(', ')}`);
     if (graph === 'unresolved') lines.push('graph  unresolved');
-    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    emit(lines.join('\n'));
     return EXIT.OK;
   }
   return runSelected(root, flags, selected, { unmatched, graph });
@@ -170,11 +176,7 @@ async function runSelected(root, flags, selected, { unmatched = [], graph = 'res
     raw,
     runs,
   };
-  if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
-    return code === 0 ? EXIT.OK : EXIT.FAIL;
-  }
-  emit(text.filter((line) => line !== undefined).join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  present(payload, () => text.filter((line) => line !== undefined).join('\n'), flags);
   return code === 0 ? EXIT.OK : EXIT.FAIL;
 }
 
@@ -185,6 +187,11 @@ async function writeRaw(root, body) {
     const dir = join(root, dirname(rel));
     await mkdir(dir, { recursive: true });
     await writeFile(join(root, rel), body);
+    // Keep the newest few: raw gate output is machine-local state (Q19), and a file per
+    // run with no bound is a directory that grows on every command (Q83).
+    const kept = await readdir(dir).catch(() => []);
+    const logs = kept.filter((name) => /^gate-\d+\.log$/.test(name)).sort().reverse();
+    for (const name of logs.slice(RAW_LOG_KEEP)) await unlink(join(dir, name)).catch(() => {});
     return rel;
   } catch {
     return '';
@@ -195,8 +202,7 @@ async function tracked(root) {
   try {
     // `-z`: without it git C-quotes a non-ASCII path (`src/\303\274n...`) and
     // the reader's real filename never matches it (review 0003 Q39).
-    const { stdout } = await exec('git', ['ls-files', '-z'], { cwd: root, maxBuffer: 16 << 20 });
-    return { files: stdout.split('\0').filter(Boolean) };
+    return { files: await gitPaths(root, ['ls-files']) };
   } catch (error) {
     return {
       error: fail(
@@ -210,9 +216,9 @@ async function tracked(root) {
 
 async function changedFiles(root) {
   try {
-    const { stdout } = await exec('git', ['diff', '--name-only', '-z', 'HEAD'], { cwd: root, maxBuffer: 8 << 20 });
-    const untracked = await exec('git', ['ls-files', '--others', '--exclude-standard', '-z'], { cwd: root, maxBuffer: 8 << 20 });
-    return { files: [...new Set([...stdout.split('\0'), ...untracked.stdout.split('\0')].filter(Boolean))].sort() };
+    const files = await gitPaths(root, ['diff', '--name-only', 'HEAD'], { maxBuffer: 8 << 20 });
+    const untracked = await gitPaths(root, ['ls-files', '--others', '--exclude-standard'], { maxBuffer: 8 << 20 });
+    return { files: [...new Set([...files, ...untracked])].sort() };
   } catch (error) {
     return {
       error: fail(
@@ -224,8 +230,3 @@ async function changedFiles(root) {
   }
 }
 
-function cmp(a, b) {
-  if (a < b) return -1;
-  if (a > b) return 1;
-  return 0;
-}

package/src/commands/graph.mjs

@@ -71,7 +71,6 @@ export async function lintCommand(positional, flags) {
         errors,
         warnings,
       },
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return finalOk ? EXIT.OK : EXIT.REGISTRY;
   }
@@ -109,11 +108,11 @@ export async function lintCommand(positional, flags) {
   if (errors.length > 0) {
     lines.push('', `FAIL ${errors.length}`);
     for (const error of errors) lines.push(`  ${error}`);
-    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    emit(lines.join('\n'));
     return EXIT.REGISTRY;
   }
 
   lines.push('', verified ? 'OK no findings' : 'OK structural checks only');
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return EXIT.OK;
 }

package/src/commands/harness.mjs

@@ -27,6 +27,7 @@ import { EXIT, emit, emitJson, fail, isJson, note } from '../output/index.mjs';
 import { SURFACES, CANDIDATE_DIRS } from '../projection/surfaces.mjs';
 import { LOADERS, LOADER_IDS, caps, loader } from '../projection/loaders.mjs';
 import { viewAll } from '../measure/loaderView.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 /**
  * `simt harness detect`. The subcommand is validated by dispatch, which rejects a
@@ -39,7 +40,7 @@ import { viewAll } from '../measure/loaderView.mjs';
  * @returns {Promise<number>} process exit code
  */
 export async function harnessCommand(positional, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
 
   // MCP evidence is project-scope by construction: the loader table carries repo-root
   // paths (.mcp.json, .codex/config.toml, …), and the same path means different scopes
@@ -99,13 +100,13 @@ async function scan(root, { mcp = false } = {}) {
   const rows = [];
   for (const s of SURFACES) {
     for (const dir of s.configDirs ?? []) {
-      if (await present(root, dir)) {
+      if (await isDirectory(root, dir)) {
         rows.push(row(dir, s.label, { id: s.id, verified: s.verified ?? null, readsAgentsMd: s.readsAgentsMd, rule: s.rule }));
       }
     }
   }
   for (const c of CANDIDATE_DIRS) {
-    if (await present(root, c.dir)) {
+    if (await isDirectory(root, c.dir)) {
       rows.push(row(c.dir, c.harness, { readsAgentsMd: c.readsAgentsMd ?? null, readsAgentsMdNote: c.readsAgentsMdNote ?? null, verified: c.verified ?? null }));
     }
   }
@@ -114,7 +115,7 @@ async function scan(root, { mcp = false } = {}) {
   return { root, rows };
 }
 
-async function present(root, dir) {
+async function isDirectory(root, dir) {
   try {
     return (await stat(join(root, dir))).isDirectory();
   } catch {
@@ -256,7 +257,7 @@ function block(scan, pad) {
  * do" in a repository where the answer is not about bytes.
  */
 export async function harnessLoadersCommand(positional, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   const wanted = typeof flags.reader === 'string' ? flags.reader : null;
   const rows = wanted === null ? LOADERS : [loader(wanted)].filter(Boolean);