simt-dev 0.6.3 → 0.7.1

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,13 +6,21 @@
 
 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 { claimsVerification, evidenceMode, readLedger, treeId } from '../ledger/index.mjs';
+import {
+  claimsVerification,
+  evidenceMode,
+  hasTestEvidence,
+  indexTreeId,
+  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`);
@@ -35,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}`];
@@ -44,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;
 }
 
@@ -72,14 +80,17 @@ async function checkClaim(root, file, flags) {
     if (isJson(flags)) emitJson(payload, { pretty: flags.pretty === true });
     return EXIT.OK;
   }
+  // A commit records the index, not the worktree: `git add -p` can commit bytes
+  // the worktree tree never had (review 0003 Q18). Match on the staged tree, with
+  // the worktree tree as the fallback when git cannot name the index.
   let tree;
   try {
-    tree = await treeId(root);
+    tree = (await indexTreeId(root)) ?? (await treeId(root));
   } catch (error) {
     return fail(`could not name this tree (${error.message})`, EXIT.UNSUPPORTED, 'run this inside a git repository');
   }
   const { entries } = await readLedger(root);
-  const supported = entries.some((e) => e.tree === tree && e.exit === 0);
+  const supported = hasTestEvidence(entries, tree);
   const payload = { ok: supported || mode === 'warn', command: 'evidence check', claim: true, supported, mode, tree };
   if (supported) {
     if (isJson(flags)) emitJson(payload, { pretty: flags.pretty === true });
@@ -87,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

@@ -6,21 +6,27 @@
 // this tool knows how to read is compacted; the raw log is kept.
 
 import { execFile } from 'node:child_process';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+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 { compactOutput } from '../index/compact.mjs';
 import { readImportEdges, selectTests } from '../index/gate.mjs';
-import { packageOf } from '../index/store.mjs';
+import { langOf, packageOf } from '../index/store.mjs';
+import { localRel } from '../state.mjs';
+import { commandRoot } from '../repo-root.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);
@@ -31,31 +37,80 @@ export async function gateCommand(args, flags) {
   }
   if (changed.length === 0) {
     if (flags.changed === true) {
+      // No change: nothing is unmatched and no language is implicated, so the
+      // graph is vacuously resolved and the verdict is still said out loud.
       if (isJson(flags)) {
-        emitJson({ ok: true, command: 'gate', root, selected: [], code: 0 }, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+        emitJson(
+          { ok: true, command: 'gate', root, selected: [], unmatched: [], graph: 'resolved', verdict: 'nothing-selected', code: 0 },
+        );
       } else {
-        emit('selected  0', { maxBytes: flags.maxBytes ?? 0 });
+        emit('selected  0\nverdict  nothing-selected');
       }
       return EXIT.OK;
     }
     return fail(`nothing changed`, EXIT.USAGE, `pass a path, or ${CLI} gate --changed`);
   }
+  // Q40: an explicit path that is neither tracked nor on disk names nothing the
+  // gate could select from. That is a usage error, not an empty selection: the
+  // old answer (`ok: true`, no tests, exit 0) was indistinguishable from "this
+  // change is safe" and trained the reader to trust it.
+  const unknown = changed.filter((p) => !listed.files.includes(p) && !existsSync(join(root, p)));
+  if (unknown.length > 0) {
+    return fail(
+      `no such file: ${unknown.join(', ')}`,
+      EXIT.USAGE,
+      `pass a path git tracks, or ${CLI} gate --changed`,
+    );
+  }
   const files = new Set(listed.files);
   for (const file of changed) files.add(file);
-  const selected = selectTests(changed, await readImportEdges(root, files));
+  const edges = await readImportEdges(root, files);
+  const selected = selectTests(changed, edges);
+  // 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
+  // a tracked file (the Kotlin estate: thousands of specs, zero resolutions);
+  // `verdict` says the empty set out loud instead of leaving `selected: []` to
+  // be read as either safe or blind. `ok` stays as is until W27's opt-in.
+  const unmatched = changed.filter((p) => !listed.files.includes(p));
+  const graph = graphState(edges, files);
   if (selected.length === 0) {
-    const payload = { ok: true, command: 'gate', root, selected, code: 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;
     }
-    emit('selected  0', { maxBytes: flags.maxBytes ?? 0 });
+    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'));
     return EXIT.OK;
   }
-  return runSelected(root, flags, selected);
+  return runSelected(root, flags, selected, { unmatched, graph });
+}
+
+/**
+ * `resolved` unless some language present in the edges has total edges but
+ * zero reaching a tracked file. A language with no edges at all is not
+ * evidence of anything - an unimported file needs no resolution.
+ */
+function graphState(edges, files) {
+  const byLang = new Map();
+  for (const edge of edges) {
+    const lang = langOf(edge.src);
+    if (!lang) continue;
+    const stat = byLang.get(lang) ?? { total: 0, resolved: 0 };
+    stat.total += 1;
+    if (files.has(edge.dst)) stat.resolved += 1;
+    byLang.set(lang, stat);
+  }
+  for (const stat of byLang.values()) {
+    if (stat.total > 0 && stat.resolved === 0) return 'unresolved';
+  }
+  return 'resolved';
 }
 
-async function runSelected(root, flags, selected) {
+async function runSelected(root, flags, selected, { unmatched = [], graph = 'resolved' } = {}) {
   const cache = new Map();
   const groups = new Map();
   for (const file of selected) {
@@ -106,22 +161,35 @@ async function runSelected(root, flags, selected) {
   }
   const raw = await writeRaw(root, rawParts.join('\n'));
   if (raw) text.push('', `raw  ${raw}`);
-  const payload = { ok: code === 0, command: 'gate', root, selected, code, 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 });
+  const payload = {
+    ok: code === 0,
+    command: 'gate',
+    root,
+    selected,
+    unmatched,
+    graph,
+    verdict: 'selected',
+    code,
+    raw,
+    runs,
+  };
+  present(payload, () => text.filter((line) => line !== undefined).join('\n'), flags);
   return code === 0 ? EXIT.OK : EXIT.FAIL;
 }
 
 async function writeRaw(root, body) {
+  // Raw gate output is machine-local state (review 0003 Q19).
   try {
-    const dir = join(root, '.simt', 'gate');
+    const rel = localRel('gate', `gate-${Date.now()}.log`);
+    const dir = join(root, dirname(rel));
     await mkdir(dir, { recursive: true });
-    const name = `gate-${Date.now()}.log`;
-    await writeFile(join(dir, name), body);
-    return `.simt/gate/${name}`;
+    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 '';
   }
@@ -129,8 +197,10 @@ async function writeRaw(root, body) {
 
 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 (`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) };
   } catch (error) {
     return {
       error: fail(
@@ -144,9 +214,9 @@ async function tracked(root) {
 
 async function changedFiles(root) {
   try {
-    const { stdout } = await exec('git', ['diff', '--name-only', 'HEAD'], { cwd: root, maxBuffer: 8 << 20 });
-    const untracked = await exec('git', ['ls-files', '--others', '--exclude-standard'], { cwd: root, maxBuffer: 8 << 20 });
-    return { files: [...new Set([...stdout.split('\n'), ...untracked.stdout.split('\n')].filter(Boolean))].sort() };
+    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() };
   } catch (error) {
     return {
       error: fail(

package/src/commands/graph.mjs

@@ -31,16 +31,29 @@ export async function lintCommand(positional, flags) {
   // client accept these files", and the second question needs no registry at all. A
   // reader with no registry can still lint a skill directory, so the two are additive
   // rather than one gating the other.
-  const specReport = registry && workspace?.root
-    ? await lintSpec(registry, workspace.root)
-    : { errors: [], warnings: [], checked: 0 };
+  //
+  // The pass runs only when asked for (`--spec`) and only against a verified
+  // registry: without it the default lint reported 37 warnings for a pass the
+  // payload claimed never ran (`spec: null`), and `ok` stayed true over errors
+  // the spec pass had just found (review 0003 Q35).
+  let specReport = { errors: [], warnings: [], checked: 0 };
+  if (spec !== null) {
+    if (registry && verified && workspace?.root) {
+      specReport = await lintSpec(registry, workspace.root);
+    } else {
+      warnings.push(
+        'spec pass skipped: it needs --spec against a registry verified on disk (see `verified` above)',
+      );
+    }
+  }
   errors.push(...specReport.errors);
   warnings.push(...specReport.warnings);
+  const finalOk = ok && errors.length === 0;
 
   if (isJson(flags)) {
     emitJson(
       {
-        ok,
+        ok: finalOk,
         registry: path,
         capabilities: registry?.capabilities?.length ?? 0,
         skills: registry?.skills?.length ?? 0,
@@ -58,9 +71,8 @@ export async function lintCommand(positional, flags) {
         errors,
         warnings,
       },
-      { maxBytes: flags.maxBytes ?? 0 },
     );
-    return ok ? EXIT.OK : EXIT.REGISTRY;
+    return finalOk ? EXIT.OK : EXIT.REGISTRY;
   }
 
   if (!registry) {
@@ -96,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
@@ -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);