simt-dev 0.6.3 → 0.7.0

package/src/commands/agenthook.mjs

@@ -22,15 +22,18 @@
 // tool call. Failures of this command exit 1, which a harness reports as a failed hook,
 // and that is the right blast radius for a hook that is broken rather than refusing.
 
+import { existsSync } from 'node:fs';
 import { mkdir, readFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { dirname, isAbsolute, join } from 'node:path';
 import { commitJournal, journaledWriteFile } from '../journal.mjs';
+import { AGENT_HOOK_SHIM, renderAgentHookShim } from '../agenthooks/shim.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
 
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
-import { CLI } from '../name.mjs';
-import { ALLOW_ENV, EVENTS, POLICY_IDS } from '../agenthooks/policy.mjs';
+import { CLI, MANIFEST_FILE, MANIFEST_LEGACY } from '../name.mjs';
+import { ALLOW_ENV, EVENTS, POLICY_IDS, SESSION_ENV } from '../agenthooks/policy.mjs';
 import { decide, factsFor } from '../agenthooks/decide.mjs';
+import { repoRoot } from '../repo-root.mjs';
 import {
   adapter,
   adapters,
@@ -97,10 +100,33 @@ export async function agentHookCommand(args, flags) {
   // `--root` outranks the payload: a packaged hook runs from the plugin directory and the
   // harness's environment variable names the project, so a payload cwd that is the plugin's
   // own working directory must not win. The repository-install path passes no flag, and the
-  // payload's cwd is what the harness reports.
-  const { root, command, writes } = factsFrom(row, payload, { root: flags.root });
-  const facts = await factsFor(root, { command, writes });
-  const decision = decide({ event, facts, env: process.env });
+  // payload's cwd is what the harness reports. The answer is then resolved to the
+  // repository's top level: a harness reports the directory it happens to be in, and an
+  // agent works from subdirectories, so every repository-relative fact (the lease file,
+  // `.gitmodules`) must resolve against the root git itself uses, not the cwd (review
+  // 0003 Q16).
+  const { root: payloadRoot, command, writes, session: payloadSession } = factsFrom(row, payload, { root: flags.root });
+  const root = repoRoot(payloadRoot);
+  // A relative write path is relative to the directory the harness is in, not to the
+  // repository root the facts resolve against: an agent editing `keep.mjs` from `src/`
+  // means `src/keep.mjs`, and a path joined to the wrong base is a path the lease file
+  // will never meet (review 0003 Q16).
+  // Writes are `{path, ...edit}` rows (Q17): the path resolves against the harness
+  // cwd, the edit detail travels untouched so the region check sees the old_string.
+  const writesAbsolute = writes.map((w) => {
+    const path = typeof w === 'string' ? w : w?.path;
+    const abs = typeof path === 'string' && isAbsolute(path) ? path : join(payloadRoot, path);
+    return typeof w === 'string' ? abs : { ...w, path: abs };
+  });
+  const facts = await factsFor(root, { command, writes: writesAbsolute });
+  // Harness hook processes rarely carry SIMT_SESSION, so the payload's own
+  // session id is the fallback: without it an agent is blocked by its own
+  // lease (review 0003 Q20). The environment still wins when it names one.
+  const session =
+    typeof process.env[SESSION_ENV] === 'string' && process.env[SESSION_ENV] !== ''
+      ? process.env[SESSION_ENV]
+      : (payloadSession ?? '');
+  const decision = decide({ event, facts, env: { ...process.env, [SESSION_ENV]: session } });
 
   // Both notes are about a conclusion the author is about to draw: a lift that did
   // nothing because of a typo, and a lift that is the reason the command they expected to
@@ -115,7 +141,11 @@ export async function agentHookCommand(args, flags) {
   const json = decisionJson(row, decision);
   if (json === null) return EXIT.OK;
 
-  if (root) {
+  // A denial is recorded only for a repository that adopted the tool: hook
+  // denials in a never-adopted repo are noise about someone else's policy, and
+  // that is how an unadopted checkout accumulated 23 candidates nobody would
+  // ever promote (review 0003 Q36). The manifest is the adoption mark.
+  if (root && (existsSync(join(root, MANIFEST_FILE)) || existsSync(join(root, MANIFEST_LEGACY)))) {
     try {
       const { recordHookDenial } = await import('../memory/lessons.mjs');
       await recordHookDenial(root, {
@@ -143,8 +173,24 @@ export async function agentHooksCommand(sub, args, flags) {
   return fail(`unknown agent-hooks subcommand ${sub}`, EXIT.USAGE, `run: ${CLI} agent-hooks status`);
 }
 
+// The label for a reader the run did not write, by the state that names why:
+// `none` documents no hooks file, `other` is a reader this tool does not write,
+// `skipped` was an adapter the caller did not ask for (ADR-107).
+const OTHER_LABEL = { none: 'NO FILE ', other: 'NOT OURS', skipped: 'SKIPPED ' };
+
 async function installHooks(root, flags) {
   const mode = writeMode(flags);
+  // `--harness` narrows the install to one reader (ADR-107). The id is validated
+  // against the same table the loop reads, so a typo fails before anything is
+  // planned; the remedy names the ids the way `agent-hook` does.
+  const selected = flags.harness;
+  if (selected !== undefined && adapter(selected) === null) {
+    return fail(
+      `unknown harness \`${selected}\``,
+      EXIT.USAGE,
+      `--harness <id>, one of: ${adapters().map((a) => a.id).join(', ')}`,
+    );
+  }
   // The delivery is a second entry in the same config, and a repository asks for it by
   // declaring a `brief` key rather than by having the entry. Read through a dynamic
   // import for the same reason the hook delivers through one.
@@ -155,8 +201,9 @@ async function installHooks(root, flags) {
     listPromotedLessons(root).catch(() => []),
   ]);
   const hasLessons = promotedLessons.length > 0;
+  const rows = selected === undefined ? adapters() : adapters().filter((r) => r.id === selected);
   const plan = [];
-  for (const row of adapters()) {
+  for (const row of rows) {
     const path = hookPath(row.id);
     const existing = await readIfExists(join(root, path));
     const result = rendered(row, existing, { prompt: optIn.optedIn, post: hasLessons });
@@ -178,15 +225,28 @@ async function installHooks(root, flags) {
 
   // The readers this tool does not write an entry for, reported rather than skipped in
   // silence: a command that writes four files and says nothing about the fifth harness
-  // in the repository reads as "that one is covered too".
+  // in the repository reads as "that one is covered too". A narrowed install adds a
+  // third state: an adapter that is this tool's but was not requested (ADR-107).
   const others = [];
   for (const r of hookRows()) {
     if (r.path === null) others.push({ id: r.id, path: null, state: 'none', note: r.note });
     else if (adapter(r.id) === null) others.push({ id: r.id, path: r.path, state: 'other', note: r.note });
+    else if (selected !== undefined && r.id !== selected) {
+      others.push({ id: r.id, path: r.path, state: 'skipped', note: 'not requested; install without --harness to write every harness' });
+    }
   }
 
   const refused = plan.filter((p) => p.error);
 
+  // The shim every harness config points at: without it the entries above name a
+  // binary no harness has on PATH (review 0003 Q21). Its remedy installs the
+  // dependency the same way the git shims' does — a devDependency where the
+  // repository has a package.json, the release binary where it does not.
+  const shimText = renderAgentHookShim({ npm: (await readIfExists(join(root, 'package.json'))) !== null });
+  const shimBefore = await readBefore(join(root, AGENT_HOOK_SHIM));
+  const shimAction = shimBefore === null ? 'create' : shimBefore === shimText ? 'unchanged' : 'update';
+  const shimRow = { id: 'shim', path: AGENT_HOOK_SHIM, action: shimAction };
+
   // The `--diff` pairs, read before anything is written so the before side is
   // true in preview and in apply alike (R50).
   const diffs =
@@ -194,7 +254,8 @@ async function installHooks(root, flags) {
       ? await Promise.all(
         plan
           .filter((p) => p.action !== 'unchanged')
-          .map(async (p) => ({ path: p.path, before: await readBefore(join(root, p.path)), after: p.text })),
+          .map(async (p) => ({ path: p.path, before: await readBefore(join(root, p.path)), after: p.text }))
+          .concat(shimAction === 'unchanged' ? [] : [{ path: AGENT_HOOK_SHIM, before: shimBefore, after: shimText }]),
       )
       : [];
 
@@ -206,6 +267,7 @@ async function installHooks(root, flags) {
         root,
         dryRun: true,
         plan: plan.map(({ text, ...rest }) => rest),
+        shim: shimRow,
         notWritten: others,
         filesWritten: false,
         ...diffField(diffs, flags),
@@ -216,7 +278,8 @@ async function installHooks(root, flags) {
       [
         `repo     ${root}`,
         ...plan.map((p) => `${p.action.toUpperCase().padEnd(9)} ${p.id.padEnd(12)} ${p.path}${p.error ? `  (${p.error})` : ''}`),
-        ...others.map((o) => `${o.state === 'none' ? 'NO FILE ' : 'NOT OURS'} ${o.id.padEnd(12)} ${o.path ?? '(no hooks file is documented)'}`),
+        `${shimAction.toUpperCase().padEnd(9)} shim         ${AGENT_HOOK_SHIM}`,
+        ...others.map((o) => `${OTHER_LABEL[o.state]} ${o.id.padEnd(12)} ${o.path ?? '(no hooks file is documented)'}`),
         ...promptLine,
         '',
         refused.length > 0
@@ -245,6 +308,14 @@ async function installHooks(root, flags) {
     await journaledWriteFile(root, journal, join(root, p.path), p.text);
     written.push(p);
   }
+  // The shim is a file like the configs: unchanged installs leave it alone, and a
+  // changed one is journaled so `undo` removes or restores it with the configs.
+  let shimWritten = false;
+  if (shimAction !== 'unchanged') {
+    await mkdir(join(root, dirname(AGENT_HOOK_SHIM)), { recursive: true });
+    await journaledWriteFile(root, journal, join(root, AGENT_HOOK_SHIM), shimText, { mode: 0o755 });
+    shimWritten = true;
+  }
   await commitJournal(root, 'agent-hooks install', journal);
 
   const notes = [];
@@ -260,6 +331,7 @@ async function installHooks(root, flags) {
       command: 'agent-hooks install',
       root,
       plan: plan.map(({ text, ...rest }) => rest),
+      shim: { ...shimRow, written: shimWritten },
       notWritten: others,
       written: written.map((p) => p.path),
       filesWritten: true,
@@ -272,10 +344,11 @@ async function installHooks(root, flags) {
     [
       `repo     ${root}`,
       ...plan.map((p) => `${p.action.toUpperCase().padEnd(9)} ${p.id.padEnd(12)} ${p.path}`),
-      ...others.map((o) => `${o.state === 'none' ? 'NO FILE ' : 'NOT OURS'} ${o.id.padEnd(12)} ${o.path ?? '(no hooks file is documented)'}`),
+      `${shimAction.toUpperCase().padEnd(9)} shim         ${AGENT_HOOK_SHIM}`,
+      ...others.map((o) => `${OTHER_LABEL[o.state]} ${o.id.padEnd(12)} ${o.path ?? '(no hooks file is documented)'}`),
       ...promptLine,
       '',
-      `WROTE    ${written.length} hooks file(s); each one runs ${CLI} agent-hook before the tool call`,
+      `WROTE    ${written.length} hooks file(s)${shimWritten ? ' and the shim' : ''}; each one runs the ${AGENT_HOOK_SHIM} shim before the tool call`,
     ].join('\n'),
     { maxBytes: flags.maxBytes ?? 0 },
   );
@@ -290,10 +363,31 @@ async function installHooks(root, flags) {
 async function hooksStatus(root, flags) {
   const rows = [];
   const problems = [];
+  // The plugin file this tool owns whole is compared against what `install` would write
+  // right now, so status reads the same opt-in install reads: a file that matches the
+  // preview is present, anything else is drift an install will rewrite.
+  const { promptOptIn } = await import('../agenthooks/prompt.mjs');
+  const optIn = await promptOptIn(root);
 
   for (const row of adapters()) {
     const path = hookPath(row.id);
     const existing = await readIfExists(join(root, path));
+    if (row.file) {
+      if (existing === null) {
+        rows.push({ id: row.id, path, state: 'absent', entries: 0, prompt: row.prompt ? 'absent' : null, note: null });
+      } else {
+        const present = rendered(row, existing, { prompt: optIn.optedIn }).action === 'unchanged';
+        rows.push({
+          id: row.id,
+          path,
+          state: present ? 'present' : 'drift',
+          entries: present ? 1 : 0,
+          prompt: row.prompt ? (present && optIn.optedIn ? 'present' : 'absent') : null,
+          note: present ? null : 'differs from what install would write; run install to restore it',
+        });
+      }
+      continue;
+    }
     if (existing === null) {
       rows.push({ id: row.id, path, state: 'absent', entries: 0, prompt: row.prompt ? 'absent' : null, note: null });
       continue;
@@ -341,7 +435,7 @@ async function hooksStatus(root, flags) {
 
   const lines = [`repo     ${root}`];
   for (const r of rows) {
-    const state = { present: 'PRESENT ', absent: 'ABSENT  ', unreadable: 'INVALID ', none: 'NO FILE ', other: 'NOT OURS' }[r.state];
+    const state = { present: 'PRESENT ', absent: 'ABSENT  ', unreadable: 'INVALID ', drift: 'DRIFT   ', none: 'NO FILE ', other: 'NOT OURS' }[r.state];
     lines.push(`${state} ${r.id.padEnd(12)} ${r.path ?? '(no hooks file is documented)'}`);
     if (r.state === 'absent') lines.push(`          ${' '.repeat(12)} install: ${CLI} agent-hooks install --yes`);
     // The second event is a separate answer to a separate question: a harness can carry

package/src/commands/bench.mjs

@@ -217,6 +217,7 @@ export async function benchReportCommand(positional, flags) {
       harness: flags.harness,
       model: flags.model,
       compare: compareItems.length === 2 ? compareItems : null,
+      crossGroup: Boolean(flags.crossGroup),
     });
   } catch (error) {
     return fail(
@@ -405,7 +406,7 @@ export async function benchVariantsCommand(positional, flags) {
 // and until a bench here shows that, every report calls the critic advisory.
 export async function benchCriticCommand(positional, flags, commands = []) {
   const root = resolve(flags.root ?? positional[0] ?? process.cwd());
-  const labelsPath = flags.labels ?? '.simt/critic-labels.jsonl';
+  const labelsPath = flags.labels ?? '.simt/local/critic-labels.jsonl';
   const result = await criticBench(root, { labelsPath, flags, commands });
   if (typeof result === 'number') return result;
 

package/src/commands/compare.mjs

@@ -24,7 +24,7 @@ import { basename, resolve } from 'node:path';
 import { EXIT, emit, emitJson, fail, isJson, note } from '../output/index.mjs';
 import { provenanceDigest } from '../projection/project.mjs';
 import { GATES } from '../hooks/gates.mjs';
-import { buildRow, summarise } from '../compare/row.mjs';
+import { buildRows, resolveConcurrency, summarise } from '../compare/row.mjs';
 import { discover } from '../compare/discover.mjs';
 import { learnAcrossEstate, renderLearningLines } from '../compare/learn.mjs';
 import { targetRoot, WORKSPACE_REMEDY } from '../workspace.mjs';
@@ -60,12 +60,13 @@ export async function compareCommand(positional, flags) {
   const expectedSha = await provenanceDigest();
   const context = { expectedSha, gates: new Set(Object.keys(GATES)), gateKinds: GATE_KINDS };
 
-  // Sequential on purpose. 16 fingerprint+region computations each spawn a git
-  // process; running them concurrently produces a burst of subprocesses and no
-  // measurable speedup, because the work is process-spawn bound rather than CPU
-  // bound. Determinism of the output matters more than wall clock on a dashboard.
-  const rows = [];
-  for (const repo of found.repos) rows.push(await buildRow(repo, context));
+  // Parallel with a cap, in discovery order. 16 fingerprint+region computations
+  // each spawn a git process; unbounded parallelism is a burst of subprocesses
+  // with no speedup, and sequential builds are what took 48 s over MCP for 17
+  // repos (review 0003 Q38). The cap keeps the burst bounded while overlapping
+  // the spawn wait; the rows still come back in input order, so two runs diff
+  // cleanly and determinism of the output is untouched.
+  const rows = await buildRows(found.repos, context, { concurrency: resolveConcurrency(flags) });
   const learning = await learnAcrossEstate(found.repos);
 
   const summary = summarise(rows, {

package/src/commands/decide.mjs

@@ -2,10 +2,10 @@
 // a rulings skeleton, and structured `simt-affects` + `simt-supersedes` frontmatter
 // (plan 0003 R34).
 
-import { join, resolve } from 'node:path';
+import { join } from 'node:path';
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
-import { DECISIONS_DIR } from '../decisions/index.mjs';
+import { decisionsCutoff, decisionsDir } from '../decisions/dir.mjs';
 import { lintDecisions, scaffoldDecision } from '../memory/decide.mjs';
 import { commitJournal } from '../journal.mjs';
 import { diffField, emitDiffs } from '../diff.mjs';
@@ -15,9 +15,10 @@ export async function decideCommand(args, flags) {
   const root = flags.root ?? process.cwd();
 
   if (flags.check === true) {
-    const decisionsDir = join(root, 'docs', 'decisions');
-    const allowHistorical = resolve(decisionsDir) === DECISIONS_DIR;
-    const res = await lintDecisions(decisionsDir, { allowHistorical });
+    // Q55: one resolution — the manifest key, then the detected directory —
+    // and the cutoff from the same config, never a hard-coded number or path.
+    const relDir = await decisionsDir(root);
+    const res = await lintDecisions(join(root, relDir), { historicalCutoff: await decisionsCutoff(root) });
 
     if (isJson(flags)) {
       emitJson({

package/src/commands/evidence.mjs

@@ -9,7 +9,14 @@ import { readFile } from 'node:fs/promises';
 import { EXIT, emit, emitJson, fail, isJson } 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';
 
 export async function evidenceCommand(args, flags) {
   const root = flags.root ?? process.cwd();
@@ -72,14 +79,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 });

package/src/commands/gate.mjs

@@ -6,8 +6,9 @@
 // this tool knows how to read is compacted; the raw log is kept.
 
 import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
@@ -15,7 +16,8 @@ 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';
 
 const exec = promisify(execFile);
 
@@ -31,31 +33,81 @@ 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 },
+          { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 },
+        );
       } else {
-        emit('selected  0', { maxBytes: flags.maxBytes ?? 0 });
+        emit('selected  0\nverdict  nothing-selected', { maxBytes: flags.maxBytes ?? 0 });
       }
       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 });
       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'), { maxBytes: flags.maxBytes ?? 0 });
     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,7 +158,18 @@ 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 };
+  const payload = {
+    ok: code === 0,
+    command: 'gate',
+    root,
+    selected,
+    unmatched,
+    graph,
+    verdict: 'selected',
+    code,
+    raw,
+    runs,
+  };
   if (isJson(flags)) {
     emitJson(payload, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
     return code === 0 ? EXIT.OK : EXIT.FAIL;
@@ -116,12 +179,13 @@ async function runSelected(root, flags, selected) {
 }
 
 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);
+    return rel;
   } catch {
     return '';
   }
@@ -129,8 +193,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 +210,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,
@@ -60,7 +73,7 @@ export async function lintCommand(positional, flags) {
       },
       { maxBytes: flags.maxBytes ?? 0 },
     );
-    return ok ? EXIT.OK : EXIT.REGISTRY;
+    return finalOk ? EXIT.OK : EXIT.REGISTRY;
   }
 
   if (!registry) {