@1aboveio/skills 0.0.0-stage → 1.0.0

package/skills/engineering/better-review/scripts/rereview-scope.test.mjs

@@ -0,0 +1,587 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { execFileSync, spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { decideScope, numstatLines, priorProblems, parseCliArgs, RereviewScopeError, changedSymbols, headingSlug, sweepRecheck, patchImpactLines, skipRecord, ownLinesUnchanged } from './rereview-scope.mjs'
+
+const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'rereview-scope.mjs')
+const DONE = { spec: 'done', correctness: 'done', tests: 'done', standards: 'done' }
+
+// A repo with main (a.txt, b.txt) and a feature branch changing both, reviewed at `reviewed`.
+function fixture(t) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rereview-scope-'))
+  const outside = fs.mkdtempSync(path.join(os.tmpdir(), 'rereview-prior-'))
+  t.after(() => { fs.rmSync(dir, { recursive: true, force: true }); fs.rmSync(outside, { recursive: true, force: true }) })
+  const git = (...args) => execFileSync('git', args, { cwd: dir, encoding: 'utf8' }).trim()
+  const write = (file, text) => fs.writeFileSync(path.join(dir, file), text)
+  const commit = (msg) => { git('add', '-A'); git('commit', '-qm', msg); return git('rev-parse', 'HEAD') }
+  git('init', '-q', '-b', 'main')
+  git('config', 'user.email', 't@example.com')
+  git('config', 'user.name', 'T')
+  write('a.txt', 'a1\na2\na3\na4\n'); write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8\n'); write('c.txt', 'c1\n')
+  const base = commit('base')
+  git('checkout', '-qb', 'feature')
+  write('a.txt', 'A1\nA2\nA3\na4\n'); write('b.txt', 'B1\nB2\nB3\nb4\nb5\nb6\nb7\nb8\n')
+  const reviewed = commit('feature')
+  const context = spawnSync('node', [path.join(path.dirname(SCRIPT), 'pr-context.mjs'), '--base', base, '--head', reviewed], { cwd: dir, encoding: 'utf8' })
+  assert.equal(context.status, 0, context.stderr)
+  const patchFingerprint = JSON.parse(context.stdout).patchFingerprint
+  const prior = (extra = {}) => {
+    const file = path.join(outside, 'prior.json')
+    fs.writeFileSync(file, JSON.stringify({ version: 1, round: 1, head: reviewed, mergeBase: base, patchFingerprint, passes: DONE, commands: ['node --test'], findings: [{ id: 'R1', severity: 'P1', summary: 's' }, { id: 'R2', severity: 'P3', summary: 's', followUpUrl: 'https://github.com/o/r/issues/9' }], ...extra }))
+    return file
+  }
+  const run = (priorFile, base = 'main') => {
+    const r = spawnSync('node', [SCRIPT, '--prior', priorFile, '--base', base], { cwd: dir, encoding: 'utf8' })
+    return { status: r.status, out: r.status === 0 ? JSON.parse(r.stdout) : null, stderr: r.stderr }
+  }
+  return { dir, git, write, commit, base, reviewed, prior, run }
+}
+
+test('a small fix to one PR file is a delta review: that file in full, the other carried', (t) => {
+  const f = fixture(t)
+  f.write('a.txt', 'A1\nA2-fixed\nA3\na4\n'); f.commit('fix')
+  const { status, out } = f.run(f.prior())
+  assert.equal(status, 0)
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.deepEqual(out.touchedFiles, ['a.txt'])
+  assert.deepEqual(out.carriedFiles, ['b.txt'])
+  assert.deepEqual(out.openFindings.map((f) => f.id), ['R1'])
+  assert.match(out.fixDiffCommand, /^git diff [0-9a-f]{40} [0-9a-f]{40} -- a\.txt$/)
+})
+
+test('a rebase whose base change touches no PR file stays a delta', (t) => {
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main'); f.write('c.txt', 'c2\n'); f.commit('base moves elsewhere')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('a.txt', 'A1\nA2-fixed\nA3\na4\n'); f.commit('fix')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.deepEqual(out.touchedFiles, ['a.txt'])
+})
+
+test('main moving under a PR file without a conflict, while a P1 is open, reviews only the merge diff', (t) => {
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main'); f.write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8-base\n'); f.commit('base moves under b')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.deepEqual(out.mergeFiles, ['b.txt'])
+  assert.deepEqual(out.touchedFiles, ['b.txt'])
+  assert.equal(out.fixLines, 0)
+  assert.match(out.mergeDiffCommand, /^git diff [0-9a-f]{40} [0-9a-f]{40} -- b\.txt$/)
+  assert.match(out.fixDiff, /\+b8-base/)
+})
+
+test('a small resolution in a file main moved under receives an integration delta', (t) => {
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main'); f.write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8-base\n'); f.commit('base moves under b')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('b.txt', 'B1\nB2-resolved\nB3\nb4\nb5\nb6\nb7\nb8-base\n'); f.commit('resolve')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.deepEqual(out.integrationFiles, ['b.txt'])
+  assert.deepEqual(out.touchedFiles, ['b.txt'])
+  assert.deepEqual(out.carriedFiles, ['a.txt'])
+  assert.equal(out.fixLines, 0)
+  assert.equal(out.integrationLines, 2)
+  assert.match(out.fixDiff, /\+B2-resolved/)
+  assert.match(out.mergeDiffCommand, /-- b\.txt$/)
+})
+
+test('imported main lines do not inflate a small integration change', (t) => {
+  const f = fixture(t)
+  const imported = Array.from({ length: 100 }, (_, i) => `base-${i}`).join('\n') + '\n'
+  f.git('checkout', '-q', 'main'); f.write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8\n' + imported); f.commit('large base addition')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('b.txt', 'B1\nB2-resolved\nB3\nb4\nb5\nb6\nb7\nb8\n' + imported); f.commit('small resolution')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.equal(out.integrationLines, 2)
+  assert.equal(out.fixLinesSinceFull, 2)
+  assert.match(out.fixDiff, /\+base-99/)
+})
+
+test('broad integration changes still require a full review', (t) => {
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main'); f.write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8-base\n'); f.commit('base moves under b')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('b.txt', 'Y1\nY2\nY3\ny4\nb5\nb6\nb7\nb8-base\n'); f.commit('broad resolution')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'full')
+  assert.ok(out.reasons.some((r) => r.includes('more than 50%')), out.reasons.join('; '))
+})
+
+test('moving a PR edit between functions over a changed base counts as integration impact', (t) => {
+  const f = fixture(t)
+  const source = (publicEnabled, adminEnabled, tail = '') =>
+    `def public():\n    public_only = 1\n    enabled = ${publicEnabled}\n    return enabled\n\ndef admin():\n    admin_only = 2\n    enabled = ${adminEnabled}\n    return enabled\n${tail}`
+  f.git('checkout', '-q', 'main'); f.write('logic.py', source('False', 'False')); f.commit('function base')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  // Isolate the PR to a single two-line edit so moving it changes its entire scope.
+  f.write('a.txt', 'a1\na2\na3\na4\n'); f.write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8\n')
+  f.write('logic.py', source('True', 'False'))
+  const head = f.commit('enable public')
+  const prior = f.prior({ head, mergeBase: f.git('merge-base', 'main', 'HEAD'), findings: [] })
+  f.git('checkout', '-q', 'main'); f.write('logic.py', source('False', 'False', '# imported main comment\n')); f.commit('move base')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('logic.py', source('False', 'True', '# imported main comment\n')); f.commit('move edit to admin')
+  const { out } = f.run(prior)
+  assert.equal(out.samePatch, false)
+  assert.equal(out.prLines, 2)
+  assert.ok(out.integrationLines > out.prLines / 2)
+  assert.equal(out.tier, 'full')
+})
+
+test('an actual rebase conflict can stay delta after a bounded resolution', (t) => {
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main'); f.write('b.txt', 'b1\nb2-base\nb3\nb4\nb5\nb6\nb7\nb8\n'); f.commit('competing base edit')
+  f.git('checkout', '-q', 'feature')
+  const rebase = spawnSync('git', ['rebase', 'main'], { cwd: f.dir, encoding: 'utf8' })
+  assert.equal(rebase.status, 1)
+  f.write('b.txt', 'B1\nB2-with-base\nB3\nb4\nb5\nb6\nb7\nb8\n')
+  f.git('add', 'b.txt'); f.git('-c', 'core.editor=true', 'rebase', '--continue')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.deepEqual(out.integrationFiles, ['b.txt'])
+  assert.equal(out.integrationLines, 4)
+  assert.match(out.fixDiff, /\+B2-with-base/)
+})
+
+test('a PR file removed from the current net diff remains in review scope', (t) => {
+  const f = fixture(t)
+  f.write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8\n'); f.commit('remove reviewed change')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'full')
+  assert.ok(out.touchedFiles.includes('b.txt'))
+  assert.ok(out.reasons.some((r) => r.includes('more than 50%')))
+})
+
+test('unbounded integration impact fails closed, while reordered patch lines count as changes', () => {
+  const patch = (lines) => `diff --git a/x b/x\n--- a/x\n+++ b/x\n@@ -1 +1 @@\n${lines.join('\n')}\n`
+  assert.equal(patchImpactLines(patch(['-old', '+one', '+two']), patch(['-old', '+two', '+one'])), 2)
+  assert.equal(patchImpactLines(patch(['-old', '+new']), patch(['-old', '+new']).replace('@@ -1 +1 @@', '@@ -20 +20 @@')), 4)
+  assert.equal(patchImpactLines('Binary files a/x and b/x differ', patch(['+new'])), null)
+  const large = Array.from({ length: 2001 }, (_, i) => `+line-${i}`)
+  assert.equal(patchImpactLines(patch(large), patch([...large].reverse())), null)
+  const out = decideScope({ prior: { round: 1, head: 'h', mergeBase: 'm', passes: DONE, commands: ['node --test'] }, round: 2, prFiles: ['x'], touchedFiles: ['x'], baseMovedFiles: ['x'], conflictFiles: ['x'], fixLines: 0, integrationLines: null, prLines: 10000, priorHeadReachable: true })
+  assert.equal(out.tier, 'full')
+  assert.ok(out.reasons.some((r) => r.includes('cannot be bounded')))
+})
+
+test('integration anchors count partial relocations but normalize imported base offsets', () => {
+  const header = 'diff --git a/x b/x\n--- a/x\n+++ b/x\n'
+  const hunk = (line, from, to) => `@@ -${line} +${line} @@\n-${from}\n+${to}\n`
+  const before = header + hunk(1, 'old', 'new') + hunk(10, 'value', 'one')
+  const relocated = header + hunk(2, 'old', 'new') + hunk(10, 'value', 'two')
+  assert.equal(patchImpactLines(before, relocated), 6)
+  const rebased = header + hunk(4, 'old', 'new') + hunk(13, 'value', 'two')
+  const baseDiff = header + '@@ -0,0 +1,3 @@\n+base1\n+base2\n+base3\n'
+  assert.equal(patchImpactLines(before, rebased, baseDiff), 2)
+  const afterDeletion = header + hunk(1, 'old', 'new') + hunk(8, 'value', 'two')
+  const deletedBase = header + '@@ -5,2 +4,0 @@\n-base1\n-base2\n'
+  assert.equal(patchImpactLines(before, afterDeletion, deletedBase), 2)
+})
+
+test('own lines stay unchanged only at the same places: kept-both conflicts yes, relocations and base rewrites no', () => {
+  const header = 'diff --git a/x b/x\n--- a/x\n+++ b/x\n'
+  const reviewed = header + '@@ -4,0 +5 @@ a4\n+mine\n'
+  const sibling = header + '@@ -4,0 +5 @@ a4\n+sibling\n'
+  assert.equal(ownLinesUnchanged(reviewed, header + '@@ -5,0 +6 @@ sibling\n+mine\n', sibling), true, 'after the base\'s insertion')
+  assert.equal(ownLinesUnchanged(reviewed, header + '@@ -4,0 +5 @@ a4\n+mine\n', sibling), true, 'before it')
+  assert.equal(ownLinesUnchanged(reviewed, header + '@@ -6,0 +7 @@ a6\n+mine\n', sibling), false, 'moved one line further')
+  assert.equal(ownLinesUnchanged(reviewed, header + '@@ -5,0 +6 @@ sibling\n+mine2\n', sibling), false, 'its own line changed')
+  const rewrite = header + '@@ -5 +5 @@\n-sibling\n+mine\n'
+  assert.equal(ownLinesUnchanged(reviewed, rewrite, sibling), false, 'replacing a base line is a change')
+  const shifted = header + '@@ -1,0 +1,2 @@\n+top1\n+top2\n'
+  assert.equal(ownLinesUnchanged(reviewed, header + '@@ -6,0 +7 @@ a4\n+mine\n', shifted), true, 'base lines above only shift it')
+  assert.equal(ownLinesUnchanged('Binary files a/x and b/x differ', reviewed), false)
+  const block = header + '@@ -4,0 +5,3 @@ a4\n+if (admin) {\n+  grant()\n+}\n'
+  assert.equal(ownLinesUnchanged(reviewed, header + '@@ -5,0 +6 @@ if (admin) {\n+mine\n', block), false, 'inside the base block, not at its edge')
+  assert.equal(ownLinesUnchanged(reviewed, header + '@@ -7,0 +8 @@ }\n+mine\n', block), true, 'after the whole block')
+  const pair = header + '@@ -4,0 +5,2 @@ a4\n+lock\n+unlock\n'
+  const split = header + '@@ -4,0 +5 @@ a4\n+lock\n@@ -5,0 +7 @@ sibling\n+unlock\n'
+  assert.equal(ownLinesUnchanged(pair, split, sibling), false, 'a reviewed hunk split around base lines')
+  const strict = header + '@@ -0,0 +1 @@\n+use strict\n'
+  const imports = header + '@@ -0,0 +1,2 @@\n+import a\n+import b\n'
+  assert.equal(ownLinesUnchanged(strict, header + '@@ -1,0 +2 @@ import a\n+use strict\n', imports), false, 'between the base\'s new lines at the file start')
+  assert.equal(ownLinesUnchanged(strict, strict, imports), true, 'still before them')
+})
+
+test('an equivalent rebase after a passing review skips the reviewer, and the verdict CLI re-derives the skip', (t) => {
+  const f = fixture(t)
+  const prior = f.prior({ unit: '1201', round: 7, fixRound: 1, findings: [], commands: ['node --test'] })
+  f.git('checkout', '-q', 'main'); f.write('c.txt', 'c2\n'); f.commit('unrelated base update')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  const reviews = fs.mkdtempSync(path.join(os.tmpdir(), 'rereview-skip-'))
+  t.after(() => fs.rmSync(reviews, { recursive: true, force: true }))
+  const file = path.join(reviews, 'review-r8.json')
+  const scope = spawnSync('node', [SCRIPT, '--prior', prior, '--base', 'main', '--write-skip', file], { cwd: f.dir, encoding: 'utf8' })
+  assert.equal(scope.status, 0, scope.stderr)
+  const out = JSON.parse(scope.stdout)
+  assert.equal(out.tier, 'skip', out.reasons.join('; '))
+  assert.equal(out.samePatch, true)
+  assert.equal(out.round, 8)
+  assert.equal(out.fixRound, 1)
+  assert.deepEqual(out.touchedFiles, [])
+  assert.deepEqual(out.baseMovedFiles, ['c.txt'])
+  assert.equal(out.skipRecord, file)
+  const record = JSON.parse(fs.readFileSync(file, 'utf8'))
+  assert.equal(record.tier, 'skip')
+  assert.equal(record.carriedFrom, f.reviewed)
+  assert.equal(record.head, out.head)
+  assert.deepEqual(record.commands, [], 'a skip runs no checks and claims none')
+  assert.deepEqual(record.findings, [])
+
+  const verdict = path.resolve(path.dirname(SCRIPT), '../../resolve-issues/scripts/review-verdict.mjs')
+  const run = (...args) => spawnSync('node', [verdict, '--review', file, '--prior', prior, ...args], { cwd: f.dir, encoding: 'utf8' })
+  const result = run('--head', out.head, '--base', 'main')
+  assert.equal(result.status, 0, result.stderr)
+  assert.equal(JSON.parse(result.stdout).reviewedHead, out.head)
+  assert.equal(JSON.parse(result.stdout).tier, 'skip')
+  assert.equal(JSON.parse(result.stdout).fixRound, 1)
+  assert.equal(run('--head', out.head).status, 2, 'a skip record is never taken on its word: --base is required')
+  const bound = run('--head', f.reviewed, '--base', 'main')
+  assert.equal(bound.status, 0, bound.stderr)
+  assert.equal(JSON.parse(bound.stdout).verdict, 'review-again', 'a skip record is bound to its HEAD')
+
+  // A skip record forged over a real change fails the rerun: the reviewer must run.
+  f.write('a.txt', 'A1\nA2-changed\nA3\na4\n'); const changed = f.commit('real change')
+  fs.writeFileSync(file, JSON.stringify({ ...record, head: changed }))
+  const forged = run('--head', changed, '--base', 'main')
+  assert.equal(forged.status, 0, forged.stderr)
+  assert.equal(JSON.parse(forged.stdout).verdict, 'review-again')
+  assert.match(JSON.parse(forged.stdout).reason, /picks "delta"/, forged.stdout)
+
+  // The skip record is a valid prior: the next fix gets a delta against it.
+  fs.writeFileSync(file, JSON.stringify(record))
+  const next = f.run(file)
+  assert.equal(next.out.tier, 'delta', next.out.reasons.join('; '))
+  assert.equal(next.out.round, 9)
+  assert.deepEqual(next.out.touchedFiles, ['a.txt'])
+})
+
+test('a skip needs a passing prior; a base moving under a PR file still skips while the PR\'s own lines are unchanged', (t) => {
+  const f = fixture(t)
+  f.git('commit', '-q', '--amend', '-m', 'reworded')
+  assert.equal(f.run(f.prior()).out.tier, 'delta', 'an open P1 is never carried: it is fixed')
+  assert.equal(f.run(f.prior({ findings: [] })).out.tier, 'skip')
+  assert.equal(f.run(f.prior({ findings: undefined })).out.tier, 'delta', 'a prior with no findings array proves no pass')
+  const passedAt = f.git('rev-parse', 'HEAD')
+  assert.equal(f.run(f.prior({ findings: [], head: passedAt })).out.tier, 'skip', 'same HEAD: nothing to review')
+  f.git('checkout', '-q', 'main'); f.write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8-base\n'); f.commit('base moves under b')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  const { out } = f.run(f.prior({ findings: [], head: passedAt }))
+  assert.equal(out.tier, 'skip', 'the unit\'s own changes are the reviewed ones; CI on the new HEAD proves the fit')
+  assert.deepEqual(out.mergeFiles, ['b.txt'])
+  assert.throws(() => skipRecord({ head: 'h' }, f.run(f.prior()).out), RereviewScopeError)
+})
+
+test('a rebase conflict resolved by keeping both sides skips; one that rewrites a PR line is reviewed', (t) => {
+  // wiki-kb #12: six of ten extra review rounds only re-checked sibling registrations a rebase
+  // added beside the unit's own, unchanged lines.
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main'); f.write('a.txt', 'a1\na2\na3\na4\nsibling\n'); f.commit('sibling registration')
+  f.git('checkout', '-q', 'feature')
+  f.write('a.txt', 'A1\nA2\nA3\na4\nmine\n'); const reviewed = f.commit('own registration')
+  const prior = f.prior({ findings: [], head: reviewed })
+  const rebase = spawnSync('git', ['rebase', 'main'], { cwd: f.dir, encoding: 'utf8' })
+  assert.equal(rebase.status, 1, 'both sides appended at the same place')
+  f.write('a.txt', 'A1\nA2\nA3\na4\nsibling\nmine\n')
+  f.git('add', 'a.txt'); f.git('-c', 'core.editor=true', 'rebase', '--continue')
+  assert.equal(f.run(prior).out.tier, 'skip')
+  f.write('a.txt', 'A1\nA2\nA3\na4\nsibling\nmine-and-sibling\n'); f.commit('resolution rewrites the unit\'s line')
+  const { out } = f.run(prior)
+  assert.equal(out.tier, 'delta')
+  assert.ok(out.touchedFiles.includes('a.txt'))
+})
+
+test('a completed full retry replaces incomplete coverage without consuming a fix cycle', (t) => {
+  const f = fixture(t)
+  const prior = f.prior({ unit: '1201', fixRound: 1, complete: false, commands: [], findings: [{ id: 'R1', severity: 'P1', summary: 'unconfirmed blocker' }], passes: { ...DONE, tests: 'partial' } })
+  const { out } = f.run(prior)
+  assert.equal(out.tier, 'full')
+  assert.equal(out.round, 2)
+  assert.equal(out.fixRound, 1)
+  const file = path.join(f.dir, 'review.json')
+  fs.writeFileSync(file, JSON.stringify({ ...out, version: 1, unit: '1201', complete: true, passes: DONE, commands: ['git diff --check main...HEAD'], findings: [] }))
+  const verdict = path.resolve(path.dirname(SCRIPT), '../../resolve-issues/scripts/review-verdict.mjs')
+  const result = spawnSync('node', [verdict, '--review', file, '--head', out.head, '--prior', prior], { cwd: f.dir, encoding: 'utf8' })
+  assert.equal(result.status, 0, result.stderr)
+  assert.equal(JSON.parse(result.stdout).fixRound, 1)
+})
+
+test('missing check evidence or follow-ups alone force full retry and preserve the fix count', (t) => {
+  const f = fixture(t)
+  const verdict = path.resolve(path.dirname(SCRIPT), '../../resolve-issues/scripts/review-verdict.mjs')
+  for (const extra of [{ commands: [] }, { findings: [{ id: 'R1', severity: 'P1', summary: 'blocker' }, { id: 'R2', severity: 'P2', summary: 'deferred' }] }]) {
+    const prior = f.prior({ unit: '1201', round: 3, fixRound: 3, commands: ['node --test'], ...extra })
+    const { out } = f.run(prior)
+    assert.equal(out.tier, 'full')
+    assert.equal(out.fixRound, 3)
+    // The verdict's stall guard reads every earlier round, so name the files <unit>-r<N>.json.
+    const rounds = path.dirname(prior)
+    for (const round of [1, 2]) fs.writeFileSync(path.join(rounds, `1201-r${round}.json`), JSON.stringify({ version: 1, unit: '1201', round, head: out.head, passes: DONE, commands: ['node --test'], findings: [] }))
+    const priorFile = path.join(rounds, '1201-r3.json')
+    fs.copyFileSync(prior, priorFile)
+    const file = path.join(rounds, '1201-r4.json')
+    fs.writeFileSync(file, JSON.stringify({ ...out, version: 1, unit: '1201', complete: true, passes: DONE, commands: ['git diff --check main...HEAD'], findings: [{ id: 'R1', severity: 'P1', summary: 'confirmed blocker', trigger: 'A2 reverts on reload', rule: 'a.txt line 2 stays fixed', paths: [{ path: 'a.txt:2', status: 'open' }] }] }))
+    const result = spawnSync('node', [verdict, '--review', file, '--head', out.head, '--prior', priorFile], { cwd: f.dir, encoding: 'utf8' })
+    assert.equal(result.status, 0, result.stderr)
+    assert.equal(JSON.parse(result.stdout).verdict, 'fix')
+    assert.equal(JSON.parse(result.stdout).action, 'fix')
+    assert.equal(JSON.parse(result.stdout).fixRound, 3)
+  }
+})
+
+test('scope advances the fix counter only after blocking findings', (t) => {
+  const f = fixture(t)
+  f.write('a.txt', 'A1\nA2-fixed\nA3\na4\n'); f.commit('fix')
+  assert.equal(f.run(f.prior({ round: 7, fixRound: 2 })).out.fixRound, 3)
+  assert.equal(f.run(f.prior({ round: 7, fixRound: 2, findings: [] })).out.fixRound, 2)
+  assert.equal(f.run(f.prior({ round: 7, fixRound: 0 })).out.tier, 'full')
+})
+
+test('whitespace-changing code is never classified as an equivalent patch', (t) => {
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main')
+  f.write('logic.py', 'def value():\n    if True:\n        return 1\n    return 2\n'); f.commit('python base')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('logic.py', 'def value():\n    if False:\n        return 1\n    return 2\n')
+  const head = f.commit('python feature')
+  const prior = f.prior({ head, mergeBase: f.git('merge-base', 'main', 'HEAD'), findings: [] })
+  f.write('logic.py', 'def value():\n    if False:\n        return 1\n        return 2\n'); f.commit('changed indentation')
+  const { out } = f.run(prior)
+  assert.equal(out.samePatch, false)
+  assert.ok(out.touchedFiles.includes('logic.py'))
+})
+
+test('a binary content change cannot carry an equivalent-patch approval', (t) => {
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main'); f.write('image.bin', Buffer.from([0, 1, 2, 3])); f.commit('binary base')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('image.bin', Buffer.from([0, 4, 2, 3]))
+  const head = f.commit('binary feature')
+  const prior = f.prior({ head, mergeBase: f.git('merge-base', 'main', 'HEAD'), findings: [] })
+  f.write('image.bin', Buffer.from([0, 5, 2, 3])); f.commit('changed binary')
+  const { out } = f.run(prior)
+  assert.equal(out.samePatch, false)
+  assert.ok(out.touchedFiles.includes('image.bin'))
+})
+
+test('moving an identical edit to a different function never carries approval', (t) => {
+  const f = fixture(t)
+  const source = (publicEnabled, adminEnabled) => ['public', 'admin'].map((name, i) =>
+    `def ${name}():\n    one = 1\n    two = 2\n    three = 3\n    enabled = ${i === 0 ? publicEnabled : adminEnabled}\n    four = 4\n    five = 5\n    return enabled\n`).join('\n')
+  f.git('checkout', '-q', 'main'); f.write('logic.py', source('False', 'False')); f.commit('repeated context base')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('logic.py', source('True', 'False'))
+  const head = f.commit('reviewed public change')
+  const mergeBase = f.git('merge-base', 'main', 'HEAD')
+  const prior = f.prior({ head, mergeBase, findings: [] })
+  const original = f.run(prior).out
+  f.write('logic.py', source('False', 'True')); f.commit('move change to admin')
+  const { out } = f.run(prior)
+  assert.equal(out.patchId, original.patchId, 'this is a real patch-id collision')
+  assert.notEqual(out.patchFingerprint, original.patchFingerprint)
+  assert.equal(out.samePatch, false)
+  assert.ok(out.touchedFiles.includes('logic.py'))
+  assert.ok(out.fixLines > 0)
+  const gone = f.prior({ head: '0'.repeat(40), mergeBase, patchId: original.patchId, patchFingerprint: original.patchFingerprint, findings: [] })
+  assert.equal(f.run(gone).out.tier, 'full')
+})
+
+test('an unknown previous merge-base forces full', (t) => {
+  const f = fixture(t)
+  f.write('a.txt', 'A1\nA2-fixed\nA3\na4\n'); f.commit('fix')
+  const { out } = f.run(f.prior({ mergeBase: '1'.repeat(40) }))
+  assert.equal(out.tier, 'full')
+  assert.ok(out.reasons.some((r) => r.includes('merge-base')), out.reasons.join('; '))
+})
+
+test('fixes that rewrite more than half the PR force full', (t) => {
+  const f = fixture(t)
+  f.write('a.txt', 'X1\nX2\nX3\nx4\n'); f.write('b.txt', 'Y1\nY2\nY3\ny4\nb5\nb6\nb7\nb8\n'); f.commit('rewrite')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'full')
+  assert.ok(out.reasons.some((r) => r.includes('more than 50%')), out.reasons.join('; '))
+})
+
+test('a late round after a delta stays a delta for a small fix: round number and prior scope never force full', (t) => {
+  const f = fixture(t)
+  f.write('a.txt', 'A1\nA2-fixed\nA3\na4\n'); f.commit('fix')
+  const { out } = f.run(f.prior({ round: 4, scope: 'delta', fixLinesSinceFull: 2 }))
+  assert.equal(out.round, 5)
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.equal(out.fixLinesSinceFull, 4)
+})
+
+test('small fixes that add up to more than half the PR since the last full review force full', (t) => {
+  const f = fixture(t)
+  f.write('a.txt', 'A1\nA2-fixed\nA3\na4\n'); f.commit('fix')
+  // The PR is 12 changed lines; 5 earlier delta lines plus this round's 2 is over half.
+  const { out } = f.run(f.prior({ round: 3, scope: 'delta', fixLinesSinceFull: 5 }))
+  assert.equal(out.tier, 'full')
+  assert.ok(out.reasons.some((r) => r.includes('since the last full review changed 7 of 12')), out.reasons.join('; '))
+  assert.equal(out.fixLinesSinceFull, 0)
+})
+
+test('a content-equivalent rebase reuses the review even when the reviewed HEAD is gone', (t) => {
+  const f = fixture(t)
+  const reviewedPatch = execFileSync('git', ['patch-id', '--verbatim'], { cwd: f.dir, encoding: 'utf8', input: f.git('diff', `${f.base}...${f.reviewed}`) + '\n' }).trim().split(/\s+/)[0]
+  f.git('checkout', '-q', 'main'); f.write('c.txt', 'c2\n'); f.commit('base moves elsewhere')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  const gone = '0'.repeat(40)
+  const { out } = f.run(f.prior({ head: gone, patchId: reviewedPatch }))
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.equal(out.samePatch, true)
+  assert.equal(out.patchId, reviewedPatch)
+  assert.deepEqual(out.touchedFiles, [])
+  assert.deepEqual(out.carriedFiles, ['a.txt', 'b.txt'])
+  assert.equal(out.fixDiff, '')
+  assert.deepEqual(out.openFindings.map((x) => x.id), ['R1'])
+  const legacy = f.prior({ head: gone, patchId: reviewedPatch, patchFingerprint: undefined })
+  assert.equal(f.run(legacy).out.tier, 'full', 'patch-id alone cannot prove edit locations')
+})
+
+test('a rebase that changes the PR patch with the reviewed HEAD gone forces full', (t) => {
+  const f = fixture(t)
+  const reviewedPatch = execFileSync('git', ['patch-id', '--verbatim'], { cwd: f.dir, encoding: 'utf8', input: f.git('diff', `${f.base}...${f.reviewed}`) + '\n' }).trim().split(/\s+/)[0]
+  f.write('a.txt', 'A1\nA2-fixed\nA3\na4\n'); f.commit('fix')
+  const { out } = f.run(f.prior({ head: '0'.repeat(40), patchId: reviewedPatch }))
+  assert.equal(out.tier, 'full')
+  assert.equal(out.samePatch, false)
+})
+
+test('a content-equivalent rebase over a base that moved under a PR file, with the reviewed HEAD gone, reviews the merge diff', (t) => {
+  const f = fixture(t)
+  const reviewedPatch = execFileSync('git', ['patch-id', '--verbatim'], { cwd: f.dir, encoding: 'utf8', input: f.git('diff', `${f.base}...${f.reviewed}`) + '\n' }).trim().split(/\s+/)[0]
+  f.git('checkout', '-q', 'main'); f.write('b.txt', 'b1\nb2\nb3\nb4\nb5\nb6\nb7\nb8-base\n'); f.commit('base moves under b')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  const { out } = f.run(f.prior({ head: '0'.repeat(40), patchId: reviewedPatch }))
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.equal(out.samePatch, true)
+  assert.deepEqual(out.touchedFiles, ['b.txt'])
+  assert.match(out.fixDiff, /\+b8-base/)
+})
+
+test('a metadata-only commit (same tree, new message) is a delta with nothing to review', (t) => {
+  const f = fixture(t)
+  f.git('commit', '-q', '--amend', '-m', 'feature, reworded')
+  const { out } = f.run(f.prior())
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.deepEqual(out.touchedFiles, [])
+  assert.equal(out.fixDiff, '')
+})
+
+test('a previous round that did not cover the whole diff forces full', (t) => {
+  const f = fixture(t)
+  f.write('a.txt', 'A1\nA2-fixed\nA3\na4\n'); f.commit('fix')
+  for (const extra of [{ complete: false }, { oversize: true }, { passes: { ...DONE, correctness: 'partial' } }, { passes: undefined }, { tier: 'delta' }, { scope: 'delta' }, { tier: 'skip' }, { tier: 'partial' }, { scope: 'partial' }]) {
+    assert.equal(f.run(f.prior(extra)).out.tier, 'full', JSON.stringify(extra))
+  }
+  assert.equal(f.run(f.prior({ passes: { ...DONE, spec: 'skipped: no spec found' } })).out.tier, 'delta')
+})
+
+test('an unknown previous HEAD forces full, and an unreadable prior is a usage error', (t) => {
+  const f = fixture(t)
+  const { out } = f.run(f.prior({ head: '0'.repeat(40) }))
+  assert.equal(out.tier, 'full')
+  assert.deepEqual(out.carriedFiles, [])
+  assert.equal(f.run(path.join(f.dir, 'missing.json')).status, 2)
+})
+
+test('priorProblems names every gap', () => {
+  assert.deepEqual(priorProblems({ round: 1, head: 'h', mergeBase: 'm', passes: DONE, commands: ['node --test'] }), [])
+  assert.equal(priorProblems({}).length, 3 + 2)
+})
+
+test('carry-forward refuses unfinished skips and unresolved incidents through the scope CLI', (t) => {
+  const f = fixture(t)
+  f.git('commit', '-q', '--amend', '-m', 'metadata-only change')
+  const incomplete = [
+    ...['skipped: timeout', 'skipped: not applicable: sampled due to token budget',
+      'skipped: not applicable: budget exhausted', 'skipped: not applicable: not reviewed'].map((status) =>
+      ({ passes: { ...DONE, correctness: status } })),
+    ...[{ status: 'open' }, {}, 'resolved'].map((executionIncident) => ({ executionIncident })),
+    { commands: [] },
+    { commands: undefined },
+  ]
+  for (const extra of incomplete) {
+    const { status, out } = f.run(f.prior({ findings: [], ...extra }))
+    assert.equal(status, 0)
+    assert.equal(out.samePatch, true)
+    assert.equal(out.tier, 'full', JSON.stringify(extra))
+    assert.ok(out.reasons.some((reason) => /unfinished|executionIncident|no checks/.test(reason)))
+  }
+  for (const status of ['skipped: no spec found', 'skipped: not applicable: prose-only change']) {
+    assert.equal(f.run(f.prior({ findings: [], passes: { ...DONE, spec: status }, executionIncident: { status: 'resolved' } })).out.tier, 'skip')
+  }
+})
+
+test('decideScope keeps PR order and splits touched from carried', () => {
+  const d = decideScope({ prior: { round: 1, head: 'h', mergeBase: 'm', passes: DONE, commands: ['node --test'] }, round: 2, prFiles: ['x', 'y', 'z'], touchedFiles: ['z', 'x'], baseMovedFiles: ['other'], fixLines: 5, prLines: 100, priorHeadReachable: true })
+  assert.equal(d.tier, 'delta')
+  assert.deepEqual(d.touchedFiles, ['x', 'z'])
+  assert.deepEqual(d.carriedFiles, ['y'])
+})
+
+test('numstatLines counts binary files as one line', () => {
+  assert.equal(numstatLines('3\t2\ta.txt\n-\t-\timg.png\n'), 6)
+})
+
+test('parseCliArgs requires --prior and --base', () => {
+  assert.throws(() => parseCliArgs(['--prior', 'p.json']), RereviewScopeError)
+  assert.throws(() => parseCliArgs(['--prior']), RereviewScopeError)
+  assert.deepEqual(parseCliArgs(['--prior', 'p', '--base', 'main']), { prior: 'p', base: 'main', head: 'HEAD' })
+  assert.equal(parseCliArgs(['--prior', 'p', '--base', 'main', '--write-skip', 'r2.json']).writeSkip, 'r2.json')
+})
+
+test('a delta hands over its setup: changed names, their call sites in carried files, and a fix-only scan', (t) => {
+  const f = fixture(t)
+  f.git('checkout', '-q', 'main')
+  f.write('lib.js', 'export function parseAmount(s) { return Number(s) }\nexport const LIMIT = 10\n')
+  f.write('caller.js', "import { parseAmount } from './lib.js'\nexport const total = parseAmount('5')\n")
+  f.commit('code base')
+  f.git('checkout', '-q', 'feature'); f.git('rebase', '-q', 'main')
+  f.write('lib.js', 'export function parseAmount(s) { return Number(s.trim()) }\nexport const LIMIT = 10\n')
+  f.write('caller.js', "import { parseAmount } from './lib.js'\nexport const total = parseAmount(' 5 ')\n")
+  const reviewed = f.commit('feature code')
+  const prior = f.prior({ head: reviewed, mergeBase: f.git('merge-base', 'main', 'HEAD'),
+    sweeps: [{ rule: 'amounts are trimmed', points: [{ location: 'lib.js:1', enforced: true }, { location: 'caller.js:2', enforced: true }] }] })
+  f.write('lib.js', 'export function parseAmount(s) {\n  return Number(String(s).trim())\n}\nexport const LIMIT = 10\n')
+  f.commit('fix')
+  const { out } = f.run(prior)
+  assert.equal(out.tier, 'delta', out.reasons.join('; '))
+  assert.deepEqual(out.touchedFiles, ['lib.js'])
+  assert.deepEqual(out.changedSymbols.names, ['parseAmount'])
+  assert.deepEqual(out.callSites.sites.map((s) => `${s.file}:${s.line}`), ['caller.js:1', 'caller.js:2'])
+  assert.deepEqual(out.sweepRecheck.map((p) => p.location), ['lib.js:1'])
+  assert.ok(Array.isArray(out.fixScan.leads) && Array.isArray(out.fixScan.findings))
+  assert.match(out.fixDiff, /^\+  return Number\(String\(s\)\.trim\(\)\)$/m)
+  // --head selects the reviewed commit even when the checkout has moved on
+  f.write('caller.js', "import { parseAmount } from './lib.js'\n"); f.commit('later commit drops a call site')
+  const r = spawnSync('node', [SCRIPT, '--prior', prior, '--base', 'main', '--head', 'HEAD~1'], { cwd: f.dir, encoding: 'utf8' })
+  assert.deepEqual(JSON.parse(r.stdout).callSites.sites.map((s) => `${s.file}:${s.line}`), ['caller.js:1', 'caller.js:2'])
+})
+
+test('changedSymbols reads added and removed lines only, and Markdown headings as anchors', () => {
+  const diff = [
+    '--- a/src/a.ts', '+++ b/src/a.ts',
+    '+export async function loadUser(id) {', '-const staleCache = new Map()', ' function contextOnly() {}',
+    '+  if (x) {', '+def python_helper(arg):', '+  const localOnly = 1',
+    '--- a/src/a.test.ts', '+++ b/src/a.test.ts', '+const result = run()', '+function helperInTest() {}',
+    '--- a/docs/x.md', '+++ b/docs/x.md', '+## Stacked PRs (`stack` mode)', '+plain prose with function words',
+  ].join('\n')
+  assert.deepEqual(changedSymbols(diff), { names: ['loadUser', 'python_helper', 'staleCache'], anchors: ['#stacked-prs-stack-mode'] })
+  assert.equal(headingSlug('Fix loop'), 'fix-loop')
+})
+
+test('sweepRecheck keeps only points in touched files', () => {
+  const prior = { sweeps: [{ rule: 'r', points: [{ location: 'a.js:3', enforced: false, finding: 'R1' }, { location: 'b.md:10-12', enforced: true }] }] }
+  assert.deepEqual(sweepRecheck(prior, ['b.md']), [{ rule: 'r', location: 'b.md:10-12', enforced: true }])
+  assert.deepEqual(sweepRecheck({}, ['a.js']), [])
+})