@1aboveio/skills 1.0.7 → 1.0.9

package/skills/engineering/resolve-issues/scripts/review-verdict.test.mjs

@@ -1,1060 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { spawnSync } from 'node:child_process'
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { reviewVerdict, fixAction, fixBriefOf, carryRecord, AFTER_PASS, ReviewIncomplete, ReviewVerdictError } from './review-verdict.mjs'
-import { rereviewScope } from '../../better-review/scripts/rereview-scope.mjs'
-
-const script = join(dirname(fileURLToPath(import.meta.url)), 'review-verdict.mjs')
-
-const HEAD = 'abc1234'
-const p1 = {
-  id: 'R1', severity: 'P1', summary: 'tenant id not checked on update', file: 'src/a.ts', line: 10,
-  trigger: 'update order 7 of tenant B with a tenant A token returns 200',
-  rule: 'every write checks the caller tenant against the row tenant',
-  paths: [{ path: 'src/a.ts:10', status: 'open' }, { path: 'src/b.ts:4', status: 'closed', evidence: 'assertTenant at src/b.ts:4' }],
-}
-const p2 = { id: 'R2', severity: 'P2', summary: 'rename helper', followUpUrl: 'https://github.com/o/r/issues/9' }
-const p3 = { id: 'R3', severity: 'P3', summary: 'tidy comment' }
-const review = (findings, extra = {}) => ({ version: 1, unit: '1201', round: 1, head: HEAD, commands: ['npm test'], findings, ...extra })
-const done = { spec: 'done', correctness: 'done', tests: 'done', standards: 'done' }
-const skipPrefixes = [
-  'skipped: not applicable:', 'skipped: not applicable -',
-  'skipped: non-applicable:', 'skipped: non-applicable -',
-]
-const incompleteReasons = [
-  'sampled review', 'sampling only', 'sample-only review', 'only a subset reviewed', 'spot checked files',
-  'SAMPLED REVIEW', 'sampled-review',
-  'ran out of budget', 'ran out of time', 'budget exhausted', 'exhausted review budget',
-  'time limit reached', 'token budget exceeded', 'no time left', 'insufficient review budget',
-  'review not finished', 'tests not fully completed', 'did not finish the review',
-  'could not complete the pass', "review isn't complete", 'review has not been finished',
-  'review still to be completed', 'review not yet done', 'review never completed',
-  'review not yet fully completed', "review couldn't be completed", 'review not started',
-  'ran-out-of-budget', 'review  not  finished',
-]
-
-test('completion metadata cannot authorize unfinished reviews, even with no findings or claimed completion', () => {
-  for (const complete of [false, null, undefined, 'true', 0]) {
-    assert.throws(() => reviewVerdict(review([], { complete }), HEAD), ReviewIncomplete)
-  }
-  for (const passes of [null, [], 'done', {}, { ...done, standards: undefined }]) {
-    assert.throws(() => reviewVerdict(review([], { complete: true, passes }), HEAD), ReviewIncomplete)
-  }
-  for (const pass of Object.keys(done)) {
-    for (const status of ['partial', 'pending', 'skipped: unfinished', 'skipped: not reached as a completed pass', 'skipped: timed out', 'skipped: stopped after execution incident', 'skipped: ran out of budget', 'skipped: ', 'skipped: not applicable; unfinished review']) {
-      assert.throws(() => reviewVerdict(review([], { complete: true, passes: { ...done, [pass]: status } }), HEAD), ReviewIncomplete, `${pass}: ${status}`)
-    }
-  }
-})
-
-test('an accepted non-applicable prefix cannot override sampling, exhaustion, or negated completion', () => {
-  for (const prefix of skipPrefixes) {
-    for (const reason of incompleteReasons) {
-      for (const pass of Object.keys(done)) {
-        for (const completion of [{}, { complete: true }]) {
-          const record = review([], { ...completion, passes: { ...done, [pass]: `${prefix} ${reason}` } })
-          const original = structuredClone(record)
-          assert.throws(() => reviewVerdict(record, HEAD), (error) =>
-            error instanceof ReviewIncomplete && error.message.includes(`review pass ${pass} is unfinished`),
-          `${pass}: ${prefix} ${reason}`)
-          assert.deepEqual(record, original)
-        }
-      }
-    }
-  }
-})
-
-test('documented complete v1 records and non-applicable skips retain severity-only disposition', () => {
-  for (const extra of [
-    {},
-    { complete: true },
-    { passes: done },
-    { complete: true, passes: done },
-    { passes: { ...done, spec: 'skipped: no spec found' } },
-    { passes: { ...done, standards: 'skipped: no standards found' } },
-    { passes: { ...done, standards: 'skipped: not applicable: no repository standards' } },
-    { passes: { ...done, tests: 'skipped: non-applicable: documentation-only diff' } },
-    ...skipPrefixes.map((prefix) => ({ complete: true, passes: { ...done, tests: `${prefix} documentation-only diff` } })),
-    { passes: { ...done, tests: 'skipped: not applicable' } },
-    { passes: { ...done, tests: 'skipped: non-applicable' } },
-  ]) {
-    const result = reviewVerdict(review([p2, p3], extra), HEAD)
-    assert.equal(result.verdict, 'pass')
-    assert.equal(result.reviewedHead, HEAD)
-    assert.deepEqual(result.deferred.map((finding) => finding.id), ['R2'])
-  }
-})
-
-test('unresolved or malformed execution incidents remain incomplete independently of passes and severities', () => {
-  for (const executionIncident of [{ status: 'open-impact-unresolved' }, { status: 'open' }, { status: 'contained' }, { status: 'unknown' }, {}, [], 'resolved', false]) {
-    for (const findings of [[], [p1], [p2, p3]]) {
-      assert.throws(() => reviewVerdict(review(findings, { passes: done, complete: true, executionIncident }), HEAD), ReviewIncomplete)
-    }
-  }
-  const commands = ['npm test (failed)', 'npm test (corrected)']
-  const record = review([p2], {
-    passes: done, complete: true, commands,
-    commandResults: [{ exitCode: 1 }, { exitCode: 0 }],
-    executionIncident: { status: 'resolved', disposition: 'Owner assessed impact; corrected checks completed.' },
-  })
-  const original = structuredClone(record)
-  const result = reviewVerdict(record, HEAD)
-  assert.equal(result.verdict, 'pass')
-  assert.deepEqual(result.commands, commands)
-  assert.deepEqual(record, original)
-  assert.equal(reviewVerdict(review([], { executionIncident: null }), HEAD).verdict, 'pass')
-})
-
-test('only P2/P3 findings pass the review and go to CI; P3 is skipped, not deferred', () => {
-  const result = reviewVerdict(review([p2, p3]), HEAD)
-  assert.equal(result.verdict, 'pass')
-  assert.equal(result.reviewedHead, HEAD)
-  assert.equal(result.fix, undefined)
-  assert.deepEqual(result.deferred.map((f) => f.id), ['R2'])
-})
-
-test('a P3 is ignored: no follow-up, dropbox id, id, or summary needed', () => {
-  for (const finding of [p3, { ...p3, followUpUrl: 'TODO' }, { ...p3, dropboxId: 'later' }, { severity: 'P3' }, { ...p3, summary: '' }]) {
-    const result = reviewVerdict(review([finding]), HEAD)
-    assert.equal(result.verdict, 'pass')
-    assert.deepEqual(result.deferred, [])
-  }
-  assert.equal(reviewVerdict(review([p2, { ...p3, id: 'R2' }]), HEAD).verdict, 'pass', 'a P3 never collides with a real id')
-})
-
-test('a review with no findings passes', () => {
-  assert.equal(reviewVerdict(review([]), HEAD).verdict, 'pass')
-})
-
-test('the reviewer cannot talk a P1 into a pass', () => {
-  const result = reviewVerdict(review([p1], { verdict: 'pass' }), HEAD)
-  assert.equal(result.verdict, 'fix')
-})
-
-test('a P0/P1 sends only the blocking findings to the fix worker', () => {
-  for (const severity of ['P0', 'P1']) {
-    const result = reviewVerdict(review([{ ...p1, severity }, p2, p3], { complete: true, passes: done }), HEAD)
-    assert.equal(result.verdict, 'fix')
-    const brief = fixBriefOf(result)
-    assert.deepEqual(brief.fix.map((f) => f.id), ['R1'])
-    assert.doesNotMatch(JSON.stringify(brief), /rename helper|tidy comment/)
-  }
-})
-
-test('the first blocking round is a plain fix; with no previous file a later round is too', () => {
-  const first = reviewVerdict(review([p1]), HEAD)
-  assert.equal(first.verdict, 'fix')
-  assert.equal(first.action, 'fix')
-  assert.equal(reviewVerdict(review([p1], { round: 2 }), HEAD, null).action, 'fix')
-})
-
-test('integration attempts preserve fixRound and the first blocker after a pass selects a plain fix', () => {
-  let prior = review([], { fixRound: 1 })
-  assert.equal(reviewVerdict(prior, HEAD).fixRound, 1)
-  for (let round = 2; round <= 8; round += 1) {
-    const current = review([p2], { round, fixRound: 1, head: `integration-${round}` })
-    const original = structuredClone(current)
-    const result = reviewVerdict(current, current.head, prior)
-    assert.equal(result.verdict, 'pass')
-    assert.equal(result.round, round)
-    assert.equal(result.fixRound, 1)
-    assert.equal(result.reviewedHead, current.head)
-    assert.deepEqual(current, original)
-    prior = current
-  }
-  const current = review([p1], { round: 9, fixRound: 1 })
-  const originalPrior = structuredClone(prior)
-  const result = reviewVerdict(current, HEAD, prior)
-  assert.equal(result.verdict, 'fix')
-  assert.equal(result.action, 'fix')
-  assert.deepEqual(result.recurring, [])
-  assert.deepEqual(result.introduced, [])
-  assert.equal(result.fixRound, 1)
-  assert.equal(fixBriefOf(result).round, 9)
-  assert.equal(fixBriefOf(result).fixRound, 1)
-  assert.equal(fixAction(current, [p1], prior).action, 'fix')
-  assert.deepEqual(prior, originalPrior)
-})
-
-const withOpen = (n, id = 'R1') => ({ ...p1, id, paths: Array.from({ length: n }, (_, i) => ({ path: `src/p${i}.ts:1`, status: 'open' })) })
-
-// Runs a blocking loop from open-row counts per round; returns each round's verdict.
-function runLoop(counts, extra = () => ({})) {
-  const records = []
-  return counts.map((n, i) => {
-    const current = review([withOpen(n)], { round: i + 1, fixRound: i + 1, ...extra(i) })
-    const result = reviewVerdict(current, HEAD, records.at(-1) ?? null, { history: records.slice(0, -1) })
-    records.push(current)
-    return result.verdict === 'fix' ? 'fix' : result.reason
-  })
-}
-
-test('fix rounds continue past any fixed count while open rows reach new lows', () => {
-  assert.deepEqual(runLoop([9, 8, 7, 6, 5, 4, 3, 2, 1]), Array(9).fill('fix'))
-  // One round without a new low still fixes; the second hands back.
-  assert.deepEqual(runLoop([3, 2, 2, 2]), ['fix', 'fix', 'fix', 'not-converging'])
-  // A stall, a new low, then a stall is never two in a row.
-  assert.deepEqual(runLoop([4, 4, 3, 3, 2]), Array(5).fill('fix'))
-})
-
-test('alternating or rising counts hand back: progress is a new low, not a drop from last round', () => {
-  assert.deepEqual(runLoop([3, 2, 3, 2]), ['fix', 'fix', 'fix', 'not-converging'])
-  assert.deepEqual(runLoop([5, 4, 5, 4, 5]), ['fix', 'fix', 'fix', 'not-converging', 'not-converging'])
-  assert.deepEqual(runLoop([2, 5, 3]), ['fix', 'fix', 'not-converging'])
-  // Swapping one finding for another of the same size is no progress.
-  const r1 = review([withOpen(1)], { round: 1, fixRound: 1 })
-  const r2 = review([withOpen(1, 'other')], { round: 2, fixRound: 2 })
-  const r3 = review([withOpen(1, 'third')], { round: 3, fixRound: 3 })
-  assert.equal(reviewVerdict(r3, HEAD, r2, { history: [r1] }).reason, 'not-converging')
-})
-
-test('incomplete reviews are passed over, never counted as progress; a pass starts a new loop', () => {
-  const incomplete = (i) => (i === 2 ? { complete: false } : {})
-  assert.throws(() => runLoop([2, 2, 2, 2], incomplete), ReviewIncomplete)
-  const r = (n, round, extra = {}) => review([withOpen(n)], { round, fixRound: round, ...extra })
-  const history = [r(2, 1), r(2, 2), { ...r(2, 3), complete: false, fixRound: 3 }]
-  const result = reviewVerdict(r(2, 4, { fixRound: 3, tier: 'full', complete: true, passes: done }), HEAD, history.at(-1), { history: history.slice(0, -1) })
-  assert.equal(result.reason, 'not-converging')
-  const passed = review([p2], { round: 3, fixRound: 3 })
-  assert.equal(reviewVerdict(r(2, 4, { fixRound: 3 }), HEAD, passed, { history: [r(2, 1), r(2, 2)] }).verdict, 'fix')
-})
-
-test('legacy findings without paths are not measured, so moving to new records is no false stall', () => {
-  const legacy = { ...p1, paths: undefined }
-  const old1 = review([legacy], { round: 1 })
-  const old2 = review([legacy], { round: 2 })
-  const current = review([withOpen(5)], { round: 3 })
-  assert.equal(reviewVerdict(current, HEAD, old2, { history: [old1] }).verdict, 'fix')
-})
-
-test('a valid pass at or beyond the fix cap still passes, but completion and HEAD remain required', () => {
-  for (const fixRound of [4, 5]) {
-    const prior = review([p1], { round: 10, fixRound: fixRound - 1 })
-    const current = review([p2, p3], { round: 11, fixRound, complete: true, passes: done })
-    const result = reviewVerdict(current, HEAD, prior)
-    assert.equal(result.verdict, 'pass')
-    assert.equal(result.fixRound, fixRound)
-    assert.equal(result.reviewedHead, HEAD)
-    assert.throws(() => reviewVerdict({ ...current, complete: false }, HEAD, prior), /review complete must be true/)
-    assert.throws(() => reviewVerdict({ ...current, passes: { ...done, tests: 'pending' } }, HEAD, prior), /review pass tests is unfinished/)
-    assert.throws(() => reviewVerdict({ ...current, head: 'stale' }, HEAD, prior), /HEAD "stale"/)
-    const integrated = review([], { round: 12, fixRound })
-    assert.equal(reviewVerdict(integrated, HEAD, current).fixRound, fixRound)
-  }
-})
-
-test('legacy attempt accounting remains conservative, including migration from a legacy prior', () => {
-  const legacy = review([p1], { round: 3 })
-  const result = reviewVerdict(legacy, HEAD, review([p1], { round: 2 }))
-  assert.equal(result.verdict, 'fix')
-  assert.equal(result.fixRound, 3)
-  assert.equal(fixBriefOf(result).fixRound, 3)
-  const { fixRound, ...legacyResult } = result
-  assert.equal(fixBriefOf(legacyResult).fixRound, 3)
-  assert.equal(reviewVerdict(review([p1], { round: 4, fixRound: 4 }), HEAD, legacy, { history: [review([p1], { round: 2 })] }).reason, 'not-converging')
-  const legacyPass = review([p2], { round: 7 })
-  const current = review([p1], { round: 8, fixRound: 7 })
-  const migrated = reviewVerdict(current, HEAD, legacyPass)
-  assert.equal(migrated.fixRound, 7)
-  assert.equal(migrated.verdict, 'fix')
-  assert.throws(() => reviewVerdict({ ...current, fixRound: 1 }, HEAD, legacyPass), /expected 7 from prior review/)
-  assert.throws(() => reviewVerdict(review([p1], { round: 4, fixRound: 3 }), HEAD, legacy), /expected 4 from prior review/)
-})
-
-test('malformed current and prior counters are rejected by verdict, action, and brief APIs', () => {
-  for (const value of [undefined, null, false, '1', 0, -1, 1.5, NaN, Infinity, Number.MAX_SAFE_INTEGER + 1]) {
-    for (const field of ['round', 'fixRound']) {
-      const current = review([p1], { fixRound: 1, [field]: value })
-      assert.throws(() => reviewVerdict(current, HEAD), (error) => error instanceof ReviewIncomplete && /round|fixRound/.test(error.message))
-      assert.throws(() => fixAction(current, [p1]), (error) => error instanceof ReviewIncomplete && /round|fixRound/.test(error.message))
-      assert.throws(() => fixBriefOf(current), /round and fixRound must be positive safe integers/)
-      const prior = review([p1], { fixRound: 1, [field]: value })
-      assert.throws(() => reviewVerdict(review([p1], { round: 2, fixRound: 2 }), HEAD, prior), (error) =>
-        error instanceof ReviewIncomplete && /round|fixRound/.test(error.message))
-    }
-  }
-  assert.throws(() => reviewVerdict(review([], { fixRound: 2 }), HEAD), /no greater than round/)
-  assert.throws(() => fixAction(review([p1], { fixRound: 2 }), [p1]), /no greater than round/)
-  assert.throws(() => reviewVerdict(review([], { round: 3, fixRound: 2 }), HEAD, review([], { round: 2, fixRound: 3 })), /prior review.*fixRound|fixRound must/s)
-})
-
-test('supplied fix counters must match the proven transition and cannot decrease or skip cycles', () => {
-  for (const [findings, expected] of [[[p1], 3], [[], 2], [[p2, p3], 2]]) {
-    const prior = review(findings, { round: 8, fixRound: 2 })
-    for (const fixRound of [1, 2, 3, 4].filter((value) => value !== expected)) {
-      const current = review([], { round: 9, fixRound })
-      assert.throws(() => reviewVerdict(current, HEAD, prior), new RegExp(`expected ${expected} from prior review`))
-      assert.throws(() => fixAction(current, [p1], prior), new RegExp(`expected ${expected} from prior review`))
-    }
-    assert.equal(reviewVerdict(review([], { round: 9, fixRound: expected }), HEAD, prior).fixRound, expected)
-    assert.throws(() => reviewVerdict(review([], { round: 9 }), HEAD, prior), new RegExp(`expected ${expected} from prior review`))
-  }
-  for (const round of [2, 9]) {
-    assert.throws(() => reviewVerdict(review([], { round, fixRound: 1 }), HEAD), /cannot be lower than round without a prior/)
-    assert.equal(reviewVerdict(review([p1], { round, fixRound: round }), HEAD).fixRound, round)
-  }
-})
-
-test('new counters require a same-unit completed immediate prior with valid review identity', () => {
-  const current = review([p1], { round: 9, fixRound: 2 })
-  const prior = review([p1], { round: 8, fixRound: 1, head: 'prior-head' })
-  const cases = [
-    [{ unit: 'other' }, /prior review unit does not match/],
-    [{ version: 2 }, /review version is 2/],
-    [{ head: undefined }, /prior review has no HEAD/],
-    [{ head: '' }, /prior review has no HEAD/],
-    [{ round: 7 }, /must immediately precede/],
-    [{ round: 9 }, /must immediately precede/],
-    [{ complete: false }, /review complete must be true/],
-    [{ passes: { ...done, tests: 'pending' } }, /review pass tests is unfinished/],
-    [{ executionIncident: { status: 'open' } }, /executionIncident must be resolved/],
-    [{ commands: [] }, /ran no checks/],
-    [{ findings: undefined }, /no findings array/],
-    [{ findings: [{ ...p1, id: '' }] }, /has no id/],
-    [{ findings: [{ ...p2, followUpUrl: undefined }] }, /without a followUpUrl/],
-  ]
-  for (const [extra, message] of cases) {
-    const invalid = { ...prior, ...extra }
-    assert.throws(() => reviewVerdict(current, HEAD, invalid), message)
-    assert.throws(() => fixAction(current, [p1], invalid), message)
-  }
-  for (const invalid of [{}, [], false, 'prior']) {
-    assert.throws(() => reviewVerdict(current, HEAD, invalid), /invalid prior review for fixRound/)
-  }
-  assert.equal(reviewVerdict(current, HEAD, prior).action, 'test-first')
-})
-
-test('only a completed full retry can recover from an incomplete immediate prior', () => {
-  const prior = review([p1], { fixRound: 1, complete: false, passes: { ...done, tests: 'partial' }, commands: [] })
-  const current = review([], { round: 2, fixRound: 1, scope: 'full', complete: true, passes: done })
-  assert.equal(reviewVerdict(current, HEAD, prior).verdict, 'pass')
-  assert.equal(reviewVerdict(current, HEAD, prior).fixRound, 1)
-  assert.equal(reviewVerdict({ ...current, findings: [{ ...p1, pass: 'spec' }] }, HEAD, prior).action, 'fix')
-  assert.throws(() => reviewVerdict({ ...current, scope: 'delta' }, HEAD, prior), /invalid prior review/)
-  const { passes, ...withoutCoverage } = current
-  assert.throws(() => reviewVerdict(withoutCoverage, HEAD, prior), /full retry must complete every pass/)
-  assert.throws(() => reviewVerdict({ ...current, fixRound: 2 }, HEAD, prior), /expected 1 from prior/)
-  assert.throws(() => reviewVerdict(current, HEAD, { ...prior, unit: 'other' }), /unit does not match/)
-  assert.throws(() => reviewVerdict(current, HEAD, { ...prior, fixRound: 0 }), /fixRound must/)
-})
-
-test('full retry requires pass coverage when prior checks or follow-ups are incomplete', () => {
-  for (const extra of [{ commands: [] }, { findings: [p1, { ...p2, followUpUrl: undefined }] }]) {
-    const prior = review([p1], { round: 3, fixRound: 3, passes: done, ...extra })
-    assert.throws(() => reviewVerdict(prior, HEAD), ReviewIncomplete)
-    const current = review([p1], { round: 4, fixRound: 3, scope: 'full', passes: done })
-    assert.equal(reviewVerdict(current, HEAD, prior).verdict, 'fix')
-    assert.equal(reviewVerdict(current, HEAD, prior).fixRound, 3)
-    const { passes, ...withoutCoverage } = current
-    assert.throws(() => reviewVerdict(withoutCoverage, HEAD, prior), /full retry must complete every pass/)
-    assert.throws(() => reviewVerdict({ ...current, scope: 'delta' }, HEAD, prior), /invalid prior review/)
-  }
-})
-
-test('a P0/P1 that survives a fix is fixed test-first', () => {
-  const prior = review([p1], { round: 1 })
-  const result = reviewVerdict(review([p1], { round: 2 }), HEAD, prior)
-  assert.equal(result.verdict, 'fix')
-  assert.equal(result.action, 'test-first')
-  assert.deepEqual(result.recurring, ['R1'])
-  const brief = fixBriefOf(result)
-  assert.match(brief.instruction, /failing test|see it fail/)
-  assert.match(brief.instruction, /every code path/)
-  assert.deepEqual(brief.recurring, ['R1'])
-})
-
-test('only new P0/P1 after a fix are fixed one by one', () => {
-  const prior = review([p1], { round: 2 })
-  const fresh = { ...p1, id: 'R4', summary: 'fix dropped the currency on refunds' }
-  const result = reviewVerdict(review([fresh, p2], { round: 3 }), HEAD, prior)
-  assert.equal(result.action, 'one-by-one')
-  assert.deepEqual(result.introduced, ['R4'])
-  assert.deepEqual(fixBriefOf(result).fix.map((f) => f.id), ['R4'])
-})
-
-test('a recurring finding wins over new ones: test-first', () => {
-  const prior = review([p1], { round: 1 })
-  const fresh = { ...p1, id: 'R4' }
-  const result = reviewVerdict(review([p1, fresh], { round: 2 }), HEAD, prior)
-  assert.equal(result.action, 'test-first')
-  assert.deepEqual(result.recurring, ['R1'])
-  assert.deepEqual(result.introduced, ['R4'])
-})
-
-test('a recurring spec finding with the same trigger and open paths is a decision, not a handback', () => {
-  const spec = { ...p1, pass: 'spec', summary: 'refund must also void the receipt' }
-  const result = reviewVerdict(review([spec], { round: 2 }), HEAD, review([spec]))
-  assert.equal(result.verdict, 'decide')
-  assert.equal(result.reason, 'spec-question')
-  assert.deepEqual(result.question.map((q) => [q.id, q.rule, q.trigger]), [['R1', spec.rule, spec.trigger]])
-  // Whitespace in the trigger is not a new trigger.
-  const reflowed = { ...spec, trigger: `  ${spec.trigger.replaceAll(' ', '\n ')}` }
-  assert.equal(reviewVerdict(review([reflowed], { round: 2 }), HEAD, review([spec])).verdict, 'decide')
-  // A new spec finding is still an ordinary fix.
-  assert.equal(reviewVerdict(review([spec], { round: 2 }), HEAD, review([])).verdict, 'fix')
-})
-
-test('a recurring spec finding with a new trigger on the same line is an incomplete fix (agentier #2521)', () => {
-  // Round 1: duplicate scalar selectors bypassed the refusal at router.ts:313. The fix closed
-  // that; round 2 found bracket-plus-scalar selectors bypassing the same line. Same id, same
-  // open path, new trigger: the rule is clear and the fix missed a path, so fix it test-first.
-  const rows = (status) => [{ path: 'apps/control-api/src/skills/router.ts:313', status: 'open' }, { path: 'apps/dashboard/impl.ts:56', ...status }]
-  const r1 = { ...p1, pass: 'spec', rule: 'a conflicting supplied org selector refuses deletion', trigger: 'DELETE ?orgId=org-a&orgId=org-b returns 204', paths: rows({ status: 'open' }) }
-  const r2 = { ...r1, trigger: 'DELETE ?orgId[x]=org-a&orgId=org-b returns 204', paths: rows({ status: 'closed', evidence: 'getAll at :56' }) }
-  const result = reviewVerdict(review([r2], { round: 2 }), HEAD, review([r1]))
-  assert.equal(result.verdict, 'fix')
-  assert.equal(result.action, 'test-first')
-  assert.deepEqual(result.recurring, ['R1'])
-})
-
-test('--decision turns a decide round into a test-first fix that carries the decision, past the stall guard', () => {
-  const spec = { ...p1, pass: 'spec' }
-  const history = [review([spec])]
-  const r2 = review([spec], { round: 2 })
-  const r3 = review([spec], { round: 3 })
-  // Without a decision, round 3 has gone two rounds without a new low.
-  assert.equal(reviewVerdict(r3, HEAD, r2, { history }).reason, 'not-converging')
-  const decided = reviewVerdict(r3, HEAD, r2, { history, decision: 'd-7' })
-  assert.equal(decided.verdict, 'fix')
-  assert.equal(decided.action, 'test-first')
-  const brief = fixBriefOf(decided)
-  assert.equal(brief.decision, 'd-7')
-  assert.match(brief.instruction, /Decision d-7 in the plan's `decisions` settles what the recurring spec finding requires/)
-  // A decision with nothing to decide changes nothing.
-  const ordinary = reviewVerdict(review([p1], { round: 2 }), HEAD, review([{ ...p1, id: 'R9' }]), { decision: 'd-7' })
-  assert.equal(ordinary.action, 'one-by-one')
-  assert.equal(fixBriefOf(ordinary).decision, undefined)
-})
-
-test('CLI exits 6 on decide with a decide file and no fix brief; --decision writes the brief', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-decide-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const write = (name, value) => { const p = join(dir, name); writeFileSync(p, JSON.stringify(value)); return p }
-  const spec = { ...p1, pass: 'spec', requestedAction: 'refuse before deleting' }
-  write('1201-r1.json', review([spec]))
-  const path = write('1201-r2.json', review([spec], { round: 2 }))
-  const run = (extra = []) => spawnSync(process.execPath, [script, '--exit-verdict', '--review', path, '--head', HEAD, ...extra], { encoding: 'utf8' })
-  const ask = run()
-  assert.equal(ask.status, 6, ask.stderr)
-  const out = JSON.parse(ask.stdout)
-  assert.equal(out.decide, join(dir, '1201-r2.decide.json'))
-  const file = JSON.parse(readFileSync(out.decide, 'utf8'))
-  assert.deepEqual([file.unit, file.round, file.head, file.reason, file.question[0].requestedAction], ['1201', 2, HEAD, 'spec-question', 'refuse before deleting'])
-  assert.equal(existsSync(join(dir, '1201-r2.fix.json')), false)
-  const fix = run(['--decision', 'd-1'])
-  assert.equal(fix.status, 1, fix.stderr)
-  assert.equal(JSON.parse(readFileSync(join(dir, '1201-r2.fix.json'), 'utf8')).decision, 'd-1')
-})
-
-test('a recurring spec finding with new open paths is an incomplete fix, not a question', () => {
-  const before = { ...p1, pass: 'spec', paths: [{ path: 'src/refund.ts:12', status: 'open' }] }
-  const after = { ...before, paths: [{ path: 'src/refund.ts:12', status: 'closed', evidence: 'voidReceipt at :12' }, { path: 'src/batch-refund.ts:30', status: 'open' }] }
-  const result = reviewVerdict(review([after], { round: 2 }), HEAD, review([before]))
-  assert.equal(result.verdict, 'fix')
-  assert.equal(result.action, 'test-first')
-})
-
-test('a P0/P1 without trigger, rule, or an open paths row is an incomplete review', () => {
-  const { rule, ...noRule } = p1
-  const { paths, ...noPaths } = p1
-  const { trigger, ...noTrigger } = p1
-  const allClosed = { ...p1, paths: [{ path: 'src/a.ts:10', status: 'closed', evidence: 'fixed at :10' }] }
-  const closedNoEvidence = { ...p1, paths: [{ path: 'src/a.ts:10', status: 'open' }, { path: 'src/b.ts:4', status: 'closed' }] }
-  for (const [name, finding, message] of [
-    ['no rule', noRule, /has no rule/], ['no paths', noPaths, /has no paths rows/], ['no trigger', noTrigger, /has no trigger/],
-    ['every row closed', allClosed, /no open paths row/], ['closed row without evidence', closedNoEvidence, /closed without evidence/],
-  ]) {
-    assert.throws(() => reviewVerdict(review([finding]), HEAD), (error) => error instanceof ReviewIncomplete && message.test(error.message), name)
-  }
-  // P2/P3 need none of them, and an earlier record without them still reads as a prior.
-  assert.equal(reviewVerdict(review([p2, p3]), HEAD).verdict, 'pass')
-  assert.equal(reviewVerdict(review([p1], { round: 2 }), HEAD, review([noPaths])).action, 'test-first')
-})
-
-test('two stalled rounds hand back at any round; P2/P3 alone still pass', () => {
-  assert.equal(reviewVerdict(review([p1], { round: 4 }), HEAD, review([p1], { round: 3 })).verdict, 'fix')
-  const result = reviewVerdict(review([p1], { round: 4 }), HEAD, review([p1], { round: 3 }), { history: [review([p1], { round: 2 })] })
-  assert.equal(result.verdict, 'handback')
-  assert.equal(result.reason, 'not-converging')
-  assert.deepEqual(result.fix.map((f) => f.id), ['R1'])
-  assert.equal(reviewVerdict(review([p2], { round: 5 }), HEAD).verdict, 'pass')
-})
-
-test('CLI reads the previous round beside the review, exits 1 test-first, and 4 on hand back without a fix brief', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-rounds-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const write = (name, value) => { const p = join(dir, name); writeFileSync(p, JSON.stringify(value)); return p }
-  const run = (path, extra = []) => spawnSync(process.execPath, [script, '--exit-verdict', '--review', path, '--head', HEAD, ...extra], { encoding: 'utf8' })
-  write('1201-r1.json', review([p1]))
-  const again = run(write('1201-r2.json', review([p1], { round: 2 })))
-  assert.equal(again.status, 1, again.stderr)
-  const out = JSON.parse(again.stdout)
-  assert.equal(out.action, 'test-first')
-  assert.equal(JSON.parse(readFileSync(out.fixBrief, 'utf8')).action, 'test-first')
-  const explicit = run(write('later.json', review([p1], { round: 2 })), ['--prior', join(dir, '1201-r1.json')])
-  assert.equal(JSON.parse(explicit.stdout).action, 'test-first')
-  const stop = run(write('1201-r3.json', review([p1], { round: 3 })))
-  assert.equal(stop.status, 4, stop.stderr)
-  assert.equal(JSON.parse(stop.stdout).reason, 'not-converging')
-  assert.equal(existsSync(join(dir, '1201-r3.fix.json')), false)
-  const named = run(write('next.json', review([p1], { round: 3 })), ['--prior', join(dir, '1201-r2.json')])
-  assert.equal(named.status, 4, named.stderr)
-  // Zero-padded names number earlier rounds with the same width.
-  for (const n of [1, 2]) write(`1201-r0${n}.json`, review([p1], { round: n }))
-  assert.equal(run(write('1201-r03.json', review([p1], { round: 3 }))).status, 4)
-  // The guard fails closed: a missing earlier round or an unnumbered name is an incomplete review.
-  rmSync(join(dir, '1201-r1.json'))
-  assert.equal(run(join(dir, '1201-r3.json')).status, 3)
-  const unnamed = run(write('cur.json', review([p1], { round: 3 })), ['--prior', write('prev.json', review([p1], { round: 2 }))])
-  assert.equal(unnamed.status, 3)
-  assert.match(unnamed.stdout, /name review files/)
-})
-
-test('CLI explicit and inferred priors prove low fix rounds at high attempt numbers and hand back two stalled rounds', (t) => {
-  for (const explicit of [false, true]) {
-    const dir = mkdtempSync(join(tmpdir(), 'review-verdict-fix-cycles-'))
-    t.after(() => rmSync(dir, { recursive: true, force: true }))
-    const write = (round, record) => {
-      const path = join(dir, `1201-r${round}.json`)
-      writeFileSync(path, JSON.stringify(record))
-      return path
-    }
-    const run = (round, record) => spawnSync(process.execPath, [script, '--exit-verdict',
-      '--review', write(round, record), '--head', HEAD,
-      ...(explicit ? ['--prior', join(dir, `1201-r${round - 1}.json`)] : []),
-      '--max-rounds', '100',
-    ], { encoding: 'utf8' })
-    for (let round = 1; round <= 8; round++) write(round, review([p2], { round, fixRound: 1 }))
-    const first = run(9, review([p1, p2], { round: 9, fixRound: 1 }))
-    assert.equal(first.status, 1, first.stderr)
-    const firstOut = JSON.parse(first.stdout)
-    assert.equal(firstOut.action, 'fix')
-    assert.equal(firstOut.round, 9)
-    assert.equal(firstOut.fixRound, 1)
-    const brief = JSON.parse(readFileSync(firstOut.fixBrief, 'utf8'))
-    assert.equal(brief.fixRound, 1)
-    assert.deepEqual(brief.fix.map((finding) => finding.id), ['R1'])
-    const second = run(10, review([p1], { round: 10, fixRound: 2 }))
-    assert.equal(second.status, 1, second.stderr)
-    assert.equal(JSON.parse(second.stdout).action, 'test-first')
-    const third = run(11, review([p1], { round: 11, fixRound: 3 }))
-    assert.equal(third.status, 4, third.stderr)
-    assert.equal(JSON.parse(third.stdout).reason, 'not-converging')
-    assert.equal(existsSync(join(dir, '1201-r11.fix.json')), false)
-    const stopped = run(12, review([p1], { round: 12, fixRound: 4 }))
-    assert.equal(stopped.status, 4, stopped.stderr)
-    assert.equal(JSON.parse(stopped.stdout).reason, 'not-converging')
-    const passed = run(12, review([p2], { round: 12, fixRound: 4 }))
-    assert.equal(passed.status, 0, passed.stderr)
-    assert.equal(JSON.parse(passed.stdout).reviewedHead, HEAD)
-    assert.equal(JSON.parse(passed.stdout).fixRound, 4)
-    const integration = run(13, review([], { round: 13, fixRound: 4 }))
-    assert.equal(integration.status, 0, integration.stderr)
-    assert.equal(JSON.parse(integration.stdout).fixRound, 4)
-  }
-})
-
-test('CLI counter and prior refusals preserve reviews and existing briefs with no verdict output', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-counter-refusals-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const path = join(dir, '1201-r9.json')
-  const priorPath = join(dir, '1201-r8.json')
-  const briefPath = join(dir, '1201-r9.fix.json')
-  const current = review([p1], { round: 9, fixRound: 2 })
-  const prior = review([p1], { round: 8, fixRound: 1 })
-  const cases = [
-    [current, '{not json', /cannot use prior review for fixRound/],
-    [current, null, /prior review must be an object/],
-    [current, [], /prior review must be an object/],
-    [current, { ...prior, unit: 'other' }, /prior review unit does not match/],
-    [current, { ...prior, version: 2 }, /review version is 2/],
-    [current, { ...prior, round: 7 }, /must immediately precede/],
-    [current, { ...prior, complete: false }, /review complete must be true/],
-    [current, { ...prior, fixRound: 0 }, /fixRound must be a positive/],
-    [current, { ...prior, fixRound: 1.5 }, /fixRound must be a positive/],
-    [current, { ...prior, fixRound: '1' }, /fixRound must be a positive/],
-    [{ ...current, fixRound: 0 }, prior, /fixRound must be a positive/],
-    [{ ...current, fixRound: -1 }, prior, /fixRound must be a positive/],
-    [{ ...current, fixRound: 1.5 }, prior, /fixRound must be a positive/],
-    [{ ...current, fixRound: null }, prior, /fixRound must be a positive/],
-    [{ ...current, fixRound: 1 }, prior, /expected 2 from prior review/],
-    [{ ...current, fixRound: 3 }, prior, /expected 2 from prior review/],
-    [current, { ...prior, findings: [] }, /expected 1 from prior review/],
-  ]
-  writeFileSync(briefPath, 'existing brief\n')
-  for (const explicit of [false, true]) {
-    for (const [record, previous, message] of cases) {
-      const bytes = JSON.stringify(record)
-      const priorBytes = typeof previous === 'string' ? previous : JSON.stringify(previous)
-      writeFileSync(path, bytes)
-      writeFileSync(priorPath, priorBytes)
-      const result = spawnSync(process.execPath, [script, '--exit-verdict', '--review', path, '--head', HEAD,
-        ...(explicit ? ['--prior', priorPath] : []),
-      ], { encoding: 'utf8' })
-      assert.equal(result.status, 3, result.stderr)
-      assert.equal(JSON.parse(result.stdout).verdict, 'review-again')
-      assert.match(result.stdout, message)
-      assert.equal(readFileSync(path, 'utf8'), bytes)
-      assert.equal(readFileSync(priorPath, 'utf8'), priorBytes)
-      assert.equal(readFileSync(briefPath, 'utf8'), 'existing brief\n')
-    }
-  }
-  rmSync(priorPath)
-  for (const explicit of [false, true]) {
-    const bytes = JSON.stringify(current)
-    writeFileSync(path, bytes)
-    const result = spawnSync(process.execPath, [script, '--exit-verdict', '--review', path, '--head', HEAD,
-      ...(explicit ? ['--prior', priorPath] : []),
-    ], { encoding: 'utf8' })
-    assert.equal(result.status, 3, result.stderr)
-    assert.equal(JSON.parse(result.stdout).verdict, 'review-again')
-    assert.match(result.stdout, explicit ? /cannot use prior review/ : /cannot be lower than round without a prior/)
-    assert.equal(readFileSync(path, 'utf8'), bytes)
-    assert.equal(readFileSync(briefPath, 'utf8'), 'existing brief\n')
-  }
-})
-
-test('a P2 in the dropbox counts as disposed and passes with its dropbox id', () => {
-  const result = reviewVerdict(review([{ ...p2, followUpUrl: undefined, dropboxId: 'D4' }]), HEAD)
-  assert.equal(result.verdict, 'pass')
-  assert.deepEqual(result.deferred.map((f) => [f.id, f.dropboxId]), [['R2', 'D4']])
-  assert.throws(() => reviewVerdict(review([{ ...p2, followUpUrl: undefined, dropboxId: 'later' }]), HEAD), /R2 is P2 without a followUpUrl or dropboxId/)
-})
-
-test('an incomplete review is sent back to the reviewer', () => {
-  const incomplete = (value, message) => assert.throws(() => reviewVerdict(value, HEAD), (e) => e instanceof ReviewIncomplete && message.test(e.message))
-  incomplete(review([], { commands: [] }), /ran no checks/)
-  incomplete(review([], { commands: ['  '] }), /ran no checks/)
-  incomplete(review([{ ...p2, followUpUrl: undefined }]), /R2 is P2 without a followUpUrl/)
-  incomplete(review([{ ...p1, severity: 'high' }]), /severity "high"/)
-  incomplete(review([p1, { ...p2, id: 'R1' }]), /duplicate finding id R1/)
-  incomplete(review([], { head: 'old0000' }), /HEAD "old0000", not abc1234/)
-  incomplete(review([], { version: 2 }), /version is 2/)
-  incomplete(review(undefined), /no findings array/)
-})
-
-test('a missing --head is a command error', () => {
-  assert.throws(() => reviewVerdict(review([]), ''), (e) => e instanceof ReviewVerdictError && !(e instanceof ReviewIncomplete))
-})
-
-test('CLI exits 0 on pass, 1 on fix with a P0/P1-only brief, 2 on a bad command, 3 on an incomplete review', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const write = (name, value) => { const p = join(dir, name); writeFileSync(p, typeof value === 'string' ? value : JSON.stringify(value)); return p }
-  const run = (path, head = HEAD) => spawnSync(process.execPath, [script, '--exit-verdict', '--review', path, '--head', head], { encoding: 'utf8' })
-
-  const pass = run(write('1201-r1.json', review([p2])))
-  assert.equal(pass.status, 0, pass.stderr)
-  assert.equal(JSON.parse(pass.stdout).verdict, 'pass')
-  assert.equal(existsSync(join(dir, '1201-r1.fix.json')), false)
-
-  const complete = run(write('1201-complete.json', review([p2, p3], {
-    complete: true,
-    passes: { ...done, spec: 'skipped: no spec found' },
-    executionIncident: { status: 'resolved' },
-    commands: ['npm test (failed)', 'npm test (corrected)'],
-    commandResults: [{ exitCode: 1 }, { exitCode: 0 }],
-  })))
-  assert.equal(complete.status, 0, complete.stderr)
-  const completed = JSON.parse(complete.stdout)
-  assert.equal(completed.reviewedHead, HEAD)
-  assert.deepEqual(completed.deferred.map((finding) => finding.id), ['R2'])
-  assert.deepEqual(completed.commands, ['npm test (failed)', 'npm test (corrected)'])
-  assert.equal(existsSync(join(dir, '1201-complete.fix.json')), false)
-
-  for (const passes of [
-    done,
-    { ...done, spec: 'skipped: no spec found', standards: 'skipped: no standards found' },
-    ...skipPrefixes.map((prefix) => ({ ...done, tests: `${prefix} documentation-only diff` })),
-    { ...done, tests: 'skipped: not applicable' },
-    { ...done, tests: 'skipped: non-applicable' },
-  ]) {
-    const compatible = run(write('compatible.json', review([], { passes })))
-    assert.equal(compatible.status, 0, compatible.stderr)
-    assert.equal(JSON.parse(compatible.stdout).reviewedHead, HEAD)
-    assert.equal(existsSync(join(dir, 'compatible.fix.json')), false)
-  }
-
-  const fix = run(write('1201-r2.json', review([p1, p2], { round: 2 })))
-  assert.equal(fix.status, 1, fix.stderr)
-  const out = JSON.parse(fix.stdout)
-  assert.equal(out.fixBrief, join(dir, '1201-r2.fix.json'))
-  assert.deepEqual(JSON.parse(readFileSync(out.fixBrief, 'utf8')).fix.map((f) => f.id), ['R1'])
-
-  assert.equal(run(join(dir, 'missing.json')).status, 2)
-  assert.equal(spawnSync(process.execPath, [script, '--exit-verdict', '--review', join(dir, '1201-r1.json')], { encoding: 'utf8' }).status, 2)
-  assert.equal(run(write('bad.json', '{not json')).status, 3)
-  const stale = run(join(dir, '1201-r1.json'), 'new9999')
-  assert.equal(stale.status, 3)
-  assert.match(stale.stdout, /spawn the reviewer again/)
-})
-
-test('CLI refuses interrupted review records without emitting delivery authority, changing input, or writing a fix brief', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-incomplete-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const incidentHead = 'f2a24bac863e3e7760afebe50e0e6f2c35e2fea8'
-  const interrupted = review([], {
-    head: incidentHead,
-    complete: false,
-    commands: ['node vitest.mjs run --config android/vitest.config.ts', 'git diff --check'],
-    passes: Object.fromEntries(Object.keys(done).map((pass) => [pass, 'skipped: unfinished; stopped after reviewer execution-scope incident'])),
-    executionIncident: { status: 'open-impact-unresolved', commandIndex: 0 },
-  })
-  const cases = [
-    interrupted,
-    review([], { complete: false }),
-    review([], { passes: { ...done, spec: 'skipped: unfinished' } }),
-    review([], { executionIncident: { status: 'open-impact-unresolved' } }),
-    review([p1], { complete: false }),
-  ]
-  for (const [index, record] of cases.entries()) {
-    const path = join(dir, `incomplete-${index}.json`)
-    const bytes = `${JSON.stringify(record, null, 2)}\n`
-    writeFileSync(path, bytes)
-    const result = spawnSync(process.execPath, [script, '--exit-verdict', '--review', path, '--head', record.head], { encoding: 'utf8' })
-    assert.equal(result.status, 3, result.stderr)
-    assert.equal(JSON.parse(result.stdout).verdict, 'review-again')
-    assert.match(result.stdout, /incomplete review/)
-    assert.equal(existsSync(join(dir, `incomplete-${index}.fix.json`)), false)
-    assert.equal(readFileSync(path, 'utf8'), bytes)
-  }
-})
-
-test('CLI refuses contradictory accepted-prefix skips before severity disposition and preserves artifacts', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-contradictory-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const path = join(dir, 'review.json')
-  const briefPath = join(dir, 'review.fix.json')
-  const retainedBrief = 'retained prior fix brief\n'
-  let index = 0
-  for (const prefix of skipPrefixes) {
-    for (const reason of incompleteReasons) {
-      const pass = Object.keys(done)[index % 4]
-      const findings = [[], [p1], [p2, p3]][index % 3]
-      const record = review(findings, { complete: true, passes: { ...done, [pass]: `${prefix} ${reason}` } })
-      const bytes = `${JSON.stringify(record, null, 2)}\n`
-      writeFileSync(path, bytes)
-      if (index === 1) writeFileSync(briefPath, retainedBrief)
-      const result = spawnSync(process.execPath, [script, '--exit-verdict', '--review', path, '--head', HEAD], { encoding: 'utf8' })
-      assert.equal(result.status, 3, `${prefix} ${reason}: ${result.stderr}`)
-      assert.equal(JSON.parse(result.stdout).verdict, 'review-again')
-      assert.match(result.stdout, new RegExp(`review pass ${pass} is unfinished`))
-      assert.equal(readFileSync(path, 'utf8'), bytes)
-      if (index === 0) assert.equal(existsSync(briefPath), false)
-      else assert.equal(readFileSync(briefPath, 'utf8'), retainedBrief)
-      index += 1
-    }
-  }
-})
-
-test('a skip record passes only when the scope rerun still picks skip', () => {
-  const prior = review([p2], { head: 'old1234', fixRound: 1, complete: true, passes: done })
-  const skip = review([], { round: 2, fixRound: 1, tier: 'skip', carriedFrom: 'old1234', complete: true, passes: done, commands: [] })
-  const confirm = (tier, reasons = []) => () => ({ tier, reasons })
-  const passed = reviewVerdict(skip, HEAD, prior, { confirmSkip: confirm('skip') })
-  assert.equal(passed.verdict, 'pass')
-  assert.equal(passed.reviewedHead, HEAD)
-  assert.equal(passed.tier, 'skip')
-  assert.equal(passed.carriedFrom, 'old1234')
-  assert.deepEqual(passed.deferred, [], 'carried P2/P3 already have their follow-ups')
-  assert.throws(() => reviewVerdict(skip, HEAD, prior, { confirmSkip: confirm('delta', ['b.txt moved under the PR']) }), /picks "delta"[\s\S]*b\.txt moved/)
-  assert.throws(() => reviewVerdict(skip, HEAD, prior), (e) => e instanceof ReviewVerdictError && !(e instanceof ReviewIncomplete) && /--base is required/.test(e.message))
-  assert.throws(() => reviewVerdict(skip, HEAD, null, { confirmSkip: confirm('skip') }), /the review it carries is missing/)
-  assert.throws(() => reviewVerdict({ ...skip, carriedFrom: 'other' }, HEAD, prior, { confirmSkip: confirm('skip') }), /carries "other"/)
-  assert.throws(() => reviewVerdict({ ...skip, findings: [p1] }, HEAD, prior, { confirmSkip: confirm('skip') }), /cannot hold findings/)
-  assert.throws(() => reviewVerdict(review([], { tier: 'delta', commands: [] }), HEAD), /ran no checks/, 'only a skip is exempt from running checks')
-})
-
-test('tier and the legacy scope field are read the same way', () => {
-  const prior = review([p1], { fixRound: 1, complete: false, passes: { ...done, tests: 'partial' }, commands: [] })
-  const current = review([], { round: 2, fixRound: 1, tier: 'full', complete: true, passes: done })
-  assert.equal(reviewVerdict(current, HEAD, prior).verdict, 'pass')
-  assert.throws(() => reviewVerdict({ ...current, tier: 'delta' }, HEAD, prior), /invalid prior review/)
-})
-
-test('every link of a skip chain must hold back to a real review', () => {
-  const confirmSkip = () => ({ tier: 'skip', reasons: [] })
-  const root = review([], { head: 'h1', fixRound: 1, complete: true, passes: done })
-  const link = (round, carriedFrom, extra = {}) => review([], { round, fixRound: 1, head: `h${round}`, tier: 'skip', carriedFrom, complete: true, passes: done, commands: [], ...extra })
-  const r2 = link(2, 'h1')
-  const r3 = { ...link(3, 'h2'), head: HEAD }
-  assert.equal(reviewVerdict(r3, HEAD, r2, { confirmSkip, earlier: [root] }).verdict, 'pass', 'an honest skip -> skip chain passes')
-  assert.throws(() => reviewVerdict(r3, HEAD, r2, { confirmSkip }), /round 2: the review it carries is missing/, 'a chain that cannot be walked fails closed')
-
-  // Codex F1: a forged skip prior that carries an approval that never existed.
-  const forged = link(2, 'no-such-approval')
-  assert.throws(() => reviewVerdict(r3, HEAD, forged, { confirmSkip, earlier: [root] }), /round 2: it carries "no-such-approval"/)
-  assert.throws(() => reviewVerdict(r3, HEAD, r2, { confirmSkip, earlier: [{ ...root, commands: [] }] }), /ran no checks/, 'the chain must end at a review that ran checks')
-  assert.throws(() => reviewVerdict(r3, HEAD, r2, { confirmSkip, earlier: [{ ...root, findings: [p1] }] }), /open P0\/P1/)
-
-  // Codex F2: dropping fixRound must not skip the unit and round checks.
-  const { fixRound: _a, ...legacyRoot } = root
-  const { fixRound: _b, ...stripped } = { ...link(2, 'h1'), head: HEAD }
-  assert.throws(() => reviewVerdict({ ...stripped, unit: 'other', round: 99 }, HEAD, legacyRoot, { confirmSkip }), /unit differs[\s\S]*round does not follow/)
-  assert.throws(() => reviewVerdict(stripped, HEAD, legacyRoot, { confirmSkip }), /fixRound is undefined/)
-  const { findings: _c, ...noFindings } = root
-  assert.throws(() => reviewVerdict({ ...link(2, 'h1'), head: HEAD }, HEAD, noFindings, { confirmSkip }), /no findings array/)
-})
-
-test('the verdict CLI walks a skip chain by filename and fails closed when it cannot', () => {
-  const dir = mkdtempSync(join(tmpdir(), 'verdict-chain-'))
-  try {
-    const base = { version: 1, unit: '1201', complete: true, passes: done, findings: [] }
-    writeFileSync(join(dir, '1201-r1.json'), JSON.stringify({ ...base, round: 1, fixRound: 1, head: 'h1', commands: ['npm test'] }))
-    writeFileSync(join(dir, '1201-r2.json'), JSON.stringify({ ...base, round: 2, fixRound: 1, head: 'h2', tier: 'skip', carriedFrom: 'h1', commands: [] }))
-    writeFileSync(join(dir, '1201-r3.json'), JSON.stringify({ ...base, round: 3, fixRound: 1, head: 'h3', tier: 'skip', carriedFrom: 'h2', commands: [] }))
-    const run = () => spawnSync('node', [script, '--exit-verdict', '--review', join(dir, '1201-r3.json'), '--head', 'h3', '--base', 'main'], { cwd: dir, encoding: 'utf8' })
-    // The chain holds, so the check reaches the git rerun, which has no repository here: exit 2.
-    assert.equal(run().status, 2, run().stderr)
-    writeFileSync(join(dir, '1201-r1.json'), JSON.stringify({ ...base, round: 1, fixRound: 1, head: 'h1', commands: [] }))
-    const broken = run()
-    assert.equal(broken.status, 3)
-    assert.match(broken.stdout, /round 2: the review it carries: the reviewer ran no checks/)
-  } finally {
-    rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-const ghP1 = { id: 'gh-review-11', severity: 'P1', pass: 'external', source: 'github', author: 'vera932', summary: 'refund rounds the wrong way', trigger: "vera932's changes request on GitHub: u", rule: 'blocking review feedback on the PR is resolved before merge', paths: [{ path: 'u', status: 'open' }] }
-
-test('a GitHub finding blocks like the reviewer\'s and reaches the fix brief', () => {
-  const result = reviewVerdict(review([ghP1, p2]), HEAD)
-  assert.equal(result.verdict, 'fix')
-  assert.deepEqual(result.fix.map((f) => f.id), ['gh-review-11'])
-  assert.equal(fixBriefOf(result).fix[0].source, 'github')
-})
-
-test('a re-review still awaited waits instead of passing; a blocker still fixes first', () => {
-  const awaiting = [{ id: 'gh-review-11', author: 'vera932', url: 'https://github.com/o/r/pull/1#pullrequestreview-11' }]
-  const waiting = reviewVerdict(review([p2], { external: { awaiting } }), HEAD)
-  assert.equal(waiting.verdict, 'wait')
-  assert.equal(waiting.reviewedHead, undefined, 'a wait records no reviewed HEAD')
-  assert.deepEqual(waiting.awaiting, awaiting)
-  const fixing = reviewVerdict(review([p1], { external: { awaiting } }), HEAD)
-  assert.equal(fixing.verdict, 'fix')
-  assert.deepEqual(fixing.awaiting, awaiting)
-  assert.equal(reviewVerdict(review([], { external: { awaiting: [] } }), HEAD).verdict, 'pass')
-})
-
-test('a skip record may carry GitHub findings, never the reviewer\'s', () => {
-  const prior = review([], { complete: true, passes: done, head: 'old1234' })
-  const skip = review([ghP1], { round: 2, fixRound: 1, tier: 'skip', carriedFrom: 'old1234', complete: true, passes: done, commands: [] })
-  const confirmSkip = () => ({ tier: 'skip', reasons: [] })
-  const result = reviewVerdict(skip, HEAD, prior, { confirmSkip })
-  assert.equal(result.verdict, 'fix')
-  assert.deepEqual(result.fix.map((f) => f.id), ['gh-review-11'])
-  assert.throws(() => reviewVerdict({ ...skip, findings: [ghP1, p1] }, HEAD, prior, { confirmSkip }), /cannot hold findings/)
-})
-
-test('CLI exits 5 while a re-review is awaited', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-wait-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const path = join(dir, '1201-r1.json')
-  writeFileSync(path, JSON.stringify(review([], { external: { awaiting: [{ id: 'gh-review-11', author: 'vera932' }] } })))
-  const run = spawnSync(process.execPath, [script, '--exit-verdict', '--review', path, '--head', HEAD], { encoding: 'utf8' })
-  assert.equal(run.status, 5, run.stderr)
-  assert.equal(JSON.parse(run.stdout).verdict, 'wait')
-})
-
-test('no finding is exempt from the blocking shape, whatever it claims', () => {
-  const forged = { id: 'R1', severity: 'P1', summary: 'real local blocker', source: 'github' }
-  assert.throws(() => reviewVerdict(review([forged], { external: { added: ['R1'] } }), HEAD), /R1 \(P0\/P1\) has no trigger/)
-  assert.throws(() => reviewVerdict(review([{ ...ghP1, trigger: undefined }]), HEAD), /gh-review-11 \(P0\/P1\) has no trigger/)
-})
-
-test('a HEAD pushed after a passing review carries it with no reviewer and no scope rerun', () => {
-  const passed = review([p2], { head: 'old1234', fixRound: 2, round: 4, complete: true, passes: done })
-  const carry = carryRecord(passed, HEAD)
-  assert.equal(carry.tier, 'skip')
-  assert.equal(carry.carry, AFTER_PASS)
-  assert.equal(carry.carriedFrom, 'old1234')
-  assert.equal(carry.round, 5)
-  assert.equal(carry.fixRound, 2, 'a carry is not a fix cycle')
-  assert.deepEqual(carry.findings, [], 'carried P2/P3 already have their follow-ups')
-  const result = reviewVerdict(carry, HEAD, passed)
-  assert.equal(result.verdict, 'pass', 'no --base: the chain alone proves the approval')
-  assert.equal(result.reviewedHead, HEAD)
-  assert.equal(result.carriedFrom, 'old1234')
-
-  const next = carryRecord(carry, 'new5678')
-  assert.equal(reviewVerdict(next, 'new5678', carry, { earlier: [passed] }).verdict, 'pass', 'carries chain over later CI fixes')
-  assert.throws(() => reviewVerdict(next, 'new5678', carry), /round 5: the review it carries is missing/, 'a chain that cannot be walked fails closed')
-})
-
-test('only a passing round can be carried; a P0/P1 fix is always reviewed', () => {
-  const passed = review([], { head: 'old1234', fixRound: 1, complete: true, passes: done })
-  assert.throws(() => carryRecord({ ...passed, findings: [p1] }, HEAD), (e) => e instanceof ReviewIncomplete && /open P0\/P1/.test(e.message))
-  assert.throws(() => carryRecord({ ...passed, findings: [ghP1] }, HEAD), /open P0\/P1/, 'a GitHub changes request blocks the carry')
-  assert.throws(() => carryRecord({ ...passed, external: { awaiting: [{ id: 'gh-review-11' }] } }, HEAD), /awaits a GitHub re-review/)
-  assert.throws(() => carryRecord({ ...passed, passes: { ...done, tests: 'partial' } }, HEAD), /review pass tests is unfinished/)
-  assert.throws(() => carryRecord({ ...passed, complete: false }, HEAD), /complete must be true/)
-  assert.throws(() => carryRecord({ ...passed, commands: [] }, HEAD), /ran no checks/)
-  assert.throws(() => carryRecord(passed, 'old1234'), /already of old1234/)
-  assert.throws(() => carryRecord(null, HEAD), /no previous round/)
-  const { head: _h, ...headless } = passed
-  assert.throws(() => carryRecord(headless, HEAD), /it has no head/)
-  const { complete: _c, ...legacy } = passed
-  assert.throws(() => carryRecord(legacy, HEAD), /not marked complete/, 'as next-actions, a carry needs complete: true')
-  // A record that claims to be a carry still needs a passing round before it.
-  const forged = { ...carryRecord(passed, HEAD) }
-  assert.throws(() => reviewVerdict(forged, HEAD, { ...passed, findings: [p1] }), /open P0\/P1/)
-  assert.throws(() => reviewVerdict({ ...forged, findings: [p1] }, HEAD, passed), /cannot hold findings/)
-  const ghResult = reviewVerdict({ ...forged, findings: [ghP1] }, HEAD, passed)
-  assert.equal(ghResult.verdict, 'fix', 'GitHub feedback merged onto a carry still blocks')
-})
-
-
-// A repository with main and a PR branch of `count` commits; returns their shas, oldest first.
-function prRepo(dir, count) {
-  const git = (...args) => spawnSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', ...args], { cwd: dir, encoding: 'utf8' }).stdout.trim()
-  git('init', '-q', '-b', 'main')
-  writeFileSync(join(dir, 'a.txt'), 'base\n'); git('add', '.'); git('commit', '-qm', 'base')
-  git('checkout', '-qb', 'pr')
-  const heads = []
-  const body = Array.from({ length: 40 }, (_, j) => `line ${j}`)
-  for (let i = 1; i <= count; i++) {
-    body[i] = `line ${i} changed`
-    writeFileSync(join(dir, 'a.txt'), `base\n${body.join('\n')}\n`); git('commit', '-qam', `c${i}`)
-    heads.push(git('rev-parse', 'HEAD'))
-  }
-  return heads
-}
-
-test('the verdict CLI writes a carry record in the review clone, then passes it without --base', () => {
-  const dir = mkdtempSync(join(tmpdir(), 'verdict-carry-'))
-  try {
-    const h = prRepo(dir, 4)
-    const reviews = join(dir, 'reviews')
-    spawnSync('mkdir', [reviews])
-    const base = { version: 1, unit: '1201', complete: true, passes: done, findings: [] }
-    writeFileSync(join(reviews, '1201-r1.json'), JSON.stringify({ ...base, round: 1, fixRound: 1, head: h[0], commands: ['npm test'], findings: [p1] }))
-    writeFileSync(join(reviews, '1201-r2.json'), JSON.stringify({ ...base, round: 2, fixRound: 2, head: h[1], tier: 'delta', fixLinesSinceFull: 2, commands: ['npm test'] }))
-    const node = (...args) => spawnSync('node', [script, '--exit-verdict', ...args], { cwd: dir, encoding: 'utf8' })
-    const carry = (round, head, ...extra) => node('--carry', '--review', join(reviews, `1201-r${round}.json`), '--head', head, '--base', 'main', ...extra)
-    const verdict = (round, head, ...extra) => node('--review', join(reviews, `1201-r${round}.json`), '--head', head, ...extra)
-
-    const wrote = carry(3, h[2])
-    assert.equal(wrote.status, 0, wrote.stderr)
-    const record = JSON.parse(readFileSync(join(reviews, '1201-r3.json'), 'utf8'))
-    assert.equal(record.carriedFrom, h[1])
-    assert.match(record.mergeBase, /^[0-9a-f]{40}$/, 'records the merge-base so a later tier can anchor on it')
-    assert.match(record.patchFingerprint, /^[0-9a-f]{64}$/)
-    assert.equal(verdict(3, h[2]).status, 0, verdict(3, h[2]).stderr)
-    assert.equal(carry(3, h[2]).status, 2, 'never overwrites a round')
-
-    // A carry as the prior of the next tier anchors a delta, not a forced full review.
-    const cwd = process.cwd()
-    process.chdir(dir)
-    try {
-      const scope = rereviewScope({ prior: record, base: 'main', head: h[3] })
-      assert.equal(scope.tier, 'delta', scope.reasons.join('; '))
-    } finally { process.chdir(cwd) }
-
-    assert.equal(carry(4, h[3]).status, 0)
-    const chained = verdict(4, h[3])
-    assert.equal(chained.status, 0, chained.stderr)
-    assert.equal(JSON.parse(chained.stdout).fixRound, 2)
-
-    assert.equal(node('--carry', '--review', join(reviews, '1201-r5.json'), '--head', h[3]).status, 2, '--base is required')
-    assert.match(carry(5, h[3], '--prior', join(reviews, '1201-r1.json')).stderr, /drop --prior/, 'a carry always carries the round just before it')
-    assert.match(carry(3, h[3]).stderr, /exists/)
-    assert.equal(spawnSync('node', [script, '--exit-verdict', '--carry', '--review', join(reviews, '1201-r9.json'), '--head', h[3], '--base', 'nope'], { cwd: dir, encoding: 'utf8' }).status, 3, 'no round 8 to carry')
-  } finally {
-    rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-test('a carry cannot pass over a newer round that holds a P0/P1', () => {
-  const dir = mkdtempSync(join(tmpdir(), 'verdict-carry-stale-'))
-  try {
-    const h = prRepo(dir, 3)
-    const base = { version: 1, unit: 'u', complete: true, passes: done, commands: ['npm test'] }
-    writeFileSync(join(dir, 'u-r1.json'), JSON.stringify({ ...base, round: 1, fixRound: 1, head: h[0], findings: [] }))
-    writeFileSync(join(dir, 'u-r2.json'), JSON.stringify({ ...base, round: 2, fixRound: 1, head: h[1], tier: 'delta', fixLinesSinceFull: 1, findings: [p1] }))
-    const node = (...args) => spawnSync('node', [script, '--exit-verdict', ...args], { cwd: dir, encoding: 'utf8' })
-
-    const blocked = node('--carry', '--review', join(dir, 'u-r3.json'), '--head', h[2], '--base', 'main')
-    assert.equal(blocked.status, 3, 'round 2 holds a P1: review the fix')
-    assert.equal(node('--carry', '--review', join(dir, 'u-r2.json'), '--head', h[2], '--base', 'main').status, 2, 'r2 exists')
-    rmSync(join(dir, 'u-r2.json'))
-    writeFileSync(join(dir, 'u-r4.json'), '{}')
-    assert.match(node('--carry', '--review', join(dir, 'u-r2.json'), '--head', h[2], '--base', 'main').stderr, /carry only the newest round/)
-
-    // A hand-made carry numbered for an older slot, or a stale --prior, fails closed.
-    const forged = carryRecord({ ...base, round: 1, fixRound: 1, head: h[0], findings: [] }, h[2])
-    writeFileSync(join(dir, 'u-r3.json'), JSON.stringify(forged))
-    const mismatch = node('--review', join(dir, 'u-r3.json'), '--head', h[2], '--prior', join(dir, 'u-r1.json'))
-    assert.equal(mismatch.status, 3)
-    assert.match(mismatch.stdout, /records round 2, not its file's 3/)
-    writeFileSync(join(dir, 'u-r3.json'), JSON.stringify({ ...forged, round: 3 }))
-    assert.match(node('--review', join(dir, 'u-r3.json'), '--head', h[2], '--prior', join(dir, 'u-r1.json')).stdout, /round does not follow/)
-  } finally {
-    rmSync(dir, { recursive: true, force: true })
-  }
-})
-
-test('by default every verdict exits 0 with the verdict in the output; only a script failure exits 2', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-exit0-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const write = (name, value) => { const p = join(dir, name); writeFileSync(p, typeof value === 'string' ? value : JSON.stringify(value)); return p }
-  const call = (path, ...extra) => spawnSync(process.execPath, [script, '--review', path, '--head', HEAD, ...extra], { encoding: 'utf8' })
-  const verdictOf = (r) => { assert.equal(r.status, 0, r.stderr); return JSON.parse(r.stdout).verdict }
-
-  assert.equal(verdictOf(call(write('1201-r1.json', review([p2])))), 'pass')
-  assert.equal(verdictOf(call(write('1202-r1.json', review([p1])))), 'fix')
-  assert.equal(verdictOf(call(write('1203-r1.json', review([], { external: { awaiting: [{ id: 'gh-review-11', author: 'vera932' }] } })))), 'wait')
-  // incomplete: an answer ("review again") with the reason in stdout, nothing on stderr
-  const again = call(write('1204-r1.json', '{not json'))
-  assert.equal(again.status, 0, again.stderr)
-  assert.equal(again.stderr, '')
-  assert.deepEqual(Object.keys(JSON.parse(again.stdout)), ['verdict', 'reason'])
-  assert.equal(JSON.parse(again.stdout).verdict, 'review-again')
-  assert.match(JSON.parse(again.stdout).reason, /spawn the reviewer again/)
-  // a script failure is still 2
-  assert.equal(call(join(dir, 'missing.json')).status, 2)
-  assert.equal(spawnSync(process.execPath, [script, '--review', join(dir, '1201-r1.json')], { encoding: 'utf8' }).status, 2)
-  // --json is accepted (the output is always JSON)
-  assert.equal(verdictOf(call(join(dir, '1201-r1.json'), '--json')), 'pass')
-})
-
-test('handback and decide exit 0 by default and keep their legacy codes under --exit-verdict', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-exit0b-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const write = (name, value) => { const p = join(dir, name); writeFileSync(p, JSON.stringify(value)); return p }
-  const spec = { ...p1, pass: 'spec', requestedAction: 'refuse before deleting' }
-  write('1201-r1.json', review([spec]))
-  const decidePath = write('1201-r2.json', review([spec], { round: 2 }))
-  const call = (path, ...extra) => spawnSync(process.execPath, [script, '--review', path, '--head', HEAD, ...extra], { encoding: 'utf8' })
-  const plain = call(decidePath)
-  assert.equal(plain.status, 0, plain.stderr)
-  assert.equal(JSON.parse(plain.stdout).verdict, 'decide')
-  assert.equal(call(decidePath, '--exit-verdict').status, 6)
-
-  const hbDir = mkdtempSync(join(tmpdir(), 'review-verdict-exit0c-'))
-  t.after(() => rmSync(hbDir, { recursive: true, force: true }))
-  const hb = (name, value) => { const p = join(hbDir, name); writeFileSync(p, JSON.stringify(value)); return p }
-  hb('1201-r1.json', review([p1]))
-  hb('1201-r2.json', review([p1], { round: 2 }))
-  const third = hb('1201-r3.json', review([p1], { round: 3 }))
-  const handback = call(third)
-  assert.equal(handback.status, 0, handback.stderr)
-  assert.equal(JSON.parse(handback.stdout).verdict, 'handback')
-  assert.equal(call(third, '--exit-verdict').status, 4)
-})
-
-test('--exit-verdict restores 3 for review-again and 1 for fix', (t) => {
-  const dir = mkdtempSync(join(tmpdir(), 'review-verdict-legacy-'))
-  t.after(() => rmSync(dir, { recursive: true, force: true }))
-  const path = join(dir, '1201-r1.json')
-  writeFileSync(path, '{not json')
-  const again = spawnSync(process.execPath, [script, '--review', path, '--head', HEAD, '--exit-verdict'], { encoding: 'utf8' })
-  assert.equal(again.status, 3)
-  assert.equal(JSON.parse(again.stdout).verdict, 'review-again')
-  writeFileSync(path, JSON.stringify(review([p1])))
-  assert.equal(spawnSync(process.execPath, [script, '--review', path, '--head', HEAD, '--exit-verdict'], { encoding: 'utf8' }).status, 1)
-})