@1aboveio/skills 1.0.8 → 1.0.10

package/skills/engineering/resolve-issues/scripts/dropbox.test.mjs

@@ -1,346 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { execFileSync, spawnSync } from 'node:child_process'
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { addEntry, changedRanges, emptyDropbox, fingerprint, fromReview, groupEntries, inUnitDiff, issueFor, markEntry, pendingRuns, planPost, post, sanitize } from './dropbox.mjs'
-
-const script = join(dirname(fileURLToPath(import.meta.url)), 'dropbox.mjs')
-const tmp = () => mkdtempSync(join(tmpdir(), 'dropbox-'))
-
-// A repository on `main` with a.ts (10 lines) and a unit branch that edits line 3 and adds b.ts.
-function unitRepo() {
-  const dir = tmp()
-  const git = (...args) => execFileSync('git', ['-C', dir, ...args], { encoding: 'utf8' })
-  git('init', '-q', '-b', 'main')
-  git('config', 'user.email', 't@example.com')
-  git('config', 'user.name', 't')
-  writeFileSync(join(dir, 'a.ts'), Array.from({ length: 10 }, (_, i) => `line ${i + 1}`).join('\n') + '\n')
-  git('add', '.')
-  git('commit', '-qm', 'base')
-  git('checkout', '-qb', 'unit')
-  const lines = readFileSync(join(dir, 'a.ts'), 'utf8').split('\n')
-  lines[2] = 'changed 3'
-  writeFileSync(join(dir, 'a.ts'), lines.join('\n'))
-  writeFileSync(join(dir, 'b.ts'), 'new\n')
-  git('add', '.')
-  git('commit', '-qm', 'unit')
-  return dir
-}
-
-const entry = (over = {}) => ({ unit: '12', source: 'review', kind: 'docs', file: 'docs/a.md', line: 4, summary: 'typo in heading', ...over })
-
-test('hunk ranges come from the new side; a pure deletion adds none', () => {
-  assert.deepEqual(changedRanges('@@ -3 +3 @@\n@@ -7,0 +8,2 @@\n@@ -12,3 +13,0 @@\n'), [[3, 3], [8, 9]])
-})
-
-test('the unit diff covers changed lines and added files, not untouched lines', () => {
-  const dir = unitRepo()
-  assert.equal(inUnitDiff({ dir, base: 'main', file: 'a.ts', line: 3 }), true)
-  assert.equal(inUnitDiff({ dir, base: 'main', file: 'a.ts', line: 7 }), false)
-  assert.equal(inUnitDiff({ dir, base: 'main', file: 'a.ts' }), true, 'without a line, any change to the file counts')
-  assert.equal(inUnitDiff({ dir, base: 'main', file: 'b.ts', line: 1 }), true)
-})
-
-test('uncommitted work in the workspace counts as the unit\'s change', () => {
-  const dir = unitRepo()
-  const lines = readFileSync(join(dir, 'a.ts'), 'utf8').split('\n')
-  lines[8] = 'edited 9'
-  writeFileSync(join(dir, 'a.ts'), lines.join('\n'))
-  assert.equal(inUnitDiff({ dir, base: 'main', file: 'a.ts', line: 9 }), true)
-})
-
-test('check exits 0 and reports inDiff true inside the diff and false outside', () => {
-  const dir = unitRepo()
-  const inside = spawnSync('node', [script, 'check', '--git', dir, '--base', 'main', '--file', 'a.ts', '--line', '3'], { encoding: 'utf8' })
-  assert.equal(inside.status, 0, inside.stderr)
-  assert.deepEqual([JSON.parse(inside.stdout).inDiff, JSON.parse(inside.stdout).do], [true, 'fix it in this unit'])
-  const outside = spawnSync('node', [script, 'check', '--git', dir, '--base', 'main', '--file', 'a.ts', '--line', '7'], { encoding: 'utf8' })
-  assert.equal(outside.status, 0, outside.stderr)
-  assert.equal(JSON.parse(outside.stdout).inDiff, false)
-})
-
-test('an implementer entry inside its own diff is refused; a review entry there is kept and marked', () => {
-  const box = emptyDropbox()
-  assert.equal(addEntry(box, entry({ source: 'implementer' }), true).refused, true)
-  assert.equal(box.entries.length, 0)
-  const kept = addEntry(box, entry({ source: 'review', finding: 'R2', severity: 'P2' }), true)
-  assert.equal(kept.inDiff, true)
-  assert.equal(box.entries[0].inDiff, true)
-})
-
-test('a P3 is skipped: add refuses it and from-review never adds it', () => {
-  const box = emptyDropbox()
-  assert.throws(() => addEntry(box, entry({ source: 'review', finding: 'R3', severity: 'P3' }), false), /a P3 is skipped/)
-  const review = { unit: '12', findings: [{ id: 'R3', severity: 'P3', summary: 'tidy comment', file: 'a.ts', line: 2 }] }
-  assert.deepEqual(fromReview(box, review), [])
-  assert.equal(review.findings[0].dropboxId, undefined)
-  assert.equal(box.entries.length, 0)
-})
-
-test('the CLI add refuses an implementer entry inside the diff with `refused` (exit 0) and writes nothing', () => {
-  const dir = unitRepo()
-  const path = join(tmp(), 'dropbox.json')
-  const args = ['add', '--dropbox', path, '--unit', '7', '--source', 'implementer', '--kind', 'bug', '--file', 'a.ts', '--line', '3', '--summary', 's', '--git', dir, '--base', 'main']
-  const refused = spawnSync('node', [script, ...args], { encoding: 'utf8' })
-  assert.equal(refused.status, 0, refused.stderr)
-  assert.ok(JSON.parse(refused.stdout).refused)
-  assert.equal(existsSync(path), false)
-  const ok = spawnSync('node', [script, ...args.map((a) => (a === '3' ? '7' : a))], { encoding: 'utf8' })
-  assert.equal(ok.status, 0, ok.stderr)
-  assert.equal(JSON.parse(readFileSync(path, 'utf8')).entries[0].inDiff, false)
-})
-
-test('a P0/P1, a missing location, or an unknown kind is rejected', () => {
-  const box = emptyDropbox()
-  assert.throws(() => addEntry(box, entry({ severity: 'P1' })), /never goes in the dropbox/)
-  assert.throws(() => addEntry(box, entry({ file: undefined })), /--file is required/)
-  assert.throws(() => addEntry(box, entry({ kind: 'nit' })), /--kind must be/)
-})
-
-test('the same problem is one entry, and a review finding id is one entry across rounds', () => {
-  const box = emptyDropbox()
-  const first = addEntry(box, entry())
-  assert.deepEqual(addEntry(box, entry({ summary: '  Typo in   heading ' })), { id: first.id, duplicate: true, inDiff: null })
-  const r = addEntry(box, entry({ finding: 'R3', file: 'x.ts', summary: 'one wording' }))
-  assert.equal(addEntry(box, entry({ finding: 'R3', file: 'x.ts', line: 9, summary: 'reworded next round' })).id, r.id)
-  assert.equal(box.entries.length, 2)
-})
-
-test('local absolute paths never reach an issue, and summaries are capped', () => {
-  assert.equal(sanitize('see /Users/someone/run/a.log and /tmp/x'), 'see <local path> and <local path>')
-  assert.equal(sanitize('see src/tmp/cache.ts and app/home/page.tsx'), 'see src/tmp/cache.ts and app/home/page.tsx', 'repository paths stay')
-  assert.ok(sanitize('x'.repeat(400)).length <= 280)
-})
-
-test('entries group by parent PR and by file and kind across PRs', () => {
-  const box = emptyDropbox()
-  addEntry(box, entry({ file: 'a.ts', kind: 'test', summary: '1', pr: 'https://github.com/o/r/pull/5' }))
-  addEntry(box, entry({ file: 'b.ts', kind: 'docs', summary: '2', pr: 'https://github.com/o/r/pull/5' }))
-  addEntry(box, entry({ file: 'a.ts', kind: 'test', summary: '3', pr: 'https://github.com/o/r/pull/6' }))
-  addEntry(box, entry({ file: 'z.ts', kind: 'ci', summary: '4', pr: 'https://github.com/o/r/pull/7' }))
-  const groups = groupEntries(box.entries)
-  assert.deepEqual(groups.map((g) => [g.id, g.entries.map((e) => e.summary)]), [['G1', ['1', '2', '3']], ['G4', ['4']]])
-})
-
-test('the issue lists each location, its parent PR, what it blocks, and a fingerprint marker', () => {
-  const box = emptyDropbox()
-  addEntry(box, entry({ file: 'a.ts', line: 3, kind: 'test', summary: 'weak assert', pr: 'https://github.com/o/r/pull/5', finding: 'R2', blocks: ['https://github.com/o/r/issues/44'] }))
-  addEntry(box, entry({ file: 'a.ts', line: 9, kind: 'test', summary: 'no failure case', pr: 'https://github.com/o/r/pull/5' }))
-  const { title, body } = issueFor(groupEntries(box.entries)[0])
-  assert.equal(title, '2 test follow-ups in a.ts')
-  assert.match(body, /`a\.ts:3` \(test\) weak assert \(from #5, finding R2\)/)
-  assert.match(body, /Blocks o\/r#44/)
-  for (const e of box.entries) assert.ok(body.includes(`dropbox-fp:${e.fingerprint}`))
-})
-
-test('plan drops an entry whose file is gone and never posts decisions', () => {
-  const dir = unitRepo()
-  const box = emptyDropbox()
-  addEntry(box, entry({ file: 'a.ts', summary: 'kept' }))
-  addEntry(box, entry({ file: 'gone.ts', summary: 'gone' }))
-  addEntry(box, { unit: '12', source: 'implementer', decision: true, summary: 'should refunds round half-even?' })
-  const plan = planPost(box, { dir, ref: 'unit' })
-  assert.deepEqual(plan.dropped, ['D2'])
-  assert.deepEqual(plan.groups.flatMap((g) => g.entries.map((e) => e.summary)), ['kept'])
-  assert.deepEqual(plan.decisions.map((d) => d.summary), ['should refunds round half-even?'])
-})
-
-function fakeGh(openIssues = []) {
-  const calls = []
-  return {
-    calls,
-    gh: (args, input) => {
-      calls.push({ args, input })
-      if (args[1] === 'list') return JSON.stringify(openIssues)
-      if (args[1] === 'create') return `https://github.com/o/r/issues/${100 + calls.length}\n`
-      throw new Error(`unexpected gh ${args.join(' ')}`)
-    },
-  }
-}
-
-test('post files one labeled issue per group and records each entry\'s URL', () => {
-  const box = emptyDropbox()
-  addEntry(box, entry({ file: 'a.ts', summary: '1', pr: 'https://github.com/o/r/pull/5' }))
-  addEntry(box, entry({ file: 'b.ts', summary: '2', pr: 'https://github.com/o/r/pull/5' }))
-  addEntry(box, entry({ file: 'c.ts', kind: 'ci', summary: '3' }))
-  const { gh, calls } = fakeGh()
-  const result = post(box, { repo: 'o/r' }, { gh })
-  const creates = calls.filter((c) => c.args[1] === 'create')
-  assert.equal(creates.length, 2)
-  for (const c of creates) assert.deepEqual(c.args.slice(c.args.indexOf('--label'), c.args.indexOf('--label') + 2), ['--label', 'ready-for-agent'])
-  assert.equal(result.posted.length, 2)
-  assert.ok(box.entries.every((e) => e.status === 'posted' && e.postedUrl.startsWith('https://github.com/o/r/issues/')))
-})
-
-test('post skips an entry an open issue already carries, and --only limits the groups', () => {
-  const box = emptyDropbox()
-  addEntry(box, entry({ file: 'a.ts', summary: '1' }))
-  addEntry(box, entry({ file: 'c.ts', kind: 'ci', summary: '3' }))
-  addEntry(box, entry({ file: 'd.ts', kind: 'perf', summary: '4' }))
-  const filed = { url: 'https://github.com/o/r/issues/9', body: `<!-- dropbox-fp:${box.entries[0].fingerprint} -->` }
-  const { gh, calls } = fakeGh([filed])
-  const result = post(box, { repo: 'o/r', only: ['G2'] }, { gh })
-  assert.deepEqual(result.alreadyFiled, ['D1'])
-  assert.equal(box.entries[0].postedUrl, filed.url)
-  assert.equal(calls.filter((c) => c.args[1] === 'create').length, 1)
-  assert.equal(box.entries[1].status, 'posted')
-  assert.equal(box.entries[2].status, 'pending', 'G3 was not asked for')
-})
-
-test('from-review adds each undisposed P2 and writes its dropboxId back', () => {
-  const box = emptyDropbox()
-  const review = { unit: '12', findings: [
-    { id: 'R1', severity: 'P1', summary: 'blocker', file: 'a.ts', line: 1 },
-    { id: 'R2', severity: 'P2', pass: 'tests', summary: 'weak test', file: 'a.ts', line: 3 },
-    { id: 'R3', severity: 'P2', summary: 'filed already', file: 'a.ts', followUpUrl: 'https://github.com/o/r/issues/1' },
-  ] }
-  const added = fromReview(box, review, { pr: 'https://github.com/o/r/pull/5', inDiffOf: (file, line) => line === 3 })
-  assert.deepEqual(added, ['D1'])
-  assert.equal(review.findings[1].dropboxId, 'D1')
-  assert.equal(review.findings[0].dropboxId, undefined)
-  assert.deepEqual([box.entries[0].kind, box.entries[0].inDiff, box.entries[0].finding], ['test', true, 'R2'])
-  assert.deepEqual(fromReview(box, review), [], 'a second run adds nothing')
-})
-
-test('pending lists runs with unposted entries and exits 0 either way', () => {
-  const runs = tmp()
-  mkdirSync(join(runs, 'r1'))
-  mkdirSync(join(runs, 'r2'))
-  const box = emptyDropbox()
-  addEntry(box, entry())
-  writeFileSync(join(runs, 'r1', 'dropbox.json'), JSON.stringify(box))
-  writeFileSync(join(runs, 'r2', 'dropbox.json'), JSON.stringify(emptyDropbox()))
-  assert.deepEqual(pendingRuns(runs).map((r) => [r.run, r.pending]), [['r1', 1]])
-  const cli = spawnSync('node', [script, 'pending', '--runs', runs], { encoding: 'utf8' })
-  assert.equal(cli.status, 0, cli.stderr)
-  assert.equal(JSON.parse(cli.stdout).runs.length, 1)
-  const none = spawnSync('node', [script, 'pending', '--runs', join(runs, 'none')], { encoding: 'utf8' })
-  assert.equal(none.status, 0, none.stderr)
-  assert.deepEqual(JSON.parse(none.stdout).runs, [])
-})
-
-test('a problem found again at a shifted line is the same problem', () => {
-  assert.equal(fingerprint(entry({ line: 4 })), fingerprint(entry({ line: 40 })))
-})
-
-test('the diff can be taken at a given head, whatever the checkout', () => {
-  const dir = unitRepo()
-  const head = execFileSync('git', ['-C', dir, 'rev-parse', 'unit'], { encoding: 'utf8' }).trim()
-  execFileSync('git', ['-C', dir, 'checkout', '-q', 'main'])
-  assert.equal(inUnitDiff({ dir, base: 'main', file: 'a.ts', line: 3 }), false, 'the checkout is main')
-  assert.equal(inUnitDiff({ dir, base: 'main', head, file: 'a.ts', line: 3 }), true)
-})
-
-test('from-review takes the unit diff at the review head', () => {
-  const box = emptyDropbox()
-  const seen = []
-  fromReview(box, { unit: '1', head: 'abc', findings: [{ id: 'R2', severity: 'P2', summary: 's', file: 'a.ts', line: 3 }] }, { inDiffOf: (...args) => { seen.push(args); return false } })
-  assert.deepEqual(seen, [['a.ts', 3, 'abc']])
-})
-
-test('an urgent entry is filed alone with --ids, and is not filed again at the end', () => {
-  const box = emptyDropbox()
-  addEntry(box, entry({ file: 'a.ts', summary: 'nit', pr: 'https://github.com/o/r/pull/5' }))
-  addEntry(box, entry({ file: 'b.ts', kind: 'bug', summary: 'cross-org role change', pr: 'https://github.com/o/r/pull/5' }))
-  const first = fakeGh()
-  post(box, { repo: 'o/r', ids: ['D2'] }, { gh: first.gh })
-  const created = first.calls.filter((c) => c.args[1] === 'create')
-  assert.equal(created.length, 1)
-  assert.match(created[0].input, /cross-org role change/)
-  assert.doesNotMatch(created[0].input, /nit/, 'its PR group-mate stays for the end')
-  const end = fakeGh()
-  post(box, { repo: 'o/r' }, { gh: end.gh })
-  const bodies = end.calls.filter((c) => c.args[1] === 'create').map((c) => c.input)
-  assert.equal(bodies.length, 1)
-  assert.doesNotMatch(bodies[0], /cross-org/)
-  assert.throws(() => post(box, { repo: 'o/r', ids: ['D9'] }, { gh: end.gh }), /no entry D9/)
-})
-
-test('post finds already-filed entries among open issues carrying its label', () => {
-  const { gh, calls } = fakeGh()
-  post(emptyDropbox(), { repo: 'o/r', label: 'agent-ready' }, { gh })
-  const list = calls.find((c) => c.args[1] === 'list').args
-  assert.deepEqual(list.slice(list.indexOf('--label'), list.indexOf('--label') + 2), ['--label', 'agent-ready'])
-})
-
-test('mark drops an entry or turns it into a decision; a posted entry cannot change', () => {
-  const box = emptyDropbox()
-  addEntry(box, entry({ file: 'a.ts', summary: '1' }))
-  addEntry(box, entry({ file: 'b.ts', summary: '2' }))
-  markEntry(box, { id: 'D1', drop: 'file removed by epic #40' })
-  markEntry(box, { id: 'D2', decision: true })
-  assert.deepEqual(box.entries.map((e) => [e.status, e.route]), [['dropped', 'dropbox'], ['pending', 'decision']])
-  assert.deepEqual(planPost(box).groups, [])
-  assert.throws(() => markEntry(box, { id: 'D1' }), /--drop <reason> or --decision/)
-  box.entries[1].status = 'posted'
-  assert.throws(() => markEntry(box, { id: 'D2', drop: 'x' }), /already posted/)
-})
-
-test('pending ignores decisions, which their own run reports', () => {
-  const runs = tmp()
-  mkdirSync(join(runs, 'r1'))
-  const box = emptyDropbox()
-  addEntry(box, { unit: '1', source: 'implementer', decision: true, summary: 'which period?' })
-  writeFileSync(join(runs, 'r1', 'dropbox.json'), JSON.stringify(box))
-  assert.deepEqual(pendingRuns(runs), [])
-})
-
-test('a file the unit deleted is inside its diff; a path that never existed is an error', () => {
-  const dir = unitRepo()
-  execFileSync('git', ['-C', dir, 'rm', '-q', 'a.ts'])
-  execFileSync('git', ['-C', dir, 'commit', '-qm', 'drop a'])
-  assert.equal(inUnitDiff({ dir, base: 'main', file: 'a.ts', line: 7 }), true)
-  assert.throws(() => inUnitDiff({ dir, base: 'main', file: 'nope.ts', line: 1 }), /exists neither/)
-  assert.throws(() => inUnitDiff({ dir, base: 'main', file: 'b.ts', line: Number('abc') }), /positive integer/)
-})
-
-test('check and add refuse bad input instead of calling it outside the diff', () => {
-  const dir = unitRepo()
-  const run = (...args) => spawnSync('node', [script, ...args], { encoding: 'utf8' })
-  assert.equal(run('check', '--git', dir, '--base', 'main', '--file', 'a.ts', '--line', 'abc').status, 2)
-  assert.equal(run('check', '--git', dir, '--base', 'main', '--file', 'a.ts:5').status, 2)
-  assert.equal(run('check', '--git', dir, '--base', 'main', '--file', 'a.tss', '--line', '1').status, 2)
-  const path = join(tmp(), 'dropbox.json')
-  const noDiff = run('add', '--dropbox', path, '--unit', '7', '--source', 'implementer', '--kind', 'bug', '--file', 'a.ts', '--line', '3', '--summary', 's')
-  assert.equal(noDiff.status, 2, 'an implementer entry needs the diff check')
-  assert.match(noDiff.stderr, /--git, --base/)
-  assert.throws(() => addEntry(emptyDropbox(), entry({ file: join(dir, 'a.ts') })), /repository-relative/)
-})
-
-test('a bare issue number in --blocks becomes a link', () => {
-  const box = emptyDropbox()
-  addEntry(box, entry({ blocks: ['55'] }))
-  assert.match(issueFor(groupEntries(box.entries)[0]).body, /Blocks #55/)
-})
-
-test('post drops entries whose file is gone at --ref and posts --only groups by plan id', () => {
-  const dir = unitRepo()
-  const path = join(tmp(), 'dropbox.json')
-  const box = emptyDropbox()
-  addEntry(box, entry({ file: 'gone.ts', summary: 'gone' }))
-  addEntry(box, entry({ file: 'a.ts', kind: 'test', summary: 'kept 1' }))
-  addEntry(box, entry({ file: 'b.ts', kind: 'ci', summary: 'kept 2' }))
-  writeFileSync(path, JSON.stringify(box))
-  const bin = tmp()
-  const log = join(bin, 'log')
-  writeFileSync(join(bin, 'gh'), `#!/bin/sh\necho "$@" >> ${log}\ncat >> ${log}\ncase "$2" in list) echo '[]';; create) echo https://github.com/o/r/issues/101;; esac\n`, { mode: 0o755 })
-  const env = { ...process.env, PATH: `${bin}:${process.env.PATH}` }
-  const planned = JSON.parse(spawnSync('node', [script, 'plan', '--dropbox', path, '--git', dir, '--ref', 'unit'], { encoding: 'utf8' }).stdout)
-  assert.deepEqual(planned.groups.map((g) => g.id), ['G2', 'G3'])
-  const result = spawnSync('node', [script, 'post', '--dropbox', path, '--repo', 'o/r', '--git', dir, '--ref', 'unit', '--only', 'G3'], { encoding: 'utf8', env })
-  assert.equal(result.status, 0, result.stderr)
-  const after = JSON.parse(readFileSync(path, 'utf8')).entries
-  assert.deepEqual(after.map((e) => e.status), ['dropped', 'pending', 'posted'])
-  assert.doesNotMatch(readFileSync(log, 'utf8'), /gone/)
-  assert.equal(spawnSync('node', [script, 'plan', '--dropbox', path, '--ref', 'unit'], { encoding: 'utf8' }).status, 2, '--ref needs --git')
-})
-
-test('post --ids names a decision as one', () => {
-  const box = emptyDropbox()
-  addEntry(box, { unit: '1', source: 'implementer', decision: true, summary: 'which period?' })
-  assert.throws(() => post(box, { repo: 'o/r', ids: ['D1'] }, { gh: fakeGh().gh }), /D1 is a decision/)
-})

package/skills/engineering/resolve-issues/scripts/findings-reuse.test.mjs

@@ -1,88 +0,0 @@
-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 { pathsIn, evidencePaths, decideReuse, parseCliArgs, FindingsReuseError } from './findings-reuse.mjs'
-
-const SCRIPT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'findings-reuse.mjs')
-
-// A repo at `base`; then `src/charge/layout.ts` changes on main.
-function fixture(t) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'findings-reuse-'))
-  t.after(() => fs.rmSync(dir, { recursive: true, force: true }))
-  const git = (...a) => execFileSync('git', a, { cwd: dir, encoding: 'utf8' }).trim()
-  const write = (f, text) => { fs.mkdirSync(path.dirname(path.join(dir, f)), { recursive: true }); fs.writeFileSync(path.join(dir, f), text) }
-  git('init', '-q', '-b', 'main'); git('config', 'user.email', 't@e.com'); git('config', 'user.name', 'T')
-  write('src/charge/layout.ts', 'a\n'); write('src/history/list.ts', 'b\n'); write('db/schema.sql', 'c\n')
-  git('add', '-A'); git('commit', '-qm', 'base')
-  const base = git('rev-parse', 'HEAD')
-  write('src/charge/layout.ts', 'a2\n'); git('commit', '-qam', 'earlier units merged')
-  const prior = {
-    version: 2, base,
-    units: {
-      charge: { slice: { prerequisites: [{ what: 'layout store', status: 'present', evidence: 'src/charge/layout.ts:3' }] }, readFirst: [] },
-      history: { slice: { prerequisites: [{ what: 'list view', status: 'present', evidence: 'src/history/list.ts:1' }] }, readFirst: ['src/history/'] },
-      migrate: { slice: { prerequisites: [{ what: 'cursor column', status: 'missing', separate: false, evidence: 'not in db/schema.sql' }] } },
-    },
-  }
-  const priorFile = path.join(dir, '..', `${path.basename(dir)}-prior.json`)
-  fs.writeFileSync(priorFile, JSON.stringify(prior))
-  t.after(() => fs.rmSync(priorFile, { force: true }))
-  const run = (...args) => spawnSync('node', [SCRIPT, '--prior', priorFile, ...args], { cwd: dir, encoding: 'utf8' })
-  return { dir, git, write, base, prior, run }
-}
-
-test('pathsIn finds repository paths in evidence prose, without line numbers', () => {
-  assert.deepEqual(pathsIn('packages/core/page.ts:12'), ['packages/core/page.ts'])
-  assert.deepEqual(pathsIn('not in db/schema.sql'), ['db/schema.sql'])
-  assert.deepEqual(pathsIn('no authority in backend/services'), ['backend/services'])
-  assert.deepEqual(pathsIn('e2e job green'), [])
-})
-
-test('evidencePaths reads prerequisites, readFirst (or legacy start), and the suite', () => {
-  const entry = {
-    slice: { prerequisites: [{ evidence: 'a/b.ts:1' }] },
-    start: ['c/d.ts'],
-    proof: { suite: { evidence: 'scripts/journey.py; green in CI', check: 'gh workflow run android.yml', local: 'bash scripts/charge-journey.sh' } },
-  }
-  // A renamed local journey script invalidates the reuse, like any other evidence path.
-  assert.deepEqual(evidencePaths(entry), ['a/b.ts', 'android.yml', 'c/d.ts', 'scripts/charge-journey.sh', 'scripts/journey.py'])
-})
-
-test('a unit is reused unless a file its evidence names changed; directories match files under them', () => {
-  const prior = { units: { a: { slice: { prerequisites: [{ evidence: 'src/x.ts:1' }] } }, b: { readFirst: ['src/y/'] } } }
-  assert.deepEqual(decideReuse(prior, ['a', 'b', 'c'], ['src/y/z.ts'], true), { reuse: ['a'], recheck: [{ id: 'b', changed: ['src/y/z.ts'] }], new: ['c'] })
-  assert.deepEqual(decideReuse(prior, ['a'], [], false).recheck.map((r) => r.id), ['a'], 'unknown base rechecks everything')
-})
-
-test('CLI: after an earlier unit changed the charge layout, only the charge unit is rechecked', (t) => {
-  const f = fixture(t)
-  const out = JSON.parse(f.run().stdout)
-  assert.deepEqual(out.reuse, ['history', 'migrate'])
-  assert.deepEqual(out.recheck, [{ id: 'charge', changed: ['src/charge/layout.ts'] }])
-  assert.deepEqual(out.new, [])
-  const only = JSON.parse(f.run('--units', 'history,newunit').stdout)
-  assert.deepEqual(only.reuse, ['history'])
-  assert.deepEqual(only.new, ['newunit'])
-})
-
-test('CLI: a missing prerequisite whose evidence file changed is rechecked (it may now exist)', (t) => {
-  const f = fixture(t)
-  f.write('db/schema.sql', 'c\ncursor\n'); f.git('commit', '-qam', 'add cursor')
-  assert.deepEqual(JSON.parse(f.run().stdout).recheck.map((r) => r.id), ['charge', 'migrate'])
-})
-
-test('CLI: a prior base not in this repository rechecks every unit; bad input exits 2', (t) => {
-  const f = fixture(t)
-  const priorFile = path.join(f.dir, 'gone.json')
-  fs.writeFileSync(priorFile, JSON.stringify({ ...f.prior, base: '0'.repeat(40) }))
-  const out = JSON.parse(spawnSync('node', [SCRIPT, '--prior', priorFile], { cwd: f.dir, encoding: 'utf8' }).stdout)
-  assert.deepEqual(out.reuse, [])
-  assert.equal(out.recheck.length, 3)
-  assert.equal(spawnSync('node', [SCRIPT, '--prior', path.join(f.dir, 'missing.json')], { cwd: f.dir }).status, 2)
-  assert.throws(() => parseCliArgs([]), FindingsReuseError)
-})