simt-dev 0.6.3 → 0.7.0

package/src/projection/project.mjs

@@ -16,7 +16,8 @@
 // same matcher, so supporting an ecosystem nobody here has heard of requires no
 // code change and no release.
 
-import { readFile, readdir } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+import { access, readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 
 import { baselineTargets, misplaced } from './baselines.mjs';
@@ -31,8 +32,75 @@ import { measureRoot } from '../measure/context.mjs';
 import { loadMdcRules, renderMdc } from './mdc.mjs';
 import { foldsRules, resolveSurfaces, SURFACES, SURFACE_IDS } from './surfaces.mjs';
 import { pointerState, pointerTargets, ruleTargets, scopedTargets } from './targets.mjs';
-import { CLI } from '../name.mjs';
-import { MANIFEST_FILE } from '../name.mjs';
+import { CLI, LOCK_FILE, LOCK_LEGACY, PACKAGE_NAME } from '../name.mjs';
+import { MANIFEST_FILE, WORKFLOW_FILE_NAME } from '../name.mjs';
+import { resolveNodeRunner } from '../ecosystem/node-runner.mjs';
+import { LOCAL_BIN } from '../distribute/release.mjs';
+
+/**
+ * A checked-in gate workflow the locator cannot resolve (review 0003 Q31).
+ *
+ * Returns a finding, or null when some resolution path can still succeed. Only
+ * committed evidence counts: the pinned devDependency, the release binary, and
+ * `simt` on this machine's PATH (a global install CI may share — its presence
+ * here is a reason to stay silent, its absence is not proof CI lacks it, so the
+ * finding also requires the first two to be missing).
+ */
+async function workflowResolvable(root) {
+  let pkg = null;
+  try {
+    pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+  } catch {
+    pkg = null;
+  }
+  if (pkg !== null) {
+    const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+    if (Object.hasOwn(deps, PACKAGE_NAME)) return null;
+  }
+  try {
+    await stat(join(root, LOCAL_BIN));
+    return null;
+  } catch {
+    // No release binary: keep checking the last path.
+  }
+  for (const dir of (process.env.PATH ?? '').split(':').filter(Boolean)) {
+    try {
+      await access(join(dir, 'simt'), fsConstants.X_OK);
+      return null;
+    } catch {
+      // Not here; keep looking.
+    }
+  }
+  const file = `.github/workflows/${WORKFLOW_FILE_NAME}`;
+  if (pkg !== null) {
+    const lockfiles = [];
+    for (const name of ['pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb', 'package-lock.json']) {
+      try {
+        await stat(join(root, name));
+        lockfiles.push(name);
+      } catch {
+        // Absent is the normal case.
+      }
+    }
+    const runner = resolveNodeRunner({
+      lockfiles,
+      packageManager: typeof pkg.packageManager === 'string' ? pkg.packageManager : null,
+    });
+    return {
+      file,
+      status: 'unresolvable',
+      detail: `the checked-in gate workflow looks for ${PACKAGE_NAME} in node_modules, but nothing it tries can succeed: no pinned devDependency, no ${LOCAL_BIN}, no simt on PATH`,
+      remedy: `run: ${runner.addDev} ${PACKAGE_NAME}   (the gate runs from the pinned dependency)`,
+    };
+  }
+  return {
+    file,
+    status: 'unresolvable',
+    detail: `the checked-in gate workflow cannot resolve ${PACKAGE_NAME}: no package.json to pin it in, no ${LOCAL_BIN}, no simt on PATH`,
+    remedy: `install the pinned gate binary into the repository, then re-run: simt init --yes`,
+  };
+}
+import { computeLock } from './lock.mjs';
 import {
   desiredRegion,
   provenanceDigest,
@@ -53,6 +121,16 @@ import {
  *  most agents, including ones that ignore .cursor/ entirely. */
 export const PRIMARY_TARGET = 'AGENTS.md';
 
+/** The gate's verdict on a region `sync` has already written. `current` rows carry
+ *  `detail: null`, not `undefined`: a key whose value is `undefined` survives into the
+ *  structured MCP surface but is dropped by `JSON.stringify`, so the two surfaces of one
+ *  answer no longer deep-equal. */
+function regionVerdict(action) {
+  return action === 'unchanged'
+    ? { status: 'current', detail: null }
+    : { status: 'drift', detail: `region is ${action}; run: ${CLI} sync --yes` };
+}
+
 
 /**
  * @param {string} root repo root
@@ -62,7 +140,7 @@ export const PRIMARY_TARGET = 'AGENTS.md';
 export async function plan(root, flags = {}) {
   const desired = await desiredRegion(root, flags);
   const { stack, facts, profiles, fallback, notes, body, meta, all, manifest } = desired;
-  const target = await targetFor(root, body, meta);
+  const target = await targetFor(root, root, body, meta);
 
   // Per-rule content projects to every editor the repo selected, not only Cursor. The
   // body is identical on each; only the frontmatter the editor reads before any rule
@@ -94,9 +172,39 @@ export async function plan(root, flags = {}) {
   // root's would read as though the packages were the repository.
   const packages = await packageRegions(root, flags, profiles);
   const nested = await Promise.all(
-    packages.regions.map((r) => targetFor(join(root, r.path), r.body, r.meta, `${r.path}/${PRIMARY_TARGET}`)),
+    packages.regions.map((r) => targetFor(root, join(root, r.path), r.body, r.meta, `${r.path}/${PRIMARY_TARGET}`)),
   );
 
+  // The lock records the two digests a frozen check compares (ADR-086). It is a target
+  // like every other: `plan` produces it, so preview, `--diff`, the journal, the idle
+  // test and `init` all inherit it. Computing it here rather than in `sync` is what makes
+  // a deleted lock show up in the plan as a write instead of vanishing from it — the
+  // `sync` that printed "wrote simt-dev.lock.json" and then "nothing written" (Q29).
+  const lock = await computeLock(root, flags);
+  const lockText = `${JSON.stringify(lock, null, 2)}\n`;
+  let previousLockText = '';
+  let lockExists = false;
+  for (const name of [LOCK_FILE, LOCK_LEGACY]) {
+    try {
+      previousLockText = await readFile(join(root, name), 'utf8');
+      lockExists = true;
+      break;
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+    }
+  }
+  const lockTarget = {
+    file: LOCK_FILE,
+    path: join(root, LOCK_FILE),
+    kind: 'lock',
+    surface: null,
+    exists: lockExists,
+    action: !lockExists ? 'create' : previousLockText === lockText ? 'unchanged' : 'update',
+    bytes: Buffer.byteLength(lockText),
+    previousBytes: Buffer.byteLength(previousLockText),
+    text: lockText,
+  };
+
   return {
     root,
     stack,
@@ -107,15 +215,25 @@ export async function plan(root, flags = {}) {
     surfaceSource: surfaces.source,
     surfaceProblems: surfaces.problems,
     rules: all,
-    targets: [target, ...nested, ...mdc.targets, ...scoped.targets, ...baselines.targets],
+    targets: [target, ...nested, ...mdc.targets, ...scoped.targets, ...baselines.targets, lockTarget],
     packages: packages.regions.map((r) => ({ path: r.path, profiles: r.profiles })),
     mdcProblems: mdc.problems,
+    crossRefs: desired.crossRefs,
     notes: [...notes, ...mdc.notes, ...packages.notes],
   };
 }
 
-async function targetFor(root, body, meta, label = PRIMARY_TARGET) {
-  const path = join(root, PRIMARY_TARGET);
+/**
+ * Build the write target for one AGENTS.md. `root` is the repository: `regionOpts`
+ * reads its manifest, because placement is a repository-level decision that holds for
+ * every package's region too. `dir` is where the file lives, which differs from
+ * `root` only for a nested monorepo package (review 0003 Q26).
+ *
+ * @param {string} root repo root
+ * @param {string} dir directory the target file lives in
+ */
+async function targetFor(root, dir, body, meta, label = PRIMARY_TARGET) {
+  const path = join(dir, PRIMARY_TARGET);
   let existing = '';
   let exists = true;
   try {
@@ -186,8 +304,24 @@ export async function checkTargets(root, flags = {}) {
   // Two `.github` files, one ownership rule, so one loop over both. The gate and the
   // dependency-updates config fail for the same reason and are fixed the same way,
   // and listing them separately is how the second copy of this rule gets written.
+  const workflowPlan = await planWorkflow(root);
+  // Q31: a workflow that exists but cannot resolve simt-dev by any path the
+  // locator tries is a green tick on a gate that never runs. The locator tries
+  // `$SIMT_DEV_BIN`, the pinned devDependency, the release binary and `simt`
+  // on PATH, in that order; only the middle two are committed evidence this
+  // check can see. When the repo pins nothing and carries no binary, the check
+  // can still see `simt` on its own PATH — a global install CI may share — so
+  // it stays silent then rather than crying wolf about a resolution it cannot
+  // disprove. The remedy names the repo's own manager, never a bare npm guess.
+  // simt-dev's own copy is exempt: it runs this checkout directly and never asks the
+  // locator to find a binary, so a machine without `simt` on PATH is not evidence that
+  // the gate cannot start. The consumer copy is not exempt, because its locator does.
+  if (!workflowPlan.own && workflowPlan.action !== 'create' && workflowPlan.action !== 'skip') {
+    const unresolvable = await workflowResolvable(root);
+    if (unresolvable) findings.push(unresolvable);
+  }
   for (const [plan, what] of [
-    [await planWorkflow(root), 'nothing gates it'],
+    [workflowPlan, 'nothing gates it'],
     [await planDependabot(root), 'nothing watches its dependencies'],
   ]) {
     if (plan.action === 'create') {
@@ -258,7 +392,20 @@ export async function checkTargets(root, flags = {}) {
   for (const p of resolved.problems) {
     findings.push({ file: `${MANIFEST_FILE}`, status: 'invalid', detail: p, remedy: `known surfaces: ${SURFACE_IDS.join(', ')}` });
   }
-  const rules = all.filter((r) => isEligible(r, new Set([...stack, ...facts]), declared.optIn));
+  const signals = new Set([...stack, ...facts]);
+  const rules = all.filter((r) => isEligible(r, signals, declared.optIn));
+
+  // A dangling cross-reference is a rule-text defect: the region renders, but it points
+  // the reader at a profile they cannot reach. A gate failure, like any other rule defect.
+  for (const p of desired.crossRefs ?? []) {
+    const idx = p.indexOf(': ');
+    findings.push({
+      file: p.slice(0, idx),
+      status: 'invalid',
+      detail: p.slice(idx + 2),
+      remedy: `co-select the profile, or name it with ${CLI} rules show <id>`,
+    });
+  }
 
   const sha = await provenanceDigest();
   const notes = [];
@@ -286,8 +433,7 @@ export async function checkTargets(root, flags = {}) {
       findings.push({
         file: target.file,
         surface: target.surface,
-        status: action === 'unchanged' ? 'current' : 'drift',
-        detail: action === 'unchanged' ? undefined : `region is ${action}; run: ${CLI} sync --yes`,
+        ...regionVerdict(action),
         recordedSha: parse(target.previous).sha ?? null,
       });
     }
@@ -308,6 +454,7 @@ export async function checkTargets(root, flags = {}) {
     const { body, problems } = renderMdc(
       rule,
       ruleValues(rule, declared.values[rule.id] ?? {}, resolved.surfaces),
+      signals,
     );
     if (problems.length > 0) {
       findings.push({
@@ -359,8 +506,7 @@ export async function checkTargets(root, flags = {}) {
       findings.push({
         file: rel,
         surface: target.surface,
-        status: action === 'unchanged' ? 'current' : 'drift',
-        detail: action === 'unchanged' ? undefined : `region is ${action}; run: ${CLI} sync --yes`,
+        ...regionVerdict(action),
         recordedSha: state.sha ?? null,
       });
     }
@@ -395,8 +541,7 @@ export async function checkTargets(root, flags = {}) {
     }
     findings.push({
       file: t.file,
-      status: t.action === 'unchanged' ? 'current' : 'drift',
-      detail: t.action === 'unchanged' ? undefined : `region is ${t.action}; run: ${CLI} sync --yes`,
+      ...regionVerdict(t.action),
       recordedSha: state.sha ?? null,
     });
     const off = misplaced(state, t.style);
@@ -566,8 +711,7 @@ async function checkRegion(root, dir, body, meta) {
   const d = diff(existing, body, meta, await regionOpts(root));
   return {
     file: PRIMARY_TARGET,
-    status: d.action === 'unchanged' ? 'current' : 'drift',
-    detail: d.action === 'unchanged' ? undefined : `region is ${d.action}; run: ${CLI} sync --yes`,
+    ...regionVerdict(d.action),
     recordedSha: state.sha ?? null,
     expectedSha: meta.sha,
   };

package/src/projection/rules.mjs

@@ -37,7 +37,7 @@ import { filterInferable, inferableDefect, inferableProofs } from '../kernel/inf
 import { checkDefect, foldChecks } from '../kernel/checks.mjs';
 import { foldVariants, readLockedVariants, variantsDefect } from '../kernel/variants.mjs';
 import { BASELINES } from './baselines.mjs';
-import { CLI } from '../name.mjs';
+import { CLI, MANIFEST_FILE } from '../name.mjs';
 import { installedSkills } from './disclosure.mjs';
 import { PACK_DIR, resolvePacks } from '../packs.mjs';
 import { discoverPackages } from '../monorepo.mjs';
@@ -134,6 +134,10 @@ export async function provenanceInputs() {
 async function walk(dir, prefix = '') {
   const out = [];
   for (const entry of await readdir(dir, { withFileTypes: true })) {
+    // A dotfile is machine noise (.DS_Store on macOS), not rule content: the digest
+    // must be stable across checkouts, and a fresh worktree does not carry the
+    // author's Finder metadata. Rule files are .md/.mdc, never dotfiles.
+    if (entry.name.startsWith('.')) continue;
     const rel = prefix === '' ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) out.push(...(await walk(join(dir, entry.name), rel)));
     else if (entry.isFile()) out.push(rel);
@@ -282,8 +286,11 @@ export async function mdcTargets(root, sha, manifest, flags) {
   // same `bodies` from the same call, so the region and the files cannot disagree.
   if (foldsRules(resolved) && !resolved.surfaces.some((s) => s.rule)) {
     if (bodies.length > 0) {
+      // An empty selection has no row to read the primary from; the document is the
+      // one the region lives in, which is the answer in every case this note fires.
+      const primary = resolved.surfaces[0]?.primary ?? 'AGENTS.md';
       notes.push(
-        `every rule is folded into ${resolved.surfaces[0].primary}; add a surface with its own rule path for a file per rule`,
+        `every rule is folded into ${primary}; add a surface with its own rule path for a file per rule`,
       );
     }
     return { targets, problems, notes };
@@ -411,6 +418,7 @@ async function ruleBodies(root, manifest, flags) {
     const { body, problems: renderProblems } = renderMdc(
       rule,
       ruleValues(rule, declared.values[rule.id] ?? {}, resolved.surfaces),
+      signals,
     );
     for (const p of renderProblems) problems.push(`${rule.file}: ${p}`);
     if (renderProblems.length > 0) continue;
@@ -558,6 +566,16 @@ export async function desiredRegion(root, flags) {
     for (const x of filtered.removed) inferable.push({ rule: r.id, text: x.text, expr: x.expr });
     shipped.push({ ...r, body: folded.body });
   }
+  // A body that points the reader at a profile they cannot reach is a rule-text defect:
+  // the region renders, but the reference dangles. Kept out of `problems` because that
+  // array is the mdc list `sync` already reports, and one fault must not print twice.
+  const crossRefs = [];
+  const selectedIds = new Set(selected.map((r) => r.id));
+  for (const r of shipped) {
+    for (const p of crossRefProblems(r.body, all, selectedIds)) {
+      crossRefs.push(`${r.id}: ${p}`);
+    }
+  }
   const lockedNonDefault = variantsSelected.filter((v) => v.locked && v.winner !== v.baseline);
   if (lockedNonDefault.length > 0) {
     notes.push(
@@ -906,6 +924,7 @@ export async function desiredRegion(root, flags) {
     surfaces: resolved.ids,
     surfaceSource: resolved.source,
     problems,
+    crossRefs,
     fallback,
     notes,
     body: assembled.body,
@@ -1301,9 +1320,13 @@ export function byPriorityThenId(a, b) {
  * `Applies to` is already the first line of a stack profile once its H1 is gone,
  * so it lands directly under `## Stack: …` instead of under whatever section the
  * previous source ended on.
+ *
+ * The rule text names the manifest with a `{manifest}` token and the render
+ * substitutes it, so a rename of the file is a change in one place (MANIFEST_FILE),
+ * not a search across every rule body.
  */
 function frameSource(rule, body, kind) {
-  const text = demoteHeadings(body).trim();
+  const text = demoteHeadings(body.replaceAll('{manifest}', MANIFEST_FILE)).trim();
   if (!text) return '';
   const title = sourceTitle(rule, kind);
   if (!title) return text;
@@ -1317,6 +1340,34 @@ function sourceTitle(rule, kind) {
   return `Stack: ${rule.id}`;
 }
 
+/**
+ * A body may point the reader at another profile in two ways: naming a profile
+ * that is selected alongside it, or giving the command to fetch one
+ * (`simt rules show <id>`). A reference that is neither is one the reader of
+ * the projected region cannot follow. Both citation forms are checked: the
+ * backtick-quoted `<id> profile` in prose, and the `simt rules show <id>`
+ * command itself - an id that form names must exist, or the command 404s.
+ */
+function crossRefProblems(body, all, selectedIds) {
+  const problems = [];
+  const seen = new Set();
+  for (const m of String(body).matchAll(/`([a-z0-9][a-z0-9-]*)`\s+profile|rules show ([a-z0-9][a-z0-9-]*)/g)) {
+    const id = m[1] ?? m[2];
+    if (seen.has(id)) continue;
+    seen.add(id);
+    if (!all.some((r) => r.id === id)) {
+      problems.push(`cross-reference: body cites the \`${id}\` profile, which is not a declared rule`);
+      continue;
+    }
+    if (!selectedIds.has(id) && !new RegExp(`${CLI} rules show ${id}`).test(body)) {
+      problems.push(
+        `cross-reference: body cites the \`${id}\` profile, which is neither co-selected nor reachable via \`${CLI} rules show ${id}\``,
+      );
+    }
+  }
+  return problems;
+}
+
 /** `##` becomes `###`. A fence is left alone: a heading in an example is an example. */
 function demoteHeadings(text) {
   let fence = false;

package/src/projection/surfaces.mjs

@@ -327,12 +327,20 @@ export const DEFAULT_SURFACES = ['opencode'];
  * Cursor reader gets them as `.mdc`. Folding and per-rule files therefore coexist,
  * and `ruleTargets` already skips a surface that has no rule path.
  *
+ * An empty selection folds too: with no surface carrying a rule path, the region is
+ * the only channel a rule has, and the old answer (no surface folds, so nothing
+ * folds) wrote every process rule nowhere while `check` reported current (review
+ * 0003 Q27).
+ *
  * Asked in exactly two places that must agree: `desiredRegion` folds the bodies in,
  * and `mdcTargets` writes the files. Asking it twice is how ADR-020's fold decision
  * could drift between the writer and the gate, which is the step-6 failure.
  */
 export function foldsRules(resolved) {
-  return resolved.surfaces.some((s) => s.foldRules === true);
+  if (resolved.surfaces.length === 0) return true;
+  // A surface with no rule path has no per-rule channel, so its rules must be in the
+  // region; `foldRules` is that fact recorded on the row.
+  return resolved.surfaces.some((s) => s.foldRules === true || !s.rule);
 }
 
 /**

package/src/repo-root.mjs

@@ -0,0 +1,69 @@
+// The repository root a working directory belongs to, for the hook path.
+//
+// A payload's `cwd` is the directory the harness happens to be in, and a harness
+// happens to be in subdirectories: an agent that was told to work in `src/` edits
+// from there, and every repository-relative comparison that resolves against the
+// payload's cwd — the lease file, `.gitmodules`, the manifest — compares against
+// the wrong root and silently stops matching (review 0003 Q16). The root this
+// module answers is the one git itself would use, so a lease taken at the top
+// level matches an edit made three directories down.
+//
+// The answer is synchronous because the caller is a hook on the hot path: one
+// `git rev-parse` is cheaper than the repository walk the fallback would do in
+// the common case, and the fallback only pays when git cannot answer at all —
+// a directory that is not in a repository, where the walk is short by
+// definition.
+
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+import { MANIFEST_FILE, STATE_DIR } from './name.mjs';
+
+/**
+ * The top-level directory of the repository `cwd` is in, or `cwd` itself when it
+ * is in none.
+ *
+ * The fallback looks for the two facts that mark a directory as adopted by this
+ * tool — the state directory and the manifest — and walks up, because a hook
+ * fired from a subdirectory of an adopted repository must still find it: a
+ * repository with no `.git` at all (a worktree's parent, a fresh checkout
+// before `git init` finishes) is the case the git call refuses and the walk
+ * answers.
+ */
+export function repoRoot(cwd) {
+  const start = resolve(String(cwd ?? ''));
+  const result = spawnSync('git', ['-C', start, 'rev-parse', '--show-toplevel'], {
+    encoding: 'utf8',
+    timeout: 2000,
+  });
+  if (result.status === 0) {
+    const top = String(result.stdout ?? '').trim();
+    if (top !== '') return top;
+  }
+  let dir = start;
+  for (;;) {
+    if (existsSync(join(dir, STATE_DIR)) || existsSync(join(dir, MANIFEST_FILE))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return start;
+    dir = parent;
+  }
+}
+
+/**
+ * Whether git on this repository compares paths case-insensitively, which is
+ * the one filesystem fact a path comparison must honour: on a case-insensitive
+ * volume `NB.ipynb` and `nb.ipynb` are the file, and a comparison that spells
+ * them differently is a comparison that misses.
+ *
+ * A git that cannot answer (no repository, no binary) answers `false`, which is
+ * the strict spelling: the two case variants are then treated as distinct, the
+// way they are on the filesystem the comparison is being done for.
+ */
+export function coreIgnoreCase(root) {
+  const result = spawnSync('git', ['-C', root, 'config', '--get', 'core.ignorecase'], {
+    encoding: 'utf8',
+    timeout: 1000,
+  });
+  return result.status === 0 && String(result.stdout ?? '').trim().toLowerCase() === 'true';
+}

package/src/resolve/body.mjs

@@ -22,6 +22,10 @@ import { existsSync } from 'node:fs';
 import { locateSource, sourceHeldLocally } from './source.mjs';
 
 export async function sourcePath(skill, workspaceRoot, root) {
+  // A node synthesized from the repo's own skill directory already names its file.
+  // Asking the workspace for it would hunt for a body the registry never declared.
+  if (skill.localFile) return skill.localFile;
+
   const canonical = skill.sources?.find((s) => s.role === 'canonical') ?? skill.sources?.[0];
 
   if (canonical) {

package/src/resolve/fingerprint.mjs

@@ -180,6 +180,11 @@ const FACTS = [
   { name: 'has-mix', kind: 'file', paths: ['mix.exs'] },
   { name: 'has-deno-config', kind: 'file', paths: ['deno.json', 'deno.jsonc'] },
   { name: 'has-bun-lock', kind: 'file', paths: ['bun.lock', 'bun.lockb'] },
+  // Q31: one fact per Node lockfile, so the runner resolver, the card, the gate
+  // seeds and CI all read the same committed evidence instead of assuming npm.
+  { name: 'has-pnpm-lock', kind: 'file', paths: ['pnpm-lock.yaml'] },
+  { name: 'has-yarn-lock', kind: 'file', paths: ['yarn.lock'] },
+  { name: 'has-package-lock', kind: 'file', paths: ['package-lock.json'] },
   // A glob walk skips dot directories, and `.devcontainer` is one. Stat the path.
   { name: 'has-devcontainer', kind: 'path', paths: ['.devcontainer/devcontainer.json'] },
 ];

package/src/resolve/local.mjs

@@ -0,0 +1,58 @@
+// Repo-local skills as resolver nodes.
+//
+// The registry is what simt-dev ships; the skill directories a repo holds are what
+// that repo owns. After plan 0005 S2 the registry is small and generic, so a skill
+// that lives only in a repo was invisible to `skills find` and `skills brief`, and
+// the NOT SELECTED block points a reader at `skills show` by name - a remedy that
+// 404s for a name the registry does not declare.
+//
+// Presence in the repo's skill directory is the eligibility signal: a skill the repo
+// installed is about the repo, and the stack it belongs to is the stack the repo has.
+// The node's `stack` is therefore the repo's own signals, which makes the stack gate
+// a self-overlap that always passes, and the stack score reads "more this repo's"
+// rather than "compatible with a stranger".
+
+import { stat } from 'node:fs/promises';
+
+import { BODY_BYTE_BUDGET } from '../graph/compile.mjs';
+import { installedSkills } from '../projection/disclosure.mjs';
+
+/**
+ * The repo's own skills, as nodes the resolver can rank.
+ *
+ * Names the registry declares are excluded: the registry entry is canonical and the
+ * local file is its installed copy, so keeping both would rank one skill twice.
+ *
+ * @param {string} root the repository
+ * @param {object} registry the loaded registry
+ * @param {string[]} repoStack the repo's signals (stack ∪ facts)
+ * @returns {Promise<object[]>} resolver-ready nodes, name-sorted
+ */
+export async function localSkillNodes(root, registry, repoStack) {
+  const installed = await installedSkills(root);
+  const known = new Set(registry.skills.map((s) => s.name));
+  const nodes = [];
+  for (const { name, trigger, file } of installed) {
+    if (known.has(name)) continue;
+    let size;
+    try {
+      size = (await stat(file)).size;
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      continue; // gone between listing and measuring
+    }
+    nodes.push({
+      name,
+      summary: trigger,
+      keywords: [],
+      capabilities: [],
+      stack: [...repoStack],
+      paths: [],
+      bytes: size,
+      deferred: size > BODY_BYTE_BUDGET,
+      localFile: file,
+    });
+  }
+  nodes.sort((a, b) => a.name.localeCompare(b.name));
+  return nodes;
+}

package/src/review/critic.mjs

@@ -32,9 +32,11 @@ import { digestOf, promptHash, proposalFrontmatter } from '../distill/engine.mjs
 
 const exec = promisify(execFile);
 
-// Locked on-disk beneath `.simt`, like `.simt/distilled` (R38) — a cache of
+import { LOCAL_DIR } from '../state.mjs';
+
+// Locked on-disk beneath machine-local state, like the distilled cache (R38) —
 // proposals keyed by content digest, never projected and never committed.
-const REVIEW_DIR = '.simt/reviews';
+const REVIEW_DIR = join(LOCAL_DIR, 'reviews');
 const ENGINE_REVIEW_LOCAL = 'review-local';
 
 /** The diff brief's byte cap; `--budget` overrides it, `0` means unlimited. */