@iceinvein/agent-skills 0.23.9 → 0.23.13

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

@@ -31,6 +31,12 @@ async function sh(cwd: string, ...cmd: string[]): Promise<void> {
   }
 }
 
+async function revParse(cwd: string, ref: string): Promise<string> {
+  const proc = Bun.spawn(['git', 'rev-parse', ref], { cwd, stdout: 'pipe', stderr: 'pipe' })
+  if ((await proc.exited) !== 0) throw new Error(await new Response(proc.stderr).text())
+  return (await new Response(proc.stdout).text()).trim()
+}
+
 beforeEach(async () => {
   repo = await mkdtemp(join(tmpdir(), 'magpie-setup-repo-'))
   runDir = await mkdtemp(join(tmpdir(), 'magpie-setup-run-'))
@@ -140,7 +146,11 @@ test('runSetup writes incremental.json when a prior run for the same PR exists',
   await sh(magpieHome, 'mkdir', '-p', 'pr-1234-100')
   await writeFile(
     join(magpieHome, 'pr-1234-100', 'pr.json'),
-    JSON.stringify({ headRefOid: 'oldsha', number: 1234 }),
+    JSON.stringify({
+      headRefOid: 'oldsha',
+      number: 1234,
+      url: 'https://github.com/octocat/Hello-World/pull/1234',
+    }),
   )
   const originalHome = process.env.MAGPIE_HOME
   process.env.MAGPIE_HOME = magpieHome
@@ -164,6 +174,166 @@ test('runSetup writes incremental.json when a prior run for the same PR exists',
   }
 })
 
+test('runSetup carries the previous run posted findings forward with their anchor status', async () => {
+  const magpieHome = await mkdtemp(join(tmpdir(), 'magpie-home-prev-'))
+  const prev = join(magpieHome, 'pr-1234-100')
+  await mkdir(prev, { recursive: true })
+  await writeFile(
+    join(prev, 'pr.json'),
+    JSON.stringify({
+      headRefOid: 'oldsha',
+      number: 1234,
+      url: 'https://github.com/octocat/Hello-World/pull/1234',
+    }),
+  )
+  await writeFile(
+    join(prev, 'findings.final.json'),
+    JSON.stringify([
+      {
+        id: 'bugs-1',
+        file: 'a.txt',
+        line: 1,
+        evidence: 'one',
+        severity: 'high',
+        risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'should-fix' },
+        title: 'a.txt says one',
+        description: 'Observation: x',
+        domain: 'bugs',
+      },
+    ]),
+  )
+  await writeFile(join(prev, 'post-status.json'), JSON.stringify({ 'bugs-1': 'posted' }))
+  const originalHome = process.env.MAGPIE_HOME
+  process.env.MAGPIE_HOME = magpieHome
+  try {
+    const exit = await runSetup({
+      mode: 'pr',
+      runDir,
+      prNumber: 1234,
+      repoPath: repo,
+      deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+    })
+    expect(exit).toBe(0)
+    const previous = JSON.parse(await readFile(join(runDir, 'previous-findings.json'), 'utf8'))
+    expect(previous).toEqual({
+      previousRunId: 'pr-1234-100',
+      findings: [
+        {
+          id: 'bugs-1',
+          fromRunId: 'pr-1234-100',
+          file: 'a.txt',
+          line: 1,
+          title: 'a.txt says one',
+          domain: 'bugs',
+          label: 'posted',
+          anchor: 'unchanged',
+        },
+      ],
+    })
+    const incremental = JSON.parse(await readFile(join(runDir, 'incremental.json'), 'utf8'))
+    // oldsha is not a commit in the clone, so there is nothing to diff from.
+    expect(incremental.changedSincePrevious).toBeNull()
+  } finally {
+    if (originalHome === undefined) delete process.env.MAGPIE_HOME
+    else process.env.MAGPIE_HOME = originalHome
+    await rm(magpieHome, { recursive: true, force: true })
+  }
+})
+
+test('runSetup writes the PR checks, comments and review threads to pr-activity.json', async () => {
+  const exit = await runSetup({
+    mode: 'pr',
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+  expect(exit).toBe(0)
+  const activity = JSON.parse(await readFile(join(runDir, 'pr-activity.json'), 'utf8'))
+  expect(activity.checks).toEqual([
+    { name: 'build', conclusion: 'FAILURE', url: 'https://ci.example/1' },
+  ])
+  expect(activity.comments).toEqual([
+    { author: 'alice', body: 'Does this retry past three attempts?', magpie: false },
+  ])
+  expect(activity.threads.map((t: { file: string }) => t.file)).toEqual(['src/a.ts'])
+})
+
+test('runSetup fails and cleans up when the PR activity cannot be fetched', async () => {
+  const gh = join(runDir, '..', `gh-noactivity-${Date.now()}.sh`)
+  await writeFile(
+    gh,
+    [
+      '#!/usr/bin/env bash',
+      'if [[ "$1 $2" == "api graphql" ]]; then echo "HTTP 502" >&2; exit 1; fi',
+      `exec "${FAKE_GH}" "$@"`,
+    ].join('\n'),
+  )
+  await sh(runDir, 'chmod', '+x', gh)
+  try {
+    const exit = await runSetup({
+      mode: 'pr',
+      runDir,
+      prNumber: 1234,
+      repoPath: repo,
+      deps: { bun: 'bun', gh, codex: 'echo', git: 'git' },
+    })
+    expect(exit).not.toBe(0)
+    const contents = await readdir(runDir)
+    expect(contents).not.toContain('pr.json')
+    expect(contents).not.toContain('pr-activity.json')
+    const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+    expect(log).toContain('HTTP 502')
+  } finally {
+    await rm(gh, { force: true })
+  }
+})
+
+test('runSetup fails and cleans up when diffing against the previous head fails', async () => {
+  const magpieHome = await mkdtemp(join(tmpdir(), 'magpie-home-gitfail-'))
+  const prev = join(magpieHome, 'pr-1234-100')
+  await mkdir(prev, { recursive: true })
+  await writeFile(
+    join(prev, 'pr.json'),
+    JSON.stringify({
+      headRefOid: 'oldsha',
+      url: 'https://github.com/octocat/Hello-World/pull/1234',
+    }),
+  )
+  // Both commits probe as present, then the diff itself fails, as a corrupt object would.
+  const git = join(magpieHome, 'git.sh')
+  await writeFile(
+    git,
+    [
+      '#!/usr/bin/env bash',
+      'if [[ "$1" == "cat-file" ]]; then exit 0; fi',
+      'if [[ "$1 $2" == "diff --name-only" ]]; then echo "fatal: bad object" >&2; exit 128; fi',
+      'exec git "$@"',
+    ].join('\n'),
+  )
+  await sh(magpieHome, 'chmod', '+x', git)
+  const originalHome = process.env.MAGPIE_HOME
+  process.env.MAGPIE_HOME = magpieHome
+  try {
+    const exit = await runSetup({
+      mode: 'pr',
+      runDir,
+      prNumber: 1234,
+      repoPath: repo,
+      deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git },
+    })
+    expect(exit).not.toBe(0)
+    const contents = await readdir(runDir)
+    expect(contents).not.toContain('pr.json')
+    const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+    expect(log).toContain('fatal: bad object')
+  } 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
@@ -584,3 +754,208 @@ test('local setup with --repo outside any git repository fails with exit 2 and c
     await rm(notRepo, { recursive: true, force: true })
   }
 })
+
+test('the worktree is the PR head commit even when the local branch has moved past it', async () => {
+  const prHead = await revParse(repo, 'feature-x')
+  await sh(repo, 'git', 'tag', 'fake-pr-head', prHead)
+  await sh(repo, 'git', 'checkout', '-q', 'feature-x')
+  await writeFile(join(repo, 'a.txt'), 'unpushed\n')
+  await sh(repo, 'git', 'commit', '-q', '-am', 'local only')
+  await sh(repo, 'git', 'checkout', '-q', 'main')
+
+  const exit = await runSetup({
+    mode: 'pr',
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+
+  expect(exit).toBe(0)
+  expect(await revParse(join(runDir, 'worktree'), 'HEAD')).toBe(prHead)
+  expect(await readFile(join(runDir, 'worktree', 'a.txt'), 'utf8')).toBe('one\n')
+})
+
+test('setup works when no local branch carries the PR head name, as on a fork PR', async () => {
+  const prHead = await revParse(repo, 'feature-x')
+  await sh(repo, 'git', 'tag', 'fake-pr-head', prHead)
+  await sh(repo, 'git', 'branch', '-q', '-D', 'feature-x')
+
+  const exit = await runSetup({
+    mode: 'pr',
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+
+  expect(exit).toBe(0)
+  expect(await revParse(join(runDir, 'worktree'), 'HEAD')).toBe(prHead)
+})
+
+test('setup fails and cleans up when the PR head commit is not in the clone', async () => {
+  await sh(repo, 'git', 'branch', '-q', '-D', 'feature-x')
+
+  const exit = await runSetup({
+    mode: 'pr',
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+
+  expect(exit).toBe(5)
+  const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+  expect(log).toContain('cannot resolve PR head deadbeefdeadbeefdeadbeefdeadbeefdeadbeef locally')
+  const contents = await readdir(runDir)
+  expect(contents.filter((c) => c !== 'log.jsonl')).toHaveLength(0)
+})
+
+test('a re-review after the author force-pushed checks out the new PR head', async () => {
+  const origin = await mkdtemp(join(tmpdir(), 'magpie-setup-origin-'))
+  try {
+    await sh(origin, 'git', 'init', '-q', '--bare')
+    await sh(repo, 'git', 'remote', 'add', 'origin', origin)
+    await sh(repo, 'git', 'checkout', '-q', 'feature-x')
+    await writeFile(join(repo, 'a.txt'), 'first\n')
+    await sh(repo, 'git', 'commit', '-q', '-am', 'first')
+    const first = await revParse(repo, 'HEAD')
+    await sh(repo, 'git', 'checkout', '-q', 'main')
+    await sh(repo, 'git', 'push', '-q', 'origin', `${first}:refs/pull/1234/head`)
+    await sh(repo, 'git', 'tag', 'fake-pr-head', first)
+    expect(
+      await runSetup({
+        mode: 'pr',
+        runDir,
+        prNumber: 1234,
+        repoPath: repo,
+        deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+      }),
+    ).toBe(0)
+
+    // The amended head does not descend from the first, as after `git commit --amend`.
+    await sh(repo, 'git', 'checkout', '-q', '--detach', 'main')
+    await writeFile(join(repo, 'a.txt'), 'amended\n')
+    await sh(repo, 'git', 'commit', '-q', '-am', 'amended')
+    const amended = await revParse(repo, 'HEAD')
+    await sh(repo, 'git', 'checkout', '-q', 'main')
+    await sh(repo, 'git', 'push', '-q', '-f', 'origin', `${amended}:refs/pull/1234/head`)
+    await sh(repo, 'git', 'tag', '-f', 'fake-pr-head', amended)
+    const secondRun = await mkdtemp(join(tmpdir(), 'magpie-setup-run-'))
+    try {
+      const exit = await runSetup({
+        mode: 'pr',
+        runDir: secondRun,
+        prNumber: 1234,
+        repoPath: repo,
+        deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+      })
+      expect(exit).toBe(0)
+      expect(await revParse(join(secondRun, 'worktree'), 'HEAD')).toBe(amended)
+    } finally {
+      await rm(secondRun, { recursive: true, force: true })
+    }
+  } finally {
+    await rm(origin, { recursive: true, force: true })
+  }
+})
+
+test('offline, a PR head commit already in the clone wins over a stale PR ref', async () => {
+  const stale = await revParse(repo, 'main')
+  await sh(repo, 'git', 'checkout', '-q', 'feature-x')
+  await writeFile(join(repo, 'a.txt'), 'new head\n')
+  await sh(repo, 'git', 'commit', '-q', '-am', 'new head')
+  const head = await revParse(repo, 'HEAD')
+  await sh(repo, 'git', 'checkout', '-q', 'main')
+  await sh(repo, 'git', 'update-ref', 'refs/magpie/pr-1234', stale)
+
+  const exit = await runSetup({
+    mode: 'pr',
+    runDir,
+    prNumber: 1234,
+    repoPath: repo,
+    deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+  })
+
+  expect(exit).toBe(0)
+  expect(await revParse(join(runDir, 'worktree'), 'HEAD')).toBe(head)
+})
+
+test('setup fetches nothing when the PR head commit is already in the clone', async () => {
+  const origin = await mkdtemp(join(tmpdir(), 'magpie-setup-origin-'))
+  try {
+    await sh(origin, 'git', 'init', '-q', '--bare')
+    await sh(repo, 'git', 'remote', 'add', 'origin', origin)
+    await sh(repo, 'git', 'push', '-q', 'origin', 'feature-x:refs/pull/1234/head')
+
+    const exit = await runSetup({
+      mode: 'pr',
+      runDir,
+      prNumber: 1234,
+      repoPath: repo,
+      deps: { bun: 'bun', gh: FAKE_GH, codex: 'echo', git: 'git' },
+    })
+
+    expect(exit).toBe(0)
+    const ref = Bun.spawn(['git', 'rev-parse', '--verify', '-q', 'refs/magpie/pr-1234'], {
+      cwd: repo,
+      stdout: 'pipe',
+    })
+    expect(await ref.exited).toBe(1)
+  } finally {
+    await rm(origin, { recursive: true, force: true })
+  }
+})
+
+test('a re-review lists the files changed since the last review when the new head is not yet local', async () => {
+  const origin = await mkdtemp(join(tmpdir(), 'magpie-setup-origin-'))
+  const other = await mkdtemp(join(tmpdir(), 'magpie-setup-other-'))
+  const magpieHome = await mkdtemp(join(tmpdir(), 'magpie-home-fetch-'))
+  const originalHome = process.env.MAGPIE_HOME
+  try {
+    await sh(origin, 'git', 'init', '-q', '--bare')
+    await sh(repo, 'git', 'remote', 'add', 'origin', origin)
+    await sh(repo, 'git', 'push', '-q', 'origin', 'feature-x')
+    const previousHead = await revParse(repo, 'feature-x')
+    // The author pushes from another clone, so this clone has never seen the new head.
+    await sh(other, 'git', 'clone', '-q', '-b', 'feature-x', origin, '.')
+    await sh(other, 'git', 'config', 'user.email', 't@t.t')
+    await sh(other, 'git', 'config', 'user.name', 't')
+    await sh(other, 'git', 'config', 'commit.gpgsign', 'false')
+    await writeFile(join(other, 'b.txt'), 'new\n')
+    await sh(other, 'git', 'add', '.')
+    await sh(other, 'git', 'commit', '-q', '-m', 'new')
+    const newHead = await revParse(other, 'HEAD')
+    await sh(other, 'git', 'push', '-q', 'origin', 'HEAD:refs/pull/1234/head')
+    await writeFile(join(repo, '.git', 'fake-pr-head'), newHead)
+
+    await mkdir(join(magpieHome, 'pr-1234-100'))
+    await writeFile(
+      join(magpieHome, 'pr-1234-100', 'pr.json'),
+      JSON.stringify({
+        headRefOid: previousHead,
+        number: 1234,
+        url: 'https://github.com/octocat/Hello-World/pull/1234',
+      }),
+    )
+    process.env.MAGPIE_HOME = magpieHome
+
+    const exit = await runSetup({
+      mode: 'pr',
+      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.changedSincePrevious).toEqual(['b.txt'])
+  } finally {
+    if (originalHome === undefined) delete process.env.MAGPIE_HOME
+    else process.env.MAGPIE_HOME = originalHome
+    await rm(origin, { recursive: true, force: true })
+    await rm(other, { recursive: true, force: true })
+    await rm(magpieHome, { recursive: true, force: true })
+  }
+})

package/skills/magpie/scripts/__tests__/shard-coverage.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describeUnreviewed, readShardCoverage } from '../shard-coverage.ts'
+
+let runDir: string
+
+beforeEach(async () => {
+  runDir = await mkdtemp(join(tmpdir(), 'magpie-coverage-'))
+  await mkdir(join(runDir, 'shards'))
+  await writeFile(
+    join(runDir, 'shards', 'manifest.json'),
+    JSON.stringify({
+      budget: 6000,
+      maxFiles: 80,
+      totalFiles: 4,
+      totalLines: 40,
+      shards: [
+        { id: 1, path: 'shards/shard-1.patch', files: ['src/a.ts'], lines: 10 },
+        { id: 2, path: 'shards/shard-2.patch', files: ['src/b.ts', 'src/c.ts'], lines: 20 },
+        { id: 3, path: 'shards/shard-3.patch', files: ['docs/d.md'], lines: 10 },
+      ],
+    }),
+  )
+})
+
+afterEach(async () => {
+  await rm(runDir, { recursive: true, force: true })
+})
+
+async function writeLog(entries: Array<Record<string, unknown>>): Promise<void> {
+  await writeFile(join(runDir, 'log.jsonl'), entries.map((e) => `${JSON.stringify(e)}\n`).join(''))
+}
+
+test('the skipped shards and their files come from the shard-coverage entry and the manifest', async () => {
+  await writeLog([
+    { stage: 'setup', status: 'done' },
+    { stage: 'shard-coverage', status: 'partial', reviewed: [1], skipped: [2, 3] },
+  ])
+  expect(await readShardCoverage(runDir)).toEqual({
+    skipped: [
+      { id: 2, files: ['src/b.ts', 'src/c.ts'] },
+      { id: 3, files: ['docs/d.md'] },
+    ],
+  })
+})
+
+test('the last shard-coverage entry wins', async () => {
+  await writeLog([
+    { stage: 'shard-coverage', status: 'partial', reviewed: [1], skipped: [2, 3] },
+    { stage: 'shard-coverage', status: 'partial', reviewed: [1, 2], skipped: [3] },
+  ])
+  expect(await readShardCoverage(runDir)).toEqual({ skipped: [{ id: 3, files: ['docs/d.md'] }] })
+})
+
+test('a run that reviewed every shard has no coverage gap', async () => {
+  await writeLog([{ stage: 'specialists', status: 'done' }])
+  expect(await readShardCoverage(runDir)).toBeNull()
+})
+
+test('a skipped shard the manifest does not have is rejected, naming it', async () => {
+  await writeLog([{ stage: 'shard-coverage', status: 'partial', reviewed: [1], skipped: [9] }])
+  await expect(readShardCoverage(runDir)).rejects.toThrow('shard 9')
+})
+
+test('the gap reads as the shard ids and the file count', () => {
+  expect(
+    describeUnreviewed({
+      skipped: [
+        { id: 2, files: ['src/b.ts', 'src/c.ts'] },
+        { id: 3, files: ['docs/d.md'] },
+      ],
+    }),
+  ).toBe('Not reviewed: shards 2, 3 (3 files)')
+  expect(describeUnreviewed({ skipped: [{ id: 3, files: ['docs/d.md'] }] })).toBe(
+    'Not reviewed: shard 3 (1 file)',
+  )
+})

package/skills/magpie/scripts/__tests__/skill-lint.test.ts

@@ -24,7 +24,7 @@ test('references/ ships in the install bundle', async () => {
   }
   const covers = (p: string) =>
     manifest.bundle.include.some((inc) => inc === p || p.startsWith(`${inc}/`))
-  for (const name of ['specialists.md', 'critic.md', 'peer-review.md', 'scout.md']) {
+  for (const name of ['specialists.md', 'critic.md', 'peer-review.md', 'scout.md', 'proof.md']) {
     expect(covers(`references/${name}`)).toBe(true)
   }
 })
@@ -88,6 +88,7 @@ test('references/critic.md carries every placeholder critic-prompt fills', async
     '<<CANDIDATES>>',
     '<<MERGE_CANDIDATES>>',
     '<<REVIEW_RULES>>',
+    '<<ALREADY_RAISED>>',
     '<<WORKTREE>>',
     '<<DIFF_PATH>>',
     '<<OUTPUT_PATH>>',
@@ -96,6 +97,43 @@ test('references/critic.md carries every placeholder critic-prompt fills', async
   }
 })
 
+test('references/specialists.md has the orchestrator fill in the focus id', async () => {
+  // A bugs specialist left to fill in <focus> itself wrote correctness.shard-4.json,
+  // which nothing reads.
+  const text = await readFile(ref('specialists.md'), 'utf8')
+  expect(text).toMatch(/Replace every `<RUN_DIR>`, `<WORKTREE>`, `<TARGET>` and `<focus>`/)
+  expect(text).not.toContain('Leave `<focus>` as written')
+})
+
+test('references/proof.md carries every placeholder proof-prompt fills', async () => {
+  const text = await readFile(ref('proof.md'), 'utf8')
+  const block = text.match(/^(`{3,4})magpie-proof\n([\s\S]*?)\n\1[ \t]*$/m)?.[2] ?? ''
+  expect(block.length).toBeGreaterThan(0)
+  for (const ph of ['<<FINDING>>', '<<WORKTREE>>', '<<DIFF_PATH>>', '<<OUTPUT_PATH>>']) {
+    expect(block).toContain(ph)
+  }
+})
+
+test("references/proof.md keeps each prover's scratch output in a directory of its own", async () => {
+  // On PR 254 a prover picked up another prover's run output from the session
+  // scratchpad every subagent shares, and nearly reported it as its own.
+  const text = await readFile(ref('proof.md'), 'utf8')
+  const block = text.match(/^(`{3,4})magpie-proof\n([\s\S]*?)\n\1[ \t]*$/m)?.[2] ?? ''
+  expect(block).toContain('mktemp -d')
+  expect(block).toMatch(/never a scratchpad or\s+temp path another session shares/)
+})
+
+test('references/proof.md asks for the result shape proof-apply accepts', async () => {
+  const text = await readFile(ref('proof.md'), 'utf8')
+  const block = text.match(/^(`{3,4})magpie-proof\n([\s\S]*?)\n\1[ \t]*$/m)?.[2] ?? ''
+  for (const outcome of ['"reproduced"', '"disproved"', '"not-proven"']) {
+    expect(block).toContain(outcome)
+  }
+  for (const field of ['"path"', '"command"', '"source"', '"output"']) {
+    expect(block).toContain(field)
+  }
+})
+
 test('references/critic.md asks for the verdict shape critic-apply accepts', async () => {
   const text = await readFile(ref('critic.md'), 'utf8')
   const block = text.match(/^(`{3,4})magpie-critic\n([\s\S]*?)\n\1[ \t]*$/m)?.[2] ?? ''
@@ -210,6 +248,7 @@ test('SKILL.md sends each stage to the reference file it needs', async () => {
   expect(section('### 4. Specialists')).toContain('references/specialists.md')
   expect(section('### 6. Critic')).toContain('references/critic.md')
   expect(section('### 7. Peer review')).toContain('references/peer-review.md')
+  expect(section('### 7b. Proof')).toContain('references/proof.md')
 })
 
 test('a bare /magpie is routed to local mode and the hint says so', async () => {
@@ -222,7 +261,13 @@ test('a bare /magpie is routed to local mode and the hint says so', async () =>
 
 test('SKILL.md no longer inlines the prompt bodies it moved out', async () => {
   const text = await readFile(SKILL, 'utf8')
-  for (const tag of ['magpie-specialist-', 'magpie-critic', 'magpie-peer-review', 'magpie-scout']) {
+  for (const tag of [
+    'magpie-specialist-',
+    'magpie-critic',
+    'magpie-peer-review',
+    'magpie-scout',
+    'magpie-proof',
+  ]) {
     expect(text).not.toContain(`\`\`\`${tag}`)
   }
   // The walkthrough is the always-read part; keep it small enough to be cheap.
@@ -273,6 +318,7 @@ test('rendered HTML opts into light/dark with a color-scheme meta tag', async ()
       dedupe: 'pending',
       critic: 'pending',
       'peer-review': 'pending',
+      proof: 'pending',
       report: 'pending',
       post: 'pending',
     },

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

@@ -67,12 +67,12 @@ const throughPeerReview: [string, string][] = [
   ['peer-review', 'done'],
 ]
 
-test('a local run after peer-review resumes at handoff', async () => {
+test('a local run after peer-review resumes at proof', async () => {
   await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: runDir }))
   await writeFile(join(runDir, 'log.jsonl'), logLines(throughPeerReview))
   const result = await runStatus(runDir)
   expect(result.lastCompleted).toBe('peer-review')
-  expect(result.next).toBe('handoff')
+  expect(result.next).toBe('proof')
 })
 
 test('a local run with handoff done goes to cleanup', async () => {
@@ -83,17 +83,29 @@ test('a local run with handoff done goes to cleanup', async () => {
   expect(result.next).toBe('cleanup')
 })
 
-test('a PR or archived run with no target.json resumes at report after peer-review', async () => {
-  await writeFile(join(runDir, 'log.jsonl'), logLines(throughPeerReview))
+test('a PR or archived run with no target.json resumes at report after proof', async () => {
+  await writeFile(join(runDir, 'log.jsonl'), logLines([...throughPeerReview, ['proof', 'done']]))
   const result = await runStatus(runDir)
-  expect(result.lastCompleted).toBe('peer-review')
+  expect(result.lastCompleted).toBe('proof')
   expect(result.next).toBe('report')
 })
 
-test('a PR run with target.json resumes at report after peer-review', async () => {
+test('a PR run with target.json resumes at report after proof', async () => {
   await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'pr', root: runDir }))
-  await writeFile(join(runDir, 'log.jsonl'), logLines(throughPeerReview))
+  await writeFile(join(runDir, 'log.jsonl'), logLines([...throughPeerReview, ['proof', 'done']]))
   const result = await runStatus(runDir)
-  expect(result.lastCompleted).toBe('peer-review')
+  expect(result.lastCompleted).toBe('proof')
   expect(result.next).toBe('report')
 })
+
+test('a PR run after peer-review resumes at proof', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'pr', root: runDir }))
+  await writeFile(join(runDir, 'log.jsonl'), logLines(throughPeerReview))
+  expect((await runStatus(runDir)).next).toBe('proof')
+})
+
+test('a local run after proof resumes at handoff', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: runDir }))
+  await writeFile(join(runDir, 'log.jsonl'), logLines([...throughPeerReview, ['proof', 'done']]))
+  expect((await runStatus(runDir)).next).toBe('handoff')
+})

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

@@ -418,3 +418,49 @@ test('parseBrief keeps review rules with a non-empty rule and source', () => {
 test('parseBrief yields no review rules when the key is absent', () => {
   expect(parseBrief({ purpose: 'Does a thing.' })?.reviewRules).toEqual([])
 })
+
+test('parseFinding keeps a reproduced proof with its repro', () => {
+  const proof = {
+    status: 'reproduced',
+    reason: 'fails as described',
+    repro: { path: 'a.test.ts', command: 'bun test a.test.ts', source: 'src', output: 'out' },
+  }
+  const f = parseFinding({
+    id: 'a',
+    file: 'a.ts',
+    line: 1,
+    title: 't',
+    description: 'd',
+    risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+    proof,
+  })
+  expect(f.proof).toEqual(proof as never)
+})
+
+test('parseFinding rejects a proof that is neither reproduced nor not-proven', () => {
+  expect(() =>
+    parseFinding({
+      id: 'a',
+      file: 'a.ts',
+      line: 1,
+      title: 't',
+      description: 'd',
+      risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+      proof: { status: 'disproved', reason: 'r' },
+    }),
+  ).toThrow('Finding.proof.status must be reproduced or not-proven')
+})
+
+test('parseFinding rejects a proof with an empty reason', () => {
+  expect(() =>
+    parseFinding({
+      id: 'a',
+      file: 'a.ts',
+      line: 1,
+      title: 't',
+      description: 'd',
+      risk: { impact: 'high', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+      proof: { status: 'not-proven', reason: '' },
+    }),
+  ).toThrow('Finding.proof.reason must be a non-empty string')
+})