pan-wizard 3.34.0 → 3.35.0

package/pan-wizard-core/bin/lib/preview.cjs

@@ -161,7 +161,8 @@ function buildPhasePreview(cwd, phaseNum) {
  * Produce a dependency graph + mermaid source + parallel-batch recommendation.
  *
  * Dependency detection:
- *  - plan frontmatter `depends_on: [phase:NN, phase:MM]` (explicit)
+ *  - the roadmap's `**Depends on:** Phase N` line (explicit)
+ *  - plan frontmatter `depends_on: [phase:NN, phase:MM]` (explicit; bare plan ids are not phases)
  *  - mentions of prior phases in plan text (heuristic, flagged as "hidden")
  *
  * @param {string} cwd - Project root
@@ -195,6 +196,13 @@ function buildPhaseDependencyGraph(cwd) {
     }
   }
 
+  // Graph keys are the roadmap checklist's numbers; a dependency written "01" or
+  // "Phase 1" resolves to the key whose unpadded form matches.
+  const unpad = (n) => String(n).trim().replace(/^0+(?=\d)/, '');
+  const keyByUnpadded = new Map(phaseList.map(p => [unpad(p.num), p.num]));
+  const keyOf = (n) => keyByUnpadded.get(unpad(n)) || unpad(n);
+  const { phaseDependencies } = require('./roadmap.cjs');
+
   for (const p of phaseList) {
     graph[p.num] = {
       num: p.num,
@@ -204,6 +212,15 @@ function buildPhaseDependencyGraph(cwd) {
       hidden_deps: [],
     };
 
+    const addExplicit = (d) => {
+      const key = keyOf(d);
+      if (key !== keyOf(p.num) && !graph[p.num].explicit_deps.includes(key)) graph[p.num].explicit_deps.push(key);
+    };
+
+    // Explicit via the roadmap: the phase's `**Depends on:** Phase N` line.
+    const roadmapPhase = getRoadmapPhaseInternal(cwd, p.num);
+    for (const d of phaseDependencies(roadmapPhase && roadmapPhase.section)) addExplicit(d);
+
     // Read plan files for depends_on frontmatter + prior-phase mentions.
     const dir = phaseDirs[p.num];
     if (!dir) continue;
@@ -212,35 +229,18 @@ function buildPhaseDependencyGraph(cwd) {
     try { files = fs.readdirSync(fullDir).filter(isPlanFile); } catch { continue; }
 
     // LF, so the frontmatter match below also finds a CRLF plan's depends_on.
-    const phaseText = toLf(files.map(f => safeReadFile(path.join(fullDir, f)) || '').join('\n'));
-
-    // Explicit via frontmatter. Parse depends_on as freeform string (either
-    // inline `[phase:1, phase:2]`, or block-list). Extract all digit runs.
-    const fmMatch = phaseText.match(/^---\n([\s\S]*?)\n---/);
-    if (fmMatch) {
-      const depsLine = fmMatch[1].match(/^depends_on:\s*(.+)$/m);
-      if (depsLine) {
-        const digitRuns = depsLine[1].match(/\d+(?:\.\d+)?/g) || [];
-        for (const d of digitRuns) {
-          if (d !== p.num && !graph[p.num].explicit_deps.includes(d)) {
-            graph[p.num].explicit_deps.push(d);
-          }
-        }
-      }
-      // Also support block-list form:
-      //   depends_on:
-      //     - phase:1
-      //     - phase:2
-      const blockMatch = fmMatch[1].match(/^depends_on:\s*\n((?:\s*-\s*.+\n?)*)/m);
-      if (blockMatch && !depsLine) {
-        const items = blockMatch[1].match(/^\s*-\s*(.+)$/gm) || [];
-        for (const item of items) {
-          const d = item.match(/\d+(?:\.\d+)?/);
-          if (d && d[0] !== p.num && !graph[p.num].explicit_deps.includes(d[0])) {
-            graph[p.num].explicit_deps.push(d[0]);
-          }
-        }
-      }
+    const planTexts = files.map(f => toLf(safeReadFile(path.join(fullDir, f)) || ''));
+    const phaseText = planTexts.join('\n');
+
+    // Explicit via each plan's frontmatter. A plan's `depends_on` names plan ids
+    // inside its own phase (`["01"]`), so only `phase:N` entries are phase
+    // dependencies, inline (`[phase:1, phase:2]`) or as a block list.
+    for (const text of planTexts) {
+      const fmMatch = text.match(/^---\n([\s\S]*?)\n---/);
+      if (!fmMatch) continue;
+      const depsBlock = fmMatch[1].match(/^depends_on:[^\n]*(?:\n[ \t]*-[^\n]*)*/m);
+      if (!depsBlock) continue;
+      for (const m of depsBlock[0].matchAll(/\bphase[:\s]*(\d+(?:\.\d+)?)/gi)) addExplicit(m[1]);
     }
 
     // Hidden via mentions: "phase N", "from phase N", "as in phase N".
@@ -248,7 +248,8 @@ function buildPhaseDependencyGraph(cwd) {
     let mm;
     const mentions = new Set();
     while ((mm = mentionRe.exec(phaseText)) !== null) {
-      if (mm[1] !== p.num) mentions.add(mm[1]);
+      const k = keyOf(mm[1]);
+      if (k !== keyOf(p.num)) mentions.add(k);
     }
     graph[p.num].hidden_deps = [...mentions].filter(d => !graph[p.num].explicit_deps.includes(d));
   }

package/pan-wizard-core/bin/lib/verdict.cjs

@@ -28,10 +28,6 @@ const FINDING_CLASSES = Object.freeze(['missing', 'partial', 'contradicts', 'unr
 const SEVERITIES = Object.freeze(['critical', 'high', 'medium', 'low', 'info']);
 const DISPOSITIONS = Object.freeze(['fixed', 'deferred', 'dismissed', 'decision']);
 const REASON_REQUIRED = Object.freeze(['deferred', 'dismissed', 'decision']);
-// A re-run does not re-check these, so their absence from a later verdict is not
-// evidence that they were resolved (D6).
-const AUTO_FIX_EXEMPT = Object.freeze(['human', 'unrequested']);
-
 /** Each judge's own verdict word → the normalised outcome it implies. */
 const KNOWN_VERDICTS = Object.freeze({
   'pan-verifier': Object.freeze({ passed: 'pass', gaps_found: 'fail', human_needed: 'needs_human' }),
@@ -43,6 +39,8 @@ const KNOWN_VERDICTS = Object.freeze({
 const LIMITS = Object.freeze({ findings: 100, where: 200, summary: 300, verdict: 40, score: 40, not_checked: 20, check: 80 });
 // What the verifier's test gate can report (verify-phase.md, run_test_suite).
 const TEST_GATE_VALUES = Object.freeze(['passed', 'failed', 'skipped']);
+const RESOLUTION_STATUSES = Object.freeze(['resolved', 'still_present', 'cannot_tell']);
+const FINDING_ID_RE = /^f_[0-9a-f]{10}$/;
 const AGENT_RE = /^[a-z][a-z0-9-]{0,63}$/;
 const OPEN_FENCE_RE = /^[ \t]*(`{3,}|~{3,})[ \t]*pan-verdict[ \t]*$/;
 const CLOSE_FENCE_RE = /^[ \t]*(`{3,}|~{3,})[ \t]*$/;
@@ -198,7 +196,42 @@ function validateVerdict(obj, opts = {}) {
   });
 
   const notChecked = normaliseNotChecked(obj.not_checked, warnings);
-  return { ok: true, verdict: { contract, agent, outcome, verdict, phase, score, findings, not_checked: notChecked }, warnings };
+  const resolutions = normaliseResolutions(obj.resolutions, warnings);
+  return { ok: true, verdict: { contract, agent, outcome, verdict, phase, score, findings, not_checked: notChecked, resolutions }, warnings };
+}
+
+/**
+ * A judge's answers about its earlier open findings (V6): each `{id|summary, status,
+ * evidence}` with status resolved | still_present | cannot_tell. Silence is not an
+ * answer: a finding the judge leaves out stays open. `resolved` without evidence is
+ * recorded as cannot_tell, so a bare "fixed" closes nothing.
+ */
+function normaliseResolutions(value, warnings) {
+  if (value == null) return [];
+  if (!Array.isArray(value)) {
+    warnings.push('resolutions_not_an_array');
+    return [];
+  }
+  const out = [];
+  value.slice(0, LIMITS.findings).forEach((r, i) => {
+    if (!r || typeof r !== 'object' || Array.isArray(r)) { warnings.push(`resolution_dropped: #${i} is not an object`); return; }
+    const id = typeof r.id === 'string' && FINDING_ID_RE.test(r.id.trim()) ? r.id.trim() : null;
+    const named = r.summary ?? r.truth;
+    const summary = named == null ? null : (truncate(cleanText(String(named)), LIMITS.summary) || null);
+    if (!id && !summary) { warnings.push(`resolution_dropped: #${i} names no finding id or summary`); return; }
+    let status = typeof r.status === 'string' ? r.status.trim().toLowerCase() : '';
+    if (!RESOLUTION_STATUSES.includes(status)) {
+      warnings.push(`resolution_unknown_status: #${i} ${JSON.stringify(r.status === undefined ? null : r.status)} recorded as cannot_tell`);
+      status = 'cannot_tell';
+    }
+    const evidence = r.evidence == null ? '' : truncate(cleanText(String(r.evidence)), LIMITS.summary);
+    if (status === 'resolved' && !evidence) {
+      warnings.push(`resolution_without_evidence: #${i} recorded as cannot_tell`);
+      status = 'cannot_tell';
+    }
+    out.push({ id, summary, status, evidence: evidence || null });
+  });
+  return out;
 }
 
 /**
@@ -336,6 +369,49 @@ function listOfMappings(yaml, key) {
   return items;
 }
 
+/**
+ * A list nested one level under a top-level key, as the verifier writes
+ * `re_verification.gaps_closed`. Items are bare strings (read as `{truth}`) or
+ * mappings (`- truth: "…"` with `evidence: "…"` below it).
+ */
+function nestedList(yaml, parent, key) {
+  const lines = yaml.split('\n');
+  const start = lines.findIndex((l) => {
+    const m = KEY_VALUE_RE.exec(l);
+    return m && m[1] === parent && indentOf(l) === 0;
+  });
+  if (start === -1) return [];
+  const items = [];
+  let keyIndent = -1;
+  let cur = null;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim()) continue;
+    const ind = indentOf(line);
+    if (ind === 0) break;
+    const body = line.trim();
+    if (keyIndent === -1) {
+      const kv = KEY_VALUE_RE.exec(body);
+      if (kv && kv[1] === key) {
+        if (stripComment(kv[2]) !== '') return []; // `gaps_closed: []`
+        keyIndent = ind;
+      }
+      continue;
+    }
+    if (ind <= keyIndent) break;
+    const it = ITEM_RE.exec(line);
+    if (it) {
+      const kv = KEY_VALUE_RE.exec(it[2]);
+      cur = kv ? { [kv[1]]: unquote(kv[2]) } : { truth: unquote(it[2]) };
+      items.push(cur);
+    } else if (cur) {
+      const kv = KEY_VALUE_RE.exec(body);
+      if (kv) cur[kv[1]] = unquote(kv[2]);
+    }
+  }
+  return items.filter((x) => x.truth || x.summary || x.id);
+}
+
 /** A top-level scalar from the frontmatter (e.g. `status`), or null. */
 function frontmatterScalar(yaml, key) {
   for (const l of yaml.split('\n')) {
@@ -397,12 +473,57 @@ function verdictFromVerificationFrontmatter(text, agent = 'pan-verifier') {
     notChecked = notChecked.filter((n) => !isTests(n));
     contradicted = true;
   }
-  return { contract: VERDICT_CONTRACT, agent, verdict: status, outcome, findings, not_checked: notChecked, test_gate: testGate, not_checked_contradicted: contradicted };
+  // Re-verification answers (V6): a gap the verifier re-checked and closed is
+  // resolved; a regression or a remaining gap is still present.
+  const resolutions = [
+    ...nestedList(yaml, 're_verification', 'gaps_closed').map((g) => ({
+      id: g.id, summary: g.truth || g.summary, status: 'resolved', evidence: g.evidence || 'closed by the verifier\'s re-verification',
+    })),
+    ...nestedList(yaml, 're_verification', 'regressions').map((g) => ({ id: g.id, summary: g.truth || g.summary, status: 'still_present', evidence: g.evidence || null })),
+    ...nestedList(yaml, 're_verification', 'gaps_remaining').map((g) => ({ id: g.id, summary: g.truth || g.summary, status: 'still_present', evidence: g.evidence || null })),
+  ];
+  return { contract: VERDICT_CONTRACT, agent, verdict: status, outcome, findings, not_checked: notChecked, resolutions, test_gate: testGate, not_checked_contradicted: contradicted };
+}
+
+/** Names of the code facts that passed: a passing fact closes its own code-fact finding (V6). */
+function passingFacts(facts) {
+  return (Array.isArray(facts) ? facts : []).filter((f) => f && f.ok === true && f.fact).map((f) => f.fact);
+}
+
+/** The verdict word an agent uses for a fail, or null for an agent outside KNOWN_VERDICTS. */
+function failWordFor(agent) {
+  const table = KNOWN_VERDICTS[agent];
+  return table ? Object.keys(table).find((k) => table[k] === 'fail') || null : null;
+}
+
+/**
+ * Two-key verdict (V9): a code fact can lower a judge's verdict, never raise it.
+ * Any failing fact turns a pass or needs_human into the agent's fail word, keeps
+ * the agent's own word as `agent_verdict`, and adds one high finding per fact
+ * (`where: code-fact:<fact>`) so the gap round has something to close.
+ *
+ * @param {Object} verdict - a validated verdict
+ * @param {Array<{fact: string, ok: boolean, summary: string}>} facts
+ * @returns {{verdict: Object, lowered_by: string[]}} the same verdict object when nothing lowers it
+ */
+function lowerByCodeFacts(verdict, facts) {
+  const failing = (Array.isArray(facts) ? facts : []).filter((f) => f && f.ok === false && f.fact);
+  if (!failing.length || verdict.outcome === 'fail') return { verdict, lowered_by: [] };
+  const findings = [...verdict.findings];
+  for (const f of failing) {
+    findings.push({ class: 'defect', severity: 'high', where: `code-fact:${f.fact}`, summary: truncate(cleanText(f.summary || `${f.fact} failed`), LIMITS.summary) });
+  }
+  return {
+    verdict: { ...verdict, outcome: 'fail', verdict: failWordFor(verdict.agent) || 'fail', agent_verdict: verdict.verdict, findings },
+    lowered_by: failing.map((f) => f.fact),
+  };
 }
 
 /**
  * Read a judge's verdict from an artifact: the LAST `pan-verdict` block wins; with
  * no block, a verification.md frontmatter `status` is read through the adapter.
+ * Code facts (`opts.facts`, plus a verification's own `test_gate`) are applied
+ * after parsing through lowerByCodeFacts.
  * @param {string} text
  * @param {{agent?: string, phase?: string|number}} [opts]
  * @returns {{ok: true, verdict: Object, warnings: string[], source_kind: 'block'|'frontmatter'}
@@ -418,7 +539,9 @@ function parseVerdictText(text, opts = {}) {
       return { ok: false, error: 'invalid_json', reason: `the last pan-verdict block is not valid JSON: ${e.message}` };
     }
     const r = validateVerdict(obj, opts);
-    return r.ok ? { ...r, source_kind: 'block' } : r;
+    if (!r.ok) return r;
+    const low = lowerByCodeFacts(r.verdict, opts.facts);
+    return { ...r, verdict: low.verdict, lowered_by: low.lowered_by, facts_ok: passingFacts(opts.facts), source_kind: 'block' };
   }
   const adapted = verdictFromVerificationFrontmatter(text, opts.agent || 'pan-verifier');
   if (adapted) {
@@ -431,9 +554,13 @@ function parseVerdictText(text, opts = {}) {
     // gate under a pass: both make "passed" claim more than the verifier checked.
     if (!adapted.test_gate) r.warnings.push('test_gate_unrecorded: the verification does not say whether the test suite ran');
     else if (!TEST_GATE_VALUES.includes(adapted.test_gate)) r.warnings.push(`test_gate_unknown: "${adapted.test_gate}" is not passed, failed or skipped`);
-    else if (adapted.test_gate === 'failed' && adapted.outcome === 'pass') r.warnings.push('test_gate_failed_under_pass: the test gate failed but the status is passed');
+    else if (adapted.test_gate === 'failed' && adapted.outcome === 'pass') r.warnings.push('test_gate_failed_under_pass: the test gate failed but the status is passed, so it records as gaps_found');
     if (adapted.not_checked_contradicted) r.warnings.push(`not_checked_contradicted: test_gate is ${adapted.test_gate}, so the not_checked tests entry was dropped`);
-    return { ...r, source_kind: 'frontmatter' };
+    const facts = [...(Array.isArray(opts.facts) ? opts.facts : [])];
+    if (adapted.test_gate === 'failed') facts.push({ fact: 'test_gate', ok: false, summary: 'The test gate failed: the suite reported failures or did not run' });
+    if (adapted.test_gate === 'passed') facts.push({ fact: 'test_gate', ok: true, summary: 'the test gate passed' });
+    const low = lowerByCodeFacts(r.verdict, facts);
+    return { ...r, verdict: low.verdict, lowered_by: low.lowered_by, facts_ok: passingFacts(facts), source_kind: 'frontmatter' };
   }
   return { ok: false, error: 'no_verdict', reason: 'no pan-verdict block and no verification frontmatter status' };
 }
@@ -466,13 +593,16 @@ module.exports = {
   SEVERITIES,
   DISPOSITIONS,
   REASON_REQUIRED,
-  AUTO_FIX_EXEMPT,
   KNOWN_VERDICTS,
   LIMITS,
+  RESOLUTION_STATUSES,
+  FINDING_ID_RE,
   findVerdictBlocks,
   validateVerdict,
   verdictFromVerificationFrontmatter,
   parseVerdictText,
+  lowerByCodeFacts,
+  failWordFor,
   recordSig,
   findingId,
   outcomeForVerdict,

package/pan-wizard-core/bin/lib/verify-integrity.cjs

@@ -0,0 +1,181 @@
+'use strict';
+/**
+ * Test integrity (program V3): did this phase weaken the tests that judge it?
+ *
+ * An agent that cannot make a test pass can make the test stop failing instead:
+ * delete it, skip it, drop its assertions, rewrite its expectation or snapshot, or
+ * add an assertion that cannot fail. ImpossibleBench measured agents doing this on a
+ * large share of impossible tasks, and a stated way out (stop and report the
+ * conflict) cut it sharply. This is the check in code; the executor's way out is
+ * the `BLOCKED_SPEC_CONFLICT` return.
+ *
+ * It walks the phase's own plan commits (the `{type}({phase}-{plan}):` subjects that
+ * verify-scope reads) one at a time and reads each test file's diff:
+ *
+ *   errors    test_deleted · skip_marker_added · assertions_dropped ·
+ *             undeclared_test_edit (an existing assertion changed in a test no plan
+ *             declared) · snapshot_rewritten (undeclared) · always_true_assert
+ *   warnings  test_renamed
+ *
+ * A file a plan declares in `files_modified` may be edited freely, except that an
+ * added skip marker or an always-true assertion is an error anywhere.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execGit, findPhaseInternal, safeReadFile, output, error, toPosix } = require('./core.cjs');
+const { extractFrontmatter } = require('./frontmatter.cjs');
+const { isPlanFile } = require('./constants.cjs');
+const { committedFiles, TEST_PATH_RE, TEST_FILE_RE } = require('./verify-scope.cjs');
+
+const TEST_NAME_RE = /(^|\/)(test_[^/]+\.py|[^/]+_test\.(py|go)|[^/]+Tests?\.(java|kt|cs))$/;
+// A snapshot directory anywhere in the path, or a `.snap` file: two patterns, so neither
+// alternative's anchoring reads as the other's.
+const SNAPSHOT_DIR_RE = /(?:^|\/)(?:__snapshots__|snapshots)\//;
+const SNAPSHOT_EXT_RE = /\.snap$/;
+
+/** Markers that stop a test from running, per ecosystem. */
+const SKIP_RE = [
+  /\b(?:it|test|describe|suite|context)\.(?:skip|only|todo)\s*\(/, // jest / mocha / vitest / node:test
+  /\bx(?:it|test|describe)\s*\(/, // jasmine / mocha
+  /\b(?:skip|only|todo)\s*:\s*(?:true|['"`])/, // node:test options
+  /@pytest\.mark\.(?:skip|skipif|xfail)\b/,
+  /\bpytest\.skip\s*\(/,
+  /@unittest\.skip\w*\b/,
+  /\bt\.Skip(?:Now|f)?\s*\(/, // go
+  /#\[ignore\]/, // rust
+  /@(?:Disabled|Ignore)\b/, // junit
+];
+
+/** Lines that assert, per ecosystem. */
+const ASSERT_RE = [
+  /\bassert(?:\.\w+)?\s*\(/,
+  /\bassert(?:_eq|_ne)?!\s*\(/,
+  /\bexpect\s*\(/,
+  /\.should\b/,
+  /\bself\.assert\w+\s*\(/,
+  /^\s*assert\s+\S/,
+  /\bt\.(?:Error|Errorf|Fatal|Fatalf|Fail|FailNow)\s*\(/,
+  /\b(?:require|assert)\.\w+\s*\(\s*t\b/, // testify
+  /\bAssert\.\w+\s*\(/,
+];
+
+/** Assertions that cannot fail. */
+const ALWAYS_TRUE_RE = [
+  /\bassert(?:\.ok)?\s*\(\s*true\s*[,)]/,
+  /\bexpect\s*\(\s*true\s*\)\s*\.\s*(?:toBe|toEqual|toBeTruthy)\s*\(\s*(?:true)?\s*\)/,
+  /^\s*assert\s+True\s*(?:#.*)?$/,
+  /^\s*assert\s+(\d+)\s*==\s*\1\s*(?:#.*)?$/,
+  /\bself\.assertTrue\s*\(\s*True\s*\)/,
+  /\bassert!\s*\(\s*true\s*\)/,
+  /\bassertTrue\s*\(\s*true\s*\)/,
+];
+
+const isTestFile = (f) => TEST_PATH_RE.test(f) || TEST_FILE_RE.test(f) || TEST_NAME_RE.test(f);
+const isSnapshot = (f) => SNAPSHOT_DIR_RE.test(f) || SNAPSHOT_EXT_RE.test(f);
+const any = (res, line) => res.some((re) => re.test(line));
+const norm = (p) => toPosix(String(p || '').trim()).replace(/^\.\/+/, '');
+
+/** A Rust source file that holds its own unit tests (`#[test]`) at this commit. */
+function hasInlineTests(cwd, hash, file) {
+  if (!file.endsWith('.rs')) return false;
+  const r = execGit(cwd, ['show', `${hash}:${file}`]);
+  return r.exitCode === 0 && /#\[(?:test|cfg\(test\))\]/.test(r.stdout);
+}
+
+/** The union of the phase plans' `files_modified`. */
+function declaredFiles(cwd, info) {
+  const dir = path.join(cwd, info.directory);
+  const out = new Set();
+  for (const f of info.plans.filter(isPlanFile)) {
+    const fm = extractFrontmatter(safeReadFile(path.join(dir, f)) || '');
+    const raw = fm.files_modified || fm['files-modified'];
+    for (const p of Array.isArray(raw) ? raw : (raw ? [raw] : [])) if (norm(p)) out.add(norm(p));
+  }
+  return out;
+}
+
+function isDeclared(file, declared) {
+  for (const d of declared) if (d === file || (d.endsWith('/') && file.startsWith(d))) return true;
+  return false;
+}
+
+/** One commit's file changes: `[{status, file, from?}]`, renames detected. */
+function commitChanges(cwd, hash) {
+  const r = execGit(cwd, ['-c', 'core.quotepath=off', 'show', '--relative', '-M', '--name-status', '--format=', hash]);
+  if (r.exitCode !== 0) return [];
+  return r.stdout.split(/\r?\n/).filter(Boolean).map((line) => {
+    const parts = line.split('\t');
+    const status = parts[0][0];
+    return status === 'R' || status === 'C'
+      ? { status, from: norm(parts[1]), file: norm(parts[2]) }
+      : { status, file: norm(parts[1]) };
+  });
+}
+
+/** One file's added and removed lines in one commit. */
+function fileDiff(cwd, hash, file) {
+  const r = execGit(cwd, ['-c', 'core.quotepath=off', 'show', '--relative', '--format=', '-U0', '--no-color', hash, '--', file]);
+  const added = [];
+  const removed = [];
+  if (r.exitCode !== 0) return { added, removed };
+  for (const line of r.stdout.split(/\r?\n/)) {
+    if (line.startsWith('+++') || line.startsWith('---')) continue;
+    if (line.startsWith('+')) added.push(line.slice(1));
+    else if (line.startsWith('-')) removed.push(line.slice(1));
+  }
+  return { added, removed };
+}
+
+/**
+ * The integrity check for one phase.
+ * @returns {{phase, checked: boolean, ok: boolean, reason?: string, commits: number, violations: Array, warnings: Array}|{error, reason}}
+ */
+function checkTestIntegrity(cwd, phase) {
+  const info = findPhaseInternal(cwd, phase);
+  if (!info || !info.found) return { error: 'phase_not_found', reason: `no phase directory for phase ${phase}` };
+  const git = committedFiles(cwd, info.phase_number);
+  const base = { phase: info.phase_number, commits: git.commits, violations: [], warnings: [] };
+  if (!git.git) return { ...base, checked: false, ok: true, reason: 'git is unavailable or this is not a repository' };
+  if (!git.commits) return { ...base, checked: false, ok: true, reason: 'no plan commits for this phase (subjects like "feat(03-01): …")' };
+
+  const declared = declaredFiles(cwd, info);
+  const violations = [];
+  const warnings = [];
+  const add = (list, code, file, commit, detail) => list.push({ code, file, commit: commit.slice(0, 12), detail });
+
+  for (const hash of [...git.hashes].reverse()) { // oldest first
+    for (const ch of commitChanges(cwd, hash)) {
+      const { file } = ch;
+      if (ch.status === 'D' && isTestFile(file)) { add(violations, 'test_deleted', file, hash, `${file} was deleted`); continue; }
+      if (ch.status === 'R' && isTestFile(ch.from)) add(warnings, 'test_renamed', file, hash, `${ch.from} was renamed to ${file}`);
+      if (isSnapshot(file) && (ch.status === 'M' || ch.status === 'D') && !isDeclared(file, declared)) {
+        add(violations, 'snapshot_rewritten', file, hash, `snapshot ${file} was ${ch.status === 'D' ? 'deleted' : 'rewritten'} and no plan declares it`);
+        continue;
+      }
+      if (ch.status === 'D' || !(isTestFile(file) || hasInlineTests(cwd, hash, file))) continue;
+      const { added, removed } = fileDiff(cwd, hash, file);
+      const skipsAdded = added.filter((l) => any(SKIP_RE, l)).length - removed.filter((l) => any(SKIP_RE, l)).length;
+      if (skipsAdded > 0) add(violations, 'skip_marker_added', file, hash, `${skipsAdded} skip/only marker(s) added`);
+      const trivial = added.filter((l) => any(ALWAYS_TRUE_RE, l));
+      if (trivial.length) add(violations, 'always_true_assert', file, hash, `an assertion that cannot fail: ${trivial[0].trim().slice(0, 120)}`);
+      const assertsAdded = added.filter((l) => any(ASSERT_RE, l) && !any(ALWAYS_TRUE_RE, l)).length;
+      const assertsRemoved = removed.filter((l) => any(ASSERT_RE, l)).length;
+      if (assertsRemoved > assertsAdded) {
+        add(violations, 'assertions_dropped', file, hash, `${assertsRemoved} assertion line(s) removed, ${assertsAdded} added`);
+      } else if (assertsRemoved > 0 && ch.status === 'M' && !isDeclared(file, declared)) {
+        add(violations, 'undeclared_test_edit', file, hash, `${assertsRemoved} existing assertion(s) changed in a test no plan declares`);
+      }
+    }
+  }
+  return { ...base, checked: true, ok: violations.length === 0, violations, warnings };
+}
+
+function cmdVerifyTestIntegrity(cwd, phase, raw) {
+  if (!phase) error('Usage: verify test-integrity <phase>');
+  const r = checkTestIntegrity(cwd, phase);
+  if (r.error) { output(r, raw); return; }
+  const word = !r.checked ? 'not_checked' : (r.ok ? 'clean' : 'violated');
+  output(r, raw, word, r.ok ? 0 : 1);
+}
+
+module.exports = { checkTestIntegrity, cmdVerifyTestIntegrity, isTestFile, SKIP_RE, ASSERT_RE, ALWAYS_TRUE_RE };