simt-dev 0.2.2 → 0.3.0

package/src/commands/harness.mjs

@@ -16,10 +16,12 @@
 
 import { stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { isAbsolute, join } from 'node:path';
 
-import { EXIT, emit, emitJson, isJson, note } from '../output/index.mjs';
+import { EXIT, emit, emitJson, fail, isJson, note } from '../output/index.mjs';
 import { SURFACES, CANDIDATE_DIRS } from '../projection/surfaces.mjs';
+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
@@ -88,7 +90,9 @@ async function scan(root) {
     }
   }
   for (const c of CANDIDATE_DIRS) {
-    if (await present(root, c.dir)) rows.push(row(c.dir, c.harness, {}));
+    if (await present(root, c.dir)) {
+      rows.push(row(c.dir, c.harness, { readsAgentsMd: c.readsAgentsMd ?? null, verified: c.verified ?? null }));
+    }
   }
   rows.sort((a, b) => (a.dir < b.dir ? -1 : a.dir > b.dir ? 1 : 0));
   return { root, rows };
@@ -120,7 +124,9 @@ function row(dir, label, surface) {
 }
 
 function countUnclaimed(scan) {
-  return scan.rows.filter((r) => r.surface === null).length;
+  // 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;
 }
 
 /**
@@ -143,8 +149,153 @@ function render(root, repo, user) {
 function block(scan, pad) {
   if (scan.rows.length === 0) return [`${pad}(none present)`];
   return scan.rows.map((r) => {
-    const through = r.surface === null ? 'no rule channel in this release' : r.channel ? 'projected rule file' : 'AGENTS.md';
+    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)' : '';
     return `${pad}${r.dir.padEnd(12)} ${r.label.padEnd(38)} ${through}${agents}`;
   });
 }
+
+// `simt harness loaders` - what each reader loads at session start, and the vendor
+// document every claim in that answer came from.
+//
+// It exists because `simt tokens` answers a question about files and this one answers a
+// question about a reader, and the two disagree in ways that matter: Antigravity scans
+// `.agents/rules/` flat and ignores nested files, and Codex stops merging at 32 KiB
+// across the chain rather than per file. A byte count that ignores those is not
+// pessimistic, it is wrong, and it was wrong in the meter this slice unblocked.
+//
+// It exits 0 whatever it finds, for the same reason `harness detect` does: a reader that
+// loads nothing here is a fact about this repository, not a defect in it.
+
+/**
+ * `simt harness loaders [--root <path>] [--reader <id>] [--table]`.
+ *
+ * With no flags it prints one block per reader: what it loads, what the cap leaves out,
+ * and the sentence it was read from. `--reader` narrows it. `--table` prints the
+ * vendor facts without measuring anything, which is the answer to "what does this reader
+ * do" in a repository where the answer is not about bytes.
+ */
+export async function harnessLoadersCommand(positional, flags) {
+  const root = flags.root ?? process.cwd();
+  const wanted = typeof flags.reader === 'string' ? flags.reader : null;
+  const rows = wanted === null ? LOADERS : [loader(wanted)].filter(Boolean);
+
+  if (rows.length === 0) {
+    return fail(
+      `unknown reader "${wanted}"`,
+      EXIT.USAGE,
+      `known readers: ${LOADER_IDS.join(', ')}`,
+    );
+  }
+
+  if (flags.table === true) {
+    const payload = rows.map((row) => ({
+      id: row.id,
+      label: row.label,
+      readers: row.readers,
+      order: row.order,
+      nested: row.nested,
+      start: row.start,
+      alsoReads: row.alsoReads ?? [],
+      imports: row.imports,
+      caps: caps(row),
+      skills: row.skills ?? [],
+      hooks: row.hooks,
+      hooksNote: row.hooksNote ?? null,
+      mcp: row.mcp,
+      verified: row.verified,
+      note: row.note ?? null,
+    }));
+    if (isJson(flags)) {
+      emitJson({ ok: true, command: 'harness loaders', rows: payload });
+      return EXIT.OK;
+    }
+    emit(rows.map((row) => loaderTable(row)).join('\n'));
+    return EXIT.OK;
+  }
+
+  // `--at` asks what a reader loading from a subdirectory would get, which is the only
+  // way the chain rows mean anything: Codex merges the project root down to the working
+  // directory, so the same repository costs a different reader a different total
+  // depending on where that reader is standing.
+  const views = await viewAll(root, rows, flags.at ? { cwd: isAbsolute(flags.at) ? flags.at : join(root, flags.at) } : {});
+  if (isJson(flags)) {
+    emitJson({ ok: true, command: 'harness loaders', root, rows: views });
+    return EXIT.OK;
+  }
+  emit(`${views.map((view) => renderView(view)).join('\n')}`);
+  return EXIT.OK;
+}
+
+/**
+ * One reader's measured view of the repository.
+ *
+ * The dropped rows come first under a heading of their own. A total that quietly
+ * excludes a file past the cap reads as a total, and the reader who is about to lose the
+ * tail of their deepest instruction file to a merge is exactly the person who needs to
+ * see it named.
+ */
+function renderView(view) {
+  const lines = [`${view.reader.padEnd(11)} ${view.label}  ${view.files.length} file(s) at start, ${view.totalBytes} B`];
+  lines.push(`            order     ${view.order}`);
+  for (const file of view.files) {
+    const state = file.beyondCap
+      ? '  BEYOND CAP - not read'
+      : file.truncated
+        ? `  TRUNCATED to ${file.keptBytes} B`
+        : file.overCap
+          ? `  OVER CAP (${file.countedBytes} B)`
+          : '';
+    lines.push(`            ${file.file.padEnd(44)} ${String(file.countedBytes).padStart(7)} B${state}`);
+  }
+  if (view.cap) {
+    lines.push(`            cap       ${view.cap.bytes} B over ${view.cap.appliesTo} (${view.cap.config ?? 'fixed'})`);
+  } else if (!view.perFileCap && !view.budget) {
+    lines.push('            cap       none published');
+  }
+  if (view.perFileCap) {
+    lines.push(`            file cap  ${view.perFileCap.bytes} B per rule file (${view.perFileCap.config ?? 'fixed'})`);
+  }
+  if (view.budget) {
+    lines.push(`            budget    ${view.budget.tokens} tokens (${view.budget.bytes} B approx) over ${view.budget.appliesTo}`);
+  }
+  if (view.imports?.syntax) {
+    lines.push(`            imports   ${view.imports.syntax}, ${view.imports.depth} hop(s)`);
+  }
+  if (view.userScope.length > 0) {
+    lines.push(`            user      ${view.userScope.join(', ')} (not measured: your bytes, not the repo's)`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+/** The vendor facts, without a repository — the part of the answer that is not a measurement. */
+function loaderTable(row) {
+  const lines = [`${row.id}  ${row.label}  (${row.readers})`];
+  lines.push(`  order     ${row.order}`);
+  lines.push(`  nested    ${row.nested}`);
+  for (const entry of row.start) {
+    const where = entry.scope === 'user' ? 'user' : 'project';
+    lines.push(`  start     ${where} ${entry.path}${entry.atStart ? '' : ' (on demand)'}`);
+  }
+  for (const extra of row.alsoReads ?? []) {
+    lines.push(`  also      ${extra.what}${extra.atStart ? '' : ' (on demand)'}`);
+  }
+  for (const c of caps(row)) {
+    lines.push(`  cap       ${c.bytes} ${c.scope === 'tokens' ? 'tokens' : 'B'} over ${c.appliesTo ?? c.scope}`);
+  }
+  if (row.cap === null) lines.push(`  cap       none published — ${row.capNote ?? 'checked'}`);
+  lines.push(`  skills    ${(row.skills ?? []).join(', ') || 'none documented'}`);
+  lines.push(`  hooks     ${row.hooks?.path ?? 'none documented'}${row.hooksNote ? ` — ${row.hooksNote}` : ''}`);
+  lines.push(
+    `  mcp       ${row.mcp?.path ?? (row.mcp?.key ? `profile ${row.mcp.key}` : 'none documented')}`,
+  );
+  lines.push(`  source    ${row.verified}`);
+  return lines.join('\n');
+}

package/src/commands/help.mjs

@@ -1,6 +1,7 @@
 import { emit } from '../output/index.mjs';
 import { parse } from '../argv.mjs';
-import { CLI } from '../name.mjs';
+import { CLI, MANIFEST_FILE } from '../name.mjs';
+import { DEFAULT_DIRECTORIES, DEFAULT_TEMPLATE } from '../plan/template.mjs';
 
 const COMMANDS = `${CLI} init [path]            adopt or scaffold a repo into the ecosystem
                            (dry-run unless --yes; conflicts block without
@@ -38,6 +39,20 @@ ${CLI} hooks install [--yes]   install the shared dispatcher; report what it wou
 ${CLI} hooks status            what each git event routes to, and whether it is wired
 ${CLI} hooks run <event>       run one event's gates now, as git would
                            (pre-commit, pre-push, post-merge, ...)
+${CLI} agent-hook <event>      the entry point a harness calls before a tool call
+                           (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
+                           (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} plan status             count tracker rows
+                           (${MANIFEST_FILE} key plans when set, otherwise
+                           the ${DEFAULT_TEMPLATE} template:
+                           ${DEFAULT_DIRECTORIES.join(' and ')})
+${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} 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
@@ -54,6 +69,25 @@ ${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)
+${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;
+                            --reader <id> narrows it; every claim cites its source)
+${CLI} bench mine [--yes]     mine verified benchmark tasks from git history
+                            (dry-run unless --yes; validates RED and GOLD twice in
+                            a temp worktree and stores test patches in the vault)
+${CLI} bench run [--yes]      run benchmark tasks across arms in isolated one-commit exports
+                            (dry-run unless --yes; grades against vault test patches
+                            and declared gates; --regrade <run> verifies stored runs)
+${CLI} bench report           statistical report across benchmark arms (R, Q, C, CPI, cache)
+                            (read-only; paired bootstrap 95% CIs; --compare <a> <b>
+                            prints deltas with McNemar and Wilcoxon p-values)
+${CLI} bench ablate [--yes]    leave-one-out ablation across core, profile and process sections
+                            (dry-run unless --yes; 10-task canary with escalation,
+                            value-per-KB ranking and deletion candidates)
+${CLI} bench probes [--yes]    12 synthetic rule-compliance probes with deterministic graders
+                            (dry-run unless --yes; grades git state, transcript and ledger,
+                            and reports compliance per arm)
 ${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)`;
@@ -76,6 +110,8 @@ const FLAGS = `--json                 structured output (compact; one document,
 --dry-run               report what would change, change nothing
 --yes                   assume yes; required in automation, never prompts
 --check                 report drift and write nothing (sync, ci)
+--explain               sync: name each line dropped as already inferable, with
+                        the fact behind it
 --all                   ignore a cap: every ruling of a record, or the skills budget
 --variant <id>          which body of a multi-variant skill to use
 --from <repo/path>      install from a declared source by name
@@ -88,6 +124,27 @@ const FLAGS = `--json                 structured output (compact; one document,
 --user                  harness detect: also report the directories in your home
 --repos                 tokens: measure every repository under the root, not
                         just the one, and report what repeats an earlier one
+--session <path>        tokens: split a local Claude Code or Codex transcript
+                        into rules, file reads and tool output
+--reader <id>           harness loaders: report one reader (opencode, claude, codex,
+                         cursor, antigravity, copilot, deepseek)
+--table                 harness loaders: print order, caps, imports, skill dirs and
+                         the hook and MCP config files, without measuring a repo
+--at <path>             harness loaders: measure as if the agent were working in
+                         this directory (default: the root; readers that merge the
+                         project root down to the working directory cost more here)
+--arm <spec>            bench run: arm to evaluate (bare, current, kernel, brief,
+                         or name=path/to/arm.json; repeatable)
+--harness <id>          bench run: adapter to invoke (claude, codex, gemini, opencode,
+                         cursor, aider, gold, noop; default: gold);
+                         agent-hook: which dialect to answer in (claude, cursor,
+                         codex, antigravity)
+--model <id>            bench run: model identifier recorded and passed to the adapter
+--reps <n>              bench run: repetitions per task and arm (default: 3)
+--regrade <run>         bench run: re-grade a stored run from its archived agent patch
+--compare <a> <b>       bench report: compare two arms with deltas and p-values
+--test <cmd>            plan done: the test command that closes the row
+--state <name>          plan done: target state (default: Complete)
 --help                  this text
 --version               the version, and the SHA it was built from`;
 

package/src/commands/index.mjs

@@ -29,13 +29,22 @@ import { syncCommand, checkCommand } from './sync.mjs';
 import { initCommand } from './init.mjs';
 import { ciCommand } from './ci.mjs';
 import { hooksCommand } from './hooks.mjs';
+import { agentHookCommand, agentHooksCommand } from './agenthook.mjs';
 import { compareCommand } from './compare.mjs';
 import { upgradeCommand } from './upgrade.mjs';
 import { mcpCommand } from './mcp.mjs';
 import { installCommand } from './skillsinstall.mjs';
 import { listCommand as rulesList, showCommand as rulesShow, whyCommand as rulesWhy } from './rules.mjs';
 import { tokensCommand } from './tokens.mjs';
-import { harnessCommand } from './harness.mjs';
+import { harnessCommand, harnessLoadersCommand } from './harness.mjs';
+import {
+  benchMineCommand,
+  benchRunCommand,
+  benchReportCommand,
+  benchAblateCommand,
+  benchProbesCommand,
+} from './bench.mjs';
+import { planCommand } from './plan.mjs';
 import { parse } from '../argv.mjs';
 import { fingerprint } from '../resolve/fingerprint.mjs';
 import { resolveWorkspace } from '../workspace.mjs';
@@ -53,7 +62,10 @@ const GROUPS = new Map([
   ['graph', 'lint'],
   ['rules', 'list'],
   ['hooks', 'status'],
+  ['plan', 'status'],
+  ['agent-hooks', 'status'],
   ['harness', 'detect'],
+  ['bench', 'mine'],
 ]);
 
 /**
@@ -84,14 +96,26 @@ export const IMPLEMENTED = {
   'rules why': rulesWhy,
   sync: syncCommand,
   check: checkCommand,
+  'plan status': (args, flags) => planCommand('status', args, flags),
+  'plan next': (args, flags) => planCommand('next', args, flags),
+  'plan done': (args, flags) => planCommand('done', args, flags),
   init: initCommand,
   ci: ciCommand,
   'hooks install': (args, flags) => hooksCommand('install', args, flags),
   'hooks status': (args, flags) => hooksCommand('status', args, flags),
   'hooks run': (args, flags) => hooksCommand('run', args, flags),
+  'agent-hook': agentHookCommand,
+  'agent-hooks install': (args, flags) => agentHooksCommand('install', args, flags),
+  'agent-hooks status': (args, flags) => agentHooksCommand('status', args, flags),
   compare: compareCommand,
   tokens: tokensCommand,
   'harness detect': harnessCommand,
+  'harness loaders': harnessLoadersCommand,
+  'bench mine': benchMineCommand,
+  'bench run': benchRunCommand,
+  'bench report': benchReportCommand,
+  'bench ablate': benchAblateCommand,
+  'bench probes': benchProbesCommand,
   upgrade: upgradeCommand,
   mcp: mcpCommand,
 };

package/src/commands/plan.mjs

@@ -0,0 +1,99 @@
+import { EXIT, emit, emitJson, fail, isJson, writeMode } from '../output/index.mjs';
+import { formatCounts, planDone, planNext, planStatus } from '../plan/index.mjs';
+import { CLI } from '../name.mjs';
+
+// Preview unless --yes, and --dry-run wins even then. A tracker row marked done
+// for a commit that was never written is a claim the next reader will believe.
+
+export async function planCommand(sub, args, flags) {
+  const root = flags.root ?? process.cwd();
+  if (sub === 'status') return runStatus(root, flags);
+  if (sub === 'next') return runNext(root, args[0] ?? null, flags);
+  if (sub === 'done') {
+    if (!args[0]) return fail('plan done needs a slice id', EXIT.USAGE, `run: ${CLI} plan next`);
+    return runDone(root, args[0], args[1] ?? null, flags);
+  }
+  if (!sub) {
+    return fail('plan needs a subcommand', EXIT.USAGE, `run: ${CLI} plan status  |  ${CLI} plan next  |  ${CLI} plan done <id>`);
+  }
+  return fail(`unknown plan subcommand ${sub}`, EXIT.USAGE, `run: ${CLI} plan status`);
+}
+
+async function runStatus(root, flags) {
+  const result = await planStatus(root);
+  if (result.error) return fail(result.error, EXIT.USAGE, result.remedy);
+  if (isJson(flags)) {
+    emitJson({ ok: true, command: 'plan status', ...result });
+    return EXIT.OK;
+  }
+  const lines = [`repo     ${root}`, `template ${result.template}`, `dirs     ${result.directories.join(', ')}`];
+  if (result.documents.length === 0) lines.push(`(no tracker in ${result.directories.join(' or ')})`);
+  for (const doc of result.documents) {
+    lines.push(`${doc.name}  slices=${doc.slices}  ${formatCounts(doc.counts, result.stateOrder)}`);
+  }
+  lines.push('', `total    ${formatCounts(result.totals, result.stateOrder) || '-'}`);
+  lines.push(`ready    ${result.ready}`);
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}
+
+async function runNext(root, id, flags) {
+  const result = await planNext(root, id);
+  if (result.error) return fail(result.error, EXIT.USAGE, result.remedy);
+  if (isJson(flags)) {
+    emitJson({ ok: true, command: 'plan next', ...result });
+    return EXIT.OK;
+  }
+  if (!result.next) {
+    const lines = [`repo     ${root}`, result.reason];
+    if (result.blocked?.length) {
+      lines.push('', 'blocked:');
+      for (const row of result.blocked) {
+        const unknown = row.unknownDependencies.length ? `  unknown: ${row.unknownDependencies.join(', ')}` : '';
+        lines.push(`  ${row.id}  ${row.doc}  depends on: ${row.dependsOn || '(none)'}${unknown}`);
+      }
+    }
+    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+  const next = result.next;
+  const head = [
+    `repo     ${root}`,
+    `slice    ${next.id}  ${next.doc}`,
+    `state    ${next.state}`,
+    `depends  ${next.dependsOn || '(none)'}`,
+    `bytes    ${next.sectionBytes}`,
+    '',
+    next.section || '(no section for this id)',
+  ];
+  emit(head.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}
+
+async function runDone(root, id, sha, flags) {
+  const mode = writeMode(flags);
+  const result = await planDone(root, id, {
+    sha,
+    test: flags.test ?? null,
+    state: flags.state ?? null,
+    dryRun: !mode.apply,
+  });
+  if (result.error) return fail(result.error, EXIT.USAGE, result.remedy);
+  if (isJson(flags)) {
+    emitJson({ ok: true, command: 'plan done', ...result });
+    return EXIT.OK;
+  }
+  const lines = [`repo     ${root}`];
+  if (result.dryRun) {
+    lines.push(`dry-run  ${result.id}  ${result.doc}  line ${result.line}`);
+    lines.push(result.wouldChange ? `would    ${result.from} -> ${result.to}` : `state    ${result.from}`);
+    if (result.remedy) lines.push(`apply    ${result.remedy}`);
+  } else {
+    lines.push(`changed  ${result.changed ? 'yes' : 'no'}  ${result.id}  ${result.doc}  line ${result.line}`);
+    lines.push(result.from === result.to ? `state    ${result.to}` : `state    ${result.from} -> ${result.to}`);
+  }
+  if (result.evidenceRecorded) lines.push(`evidence ${result.sha}${result.test ? `  test: ${result.test}` : ''}`);
+  else if (result.evidenceNote) lines.push(`note     ${result.evidenceNote}`);
+  emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+  return EXIT.OK;
+}

package/src/commands/tokens.mjs

@@ -33,6 +33,7 @@ import {
   mcpTools,
   totals,
 } from '../measure/context.mjs';
+import { measureSession } from '../measure/session.mjs';
 
 /** `1234567`, never `1,234,567`. `toLocaleString` output depends on the locale, and
  *  this command exists so two machines produce two numbers a pull request can diff. */
@@ -45,6 +46,36 @@ function files(n) {
 }
 
 export async function tokensCommand(positional, flags) {
+  if (flags.session !== undefined) {
+    const session = await measureSession(flags.session);
+    if (!session.ok) {
+      return fail(session.error, EXIT.CONFIG, session.remedy);
+    }
+    if (isJson(flags)) {
+      emitJson({
+        ok: true,
+        command: 'tokens',
+        mode: 'session',
+        session: session.path,
+        bytesPerToken: BYTES_PER_TOKEN,
+        rules: session.rules,
+        fileReads: session.fileReads,
+        toolOutput: session.toolOutput,
+        total: session.total,
+      });
+      return EXIT.OK;
+    }
+    const lines = [
+      `tokens   ${session.path}  (session)`,
+      `rules       ${plain(session.rules.bytes)} B  ~${plain(session.rules.tokens)} tokens  (${plain(session.rules.share)}%)`,
+      `file reads  ${plain(session.fileReads.bytes)} B  ~${plain(session.fileReads.tokens)} tokens  (${plain(session.fileReads.share)}%)`,
+      `tool output ${plain(session.toolOutput.bytes)} B  ~${plain(session.toolOutput.tokens)} tokens  (${plain(session.toolOutput.share)}%)`,
+      `total       ${plain(session.total.bytes)} B  ~${plain(session.total.tokens)} tokens`,
+    ];
+    emit(lines.join('\n'), { maxBytes: flags.maxBytes ?? 0 });
+    return EXIT.OK;
+  }
+
   // `targetRoot` owns the precedence, so `tokens`, `compare` and `upgrade` cannot
   // disagree about which directory was named (ADR-014).
   const target = await targetRoot(flags, positional);

package/src/decisions/index.mjs

@@ -20,6 +20,7 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { MANIFEST_FILE } from '../name.mjs';
 import { CLI } from '../name.mjs';
+import { PREFIX_ARGUING, TOOL_WORDS } from '../toolwords.mjs';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 export const DECISIONS_DIR = resolve(HERE, '..', '..', 'docs', 'decisions');
@@ -240,7 +241,7 @@ export async function loadDecisions({ all = false } = {}) {
         (m) => `ADR-${m[1]}`,
       ),
       partial,
-      summary: summarise(text, partial, { all }),
+      summary: summarise(text, partial, { all, file }),
       bytes: Buffer.byteLength(text),
     });
   }
@@ -288,7 +289,7 @@ export function byId(decisions) {
  *   answer "why is this here"; the reader who needs the rest asks.
  * @returns {{ruled: string[], rulingNumbers: (number|null)[], rulingCount: number, rejected: string[], writtenAgainst: string[]}}
  */
-function summarise(text, partial = [], { all = false } = {}) {
+function summarise(text, partial = [], { all = false, file = null } = {}) {
   // A section ends at the next `## ` — but not at one inside a fenced code block.
 // ADR-007's entire ruling is a document skeleton in a fence whose headings are `##`,
 // so the old lookahead ended the section at the first line of the ruling itself. It
@@ -446,7 +447,15 @@ const section = (name) => {
     // Named rather than stripped. A record that cites this org's repositories is still
     // the record; silently deleting the citation would hide which decisions were made in
     // response to what, and would mangle sentences mid-clause.
-    writtenAgainst: [...new Set(text.match(ESTATE) ?? [])].sort(),
+    //
+    // What is named is a repository, and the shape was wrong about that: every
+    // `simt-<word>` that was not `simt-dev` was reported as one, so the tool's own
+    // `simt-priority` was listed as a surveyed repository and the record that settled the
+    // kernel read as if it had been decided by looking at some other repository (ADR-080).
+    // A record whose subject is the prefix is arguing rather than citing, so it names none.
+    writtenAgainst: PREFIX_ARGUING.has(file)
+      ? []
+      : [...new Set((text.match(ESTATE) ?? []).filter((name) => !TOOL_WORDS.has(name)))].sort(),
   };
 }
 
@@ -458,6 +467,10 @@ const section = (name) => {
  * The skill registry's `source.repo` values are asserted to match this (S14); a name
  * the registry adds that is not `simt-*` has to be added here or that assertion fails.
  *
+ * The shape is not the whole answer, and treating it as one is what ADR-080 settles: a
+ * `simt-` name this tool owns is not a repository, and neither reader can tell that from
+ * the shape. `src/toolwords.mjs` is the list both of them share.
+ *
  * Not global: callers reuse it with `exec`, and a `/g` flag would remember `lastIndex`.
  */
 /**
@@ -486,7 +499,12 @@ export const ESTATE_NAME =
 
 /** Replace estate repository names with a phrase a reader who does not have them can use. */
 export function redactEstate(text) {
-  return text.replace(new RegExp(ESTATE_NAME.source, 'g'), 'a repository');
+  return String(text ?? '').replace(new RegExp(ESTATE_NAME.source, 'g'), (name) =>
+    // The tool's own names are left where they are. Redacting them turned a ruling about
+    // `simt-priority` into a sentence about `a repository`, which is how a reader learned
+    // that the record had surveyed something and not what it said (ADR-080).
+    TOOL_WORDS.has(name) ? name : 'a repository',
+  );
 }
 
 /**
@@ -506,7 +524,7 @@ export function redactEstate(text) {
  * Only a real verb follows, which is what keeps `simt-dev.json`, `simt-dev-check.yml` and
  * `simt-dev's` untouched - those are the project's artefacts and the project keeps its name.
  */
-const VERB = '(?:init|doctor|check|sync|upgrade|ci|compare|hooks|mcp|rules|skills|graph|--[a-z-]+)';
+const VERB = '(?:init|doctor|check|sync|upgrade|ci|compare|hooks|mcp|rules|skills|graph|tokens|harness|bench|--[a-z-]+)';
 
 function redactCommand(text) {
   return String(text ?? '').replace(new RegExp(`\\bsimt-dev (?=${VERB})\\b`, 'g'), `${CLI} `);