@iceinvein/agent-skills 0.23.9 → 0.23.13

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

@@ -0,0 +1,226 @@
+import { appendFile, copyFile, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import {
+  applyProofResults,
+  buildProofPrompts,
+  DEFAULT_PROOF_CAP,
+  type ProofDropped,
+  type ProofResult,
+  parseProofResult,
+  selectForProof,
+} from './proof.ts'
+import { reviewRoot } from './target.ts'
+import { isRepro, parseFinding, type ReviewFinding } from './types.ts'
+
+const DEFAULT_TEMPLATE_PATH = new URL('../references/proof.md', import.meta.url).pathname
+
+async function logLine(runDir: string, entry: Record<string, unknown>): Promise<void> {
+  const line = `${JSON.stringify({ ...entry, ts: Date.now() })}\n`
+  await appendFile(join(runDir, 'log.jsonl'), line)
+}
+
+function isMissingFile(err: unknown): boolean {
+  return (err as NodeJS.ErrnoException)?.code === 'ENOENT'
+}
+
+/** The prompt is the body of the fenced block tagged `magpie-proof` (3 or 4 backticks). */
+function extractTemplate(doc: string, path: string): string {
+  const match = doc.match(/^(`{3,4})magpie-proof\n([\s\S]*?)\n\1[ \t]*$/m)
+  if (!match?.[2]) throw new Error(`${path}: no magpie-proof fenced block`)
+  return match[2]
+}
+
+async function readFindings(path: string): Promise<ReviewFinding[]> {
+  const raw: unknown = JSON.parse(await readFile(path, 'utf8'))
+  if (!Array.isArray(raw)) throw new Error(`${path}: expected a JSON array`)
+  return raw.map(parseFinding)
+}
+
+/**
+ * proof-apply rewrites findings.final.json, so the findings as the peer review
+ * left them are kept aside on the first proof-prompt. Selecting from that copy
+ * makes a re-run of either command land on the same findings.
+ */
+async function readUnproven(runDir: string): Promise<ReviewFinding[]> {
+  const unproven = join(runDir, 'findings.unproven.json')
+  try {
+    return await readFindings(unproven)
+  } catch (err) {
+    if (!isMissingFile(err)) throw err
+  }
+  await copyFile(join(runDir, 'findings.final.json'), unproven)
+  return readFindings(unproven)
+}
+
+export type RunProofPromptOptions = {
+  /** Markdown file holding the `magpie-proof` block. Defaults to `references/proof.md`. */
+  templatePath?: string
+}
+
+export async function runProofPrompt(
+  runDir: string,
+  options: RunProofPromptOptions = {},
+): Promise<number> {
+  const templatePath = options.templatePath ?? DEFAULT_TEMPLATE_PATH
+  try {
+    const template = extractTemplate(await readFile(templatePath, 'utf8'), templatePath)
+    const prompts = buildProofPrompts({
+      template,
+      findings: selectForProof(await readUnproven(runDir), DEFAULT_PROOF_CAP),
+      worktree: await reviewRoot(runDir),
+      diffPath: join(runDir, 'diff.patch'),
+      runDir,
+    })
+    const lines: string[] = []
+    for (const p of prompts) {
+      const promptPath = join(runDir, `proof-prompt-${p.id}.md`)
+      await writeFile(promptPath, p.prompt)
+      lines.push(`${promptPath}\t${p.outputPath}\n`)
+    }
+    process.stdout.write(lines.join(''))
+    return 0
+  } catch (err) {
+    process.stderr.write(`proof-prompt: ${err instanceof Error ? err.message : String(err)}\n`)
+    return 1
+  }
+}
+
+/** Null when the subagent wrote no file, so the caller can name every missing one. */
+async function readResult(path: string, id: string): Promise<ProofResult | null> {
+  let text: string
+  try {
+    text = await readFile(path, 'utf8')
+  } catch (err) {
+    if (isMissingFile(err)) return null
+    throw err
+  }
+  let raw: unknown
+  try {
+    raw = JSON.parse(text)
+  } catch (err) {
+    throw new Error(`${path}: ${err instanceof Error ? err.message : String(err)}`)
+  }
+  const result = parseProofResult(raw, path)
+  if (result.id !== id) throw new Error(`${path}: id is ${result.id}, expected ${id}`)
+  return result
+}
+
+// Provers name their file `magpie-proof-<id>`, or `MagpieProof<id>` where a name must be an identifier.
+const REPRO_NAME = /magpie[-_]?proof/i
+
+/** A prover that crashed or skipped its cleanup leaves its test in the tree, which in local mode is the author's. */
+async function leftoverRepros(root: string, gitBin: string): Promise<string[]> {
+  const proc = Bun.spawn([gitBin, 'ls-files', '--others', '--exclude-standard', '-z'], {
+    cwd: root,
+    stdout: 'pipe',
+    stderr: 'pipe',
+  })
+  const [exit, out, err] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ])
+  if (exit !== 0) throw new Error(`git ls-files in ${root} exit ${exit}: ${err.trim()}`)
+  return out.split('\0').filter((path) => REPRO_NAME.test(path.split('/').at(-1) ?? ''))
+}
+
+/** Runner output carries the worktree's absolute path, which names the reviewer's home directory on GitHub. */
+function relativise(result: ProofResult, root: string): ProofResult {
+  if (result.outcome === 'not-proven') return result
+  const strip = (text: string) => text.replaceAll(root, '.')
+  const { path, command, source, output } = result.repro
+  return {
+    ...result,
+    repro: { path, command: strip(command), source: strip(source), output: strip(output) },
+  }
+}
+
+export async function runProofApply(
+  runDir: string,
+  opts: { gitBin?: string } = {},
+): Promise<number> {
+  try {
+    const root = await reviewRoot(runDir)
+    const unprovenPath = join(runDir, 'findings.unproven.json')
+    let findings: ReviewFinding[]
+    try {
+      findings = await readFindings(unprovenPath)
+    } catch (err) {
+      if (isMissingFile(err)) throw new Error(`${unprovenPath} is missing; run proof-prompt first`)
+      throw err
+    }
+    const missing: string[] = []
+    const results: ProofResult[] = []
+    for (const f of selectForProof(findings, DEFAULT_PROOF_CAP)) {
+      const path = join(runDir, `proof-${f.id}.json`)
+      const result = await readResult(path, f.id)
+      if (result === null) missing.push(path)
+      else results.push(relativise(result, root))
+    }
+    if (missing.length > 0) throw new Error(`no proof result: ${missing.join(', ')}`)
+    const leftovers = await leftoverRepros(root, opts.gitBin ?? 'git')
+    if (leftovers.length > 0) {
+      throw new Error(`provers left files in ${root}; delete them: ${leftovers.join(', ')}`)
+    }
+    const applied = applyProofResults({ findings, results })
+    await writeFile(
+      join(runDir, 'findings.final.json'),
+      `${JSON.stringify(applied.findings, null, 2)}\n`,
+    )
+    await writeFile(
+      join(runDir, 'proof-dropped.json'),
+      `${JSON.stringify(applied.dropped, null, 2)}\n`,
+    )
+    await logLine(runDir, {
+      stage: 'proof',
+      status: 'done',
+      reproduced: results.filter((r) => r.outcome === 'reproduced').length,
+      notProven: results.filter((r) => r.outcome === 'not-proven').length,
+      disproved: applied.dropped.length,
+    })
+    return 0
+  } catch (err) {
+    process.stderr.write(`proof-apply: ${err instanceof Error ? err.message : String(err)}\n`)
+    return 1
+  }
+}
+
+/** What proof-apply removed, for the report and the handoff; a run before proof has none. */
+export async function readProofDropped(runDir: string): Promise<ProofDropped[]> {
+  const path = join(runDir, 'proof-dropped.json')
+  let text: string
+  try {
+    text = await readFile(path, 'utf8')
+  } catch (err) {
+    if (isMissingFile(err)) return []
+    throw err
+  }
+  let raw: unknown
+  try {
+    raw = JSON.parse(text)
+  } catch (err) {
+    throw new Error(`${path}: ${err instanceof Error ? err.message : String(err)}`)
+  }
+  if (!Array.isArray(raw)) throw new Error(`${path}: expected a JSON array`)
+  return raw.map((entry, i) => {
+    const e = (entry ?? {}) as Record<string, unknown>
+    if (
+      typeof e.id !== 'string' ||
+      typeof e.file !== 'string' ||
+      (e.line !== null && typeof e.line !== 'number') ||
+      typeof e.title !== 'string' ||
+      typeof e.reason !== 'string' ||
+      !isRepro(e.repro)
+    ) {
+      throw new Error(`${path}: entry ${i} needs id, file, line, title, reason and repro`)
+    }
+    return {
+      id: e.id,
+      file: e.file,
+      line: e.line as number | null,
+      title: e.title,
+      reason: e.reason,
+      repro: e.repro,
+    }
+  })
+}

package/skills/magpie/scripts/proof.ts

@@ -0,0 +1,150 @@
+import { join } from 'node:path'
+import { scoreRisk } from './score.ts'
+import { isRepro, type Repro, type ReviewFinding } from './types.ts'
+
+/** Each proof is one subagent writing and running a test, so the count is the cost. */
+export const DEFAULT_PROOF_CAP = 8
+
+export const PROOF_PLACEHOLDERS = [
+  '<<FINDING>>',
+  '<<WORKTREE>>',
+  '<<DIFF_PATH>>',
+  '<<OUTPUT_PATH>>',
+] as const
+
+const PLACEHOLDER_PATTERN = new RegExp(PROOF_PLACEHOLDERS.join('|'), 'g')
+
+// The id names the prompt and output files.
+const SAFE_ID = /^[A-Za-z0-9_-]+$/
+
+const OUTCOMES = ['reproduced', 'disproved', 'not-proven'] as const
+
+export type ProofResult =
+  | { id: string; outcome: 'reproduced' | 'disproved'; reason: string; repro: Repro }
+  | { id: string; outcome: 'not-proven'; reason: string }
+
+export type ProofDropped = {
+  id: string
+  file: string
+  line: number | null
+  title: string
+  reason: string
+  repro: Repro
+}
+
+export function selectForProof(findings: ReviewFinding[], cap: number): ReviewFinding[] {
+  // Action, not impact: the critic keeps a confirmed defect at should-fix even when
+  // it rates the impact low, and a real PR left nothing high to prove.
+  const eligible = findings.filter(
+    (f) => f.risk.action === 'must-fix' || f.risk.action === 'should-fix',
+  )
+  // Scored from risk here, not read from `score`: the peer reviewer may have
+  // changed risk or added findings after dedupe set it.
+  return [...eligible].sort((a, b) => scoreRisk(b.risk) - scoreRisk(a.risk)).slice(0, cap)
+}
+
+export function buildProofPrompts(input: {
+  template: string
+  findings: ReviewFinding[]
+  worktree: string
+  diffPath: string
+  runDir: string
+}): Array<{ id: string; prompt: string; outputPath: string }> {
+  const { template, findings, worktree, diffPath, runDir } = input
+  const missing = PROOF_PLACEHOLDERS.filter((p) => !template.includes(p))
+  if (missing.length > 0) {
+    throw new Error(`proof template is missing placeholders: ${missing.join(', ')}`)
+  }
+  return findings.map((f) => {
+    if (!SAFE_ID.test(f.id)) throw new Error(`finding id ${f.id} is not safe in a file name`)
+    const outputPath = join(runDir, `proof-${f.id}.json`)
+    const finding = JSON.stringify(
+      {
+        id: f.id,
+        file: f.file,
+        line: f.line,
+        risk: f.risk,
+        domain: f.domain,
+        title: f.title,
+        description: f.description,
+        evidence: f.evidence,
+      },
+      null,
+      2,
+    )
+    const values: Record<(typeof PROOF_PLACEHOLDERS)[number], string> = {
+      '<<FINDING>>': finding,
+      '<<WORKTREE>>': worktree,
+      '<<DIFF_PATH>>': diffPath,
+      '<<OUTPUT_PATH>>': outputPath,
+    }
+    // A function replacer, so `$` in a finding's text is not read as a pattern.
+    const prompt = template.replace(PLACEHOLDER_PATTERN, (m) => values[m as keyof typeof values])
+    return { id: f.id, prompt, outputPath }
+  })
+}
+
+export function parseProofResult(raw: unknown, source: string): ProofResult {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new Error(`${source}: expected a JSON object`)
+  }
+  const r = raw as Record<string, unknown>
+  if (typeof r.id !== 'string') throw new Error(`${source}: id must be a string`)
+  if (typeof r.reason !== 'string' || r.reason === '') {
+    throw new Error(`${source}: reason must be a non-empty string`)
+  }
+  if (!(OUTCOMES as readonly unknown[]).includes(r.outcome)) {
+    throw new Error(`${source}: outcome must be reproduced, disproved or not-proven`)
+  }
+  if (r.outcome === 'not-proven') return { id: r.id, outcome: 'not-proven', reason: r.reason }
+  const outcome = r.outcome as 'reproduced' | 'disproved'
+  if (!isRepro(r.repro)) {
+    throw new Error(`${source}: ${outcome} needs a repro with path, command, source and output`)
+  }
+  const { path, command, source: code, output } = r.repro
+  return {
+    id: r.id,
+    outcome,
+    reason: r.reason,
+    repro: { path, command, source: code, output },
+  }
+}
+
+export function applyProofResults(input: { findings: ReviewFinding[]; results: ProofResult[] }): {
+  findings: ReviewFinding[]
+  dropped: ProofDropped[]
+} {
+  const ids = new Set(input.findings.map((f) => f.id))
+  const unknown = input.results.filter((r) => !ids.has(r.id)).map((r) => r.id)
+  if (unknown.length > 0) throw new Error(`proof result for unknown id: ${unknown.join(', ')}`)
+  const byId = new Map(input.results.map((r) => [r.id, r]))
+  const findings: ReviewFinding[] = []
+  const dropped: ProofDropped[] = []
+  for (const f of input.findings) {
+    const r = byId.get(f.id)
+    if (r === undefined) {
+      findings.push(f)
+    } else if (r.outcome === 'disproved') {
+      dropped.push({
+        id: f.id,
+        file: f.file,
+        line: f.line,
+        title: f.title,
+        reason: r.reason,
+        repro: r.repro,
+      })
+    } else if (r.outcome === 'not-proven') {
+      findings.push({ ...f, proof: { status: 'not-proven', reason: r.reason } })
+    } else {
+      // A failing test that shows the defect leaves nothing to be unsure of.
+      const risk = { ...f.risk, confidence: 'high' as const }
+      findings.push({
+        ...f,
+        risk,
+        score: scoreRisk(risk),
+        proof: { status: 'reproduced', reason: r.reason, repro: r.repro },
+      })
+    }
+  }
+  return { findings, dropped }
+}

package/skills/magpie/scripts/refresh.ts

@@ -1,8 +1,12 @@
 import { readdir, readFile, rename, unlink } from 'node:fs/promises'
 import { basename, join } from 'node:path'
+import { readHistory } from './history.ts'
 import { readDismissed } from './labels.ts'
+import { describePreviousPosted } from './previous-findings.ts'
+import { readProofDropped } from './proof-cmd.ts'
 import { type PostStatusMap, parseClosingIssues, renderFindingsToDisk } from './render-findings.ts'
 import { DEFAULT_TOP_N } from './render-issues-list.ts'
+import { readShardCoverage } from './shard-coverage.ts'
 import { type PrFileEntry, parseBrief, parseFinding } from './types.ts'
 
 export type RefreshResult = {
@@ -96,6 +100,10 @@ export async function refreshFindings(runDir: string): Promise<RefreshResult> {
   // to a temp file first, so a failure leaves the previous findings.html
   // in place instead of an empty screen dir.
   const dismissed = await readDismissed(runDir)
+  const { previous } = await readHistory(runDir)
+  const previousRun = previous ? (describePreviousPosted(previous) ?? undefined) : undefined
+  const unreviewed = await readShardCoverage(runDir)
+  const disproved = await readProofDropped(runDir)
   const screenDir = join(runDir, 'screen')
   const tempPath = join(screenDir, '.findings.html.tmp')
   await renderFindingsToDisk(
@@ -109,6 +117,9 @@ export async function refreshFindings(runDir: string): Promise<RefreshResult> {
       brief: brief ?? undefined,
       issues,
       diffSource,
+      ...(previousRun ? { previousRun } : {}),
+      ...(unreviewed ? { unreviewed } : {}),
+      disproved,
       dismissed,
       topN: DEFAULT_TOP_N,
     },

package/skills/magpie/scripts/render-annotation.ts

@@ -108,6 +108,21 @@ function renderSuggestion(f: ReviewFinding, highlighter: Highlighter): string {
   return `<section class="section"><div class="section-label">Suggested change</div>${withClass}</section>`
 }
 
+function renderProofChip(f: ReviewFinding): string {
+  if (!f.proof) return ''
+  const label = f.proof.status === 'reproduced' ? 'REPRODUCED' : 'NOT PROVEN'
+  return `<span class="proof-chip ${f.proof.status}" title="${esc(f.proof.reason)}">${label}</span>`
+}
+
+function renderProof(f: ReviewFinding): string {
+  if (f.proof?.status === 'not-proven') {
+    return `<section class="section"><div class="section-label">Not proven</div><div class="section-body">${renderInline(f.proof.reason)}</div></section>`
+  }
+  if (f.proof?.status !== 'reproduced') return ''
+  const { command, source, output } = f.proof.repro
+  return `<section class="section"><div class="section-label">Reproduced with <code class="inline-code">${esc(command)}</code></div><pre class="repro">${esc(source)}</pre><pre class="repro">${esc(output)}</pre></section>`
+}
+
 function renderRisk(f: ReviewFinding): string {
   return `<div class="risk">Impact: <span class="tag">${esc(f.risk.impact)}</span> · Likelihood: <span class="tag">${esc(f.risk.likelihood)}</span> · Confidence: <span class="tag">${esc(f.risk.confidence)}</span> · Action: <span class="tag">${esc(f.risk.action)}</span></div>`
 }
@@ -140,10 +155,12 @@ export function renderAnnotation(f: ReviewFinding, opts: RenderAnnotationOptions
         <span class="sev-label sev-${f.severity}">${sevLabel}</span>
         <span class="annot-title">${esc(f.title)}</span>
         <span class="domain-chip">${esc(domainLabel)}</span>
+        ${renderProofChip(f)}
         ${statusChip}
       </div>
       ${renderSections(f.description)}
       ${renderSuggestion(f, opts.highlighter)}
+      ${renderProof(f)}
       ${renderRisk(f)}
       ${opts.posted ? '' : renderDismiss(f.id, dismissed)}
     </div>

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

@@ -1,9 +1,13 @@
 import { readdir, readFile } from 'node:fs/promises'
 import { basename, join } from 'node:path'
+import { readHistory } from './history.ts'
 import { readDismissed } from './labels.ts'
+import { describePreviousPosted } from './previous-findings.ts'
+import { readProofDropped } from './proof-cmd.ts'
 import { type PostStatusMap, parseClosingIssues, renderFindingsToDisk } from './render-findings.ts'
 import { DEFAULT_TOP_N } from './render-issues-list.ts'
 import { renderProgressToDisk } from './render-progress.ts'
+import { readShardCoverage } from './shard-coverage.ts'
 import { parseBrief, parseFinding } from './types.ts'
 
 async function nextVersionedPath(screenDir: string, base: string): Promise<string> {
@@ -47,6 +51,7 @@ function summarizeStages(log: Array<Record<string, unknown>>): {
     dedupe: 'pending',
     critic: 'pending',
     'peer-review': 'pending',
+    proof: 'pending',
     report: 'pending',
     post: 'pending',
   }
@@ -150,6 +155,10 @@ export async function runRender(
       null,
     )) ?? undefined
   const dismissed = await readDismissed(runDir)
+  const { previous } = await readHistory(runDir)
+  const previousRun = previous ? (describePreviousPosted(previous) ?? undefined) : undefined
+  const unreviewed = await readShardCoverage(runDir)
+  const disproved = await readProofDropped(runDir)
   const outPath = await nextVersionedPath(screenDir, 'findings')
   await renderFindingsToDisk(
     {
@@ -162,6 +171,9 @@ export async function runRender(
       brief,
       issues,
       diffSource,
+      ...(previousRun ? { previousRun } : {}),
+      ...(unreviewed ? { unreviewed } : {}),
+      disproved,
       dismissed,
       topN: opts.topN ?? DEFAULT_TOP_N,
     },

package/skills/magpie/scripts/render-findings.ts

@@ -3,10 +3,12 @@ import { basename } from 'node:path'
 import type { Highlighter } from 'shiki'
 import { parseUnifiedDiffToHunks, splitDiffByFile } from './diff-utils.ts'
 import { getHighlighter } from './highlight.ts'
+import type { ProofDropped } from './proof.ts'
 import { renderActionBar } from './render-action-bar.ts'
 import { renderSplitDiff, renderUnifiedDiff } from './render-diff.ts'
 import { renderFileTree } from './render-file-tree.ts'
 import { renderIssuesList } from './render-issues-list.ts'
+import { describeUnreviewed, type ShardCoverage } from './shard-coverage.ts'
 import type { PostStatusMap, PrBrief, PrFileEntry, ReviewFinding } from './types.ts'
 
 export type { PostStatusEntry, PostStatusMap } from './types.ts'
@@ -65,6 +67,12 @@ export type RenderFindingsInput = {
   topN: number
   /** Where diff.patch came from. Absent means gh, which needs no note. */
   diffSource?: { source: 'gh' | 'git'; mergeBase: string | null }
+  /** `describePreviousPosted` on a re-review; absent on a first run. */
+  previousRun?: string
+  /** Shards skipped at the stage 4 gate; absent when every shard was reviewed. */
+  unreviewed?: ShardCoverage
+  /** Findings the proof stage removed because a passing test showed the code is right. */
+  disproved?: ProofDropped[]
 }
 
 function esc(s: string): string {
@@ -90,6 +98,24 @@ function brandBlock(): string {
   return `<div class="brand">${BRAND_MARK_SVG}<span class="brand-text">magpie</span></div>`
 }
 
+// Closed by default: these are not findings any more, but a reader should be able
+// to check the one test that removed each of them.
+function disprovedBlock(disproved: ProofDropped[] | undefined): string {
+  if (!disproved || disproved.length === 0) return ''
+  const items = disproved
+    .map((d) => {
+      const anchor = d.line === null ? d.file : `${d.file}:${d.line}`
+      return `<li><code>${esc(anchor)}</code> ${esc(d.title)}: ${esc(d.reason)}
+        <div>Test: <code>${esc(d.repro.command)}</code></div>
+        <pre class="repro">${esc(d.repro.source)}</pre>
+        <pre class="repro">${esc(d.repro.output)}</pre></li>`
+    })
+    .join('\n')
+  return `<details class="pr-brief disproved"><summary class="brief-summary">Disproved by test (${disproved.length})</summary>
+    <ul class="brief-changes">${items}</ul>
+  </details>`
+}
+
 function prHeader(input: RenderFindingsInput): string {
   const pr = input.pr
   const src = input.diffSource
@@ -99,14 +125,22 @@ function prHeader(input: RenderFindingsInput): string {
           src.mergeBase ? ` at <code>${esc(src.mergeBase.slice(0, 12))}</code>` : ''
         }</span>`
       : ''
+  const previousNote = input.previousRun
+    ? `<span class="diff-source" title="Changed code is not the same as fixed: the defect can survive an edit">${esc(input.previousRun)}</span>`
+    : ''
+  const unreviewedNote = input.unreviewed
+    ? `<span class="diff-source" title="${esc(input.unreviewed.skipped.flatMap((s) => s.files).join(', '))}">${esc(describeUnreviewed(input.unreviewed))}</span>`
+    : ''
   const prMeta = pr
     ? `<div class="pr-meta">
         <span class="pr-number">PR #${pr.number}</span>
         <span class="pr-branch">${esc(pr.branch)}</span>
         <code>${esc(pr.headSha.slice(0, 12))}</code>
         ${diffNote}
+        ${previousNote}
+        ${unreviewedNote}
       </div>`
-    : `<div class="pr-meta">${diffNote}</div>`
+    : `<div class="pr-meta">${diffNote}${previousNote}${unreviewedNote}</div>`
   const total = input.findings.length
   return `<header class="pr-header">
     ${brandBlock()}
@@ -252,6 +286,7 @@ export function renderFindingsHtml(input: RenderFindingsInput): string {
 <body data-run-id="${esc(runId)}" data-page="findings" data-view="files" data-diff-mode="unified" data-show-suggestions="false">
 ${prHeader(input)}
 ${briefHtml}
+${disprovedBlock(input.disproved)}
 <main class="page-main">
   <div class="empty-state"><h1>No findings</h1><p>All specialists returned cleanly.</p></div>
 </main>
@@ -310,6 +345,7 @@ ${briefHtml}
 <body data-run-id="${esc(runId)}" data-page="findings" data-view="files" data-diff-mode="unified" data-show-suggestions="false">
 ${prHeader(input)}
 ${briefHtml}
+${disprovedBlock(input.disproved)}
 <main class="page-main">
   <div class="view files-view">
     ${tree}

package/skills/magpie/scripts/render-progress.ts

@@ -7,6 +7,7 @@ const STAGES = [
   'dedupe',
   'critic',
   'peer-review',
+  'proof',
   'report',
   'post',
 ] as const
@@ -20,6 +21,7 @@ const STAGE_HINT: Record<StageId, string> = {
   dedupe: 'merge overlaps',
   critic: 'keep the high-signal ones',
   'peer-review': 'independent second opinion',
+  proof: 'reproduce the serious ones',
   report: 'render this page',
   post: 'comment on the PR',
 }
@@ -31,6 +33,7 @@ const STAGE_NOW_DOING: Record<StageId, string> = {
   dedupe: 'Merging overlapping findings',
   critic: 'Keeping only the high-signal ones',
   'peer-review': 'Getting an independent second opinion',
+  proof: 'Writing failing tests for the serious findings',
   report: 'Composing the report page',
   post: 'Ready to post; switch tabs to pick findings',
 }