testguard-cli 0.15.1 → 0.17.0

package/src/init/templates/SKILL.md

@@ -9,8 +9,66 @@ TestGuard injects the faults a project's claims forbid and reports every one
 the tests fail to detect. It is a **claim verifier**, not a test generator.
 You operate it through one loop and one source of truth.
 
+## Update advice (once per session, never an automatic install)
+
+Before the operating loop, identify the CLI you will actually run: prefer the
+project's installed `node_modules/.bin/testguard`, then the repository-root
+install for a nested project, then `testguard` on PATH. Run that exact CLI with
+`--version`, and use the same executable for verification. Do not use `npx` to
+discover a version: it can fetch or install a different tool. When developing
+TestGuard itself, use `node cli/testguard.mjs`; do not replace a source checkout
+with a published version to make validation pass.
+
+If the user's network policy permits registry access, make one bounded,
+read-only check per session (not per command or project):
+
+```bash
+npm view testguard-cli dist-tags.latest --json --fetch-retries=0 --fetch-timeout=5000
+```
+
+Compare valid stable versions by numeric SemVer major, minor, then patch, not
+lexicographically and not merely for inequality. Do not recommend a downgrade
+or replacing a prerelease/development checkout. If the registry result is
+missing, malformed, unavailable, or network access is prohibited, continue the
+operating loop without claiming the installation is up to date. No retries or
+repeated prompts after the user declines within this session.
+
+For a newer stable version, say: "Using TestGuard X from <resolved executable>;
+Y is available. Would you like to update?" Respect project pins, compatibility,
+company policy and the original package manager; a registry's `latest` tag is
+not proof that an upgrade is safe. Never install automatically, modify a
+lockfile or CI pin, or switch between local and global installs without approval.
+After an approved update, verify the same executable's version again.
+
+Keep this advice in the AI conversation, separate from CLI JSON, evidence,
+verdicts and exit codes. The CLI and session-start hook remain offline; the AI
+performs this optional check, not TestGuard. Instructions cannot guarantee that
+every AI checks for updates.
+
+Package upgrades do not refresh an existing copied skill. Preserve customized
+instructions: compare this file with the upgraded package's
+`src/init/templates/SKILL.md` and merge approved changes. Use `testguard init
+--force` only with explicit permission to replace the whole skill; review the
+diff afterward. An ordinary `init` preserves existing skills and managed
+sections already listing this project.
+
 ## The one source of truth
 
+Missing source-link advisories in claims/status never replace `next`, change
+verdicts or prove intent. Exact anchors remain checked without annotations.
+Origin summaries are likewise informational: status counts current declared
+claims; evidence/briefs count recorded declarations and records, including
+mixed sources. Source kinds are not authenticated independence. Never use an
+origin label to waive a survivor.
+Optional source links: `testguard claims --annotate --claim <ID>` is a read-only
+file-header preview. Only with explicit permission to edit source, rerun with
+`--apply`; each invocation recomputes its plan. Review refusals and partial
+failures, and retain the reported private recovery originals. Never automatically
+remove an existing lock or roll back over user edits. Placement is file-level,
+not symbol ownership, verified behavior or authenticated intent. Missing links
+do not disable exact fault-anchor checks. Authoring never replaces the status
+operating loop or writes canonical claims/evidence/baselines.
+
 ```bash
 testguard status --json
 ```
@@ -33,6 +91,18 @@ Exit codes: `0` clean · `1` unproven claims (or drift, or unclaimed changes) ·
 
 ## Every change needs a claim
 
+Scaffold proposes mechanical faults, not intended behavior. New drafts declare
+`source.kind: inferred` even when grouped by an annotation. Before adopting a
+draft, ask for the intended observable behavior from a requirement, ADR, bug or
+incident independently of the implementation: inputs, expected outcome and
+forbidden outcome. Record the supplied source kind/ref; when unavailable, keep
+inferred and say the intent remains unestablished. Do not promote origin because
+an annotation exists or tests pass. References are opaque, not authenticated;
+verification commands never fetch them. Preserve existing supplied metadata.
+Review each proposal against that intent, then probe. Do not paraphrase the code
+and call that independent intent, or automatically move drafts into canonical
+claims.
+
 `probe` verifies only the claims that exist; it is silent about unclaimed
 code by construction. So, for every source file you create or change:
 
@@ -65,6 +135,14 @@ code by construction. So, for every source file you create or change:
 
 ## The fix loop
 
+For independently supplied intent in an existing disposable draft, use
+`testguard scaffold <source...> --into <draft.json> --claim <existing-ID> --json`
+to preview appended faults without writes. Omit `--json` only when explicitly
+authorized to update that draft; private recovery is retained. Never use a
+canonical claims/evidence/baseline path. Preserve intended behavior and declared
+origin; generated faults are not independent intent or verification. Review the
+faults and probe the selected draft before promoting it to canonical claims.
+
 1. `testguard status --json` → take `next.target`.
 2. Write the test. It must **fail when the fault is applied and pass on HEAD**. To check the first half by hand: apply `find` → `replace` in the target file, run the defender, restore.
 3. `testguard admit <test-file> --claim <ID>` — the two gates as one verb, on your uncommitted test, without touching the tree: `ADMITTED` (exit 0) means the test is green on HEAD and fails on every fault of the claim, 3/3; `NOT ADMITTED` (exit 1) names the first blocking fault and what to do. `--fault <FID>` judges one fault; `--confirm 1` gives a fast **provisional** `ADMITTED?` that must be confirmed at 3 before you commit. (`testguard probe --claim <ID> --include-dirty` is the same run with the full report.)

package/src/probe/attribution.mjs

@@ -11,8 +11,17 @@
  * worktree is. Everything it needs is passed in.
  */
 
+import { isDeepStrictEqual } from 'node:util';
+
 const isKill = (r) => r.outcome === 'fail' && (r.assertionFailures ?? 0) > 0;
 
+/** Compare only the claim metadata actually recorded in evidence. */
+export function sameClaimMetadata(recorded, current) {
+  if (!recorded || !current) return false;
+  const metadata = ({ id, statement, severity, source, producedBy }) => ({ id, statement, severity, source, producedBy });
+  return isDeepStrictEqual(metadata(recorded), metadata(current));
+}
+
 /**
  * Fold one escalation run into the running attribution state.
  *
@@ -109,11 +118,21 @@ export function subjectOf(fault, sha256) {
  * The cost of re-measuring is a run; the cost of the other direction is a
  * verdict nobody measured.
  */
+/** Select declarations without resolving globs or running discovery. */
+export function defenderSelection(claim, fault) {
+  if (Object.hasOwn(fault, 'defendedBy')) return { requested: [...fault.defendedBy], selectionSource: 'fault' };
+  if (claim.defendedBy?.length) return { requested: [...claim.defendedBy], selectionSource: 'claim' };
+  return { requested: [], selectionSource: 'discovery' };
+}
+
 export function isReusable(prior, current) {
   if (!prior || !prior.subject?.contentHash) return false;
+  if (current.claim && !sameClaimMetadata(prior.claim, current.claim)) return false;
   // A record that exists because the probe threw is a statement about the run,
   // not about the code. Reusing it would make one disturbed run permanent.
   if (prior.detail?.reason === 'probe-error') return false;
+  const origin = prior.defenders.selectionSource ?? (prior.defenders.requested.length ? 'claim' : 'discovery');
+  if (current.selectionSource && origin !== current.selectionSource) return false;
   const same = (x, y) => JSON.stringify(x) === JSON.stringify(y);
   return prior.inputs.targetHash === current.inputs.targetHash
     && same(prior.inputs.defenderHashes, current.inputs.defenderHashes)

package/src/probe/contention.mjs

@@ -37,9 +37,13 @@ export function processList({ platform = process.platform, run = spawnSync } = {
   try {
     const r = platform === 'win32'
       ? run('wmic', ['process', 'get', 'ProcessId,CommandLine', '/format:csv'], { encoding: 'utf8', timeout: 5000 })
-      : run('ps', ['-Ao', 'pid=,args='], { encoding: 'utf8', timeout: 5000 });
+      : run('ps', ['-Ao', 'pid=,ppid=,stat=,args='], { encoding: 'utf8', timeout: 5000 });
     if (r.status !== 0 || !r.stdout) return [];
     return r.stdout.split('\n').map((line) => {
+      if (platform !== 'win32') {
+        const row = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
+        if (row) return { pid: Number(row[1]), ppid: Number(row[2]), stat: row[3], command: row[4].trim() };
+      }
       const m = platform === 'win32' ? /^[^,]*,(.*),(\d+)\s*$/.exec(line) : /^\s*(\d+)\s+(.*)$/.exec(line);
       if (!m) return null;
       const [pid, command] = platform === 'win32' ? [m[2], m[1]] : [m[1], m[2]];
@@ -57,8 +61,22 @@ export function processList({ platform = process.platform, run = spawnSync } = {
  */
 export function detectContention({ self = process.pid, alive = defaultAlive, ...opts } = {}) {
   const rows = processList(opts);
+  const owned = new Set([self]);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const row of rows) {
+      if (owned.has(row.ppid) && !owned.has(row.pid)) { owned.add(row.pid); changed = true; }
+    }
+  }
+  const ancestors = new Set();
+  let parent = rows.find((row) => row.pid === self)?.ppid;
+  while (parent && !ancestors.has(parent)) {
+    ancestors.add(parent);
+    parent = rows.find((row) => row.pid === parent)?.ppid;
+  }
   const runners = rows
-    .filter((p) => p.pid !== self && RUNNER_RE.test(p.command) && !SELF_RE.test(p.command))
+    .filter((p) => !owned.has(p.pid) && !ancestors.has(p.pid) && !p.stat?.startsWith('Z') && RUNNER_RE.test(p.command) && (p.ppid !== undefined || !SELF_RE.test(p.command)))
     // `ps` lists the grep/ps itself and any shell wrapper; a runner's command
     // line always names its own binary, so require it to look like an exec.
     .filter((p) => !/^\s*(ps|grep|wmic)\b/.test(p.command))

package/src/probe/cost.mjs

@@ -12,7 +12,7 @@
  * already recorded. Nothing re-measures, nothing spawns, nothing guesses: a
  * cost report costs the price of reading one JSON file.
  *
- * ATTRIBUTION, HONESTLY. Runs execute a claim's whole defender set together,
+ * ATTRIBUTION, HONESTLY. Runs execute a fault's selected defender set together,
  * so the runner never says how much of a run belonged to which file. Per-file
  * `ms` is therefore the time of every run that *included* that file: an upper
  * bound on what removing it could save, and, when a claim names several
@@ -70,15 +70,16 @@ export function defenderCosts(records) {
   for (const r of records) {
     const c = recordCost(r);
     for (const file of r.defenders?.resolved ?? []) {
-      const e = by.get(file) ?? { file, ms: 0, runs: 0, claims: new Set() };
+      const e = by.get(file) ?? { file, ms: 0, runs: 0, claims: new Set(), faults: new Set() };
       e.ms += c.ms;
       e.runs += c.runs;
       e.claims.add(r.claim.id);
+      e.faults.add(`${r.claim.id}/${r.subject.id}`);
       by.set(file, e);
     }
   }
   return [...by.values()]
-    .map((e) => ({ ...e, claims: [...e.claims].sort() }))
+    .map((e) => ({ ...e, claims: [...e.claims].sort(), faults: [...e.faults].sort() }))
     .sort((a, b) => b.ms - a.ms || a.file.localeCompare(b.file));
 }
 
@@ -86,22 +87,25 @@ export function defenderCosts(records) {
  * The whole cost model for one evidence document.
  *
  * `sharedDefenders` is the actionable part: a file named by more than one
- * claim, whose cost is multiplied by every claim that names it. Splitting the
+ * fault identity, including siblings within one claim. Splitting the
  * behaviour it defends into a unit test that runs in milliseconds is what
  * turns a twenty-four-minute gate into a one-minute one, and until a report
  * names the file nobody knows which test to split.
  */
-export function costReport(records) {
+export function costReport(records, { run } = {}) {
   const claims = claimCosts(records);
   const defenders = defenderCosts(records);
   return {
+    ...(run?.measurements ? { measurements: { ...run.measurements } } : {}),
     totalMs: claims.reduce((a, c) => a + c.ms, 0),
     totalRuns: claims.reduce((a, c) => a + c.runs, 0),
     reusedRecords: records.filter((r) => r.reusedFrom).length,
     records: records.length,
     claims,
+    faults: records.map((r) => ({ claimId: r.claim.id, faultId: r.subject.id, ...recordCost(r), defenders: [...(r.defenders?.resolved ?? [])], ...(r.defenders?.selectionSource ? { selectionSource: r.defenders.selectionSource } : {}) }))
+      .sort((a, b) => b.ms - a.ms || a.claimId.localeCompare(b.claimId) || a.faultId.localeCompare(b.faultId)),
     defenders,
-    sharedDefenders: defenders.filter((d) => d.claims.length > 1),
+    sharedDefenders: defenders.filter((d) => d.faults.length > 1),
   };
 }
 
@@ -115,6 +119,10 @@ export const formatMs = secs;
  */
 export function renderCost(report, { limit = 10 } = {}) {
   const out = [];
+  if (report.measurements) {
+    const m = report.measurements;
+    out.push(`actual elapsed ${secs(m.elapsedMs)}; fresh runners ${secs(m.runnerMs)} across ${m.runnerInvocations} invocations; setup/discovery/other overhead ${secs(m.overheadMs)}`);
+  }
   if (!report.records) return 'no evidence records — run `testguard probe` first; cost is read back from the runs it records.';
   out.push(`${report.records} fault record${report.records === 1 ? '' : 's'} cost ${secs(report.totalMs)} across ${report.totalRuns} defender runs${report.reusedRecords ? ` (${report.reusedRecords} reused; their runs are what they cost when reuse does not apply)` : ''}.`);
   out.push('');
@@ -123,19 +131,24 @@ export function renderCost(report, { limit = 10 } = {}) {
     out.push(`  ${secs(c.ms).padStart(7)}  ${c.claimId.padEnd(34)} ${c.faults} fault${c.faults === 1 ? ' ' : 's'} · ${c.runs} runs${c.reused ? ` · ${c.reused} reused` : ''}`);
   }
   if (report.claims.length > limit) out.push(`  … ${report.claims.length - limit} more`);
+  if (report.faults?.length) {
+    out.push('', 'most expensive faults');
+    for (const f of report.faults.slice(0, limit)) out.push(`  ${secs(f.ms).padStart(7)}  ${f.claimId}/${f.faultId} · ${f.runs} runs${f.selectionSource ? ` · ${f.selectionSource}` : ''} · ${f.defenders.join(', ') || 'no defenders'}`);
+    if (report.faults.length > limit) out.push(`  … ${report.faults.length - limit} more`);
+  }
   out.push('');
   out.push('defender files, by the time of the runs that included them');
-  out.push('  (a claim runs its whole defender set at once, so these overlap and do not sum to the total)');
+  out.push('  (a fault runs its selected defender set at once, so these overlap and do not sum to the total)');
   for (const d of report.defenders.slice(0, limit)) {
     out.push(`  ${secs(d.ms).padStart(7)}  ${d.file.padEnd(44)} ${d.claims.length} claim${d.claims.length === 1 ? '' : 's'}`);
   }
   if (report.defenders.length > limit) out.push(`  … ${report.defenders.length - limit} more`);
   if (report.sharedDefenders.length) {
     out.push('');
-    out.push('shared defenders — each claim pays the file\'s full cost again');
+    out.push('shared defenders — each fault selects the file; durations include recorded baseline sharing');
     for (const d of report.sharedDefenders.slice(0, limit)) {
       out.push(`  ${secs(d.ms).padStart(7)}  ${d.file}`);
-      out.push(`           named by ${d.claims.join(', ')}`);
+      out.push(`           named by ${d.faults.join(', ')}`);
     }
     out.push('');
     out.push('  To make a probe cheaper, split the behaviour a shared defender proves into a');

package/src/probe/inject.mjs

@@ -1,3 +1,4 @@
+import { registerCleanup } from './runners/lifecycle.mjs';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
@@ -19,12 +20,7 @@ function restoreAll() {
 function installHandlers() {
   if (handlersInstalled) return;
   handlersInstalled = true;
-  for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
-    process.on(sig, () => {
-      restoreAll();
-      process.exit(130);
-    });
-  }
+  registerCleanup(restoreAll, { priority: 1 });
   process.on('uncaughtException', (err) => {
     restoreAll();
     throw err;

package/src/probe/origin-policy.mjs

@@ -0,0 +1,69 @@
+import { isDeepStrictEqual } from 'node:util';
+import { validate, methodOf } from '../../spec/lib/validate.mjs';
+import { CLAIM_SOURCE_KINDS } from '../../spec/lib/origins.mjs';
+import { sameClaimMetadata, subjectOf } from './attribution.mjs';
+import { sha256 } from '../util/hash.mjs';
+
+/** Admit the planned probe option before loading claims or executing/writing. */
+export function originPolicyRequest(values, command = 'probe') {
+  const raw = values['require-origin'];
+  if (raw === undefined) return undefined;
+  if (command !== 'probe') throw new TypeError('--require-origin is only valid on probe');
+  if (!Array.isArray(raw) || !raw.length || raw.some((v) => typeof v !== 'string')) {
+    throw new TypeError('--require-origin must name declared source kinds');
+  }
+  const kinds = raw.flatMap((v) => v.split(',').map((k) => k.trim()));
+  if (kinds.some((k) => !CLAIM_SOURCE_KINDS.includes(k))) throw new TypeError('--require-origin contains an empty or unsupported kind');
+  if (values.claim !== undefined || values['allow-empty'] || values.ref !== undefined || values['ignore-dirty']) {
+    throw new TypeError('--require-origin needs a complete current-project run without --claim, --allow-empty, --ref or --ignore-dirty');
+  }
+  const n = Number(values.confirm ?? 3);
+  if (!Number.isInteger(n) || n < 3) throw new TypeError('--require-origin requires --confirm of at least 3');
+  return [...new Set(kinds)].sort();
+}
+
+/** Internal policy only: fresh must come from the existing input-binding checker. */
+export function evaluateOriginPolicy({ claims, evidence, eligibleKinds, fresh }) {
+  if (eligibleKinds === undefined) return undefined;
+  if (!Array.isArray(eligibleKinds) || !eligibleKinds.length || eligibleKinds.some((k) => !CLAIM_SOURCE_KINDS.includes(k))) {
+    throw new TypeError('origin policy needs a nonempty set of declared source kinds');
+  }
+  const eligible = [...new Set(eligibleKinds)].sort();
+  const reasons = new Set();
+  const claimsValid = validate('claims', claims).ok;
+  const evidenceValid = validate('evidence', evidence).ok;
+  if (!claimsValid) reasons.add('invalid-claims');
+  if (!evidenceValid) reasons.add('invalid-evidence');
+  if (fresh !== true) reasons.add('stale-inputs');
+  const current = claimsValid ? claims.claims : [];
+  const records = evidenceValid ? evidence.records : [];
+  const key = (claimId, faultId) => JSON.stringify([claimId, faultId]);
+  const expected = new Map(current.flatMap((claim) => claim.faults.map((fault) => [key(claim.id, fault.id), { claim, fault }])));
+  if (!current.length || !expected.size) reasons.add('empty-universe');
+  if (evidenceValid && (evidence.run.provisional === true || evidence.run.confirmRuns < 3)) reasons.add('provisional-evidence');
+  if (evidenceValid && methodOf(evidence.run) !== 'fault-injection') reasons.add('incompatible-method');
+  if (current.some((c) => c.faults.some((f) => methodOf(f) !== 'fault-injection'))) reasons.add('incompatible-method');
+  const seen = new Set();
+  for (const record of records) {
+    const identity = key(record.claim.id, record.subject.id);
+    if (seen.has(identity)) reasons.add('duplicate-record');
+    seen.add(identity);
+    const pair = expected.get(identity);
+    if (!pair) { reasons.add('extra-record'); continue; }
+    if (!sameClaimMetadata(record.claim, pair.claim)) reasons.add('claim-metadata-mismatch');
+    if (methodOf(pair.fault) !== 'fault-injection') continue;
+    const subject = subjectOf(pair.fault, sha256);
+    if (['kind', 'id', 'file', 'faultClass', 'contentHash'].some((field) => record.subject[field] !== subject[field])
+      || !isDeepStrictEqual(record.subject.producedBy, subject.producedBy)) reasons.add('fault-mismatch');
+  }
+  if ([...expected.keys()].some((identity) => !seen.has(identity))) reasons.add('missing-record');
+  const ineligibleClaims = current.filter((c) => !eligible.includes(c.source.kind)).map((c) => c.id).sort();
+  const nonKilledFaults = [...new Map(records.filter((r) => r.verdict !== 'killed').map((r) =>
+    [key(r.claim.id, r.subject.id), { claimId: r.claim.id, faultId: r.subject.id }])).values()]
+    .sort((a, b) => a.claimId.localeCompare(b.claimId) || a.faultId.localeCompare(b.faultId));
+  return {
+    state: reasons.size ? 'unavailable' : ineligibleClaims.length || nonKilledFaults.length ? 'failed' : 'passed',
+    eligibleKinds: eligible, claims: current.length, faults: expected.size,
+    ineligibleClaims, nonKilledFaults, unavailableReasons: [...reasons].sort(),
+  };
+}

package/src/probe/policy-freshness.mjs

@@ -0,0 +1,74 @@
+import { closeSync, constants, fstatSync, openSync, readFileSync, realpathSync } from 'node:fs';
+import { isAbsolute, join, relative, sep } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { validate, methodOf } from '../../spec/lib/validate.mjs';
+import { sha256 } from '../util/hash.mjs';
+import { defenderSelection, isReusable, subjectOf } from './attribution.mjs';
+import { discoverDefendersDetailed } from './discover.mjs';
+import { resolveDefenders } from './runners/shared.mjs';
+import { hashNativeTestUniverse } from './universe.mjs';
+
+// Point-in-time reads, not a transaction over the whole project. Never turn a
+// missing file into the empty-file hash that diagnostic probe records can use.
+function currentHash(projectDir, file) {
+  if (typeof file !== 'string' || isAbsolute(file) || file.split(/[\\/]/).includes('..')) throw new Error('unsafe input path');
+  const path = join(projectDir, file);
+  const resolved = realpathSync(path);
+  const inside = relative(realpathSync(projectDir), resolved);
+  if (isAbsolute(inside) || inside === '..' || inside.startsWith(`..${sep}`)) throw new Error('input escaped project');
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  try {
+    const before = fstatSync(fd);
+    if (!before.isFile()) throw new Error('input is not a regular file');
+    const hash = sha256(readFileSync(fd));
+    const after = fstatSync(fd);
+    if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || realpathSync(path) !== resolved) throw new Error('input changed during read');
+    return hash;
+  } finally { closeSync(fd); }
+}
+
+/** Internal policy boundary: native listing plus current per-fault bindings.
+ * Legacy/static universes and any uncertainty refuse; verdicts remain intact.
+ */
+export function originPolicyInputsFresh({ projectDir, claims, evidence, universe }) {
+  try {
+    if (!validate('claims', claims).ok || !validate('evidence', evidence).ok) return false;
+    if (methodOf(evidence.run) !== 'fault-injection' || evidence.run.provisional || evidence.run.confirmRuns < 3) return false;
+    const testUniverseHash = hashNativeTestUniverse(universe.manifests);
+    if (universe.testUniverseHash !== testUniverseHash) return false;
+    const matchesRunner = (recorded, current) => recorded?.name === current?.name && recorded?.version === current?.version;
+    if (!universe.primaryRunner || !matchesRunner(evidence.run.runner, universe.primaryRunner)) return false;
+    if ((evidence.run.runners ?? []).some((recorded) => !universe.runners?.some((current) => matchesRunner(recorded, current)))) return false;
+    const allTests = Object.freeze([...new Set([...universe.manifests.values()].flatMap((m) => m.files))].sort());
+    const expected = new Map();
+    for (const claim of claims.claims) for (const fault of claim.faults) {
+      if (methodOf(fault) !== 'fault-injection') return false;
+      expected.set(JSON.stringify([claim.id, fault.id]), { claim, fault });
+    }
+    if (!expected.size || evidence.records.length !== expected.size) return false;
+    const seen = new Set();
+    for (const record of evidence.records) {
+      const key = JSON.stringify([record.claim.id, record.subject.id]);
+      const current = expected.get(key);
+      if (!current || seen.has(key)) return false;
+      seen.add(key);
+      const { claim, fault } = current;
+      const subject = subjectOf(fault, sha256);
+      if (['kind', 'id', 'file', 'faultClass', 'contentHash', 'producedBy'].some((field) => !isDeepStrictEqual(record.subject[field], subject[field]))) return false;
+      const { requested, selectionSource } = defenderSelection(claim, fault);
+      const discovery = requested.length ? null : discoverDefendersDetailed(projectDir, fault.file, allTests);
+      if (discovery?.indeterminate.length) return false;
+      const resolved = requested.length ? resolveDefenders(projectDir, requested) : discovery.canDetect;
+      if (resolved.some((file) => !allTests.includes(file))) return false;
+      const hashes = (files) => Object.fromEntries(files.map((file) => [file, currentHash(projectDir, file)]));
+      const inputs = {
+        targetHash: currentHash(projectDir, fault.file),
+        defenderHashes: hashes(resolved),
+        testUniverseHash,
+        discoveryHashes: hashes(discovery?.dependencies ?? []),
+      };
+      if (!isReusable(record, { claim, requested, resolved, selectionSource, contentHash: subject.contentHash, inputs })) return false;
+    }
+    return true;
+  } catch { return false; }
+}