@iceinvein/agent-skills 0.1.28 → 0.1.30

package/skills/magpie/scripts/__tests__/post-cmd.test.ts

@@ -3,6 +3,7 @@ import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import {
+  computeEffortScore,
   formatConversationBody,
   formatInlineBody,
   formatPostBody,
@@ -158,8 +159,8 @@ test('runPost skips ids already marked as posted', async () => {
   await seedRunDir()
   await writeFile(join(runDir, 'post-status.json'), JSON.stringify({ 'sec-1': 'posted' }))
   const outcome = await runPost({ runDir, findingIds: ['sec-1', 'bug-1'], dryRun: true })
-  expect(outcome.results[0]?.status).toBe('already-posted')
-  expect(outcome.results[1]?.status).toBe('posted')
+  expect(outcome.results.find((r) => r.id === 'sec-1')?.status).toBe('already-posted')
+  expect(outcome.results.find((r) => r.id === 'bug-1')?.status).toBe('posted')
 })
 
 test('runPost surfaces gh failure per finding (here: gh binary missing)', async () => {
@@ -169,6 +170,7 @@ test('runPost surfaces gh failure per finding (here: gh binary missing)', async
     runDir,
     findingIds: ['sec-1'],
     ghBin: '/does/not/exist/gh-binary',
+    includeSummary: 'never',
   })
   expect(outcome.ok).toBe(true) // overall request succeeds; per-id reflects gh's failure
   expect(outcome.results[0]?.status).toBe('failed')
@@ -204,8 +206,9 @@ test('runPost falls back to a top-level PR comment when GitHub rejects the inlin
 
   const outcome = await runPost({ runDir, findingIds: ['sec-1'], ghBin: fakeGh })
   expect(outcome.ok).toBe(true)
-  expect(outcome.results[0]?.status).toBe('posted')
-  expect(outcome.results[0]?.message).toMatch(/posted as PR comment/i)
+  const sec1 = outcome.results.find((r) => r.id === 'sec-1')
+  expect(sec1?.status).toBe('posted')
+  expect(sec1?.message).toMatch(/posted as PR comment/i)
   const status = JSON.parse(await readFile(join(runDir, 'post-status.json'), 'utf8'))
   expect(status['sec-1']).toBe('posted')
   const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
@@ -226,8 +229,9 @@ test('runPost reports a combined failure when both inline and fallback gh calls
   )
   await Bun.spawn(['chmod', '+x', fakeGh]).exited
   const outcome = await runPost({ runDir, findingIds: ['sec-1'], ghBin: fakeGh })
-  expect(outcome.results[0]?.status).toBe('failed')
-  expect(outcome.results[0]?.message).toMatch(/inline.*fallback also failed/i)
+  const sec1 = outcome.results.find((r) => r.id === 'sec-1')
+  expect(sec1?.status).toBe('failed')
+  expect(sec1?.message).toMatch(/inline.*fallback also failed/i)
 })
 
 test('formatReviewSummaryBody renders verdict, Needs Attention and Risk breakdown', () => {
@@ -265,7 +269,82 @@ test('formatReviewSummaryBody handles the empty case', () => {
   expect(body).not.toContain('Risk breakdown')
 })
 
-test('runPost auto-posts the review summary when batch has 2+ pending findings', async () => {
+test('formatReviewSummaryBody includes effort score when files are provided', () => {
+  const body = formatReviewSummaryBody([], {
+    files: [{ path: 'src/a.ts', additions: 5, deletions: 0 }],
+  })
+  expect(body).toContain('Review effort')
+  expect(body).toMatch(/\d\/5/)
+})
+
+test('formatReviewSummaryBody renders walkthrough table sorted by churn', () => {
+  const body = formatReviewSummaryBody([], {
+    files: [
+      { path: 'small.ts', additions: 1, deletions: 0 },
+      { path: 'big.ts', additions: 200, deletions: 100 },
+    ],
+  })
+  expect(body).toContain('Files changed')
+  expect(body).toContain('big.ts')
+  const bigIdx = body.indexOf('big.ts')
+  const smallIdx = body.indexOf('small.ts')
+  expect(bigIdx).toBeLessThan(smallIdx)
+})
+
+test('formatReviewSummaryBody surfaces risk hotspots when 2+ findings per file', () => {
+  const findings = [
+    {
+      ...findingA,
+      id: 'h1',
+      file: 'src/hot.ts',
+      line: 5,
+    },
+    {
+      ...findingA,
+      id: 'h2',
+      file: 'src/hot.ts',
+      line: 10,
+    },
+    {
+      ...findingA,
+      id: 'h3',
+      file: 'src/cool.ts',
+      line: 1,
+    },
+  ] as Parameters<typeof formatReviewSummaryBody>[0]
+  const body = formatReviewSummaryBody(findings)
+  expect(body).toContain('Risk hotspots')
+  expect(body).toContain('src/hot.ts')
+  expect(body).not.toContain('- `src/cool.ts`')
+})
+
+test('formatReviewSummaryBody renders incremental trailer with new commits', () => {
+  const body = formatReviewSummaryBody([], {
+    incremental: { previousSha: 'abcdef0123456', sameSha: false },
+  })
+  expect(body).toContain('Incremental review since')
+  expect(body).toContain('abcdef0')
+})
+
+test('formatReviewSummaryBody renders re-review trailer when sameSha', () => {
+  const body = formatReviewSummaryBody([], {
+    incremental: { previousSha: 'abcdef0123456', sameSha: true },
+  })
+  expect(body).toContain('Re-review')
+})
+
+test('computeEffortScore: small PR = 1, huge PR = 5', () => {
+  expect(computeEffortScore([])).toBe(1)
+  expect(computeEffortScore([{ path: 'a', additions: 5, deletions: 5 }])).toBe(1)
+  const huge = Array.from({ length: 25 }, (_, i) => ({
+    path: `f${i}.ts`,
+    additions: 100,
+    deletions: 0,
+  }))
+  expect(computeEffortScore(huge)).toBe(5)
+})
+
+test('runPost auto-posts the review summary on any non-empty batch', async () => {
   await seedRunDir()
   const outcome = await runPost({
     runDir,
@@ -280,16 +359,37 @@ test('runPost auto-posts the review summary when batch has 2+ pending findings',
   expect(status.__summary__).toBe('posted')
 })
 
-test('runPost skips the summary on single-finding batches in auto mode', async () => {
+test('runPost auto-posts the summary even on single-finding batches', async () => {
   await seedRunDir()
   const outcome = await runPost({
     runDir,
     findingIds: ['sec-1'],
     dryRun: true,
   })
+  expect(outcome.results.find((r) => r.id === '__summary__')?.status).toBe('posted')
+})
+
+test('runPost auto-skips the summary when the batch has zero findings', async () => {
+  await seedRunDir()
+  const outcome = await runPost({
+    runDir,
+    findingIds: ['nope-id'],
+    dryRun: true,
+  })
   expect(outcome.results.find((r) => r.id === '__summary__')).toBeUndefined()
 })
 
+test('runPost with includeSummary: always posts the summary even on empty batches', async () => {
+  await seedRunDir()
+  const outcome = await runPost({
+    runDir,
+    findingIds: [],
+    dryRun: true,
+    includeSummary: 'always',
+  })
+  expect(outcome.results.find((r) => r.id === '__summary__')?.status).toBe('posted')
+})
+
 test('runPost forces the summary when includeSummary: always', async () => {
   await seedRunDir()
   const outcome = await runPost({

package/skills/magpie/scripts/__tests__/score.test.ts

@@ -0,0 +1,51 @@
+import { expect, test } from 'bun:test'
+import { DEFAULT_THRESHOLD, scoreRisk } from '../score.ts'
+import type { Risk } from '../types.ts'
+
+const risk = (over: Partial<Risk> = {}): Risk => ({
+  impact: 'medium',
+  likelihood: 'possible',
+  confidence: 'medium',
+  action: 'should-fix',
+  ...over,
+})
+
+test('scoreRisk: maxed-out risk hits ~10', () => {
+  const s = scoreRisk({
+    impact: 'critical',
+    likelihood: 'likely',
+    confidence: 'high',
+    action: 'must-fix',
+  })
+  expect(s).toBeCloseTo(10, 1)
+})
+
+test('scoreRisk: floor risk is near 1', () => {
+  const s = scoreRisk({
+    impact: 'low',
+    likelihood: 'edge-case',
+    confidence: 'low',
+    action: 'optional',
+  })
+  expect(s).toBeGreaterThanOrEqual(1)
+  expect(s).toBeLessThan(2.5)
+})
+
+test('scoreRisk: impact dominates over action', () => {
+  const highImpact = scoreRisk(risk({ impact: 'critical', action: 'optional' }))
+  const lowImpact = scoreRisk(risk({ impact: 'low', action: 'must-fix' }))
+  expect(highImpact).toBeGreaterThan(lowImpact)
+})
+
+test('scoreRisk: confidence pulls weight', () => {
+  const highConf = scoreRisk(risk({ confidence: 'high' }))
+  const lowConf = scoreRisk(risk({ confidence: 'low' }))
+  expect(highConf - lowConf).toBeGreaterThan(0.5)
+})
+
+test('DEFAULT_THRESHOLD is sensible (drops floor, keeps medium)', () => {
+  expect(DEFAULT_THRESHOLD).toBeGreaterThan(0)
+  expect(DEFAULT_THRESHOLD).toBeLessThan(5)
+  const medium = scoreRisk(risk())
+  expect(medium).toBeGreaterThanOrEqual(DEFAULT_THRESHOLD)
+})

package/skills/magpie/scripts/__tests__/server.test.ts

@@ -126,7 +126,10 @@ test('POST /post wires through to runPost (dry-run) and returns results', async
   }
   expect(body.ok).toBe(true)
   expect(body.target).toEqual({ repo: 'o/r', number: 7 })
-  expect(body.results[0]).toMatchObject({ id: 'sec-1', status: 'posted' })
+  expect(body.results.find((r) => r.id === 'sec-1')).toMatchObject({
+    id: 'sec-1',
+    status: 'posted',
+  })
 })
 
 test('writes server-info on start with url and port', async () => {

package/skills/magpie/scripts/__tests__/setup-cmd.test.ts

@@ -1,10 +1,12 @@
 import { afterEach, beforeEach, expect, test } from 'bun:test'
-import { mkdtemp, readdir, rm, writeFile } from 'node:fs/promises'
+import { mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { runSetup } from '../setup-cmd.ts'
 
 const FAKE_GH = new URL('../../fixtures/fake-gh.sh', import.meta.url).pathname
+const FAKE_GH_WITH_LOCKFILE = new URL('../../fixtures/fake-gh-with-lockfile.sh', import.meta.url)
+  .pathname
 const FALSE_BIN = '/usr/bin/false'
 
 let repo: string
@@ -64,6 +66,107 @@ test('runSetup with missing dep returns non-zero and cleans up', async () => {
   expect(contents.filter((c) => c !== 'log.jsonl')).toHaveLength(0)
 })
 
+test('runSetup filters excluded files by default and preserves raw diff', async () => {
+  const exit = await runSetup({
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH_WITH_LOCKFILE, codex: 'echo', git: 'git' },
+  })
+  expect(exit).toBe(0)
+  const contents = await readdir(runDir)
+  expect(contents).toContain('diff.patch')
+  expect(contents).toContain('diff.full.patch')
+  expect(contents).toContain('excluded-files.json')
+  const filtered = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(filtered).toContain('src/a.ts')
+  expect(filtered).not.toContain('bun.lock')
+  expect(filtered).not.toContain('dist/x.js')
+  const excluded = JSON.parse(
+    await readFile(join(runDir, 'excluded-files.json'), 'utf8'),
+  ) as Array<{
+    path: string
+    pattern: string
+  }>
+  expect(excluded.map((e) => e.path).sort()).toEqual(['bun.lock', 'dist/x.js'])
+})
+
+test('runSetup with no excludable files does not write filter sidecars', async () => {
+  const exit = await runSetup({
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+  expect(exit).toBe(0)
+  const contents = await readdir(runDir)
+  expect(contents).not.toContain('diff.full.patch')
+  expect(contents).not.toContain('excluded-files.json')
+})
+
+test('runSetup honors .magpie.json useDefaults=false', async () => {
+  await writeFile(join(repo, '.magpie.json'), JSON.stringify({ useDefaults: false, exclude: [] }))
+  const exit = await runSetup({
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH_WITH_LOCKFILE, codex: 'echo', git: 'git' },
+  })
+  expect(exit).toBe(0)
+  const filtered = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(filtered).toContain('bun.lock')
+  expect(filtered).toContain('dist/x.js')
+})
+
+test('runSetup writes incremental.json when a prior run for the same PR exists', async () => {
+  const magpieHome = await mkdtemp(join(tmpdir(), 'magpie-home-incr-'))
+  await sh(magpieHome, 'mkdir', '-p', 'pr-1234-100')
+  await writeFile(
+    join(magpieHome, 'pr-1234-100', 'pr.json'),
+    JSON.stringify({ headRefOid: 'oldsha', number: 1234 }),
+  )
+  const originalHome = process.env.MAGPIE_HOME
+  process.env.MAGPIE_HOME = magpieHome
+  try {
+    const exit = await runSetup({
+      runDir,
+      prNumber: 1234,
+      repoPath: repo,
+      deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+    })
+    expect(exit).toBe(0)
+    const incremental = JSON.parse(await readFile(join(runDir, 'incremental.json'), 'utf8'))
+    expect(incremental.previousRunId).toBe('pr-1234-100')
+    expect(incremental.previousSha).toBe('oldsha')
+    expect(incremental.sameSha).toBe(false)
+  } finally {
+    if (originalHome === undefined) delete process.env.MAGPIE_HOME
+    else process.env.MAGPIE_HOME = originalHome
+    await rm(magpieHome, { recursive: true, force: true })
+  }
+})
+
+test('runSetup omits incremental.json when no prior run exists', async () => {
+  const magpieHome = await mkdtemp(join(tmpdir(), 'magpie-home-incr-empty-'))
+  const originalHome = process.env.MAGPIE_HOME
+  process.env.MAGPIE_HOME = magpieHome
+  try {
+    const exit = await runSetup({
+      runDir,
+      prNumber: 1234,
+      repoPath: repo,
+      deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+    })
+    expect(exit).toBe(0)
+    const contents = await readdir(runDir)
+    expect(contents).not.toContain('incremental.json')
+  } finally {
+    if (originalHome === undefined) delete process.env.MAGPIE_HOME
+    else process.env.MAGPIE_HOME = originalHome
+    await rm(magpieHome, { recursive: true, force: true })
+  }
+})
+
 test('runSetup with failing gh removes any partial state', async () => {
   const exit = await runSetup({
     runDir,

package/skills/magpie/scripts/__tests__/tests-check.test.ts

@@ -0,0 +1,94 @@
+import { expect, test } from 'bun:test'
+import { detectMissingTests, isTestFile } from '../tests-check.ts'
+
+const sourceDiff = (path: string, added: number): string => {
+  const lines = [
+    `diff --git a/${path} b/${path}`,
+    'index 1..2 100644',
+    `--- a/${path}`,
+    `+++ b/${path}`,
+    `@@ -1,1 +1,${added + 1} @@`,
+    ' const existing = 1',
+  ]
+  for (let i = 0; i < added; i++) {
+    lines.push(`+export function newFn${i}() { return ${i} }`)
+  }
+  return `${lines.join('\n')}\n`
+}
+
+const testDiff = (path: string): string =>
+  [
+    `diff --git a/${path} b/${path}`,
+    'index 1..2 100644',
+    `--- a/${path}`,
+    `+++ b/${path}`,
+    '@@ -1,1 +1,2 @@',
+    ' import { x } from "./x"',
+    '+test("x", () => expect(x()).toBe(1))',
+    '',
+  ].join('\n')
+
+test('isTestFile: common patterns', () => {
+  expect(isTestFile('src/a.test.ts')).toBe(true)
+  expect(isTestFile('src/a.spec.ts')).toBe(true)
+  expect(isTestFile('src/__tests__/a.ts')).toBe(true)
+  expect(isTestFile('tests/foo.ts')).toBe(true)
+  expect(isTestFile('app/test_foo.py')).toBe(true)
+  expect(isTestFile('cmd/foo_test.go')).toBe(true)
+  expect(isTestFile('UserTest.java')).toBe(true)
+  expect(isTestFile('src/a.ts')).toBe(false)
+  expect(isTestFile('docs/a.md')).toBe(false)
+})
+
+test('detectMissingTests: flags source files when no test file in diff', () => {
+  const findings = detectMissingTests(sourceDiff('src/a.ts', 12))
+  expect(findings).toHaveLength(1)
+  expect(findings[0]?.file).toBe('src/a.ts')
+  expect(findings[0]?.domain).toBe('tests')
+  expect(findings[0]?.severity).toBe('medium')
+  expect(findings[0]?.line).toBeNull()
+})
+
+test('detectMissingTests: empty when a test file is present anywhere', () => {
+  const diff = sourceDiff('src/a.ts', 20) + testDiff('src/a.test.ts')
+  const findings = detectMissingTests(diff)
+  expect(findings).toHaveLength(0)
+})
+
+test('detectMissingTests: respects minAddedLines threshold', () => {
+  const findings = detectMissingTests(sourceDiff('src/a.ts', 5))
+  expect(findings).toHaveLength(0)
+})
+
+test('detectMissingTests: skips non-source files', () => {
+  const diff = sourceDiff('README.md', 30)
+  expect(detectMissingTests(diff)).toHaveLength(0)
+})
+
+test('detectMissingTests: emits one finding per source file', () => {
+  const diff = sourceDiff('src/a.ts', 12) + sourceDiff('src/b.ts', 15)
+  const findings = detectMissingTests(diff)
+  expect(findings.map((f) => f.file).sort()).toEqual(['src/a.ts', 'src/b.ts'])
+})
+
+test('detectMissingTests: empty diff yields nothing', () => {
+  expect(detectMissingTests('')).toEqual([])
+})
+
+test('detectMissingTests: ignores comment-only and import-only additions', () => {
+  const diff = [
+    'diff --git a/src/a.ts b/src/a.ts',
+    'index 1..2 100644',
+    '--- a/src/a.ts',
+    '+++ b/src/a.ts',
+    '@@ -1,1 +1,15 @@',
+    ' const x = 1',
+    '+// just a comment',
+    '+import { foo } from "./foo"',
+    '+import { bar } from "./bar"',
+    '+// another comment',
+    '+# python-style comment',
+    '',
+  ].join('\n')
+  expect(detectMissingTests(diff)).toHaveLength(0)
+})

package/skills/magpie/scripts/__tests__/types.test.ts

@@ -2,8 +2,15 @@ import { describe, expect, test } from 'bun:test'
 import type { FocusId, PrFileEntry, ReviewFinding } from '../types.ts'
 import { FOCUS_IDS, isSuggestion, parseFinding } from '../types.ts'
 
-test('FOCUS_IDS contains the five default focuses', () => {
-  expect(FOCUS_IDS).toEqual(['security', 'bugs', 'performance', 'code-smells', 'architecture'])
+test('FOCUS_IDS contains the LLM focuses plus the deterministic tests domain', () => {
+  expect(FOCUS_IDS).toEqual([
+    'security',
+    'bugs',
+    'performance',
+    'code-smells',
+    'architecture',
+    'tests',
+  ])
 })
 
 test('parseFinding accepts a minimal finding', () => {

package/skills/magpie/scripts/dedupe-cmd.ts

@@ -1,6 +1,8 @@
 import { appendFile, readdir, readFile, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { deduplicateFindings } from './dedupe.ts'
+import { verifyEvidence } from './evidence-filter.ts'
+import { DEFAULT_THRESHOLD, scoreRisk } from './score.ts'
 import { FOCUS_IDS, parseFinding, type ReviewFinding } from './types.ts'
 
 async function logLine(runDir: string, entry: Record<string, unknown>): Promise<void> {
@@ -8,7 +10,13 @@ async function logLine(runDir: string, entry: Record<string, unknown>): Promise<
   await appendFile(join(runDir, 'log.jsonl'), line)
 }
 
-export async function runDedupe(runDir: string): Promise<number> {
+export type RunDedupeOptions = {
+  /** 0-10 importance score below which findings are dropped pre-critic. */
+  threshold?: number
+}
+
+export async function runDedupe(runDir: string, options: RunDedupeOptions = {}): Promise<number> {
+  const threshold = options.threshold ?? DEFAULT_THRESHOLD
   const findingsDir = join(runDir, 'findings')
   const collected: ReviewFinding[] = []
   let files: string[]
@@ -67,12 +75,41 @@ export async function runDedupe(runDir: string): Promise<number> {
   }
 
   const deduped = deduplicateFindings(collected)
-  await writeFile(join(runDir, 'findings.deduped.json'), `${JSON.stringify(deduped, null, 2)}\n`)
+  const scored = deduped.map((f) => ({ ...f, score: scoreRisk(f.risk) }))
+  const evidence = await verifyEvidence(scored, join(runDir, 'worktree'))
+  const aboveThreshold = evidence.kept.filter((f) => (f.score ?? 0) >= threshold)
+  const belowThreshold = evidence.kept.filter((f) => (f.score ?? 0) < threshold)
+  await writeFile(
+    join(runDir, 'findings.deduped.json'),
+    `${JSON.stringify(aboveThreshold, null, 2)}\n`,
+  )
+  if (evidence.dropped.length > 0) {
+    await writeFile(
+      join(runDir, 'evidence-dropped.json'),
+      `${JSON.stringify(evidence.dropped, null, 2)}\n`,
+    )
+  }
+  if (belowThreshold.length > 0) {
+    await writeFile(
+      join(runDir, 'threshold-dropped.json'),
+      `${JSON.stringify(
+        belowThreshold.map((f) => ({ id: f.id, score: f.score, title: f.title })),
+        null,
+        2,
+      )}\n`,
+    )
+  }
   await logLine(runDir, {
     stage: 'dedupe',
     status: 'done',
     input: collected.length,
-    output: deduped.length,
+    output: aboveThreshold.length,
+    threshold,
+    threshold_dropped: belowThreshold.length,
+    evidence: {
+      skipped: evidence.skipped,
+      dropped: evidence.dropped.length,
+    },
   })
   return 0
 }

package/skills/magpie/scripts/evidence-filter.ts

@@ -0,0 +1,73 @@
+import { existsSync, statSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { ReviewFinding } from './types.ts'
+
+export type EvidenceDrop = {
+  id: string
+  reason: 'hallucinated-file' | 'invented-line'
+  file: string
+  line: number | null
+}
+
+export type VerifyEvidenceResult = {
+  kept: ReviewFinding[]
+  dropped: EvidenceDrop[]
+  /** Set when the worktree itself was not available; verification was skipped. */
+  skipped: boolean
+}
+
+function isReadableFile(path: string): boolean {
+  if (!existsSync(path)) return false
+  try {
+    return statSync(path).isFile()
+  } catch {
+    return false
+  }
+}
+
+async function lineCount(path: string): Promise<number> {
+  const text = await readFile(path, 'utf8')
+  if (text.length === 0) return 0
+  let count = 1
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) count += 1
+  }
+  if (text.charCodeAt(text.length - 1) === 10) count -= 1
+  return count
+}
+
+export async function verifyEvidence(
+  findings: ReviewFinding[],
+  worktreePath: string,
+): Promise<VerifyEvidenceResult> {
+  if (!existsSync(worktreePath)) {
+    return { kept: findings, dropped: [], skipped: true }
+  }
+  const kept: ReviewFinding[] = []
+  const dropped: EvidenceDrop[] = []
+  const lineCounts = new Map<string, number>()
+
+  for (const f of findings) {
+    if (f.line === null || !f.file) {
+      kept.push(f)
+      continue
+    }
+    const abs = join(worktreePath, f.file)
+    if (!isReadableFile(abs)) {
+      dropped.push({ id: f.id, reason: 'hallucinated-file', file: f.file, line: f.line })
+      continue
+    }
+    let count = lineCounts.get(abs)
+    if (count === undefined) {
+      count = await lineCount(abs)
+      lineCounts.set(abs, count)
+    }
+    if (f.line < 1 || f.line > count) {
+      dropped.push({ id: f.id, reason: 'invented-line', file: f.file, line: f.line })
+      continue
+    }
+    kept.push(f)
+  }
+  return { kept, dropped, skipped: false }
+}

package/skills/magpie/scripts/incremental.ts

@@ -0,0 +1,75 @@
+import { readdir, readFile, stat } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, join } from 'node:path'
+
+export type IncrementalContext = {
+  previousRunId: string
+  previousSha: string
+  currentSha: string
+  /** True when the head SHA is unchanged from the previous run (no new commits). */
+  sameSha: boolean
+}
+
+const RUN_PATTERN = /^pr-(\d+)-(\d+)(?:\.archived-\d+)?$/
+
+function reviewHome(): string {
+  return process.env.MAGPIE_HOME ?? join(homedir(), '.magpie')
+}
+
+/**
+ * Find the most recent prior run (active or archived) for the same PR number,
+ * excluding the current run. Returns null when no prior run exists. The current
+ * run is identified by basename match so we don't accidentally pick it up.
+ */
+export async function findPreviousRun(
+  prNumber: number,
+  currentRunDir: string,
+  home?: string,
+): Promise<{ runId: string; runDir: string; prJson: Record<string, unknown> } | null> {
+  const root = home ?? reviewHome()
+  let entries: string[]
+  try {
+    entries = await readdir(root)
+  } catch {
+    return null
+  }
+  const currentId = basename(currentRunDir)
+  const candidates: Array<{ id: string; ts: number }> = []
+  for (const id of entries) {
+    if (id === currentId) continue
+    const m = id.match(RUN_PATTERN)
+    if (!m) continue
+    if (Number(m[1]) !== prNumber) continue
+    candidates.push({ id, ts: Number(m[2]) })
+  }
+  candidates.sort((a, b) => b.ts - a.ts)
+  for (const c of candidates) {
+    const runDir = join(root, c.id)
+    const s = await stat(runDir).catch(() => null)
+    if (!s?.isDirectory()) continue
+    const prJsonPath = join(runDir, 'pr.json')
+    try {
+      const text = await readFile(prJsonPath, 'utf8')
+      return { runId: c.id, runDir, prJson: JSON.parse(text) }
+    } catch {
+      // Missing or malformed pr.json; try the next candidate.
+    }
+  }
+  return null
+}
+
+export function buildIncrementalContext(
+  current: Record<string, unknown>,
+  previous: { runId: string; prJson: Record<string, unknown> },
+): IncrementalContext | null {
+  const currentSha = typeof current.headRefOid === 'string' ? current.headRefOid : ''
+  const previousSha =
+    typeof previous.prJson.headRefOid === 'string' ? previous.prJson.headRefOid : ''
+  if (!currentSha || !previousSha) return null
+  return {
+    previousRunId: previous.runId,
+    previousSha,
+    currentSha,
+    sameSha: previousSha === currentSha,
+  }
+}