simt-dev 0.6.3 → 0.7.0

package/src/commands/help.mjs

@@ -47,6 +47,7 @@ ${CLI} rules list             the rule catalogue (--root marks what applies to a
 ${CLI} rules show <id>        one rule body
 ${CLI} rules why <id|ADR-NNN> the decision that settled it, and whether it is still in force
                            (--all prints every ruling, not the first two)
+${CLI} rules decisions       every known decision, shipped and repo, and which layer each came from
 ${CLI} hooks install [--yes]   install the shared dispatcher; report what it would run
                            (dry-run unless --yes; refuses to take over routing git
                             already uses, and --yes is that consent)
@@ -58,11 +59,16 @@ ${CLI} agent-hook <event>      the entry point a harness calls: pre-tool-use dec
                            (reads one JSON payload on stdin and answers in that
                             harness's dialect; exit 2 blocks; needs --harness)
 ${CLI} agent-hooks install     write this repo's policies into the harnesses that
-                            read a hooks file
+                            read a hooks file (--harness <id> writes one, not all)
                            (dry-run unless --yes; merges into the file, keeps every
                             key it does not own; Codex needs the hook trusted)
 ${CLI} agent-hooks status      what each harness will run, and what is not trusted yet
-${CLI} plugin <claude|gemini|cursor>  generate a harness package from the same tables
+${CLI} agents install          write the Simt-Agent into the harnesses that read an
+                            agents file (--harness <id> writes one, not all; dry-run
+                            unless --yes; markdown with a frontmatter the harness
+                            documents, TOML for Codex)
+${CLI} agents status           what each harness carries, and what is not installed yet
+${CLI} plugin <claude|gemini|cursor|opencode>  generate a harness package from the same tables
                            (dry-run unless --yes; writes a self-contained runtime, the
                            hooks and MCP registration, and for cursor the kernel rules;
                            the skill registry is workspace data and is not shipped)
@@ -77,17 +83,24 @@ ${CLI} plan status             count tracker rows
 ${CLI} plan next [<id>]        one ready slice's section, or the one named; ~1 KB
 ${CLI} plan done <id> [<sha>]  mark one row; dry-run unless --yes
 ${CLI} slice start <id>     give a slice its own worktree and branch, preload the
-                           brief, and mark the row In progress (dry-run unless
-                           --yes; the worktree is ${STATE_DIR}/worktrees/<id> on
-                           branch slice/<id>, the brief ${STATE_DIR}/brief.md in it)
+                           brief, and mark the row started (dry-run unless
+                           --yes; the worktree is ${STATE_DIR}/local/worktrees/<id>
+                           on branch slice/<id>, the brief ${STATE_DIR}/local/briefs/<id>.md
+                           beside it; --session <id> leases the slice)
 ${CLI} slice finish <id>    run the pre-commit gates, commit what is staged with a
                            Conventional subject from the row's title, then record
                            the SHA and the --test command on the row (dry-run
-                           unless --yes; --type picks the type, default feat)
+                           unless --yes; --type picks the type, default feat;
+                           refuses unless HEAD is the slice branch; gates the
+                           ledger already proves for this tree are not re-run)
+${CLI} slice abandon <id>   remove the worktree, delete the branch, and return
+                           the row to ready (dry-run unless --yes; refuses from
+                           inside the worktree)
 ${CLI} lease [<paths>...]    claim files for one session and a TTL, or list the
                            claims (dry-run unless --yes; the session is --session
                            <id> or ${SESSION_ENV}; a pre-edit hook refuses an edit
-                           to a path another session holds — ADR-101)
+                           to a path another session holds — ADR-101;
+                           release and renew end and extend your own claims)
 ${CLI} graph lint              check the skill registry against the skills on disk
                            (byte counts, dangling edges, unresolvable variants)
 ${CLI} ci                     simt-dev's own .github files: create or refresh them
@@ -100,7 +113,8 @@ ${CLI} ignore [--yes]         render the one .simtignore list into .cursorignore
                            Claude settings file is merged, never replaced)
 ${CLI} compare                org-wide matrix across every sibling repo
                            (read-only; exits non-zero on defects, not on
-                           repos that have not adopted yet)
+                           repos that have not adopted yet;
+                           --concurrency <n> caps the rows built at once)
 ${CLI} index                   rebuild the local file index from git blob hashes
 ${CLI} why [path]            what governs a file: a decision whose Affects line names
                            it, a rule whose scope matches it, a skill, a gate
@@ -127,8 +141,9 @@ ${CLI} pr-body [--base <ref>]  a pull request body: the evidence block for this
 ${CLI} evidence                the runs recorded against the tree on disk
 ${CLI} evidence check <file>   a commit message that claims a run this tree does not
                            have: a warning, or a block when gates.evidence is "block"
-${CLI} lessons list            deterministic lesson candidates in .simt/lessons.jsonl
-                           and promoted lessons in docs/lessons/*.md
+${CLI} lessons list            deterministic lesson candidates in .simt/local/lessons.jsonl
+                           and promoted lessons in docs/lessons/*.md (reads nothing else)
+${CLI} lessons capture         scan the ledger and git history for new candidates (the write half of list)
 ${CLI} lessons review [<id>]   promote a lesson candidate to docs/lessons/NNNN-<slug>.md
                            (dry-run unless --yes; writes Appendix A frontmatter)
 ${CLI} explain <CODE>        what a check finding means: the decision behind it, how
@@ -147,7 +162,7 @@ ${CLI} local doctor            probe configured local model endpoints (chat and
                            unset; refuses non-loopback URLs without --allow-remote)
 ${CLI} distill <skill|doc>     a budgeted proposal summary of a skill body or doc,
                            every claim citing the source line range it rests on
-                           (writes .simt/distilled/<digest>.md; a proposal a
+                           (writes .simt/local/distilled/<digest>.md; a proposal a
                            human merges - never projected or committed;
                            deterministic outline by default; --local proposes
                            from the configured chat model instead; the cache is
@@ -157,7 +172,7 @@ ${CLI} review [--local]        an ADR-008 verdict skeleton for the staged diff,
                            (deterministic without --local: the brief and its
                            governing ids only; --local proposes from the
                            configured chat model and writes
-                           .simt/reviews/<digest>.md — a proposal a human
+                           .simt/local/reviews/<digest>.md — a proposal a human
                            reads, verified against the verdict vocabulary and
                            the brief's ids; advisory always, never a gate)
 ${CLI} shared plan            what a workspace's repeated rules cost to carry
@@ -197,10 +212,10 @@ ${CLI} bench probes [--yes]    12 synthetic rule-compliance probes with determin
                             (dry-run unless --yes; grades git state, transcript and ledger,
                             and reports compliance per arm)
 ${CLI} bench variants [--yes]  evaluate simt-variants rule slots on the canary suite and lock
-                            winning variants in simt-dev.lock.json (dry-run unless --yes;
+                            winning variants in simt.lock.json (dry-run unless --yes;
                             re-opens when model or harness changes)
 ${CLI} bench critic          precision and recall of the local critic over a labelled
-                            set of historical diffs (.simt/critic-labels.jsonl;
+                            set of historical diffs (.simt/local/critic-labels.jsonl;
                             overrides --labels; labels are human-written verdicts
                             under ADR-008; the critic is advisory until precision
                             reaches 0.8 on 30 labelled diffs)
@@ -240,6 +255,12 @@ const FLAGS = `--json                 structured output (compact; one document,
 --workspace <path>      where the skill sources live; "off" declines it
                         (default: SIMT_DEV_WORKSPACE, then the user config
                         file, then the sibling heuristic if it verifies)
+--registry <path>       which skill registry to read (skills commands and
+                        graph lint; default: SIMT_REGISTRY, then the checkout's
+                        own graph/skills.graph.json, then the one member of the
+                        workspace that holds one)
+--concurrency <n>       compare: rows built at once (default 4, or
+                        SIMT_CONCURRENCY; order-preserving whatever it is)
 --dry-run               report what would change, change nothing
 --yes                   assume yes; required in automation, never prompts
 --check                 report drift and write nothing (sync, ci)

package/src/commands/hooks.mjs

@@ -12,13 +12,11 @@
 // DEFAULT location, which core.hooksPath being unset does not reveal, so a
 // foreign hook is found by asking git rather than by reading config.
 
-import { execFile } from 'node:child_process';
-import { chmod, mkdir, readFile, realpath } from 'node:fs/promises';
-import { commitJournal, journaledRemoveFile, journaledWriteFile } from '../journal.mjs';
+import { mkdir, readFile, realpath } from 'node:fs/promises';
+import { commitJournal, journaledGitConfig, journaledRemoveFile, journaledWriteFile } from '../journal.mjs';
 import { diffField, emitDiffs, readBefore } from '../diff.mjs';
 import { invalidateCheckCache } from '../status.mjs';
 import { isAbsolute, join, relative } from 'node:path';
-import { promisify } from 'node:util';
 
 import { EXIT, emit, emitJson, fail, isJson, note, writeMode } from '../output/index.mjs';
 import { MANIFEST, readManifest } from '../projection/manifest.mjs';
@@ -31,8 +29,6 @@ import { CLI } from '../name.mjs';
 import { MANIFEST_FILE } from '../name.mjs';
 import { packageVersion, hasNpm } from '../package-version.mjs';
 
-const exec = promisify(execFile);
-
 export async function hooksCommand(sub, args, flags) {
   const root = flags.root ?? args[0] ?? process.cwd();
   if (sub === 'install') return installHooks(root, flags);
@@ -54,7 +50,12 @@ async function runHook(args, flags) {
     return fail(`${root} has no ${MANIFEST_FILE}; the hook cannot know its gate list`, EXIT.CONFIG, `run: ${CLI} init --root ${root}`);
   }
 
-  const result = await runGates(event, { root, manifest });
+  // git feeds pre-push its ref list on stdin, and the docs-only skip (ADR-113)
+  // needs it. A manual run from a terminal has a TTY and reads empty, which the
+  // dispatcher treats as "no push to classify" and answers with the full suite.
+  const pushed = event === 'pre-push' ? await readStdin() : undefined;
+
+  const result = await runGates(event, { root, manifest, pushed });
   if (result.error) return fail(result.error, EXIT.USAGE);
 
   if (isJson(flags)) {
@@ -67,6 +68,29 @@ async function runHook(args, flags) {
   return result.failed ? EXIT.FAIL : EXIT.OK;
 }
 
+/**
+ * Read all of stdin, or '' when there is none to read.
+ *
+ * The pre-push shim execs this command, so git's ref list arrives on the
+ * dispatcher's stdin. A TTY (a manual run from a terminal) has no ref list and
+ * reads empty - and empty is the fail-closed answer: the dispatcher cannot
+ * classify a push it was never told about, so the suite runs.
+ *
+ * @returns {Promise<string>}
+ */
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) {
+      resolve('');
+      return;
+    }
+    const chunks = [];
+    process.stdin.on('data', (chunk) => chunks.push(chunk));
+    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    process.stdin.resume();
+  });
+}
+
 /**
  * The path to write into a chained shim: relative to the repository's top level
  * wherever the hook lives inside it.
@@ -123,6 +147,22 @@ export async function planHooksInstall(root, { manifest, exists }) {
   // install where there is no node_modules to pin in.
   const version = packageVersion();
   const npm = await hasNpm(root);
+  // Q31: installed shims name the repo's own installer in their remedy.
+  // Lockfile first, `packageManager` next, npm default — the one resolver.
+  let manager = null;
+  if (npm) {
+    const { resolveNodeRunner } = await import('../ecosystem/node-runner.mjs');
+    let packageManager = null;
+    try {
+      const pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
+      if (typeof pkg.packageManager === 'string') packageManager = pkg.packageManager;
+    } catch {
+      // Unreadable here leaves the npm default; the manifest path reports it.
+    }
+    const { fingerprint } = await import('../resolve/fingerprint.mjs');
+    const detected = await fingerprint(root);
+    manager = resolveNodeRunner({ facts: detected.facts, packageManager }).id;
+  }
 
   // Only install a shim for an event that declares at least one gate. A shim with
   // an empty gate list enforces nothing, yet merely existing it REPLACES whatever
@@ -224,7 +264,7 @@ export async function planHooksInstall(root, { manifest, exists }) {
   const evidenceDeclared = manifest?.gates?.evidence === 'warn' || manifest?.gates?.evidence === 'block';
   const evidenceFile = fileFor('commit-msg');
   const evidenceExisting = await readIfExists(join(root, evidenceFile));
-  const evidenceSource = evidenceDeclared ? renderEvidenceShim({ npm, version }) : null;
+  const evidenceSource = evidenceDeclared ? renderEvidenceShim({ npm, manager, version }) : null;
   const evidenceOurs = evidenceExisting !== null && evidenceExisting.includes(SHIM_MARKER);
   if (!evidenceDeclared && evidenceOurs) obsolete.push({ event: 'commit-msg' });
   // A foreign commit-msg would otherwise be chained onto the same path. The chain
@@ -243,6 +283,7 @@ export async function planHooksInstall(root, { manifest, exists }) {
     current,
     wants,
     npm,
+    manager,
     version,
     wanted,
     chained,
@@ -271,23 +312,25 @@ export async function planHooksInstall(root, { manifest, exists }) {
  * @returns {{wrote: string[]}} the shim paths written, removed, or refreshed
  */
 export async function applyHooksInstall(root, planned, journal) {
-  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, version, routed, wants, current } =
+  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version, routed, wants, current } =
     planned;
-  // Shim and evidence bytes are journaled so `undo` restores them (R49). The
-  // `core.hooksPath` config below is deliberately not journaled: it is git
-  // config, not a repo file, and `undo` restores files.
+  // Shim and evidence bytes are journaled so `undo` restores them (R49), with
+  // the executable bit they are written with: a shim the run chmodded is one
+  // change, and `undo` must restore the mode it found, not just the bytes.
+  // The `core.hooksPath` routing below is journaled as a `git-config` entry
+  // for the same reason — unwinding the shims while the config still points
+  // at their directory silently stops the repository's own hooks (review 0003
+  // Q22).
   const wrote = [];
   await mkdir(join(root, HOOKS_DIR), { recursive: true });
   for (const event of wanted) {
     const path = join(root, fileFor(event));
-    await journaledWriteFile(root, journal, path, renderShim(event, { npm, version }));
-    await chmod(path, 0o755);
+    await journaledWriteFile(root, journal, path, renderShim(event, { npm, manager, version }), { mode: 0o755 });
     wrote.push(fileFor(event));
   }
   for (const c of chained) {
     const path = join(root, fileFor(c.event));
-    await journaledWriteFile(root, journal, path, renderChainedShim(c.event, c.target));
-    await chmod(path, 0o755);
+    await journaledWriteFile(root, journal, path, renderChainedShim(c.event, c.target), { mode: 0o755 });
     wrote.push(fileFor(c.event));
   }
   for (const h of obsolete) {
@@ -297,8 +340,7 @@ export async function applyHooksInstall(root, planned, journal) {
   // After the chain loop, so a chained commit-msg cannot replace the claim check.
   if (evidenceSource) {
     const path = join(root, evidenceFile);
-    await journaledWriteFile(root, journal, path, evidenceSource);
-    await chmod(path, 0o755);
+    await journaledWriteFile(root, journal, path, evidenceSource, { mode: 0o755 });
     wrote.push(evidenceFile);
   }
   // `core.hooksPath` tells git to read ONE directory for EVERY event, so leaving it
@@ -306,9 +348,9 @@ export async function applyHooksInstall(root, planned, journal) {
   // `.git/hooks` that predate this tool - from running, silently. Unsetting it is the
   // only way back, and this is the only place that knows the last shim just left.
   if (routed) {
-    await exec('git', ['config', HOOKS_PATH_KEY, wants], { cwd: root });
+    await journaledGitConfig(root, journal, HOOKS_PATH_KEY, wants);
   } else if (current === wants) {
-    await exec('git', ['config', '--unset', HOOKS_PATH_KEY], { cwd: root });
+    await journaledGitConfig(root, journal, HOOKS_PATH_KEY, null);
   }
   return { wrote };
 }
@@ -320,11 +362,11 @@ export async function applyHooksInstall(root, planned, journal) {
  * `doctor --fix` reuses it rather than deriving a second answer.
  */
 export async function plannedDiffs(root, planned) {
-  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, version } = planned;
+  const { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version } = planned;
   const pairs = [];
   for (const event of wanted) {
     const path = fileFor(event);
-    pairs.push({ path, before: await readBefore(join(root, path)), after: renderShim(event, { npm, version }) });
+    pairs.push({ path, before: await readBefore(join(root, path)), after: renderShim(event, { npm, manager, version }) });
   }
   for (const c of chained) {
     const path = fileFor(c.event);
@@ -355,6 +397,7 @@ async function installHooks(root, flags) {
     current,
     wants,
     npm,
+    manager,
     version,
     wanted,
     chained,
@@ -403,7 +446,7 @@ async function installHooks(root, flags) {
   const plan = [];
   for (const event of wanted) {
     const path = join(root, fileFor(event));
-    const source = renderShim(event, { npm, version });
+    const source = renderShim(event, { npm, manager, version });
     const existing = await readIfExists(path);
     if (existing === source) {
       plan.push({ file: fileFor(event), action: 'unchanged' });
@@ -487,7 +530,7 @@ async function installHooks(root, flags) {
   // true in preview and in apply alike (R50).
   const diffs =
     flags.diff === true
-      ? await plannedDiffs(root, { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, version })
+      ? await plannedDiffs(root, { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version })
       : [];
 
   if (!mode.apply) {
@@ -535,7 +578,7 @@ async function installHooks(root, flags) {
   const journal = [];
   await applyHooksInstall(
     root,
-    { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, version, routed, wants, current },
+    { wanted, chained, obsolete, evidenceSource, evidenceFile, npm, manager, version, routed, wants, current },
     journal,
   );
   await commitJournal(root, 'hooks install', journal);

package/src/commands/impact.mjs

@@ -191,8 +191,10 @@ function textExt(file) {
 
 async function tracked(root) {
   try {
-    const { stdout } = await exec('git', ['ls-files'], { cwd: root, maxBuffer: 16 << 20 });
-    return { files: stdout.split('\n').filter(Boolean) };
+    // `-z`: without it git C-quotes a non-ASCII path and the reader's real
+    // filename never matches it (review 0003 Q39).
+    const { stdout } = await exec('git', ['ls-files', '-z'], { cwd: root, maxBuffer: 16 << 20 });
+    return { files: stdout.split('\0').filter(Boolean) };
   } catch (error) {
     return {
       error: fail(

package/src/commands/index.mjs

@@ -31,6 +31,7 @@ import { initCommand } from './init.mjs';
 import { ciCommand } from './ci.mjs';
 import { hooksCommand } from './hooks.mjs';
 import { agentHookCommand, agentHooksCommand } from './agenthook.mjs';
+import { agentsCommand } from './agent.mjs';
 import { compareCommand } from './compare.mjs';
 import { upgradeCommand } from './upgrade.mjs';
 import { mcpCommand } from './mcp.mjs';
@@ -38,7 +39,7 @@ import { pluginCommand } from './plugin.mjs';
 import { packCommand } from './pack.mjs';
 import { installCommand } from './skillsinstall.mjs';
 import { compileCommand } from './skillscompile.mjs';
-import { listCommand as rulesList, showCommand as rulesShow, whyCommand as rulesWhy } from './rules.mjs';
+import { decisionsCommand as rulesDecisions, listCommand as rulesList, showCommand as rulesShow, whyCommand as rulesWhy } from './rules.mjs';
 import { tokensCommand } from './tokens.mjs';
 import { harnessCommand, harnessLoadersCommand } from './harness.mjs';
 import {
@@ -63,7 +64,7 @@ import { testsCommand } from './tests.mjs';
 import { whyCommand } from './why.mjs';
 import { gateCommand } from './gate.mjs';
 import { impactCommand } from './impact.mjs';
-import { lessonsListCommand, lessonsReviewCommand } from './lessons.mjs';
+import { lessonsCaptureCommand, lessonsListCommand, lessonsReviewCommand } from './lessons.mjs';
 import { decideCommand } from './decide.mjs';
 import { explainCommand } from './explain.mjs';
 import { undoCommand } from './undo.mjs';
@@ -95,6 +96,10 @@ const GROUPS = new Map([
   // error before anything is created — the one default here that cannot mutate.
   ['slice', 'start'],
   ['agent-hooks', 'status'],
+  // A group like `agent-hooks`: `install` writes the agent file into each harness's
+  // own directory, `status` reports what each harness carries. The default is the
+  // read, the way `agent-hooks`'s is.
+  ['agents', 'status'],
   ['harness', 'detect'],
   ['bench', 'mine'],
   // ADR-084. `shared` is the one group whose default writes nothing, and it is `plan` for
@@ -137,6 +142,7 @@ export const IMPLEMENTED = {
   'skills eval': skillsEval,
   'skills install': installCommand,
   'skills compile': compileCommand,
+  'rules decisions': rulesDecisions,
   'rules list': rulesList,
   'rules show': rulesShow,
   'rules why': rulesWhy,
@@ -146,10 +152,12 @@ export const IMPLEMENTED = {
   'plan next': (args, flags) => planCommand('next', args, flags),
   'plan done': (args, flags) => planCommand('done', args, flags),
   // Plan 0003 R53. A group: `start` isolates the work on a branch with its brief,
-  // `finish` runs the gates, commits and records the evidence. Both take the slice
-  // id as a positional.
+  // `finish` runs the gates, commits and records the evidence, and `abandon`
+  // (review 0003 Q23) takes the slice back down. All three take the slice id
+  // as a positional.
   'slice start': (args, flags) => sliceCommand('start', args, flags),
   'slice finish': (args, flags) => sliceCommand('finish', args, flags),
+  'slice abandon': (args, flags) => sliceCommand('abandon', args, flags),
   'shared plan': sharedPlanCommand,
   'shared install': sharedInstallCommand,
   evidence: evidenceCommand,
@@ -159,6 +167,7 @@ export const IMPLEMENTED = {
   why: (args, flags) => whyCommand(args, flags, COMMANDS),
   gate: gateCommand,
   impact: (args, flags) => impactCommand(args, flags, COMMANDS),
+  'lessons capture': lessonsCaptureCommand,
   'lessons list': lessonsListCommand,
   'lessons review': lessonsReviewCommand,
   decide: decideCommand,
@@ -192,6 +201,10 @@ export const IMPLEMENTED = {
   'agent-hook': agentHookCommand,
   'agent-hooks install': (args, flags) => agentHooksCommand('install', args, flags),
   'agent-hooks status': (args, flags) => agentHooksCommand('status', args, flags),
+  // ADR-111. The one agent this tool ships, written into each harness's own agents
+  // directory. A group like `agent-hooks`: `install` writes, `status` reads.
+  'agents install': (args, flags) => agentsCommand('install', args, flags),
+  'agents status': (args, flags) => agentsCommand('status', args, flags),
   compare: compareCommand,
   tokens: tokensCommand,
   'harness detect': harnessCommand,