simt-dev 0.7.0 → 0.8.0

package/src/bench/mine.mjs

@@ -13,455 +13,28 @@
 import { execFile, spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync } from 'node:fs';
-import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { homedir, platform as osPlatform, tmpdir } from 'node:os';
+import { chmod, mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
 
-import { CONFIG_DIR } from '../name.mjs';
-import { SCHEMA_VERSION } from '../output/index.mjs';
+import { STATE_DIR } from '../name.mjs';
+import { readManifest } from '../projection/manifest.mjs';
+import { packageVersion } from '../package-version.mjs';
+import { TASK_SCHEMA_VERSION, normaliseTask } from '../measure/task-schema.mjs';
+import { isTestPath } from '../testing/paths.mjs';
+import { cleanupReports, dedupeSorted, readReports } from '../testing/parsers.mjs';
+import { detectTestRunner } from '../testing/runners.mjs';
+import { resolveVaultDir } from '../testing/vault.mjs';
 
 const exec = promisify(execFile);
-
-/** Default target task count when mining a repository's history. */
 export const DEFAULT_MINE_TARGET = 20;
 
 /**
- * Classify whether a repository-relative path is a test file.
- *
- * 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
- * @returns {boolean}
- */
-export function isTestPath(relPath) {
-  const norm = String(relPath).replaceAll('\\', '/').replace(/^\.\//, '');
-  if (!norm) return false;
-  const segments = norm.split('/');
-  const base = segments[segments.length - 1];
-
-  if (
-    norm.startsWith('test/') ||
-    norm.startsWith('tests/') ||
-    norm.startsWith('spec/') ||
-    norm.startsWith('__tests__/') ||
-    norm.startsWith('src/test/') ||
-    segments.includes('__tests__') ||
-    segments.includes('test') ||
-    segments.includes('tests') ||
-    segments.includes('spec')
-  ) {
-    return true;
-  }
-
-  if (/\.(?:test|spec)\.[A-Za-z0-9]+$/.test(base)) return true;
-  if (/_(?:test|spec)\.[A-Za-z0-9]+$/.test(base)) return true;
-  if (/^test_[^/]+\.py$/.test(base)) return true;
-  if (/Tests?\.(?:java|kt)$/.test(base)) return true;
-
-  return false;
-}
-
-/**
- * Parse TAP version 13 output from `node --test --test-reporter=tap`.
- *
- * Leaf test cases carry `type: 'test'` in their YAML block; suite headers carry
- * `type: 'suite'` and are used only to build `parent > child` qualified IDs.
- *
- * @param {string} text
- * @returns {{passed: string[], failed: string[]}}
- */
-export function parseTapOutput(text) {
-  const passed = [];
-  const failed = [];
-  const lines = String(text ?? '').split('\n');
-  const stack = [];
-  let pending = null;
-
-  const flush = () => {
-    if (!pending) return;
-    if (pending.type !== 'suite' && !pending.hadChild && !pending.directive) {
-      const id = [...pending.ancestors, pending.name].join(' > ');
-      if (pending.ok) passed.push(id);
-      else failed.push(id);
-    }
-    pending = null;
-  };
-
-  for (const raw of lines) {
-    const sub = /^(\s*)# Subtest:\s+(.*)$/.exec(raw);
-    if (sub) {
-      flush();
-      const indent = sub[1].length;
-      while (stack.length > 0 && stack[stack.length - 1].indent >= indent) {
-        stack.pop();
-      }
-      if (stack.length > 0) {
-        stack[stack.length - 1].hadChild = true;
-      }
-      stack.push({ indent, name: sub[2].trim(), hadChild: false });
-      continue;
-    }
-
-    const res = /^(\s*)(not ok|ok)\s+\d+(?:\s+-\s+(.*?))?(?:\s+#\s*(SKIP|TODO)\b.*)?$/i.exec(raw);
-    if (res) {
-      flush();
-      const indent = res[1].length;
-      while (stack.length > 0 && stack[stack.length - 1].indent > indent) {
-        stack.pop();
-      }
-      let hadChild = false;
-      if (stack.length > 0 && stack[stack.length - 1].indent === indent) {
-        hadChild = stack.pop().hadChild;
-      }
-      const ancestors = stack.map((s) => s.name);
-      const ok = res[2].toLowerCase() === 'ok';
-      const name = (res[3] ?? '').trim();
-      const directive = res[4] ? res[4].toUpperCase() : null;
-      if (name) {
-        pending = { indent, ok, name, ancestors, hadChild, directive, type: null };
-      }
-      continue;
-    }
-
-    if (pending) {
-      const typeMatch = /^\s*type:\s*['"]?(test|suite)['"]?\s*$/.exec(raw);
-      if (typeMatch) {
-        pending.type = typeMatch[1];
-      } else if (/^\s*\.\.\.\s*$/.test(raw)) {
-        flush();
-      }
-    }
-  }
-  flush();
-
-  return {
-    passed: dedupeSorted(passed),
-    failed: dedupeSorted(failed),
-  };
-}
-
-/**
- * Parse Vitest `--reporter=json` output.
- *
- * @param {string} text
- * @returns {{passed: string[], failed: string[]}}
- */
-export function parseVitestJson(text) {
-  const passed = [];
-  const failed = [];
-  const raw = String(text ?? '').trim();
-  const start = raw.indexOf('{');
-  const end = raw.lastIndexOf('}');
-  if (start === -1 || end === -1 || end < start) return { passed, failed };
-
-  let doc;
-  try {
-    doc = JSON.parse(raw.slice(start, end + 1));
-  } catch {
-    return { passed, failed };
-  }
-
-  for (const suite of doc.testResults ?? []) {
-    for (const assertion of suite.assertionResults ?? []) {
-      const parts = [...(assertion.ancestorTitles ?? []), assertion.title].filter(Boolean);
-      const id = parts.length > 0 ? parts.join(' > ') : (assertion.fullName ?? '').trim();
-      if (!id) continue;
-      if (assertion.status === 'passed') passed.push(id);
-      else if (assertion.status === 'failed') failed.push(id);
-    }
-  }
-
-  return {
-    passed: dedupeSorted(passed),
-    failed: dedupeSorted(failed),
-  };
-}
-
-/**
- * Parse JUnit XML output (used by pytest `--junitxml`, Gradle and Maven).
- *
- * @param {string} xml
- * @returns {{passed: string[], failed: string[]}}
- */
-export function parseJunitXml(xml) {
-  const passed = [];
-  const failed = [];
-  const source = String(xml ?? '');
-  const tagRe = /<testcase\b([^>]*?)(?:\/>|>([\s\S]*?)<\/testcase>)/g;
-
-  for (const match of source.matchAll(tagRe)) {
-    const attrs = match[1] ?? '';
-    const inner = match[2] ?? '';
-    const name = xmlAttr(attrs, 'name');
-    const classname = xmlAttr(attrs, 'classname');
-    if (!name) continue;
-    if (/<skipped\b/i.test(inner)) continue;
-
-    const id = classname ? `${classname} > ${name}` : name;
-    if (/<(?:failure|error)\b/i.test(inner)) failed.push(id);
-    else passed.push(id);
-  }
-
-  return {
-    passed: dedupeSorted(passed),
-    failed: dedupeSorted(failed),
-  };
-}
-
-function xmlAttr(attrs, key) {
-  const m = new RegExp(`\\b${key}=["']([^"']*)["']`).exec(attrs);
-  if (!m) return '';
-  return m[1]
-    .replaceAll('&quot;', '"')
-    .replaceAll('&apos;', "'")
-    .replaceAll('&lt;', '<')
-    .replaceAll('&gt;', '>')
-    .replaceAll('&amp;', '&')
-    .trim();
-}
-
-/**
- * Parse `go test -json` JSONL event stream.
- *
- * Only leaf test events (carrying `Test`) are recorded; package-level summary
- * events without `Test` are ignored.
- *
- * @param {string} text
- * @returns {{passed: string[], failed: string[]}}
- */
-export function parseGoTestJson(text) {
-  const passed = [];
-  const failed = [];
-  for (const line of String(text ?? '').split('\n')) {
-    const trimmed = line.trim();
-    if (!trimmed.startsWith('{')) continue;
-    let ev;
-    try {
-      ev = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-    if (typeof ev.Test !== 'string' || ev.Test.length === 0) continue;
-    const id = ev.Package ? `${ev.Package} > ${ev.Test}` : ev.Test;
-    if (ev.Action === 'pass') passed.push(id);
-    else if (ev.Action === 'fail') failed.push(id);
-  }
-
-  return {
-    passed: dedupeSorted(passed),
-    failed: dedupeSorted(failed),
-  };
-}
-
-/**
- * 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.
- *
- * @param {string} root
- * @param {string[]} testFiles
- * @returns {Promise<{runner: string, displayCmd: string, buildExec: (worktree: string) => {cmd: string, args: string[], reportPath?: string}, parse: (stdout: string, reportText?: string) => {passed: string[], failed: string[]}}|null>}
- */
-export async function detectTestRunner(root, testFiles) {
-  const files = [...testFiles].sort();
-
-  if (existsSync(join(root, 'package.json'))) {
-    let pkg = {};
-    try {
-      pkg = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
-    } catch {
-      pkg = {};
-    }
-    const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
-    const testScript = String(pkg.scripts?.test ?? '');
-    if (deps.vitest || /\bvitest\b/.test(testScript)) {
-      const bin = join('node_modules', '.bin', 'vitest');
-      return {
-        runner: 'vitest',
-        displayCmd: `vitest run --reporter=json ${files.join(' ')}`,
-        buildExec: (wt) => ({
-          cmd: existsSync(join(wt, bin)) ? join(wt, bin) : 'vitest',
-          args: ['run', '--reporter=json', ...files],
-        }),
-        parse: (stdout) => parseVitestJson(stdout),
-      };
-    }
-    return {
-      runner: 'node-test',
-      displayCmd: `node --test ${files.join(' ')}`,
-      buildExec: () => ({
-        cmd: process.execPath,
-        args: ['--test', '--test-reporter=tap', ...files],
-      }),
-      parse: (stdout) => parseTapOutput(stdout),
-    };
-  }
-
-  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) => {
-        const dir = dirname(f);
-        return dir === '.' ? './...' : `./${dir}`;
-      }),
-    );
-    return {
-      runner: 'go-test',
-      displayCmd: `go test -json ${pkgs.join(' ')}`,
-      buildExec: () => ({
-        cmd: 'go',
-        args: ['test', '-json', ...pkgs],
-      }),
-      parse: (stdout) => parseGoTestJson(stdout),
-    };
-  }
-
-  if (
-    existsSync(join(root, 'pyproject.toml')) ||
-    existsSync(join(root, 'requirements.txt')) ||
-    existsSync(join(root, 'setup.py'))
-  ) {
-    return {
-      runner: 'pytest',
-      displayCmd: `pytest ${files.join(' ')}`,
-      buildExec: (wt) => {
-        const reportPath = join(wt, '.bench-junit.xml');
-        return {
-          cmd: 'pytest',
-          args: [`--junitxml=${reportPath}`, ...files],
-          reportPath,
-        };
-      },
-      parse: (_stdout, reportText) => parseJunitXml(reportText ?? ''),
-    };
-  }
-
-  if (existsSync(join(root, 'build.gradle.kts')) || existsSync(join(root, 'build.gradle'))) {
-    const classes = files
-      .map((f) => basename(f).replace(/\.(?:java|kt)$/, ''))
-      .filter(Boolean);
-    const filterArgs = classes.flatMap((c) => ['--tests', `*${c}*`]);
-    return {
-      runner: 'gradle',
-      displayCmd: `./gradlew test ${filterArgs.join(' ')}`.trim(),
-      buildExec: (wt) => ({
-        cmd: existsSync(join(wt, 'gradlew')) ? join(wt, 'gradlew') : 'gradle',
-        args: ['test', ...filterArgs],
-        reportDir: join(wt, 'build', 'test-results', 'test'),
-      }),
-      parse: (_stdout, reportText) => parseJunitXml(reportText ?? ''),
-    };
-  }
-
-  if (existsSync(join(root, 'pom.xml'))) {
-    const classes = files
-      .map((f) => basename(f).replace(/\.(?:java|kt)$/, ''))
-      .filter(Boolean);
-    const arg = classes.length > 0 ? [`-Dtest=${classes.join(',')}`] : [];
-    return {
-      runner: 'maven',
-      displayCmd: `mvn test ${arg.join(' ')}`.trim(),
-      buildExec: () => ({
-        cmd: 'mvn',
-        args: ['test', ...arg],
-      }),
-      parse: (_stdout, reportText) => parseJunitXml(reportText ?? ''),
-    };
-  }
-
-  return null;
-}
-
-/**
- * Resolve the hidden verifier vault root outside every worktree.
- *
- * Precedence:
- *   1. `SIMT_DEV_VAULT_DIR` (explicit override for hermetic tests)
- *   2. `$XDG_CACHE_HOME/simt-dev/vault/<repo-id>`
- *   3. `~/Library/Caches/simt-dev/vault/<repo-id>` on macOS, or `~/.cache/simt-dev/vault/<repo-id>`
- *
- * @param {string} root
- * @param {{env?: NodeJS.ProcessEnv, home?: string, platform?: string}} [options]
- * @returns {string}
- */
-export function resolveVaultDir(root, { env = process.env, home = homedir(), platform = osPlatform() } = {}) {
-  const repoId = repoIdentifier(root);
-  if (env.SIMT_DEV_VAULT_DIR) {
-    return join(resolve(env.SIMT_DEV_VAULT_DIR), repoId);
-  }
-  const cacheBase = env.XDG_CACHE_HOME
-    ? resolve(env.XDG_CACHE_HOME)
-    : platform === 'darwin'
-      ? join(home, 'Library', 'Caches')
-      : join(home, '.cache');
-  return join(cacheBase, CONFIG_DIR, 'vault', repoId);
-}
-
-function repoIdentifier(root) {
-  const full = resolve(root);
-  const name = basename(full).replace(/[^A-Za-z0-9._-]/g, '-') || 'repo';
-  const digest = createHash('sha256').update(full).digest('hex').slice(0, 8);
-  return `${name}-${digest}`;
-}
-
-/**
- * Compute diff stats (`files`, `linesAdded`, `linesRemoved`) from a unified diff buffer.
- *
- * @param {Buffer|string} patch
- * @param {number} fileCount
- * @returns {{files: number, linesAdded: number, linesRemoved: number}}
+ * Test paths excluded by default, overridable via `simt.json` `bench.mine.exclude`
+ * (review 0003 Q48: the pack integration test was hardcoded here, a repo fact, not a miner fact).
  */
+const DEFAULT_EXCLUDES = ['test/pack.test.mjs'];
 export function patchStats(patch, fileCount) {
   const text = Buffer.isBuffer(patch) ? patch.toString('utf8') : String(patch ?? '');
   let linesAdded = 0;
@@ -519,7 +92,11 @@ export async function listCandidates(root) {
 
     const cleanSubject = (subject ?? '').trim();
     const cleanBody = (body ?? '').trim();
-    const prompt = cleanBody ? `${cleanSubject}\n\n${cleanBody}` : cleanSubject;
+    // Subject only by default. A commit body usually narrates the fix ("use x * x * x
+    // here"), which hands the agent the answer and measures nothing; a repository whose
+    // messages are curated can ask for the whole message with `bench.mine.prompt: "body"`
+    // (review 0003 Q49).
+    const prompt = cleanSubject;
 
     candidates.push({
       sha: sha.trim(),
@@ -584,15 +161,16 @@ function runProcess(cmd, args, { cwd, input, env, timeoutMs = 15000 } = {}) {
 
 async function executeRunner(runner, worktree, env, timeoutMs) {
   const spec = runner.buildExec(worktree);
-  if (spec.reportPath && existsSync(spec.reportPath)) {
-    await rm(spec.reportPath, { force: true });
+  // Remove what a previous run left behind before running: a stale report
+  // would parse as this run's result, and a directory report accumulates
+  // one XML per class across runs.
+  for (const p of spec.reportPaths ?? []) {
+    if (existsSync(p)) await rm(p, { recursive: true, force: true });
   }
   const res = await runProcess(spec.cmd, spec.args, { cwd: worktree, env, timeoutMs });
-  let reportText = '';
-  if (spec.reportPath && existsSync(spec.reportPath)) {
-    reportText = await readFile(spec.reportPath, 'utf8').catch(() => '');
-  }
+  const reportText = await readReports(spec.reportPaths);
   const parsed = runner.parse(res.stdout, reportText);
+  await cleanupReports(spec.reportPaths);
   return {
     code: res.code,
     timedOut: res.timedOut,
@@ -606,10 +184,20 @@ async function executeRunner(runner, worktree, env, timeoutMs) {
  * twice, dropping any candidate whose test outcomes are not identical across both
  * passes.
  */
-async function validateCandidate(root, worktree, candidate, { timeoutMs = 5000 } = {}) {
-  // Skip commits that modify more than 4 test files or run `npm pack` integration
-  // builds, which are sweeping renames rather than self-contained benchmark tasks.
-  if (candidate.testFiles.length > 4 || candidate.testFiles.includes('test/pack.test.mjs')) {
+async function validateCandidate(
+  root,
+  worktree,
+  candidate,
+  { timeoutMs = 5000, exclude = DEFAULT_EXCLUDES, promptMode = 'subject' } = {},
+) {
+  // Skip commits that modify more than 4 test files, or that touch a path
+  // the repository's manifest excludes (`simt.json` bench.mine.exclude,
+  // defaulting to the pack integration test the committed corpus was mined
+  // around): sweeping renames rather than self-contained benchmark tasks.
+  if (
+    candidate.testFiles.length > 4 ||
+    candidate.testFiles.some((f) => exclude.includes(f))
+  ) {
     return null;
   }
 
@@ -682,17 +270,23 @@ async function validateCandidate(root, worktree, candidate, { timeoutMs = 5000 }
   const p2p = gold1.passed.filter((id) => redPassedSet.has(id) && !redFailedSet.has(id));
   if (f2p.length === 0) return null;
 
-  const shortSha = candidate.sha.slice(0, 7);
-  const id = `t-${shortSha}-01`;
+  // 12 hex chars of the source commit: the 7-char form plus a fixed `-01`
+  // suffix could not disambiguate two tasks from the same commit (review 0003
+  // Q48). Collisions are checked at write time, where the corpus is visible.
+  const id = `t-${candidate.sha.slice(0, 12)}-01`;
   const gold = patchStats(goldPatch, candidate.implFiles.length);
 
   return {
     task: {
-      schemaVersion: SCHEMA_VERSION,
+      schemaVersion: TASK_SCHEMA_VERSION,
       id,
       base: candidate.base,
       sourceCommit: candidate.sha,
-      prompt: candidate.prompt,
+      prompt:
+        promptMode === 'body' && candidate.body
+          ? `${candidate.subject}\n\n${candidate.body}`
+          : candidate.subject,
+      promptBasis: promptMode === 'body' && candidate.body ? 'body' : 'subject',
       testCmd: runner.displayCmd,
       f2p,
       p2p,
@@ -713,8 +307,12 @@ async function validateCandidate(root, worktree, candidate, { timeoutMs = 5000 }
  * temporary worktrees until `target` valid tasks are collected, and written
  * deterministically to disk.
  *
+ * Writing is append-only: existing task files are left alone unless `replace`
+ * is set, which restores the old "reflect exactly this history" semantics by
+ * deleting files the current history does not reproduce (review 0003 Q48).
+ *
  * @param {string} root
- * @param {{apply?: boolean, target?: number, concurrency?: number, timeoutMs?: number, env?: NodeJS.ProcessEnv}} [options]
+ * @param {{apply?: boolean, target?: number, concurrency?: number, timeoutMs?: number, replace?: boolean, env?: NodeJS.ProcessEnv}} [options]
  */
 export async function mineTasks(
   root,
@@ -723,6 +321,7 @@ export async function mineTasks(
     target = DEFAULT_MINE_TARGET,
     concurrency = 4,
     timeoutMs = 5000,
+    replace = false,
     env = process.env,
   } = {},
 ) {
@@ -732,12 +331,20 @@ export async function mineTasks(
     return { ok: false, error: listed.error };
   }
 
-  const tasksDir = join(absRoot, '.simt', 'bench', 'tasks');
+  // Repository-declared mining config (review 0003 Q48): an explicit option
+  // wins, then the manifest, then the default.
+  const { manifest } = await readManifest(absRoot);
+  const benchCfg = manifest?.bench?.mine ?? {};
+  const effectiveTimeout = benchCfg.timeoutMs ?? timeoutMs;
+  const exclude = benchCfg.exclude ?? DEFAULT_EXCLUDES;
+  const promptMode = benchCfg.prompt === 'body' ? 'body' : 'subject';
+
+  const tasksDir = join(absRoot, STATE_DIR, 'bench', 'tasks');
   const vaultRoot = resolveVaultDir(absRoot, { env });
 
   if (!apply) {
     const preview = listed.candidates.slice(0, target).map((c) => ({
-      id: `t-${c.sha.slice(0, 7)}-01`,
+      id: `t-${c.sha.slice(0, 12)}-01`,
       base: c.base,
       sourceCommit: c.sha,
       subject: c.subject,
@@ -790,7 +397,11 @@ export async function mineTasks(
         cursor += 1;
         if (index >= listed.candidates.length) break;
         const candidate = listed.candidates[index];
-        const res = await validateCandidate(absRoot, wt, candidate, { timeoutMs });
+        const res = await validateCandidate(absRoot, wt, candidate, {
+          timeoutMs: effectiveTimeout,
+          exclude,
+          promptMode,
+        });
         if (res) {
           validated.push({ index, ...res });
         }
@@ -805,28 +416,68 @@ export async function mineTasks(
     const selected = validated.slice(0, target);
 
     await mkdir(tasksDir, { recursive: true });
-    await mkdir(vaultRoot, { recursive: true });
-
-    // Remove stale task files when re-mining so the directory reflects the
-    // deterministic set for this history.
-    const existing = await readdir(tasksDir).catch(() => []);
-    const keepNames = new Set(selected.map((entry) => `${entry.task.id}.json`));
-    for (const name of existing) {
-      if (name.endsWith('.json') && !keepNames.has(name)) {
-        await rm(join(tasksDir, name), { force: true });
+    await mkdir(vaultRoot, { recursive: true, mode: 0o700 });
+    // The hidden tests are the answer key: 0700 keeps every other local account out.
+    // `mkdir` alone does not tighten a vault an earlier run created.
+    await chmod(vaultRoot, 0o700).catch(() => {});
+
+    // Mining is append-only (review 0003 Q48: `mineTasks(target 3)` once
+    // deleted all 20 committed tasks and wrote 3 others). `replace` restores
+    // the old "reflect exactly this history" semantics, and only it deletes.
+    if (replace) {
+      const existing = await readdir(tasksDir).catch(() => []);
+      const keepNames = new Set(selected.map((entry) => `${entry.task.id}.json`));
+      for (const name of existing) {
+        if (name.endsWith('.json') && !keepNames.has(name)) {
+          await rm(join(tasksDir, name), { force: true });
+        }
       }
     }
 
     for (const entry of selected) {
       const taskPath = join(tasksDir, `${entry.task.id}.json`);
-      await writeFile(taskPath, `${JSON.stringify(entry.task, null, 2)}\n`, 'utf8');
+      // An id belongs to exactly one source commit. If a file with this id
+      // holds a different commit, the 12-char prefix collided and guessing
+      // which corpus the reader wants is worse than refusing.
+      if (existsSync(taskPath) && !replace) {
+        const prior = JSON.parse(await readFile(taskPath, 'utf8'));
+        if (prior.sourceCommit !== entry.task.sourceCommit) {
+          return {
+            ok: false,
+            applied: false,
+            error: `id collision: ${taskPath} holds task from ${prior.sourceCommit}, mine produced ${entry.task.sourceCommit}; rerun with --replace to take over the corpus`,
+          };
+        }
+      }
+      // The miner is the writer, so it writes the schema a reader validates: a task file
+      // that only becomes valid on load is a file two readers can disagree about.
+      await writeFile(
+        taskPath,
+        `${JSON.stringify(normaliseTask(entry.task, { source: taskPath }), null, 2)}\n`,
+        'utf8',
+      );
 
       const taskVault = join(vaultRoot, entry.task.id);
-      await mkdir(taskVault, { recursive: true });
+      await mkdir(taskVault, { recursive: true, mode: 0o700 });
+      await chmod(taskVault, 0o700).catch(() => {});
       await writeFile(join(taskVault, 'test.patch'), entry.testPatch);
       await writeFile(join(taskVault, 'gold.patch'), entry.goldPatch);
     }
 
+    // The corpus records where it came from: which commit was HEAD when the
+    // mine ran, the target, and the simt version that validated the tasks.
+    // No timestamp — a re-mine at the same HEAD is byte-identical.
+    const { stdout: headSha } = await exec('git', ['rev-parse', 'HEAD'], { cwd: absRoot });
+    await writeFile(
+      join(dirname(tasksDir), 'corpus.json'),
+      `${JSON.stringify(
+        { minedFrom: headSha.trim(), target, simtVersion: packageVersion() },
+        null,
+        2,
+      )}\n`,
+      'utf8',
+    );
+
     return {
       ok: true,
       applied: true,
@@ -844,11 +495,6 @@ export async function mineTasks(
     await rm(sandbox, { recursive: true, force: true }).catch(() => null);
   }
 }
-
-function dedupeSorted(items) {
-  return [...new Set(items)].sort();
-}
-
 function sameList(a, b) {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i += 1) {