simt-dev 0.6.2 → 0.7.0

package/src/agents/render.mjs

@@ -0,0 +1,277 @@
+// One renderer per harness for the agent file, and the plan the install writes.
+//
+// Six harnesses read a subagent and no two agree on the file. Five write a
+// markdown file with YAML frontmatter and a body that becomes the system prompt;
+// Codex writes a TOML file whose `developer_instructions` holds the same body.
+// The path, the extension, the frontmatter keys and the document shape are all
+// different, and none of them is the same fact. So this module owns the
+// differences and the command owns none of them:
+//
+//   opencode     .opencode/agents/simt-agent.md   markdown   description
+//   claude       .claude/agents/simt-agent.md     markdown   name, description
+//   cursor       .cursor/agents/simt-agent.md     markdown   name, description
+//   gemini       .gemini/agents/simt-agent.md     markdown   name, description
+//   codex        .codex/agents/simt-agent.toml    TOML       name, description, developer_instructions
+//   antigravity  .agents/agents/simt-agent.md     markdown   name, description
+//
+// The source of truth is ONE file in this repository, `agents/simt-agent.md`:
+// neutral frontmatter plus a harness-agnostic body. The renderer strips that
+// frontmatter and re-emits the keys each harness documents, so the body — the
+// part that says how to act — is written once and cannot drift between
+// harnesses. An agent is a file the tool owns whole, not a config entry to
+// merge, so `rendered` compares bytes and reports created, unchanged or updated.
+
+import { mkdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+
+import { PACKAGE_ROOT } from '../workspace.mjs';
+import { splitFrontmatter } from '../memory/decide.mjs';
+import { LOADERS } from '../projection/loaders.mjs';
+import { journaledWriteFile } from '../journal.mjs';
+
+/** The one agent this tool ships, and the filename stem every harness shares. */
+const AGENT_FILE = 'simt-agent.md';
+export const AGENT_STEM = 'simt-agent';
+
+/** The companion skill: the command reference the agent reads on demand. */
+const SKILL_SOURCE = join('skills', 'simt-commands', 'SKILL.md');
+export const SKILL_STEM = 'simt-commands';
+
+/**
+ * The per-harness differences. `frontmatter` returns the ordered [key, value]
+ * pairs a markdown harness documents; Codex has none because its shape is TOML,
+ * not frontmatter. The body is identical everywhere and is not a difference.
+ */
+const ADAPTERS = {
+  opencode: {
+    id: 'opencode',
+    format: 'md',
+    frontmatter: (agent) => [
+      ['description', agent.description],
+    ],
+  },
+  claude: {
+    id: 'claude',
+    format: 'md',
+    frontmatter: (agent) => [
+      ['name', agent.name],
+      ['description', agent.description],
+    ],
+  },
+  cursor: {
+    id: 'cursor',
+    format: 'md',
+    frontmatter: (agent) => [
+      ['name', agent.name],
+      ['description', agent.description],
+    ],
+  },
+  gemini: {
+    id: 'gemini',
+    format: 'md',
+    frontmatter: (agent) => [
+      ['name', agent.name],
+      ['description', agent.description],
+    ],
+  },
+  codex: {
+    id: 'codex',
+    format: 'toml',
+  },
+  antigravity: {
+    id: 'antigravity',
+    format: 'md',
+    frontmatter: (agent) => [
+      ['name', agent.name],
+      ['description', agent.description],
+    ],
+  },
+};
+
+/** The reader-table row for a harness's agents directory, or null when none is documented. */
+function agentInfo(id) {
+  const row = LOADERS.find((l) => l.id === id);
+  return row?.agents ?? null;
+}
+
+/**
+ * The path a harness reads the agent from, sourced from the reader table rather
+ * than spelled here. Null for a harness that documents no agents directory.
+ */
+export function agentPath(id) {
+  const info = agentInfo(id);
+  return info ? join(info.dir, `${AGENT_STEM}${info.ext}`) : null;
+}
+
+/**
+ * Every reader, with the agents path it documents and the note for the ones that
+ * do not. The command reports these so a harness this tool does not write is
+ * named rather than silent.
+ */
+export function agentRows() {
+  return LOADERS.map((l) => ({
+    id: l.id,
+    label: l.label,
+    path: l.agents ? join(l.agents.dir, `${AGENT_STEM}${l.agents.ext}`) : null,
+    note: l.agents ? l.agents.verified : (l.agentsNote ?? 'no agents file is documented'),
+  }));
+}
+
+/** The adapters that both have a reader-table path and a renderer, in reader order. */
+export function adapters() {
+  return agentRows()
+    .filter((r) => r.path !== null)
+    .map((r) => ADAPTERS[r.id])
+    .filter(Boolean);
+}
+
+/** One adapter by id, or null when the harness has no path or no renderer. */
+export function adapter(id) {
+  return ADAPTERS[id] && agentInfo(id) !== null ? ADAPTERS[id] : null;
+}
+
+/** Parse the neutral frontmatter of the source file: `key: value` lines. */
+function parseSimpleFront(front) {
+  const out = {};
+  for (const line of front.split('\n')) {
+    const idx = line.indexOf(':');
+    if (idx < 0) continue;
+    const key = line.slice(0, idx).trim();
+    const val = line.slice(idx + 1).trim();
+    if (key) out[key] = val;
+  }
+  return out;
+}
+
+/**
+ * The one agent, read from this repository's `agents/` directory. The body is
+ * the system prompt; `name` and `description` are re-emitted per harness.
+ */
+export async function loadAgent() {
+  const raw = await readFile(join(PACKAGE_ROOT, 'agents', AGENT_FILE), 'utf8');
+  const { front, body } = splitFrontmatter(raw);
+  const meta = parseSimpleFront(front ?? '');
+  if (!meta.name || !meta.description) {
+    throw new Error(`${AGENT_FILE} must declare a name and a description in its frontmatter`);
+  }
+  return { name: meta.name, description: meta.description, body: body.trim() };
+}
+
+/** The companion skill file, read verbatim from this repository. */
+async function loadSkill() {
+  return readFile(join(PACKAGE_ROOT, SKILL_SOURCE), 'utf8');
+}
+
+/**
+ * Where the skill lands in the receiving repo. The same heuristic `skills
+ * install` uses: respect an existing skills directory, default to `.agents/skills`.
+ */
+async function skillDestPath(root) {
+  let entries = [];
+  try {
+    const { readdir } = await import('node:fs/promises');
+    entries = await readdir(root);
+  } catch { /* fresh repo, no entries */ }
+  let dir;
+  if (entries.includes('.agents')) dir = '.agents/skills';
+  else if (entries.includes('.cursor')) dir = '.cursor/skills';
+  else if (entries.includes('.claude')) dir = '.claude/skills';
+  else dir = '.agents/skills';
+  return join(dir, SKILL_STEM, 'SKILL.md');
+}
+
+/** A basic TOML string: double-quoted, with backslashes and quotes escaped. */
+function tomlString(value) {
+  return '"' + String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"') + '"';
+}
+
+/** The markdown form: frontmatter the harness documents, a blank line, the body. */
+function renderMarkdown(adapterRow, agent) {
+  const fm = adapterRow.frontmatter(agent).map(([k, v]) => `${k}: ${v}`).join('\n');
+  return `---\n${fm}\n---\n\n${agent.body}\n`;
+}
+
+/**
+ * The Codex form: a TOML file. The body goes in `developer_instructions` as a
+ * multi-line basic string; a literal `"""` in the body would end the string, so
+ * one of its quotes is escaped.
+ */
+function renderToml(agent) {
+  const body = agent.body.replace(/"""/g, '\\"""');
+  return `name = ${tomlString(agent.name)}\ndescription = ${tomlString(agent.description)}\ndeveloper_instructions = """\n${body}\n"""\n`;
+}
+
+/**
+ * Render the agent for a harness and compare it to what is on disk. The tool
+ * owns the file whole, so the comparison is by bytes and the action is one of
+ * created, unchanged, updated.
+ */
+export function rendered(adapterRow, agent, existing) {
+  const text = adapterRow.format === 'toml' ? renderToml(agent) : renderMarkdown(adapterRow, agent);
+  if (existing === null) return { text, action: 'created' };
+  if (existing === text) return { text, action: 'unchanged' };
+  return { text, action: 'updated' };
+}
+
+/** Read a file as UTF-8, or null when it is not there. */
+async function readIfExists(path) {
+  try {
+    return await readFile(path, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The agent files a repository should carry, one per harness that documents an
+ * agents directory, plus the companion skill file. Reads each existing file and
+ * renders what install would write, so a dry run and a run describe the same set
+ * of files. `harness` narrows the agent files to one; the skill is always included.
+ */
+export async function planAgents(root, { harness } = {}) {
+  const agent = await loadAgent();
+  const rows = harness === undefined ? adapters() : adapters().filter((a) => a.id === harness);
+  const plan = [];
+  for (const row of rows) {
+    const path = agentPath(row.id);
+    const existing = await readIfExists(join(root, path));
+    const result = rendered(row, agent, existing);
+    plan.push({ id: row.id, path, action: result.action, text: result.text });
+  }
+  // The companion skill: one file, not per-harness.
+  const skillText = await loadSkill();
+  const skillPath = await skillDestPath(root);
+  const skillExisting = await readIfExists(join(root, skillPath));
+  const skillAction = skillExisting === null ? 'created' : skillExisting === skillText ? 'unchanged' : 'updated';
+  plan.push({ id: 'skill', path: skillPath, action: skillAction, text: skillText });
+  return plan;
+}
+
+/**
+ * Write the agent files a plan names, journaled so `undo` restores the run.
+ * Skips files that are already unchanged. Returns the paths written.
+ */
+export async function writeAgentPlan(root, journal, plan) {
+  const written = [];
+  for (const p of plan.filter((x) => x.action !== 'unchanged')) {
+    await mkdir(join(root, dirname(p.path)), { recursive: true });
+    await journaledWriteFile(root, journal, join(root, p.path), p.text);
+    written.push(p.path);
+  }
+  return written;
+}
+
+/**
+ * Write just the skill file so `installedSkills` can find it before `plan()`
+ * computes the region. Called by `init` before the region is rendered.
+ */
+export async function writeSkillFile(root, journal) {
+  const text = await loadSkill();
+  const path = await skillDestPath(root);
+  const full = join(root, path);
+  const existing = await readIfExists(full);
+  if (existing === text) return null;
+  await mkdir(dirname(full), { recursive: true });
+  await journaledWriteFile(root, journal, full, text);
+  return path;
+}

package/src/argv.mjs

@@ -10,7 +10,7 @@
 // Anything unrecognised is an error, not a silent ignore: a typo'd gate name
 // that is ignored is worse than a typo'd gate name that fails.
 
-import { EXIT, fail } from './output/index.mjs';
+import { EXIT } from './output/index.mjs';
 
 // `--quiet`, `--semantic` and `--mermaid` were here and were read by nothing (review
 // 0001 filed it; it survived every change to this file since). Each was a plan's
@@ -93,6 +93,18 @@ export const BOOL_FLAGS = new Set([
   // the deterministic outline. Off by default: no model in the default path (P1),
   // and a model that is not asked for should not be opened against (ADR-090).
   'local',
+  // doctor: apply the remedies flagged safe (local, idempotent, journaled) and
+  // list the rest. Off by default because a repair, however safe, is still a
+  // write, and a command whose name is a diagnosis should not write by default.
+  'fix',
+  // status: print the one-line gate summary from the last check. Off by
+  // default because the only mode this command has is the line; bare `status`
+  // is a usage error naming it, the way `plan` without a subcommand is.
+  'line',
+  // every writer: print the plan as unified diffs. Off by default because a
+  // plan report is the compact answer and the diff is the verbose one; --diff
+  // never changes what the run writes or its exit code, only what it shows.
+  'diff',
 ]);
 
 export const VALUE_FLAGS = new Set([
@@ -107,6 +119,14 @@ export const VALUE_FLAGS = new Set([
   'task',
   'workspace',
   'root',
+  // skills/graph: which registry to read. A value rather than a boolean because
+  // "a registry" without a path would have to guess, and the guess is the
+  // defect Q37 exists to remove (review 0003).
+  'registry',
+  // compare: how many repository rows to build at once (review 0003 Q38).
+  // A count, not a switch, because "parallel" without a cap is the burst this
+  // flag exists to prevent.
+  'concurrency',
   // skills install: which body of a multi-variant skill, and which source when the
   // bytes alone do not identify one.
   'variant',
@@ -138,6 +158,15 @@ export const VALUE_FLAGS = new Set([
   // plan done: the test command that proves the slice. Plan 0003 R31.
   'test',
   'state',
+  // slice finish: the Conventional Commits type for the commit it makes. A value,
+  // not a boolean, because a row title cannot say whether the slice was a feat, a
+  // fix or a chore, and deriving it from the words would be a guess no reader of
+  // the message could argue with (plan 0003 R53).
+  'type',
+  // lease: how long the claim lasts, in seconds. A value, because "a lease is short"
+  // is not a number any reader can act on, and an expiry nobody chose is an expiry
+  // nobody can plan around (plan 0003 R54, ADR-101).
+  'ttl',
   // map: outline (paths), names (exported symbols) or signatures (the line).
   // A boolean would not say which of the three the caller wanted.
   'level',
@@ -151,6 +180,10 @@ export const VALUE_FLAGS = new Set([
   // "generate a package" with no destination would have to guess, and a guess about where
   // a directory tree goes is the one failure that leaves files behind.
   'out',
+  // pr-body: the ref the body diffs against. A value, because the fork point is a
+  // name only the author's branch knows, and the default (origin/main, then main)
+  // is a guess the report states out loud rather than a question it asks.
+  'base',
 ]);
 
 /**
@@ -168,9 +201,29 @@ export const VALUE_FLAGS = new Set([
  */
 export const REPEATABLE_FLAGS = new Set(['skill', 'arm', 'compare', 'supersedes']);
 
+/**
+ * Whether a raw argv asks for JSON, read before parsing succeeds.
+ *
+ * A parse failure is still a result the caller may need as JSON (Q11), but the
+ * parsed flags do not exist yet — so the dispatcher reads the spelling straight
+ * off argv. Only the exact `--json` spelling counts, and nothing past `--` does:
+ * a positional that happens to read `--json` is a path, not a flag.
+ */
+export function rawJsonFlag(argv) {
+  for (const arg of argv) {
+    if (arg === '--') break;
+    if (arg === '--json') return true;
+    if (arg === '--no-json') return false;
+  }
+  return false;
+}
+
 /**
  * @param {string[]} argv raw arguments, excluding node and the script path
- * @returns {{ok: true, value: object} | {ok: false, code: number}}
+ * @returns {{ok: true, value: object} | {ok: false, error: {message: string, code: number}}}
+ *
+ * A failure is data, never output: reporting it is the caller's job, because only
+ * the caller knows whether `--json` was asked for (Q11). Nothing here prints.
  */
 export function parse(argv) {
   const flags = {};
@@ -196,14 +249,14 @@ export function parse(argv) {
     if (raw.startsWith('no-')) {
       const positive = raw.slice(3);
       if (!BOOL_FLAGS.has(positive)) {
-        return { ok: false, code: usage(`unknown flag --${raw}`) };
+        return { ok: false, error: usage(`unknown flag --${raw}`) };
       }
       flags[camel(positive)] = false;
       continue;
     }
     if (BOOL_FLAGS.has(raw)) {
       if (inlineValue !== undefined) {
-        return { ok: false, code: usage(`--${raw} takes no value`) };
+        return { ok: false, error: usage(`--${raw} takes no value`) };
       }
       flags[camel(raw)] = true;
       continue;
@@ -211,19 +264,19 @@ export function parse(argv) {
     if (VALUE_FLAGS.has(raw)) {
       const value = inlineValue ?? argv[i + 1];
       if (value === undefined || (inlineValue === undefined && value.startsWith('--'))) {
-        return { ok: false, code: usage(`--${raw} requires a value`) };
+        return { ok: false, error: usage(`--${raw} requires a value`) };
       }
       if (inlineValue === undefined) i += 1;
       if (raw === 'budget' || raw === 'max-bytes') {
         const n = Number(value);
         if (!Number.isInteger(n) || n < 0) {
-          return { ok: false, code: usage(`--${raw} must be a non-negative integer, received ${value}`) };
+          return { ok: false, error: usage(`--${raw} must be a non-negative integer, received ${value}`) };
         }
         flags[camel(raw)] = n;
       } else if (raw === 'reps') {
         const n = Number(value);
         if (!Number.isInteger(n) || n < 1) {
-          return { ok: false, code: usage(`--reps must be a positive integer, received ${value}`) };
+          return { ok: false, error: usage(`--reps must be a positive integer, received ${value}`) };
         }
         flags.reps = n;
       } else {
@@ -234,7 +287,7 @@ export function parse(argv) {
       }
       continue;
     }
-    return { ok: false, code: usage(`unknown flag --${raw}`) };
+    return { ok: false, error: usage(`unknown flag --${raw}`) };
   }
 
   return { ok: true, value: { flags, positional } };
@@ -253,5 +306,5 @@ function camel(name) {
 }
 
 function usage(message) {
-  return fail(message, EXIT.USAGE);
+  return { message, code: EXIT.USAGE };
 }

package/src/bench/ablate.mjs

@@ -11,6 +11,7 @@ import { mkdir, readFile, rm, unlink, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 
 import { MANIFEST_FILE, STATE_DIR } from '../name.mjs';
+import { LOCAL_DIR } from '../state.mjs';
 import { readManifest } from '../projection/manifest.mjs';
 import { inject, parse as parseRegion } from '../projection/markers.mjs';
 import { loadMdcRules, renderMdc, ruleName } from '../projection/mdc.mjs';
@@ -23,6 +24,7 @@ import {
   DEFAULT_BOOTSTRAP_SEED,
   compareArms,
   evaluateRunRecord,
+  holmAdjust,
   loadPrices,
   loadRunRecords,
 } from './report.mjs';
@@ -340,11 +342,14 @@ export async function ablateSectionInWorkspace(workDir, ablate) {
 
 /**
  * Decide whether a canary comparison warrants escalating the section arm to the full task suite.
+ *
+ * `pValue` overrides the comparison's raw p-values when the caller supplies a
+ * multiplicity-adjusted value (Holm over the family of sections tested in one run).
  */
-export function shouldEscalateCanary(comparison, { alpha = CANARY_ALPHA } = {}) {
+export function shouldEscalateCanary(comparison, { alpha = CANARY_ALPHA, pValue } = {}) {
   if (!comparison || !comparison.pairedTasks) return false;
-  if (comparison.mcnemar.pValue < alpha) return true;
-  if (comparison.wilcoxon.pValue < alpha) return true;
+  const p = pValue ?? Math.min(comparison.rTest.pValue, comparison.wilcoxon.pValue);
+  if (p < alpha) return true;
   if (comparison.ci95.R[0] > 0 || comparison.ci95.R[1] < 0) return true;
   if (Math.abs(comparison.deltas.R) >= 0.2) return true;
   return false;
@@ -469,15 +474,27 @@ export async function ablateBench(
       const canaryEvaluated = canaryRecords.map((rec) => evaluateRunRecord(rec, prices));
       const currentCanary = canaryEvaluated.filter((r) => r.arm === 'current');
 
+      const canaryComparisons = [];
       for (const sec of sections) {
         const armCanary = canaryEvaluated.filter((r) => r.arm === sec.arm);
         if (currentCanary.length > 0 && armCanary.length > 0) {
-          const cmp = compareArms(sec.arm, armCanary, 'current', currentCanary, { samples, seed });
-          if (shouldEscalateCanary(cmp)) {
-            escalatedArms.add(sec.arm);
-          }
+          canaryComparisons.push({
+            sec,
+            cmp: compareArms(sec.arm, armCanary, 'current', currentCanary, { samples, seed }),
+          });
         }
       }
+      // Family = every section tested in this one run: testing ~N sections at α 0.05
+      // each inflates the false-positive rate, so the p-values are Holm-adjusted
+      // before the escalation decision (review 0003 Q46).
+      const adjusted = holmAdjust(
+        canaryComparisons.map(({ cmp }) => Math.min(cmp.rTest.pValue, cmp.wilcoxon.pValue)),
+      );
+      canaryComparisons.forEach(({ sec, cmp }, i) => {
+        if (shouldEscalateCanary(cmp, { pValue: adjusted[i] })) {
+          escalatedArms.add(sec.arm);
+        }
+      });
 
       if (escalatedArms.size > 0) {
         await execRunBench(resolvedRoot, {
@@ -529,7 +546,7 @@ export async function ablateBench(
           dC: [0, 0],
           valuePerKb: [0, 0],
         },
-        mcnemar: { statistic: 0, pValue: 1, b: 0, c: 0 },
+        rTest: { statistic: 0, pValue: 1, plus: 0, minus: 0 },
         wilcoxon: { statistic: 0, pValue: 1, wPlus: 0, wMinus: 0 },
         deletionCandidate: false,
       };
@@ -566,11 +583,11 @@ export async function ablateBench(
         dC: cmp.ci95.C,
         valuePerKb: vCi,
       },
-      mcnemar: {
-        statistic: cmp.mcnemar.statistic,
-        pValue: cmp.mcnemar.pValue,
-        b: cmp.mcnemar.b,
-        c: cmp.mcnemar.c,
+      rTest: {
+        statistic: cmp.rTest.statistic,
+        pValue: cmp.rTest.pValue,
+        plus: cmp.rTest.plus,
+        minus: cmp.rTest.minus,
       },
       wilcoxon: {
         statistic: cmp.wilcoxon.statistic,
@@ -616,7 +633,7 @@ export async function ablateBench(
   const markdown = formatAblationMarkdown(result);
 
   if (apply) {
-    const outPath = join(resolvedRoot, STATE_DIR, 'bench', 'ablation.json');
+    const outPath = join(resolvedRoot, LOCAL_DIR, 'bench', 'ablation.json');
     await mkdir(dirname(outPath), { recursive: true });
     await writeFile(outPath, `${JSON.stringify({ schemaVersion: 1, ...result }, null, 2)}\n`, 'utf8');
   }

package/src/bench/mine.mjs

@@ -29,11 +29,12 @@ export const DEFAULT_MINE_TARGET = 20;
 /**
  * Classify whether a repository-relative path is a test file.
  *
- * Covers the five ecosystems named in plan 0003 §5 R01:
+ * Covers the ecosystems named in plan 0003 §5 R01:
  *   - `test/`, `tests/`, `spec/`, `__tests__/`, `src/test/`
  *   - `*.test.*`, `*.spec.*`, `*_test.*`, `*_spec.*`
  *   - `*_test.go` (Go)
  *   - `test_*.py` (pytest)
+ *   - `tests/*.rs` (Cargo integration tests)
  *   - `*Test.java`, `*Tests.java`, `*Test.kt`, `*Tests.kt` (Gradle / Maven)
  *
  * @param {string} relPath forward-slash repository-relative path
@@ -259,6 +260,31 @@ export function parseGoTestJson(text) {
   };
 }
 
+/**
+ * Parse libtest's text output, which `cargo test` prints for every test binary.
+ *
+ * A line is a result only when it has the `test <name> ... <status>` shape.
+ * Harness summaries (`test result: ok.`), compile output and doctest prose are
+ * not results. `ignored` is neither a pass nor a failure: counting it as one
+ * would make a skipped test look like evidence the change works.
+ *
+ * @param {string} text
+ * @returns {{passed: string[], failed: string[]}}
+ */
+export function parseCargoTestOutput(text) {
+  const passed = [];
+  const failed = [];
+  for (const line of String(text ?? '').split('\n')) {
+    const match = /^test\s+(.+?)\s+\.\.\.\s+(ok|FAILED|ignored)\s*$/.exec(line.trimEnd());
+    if (!match || match[2] === 'ignored') continue;
+    (match[2] === 'ok' ? passed : failed).push(match[1]);
+  }
+  return {
+    passed: dedupeSorted(passed),
+    failed: dedupeSorted(failed),
+  };
+}
+
 /**
  * Detect the test runner for a repository and build the command for a set of
  * changed test files.
@@ -302,6 +328,27 @@ export async function detectTestRunner(root, testFiles) {
     };
   }
 
+  if (existsSync(join(root, 'Cargo.toml'))) {
+    // Cargo has no "run this file" argument. An integration test is a target
+    // named after its file in `tests/`, so it can be selected with `--test`.
+    // A source file carries inline unit tests and can only be reached by the
+    // crate's test binary, so one such file means the whole crate runs.
+    const targets = dedupeSorted(
+      files.filter((f) => /^tests\/[^/]+\.rs$/.test(f)).map((f) => basename(f, '.rs')),
+    );
+    const integrationOnly = files.length > 0 && files.every((f) => /^tests\/[^/]+\.rs$/.test(f));
+    const args = ['test'];
+    if (integrationOnly) {
+      for (const target of targets) args.push('--test', target);
+    }
+    return {
+      runner: 'cargo-test',
+      displayCmd: ['cargo', ...args].join(' '),
+      buildExec: () => ({ cmd: 'cargo', args }),
+      parse: (stdout) => parseCargoTestOutput(stdout),
+    };
+  }
+
   if (existsSync(join(root, 'go.mod'))) {
     const pkgs = dedupeSorted(
       files.map((f) => {

package/src/bench/probes.mjs

@@ -25,7 +25,7 @@ import { chmod, mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 
-import { STATE_DIR } from '../name.mjs';
+import { LOCAL_DIR } from '../state.mjs';
 import { parse as parseRegion } from '../projection/markers.mjs';
 import { materialiseArm, parseArmSpec } from './run.mjs';
 
@@ -92,7 +92,7 @@ function runNode(args, { cwd, env = {} } = {}) {
  * @returns {Promise<Array<object>>}
  */
 export async function readLedgerEntries(workDir) {
-  const ledgerPath = join(workDir, STATE_DIR, 'ledger.jsonl');
+  const ledgerPath = join(workDir, LOCAL_DIR, 'ledger.jsonl');
   try {
     const text = await readFile(ledgerPath, 'utf8');
     const entries = [];
@@ -115,7 +115,7 @@ export async function readLedgerEntries(workDir) {
  * Append a ledger entry to `.simt-dev/ledger.jsonl` in `workDir`.
  */
 export async function appendLedgerEntry(workDir, entry) {
-  const ledgerPath = join(workDir, STATE_DIR, 'ledger.jsonl');
+  const ledgerPath = join(workDir, LOCAL_DIR, 'ledger.jsonl');
   await mkdir(dirname(ledgerPath), { recursive: true });
   const treeRes = await runGit(['write-tree'], { cwd: workDir });
   const record = {
@@ -1148,8 +1148,7 @@ export async function gradeProbe(probeOrId, ctx) {
  * @param {string} root
  * @returns {Promise<Array<object>>}
  */
-export async function loadProbeRecords(root) {
-  const probesRoot = join(resolve(root), STATE_DIR, 'bench', 'probes');
+export async function loadProbeRecords(root) {    const probesRoot = join(resolve(root), LOCAL_DIR, 'bench', 'probes');
   if (!existsSync(probesRoot)) return [];
 
   const entries = await readdir(probesRoot, { withFileTypes: true }).catch(() => []);
@@ -1242,7 +1241,7 @@ export async function runBenchProbes(
       for (let rep = 1; rep <= reps; rep += 1) {
         const runDir = join(
           resolvedRoot,
-          STATE_DIR,
+          LOCAL_DIR,
           'bench',
           'probes',
           `${harness}-${armSpec.name}-r${rep}`,