simt-dev 0.4.0 → 0.6.0

package/src/commands/bench.mjs

@@ -2,7 +2,7 @@
 // and statistical report (`bench report`, R03).
 //
 // Like every writer in this CLI, `bench mine` and `bench run` are previews by
-// default and write artifacts to `.simt-dev/bench/` only when authorised with
+// default and write artifacts to `.simt/bench/` only when authorised with
 // `--yes` (and not `--dry-run`). `bench report` is read-only.
 
 import { resolve } from 'node:path';
@@ -16,6 +16,7 @@ import { formatRecall, measureRecall } from '../index/map.mjs';
 import { ablateBench } from '../bench/ablate.mjs';
 import { runBenchProbes } from '../bench/probes.mjs';
 import { selectRuleVariants } from '../bench/variants.mjs';
+import { criticBench } from '../review/critic.mjs';
 import { listFlag } from './skills.mjs';
 
 export async function benchMineCommand(positional, flags) {
@@ -90,7 +91,7 @@ export async function benchRunCommand(positional, flags) {
       return fail(
         `${root}: ${error.message ?? error}`,
         EXIT.CONFIG,
-        `pass a stored run name under .simt-dev/bench/runs/: ${CLI} bench run --regrade <run>`,
+        `pass a stored run name under .simt/bench/runs/: ${CLI} bench run --regrade <run>`,
       );
     }
 
@@ -221,7 +222,7 @@ export async function benchReportCommand(positional, flags) {
     return fail(
       `${root}: ${error.message ?? error}`,
       EXIT.CONFIG,
-      `run benchmark arms first with \`${CLI} bench run --yes\` or fix .simt-dev/bench/prices.json`,
+      `run benchmark arms first with \`${CLI} bench run --yes\` or fix .simt/bench/prices.json`,
     );
   }
 
@@ -394,3 +395,34 @@ export async function benchVariantsCommand(positional, flags) {
 
 
 
+
+// `simt bench critic` (plan 0003 R39).
+//
+// The row's acceptance measured, or reported missing rather than inferred: the
+// critic runs over a labelled set of historical diffs and the bench reports
+// precision and recall for the BLOCK binary. The metric never gates the critic —
+// the row says precision >= 0.8 on >= 30 labelled diffs promotes it to a gate,
+// and until a bench here shows that, every report calls the critic advisory.
+export async function benchCriticCommand(positional, flags, commands = []) {
+  const root = resolve(flags.root ?? positional[0] ?? process.cwd());
+  const labelsPath = flags.labels ?? '.simt/critic-labels.jsonl';
+  const result = await criticBench(root, { labelsPath, flags, commands });
+  if (typeof result === 'number') return result;
+
+  if (isJson(flags)) {
+    emitJson(result, { pretty: flags.pretty === true, maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+  const lines = [
+    `bench    critic  ${root}`,
+    `labels   ${result.labels} (${labelsPath})  measured ${result.measured}  errors ${result.errors.length}`,
+    `counts   tp=${result.tp} fp=${result.fp} fn=${result.fn} tn=${result.tn}`,
+    `precision ${result.precision === null ? 'unmeasured' : result.precision.toFixed(3)}`,
+    `recall    ${result.recall === null ? 'unmeasured' : result.recall.toFixed(3)}`,
+    `gated    ${result.gated ? 'yes' : 'no'}`,
+  ];
+  if (result.labelsNote) lines.push(`labels   ${result.labelsNote}`);
+  for (const error of result.errors) lines.push(`error    ${error}`);
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}

package/src/commands/ci.mjs

@@ -1,4 +1,4 @@
-// simt-dev ci — the .github files, in the one repository whose copies are refreshed.
+// simt ci — the .github files, in the one repository whose copies are refreshed.
 //
 // Why this exists rather than a flag on `init`: the write-once rule is about a
 // repository's own file, and simt-dev's own repository has no file of its own here —

package/src/commands/compare.mjs

@@ -1,4 +1,4 @@
-// simt-dev compare - the org-wide matrix.
+// simt compare - the org-wide matrix.
 //
 // This command exists because the 2026-10-05 audit had to be reconstructed by
 // hand, from 16 repositories, into 40 KB of prose. Everything it found is a fact

package/src/commands/distill.mjs

@@ -0,0 +1,36 @@
+// `simt distill <skill|doc>` (plan 0003 R38).
+//
+// A budgeted summary with citations to source line ranges, written to
+// `.simt/distilled/` as a proposal a human merges. The deterministic engine
+// is the default; a local model proposes only when the caller asks for it and the
+// manifest names one (ADR-090, ADR-075). Model output never lands anywhere
+// projected or committed text does — that is the direction this command cannot
+// take (principle P2).
+
+import { CLI } from '../name.mjs';
+import { EXIT, emit, emitJson, isJson } from '../output/index.mjs';
+import { distillTarget } from '../distill/distill.mjs';
+
+export async function distillCommand(args, flags) {
+  const result = await distillTarget(args, flags);
+  if (typeof result === 'number') return result;
+
+  if (isJson(flags)) {
+    emitJson(result, { maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+
+  emit(
+    [
+      `source    ${result.target.kind}  ${result.target.source} (${result.target.bytes} bytes, ${result.target.lines} lines)`,
+      `digest    ${result.digest}`,
+      `engine    ${result.engine}`,
+      `budget    ${result.budget} bytes`,
+      `citations ${result.citations}`,
+      ...(result.verified === true ? [] : result.faults.map((f) => `unverified ${f}`)),
+      `proposal  ${result.proposal.path}  (${result.proposal.state}, ${result.proposal.bytes} bytes)`,
+    ].join('\n'),
+    { maxBytes: flags.maxBytes ?? 0 },
+  );
+  return EXIT.OK;
+}

package/src/commands/gate.mjs

@@ -117,11 +117,11 @@ async function runSelected(root, flags, selected) {
 
 async function writeRaw(root, body) {
   try {
-    const dir = join(root, '.simt-dev', 'gate');
+    const dir = join(root, '.simt', 'gate');
     await mkdir(dir, { recursive: true });
     const name = `gate-${Date.now()}.log`;
     await writeFile(join(dir, name), body);
-    return `.simt-dev/gate/${name}`;
+    return `.simt/gate/${name}`;
   } catch {
     return '';
   }

package/src/commands/graph.mjs

@@ -1,4 +1,4 @@
-// `simt-dev graph lint` - verify the hand-authored registry against reality.
+// `simt graph lint` - verify the hand-authored registry against reality.
 //
 // Implementation sequence step 2. This command is the reason hand-authoring the
 // registry is safe: 38 nodes across 6 repos is bookkeeping that rots silently.
@@ -64,7 +64,7 @@ export async function lintCommand(positional, flags) {
   }
 
   if (!registry) {
-    // The default remedy for this exit code is `run: simt-dev graph lint`, which from
+    // The default remedy for this exit code is `run: simt graph lint`, which from
     // inside `graph lint` is circular: the reader just ran it and got this. Name the
     // argument the command takes, because an explicit path is the way out (ADR-061).
     return fail(errors[0] ?? `${path}: unreadable`, EXIT.REGISTRY, `run: ${CLI} graph lint <path-to-registry>`);

package/src/commands/harness.mjs

@@ -13,6 +13,11 @@
 // a defect in the repository: the rules in AGENTS.md still reach whichever harnesses
 // read that file, and a reader who wanted a failing command could not tell the
 // difference between "no channel" and "broken".
+//
+// R42 added the MCP registration files to the same answer. They are reported from the
+// loader table (one source of paths, with `verified` naming the vendor page) because a
+// detection question deserves the same provenance rule the loader table set: a row with
+// no source is a guess in a report.
 
 import { stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
@@ -24,7 +29,7 @@ import { LOADERS, LOADER_IDS, caps, loader } from '../projection/loaders.mjs';
 import { viewAll } from '../measure/loaderView.mjs';
 
 /**
- * `simt-dev harness detect`. The subcommand is validated by dispatch, which rejects a
+ * `simt harness detect`. The subcommand is validated by dispatch, which rejects a
  * second token that is not in the group registry rather than silently routing to the
  * default; this function therefore has exactly one thing to do and no second spelling
  * to keep in step with it.
@@ -36,7 +41,12 @@ import { viewAll } from '../measure/loaderView.mjs';
 export async function harnessCommand(positional, flags) {
   const root = flags.root ?? process.cwd();
 
-  const repo = await scan(root);
+  // MCP evidence is project-scope by construction: the loader table carries repo-root
+  // paths (.mcp.json, .codex/config.toml, …), and the same path means different scopes
+  // per harness in $HOME - Codex registers user servers in its user config, Claude Code
+  // does not keep .mcp.json there - so a home scan reports directories only, and stays
+  // right by saying less rather than by carrying a second per-harness user-scope table.
+  const repo = await scan(root, { mcp: true });
   // Only on request. The home directory is the reader's, not the repository's, and a
   // command that reports both by default is a command whose output changes because
   // somebody installed something elsewhere.
@@ -79,8 +89,13 @@ export async function harnessCommand(positional, flags) {
  * rather than raised: a permissions error on one candidate must not make the whole
  * command fail, and the difference between "could not look" and "not there" is one
  * note in the output rather than a second failure mode nobody asked for.
+ *
+ * `{ mcp: true }` (repo scans only) adds the MCP registration files the loader table
+ * records - single-sourced from `loaders.mjs` because that is the whole point of R42:
+ * the evidence is data the tool already verified once, not a second list of paths to
+ * keep in step by hand. It is file stat and nothing else: present, labelled, cited.
  */
-async function scan(root) {
+async function scan(root, { mcp = false } = {}) {
   const rows = [];
   for (const s of SURFACES) {
     for (const dir of s.configDirs ?? []) {
@@ -91,9 +106,10 @@ async function scan(root) {
   }
   for (const c of CANDIDATE_DIRS) {
     if (await present(root, c.dir)) {
-      rows.push(row(c.dir, c.harness, { readsAgentsMd: c.readsAgentsMd ?? null, verified: c.verified ?? null }));
+      rows.push(row(c.dir, c.harness, { readsAgentsMd: c.readsAgentsMd ?? null, readsAgentsMdNote: c.readsAgentsMdNote ?? null, verified: c.verified ?? null }));
     }
   }
+  if (mcp) rows.push(...(await scanMcpFiles(root)));
   rows.sort((a, b) => (a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0));
   return { root, rows };
 }
@@ -106,11 +122,49 @@ async function present(root, dir) {
   }
 }
 
+/**
+ * The MCP registration files the loader table says a project can carry.
+ *
+ * A row requires the path to be a FILE the loader table names, and it is skipped when
+ * the loader carries none (opencode registers servers in a profile key, DeepSeek as a
+ * profile plugin). Nothing reads the file: whether the JSON parses or names servers is
+ * the harness's problem at session time, and a service that promised to validate that
+ * would be a service somebody had to keep current.
+ *
+ * This is evidence, not a channel: no rule file is projected into an MCP config, so
+ * `channel` stays false and `readsAgentsMd` stays null - the fields say what they mean
+ * instead of borrowing the meaning the directory rows give them.
+ */
+async function scanMcpFiles(root) {
+  const rows = [];
+  for (const loader of LOADERS) {
+    const mcp = loader.mcp;
+    if (mcp?.path == null) continue;
+    const file = join(root, mcp.path);
+    try {
+      if (!(await stat(file)).isFile()) continue;
+    } catch {
+      continue;
+    }
+    rows.push({
+      dir: mcp.path,
+      kind: 'mcp',
+      label: loader.label,
+      surface: loader.id,
+      channel: false,
+      readsAgentsMd: null,
+      verified: mcp.verified ?? loader.verified ?? null,
+    });
+  }
+  return rows;
+}
+
 /** One present directory, and what - if anything - this tool can project into it. */
 function row(dir, label, surface) {
   const id = surface.id ?? null;
   return {
     dir,
+    kind: 'rules',
     label,
     surface: id,
     // `channel: false` is the honest half of the answer: the directory exists and this
@@ -119,14 +173,20 @@ function row(dir, label, surface) {
     // identical in a list of names.
     channel: id !== null && surface.rule != null,
     readsAgentsMd: surface.readsAgentsMd ?? null,
+    // Which reader ("some") or which configuration ("some, under this setting") - the
+    // bare three-valued column started life on rows with many readers, where "which" is
+    // a per-row note. A row that lacks one renders without it.
+    readsAgentsMdNote: surface.readsAgentsMdNote ?? null,
     verified: surface.verified ?? null,
   };
 }
 
 function countUnclaimed(scan) {
   // A candidate that cites a document and reads AGENTS.md is covered by the standard
-  // region. One that cites nothing is the case the note exists for (ADR-067).
-  return scan.rows.filter((r) => r.surface === null && r.readsAgentsMd == null).length;
+  // region. One that cites nothing is the case the note exists for (ADR-067). An MCP
+  // config row is not "unclaimed" - it never claimed a rule channel, so it must not
+  // count toward the note, or mcp.json presence would read as a rule gap it is not.
+  return scan.rows.filter((r) => r.kind === 'rules' && r.surface === null && r.readsAgentsMd == null).length;
 }
 
 /**
@@ -149,15 +209,28 @@ function render(root, repo, user) {
 function block(scan, pad) {
   if (scan.rows.length === 0) return [`${pad}(none present)`];
   return scan.rows.map((r) => {
+    // An MCP row is judged by presence alone, so it is named first: routed last, its
+    // non-null `surface` (the loader it belongs to) would collide with the directory
+    // rows' meaning and print "AGENTS.md" under a file that carries no rules at all.
     const through =
-      r.surface === null
-        ? r.readsAgentsMd === 'all'
-          ? 'AGENTS.md'
-          : 'no rule channel in this release'
-        : r.channel
-          ? 'projected rule file'
-          : 'AGENTS.md';
-    const agents = r.readsAgentsMd === 'all' ? ' (reads AGENTS.md)' : r.readsAgentsMd === 'some' ? ' (some readers read AGENTS.md)' : '';
+      r.kind === 'mcp'
+        ? 'MCP config present'
+        : r.surface === null
+          ? r.readsAgentsMd === 'all'
+            ? 'AGENTS.md'
+            : 'no rule channel in this release'
+          : r.channel
+            ? 'projected rule file'
+            : 'AGENTS.md';
+    // "some" never renders bare when the row knows which: a reader who needs the
+    // detail already had it only in the JSON, and the detail is the answer to "is my
+    // AGENTS.md read" - the question this text is here to answer.
+    const agents =
+      r.readsAgentsMd === 'all'
+        ? ' (reads AGENTS.md)'
+        : r.readsAgentsMd === 'some'
+          ? ` (some readers read AGENTS.md${r.readsAgentsMdNote ? `: ${r.readsAgentsMdNote}` : ''})`
+          : '';
     return `${pad}${r.dir.padEnd(12)} ${r.label.padEnd(38)} ${through}${agents}`;
   });
 }

package/src/commands/help.mjs

@@ -57,6 +57,10 @@ ${CLI} agent-hooks install     write this repo's policies into the harnesses tha
                            (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
+                            (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)
 ${CLI} plan status             count tracker rows
                            (${MANIFEST_FILE} key plans when set, otherwise
                            the ${DEFAULT_TEMPLATE} template:
@@ -92,7 +96,7 @@ ${CLI} map [--task "<text>"] [--level outline|names|signatures]
 ${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-dev/lessons.jsonl
+${CLI} lessons list            deterministic lesson candidates in .simt/lessons.jsonl
                            and promoted lessons in docs/lessons/*.md
 ${CLI} lessons review [<id>]   promote a lesson candidate to docs/lessons/NNNN-<slug>.md
                            (dry-run unless --yes; writes Appendix A frontmatter)
@@ -103,6 +107,21 @@ ${CLI} decide [<title>]        scaffold an ADR with the next free number, a Stat
 ${CLI} local doctor            probe configured local model endpoints (chat and embed)
                            (reads local in ${MANIFEST_FILE}; opens no socket when
                            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
+                           human merges - never projected or committed;
+                           deterministic outline by default; --local proposes
+                           from the configured chat model instead; the cache is
+                           keyed by source digest and budget, --refresh regenerates)
+${CLI} review [--local]        an ADR-008 verdict skeleton for the staged diff,
+                           the brief listing everything that governs it (R25)
+                           (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
+                           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
                            once: the shared set, its bytes, and every path that would be written
                            (read-only; touches nothing, not even your home directory)
@@ -117,8 +136,9 @@ ${CLI} tokens [--repos]       what a reader loads at session start, in bytes
                            repository under the root and what repeats an earlier)
 ${CLI} harness detect         which harnesses this repo (and, with --user, you)
                            are set up for, and which have a rule channel here
-                           (presence only: a directory found is not a claim about
-                           what its owner reads; exits 0 whatever it finds)
+                           (presence only: a directory or an MCP config file
+                           found is not a claim about what its owner reads;
+                           exits 0 whatever it finds)
 ${CLI} harness loaders        what each reader loads at session start, in bytes,
                             and what its size cap drops
                             (--table prints the vendor facts without measuring;
@@ -141,6 +161,23 @@ ${CLI} bench probes [--yes]    12 synthetic rule-compliance probes with determin
 ${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;
                             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;
+                            overrides --labels; labels are human-written verdicts
+                            under ADR-008; the critic is advisory until precision
+                            reaches 0.8 on 30 labelled diffs)
+${CLI} pack new <name> --source <spec>
+                           scaffold a versioned pack: pack.json, an unmeasured
+                           bench.json, and one stack rule (dry-run unless --yes;
+                           refuses a directory that already exists)
+${CLI} pack lint [dir]        validate a pack: identity, source, rules, and the
+                           bench summary (--require-measured rejects a pack with
+                           no measured ΔR; a pack vendored under .simt/packs/ is
+                           also checked against the manifest's pin)
+${CLI} pack publish [dir] [--yes]
+                           publish an npm-sourced pack to the registry
+                           (dry-run unless --yes; skips a version already live;
+                           a git-sourced pack names the tag-and-push instead)
 ${CLI} mcp                    the read-only surface as MCP tools over stdio
                            (--list prints it without reading stdin; init, sync,
                            upgrade and the installers stay CLI-only by design)`;
@@ -155,6 +192,7 @@ const FLAGS = `--json                 structured output (compact; one document,
 --task "<text>"         the task text used for capability resolution
 --paths <globs>         comma-separated path globs used for path resolution
 --root <path>           repository root (default: cwd)
+--out <path>            plugin: where the generated package lands (required)
 --surfaces <ids>        comma-separated editors to write rule files for;
                          "" means AGENTS.md only (default: every surface,
                          or the "surfaces" list in simt-dev.json)
@@ -204,9 +242,21 @@ const FLAGS = `--json                 structured output (compact; one document,
 --state <name>          plan done: target state (default: Complete)
 --level <name>          map: detail level (outline, names, signatures)
 --supersedes <spec>     decide: superseded ADR or ruling (ADR-NNN or ADR-NNN:<ruling>[:<kind>]; repeatable)
---allow-remote          local doctor: allow non-loopback model URLs (refused by default)
+--source <spec>         pack new: where the pack's bytes come from
+                         (npm:<package> or git+https://…; required)
+--require-measured      pack lint: reject a pack with no measured ΔR
+                         (a bench.json marked unmeasured, or missing)
+--allow-remote          local doctor / distill / review: allow non-loopback model
+                         URLs (refused by default)
 --embed                 index / map / brief: compute or query optional local vector embeddings
                         (off by default unless recall@10 gains at least 10 points)
+--labels <path>         bench critic: the labelled set of historical diffs to score
+                        (default .simt/critic-labels.jsonl; one human-written
+                        {sha, verdict} pair per line)
+--refresh               distill / review: regenerate a proposal that is already cached
+--local                 distill / review: propose the answer from the configured
+                         local chat model (local.chat); off by default, which
+                         uses the deterministic path instead
 --help                  this text
 --version               the version, and the SHA it was built from`;
 

package/src/commands/hooks.mjs

@@ -1,4 +1,4 @@
-// simt-dev hooks install | status | run
+// simt hooks install | status | run
 //
 // Three commands with one shared body. `install` writes the shims and points
 // core.hooksPath at them; `status` reports what is installed and what would

package/src/commands/index.mjs

@@ -3,7 +3,7 @@
 // Every command named in docs/plans/0002-simt-dev-cli.md section 5 is registered
 // here from day one. A command that is declared but not yet implemented exits
 // UNSUPPORTED with a pointer to its implementation step; it never silently
-// succeeds. An agent that calls `simt-dev compare` on an unreleased build must get a
+// succeeds. An agent that calls `simt compare` on an unreleased build must get a
 // failure, not an empty result it will read as "no drift".
 
 import {
@@ -34,6 +34,8 @@ import { agentHookCommand, agentHooksCommand } from './agenthook.mjs';
 import { compareCommand } from './compare.mjs';
 import { upgradeCommand } from './upgrade.mjs';
 import { mcpCommand } from './mcp.mjs';
+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';
@@ -46,6 +48,7 @@ import {
   benchAblateCommand,
   benchProbesCommand,
   benchVariantsCommand,
+  benchCriticCommand,
 } from './bench.mjs';
 import { planCommand } from './plan.mjs';
 import { sharedPlanCommand, sharedInstallCommand, sharedWarning } from './shared.mjs';
@@ -58,7 +61,9 @@ import { gateCommand } from './gate.mjs';
 import { impactCommand } from './impact.mjs';
 import { lessonsListCommand, lessonsReviewCommand } from './lessons.mjs';
 import { decideCommand } from './decide.mjs';
+import { reviewCommand } from './review.mjs';
 import { localDoctorCommand } from './local.mjs';
+import { distillCommand } from './distill.mjs';
 import { parse } from '../argv.mjs';
 import { CLI } from '../name.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
@@ -88,6 +93,9 @@ const GROUPS = new Map([
   ['shared', 'plan'],
   ['lessons', 'list'],
   ['local', 'doctor'],
+  // Plan 0003 R45. The default is the read: `pack` alone lints the working
+  // directory, the way `skills` alone indexes and `graph` alone lints.
+  ['pack', 'lint'],
 ]);
 
 /**
@@ -135,6 +143,10 @@ export const IMPLEMENTED = {
   'lessons list': lessonsListCommand,
   'lessons review': lessonsReviewCommand,
   decide: decideCommand,
+  distill: distillCommand,
+  // R25 machinery needs the runnable command names for Affects command tokens,
+  // same wiring `why` and `impact` get through their lambdas.
+  review: (args, flags) => reviewCommand(args, flags, COMMANDS),
   'local doctor': localDoctorCommand,
   'evidence check': (args, flags) => evidenceCommand(['check', ...args], flags),
   init: initCommand,
@@ -155,8 +167,22 @@ export const IMPLEMENTED = {
   'bench ablate': benchAblateCommand,
   'bench probes': benchProbesCommand,
   'bench variants': benchVariantsCommand,
+  // plan 0003 R39. The critic's acceptance bench measures BLOCK-precision and
+  // recall over a labelled set; until it reports its floor, the critic entries
+  // stay advisory and no gate reads them. COMMANDS rides along so the brief
+  // resolves Affects command tokens the way `simt why` does.
+  'bench critic': (args, flags) => benchCriticCommand(args, flags, COMMANDS),
   upgrade: upgradeCommand,
   mcp: mcpCommand,
+  // plan 0003 R43. A bare command: the kind is a positional, so there is no group and
+  // no default subcommand to resolve.
+  plugin: pluginCommand,
+  // Plan 0003 R45. A group, not a bare command: `new` and `publish` write (or
+  // publish) and `lint` reads, and the dispatcher routes all three through one
+  // subcommand switch the way `hooks` does.
+  'pack new': (args, flags) => packCommand('new', args, flags),
+  'pack lint': (args, flags) => packCommand('lint', args, flags),
+  'pack publish': (args, flags) => packCommand('publish', args, flags),
 };
 
 /**
@@ -216,7 +242,7 @@ export async function dispatch(argv) {
 /**
  * Normalise argv into a registry key, or null when unrecognised.
  * A group with an omitted subcommand resolves to that group's default, so
- * `simt-dev skills` is `simt-dev skills index`.
+ * `simt skills` is `simt skills index`.
  */
 function commandPath(first, second) {
   if (first === undefined) return null;
@@ -225,7 +251,7 @@ function commandPath(first, second) {
   const group = GROUPS.get(first);
   if (second === undefined) return `${first} ${group}`;
   // Reject a second token that is not a subcommand of this group, rather than
-  // silently routing `simt-dev skills nonsense` to the default subcommand.
+  // silently routing `simt skills nonsense` to the default subcommand.
   //
   // Read from IMPLEMENTED rather than from a second list. The list existed because
   // there was no way to enumerate what dispatch could run — `IMPLEMENTED` was an

package/src/commands/init.mjs

@@ -1,4 +1,4 @@
-// simt-dev init - adopt a repo into the ecosystem, or scaffold a new one.
+// simt init - adopt a repo into the ecosystem, or scaffold a new one.
 //
 // The governing idea: init never destroys hand-written work. It writes a manifest
 // and a generated region, reports every conflict it found BEFORE writing anything,
@@ -647,7 +647,7 @@ function render(payload, manifest, { npm = true, version } = {}) {
         : `            runs ${CLI} check where a pull request is merged; yours to edit after this`,
     );
   } else if (payload.ci.action === 'refresh') {
-    // init does not write it. `simt-dev ci` owns the template's own copy, and a
+    // init does not write it. `simt ci` owns the template's own copy, and a
     // second writer would be a second answer to who owns it.
     lines.push(`  ${'refresh'.padEnd(9)} ${payload.ci.file}  ${payload.ci.reason}`);
     lines.push(`            remedy: ${CLI} ci --yes   (init does not write simt-dev's own copy)`);

package/src/commands/local.mjs

@@ -30,6 +30,14 @@ function formatRoleLine(role, report) {
   return `${role.padEnd(8)} ok  ${report.model} @ ${report.url}${extra}${listed}`;
 }
 
+// `requestJson` shapes a non-OK response as "METHOD url failed (STATUS): message",
+// so the HTTP status is the reliable signal here — 401/403 mean the server is up but
+// rejected the request as unauthorised, which is a different remedy than "start it".
+function isAuthFailure(report) {
+  if (!report || typeof report.error !== 'string') return false;
+  return /failed \(40[13]\)/.test(report.error);
+}
+
 function remedyFor(result) {
   if (result.status === 'refused-remote') {
     return `set a loopback URL (http://127.0.0.1:<port>/v1) in ${MANIFEST_FILE}, or run: ${CLI} local doctor --allow-remote`;
@@ -38,6 +46,9 @@ function remedyFor(result) {
     return `fix the \`local\` configuration in ${MANIFEST_FILE}`;
   }
   if (result.status === 'unreachable') {
+    if ([result.chat, result.embed].some(isAuthFailure)) {
+      return `the server is up but rejected the request as unauthorised (401/403); set \`local.<role>.apiKey\` in ${MANIFEST_FILE} to the server's bearer token, then rerun: ${CLI} local doctor`;
+    }
     return `start the local model server at the URL in ${MANIFEST_FILE}, then rerun: ${CLI} local doctor`;
   }
   return null;

package/src/commands/mcp.mjs

@@ -1,4 +1,4 @@
-// simt-dev mcp - serve the tool surface over MCP on stdio.
+// simt mcp - serve the tool surface over MCP on stdio.
 //
 // Optional by design (plan 0002 section 5): it adds a transport, not a capability, and
 // the CLI stays the primary interface because it works in CI, in a hook and in a bare