simt-dev 0.4.0 → 0.6.0

package/src/commands/pack.mjs

@@ -0,0 +1,246 @@
+// simt pack new | lint | publish - the author side of a pack.
+//
+// A pack is vendored bytes (ADR-065): the adopting repository carries them and
+// pins a digest, and nothing renders from outside the repository. These three
+// subcommands are how a pack comes to exist, how it is judged, and how its bytes
+// become obtainable - without ever fetching at render time.
+//
+// Like every writer here, `new` and `publish` are previews by default and write
+// (or publish) only with `--yes`. `lint` is a read: it judges and reports, and
+// exits non-zero when the pack fails.
+
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
+import { CLI, MANIFEST_FILE, MANIFEST_LEGACY } from '../name.mjs';
+import { PACK_DIR, packNameProblem } from '../packs.mjs';
+import {
+  BENCH_JSON,
+  PACK_JSON,
+  describeSourceProblem,
+  lintPack,
+  npmPackageOf,
+  publishPack,
+  readBench,
+  scaffoldPack,
+  writeScaffold,
+} from '../packs/manage.mjs';
+import { readManifest } from '../projection/manifest.mjs';
+
+export async function packCommand(sub, args, flags) {
+  if (sub === 'new') return packNew(args, flags);
+  if (sub === 'lint') return packLint(args, flags);
+  if (sub === 'publish') return packPublish(args, flags);
+  return fail(`unknown pack subcommand ${sub ?? '(none)'}`, EXIT.USAGE, `run: ${CLI} pack lint [dir]`);
+}
+
+/**
+ * Where a lint or publish resolves its pack: the positional directory, the
+ * `--root`, or the working directory. `hooks` reads the same three in the same
+ * order, so the two commands cannot disagree about which directory was meant.
+ */
+function packDir(args, flags) {
+  return resolve(flags.root ?? args[0] ?? process.cwd());
+}
+
+/**
+ * The manifest entry that declares this pack, when the directory is a vendored
+ * copy inside an adopting repository. Lint then checks the two promises a
+ * declaration makes - version and digest - against the bytes on disk, so a
+ * pack that drifted from its pin is reported where it sits, not only in the
+ * adopting repo's gate.
+ */
+async function declaredEntry(dir) {
+  let cursor = dir;
+  for (;;) {
+    if (existsSync(join(cursor, MANIFEST_FILE)) || existsSync(join(cursor, MANIFEST_LEGACY))) {
+      const { manifest, exists, error } = await readManifest(cursor);
+      if (!exists || error !== null || manifest === null) return null;
+      const packs = Array.isArray(manifest.packs) ? manifest.packs : [];
+      const here = join(cursor, PACK_DIR);
+      if (dir === here || dir.startsWith(`${here}/`)) {
+        const name = dir.slice(here.length + 1).split('/')[0];
+        return packs.find((p) => p?.name === name) ?? null;
+      }
+      return null;
+    }
+    const parent = dirname(cursor);
+    if (parent === cursor) return null;
+    cursor = parent;
+  }
+}
+
+async function packNew(args, flags) {
+  const name = args[0];
+  if (!name) {
+    return fail(
+      'pack new needs a name',
+      EXIT.USAGE,
+      `run: ${CLI} pack new <name> --source <npm:<package>|git+https://…>`,
+    );
+  }
+  const nameProblem = packNameProblem(name);
+  if (nameProblem !== null) {
+    return fail(nameProblem, EXIT.USAGE, 'a pack name is the directory name its bytes vendor under');
+  }
+  const source = flags.source;
+  if (!source) {
+    return fail(
+      'pack new needs --source',
+      EXIT.USAGE,
+      `run: ${CLI} pack new ${name} --source <npm:<package>|git+https://…>`,
+    );
+  }
+  const sourceProblem = describeSourceProblem(source);
+  if (sourceProblem !== null) {
+    return fail(sourceProblem, EXIT.USAGE, 'a pack source names where the bytes come from: `npm:<package>` or `git+https://…`');
+  }
+
+  const dir = join(resolve(flags.root ?? process.cwd()), name);
+  const files = scaffoldPack({ name, source });
+  const { apply, dryRun } = writeMode(flags);
+
+  if (isJson(flags)) {
+    emitJson({
+      ok: true,
+      command: 'pack new',
+      dir,
+      dryRun: !apply,
+      files: files.map((f) => f.path),
+      packFile: PACK_JSON,
+      benchFile: BENCH_JSON,
+    });
+    return EXIT.OK;
+  }
+
+  if (!apply) {
+    emit(
+      [
+        `pack     ${name} -> ${dir}`,
+        `source   ${source}`,
+        '',
+        ...files.map((f) => `PLAN     ${f.path}`),
+        '',
+        dryRun ? 'DRY-RUN  no files written' : `PLAN     nothing written; apply with: ${CLI} pack new ${name} --source ${source} --yes`,
+      ].join('\n'),
+      { maxBytes: flags.maxBytes ?? 0 },
+    );
+    return EXIT.OK;
+  }
+
+  try {
+    await writeScaffold(dir, files);
+  } catch (error) {
+    return fail(error.message, EXIT.FAIL, 'pick a name whose directory does not exist yet');
+  }
+  emit(
+    [
+      `pack     ${name} -> ${dir}`,
+      `source   ${source}`,
+      ...files.map((f) => `WRITE    ${f.path}`),
+      '',
+      `WROTE    ${files.length} scaffold file(s); write the rule, then: ${CLI} pack lint ${dir}`,
+    ].join('\n'),
+    { maxBytes: flags.maxBytes ?? 0 },
+  );
+  return EXIT.OK;
+}
+
+async function packLint(args, flags) {
+  const dir = packDir(args, flags);
+  const declared = await declaredEntry(dir);
+  const { pack, ok, findings } = await lintPack(dir, {
+    requireMeasured: flags.requireMeasured === true,
+    declared,
+  });
+
+  // The one-line answer first, because a gate that failed should say what it
+  // judged before it says why: the pack, its version, and the digest the
+  // adopting manifest would pin.
+  const headline = pack === null ? `pack     ${dir} (no ${PACK_JSON})` : `pack     ${pack.name} ${pack.version}  digest ${pack.digest}`;
+
+  if (isJson(flags)) {
+    emitJson({ ok, command: 'pack lint', dir, pack, findings });
+    return ok ? EXIT.OK : EXIT.FAIL;
+  }
+
+  const lines = [headline];
+  if (pack !== null) {
+    const summary = await summaryLine(dir);
+    if (summary !== null) lines.push(summary);
+  }
+  if (declared !== null && pack !== null) {
+    lines.push(`declared ${declared.version ?? '(no version)'}  pinned ${declared.digest ?? '(unpinned)'}`);
+  }
+  for (const f of findings) {
+    lines.push(`${f.status.toUpperCase().padEnd(24)} ${f.file}  ${f.detail}`);
+    lines.push(`                        remedy: ${f.remedy}`);
+  }
+  lines.push('', ok ? 'PASSED   the pack is well-formed' : `FAILED   ${findings.length} finding(s)`);
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return ok ? EXIT.OK : EXIT.FAIL;
+}
+
+/**
+ * The measured ΔR, in the pack's own words. Reported, never judged, here:
+ * judging is `lint`'s with `--require-measured`; this line is what a reader
+ * who asked \"what is this pack worth\" reads either way.
+ */
+async function summaryLine(dir) {
+  const { bench } = await readBench(dir);
+  if (bench === null) return null;
+  if (bench.measured !== true) return `measured unmeasured (no ΔR recorded in ${BENCH_JSON})`;
+  const dR = typeof bench.dR === 'number' ? (bench.dR >= 0 ? `+${bench.dR}` : `${bench.dR}`) : '(no dR)';
+  return `measured dR ${dR} over ${bench.tasks ?? '?'} tasks (${bench.run ?? 'unrecorded run'})`;
+}
+
+async function packPublish(args, flags) {
+  const dir = packDir(args, flags);
+  const { apply, dryRun } = writeMode(flags);
+  const result = await publishPack(dir, { apply });
+
+  if (isJson(flags)) {
+    emitJson({
+      ok: result.ok,
+      command: 'pack publish',
+      dir,
+      pack: result.pack,
+      published: result.published,
+      skipped: result.skipped,
+      planned: result.planned,
+      findings: result.findings,
+    });
+    return result.ok ? EXIT.OK : EXIT.FAIL;
+  }
+
+  const name = result.pack === null ? dir : `${result.pack.name} ${result.pack.version}`;
+  const lines = [`pack     ${name}`, `source   ${result.pack?.source ?? '(unknown)'}`];
+  if (result.skipped) {
+    lines.push(`SKIPPED  ${npmPackageOf(result.pack.source)}@${result.pack.version} is already live; nothing to publish`);
+  }
+  for (const step of result.planned) lines.push(`${apply ? 'RUN      ' : 'PLAN     '}${step}`);
+  for (const f of result.findings) {
+    lines.push(`${f.status.toUpperCase().padEnd(24)} ${f.file}  ${f.detail}`);
+    lines.push(`                        remedy: ${f.remedy}`);
+  }
+  if (result.ok && !result.skipped) {
+    lines.push(
+      '',
+      apply
+        ? `PUBLISHED ${result.pack.name}@${result.pack.version}`
+        : dryRun
+          ? 'DRY-RUN  nothing published'
+          : `PLAN     nothing published; apply with: ${CLI} pack publish ${dir} --yes`,
+    );
+  } else if (result.ok) {
+    lines.push('');
+  } else {
+    lines.push('', `FAILED   ${result.findings.length} finding(s)`);
+  }
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  if (result.ok && apply && result.published) {
+    note(`note     never committed or pushed by this tool (ADR-001); the registry now has the bytes, the repos still need vendoring`);
+  }
+  return result.ok ? EXIT.OK : EXIT.FAIL;
+}

package/src/commands/plugin.mjs

@@ -0,0 +1,61 @@
+// simt plugin <claude|gemini|cursor> --out <dir> [--yes]
+//
+// Build one harness package from the same tables `agent-hooks install` writes into a
+// repository, so a package and a repository install cannot drift apart. A dry run prints
+// the plan and writes nothing; --yes copies the runtime and writes every generated file.
+// The package is self-contained — it carries its own copy of the runtime — so it installs
+// into a clean profile that has never seen this tool (plan 0003 R43).
+
+import { EXIT, emit, emitJson, fail, isJson, writeMode } from '../output/index.mjs';
+import { CLI } from '../name.mjs';
+import { buildPackage, PLUGIN_KINDS } from '../plugins.mjs';
+
+export async function pluginCommand(args, flags) {
+  const kind = args[0];
+  if (!kind || !PLUGIN_KINDS.includes(kind)) {
+    return fail(
+      kind ? `unknown package kind \`${kind}\`` : 'plugin needs a kind',
+      EXIT.USAGE,
+      `one of: ${PLUGIN_KINDS.join(', ')}`,
+    );
+  }
+
+  const out = flags.out;
+  if (!out) {
+    return fail('plugin needs --out <dir>', EXIT.USAGE, 'where the generated package lands');
+  }
+
+  const { apply } = writeMode(flags);
+  const root = flags.root ?? process.cwd();
+  const plan = await buildPackage(kind, { root, out, apply });
+
+  if (isJson(flags)) {
+    emitJson({
+      ok: true,
+      command: `plugin ${kind}`,
+      out,
+      dryRun: !apply,
+      runtime: plan.runtime,
+      files: plan.files,
+      notes: plan.notes,
+    });
+    return EXIT.OK;
+  }
+
+  const runtimeTarget = plan.runtime.target === '.' ? '(the package root)' : `${plan.runtime.target}/`;
+  emit(
+    [
+      `kind     ${kind}`,
+      `out      ${out}`,
+      `runtime  copies ${plan.runtime.parts.join(', ')} into ${runtimeTarget}`,
+      ...plan.files.map((f) => `${apply ? 'WRITE' : 'PLAN '}  ${f.path}`),
+      ...plan.notes.map((n) => `note     ${n}`),
+      '',
+      apply
+        ? `WROTE    ${plan.files.length} generated file(s) plus the runtime`
+        : `PLAN     nothing written; apply with: ${CLI} plugin ${kind} --out ${out} --yes`,
+    ].join('\n'),
+    { maxBytes: flags.maxBytes ?? 0 },
+  );
+  return EXIT.OK;
+}

package/src/commands/review.mjs

@@ -0,0 +1,65 @@
+// `simt review [--local]` (plan 0003 R39).
+//
+// The critic's report layer: the deterministic path prints the brief (staged diff
+// plus what governs it); `--local` adds the model verdict, which always arrives as
+// a proposal a human reads — nothing here is a gate, and the exit code never
+// carries the verdict, because a critic that fails the run would be a gate by
+// another name (ADR-090, principle P2: the reply's text is model output and never
+// lands in projected or committed text).
+
+import { CLI } from '../name.mjs';
+import { EXIT, emit, emitJson, isJson } from '../output/index.mjs';
+import { reviewTarget } from '../review/critic.mjs';
+
+function governsLine(items) {
+  if (items.length === 0) return 'none';
+  const ids = items.slice(0, 8).map((item) => item.id);
+  const more = items.length > ids.length ? ` …+${items.length - ids.length}` : '';
+  return ids.join(', ') + more;
+}
+
+export async function reviewCommand(args, flags, commands = []) {
+  const result = await reviewTarget(args, flags, { commands });
+  if (typeof result === 'number') return result;
+
+  if (isJson(flags)) {
+    emitJson(result, { maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+
+  const lines = [
+    `staged    ${result.staged.files.length} files, ${result.staged.bytes} bytes`,
+    `governs   ${governsLine(result.governs)}`,
+  ];
+  // The branch keys on the path, not on the verdict: a local run whose reply
+  // lacked a verdict line still carries faults and a proposal, and hiding them
+  // behind the "needs --local" reading would erase the model's failure.
+  if (result.brief !== undefined) {
+    // The nothing-staged run is a plain answer, not an invitation to rerun with
+    // --local: there is no brief yet, so there is nothing for the critic to read.
+    if (result.staged.files.length === 0) {
+      lines.push('verdict   none (nothing is staged)');
+    } else {
+      lines.push(
+        `verdict   needs ${CLI} review --local  (advisory; a critic is never a gate)`,
+      );
+    }
+  } else {
+    if (result.verdict !== null) {
+      lines.push(
+        `verdict   ${result.verdict} (${result.verified ? 'verified' : 'unverified'})`,
+        `findings  ${result.findings}`,
+      );
+    } else {
+      lines.push('verdict   absent (unverified)');
+    }
+    if (!result.verified) {
+      for (const fault of result.faults) lines.push(`unverified ${fault}`);
+    }
+    lines.push(`proposal  ${result.proposal.path}  (${result.proposal.state}, ${result.proposal.bytes} bytes)`);
+  }
+  if (result.metric) lines.push(`metric    ${result.metric.note}`);
+
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}

package/src/commands/rules.mjs

@@ -1,4 +1,4 @@
-// `simt-dev rules` - the rule catalogue and its provenance.
+// `simt rules` - the rule catalogue and its provenance.
 //
 // A rule is only meaningful if you can answer "why is this here?". Three
 // commands, mirroring the skill surface deliberately: `list` is the catalogue,

package/src/commands/skills.mjs

@@ -1,4 +1,4 @@
-// `simt-dev skills` - tier 0 (index), tier 1 (brief), tier 2 (show), plus find/why.
+// `simt skills` - tier 0 (index), tier 1 (brief), tier 2 (show), plus find/why.
 //
 // Implementation sequence steps 4 and 5.
 //
@@ -15,7 +15,7 @@ import { existsSync } from 'node:fs';
 
 import { EXIT, emit, emitJson, fail, isJson, note as emitNote } from '../output/index.mjs';
 import { loadRegistry } from '../graph/load.mjs';
-import { locateSource, sourceHeldLocally } from '../resolve/source.mjs';
+import { bodyFile, sourcePath } from '../resolve/body.mjs';
 import { unknownSkills, scoreCorpus } from '../resolve/eval.mjs';
 import { PACKAGE_ROOT, resolveWorkspace, WORKSPACE_REMEDY } from '../workspace.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
@@ -656,36 +656,6 @@ export async function evalCommand(positional, flags) {
 
 // --- bodies -------------------------------------------------------------------
 
-/**
- * Resolve a skill's body to an absolute path.
- *
- * Sources are declared as `repo/path`, so finding one needs the workspace that
- * CONTAINS the repos. That used to be `resolve(here, '..', '..', '..')`, which is
- * right in the checkout and wrong in `node_modules` - so every source resolved to a
- * path that could not exist and `skills` failed with 38 ENOENT lines. Now it comes
- * from configuration, and `null` is a legitimate answer meaning "this installation
- * has no workspace" (ADR-014).
- *
- * A second location exists and is not a fallback: the repo being read is itself a
- * location for a declared source, matched on bytes rather than on hope (ADR-015).
- * The canonical source is still tried first, so a workspace body always wins.
- */
-async function sourcePath(skill, workspaceRoot, root) {
-  const canonical = skill.sources?.find((s) => s.role === 'canonical') ?? skill.sources?.[0];
-
-  if (canonical) {
-    const found = await locateSource(canonical, { workspaceRoot, root });
-    if (found.path) return found.path;
-  }
-
-  const held = await sourceHeldLocally(skill, root, { workspaceRoot });
-  if (held && !held.ambiguous) return held.path;
-
-  // A skill with no canonical source, or one whose bytes match nothing, has no
-  // body. Say so rather than printing an empty section.
-  return canonical && workspaceRoot ? join(workspaceRoot, canonical.repo, canonical.path) : null;
-}
-
 /** A one-line pointer. The reasons stay, so a brief that cannot inline still says why. */
 function pointerLine(entry) {
   const why = [...entry.reasons, ...[...entry.via].map((v) => `requires:${v}`)];
@@ -705,8 +675,7 @@ export async function readBody(skill, workspaceRoot, root) {
   }
   if (!existsSync(full)) return `(body unavailable: ${full} is not on this machine)`;
   try {
-    const target = existsSync(join(full, 'SKILL.md')) ? join(full, 'SKILL.md') : full;
-    return (await readFile(target, 'utf8')).trimEnd();
+    return (await readFile(bodyFile(full), 'utf8')).trimEnd();
   } catch (error) {
     return `(body unreadable: ${error.message})`;
   }

package/src/commands/skillscompile.mjs

@@ -20,9 +20,7 @@ import { resolveVaultDir } from '../bench/mine.mjs';
 import { locateSource, sourceHeldLocally } from '../resolve/source.mjs';
 import { nearMatches } from '../resolve/near.mjs';
 import { resolveWorkspace, WORKSPACE_REMEDY } from '../workspace.mjs';
-import { CLI, CONFIG_DIR } from '../name.mjs';
-
-const STATE_DIR = `.${CONFIG_DIR}`;
+import { CLI, STATE_DIR } from '../name.mjs';
 
 async function readSkillRawText(skill, workspaceRoot, root) {
   const canonical = skill.sources?.find((s) => s.role === 'canonical') ?? skill.sources?.[0];

package/src/commands/skillsinstall.mjs

@@ -1,4 +1,4 @@
-// `simt-dev skills install` - pin a skill into a repo as a local copy.
+// `simt skills install` - pin a skill into a repo as a local copy.
 //
 // Plan 0002 section 8.3: installed skills are recorded in `simt-dev.json`
 // `localSkills` and are excluded from central-drift accounting. The point is a

package/src/commands/sync.mjs

@@ -1,5 +1,5 @@
-// simt-dev sync --yes — write the generated regions.
-// simt-dev check — the gate.
+// simt sync --yes — write the generated regions.
+// simt check — the gate.
 //
 // They share plan/project.mjs so they can never disagree about what the regions
 // should contain. sync decides whether to act; check decides severity and exit
@@ -36,7 +36,7 @@ import { lintDecisions } from '../memory/decide.mjs';
 /** Findings `sync` reports and does not fail on.
  *
  *  `pointer-unread` is a misaimed pointer whose reader this repository serves. `sync`
- *  must not refuse on it: the remedy is `simt-dev sync --yes`, so a `sync` that blocked
+ *  must not refuse on it: the remedy is `simt sync --yes`, so a `sync` that blocked
  *  would be a gate whose remedy is the command being run — ADR-025 ruling 6's hazard, and
  *  worse than a noisy gate. `check` disagrees, and the reason is the whole of ADR-051.
  *
@@ -194,9 +194,9 @@ export async function syncCommand(positional, flags) {
     if (st.state === 'current') continue;
     // A *mispointed* pointer is one this tool wrote and this tool may repair: it is a
     // symlink, so it has no content, and the remedy printed by `check` for this exact
-    // finding is `simt-dev sync --yes`. Reporting a plan and then calling `symlink()` at
+    // finding is `simt sync --yes`. Reporting a plan and then calling `symlink()` at
     // an existing path is `EEXIST` — which is what this did, and the remedy it offered
-    // was `simt-dev doctor`, which reports nothing about it. A command whose own remedy
+    // was `simt doctor`, which reports nothing about it. A command whose own remedy
     // crashes on the state it names has no remedy at all.
     //
     // Only a symlink is replaced. A regular file or a directory is somebody's work and
@@ -364,7 +364,7 @@ export async function syncCommand(positional, flags) {
 
   const idle = changed.length === 0 && pointerPlan.length === 0 && !manifestChanged;
   if (checkOnly) return idle ? EXIT.OK : EXIT.FAIL;
-  // A preview that found work is not a success: `simt-dev sync --yes` with no flags is a
+  // A preview that found work is not a success: `simt sync --yes` with no flags is a
   // check that also prints the plan, and a check that exits 0 while reporting drift
   // is the one-question-two-answers shape ADR-035 rules out. This is what lets a
   // caller run `sync` in place of `sync --check` and get the same verdict.
@@ -500,8 +500,8 @@ export async function checkCommand(positional, flags) {  const root = flags.root
   const { manifest } = await readManifest(root);
   if (manifest) {
     // The gate runs from whatever binary resolved it. For a repository without npm that
-    // is a global install, and the only thing that knows which version it should be is
-    // the pin the repo recorded at adoption. A stale binary would run a different gate
+    // is the release binary in `.simt/bin` (ADR-098), and the only thing that knows
+    // which version it should be is the pin the repo recorded at adoption. A stale binary would run a different gate
     // than CI does, so the mismatch fails the gate rather than warning.
     const mismatch = assertVersionPin(manifest);
     if (mismatch) {

package/src/commands/tokens.mjs

@@ -1,4 +1,4 @@
-// simt-dev tokens - what a reader loads, counted.
+// simt tokens - what a reader loads, counted.
 //
 // Review 0002 S38 put the estate's always-on context at 90 KB per turn, 72% of it a
 // paragraph an earlier root had already loaded, and could only say so by reading seven

package/src/commands/upgrade.mjs

@@ -1,4 +1,4 @@
-// simt-dev upgrade - move every consumer to this simt-dev, as one reviewable set.
+// simt upgrade - move every consumer to this simt-dev, as one reviewable set.
 //
 // Why this command exists, and why it is shaped the way it is:
 //

package/src/commands/why.mjs

@@ -26,7 +26,7 @@ import { listPromotedLessons } from '../memory/lessons.mjs';
 
 const exec = promisify(execFile);
 
-const RULE_DIRS = ['rules', 'rules/stacks', 'rules/mdc', '.simt-dev/profiles'];
+const RULE_DIRS = ['rules', 'rules/stacks', 'rules/mdc', '.simt/profiles'];
 
 export async function whyCommand(args, flags, commands = []) {
   if (args.length > 1) return fail(`unknown why argument ${args[1]}`, EXIT.USAGE, `run: ${CLI} why [path]`);
@@ -63,7 +63,9 @@ function reportUnresolved(root, flags, unresolved) {
   return EXIT.OK;
 }
 
-async function tracked(root) {
+// `async function tracked(root)` (read by `simt why`) becomes `export async`:
+// the critic's brief resolves governance the same way without a second copy.
+export async function tracked(root) {
   try {
     const { stdout } = await exec('git', ['ls-files'], { cwd: root, maxBuffer: 16 << 20 });
     return { files: stdout.split('\n').filter(Boolean) };
@@ -98,7 +100,8 @@ export async function decisionRecords(root) {
   return records;
 }
 
-async function loadCorpus(root) {
+// `async function loadCorpus(root)` (read by `simt why`) becomes `export async`.
+export async function loadCorpus(root) {
   const [rules, skills, lessons, commands] = await Promise.all([
     ruleScopes(root),
     skillScopes(root),

package/src/compare/discover.mjs

@@ -1,4 +1,4 @@
-// Find the sibling repositories a `simt-dev compare` should report on.
+// Find the sibling repositories a `simt compare` should report on.
 //
 // Three things here are load-bearing, and each exists because the alternative is
 // a wrong answer rather than a missing one:

package/src/compare/hooksstate.mjs

@@ -1,7 +1,7 @@
 // Read a repo's hook routing and shim state without changing anything.
 //
-// This is the read half of what `simt-dev hooks status` does inline. It is a separate
-// module because two callers need it - `hooks status` and `simt-dev compare` - and a
+// This is the read half of what `simt hooks status` does inline. It is a separate
+// module because two callers need it - `hooks status` and `simt compare` - and a
 // second implementation of "is this shim current?" would be exactly the
 // duplicated-source-of-truth problem the tool exists to remove. `compare` reads it
 // for N repos, so it must not shell out per repo per event.
@@ -11,7 +11,7 @@ import { readFile, stat } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { promisify } from 'node:util';
 
-import { CHAIN_MARKER, EVENTS, HOOKS_DIR, HOOKS_PATH_KEY, SHIM_MARKER, fileFor, renderShim } from '../hooks/shim.mjs';
+import { CHAIN_MARKER, EVENTS, HOOKS_DIR, HOOKS_PATH_KEY, SHIM_MARKER, fileFor, renderChainedShim, renderShim } from '../hooks/shim.mjs';
 import { foreignHooks, resolveHooksDir } from '../hooks/where.mjs';
 import { packageVersion, hasNpm } from '../package-version.mjs';
 
@@ -123,8 +123,8 @@ export async function readHooksPath(root) {
  * already records for the same reason.
  *
  * `root` is the repository the shim belongs to: the remedy a shim prints depends on
- * the repo's kind (a devDependency where package.json exists, a pinned global install
- * where there is none), so the comparison must render the shim the way THIS repo got it,
+ * the repo's kind (a devDependency where package.json exists, the release binary into
+ * the repository where there is none), so the comparison must render the shim the way THIS repo got it,
  * or a non-npm repository would read as stale the moment this tool ships.
  */
 async function describeShim(path, root) {
@@ -142,7 +142,15 @@ async function describeShim(path, root) {
   }
   let stale = true;
   try {
-    stale = content !== renderShim(basename(path), { npm: await hasNpm(root), version: packageVersion() });
+    // A chained shim is current against the repository hook it chains to, not against
+    // the dispatcher template: comparing it to renderShim read every chained ungated
+    // event as stale forever, and no reinstall could clear it.
+    if (content.includes(CHAIN_MARKER)) {
+      const chain = await readChainedShim(path);
+      stale = chain === null || content !== renderChainedShim(chain.event, chain.target);
+    } else {
+      stale = content !== renderShim(basename(path), { npm: await hasNpm(root), version: packageVersion() });
+    }
   } catch {
     stale = true;
   }
@@ -177,17 +185,21 @@ export async function readHooksState(root, options = {}) {
   const staleOurs = [];
   for (const hook of live) {
     const shim = EVENTS.includes(hook.event) ? await describeShim(hook.path, root) : { stale: true };
-    if (!shim.stale) continue;
     // A chained shim is ours too, and its name says nothing: `post-commit` is what the
     // repository called its own hook, and the shim exists under that name precisely so
     // git finds it. Reading it as foreign would make every re-install refuse with "this
     // repo already runs hooks simt did not write" - a shim this tool wrote, refusing
     // itself. Identity is content, the same rule as the dispatcher shim above.
+    //
+    // Classified before the currency skip, because a current chain shim is not stale -
+    // and install still has to maintain it from `chained`, or a second run would forget
+    // the very shim that is already correct.
     const chain = await readChainedShim(hook.path);
     if (chain) {
       chained.push({ ...chain, path: hook.path });
       continue;
     }
+    if (!shim.stale) continue;
     // And so is a dispatcher shim from an EARLIER version of this tool, which is the
     // ordinary state of every repository adopted before the last release.
     //

package/src/compare/learn.mjs

@@ -1,6 +1,6 @@
 // Estate learning through `compare` (plan 0003 R36).
 //
-// Aggregates `.simt-dev/ledger.jsonl`, `.simt-dev/lessons.jsonl`, and ablation/bench
+// Aggregates `.simt/ledger.jsonl`, `.simt/lessons.jsonl`, and ablation/bench
 // records across workspace repositories to surface:
 //   1. the most-violated rules (from hook denials and `review-block` findings);
 //   2. the most-failing and slowest gates (from evidence ledgers);
@@ -189,7 +189,7 @@ async function collectRepoAblationRecords(repoPath) {
 }
 
 async function readExplicitNoValueSections(repoPath) {
-  const file = join(repoPath, '.simt-dev', 'ablation.json');
+  const file = join(repoPath, '.simt', 'ablation.json');
   try {
     const raw = JSON.parse(await readFile(file, 'utf8'));
     const list = Array.isArray(raw?.sections) ? raw.sections : Array.isArray(raw) ? raw : [];