simt-dev 0.6.3 → 0.7.1

package/src/commands/hooks.mjs

@@ -12,31 +12,32 @@
 // DEFAULT location, which core.hooksPath being unset does not reveal, so a
 // foreign hook is found by asking git rather than by reading config.
 
-import { execFile } from 'node:child_process';
-import { chmod, mkdir, readFile, realpath } from 'node:fs/promises';
-import { commitJournal, journaledRemoveFile, journaledWriteFile } from '../journal.mjs';
+import { mkdir, readFile, readdir, realpath, rm, stat } from 'node:fs/promises';
+import { repoContext } from '../context.mjs';
+import { commitJournal, journaledGitConfig, journaledRemoveFile, journaledWriteFile } from '../journal.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
 import { invalidateCheckCache } from '../status.mjs';
 import { isAbsolute, join, relative } from 'node:path';
-import { promisify } from 'node:util';
 
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
 import { MANIFEST, readManifest } from '../projection/manifest.mjs';
-import { EVENTS, HOOKS_DIR, HOOKS_PATH_KEY, SHIM_MARKER, fileFor, renderChainedShim, renderEvidenceShim, renderShim } from '../hooks/shim.mjs';
+import { CHAIN_MARKER, EVENTS, HOOKS_DIR, HOOKS_DIR_LEGACY, HOOKS_PATH_KEY, SHIM_MARKER, fileFor, renderChainedShim, renderEvidenceShim, renderShim } from '../hooks/shim.mjs';
 import { GATE_KEY, gateCount, readHooksPath, readHooksState, wantsShim } from '../compare/hooksstate.mjs';
 import { GATES } from '../hooks/gates.mjs';
-import { knownGates } from '../hooks/resolve.mjs';
+import { gateNames } from '../hooks/gates.mjs';
 import { renderGateReport, runGates } from '../hooks/dispatcher.mjs';
 import { CLI } from '../name.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
 import { packageVersion, hasNpm } from '../package-version.mjs';
-
-const exec = promisify(execFile);
+import { commandRoot } from '../repo-root.mjs';
 
 export async function hooksCommand(sub, args, flags) {
-  const root = flags.root ?? args[0] ?? process.cwd();
-  if (sub === 'install') return installHooks(root, flags);
-  if (sub === 'status') return hooksStatus(root, flags);
+  const root = commandRoot(flags, args);
+  // One context for the subcommand: install and status each ask about the same
+  // repository, and `doctor --fix` asks alongside them (review 0003 Q67).
+  const ctx = repoContext(root);
+  if (sub === 'install') return installHooks(root, flags, ctx);
+  if (sub === 'status') return hooksStatus(root, flags, ctx);
   if (sub === 'run') return runHook(args, flags);
   return fail(`unknown hooks subcommand ${sub}`, EXIT.USAGE, `run: ${CLI} hooks status`);
 }
@@ -44,17 +45,23 @@ export async function hooksCommand(sub, args, flags) {
 /** The shim execs this; the event name is baked into the shim, so it is arg 0. */
 async function runHook(args, flags) {
   const event = args[0];
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
+  const ctx = repoContext(root);
   if (!EVENTS.includes(event)) {
     return fail(`unknown hook event ${event}`, EXIT.USAGE, `known events: ${EVENTS.join(', ')}`);
   }
-  const { manifest, exists, error } = await readManifest(root);
+  const { manifest, exists, error } = await ctx.manifest();
   if (error) return fail(`${MANIFEST_FILE}: ${error}`, EXIT.CONFIG);
   if (!exists) {
     return fail(`${root} has no ${MANIFEST_FILE}; the hook cannot know its gate list`, EXIT.CONFIG, `run: ${CLI} init --root ${root}`);
   }
 
-  const result = await runGates(event, { root, manifest });
+  // git feeds pre-push its ref list on stdin, and the docs-only skip (ADR-113)
+  // needs it. A manual run from a terminal has a TTY and reads empty, which the
+  // dispatcher treats as "no push to classify" and answers with the full suite.
+  const pushed = event === 'pre-push' ? await readStdin() : undefined;
+
+  const result = await runGates(event, { root, manifest, pushed });
   if (result.error) return fail(result.error, EXIT.USAGE);
 
   if (isJson(flags)) {
@@ -63,10 +70,33 @@ async function runHook(args, flags) {
   }
 
   for (const n of result.notes ?? []) note(`note     ${n}`);
-  emit(renderGateReport(event, manifest.gates[GATE_KEY[event]] ?? [], result).join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(renderGateReport(event, manifest.gates[GATE_KEY[event]] ?? [], result).join('\n'));
   return result.failed ? EXIT.FAIL : EXIT.OK;
 }
 
+/**
+ * Read all of stdin, or '' when there is none to read.
+ *
+ * The pre-push shim execs this command, so git's ref list arrives on the
+ * dispatcher's stdin. A TTY (a manual run from a terminal) has no ref list and
+ * reads empty - and empty is the fail-closed answer: the dispatcher cannot
+ * classify a push it was never told about, so the suite runs.
+ *
+ * @returns {Promise<string>}
+ */
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve('');
+      return;
+    }
+    const chunks = [];
+    process.stdin.on('data', (chunk) => chunks.push(chunk));
+    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    process.stdin.resume();
+  });
+}
+
 /**
  * The path to write into a chained shim: relative to the repository's top level
  * wherever the hook lives inside it.
@@ -111,7 +141,7 @@ async function relativeTarget(root, target) {
  *   caller enforces in its own voice (`takeover`, and the `wanted`/`obsolete`
  *   emptiness the command refuses on)
  */
-export async function planHooksInstall(root, { manifest, exists }) {
+export async function planHooksInstall(root, { manifest, exists }, ctx = null) {
   const declaresGate = (event) => wantsShim(manifest, exists, event);
   const state = await readHooksState(root, { declaresGate });
   const current = state.current;
@@ -123,6 +153,24 @@ export async function planHooksInstall(root, { manifest, exists }) {
   // install where there is no node_modules to pin in.
   const version = packageVersion();
   const npm = await hasNpm(root);
+  // Q31: installed shims name the repo's own installer in their remedy.
+  // Lockfile first, `packageManager` next, npm default — the one resolver.
+  let manager = null;
+  if (npm) {
+    const { resolveNodeRunner } = await import('../ecosystem/node-runner.mjs');
+    let packageManager = null;
+    try {
+      const pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+      if (typeof pkg.packageManager === 'string') packageManager = pkg.packageManager;
+    } catch {
+      // Unreadable here leaves the npm default; the manifest path reports it.
+    }
+    // The dynamic import stays: a hook run must not pull the fingerprint module in
+    // just by loading this one. A caller that already holds a context passes it and
+    // the walk is shared (review 0003 Q67).
+    const detected = ctx ? await ctx.fingerprint() : await (await import('../resolve/fingerprint.mjs')).fingerprint(root);
+    manager = resolveNodeRunner({ facts: detected.facts, packageManager }).id;
+  }
 
   // Only install a shim for an event that declares at least one gate. A shim with
   // an empty gate list enforces nothing, yet merely existing it REPLACES whatever
@@ -150,8 +198,8 @@ export async function planHooksInstall(root, { manifest, exists }) {
   //
   // `foreignHooks` lists every executable file in the directory git reads hooks from -
   // and when that directory is this tool's own, a file a person dropped in there is
-  // listed too. Chaining it means writing a shim at `.simt-hooks/<name>` whose TARGET is
-  // `.simt-hooks/<name>`: the same path. The shim overwrites the hook it was written to
+  // listed too. Chaining it means writing a shim at `.simt/hooks/<name>` whose TARGET is
+  // `.simt/hooks/<name>`: the same path. The shim overwrites the hook it was written to
   // preserve and then runs itself, so the hook stops working and git recurses in a loop
   // nothing reports. Confirmed at the previous release, which printed
   // `UPDATED .simt-hooks/mine (chained: runs .simt-hooks/mine)`.
@@ -224,7 +272,7 @@ export async function planHooksInstall(root, { manifest, exists }) {
   const evidenceDeclared = manifest?.gates?.evidence === 'warn' || manifest?.gates?.evidence === 'block';
   const evidenceFile = fileFor('commit-msg');
   const evidenceExisting = await readIfExists(join(root, evidenceFile));
-  const evidenceSource = evidenceDeclared ? renderEvidenceShim({ npm, version }) : null;
+  const evidenceSource = evidenceDeclared ? renderEvidenceShim({ npm, manager, version }) : null;
   const evidenceOurs = evidenceExisting !== null && evidenceExisting.includes(SHIM_MARKER);
   if (!evidenceDeclared && evidenceOurs) obsolete.push({ event: 'commit-msg' });
   // A foreign commit-msg would otherwise be chained onto the same path. The chain
@@ -243,6 +291,7 @@ export async function planHooksInstall(root, { manifest, exists }) {
     current,
     wants,
     npm,
+    manager,
     version,
     wanted,
     chained,
@@ -257,9 +306,50 @@ export async function planHooksInstall(root, { manifest, exists }) {
     evidenceExisting,
     routed,
     takeover,
+    // The legacy directory's removal rides on the same planned write, so the
+    // scan is here and the deletion is in `applyHooksInstall` (ADR-122).
+    legacy: await legacyHooksScan(root),
   };
 }
 
+/**
+ * Scan the legacy top-level shim directory (ADR-122). A repository installed
+ * before the move into the state directory still carries it, and it is
+ * removable only when every entry in it is a regular file that carries a
+ * simt-dev marker: the install re-routes git to the new directory, and a
+ * file this tool cannot recognise as its own is never deleted on its way.
+ *
+ * @returns {Promise<{path: string, removable: boolean}|null>} null when the
+ *   directory is absent or empty; otherwise the directory and whether the
+ *   install may take it down. `applyHooksInstall` acts on this, so the
+ *   judgment is made once, in the plan. Module-local: one caller needs no
+ *   export, and an export is a promise to a caller (deadcode).
+ */
+async function legacyHooksScan(root) {
+  const dir = join(root, HOOKS_DIR_LEGACY);
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return null;
+  }
+  if (entries.length === 0) return null;
+  let removable = true;
+  for (const name of entries) {
+    const st = await stat(join(dir, name));
+    if (!st.isFile()) {
+      removable = false;
+      break;
+    }
+    const text = await readFile(join(dir, name), 'utf8');
+    if (!text.includes(SHIM_MARKER) && !text.includes(CHAIN_MARKER)) {
+      removable = false;
+      break;
+    }
+  }
+  return { path: HOOKS_DIR_LEGACY, removable };
+}
+
 /**
  * Write a planned install: shims, chains, removals, and the git routing (plan 0003 R47).
  *
@@ -268,26 +358,30 @@ export async function planHooksInstall(root, { manifest, exists }) {
  * names the run that actually changed something. Reporting stays with the
  * caller for the same reason it does in `planHooksInstall`.
  *
- * @returns {{wrote: string[]}} the shim paths written, removed, or refreshed
+ * @returns {{wrote: string[], removed: string[]}} the shim paths written,
+ *   removed or refreshed, and the legacy-directory files taken down
  */
 export async function applyHooksInstall(root, planned, journal) {
-  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, version, routed, wants, current } =
+  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version, routed, wants, current, legacy } =
     planned;
-  // Shim and evidence bytes are journaled so `undo` restores them (R49). The
-  // `core.hooksPath` config below is deliberately not journaled: it is git
-  // config, not a repo file, and `undo` restores files.
+  // Shim and evidence bytes are journaled so `undo` restores them (R49), with
+  // the executable bit they are written with: a shim the run chmodded is one
+  // change, and `undo` must restore the mode it found, not just the bytes.
+  // The `core.hooksPath` routing below is journaled as a `git-config` entry
+  // for the same reason — unwinding the shims while the config still points
+  // at their directory silently stops the repository's own hooks (review 0003
+  // Q22).
   const wrote = [];
+  const removed = [];
   await mkdir(join(root, HOOKS_DIR), { recursive: true });
   for (const event of wanted) {
     const path = join(root, fileFor(event));
-    await journaledWriteFile(root, journal, path, renderShim(event, { npm, version }));
-    await chmod(path, 0o755);
+    await journaledWriteFile(root, journal, path, renderShim(event, { npm, manager, version }), { mode: 0o755 });
     wrote.push(fileFor(event));
   }
   for (const c of chained) {
     const path = join(root, fileFor(c.event));
-    await journaledWriteFile(root, journal, path, renderChainedShim(c.event, c.target));
-    await chmod(path, 0o755);
+    await journaledWriteFile(root, journal, path, renderChainedShim(c.event, c.target), { mode: 0o755 });
     wrote.push(fileFor(c.event));
   }
   for (const h of obsolete) {
@@ -297,8 +391,7 @@ export async function applyHooksInstall(root, planned, journal) {
   // After the chain loop, so a chained commit-msg cannot replace the claim check.
   if (evidenceSource) {
     const path = join(root, evidenceFile);
-    await journaledWriteFile(root, journal, path, evidenceSource);
-    await chmod(path, 0o755);
+    await journaledWriteFile(root, journal, path, evidenceSource, { mode: 0o755 });
     wrote.push(evidenceFile);
   }
   // `core.hooksPath` tells git to read ONE directory for EVERY event, so leaving it
@@ -306,11 +399,23 @@ export async function applyHooksInstall(root, planned, journal) {
   // `.git/hooks` that predate this tool - from running, silently. Unsetting it is the
   // only way back, and this is the only place that knows the last shim just left.
   if (routed) {
-    await exec('git', ['config', HOOKS_PATH_KEY, wants], { cwd: root });
+    await journaledGitConfig(root, journal, HOOKS_PATH_KEY, wants);
   } else if (current === wants) {
-    await exec('git', ['config', '--unset', HOOKS_PATH_KEY], { cwd: root });
+    await journaledGitConfig(root, journal, HOOKS_PATH_KEY, null);
+  }
+  // The move into the state directory (ADR-122): the routing now points
+  // elsewhere, so a legacy directory left behind is the only place that looks
+  // like a hooks directory while holding nothing git reads. The scan in the
+  // plan already judged it removable — every file a simt-dev marker — so
+  // deletion is journaled per file, and `undo` restores the directory.
+  if (legacy?.removable) {
+    for (const name of await readdir(join(root, HOOKS_DIR_LEGACY))) {
+      await journaledRemoveFile(root, journal, join(root, HOOKS_DIR_LEGACY, name));
+      removed.push(`${HOOKS_DIR_LEGACY}/${name}`);
+    }
+    await rm(join(root, HOOKS_DIR_LEGACY), { recursive: true });
   }
-  return { wrote };
+  return { wrote, removed };
 }
 
 /**
@@ -320,11 +425,11 @@ export async function applyHooksInstall(root, planned, journal) {
  * `doctor --fix` reuses it rather than deriving a second answer.
  */
 export async function plannedDiffs(root, planned) {
-  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, version } = planned;
+  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version } = planned;
   const pairs = [];
   for (const event of wanted) {
     const path = fileFor(event);
-    pairs.push({ path, before: await readBefore(join(root, path)), after: renderShim(event, { npm, version }) });
+    pairs.push({ path, before: await readBefore(join(root, path)), after: renderShim(event, { npm, manager, version }) });
   }
   for (const c of chained) {
     const path = fileFor(c.event);
@@ -340,8 +445,8 @@ export async function plannedDiffs(root, planned) {
   return pairs;
 }
 
-async function installHooks(root, flags) {
-  const { manifest, exists, error } = await readManifest(root);
+async function installHooks(root, flags, ctx = repoContext(root)) {
+  const { manifest, exists, error } = await ctx.manifest();
   if (error) return fail(`${MANIFEST_FILE}: ${error}`, EXIT.CONFIG);
   if (!exists) {
     return fail(`${root} has no ${MANIFEST_FILE}; gates must be declared before hooks can run them`, EXIT.CONFIG, `run: ${CLI} init --root ${root}`);
@@ -355,6 +460,7 @@ async function installHooks(root, flags) {
     current,
     wants,
     npm,
+    manager,
     version,
     wanted,
     chained,
@@ -366,7 +472,8 @@ async function installHooks(root, flags) {
     evidenceExisting,
     routed,
     takeover,
-  } = await planHooksInstall(root, { manifest, exists });
+    legacy,
+  } = await planHooksInstall(root, { manifest, exists }, ctx);
 
   // Read through `writeMode` like every other writer, and only now: this command
   // used to consult `flags.yes` and `flags.dryRun` directly and write when neither
@@ -395,7 +502,6 @@ async function installHooks(root, flags) {
         '         and replace it with a gate that checks nothing.',
         `REMEDY  add the gates this repo can actually run to ${MANIFEST_FILE}, then re-run.`,
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.FAIL;
   }
@@ -403,7 +509,7 @@ async function installHooks(root, flags) {
   const plan = [];
   for (const event of wanted) {
     const path = join(root, fileFor(event));
-    const source = renderShim(event, { npm, version });
+    const source = renderShim(event, { npm, manager, version });
     const existing = await readIfExists(path);
     if (existing === source) {
       plan.push({ file: fileFor(event), action: 'unchanged' });
@@ -444,11 +550,21 @@ async function installHooks(root, flags) {
       note: 'commit-msg checks a verification claim against the ledger',
     });
   }
+  if (legacy?.removable) {
+    plan.push({
+      file: HOOKS_DIR_LEGACY,
+      action: 'removed',
+      // Named in the plan for the same reason the obsolete shims are: the
+      // reader approving this write is about to lose a directory, and the
+      // routing line above does not say the old one goes too (ADR-122).
+      note: `legacy shim directory; the shims now live in ${HOOKS_DIR}`,
+    });
+  }
 
   // The routing this install leaves behind, which is not always `wants`. A repository
   // that removed its last gate has no shims to route to, and leaving `core.hooksPath`
   // pointed at the directory would stop its own hooks running - the plan has to say so,
-  // because a plan that prints "core.hooksPath updated .simt-hooks -> .simt-hooks" while
+  // because a plan that prints "core.hooksPath updated .simt/hooks -> .simt/hooks" while
   // the command unsets it is worse than no plan.
   const leaves = routed ? wants : null;
   const pathAction =
@@ -478,7 +594,6 @@ async function installHooks(root, flags) {
         '         Taking over replaces that routing. Inspect the existing hooks first,',
         '         then re-run with --yes to accept, or set core.hooksPath yourself.',
       ].join('\n'),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     return EXIT.FAIL;
   }
@@ -487,7 +602,7 @@ async function installHooks(root, flags) {
   // true in preview and in apply alike (R50).
   const diffs =
     flags.diff === true
-      ? await plannedDiffs(root, { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, version })
+      ? await plannedDiffs(root, { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version })
       : [];
 
   if (!mode.apply) {
@@ -523,7 +638,6 @@ async function installHooks(root, flags) {
           : `PLAN     nothing written; apply with: ${CLI} hooks install --root ${root} --yes`,
         manifest,
       ),
-      { maxBytes: flags.maxBytes ?? 0 },
     );
     // After the report: the report says what, the diff shows it (R50).
     emitDiffs(diffs, flags);
@@ -535,7 +649,7 @@ async function installHooks(root, flags) {
   const journal = [];
   await applyHooksInstall(
     root,
-    { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, version, routed, wants, current },
+    { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version, routed, wants, current, legacy },
     journal,
   );
   await commitJournal(root, 'hooks install', journal);
@@ -612,7 +726,6 @@ async function installHooks(root, flags) {
       routed ? 'WROTE    shims and set core.hooksPath' : 'WROTE    no shims remain; core.hooksPath unset',
       manifest,
     ),
-    { maxBytes: flags.maxBytes ?? 0 },
   );
   // After the report: the report says what, the diff shows it (R50).
   emitDiffs(diffs, flags);
@@ -641,8 +754,8 @@ function describeGates(manifest, key) {
   }).join(', ');
 }
 
-async function hooksStatus(root, flags) {
-  const { manifest, exists, error } = await readManifest(root);
+async function hooksStatus(root, flags, ctx = repoContext(root)) {
+  const { manifest, exists, error } = await ctx.manifest();
   if (error) return fail(`${MANIFEST_FILE}: ${error}`, EXIT.CONFIG);
 
   const state = await readHooksState(root, { declaresGate: (e) => wantsShim(manifest, exists, e) });
@@ -727,14 +840,14 @@ async function hooksStatus(root, flags) {
     const unknown = [...(manifest?.gates?.preCommit ?? []), ...(manifest?.gates?.prePush ?? [])].filter((n) => !GATES[n]);
     if (unknown.length > 0) {
       lines.push('', `unknown gates (the hook will fail): ${unknown.join(', ')}`);
-      lines.push(`known gates: ${knownGates().join(', ')}`);
+      lines.push(`known gates: ${gateNames().join(', ')}`);
     }
   }
   if (problems.length > 0) {
     lines.push('', 'problems:');
     for (const p of problems) lines.push(`  ${p}`);
   }
-  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  emit(lines.join('\n'));
   return code;
 }
 

package/src/commands/ignore.mjs

@@ -14,9 +14,10 @@ import { CLI } from '../name.mjs';
 import { commitJournal, journaledWriteFile } from '../journal.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
 import { CLAUDE_SETTINGS, IGNORE_FILE, parseIgnoreList, planIgnore } from '../ignore.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 export async function ignoreCommand(args, flags) {
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
 
   let source;
   try {

package/src/commands/impact.mjs

@@ -9,7 +9,7 @@ import { readFile } from 'node:fs/promises';
 import { basename, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 
-import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
+import { EXIT, fail, present } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
 import { discover } from '../compare/discover.mjs';
 import { extract } from '../index/extract.mjs';
@@ -25,6 +25,7 @@ import {
 import { decisionHits, scopeHits, sortHits, sourceRoots } from '../index/govern.mjs';
 import { decisionRecords, ruleScopes } from './why.mjs';
 import { resolveWorkspace } from '../workspace.mjs';
+import { commandRoot } from '../repo-root.mjs';
 
 const exec = promisify(execFile);
 const TEXT_EXT = new Set(['js', 'mjs', 'cjs', 'jsx', 'ts', 'tsx', 'json', 'yaml', 'yml', 'md', 'toml', 'xml', 'py', 'go', 'kt', 'java', 'rs']);
@@ -35,7 +36,7 @@ export async function impactCommand(args, flags, commands = []) {
   if (args.length > 1) return fail(`unknown impact argument ${args[1]}`, EXIT.USAGE, `run: ${CLI} impact <file|symbol>`);
   const target = args[0];
   if (!target) return fail(`a file or a symbol is required`, EXIT.USAGE, `run: ${CLI} impact <file|symbol>`);
-  const root = flags.root ?? process.cwd();
+  const root = commandRoot(flags);
   const listed = await tracked(root);
   if (listed.error) return listed.error;
   const files = new Set(listed.files);
@@ -63,11 +64,7 @@ export async function impactCommand(args, flags, commands = []) {
     consumers: consumers.references,
     truncated,
   };
-  if (isJson(flags)) {
-    emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
-    return EXIT.OK;
-  }
-  emit(render(payload), { maxBytes: flags.maxBytes ?? 0 });
+  present(payload, () => render(payload), flags);
   return EXIT.OK;
 }
 
@@ -191,8 +188,10 @@ function textExt(file) {
 
 async function tracked(root) {
   try {
-    const { stdout } = await exec('git', ['ls-files'], { cwd: root, maxBuffer: 16 << 20 });
-    return { files: stdout.split('\n').filter(Boolean) };
+    // `-z`: without it git C-quotes a non-ASCII path 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) };
   } catch (error) {
     return {
       error: fail(