simt-dev 0.6.2 → 0.7.0

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/shared.mjs

@@ -307,7 +307,10 @@ export async function sharedState(path, rules, meta) {
  * user-level AGENTS.md is the most likely file in a reader's home directory to contain
  * something they wrote themselves. Only the bytes between the markers are ours.
  */
-function injectShared(before, rules, meta) {
+// Exported so `shared install --diff` previews the same bytes the write applies:
+// a diff rendered from a second implementation of this injection would be a
+// second opinion about what "current" means (plan 0003 R50).
+export function injectShared(before, rules, meta) {
   return inject(before, sharedBody(rules), meta, { compose: composeShared });
 }
 

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. */