simt-dev 0.3.1 → 0.5.0

package/src/commands/repoindex.mjs

@@ -13,7 +13,10 @@ export async function indexCommand(args, flags) {
   const root = flags.root ?? process.cwd();
   let result;
   try {
-    result = await reindex(root);
+    result = await reindex(root, {
+      embed: flags.embed === true,
+      allowRemote: flags.allowRemote === true,
+    });
   } catch (error) {
     return fail(
       `could not index this repository (${error.message})`,

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

@@ -14,6 +14,8 @@
 // one, because "this rule has no decision behind it" is exactly the fact a
 // reviewer needs and exactly the fact an empty output would hide.
 
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { loadRules, select } from '../projection/project.mjs';
 import { loadMdcRules } from '../projection/mdc.mjs';
@@ -217,10 +219,17 @@ export async function whyCommand(args, flags) {
   if (!what) return fail('rules why needs a rule id or an ADR id', EXIT.USAGE, `usage: ${CLI} rules why <rule-id|ADR-NNN>`);
 
   const { rules, broken } = await load(flags.root ?? null);
-  const { ok, decisions, errors } = await loadDecisions({ all: flags.all === true });
+  const localDir = flags.root ? join(flags.root, 'docs', 'decisions') : null;
+  const hasLocal = localDir
+    ? (await readdir(localDir).catch(() => [])).some((n) => /^ADR-\d{3,}-.*\.md$/i.test(n))
+    : false;
+  const { ok, decisions, errors } = await loadDecisions({
+    all: flags.all === true,
+    ...(hasLocal ? { dir: localDir } : {}),
+  });
   if (!ok) return fail(errors[0], EXIT.CONFIG, 'the decision records must be readable for provenance to work');
 
-  return what.match(/^ADR-\d{3}$/i)
+  return what.match(/^ADR-\d{3,}$/i)
     ? adrDirection(what.toUpperCase(), rules, decisions, flags)
     : ruleDirection(what, rules, decisions, flags, broken);
 }
@@ -326,6 +335,12 @@ async function adrDirection(adr, rules, decisions, flags) {
   ];
   if (d.supersededBy) lines.push(`SUPERSEDED by ${d.supersededBy} - this record is retained as evidence, not as policy.`);
   if (d.supersedes.length > 0) lines.push(`supersedes  ${d.supersedes.join(', ')}`);
+  const partialForward = (d.supersedesRulings ?? []).filter((s) => s.ruling !== null);
+  if (partialForward.length > 0) {
+    lines.push(
+      `supersedes  ${partialForward.map((s) => `${s.adr} ruling ${s.ruling} (${s.kind})`).join('; ')}`,
+    );
+  }
   // A partial supersession is named here as well as on the ruling it moved, because the
   // two print different sets: this prints every ruling the record lost, and the
   // annotation prints the ones inside the excerpt below. A ruling past the excerpt

package/src/commands/skills.mjs

@@ -15,13 +15,16 @@ 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';
 import { tokenize, rankSkills, closure, selectWithinBudget, resolveAlias, scoreSkill, selectionVerdict, stackCompatible } from '../resolve/resolve.mjs';
 import { nearMatches } from '../resolve/near.mjs';
 import { CLI } from '../name.mjs';
+import { parsePathList } from '../argv.mjs';
+
+export { parsePathList };
 
 const DEFAULT_BUDGET = 20480;
 
@@ -42,23 +45,6 @@ export async function dirtyPaths(root) {
   }
 }
 
-export function parsePathList(value) {
-  return String(value ?? '')
-    .split(',')
-    .map((s) => s.trim())
-    .filter(Boolean);
-}
-
-/**
- * Read a list flag in both the forms this tool ships.
- *
- * `--skill` accepts `--skill a --skill b` and `--skill a,b`, and arrives here as an
- * array in the first case and a string in the second. `String(['a','b'])` happens to
- * produce `'a,b'`, so the old one-line reader would have kept working by accident — and
- * would have started throwing the moment a skill name contained the character the
- * join inserts. Both shapes are handled rather than one being relied upon, because
- * relying on it is the same class of bug as the one being fixed here.
- */
 export function listFlag(value) {
   return (Array.isArray(value) ? value : [value])
     .flatMap((v) => parsePathList(v))
@@ -670,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}`)];
@@ -719,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

@@ -0,0 +1,255 @@
+// `simt skills compile [<name>]` - compile skills to Agent Skills standard, flag bodies
+// over 5k tokens with a progressive-disclosure split plan, and report per-skill trigger
+// recall and precision from R02 transcripts (plan 0003 R30).
+
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+
+import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
+import { loadRegistry } from '../graph/load.mjs';
+import {
+  BODY_TOKEN_BUDGET,
+  compileSkill,
+  evaluateSkillTriggers,
+  proposeSkillDescription,
+} from '../graph/compile.mjs';
+import { loadRunRecords } from '../bench/report.mjs';
+import { extractPatchFiles } from '../bench/grade.mjs';
+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}`;
+
+async function readSkillRawText(skill, workspaceRoot, root) {
+  const canonical = skill.sources?.find((s) => s.role === 'canonical') ?? skill.sources?.[0];
+  let full = null;
+  if (canonical) {
+    const found = await locateSource(canonical, { workspaceRoot, root });
+    if (found.path) full = found.path;
+  }
+  if (!full) {
+    const held = await sourceHeldLocally(skill, root, { workspaceRoot });
+    if (held && !held.ambiguous) full = held.path;
+  }
+  if (!full || !existsSync(full)) return null;
+  try {
+    const target = existsSync(join(full, 'SKILL.md')) ? join(full, 'SKILL.md') : full;
+    return await readFile(target, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+async function loadGoldPathsByTask(root) {
+  const map = new Map();
+  const tasksDir = join(root, STATE_DIR, 'bench', 'tasks');
+  const vaultRoot = resolveVaultDir(root);
+  const entries = (await readdir(tasksDir).catch(() => [])).filter((f) => f.endsWith('.json')).sort();
+  for (const entry of entries) {
+    try {
+      const task = JSON.parse(await readFile(join(tasksDir, entry), 'utf8'));
+      const patch = await readFile(join(vaultRoot, task.id, 'gold.patch'), 'utf8').catch(() => '');
+      if (patch) map.set(task.id, extractPatchFiles(patch));
+    } catch {
+      // ignore unreadable task
+    }
+  }
+  return map;
+}
+
+function fmtMetric(v) {
+  return v === null || v === undefined ? 'n/a' : v.toFixed(3);
+}
+
+export async function compileCommand(args, flags) {
+  const { registry, errors, ok } = await loadRegistry(null, flags);
+  if (!ok) return fail(errors[0], EXIT.REGISTRY, WORKSPACE_REMEDY);
+
+  const root = resolve(flags.root ?? process.cwd());
+  const ws = await resolveWorkspace(flags);
+  const targetName = args[0] ?? null;
+
+  if (targetName) {
+    const skill = registry.skills.find((s) => s.name === targetName);
+    if (!skill) {
+      const near = nearMatches(targetName, registry.skills.map((s) => s.name));
+      return fail(
+        `no skill named "${targetName}"${near.length ? ` (did you mean ${near.join(', ')}?)` : ''}`,
+        EXIT.USAGE,
+        `run: ${CLI} skills find <query>`,
+      );
+    }
+    return runSingleSkillCompile(skill, registry, { root, workspaceRoot: ws.root, flags });
+  }
+
+  const [runs, goldPathsByTask] = await Promise.all([
+    loadRunRecords(root),
+    loadGoldPathsByTask(root),
+  ]);
+
+  const bodiesBySkill = new Map();
+  for (const skill of registry.skills) {
+    const raw = await readSkillRawText(skill, ws.root, root);
+    if (raw) bodiesBySkill.set(skill.name, raw);
+  }
+
+  const report = evaluateSkillTriggers(registry, runs, { bodiesBySkill, goldPathsByTask });
+  const flagged = report.skills.filter((s) => s.flagged);
+
+  if (isJson(flags)) {
+    emitJson(
+      {
+        ok: true,
+        command: 'skills compile',
+        root,
+        tokenBudget: BODY_TOKEN_BUDGET,
+        runCount: report.runCount,
+        skillCount: report.skillCount,
+        flaggedCount: report.flaggedCount,
+        skills: report.skills,
+        flagged: flagged.map((s) => ({
+          name: s.name,
+          bytes: s.bytes,
+          tokens: s.tokens,
+          splitPlan: s.splitPlan,
+        })),
+      },
+      { maxBytes: flags.maxBytes ?? 0 },
+    );
+    return EXIT.OK;
+  }
+
+  const lines = [
+    `skills   ${report.skillCount} total, ${report.flaggedCount} over ${BODY_TOKEN_BUDGET} tokens (flagged with split plan)`,
+    `runs     ${report.runCount} benchmark run(s) in ${root}`,
+    '',
+    'TRIGGER REPORT',
+    'name                          tokens  exp  open  recall  precision  split',
+    ...report.skills.map((s) => {
+      const name = s.name.padEnd(28);
+      const tok = String(s.tokens).padStart(6);
+      const exp = String(s.expected).padStart(4);
+      const opn = String(s.opened).padStart(5);
+      const rec = fmtMetric(s.recall).padStart(7);
+      const prec = fmtMetric(s.precision).padStart(10);
+      const split = s.flagged ? `SPLIT (${s.splitPlan.references.length} refs)` : 'ok';
+      return `${name} ${tok} ${exp} ${opn} ${rec} ${prec}  ${split}`;
+    }),
+  ];
+
+  if (flagged.length > 0) {
+    lines.push('', `SPLIT PLANS (${flagged.length} over ${BODY_TOKEN_BUDGET} tokens)`);
+    for (const s of flagged) {
+      const refs = s.splitPlan.references.map((r) => `${r.path} (~${r.tokens}t)`).join(', ');
+      lines.push(
+        `  ${s.name.padEnd(26)} ~${s.tokens}t (${s.bytes} B) -> SKILL.md (~${s.splitPlan.mainTokens}t) + ${s.splitPlan.references.length} ref(s): ${refs}`,
+      );
+    }
+  }
+
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}
+
+async function runSingleSkillCompile(skill, registry, { root, workspaceRoot, flags }) {
+  const mode = writeMode(flags);
+  const [rawText, runs, goldPathsByTask] = await Promise.all([
+    readSkillRawText(skill, workspaceRoot, root),
+    loadRunRecords(root),
+    loadGoldPathsByTask(root),
+  ]);
+
+  const bodiesBySkill = new Map();
+  if (rawText) bodiesBySkill.set(skill.name, rawText);
+
+  const triggerReport = evaluateSkillTriggers(registry, runs, { bodiesBySkill, goldPathsByTask });
+  const triggerStats = triggerReport.skills.find((s) => s.name === skill.name) ?? null;
+  const compiled = compileSkill(skill, rawText);
+  const proposal = await proposeSkillDescription(skill, {
+    currentDescription: compiled.description,
+    triggerStats,
+  });
+
+  const outDir = join(root, STATE_DIR, 'compiled', 'skills', skill.name);
+  const proposalPath = join(root, STATE_DIR, 'proposals', 'skills', `${skill.name}.json`);
+  const writtenFiles = [];
+
+  if (mode.apply) {
+    await mkdir(outDir, { recursive: true });
+    await writeFile(join(outDir, 'SKILL.md'), compiled.mainText, 'utf8');
+    writtenFiles.push(`${STATE_DIR}/compiled/skills/${skill.name}/SKILL.md`);
+
+    for (const ref of compiled.references) {
+      if (!ref.content) continue;
+      const refFull = join(outDir, ref.path);
+      await mkdir(dirname(refFull), { recursive: true });
+      await writeFile(refFull, ref.content, 'utf8');
+      writtenFiles.push(`${STATE_DIR}/compiled/skills/${skill.name}/${ref.path}`);
+    }
+
+    await mkdir(dirname(proposalPath), { recursive: true });
+    await writeFile(proposalPath, `${JSON.stringify(proposal, null, 2)}\n`, 'utf8');
+    writtenFiles.push(`${STATE_DIR}/proposals/skills/${skill.name}.json`);
+  }
+
+  if (isJson(flags)) {
+    emitJson(
+      {
+        ok: true,
+        command: 'skills compile',
+        root,
+        skill: skill.name,
+        dryRun: mode.dryRun,
+        written: mode.apply,
+        files: writtenFiles,
+        description: compiled.description,
+        mainBytes: compiled.mainBytes,
+        mainTokens: compiled.mainTokens,
+        conformance: compiled.conformance,
+        splitPlan: compiled.splitPlan,
+        trigger: triggerStats
+          ? {
+              expected: triggerStats.expected,
+              opened: triggerStats.opened,
+              tp: triggerStats.tp,
+              fp: triggerStats.fp,
+              fn: triggerStats.fn,
+              recall: triggerStats.recall,
+              precision: triggerStats.precision,
+            }
+          : null,
+        proposal,
+      },
+      { maxBytes: flags.maxBytes ?? 0 },
+    );
+    return EXIT.OK;
+  }
+
+  const lines = [
+    `compile     ${skill.name}`,
+    `mode        ${mode.apply ? 'applied' : mode.dryRun ? 'dry-run (writes nothing)' : `preview (pass --yes to write compiled skill)`}`,
+    `source      ${rawText ? 'body on disk' : 'registry metadata'}`,
+    `tokens      ~${compiled.splitPlan.totalTokens} (${compiled.splitPlan.totalBytes} bytes)`,
+    `split       ${compiled.splitPlan.flagged ? `flagged (${compiled.splitPlan.reason}) -> SKILL.md (~${compiled.splitPlan.mainTokens}t) + ${compiled.splitPlan.references.length} reference(s)` : 'within 5000-token budget'}`,
+    `conformance ${compiled.conformance.errors.length === 0 ? 'pass' : `fail (${compiled.conformance.errors.length})`}`,
+    `trigger     expected=${triggerStats?.expected ?? 0}  opened=${triggerStats?.opened ?? 0}  recall=${fmtMetric(triggerStats?.recall)}  precision=${fmtMetric(triggerStats?.precision)}`,
+    `proposal    ${proposal.provenance.model} (${proposal.provenance.digest})`,
+  ];
+
+  if (compiled.splitPlan.references.length > 0) {
+    lines.push('', 'REFERENCES');
+    for (const ref of compiled.splitPlan.references) {
+      lines.push(`  ${ref.path.padEnd(36)} ~${String(ref.tokens).padStart(5)}t  (${ref.bytes} B)  ${ref.title}`);
+    }
+  }
+
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  if (!mode.apply) {
+    note(`note    dry-run  nothing written; apply with: ${CLI} skills compile ${skill.name} --yes`);
+  }
+  return EXIT.OK;
+}

package/src/commands/sync.mjs

@@ -30,6 +30,8 @@ import { assertVersionPin, packageVersion } from '../package-version.mjs';
 import { resolvePacks } from '../packs.mjs';
 import { computeLock, readLock, LOCK_FILE } from '../projection/lock.mjs';
 import { runDeclaredChecks } from '../kernel/checks.mjs';
+import { DECISIONS_DIR } from '../decisions/index.mjs';
+import { lintDecisions } from '../memory/decide.mjs';
 
 /** Findings `sync` reports and does not fail on.
  *
@@ -528,6 +530,19 @@ export async function checkCommand(positional, flags) {  const root = flags.root
   const { selected } = select(rules.filter((r) => r.error === null), fp.stack ?? [], fp.facts ?? []);
   findings.push(...(await runDeclaredChecks(root, selected, manifest ?? null)));
 
+  const decisionsDir = join(root, 'docs', 'decisions');
+  const decisionLint = await lintDecisions(decisionsDir, {
+    allowHistorical: resolve(decisionsDir) === DECISIONS_DIR,
+  });
+  findings.push(
+    ...decisionLint.findings.map((f) => ({
+      file: ['docs', 'decisions', f.file].join('/'),
+      status: f.status,
+      detail: f.detail,
+      remedy: f.remedy,
+    })),
+  );
+
   // `CHECK_NON_BLOCKING`, not the union. This is the gate whose exit code a repository
   // acts on, so a finding it reports and does not fail on is a decision recorded in a
   // set — not one inherited from the writer that shares this file (ADR-051).

package/src/commands/tests.mjs

@@ -13,17 +13,11 @@ import { promisify } from 'node:util';
 import { EXIT, emit, emitJson, fail, isJson } from '../output/index.mjs';
 import { CLI } from '../name.mjs';
 import { isTestPath } from '../bench/mine.mjs';
-import { readEdges, readFiles, reindex } from '../index/store.mjs';
+import { blobTexts, langOf, readEdges, readFiles, reindex } from '../index/store.mjs';
 import { HISTORY, importsOf, parseCoverage, testEdges, testsFor } from '../index/tests.mjs';
 
 const exec = promisify(execFile);
 
-const LANG = {
-  js: 'javascript', mjs: 'javascript', cjs: 'javascript', jsx: 'javascript',
-  ts: 'typescript', tsx: 'typescript', kt: 'kotlin', kts: 'kotlin', java: 'java',
-  py: 'python', go: 'go', rs: 'rust', swift: 'swift', dart: 'dart', rb: 'ruby', cs: 'csharp',
-};
-
 const COVERAGE_PATHS = [
   'coverage/lcov.info',
   'lcov.info',
@@ -112,7 +106,7 @@ async function testBlobs(root, files) {
   for (const file of files) {
     if (isTestPath(file.path) && file.blob) blobs.push(file.blob);
   }
-  return cat(root, blobs);
+  return blobTexts(root, blobs).catch(() => new Map());
 }
 
 async function coverageTexts(root) {
@@ -149,44 +143,3 @@ async function history(root) {
   }
   return commits;
 }
-
-async function cat(root, blobs) {
-  const unique = [...new Set(blobs)];
-  const texts = new Map();
-  if (unique.length === 0) return texts;
-  const body = await batch(root, unique);
-  let offset = 0;
-  while (offset < body.length) {
-    const nl = body.indexOf(0x0a, offset);
-    if (nl < 0) break;
-    const header = body.toString('utf8', offset, nl);
-    const parts = header.split(' ');
-    const size = Number(parts[2]);
-    if (parts[1] !== 'blob' || !Number.isFinite(size)) {
-      offset = nl + 1;
-      continue;
-    }
-    const start = nl + 1;
-    const bytes = body.subarray(start, start + size);
-    offset = start + size + 1;
-    texts.set(parts[0], bytes.includes(0) ? null : bytes.toString('utf8'));
-  }
-  return texts;
-}
-
-function batch(root, blobs) {
-  return new Promise((resolve) => {
-    const child = execFile('git', ['cat-file', '--batch'], { cwd: root, maxBuffer: 32 << 20, encoding: 'buffer' }, (error, stdout) => {
-      resolve(error ? Buffer.alloc(0) : stdout);
-    });
-    child.stdin.write(`${blobs.join('\n')}\n`);
-    child.stdin.end();
-  });
-}
-
-function langOf(path) {
-  const base = path.slice(path.lastIndexOf('/') + 1);
-  const dot = base.lastIndexOf('.');
-  if (dot <= 0) return '';
-  return LANG[base.slice(dot + 1)] ?? '';
-}

package/src/commands/why.mjs

@@ -15,13 +15,14 @@ import { CLI, MANIFEST_FILE } from '../name.mjs';
 import { FORMATTABLE, GATES } from '../hooks/gates.mjs';
 import {
   decisionHits,
-  lessonPaths,
   scopeHits,
   scopePaths,
   sortHits,
   sourceRoots,
   unresolvedAffects,
 } from '../index/govern.mjs';
+import { splitFrontmatter } from '../memory/decide.mjs';
+import { listPromotedLessons } from '../memory/lessons.mjs';
 
 const exec = promisify(execFile);
 
@@ -62,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) };
@@ -81,22 +84,24 @@ export async function decisionRecords(root) {
   const dir = join(root, 'docs', 'decisions');
   let names = [];
   try {
-    names = (await readdir(dir)).filter((name) => /^ADR-\d{3}-.*\.md$/.test(name)).sort();
+    names = (await readdir(dir)).filter((name) => /^ADR-\d{3,}-.*\.md$/i.test(name)).sort();
   } catch {
     return [];
   }
   const records = [];
   for (const name of names) {
     const text = await readFile(join(dir, name), 'utf8');
-    const id = /^ADR-\d{3}/.exec(name)[0];
-    const heading = /^#\s+(.*)$/m.exec(text)?.[1] ?? id;
-    const title = heading.replace(/^ADR-\d{3}\s+[—–-]\s+/, '');
+    const { body } = splitFrontmatter(text);
+    const id = /^ADR-\d{3,}/i.exec(name)[0].toUpperCase();
+    const heading = /^#\s+(.*)$/m.exec(body)?.[1] ?? id;
+    const title = heading.replace(/^ADR-\d{3,}\s*[—–-]\s*/i, '').trim();
     records.push({ id, title, text });
   }
   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),
@@ -146,24 +151,17 @@ async function skillScopes(root) {
     .map((skill) => ({ id: String(skill.name ?? ''), detail: String(skill.summary ?? ''), paths: skill.paths }));
 }
 
-async function lessonScopes(root) {
-  const dir = join(root, 'docs', 'lessons');
-  let names = [];
-  try {
-    names = (await readdir(dir)).filter((name) => name.endsWith('.md')).sort();
-  } catch {
-    return [];
-  }
-  const lessons = [];
-  for (const name of names) {
-    const text = await readFile(join(dir, name), 'utf8');
-    const paths = lessonPaths(text);
-    if (paths.length === 0) continue;
-    const id = name.replace(/\.md$/, '');
-    const detail = /^#\s+(.*)$/m.exec(text)?.[1] ?? id;
-    lessons.push({ id, detail, paths });
-  }
-  return lessons;
+export async function lessonScopes(root) {
+  return (await listPromotedLessons(root))
+    .filter((lesson) => lesson.paths.length > 0)
+    .map((lesson) => ({
+      id: lesson.id,
+      detail: lesson.title,
+      paragraph: lesson.paragraph,
+      paths: lesson.paths,
+      signature: lesson.signature,
+      keywords: lesson.keywords,
+    }));
 }
 
 async function gateCommands(root) {