@iceinvein/agent-skills 0.22.0 → 0.23.0

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

@@ -0,0 +1,319 @@
+import { afterEach, beforeEach, expect, mock, spyOn, test } from 'bun:test'
+import { mkdtemp, readFile, rm, utimes, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { formatHandoff, runHandoff } from '../handoff-cmd.ts'
+import { diffSha256, localBranchDiff } from '../local-diff.ts'
+import type { ReviewFinding } from '../types.ts'
+
+const WARNING = 'Warning: the tree changed since this review began; line anchors may be off.'
+const FOOTER = 'Address every must-fix and should-fix, or say why not. The rest are optional.'
+
+const shouldFix: ReviewFinding = {
+  id: 'f-should',
+  file: 'src/b.ts',
+  line: 20,
+  severity: 'medium',
+  risk: { impact: 'medium', likelihood: 'possible', confidence: 'medium', action: 'should-fix' },
+  title: 'Retry count is off by one',
+  description: 'Observation: the loop retries four times instead of three.',
+  domain: null,
+}
+
+const mustFix: ReviewFinding = {
+  id: 'f-must',
+  file: 'src/a.ts',
+  line: 10,
+  severity: 'blocker',
+  risk: { impact: 'critical', likelihood: 'likely', confidence: 'high', action: 'must-fix' },
+  title: 'Token leaks into the log',
+  description: 'Observation: the bearer token is written to stdout.',
+  suggestion: { body: 'log.info(redact(token))', startLine: 10, endLine: 10 },
+  domain: null,
+}
+
+const consider: ReviewFinding = {
+  id: 'f-consider',
+  file: 'README.md',
+  line: null,
+  severity: 'low',
+  risk: { impact: 'low', likelihood: 'edge-case', confidence: 'low', action: 'consider' },
+  title: 'Mention the new flag',
+  description: 'Observation: the flag is undocumented.',
+  domain: null,
+}
+
+const optional: ReviewFinding = {
+  id: 'f-optional',
+  file: 'src/c.ts',
+  line: 3,
+  severity: 'low',
+  risk: { impact: 'low', likelihood: 'edge-case', confidence: 'low', action: 'optional' },
+  title: 'Name the constant',
+  description: 'Observation: the magic number has no name.',
+  domain: null,
+}
+
+const findings = [shouldFix, consider, mustFix, optional]
+
+function render(stale: boolean): string {
+  return formatHandoff({
+    target: 'local branch feat/x against main',
+    findings,
+    stale,
+  })
+}
+
+test('formatHandoff opens with the target header', () => {
+  expect(render(false).split('\n')[0]).toBe(
+    '# magpie local review: local branch feat/x against main',
+  )
+})
+
+test('formatHandoff counts consider and optional together as optional', () => {
+  expect(render(false)).toContain('1 must-fix, 1 should-fix, 2 optional')
+})
+
+test('formatHandoff goes straight from the counts to the first finding', () => {
+  expect(render(false)).toContain(
+    '1 must-fix, 1 should-fix, 2 optional\n\n1. [must-fix] src/a.ts:10: Token leaks into the log',
+  )
+})
+
+test('formatHandoff numbers actionable findings by risk, then suggestions', () => {
+  const out = render(false)
+  const first = out.indexOf('1. [must-fix] src/a.ts:10: Token leaks into the log')
+  const second = out.indexOf('2. [should-fix] src/b.ts:20: Retry count is off by one')
+  const third = out.indexOf('3. [consider] README.md: Mention the new flag')
+  const fourth = out.indexOf('4. [optional] src/c.ts:3: Name the constant')
+  expect(first).toBeGreaterThan(-1)
+  expect(second).toBeGreaterThan(first)
+  expect(third).toBeGreaterThan(second)
+  expect(fourth).toBeGreaterThan(third)
+})
+
+test('formatHandoff renders each description as markdown sections', () => {
+  expect(render(false)).toContain('**Observation:** the bearer token is written to stdout.')
+})
+
+test('formatHandoff fences the suggestion body under a single-line label', () => {
+  expect(render(false)).toContain(
+    'Suggested replacement for line 10:\n```\nlog.info(redact(token))\n```',
+  )
+})
+
+function renderOne(suggestion: ReviewFinding['suggestion']): string {
+  return formatHandoff({
+    target: 't',
+    findings: [{ ...mustFix, suggestion }],
+    stale: false,
+  })
+}
+
+test('formatHandoff labels a multi-line suggestion with its line range', () => {
+  expect(renderOne({ body: 'a()\nb()', startLine: 4, endLine: 5 })).toContain(
+    'Suggested replacement for lines 4-5:\n```\na()\nb()\n```',
+  )
+})
+
+test('formatHandoff fences a body holding backticks one backtick longer', () => {
+  const body = 'doc = `\n```\n`'
+  expect(renderOne({ body, startLine: 1, endLine: 3 })).toContain(`\`\`\`\`\n${body}\n\`\`\`\``)
+})
+
+test('formatHandoff ends with the footer', () => {
+  expect(render(false).trimEnd().endsWith(FOOTER)).toBe(true)
+})
+
+test('formatHandoff puts the stale warning directly after the header', () => {
+  const lines = render(true).split('\n')
+  expect(lines[1]).toBe(WARNING)
+})
+
+test('formatHandoff omits the stale warning when fresh', () => {
+  expect(render(false)).not.toContain('Warning:')
+})
+
+test('formatHandoff with no findings prints only the header and No findings.', () => {
+  const out = formatHandoff({ target: 't', findings: [], stale: false })
+  expect(out).toBe('# magpie local review: t\n\nNo findings.\n')
+})
+
+let repo: string
+let runDir: string
+let stdout: string
+let stderr: string
+
+async function sh(cwd: string, ...cmd: string[]): Promise<void> {
+  const proc = Bun.spawn(cmd, { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const exit = await proc.exited
+  if (exit !== 0) {
+    const err = await new Response(proc.stderr).text()
+    throw new Error(`${cmd.join(' ')} exit ${exit}: ${err}`)
+  }
+}
+
+beforeEach(async () => {
+  repo = await mkdtemp(join(tmpdir(), 'magpie-handoff-repo-'))
+  runDir = await mkdtemp(join(tmpdir(), 'magpie-handoff-run-'))
+  await sh(repo, 'git', 'init', '-q', '-b', 'main')
+  await sh(repo, 'git', 'config', 'user.email', 't@t.t')
+  await sh(repo, 'git', 'config', 'user.name', 't')
+  await sh(repo, 'git', 'config', 'commit.gpgsign', 'false')
+  await writeFile(join(repo, 'a.txt'), 'one\n')
+  await sh(repo, 'git', 'add', '.')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'init')
+  await sh(repo, 'git', 'checkout', '-q', '-b', 'feat/x')
+  await writeFile(join(repo, 'a.txt'), 'one\ntwo\n')
+  await sh(repo, 'git', 'commit', '-q', '-am', 'add two')
+  stdout = ''
+  stderr = ''
+  spyOn(process.stdout, 'write').mockImplementation((chunk: string | Uint8Array) => {
+    stdout += String(chunk)
+    return true
+  })
+  spyOn(process.stderr, 'write').mockImplementation((chunk: string | Uint8Array) => {
+    stderr += String(chunk)
+    return true
+  })
+})
+
+afterEach(async () => {
+  mock.restore()
+  await rm(repo, { recursive: true, force: true })
+  await rm(runDir, { recursive: true, force: true })
+})
+
+async function writeLocalRun(): Promise<void> {
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!r.ok) throw new Error(r.error)
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: repo }))
+  await writeFile(
+    join(runDir, 'local.json'),
+    JSON.stringify({
+      branch: 'feat/x',
+      baseRef: 'main',
+      mergeBase: r.mergeBase,
+      head: r.head,
+      dirty: false,
+      author: 't',
+      commits: [],
+      intentFile: null,
+    }),
+  )
+  await writeFile(join(runDir, 'findings.final.json'), JSON.stringify([mustFix]))
+  await writeFile(
+    join(runDir, 'diff-source.json'),
+    JSON.stringify({
+      source: 'local',
+      mergeBase: r.mergeBase,
+      baseRef: r.baseRef,
+      head: r.head,
+      diffSha256: diffSha256(r.diff),
+    }),
+  )
+}
+
+test('runHandoff prints a fresh handoff for an unchanged tree', async () => {
+  await writeLocalRun()
+  const exit = await runHandoff(runDir)
+  expect(exit).toBe(0)
+  expect(stdout).toContain('# magpie local review: local branch feat/x against main')
+  expect(stdout).toContain('1. [must-fix] src/a.ts:10: Token leaks into the log')
+  expect(stdout).not.toContain(WARNING)
+})
+
+test('runHandoff logs a done handoff entry with the finding count', async () => {
+  await writeLocalRun()
+  await runHandoff(runDir)
+  const lines = (await readFile(join(runDir, 'log.jsonl'), 'utf8')).trim().split('\n')
+  const entry = JSON.parse(lines[lines.length - 1] as string)
+  expect(entry.stage).toBe('handoff')
+  expect(entry.status).toBe('done')
+  expect(entry.findings).toBe(1)
+})
+
+test('runHandoff warns when the tree changed after the review began', async () => {
+  await writeLocalRun()
+  await writeFile(join(repo, 'a.txt'), 'one\ntwo\nthree\n')
+  const exit = await runHandoff(runDir)
+  expect(exit).toBe(0)
+  expect(stdout).toContain(WARNING)
+})
+
+test('runHandoff warns after a same-size edit made in the same second as the last index write', async () => {
+  // b.txt matches the merge base, so git trusts the index alone to call it unchanged.
+  await sh(repo, 'git', 'checkout', '-q', 'main')
+  await writeFile(join(repo, 'b.txt'), 'bee\n')
+  await sh(repo, 'git', 'add', 'b.txt')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'add b')
+  await sh(repo, 'git', 'checkout', '-q', 'feat/x')
+  await sh(repo, 'git', 'rebase', '-q', 'main')
+  await writeLocalRun()
+  // Pinning b.txt and the index to one whole second reproduces the racy case
+  // without waiting on the clock; trustctime=false because ctime cannot be set.
+  await sh(repo, 'git', 'config', 'core.trustctime', 'false')
+  const second = new Date('2020-01-01T00:00:00Z')
+  await utimes(join(repo, 'b.txt'), second, second)
+  await sh(repo, 'git', 'update-index', '--refresh')
+  await writeFile(join(repo, 'b.txt'), 'bed\n')
+  await utimes(join(repo, 'b.txt'), second, second)
+  await utimes(join(repo, '.git', 'index'), second, second)
+  const exit = await runHandoff(runDir)
+  expect(exit).toBe(0)
+  expect(stdout).toContain(WARNING)
+})
+
+test('runHandoff names a detached HEAD in the target', async () => {
+  await writeLocalRun()
+  const meta = JSON.parse(await readFile(join(runDir, 'local.json'), 'utf8'))
+  await writeFile(join(runDir, 'local.json'), JSON.stringify({ ...meta, branch: null }))
+  await runHandoff(runDir)
+  expect(stdout).toContain('# magpie local review: detached HEAD against main')
+})
+
+test('runHandoff refuses a PR-mode run with exit 2', async () => {
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'pr', root: repo }))
+  const exit = await runHandoff(runDir)
+  expect(exit).toBe(2)
+  expect(stderr).toContain('magpie: handoff')
+})
+
+test('runHandoff returns 4 when findings.final.json is missing', async () => {
+  await writeLocalRun()
+  await rm(join(runDir, 'findings.final.json'))
+  expect(await runHandoff(runDir)).toBe(4)
+})
+
+test('runHandoff returns 4 when local.json is missing', async () => {
+  await writeLocalRun()
+  await rm(join(runDir, 'local.json'))
+  expect(await runHandoff(runDir)).toBe(4)
+})
+
+test('runHandoff reports a failed recompute as stale', async () => {
+  await writeLocalRun()
+  const meta = JSON.parse(await readFile(join(runDir, 'local.json'), 'utf8'))
+  await writeFile(join(runDir, 'local.json'), JSON.stringify({ ...meta, baseRef: 'no-such-ref' }))
+  expect(await runHandoff(runDir)).toBe(0)
+  expect(stdout).toContain(WARNING)
+})
+
+test('runHandoff reports a diff-source.json without diffSha256 as stale', async () => {
+  await writeLocalRun()
+  const source = JSON.parse(await readFile(join(runDir, 'diff-source.json'), 'utf8'))
+  delete source.diffSha256
+  await writeFile(join(runDir, 'diff-source.json'), JSON.stringify(source))
+  expect(await runHandoff(runDir)).toBe(0)
+  expect(stdout).toContain(WARNING)
+})
+
+test('runHandoff still prints, stale, when the review root is gone', async () => {
+  await writeLocalRun()
+  const gone = await mkdtemp(join(tmpdir(), 'magpie-handoff-gone-'))
+  await rm(gone, { recursive: true, force: true })
+  await writeFile(join(runDir, 'target.json'), JSON.stringify({ mode: 'local', root: gone }))
+  expect(await runHandoff(runDir)).toBe(0)
+  expect(stdout).toContain(WARNING)
+  expect(stderr).toContain('magpie: handoff: could not recompute the diff: ')
+})

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

@@ -23,6 +23,20 @@ test('listRuns picks up active and archived runs', async () => {
   expect(ids).toEqual(['pr-1-100', 'pr-2-200.archived-300'])
 })
 
+test('listRuns picks up active and archived local runs, including dotted and dashed slugs', async () => {
+  await mkdir(join(home, 'local-feature-x-100'))
+  await mkdir(join(home, 'local-release-1.2_fix-200.archived-300'))
+  await mkdir(join(home, 'local-detached-400'))
+  await mkdir(join(home, 'local--500'))
+  const runs = await listRuns(home)
+  const byId = Object.fromEntries(runs.map((r) => [r.id, r.archived]))
+  expect(byId).toEqual({
+    'local-feature-x-100': false,
+    'local-release-1.2_fix-200.archived-300': true,
+    'local-detached-400': false,
+  })
+})
+
 test('cleanupRun deletes the matching directory', async () => {
   await mkdir(join(home, 'pr-1-100'))
   const exit = await cleanupRun(home, 'pr-1-100')

package/skills/magpie/scripts/__tests__/local-diff.test.ts

@@ -0,0 +1,275 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import { mkdir, mkdtemp, readFile, rm, stat, utimes, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { diffSha256, localBranchDiff, localBranchMeta } from '../local-diff.ts'
+
+let repo: string
+
+async function sh(cwd: string, ...cmd: string[]): Promise<string> {
+  const proc = Bun.spawn(cmd, { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const out = await new Response(proc.stdout).text()
+  const exit = await proc.exited
+  if (exit !== 0) {
+    const err = await new Response(proc.stderr).text()
+    throw new Error(`${cmd.join(' ')} exit ${exit}: ${err}`)
+  }
+  return out
+}
+
+beforeEach(async () => {
+  repo = await mkdtemp(join(tmpdir(), 'magpie-local-diff-'))
+  await sh(repo, 'git', 'init', '-q', '-b', 'main')
+  await sh(repo, 'git', 'config', 'user.email', 't@t.t')
+  await sh(repo, 'git', 'config', 'user.name', 'Tess Tester')
+  await sh(repo, 'git', 'config', 'commit.gpgsign', 'false')
+  await writeFile(join(repo, 'a.txt'), 'one\n')
+  await writeFile(join(repo, 'b.txt'), 'bee\n')
+  await writeFile(join(repo, '.gitignore'), 'ignored.log\n')
+  await sh(repo, 'git', 'add', '.')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'init')
+})
+
+afterEach(async () => {
+  await rm(repo, { recursive: true, force: true })
+})
+
+async function makeFeatureBranch(): Promise<void> {
+  await sh(repo, 'git', 'checkout', '-q', '-b', 'feat/x')
+  await writeFile(join(repo, 'a.txt'), 'one\ntwo\n')
+  await sh(repo, 'git', 'commit', '-q', '-am', 'add two', '-m', 'because two beats one')
+  await writeFile(join(repo, 'b.txt'), 'bee\nsting\n')
+  await writeFile(join(repo, 'new.txt'), 'fresh\n')
+}
+
+test('localBranchDiff includes committed, uncommitted and untracked changes', async () => {
+  await makeFeatureBranch()
+  const mainSha = (await sh(repo, 'git', 'rev-parse', 'main')).trim()
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!r.ok) throw new Error(r.error)
+  expect(r.diff).toContain('diff --git a/a.txt b/a.txt')
+  expect(r.diff).toContain('+two')
+  expect(r.diff).toContain('diff --git a/b.txt b/b.txt')
+  expect(r.diff).toContain('+sting')
+  expect(r.diff).toContain('new file mode')
+  expect(r.diff).toContain('+++ b/new.txt')
+  expect(r.mergeBase).toBe(mainSha)
+  expect(r.baseRef).toBe('main')
+  expect(r.head).toBe((await sh(repo, 'git', 'rev-parse', 'HEAD')).trim())
+})
+
+test('localBranchDiff fails naming an unresolvable base ref', async () => {
+  await makeFeatureBranch()
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'nope' })
+  expect(r.ok).toBe(false)
+  if (!r.ok) expect(r.error).toContain('nope')
+})
+
+test('localBranchDiff defaults to origin/HEAD and fails naming it without a remote', async () => {
+  await makeFeatureBranch()
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo })
+  expect(r.ok).toBe(false)
+  if (!r.ok) expect(r.error).toContain('origin/HEAD')
+})
+
+test('localBranchDiff fails when the branch matches its base and the tree is clean', async () => {
+  await sh(repo, 'git', 'checkout', '-q', '-b', 'feat/x')
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  expect(r.ok).toBe(false)
+  if (!r.ok) expect(r.error).toContain('nothing to review against main')
+})
+
+test('localBranchDiff leaves gitignored files out', async () => {
+  await makeFeatureBranch()
+  await writeFile(join(repo, 'ignored.log'), 'noise\n')
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!r.ok) throw new Error(r.error)
+  expect(r.diff).not.toContain('ignored.log')
+})
+
+test('localBranchDiff leaves the index and working tree untouched', async () => {
+  await makeFeatureBranch()
+  const statusBefore = await sh(repo, 'git', 'status', '--porcelain')
+  const cachedBefore = await sh(repo, 'git', 'diff', '--cached')
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  expect(r.ok).toBe(true)
+  expect(await sh(repo, 'git', 'status', '--porcelain')).toBe(statusBefore)
+  expect(await sh(repo, 'git', 'diff', '--cached')).toBe(cachedBefore)
+  expect(statusBefore).toBe(' M b.txt\n?? new.txt\n')
+})
+
+async function metaFor(intentFile: string | null) {
+  const d = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!d.ok) throw new Error(d.error)
+  return localBranchMeta({
+    gitBin: 'git',
+    repoPath: repo,
+    baseRef: d.baseRef,
+    mergeBase: d.mergeBase,
+    head: d.head,
+    intentFile,
+  })
+}
+
+test('localBranchMeta describes the branch, dirtiness, author and commits', async () => {
+  await makeFeatureBranch()
+  const r = await metaFor('/tmp/intent.md')
+  if (!r.ok) throw new Error(r.error)
+  expect(r.meta.branch).toBe('feat/x')
+  expect(r.meta.dirty).toBe(true)
+  expect(r.meta.author).toBe('Tess Tester')
+  expect(r.meta.intentFile).toBe('/tmp/intent.md')
+  expect(r.meta.commits).toHaveLength(1)
+  expect(r.meta.commits[0]?.headline).toBe('add two')
+  expect(r.meta.commits[0]?.body).toBe('because two beats one')
+  expect(r.meta.commits[0]?.oid).toBe((await sh(repo, 'git', 'rev-parse', 'HEAD')).trim())
+})
+
+test('localBranchMeta reports a null branch on a detached HEAD', async () => {
+  await makeFeatureBranch()
+  await sh(repo, 'git', 'checkout', '-q', '--detach')
+  const r = await metaFor(null)
+  if (!r.ok) throw new Error(r.error)
+  expect(r.meta.branch).toBeNull()
+})
+
+test('localBranchMeta fails naming user.name when it is unset', async () => {
+  await makeFeatureBranch()
+  const d = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!d.ok) throw new Error(d.error)
+  await sh(repo, 'git', 'config', '--unset', 'user.name')
+  const saved = {
+    GIT_CONFIG_GLOBAL: process.env.GIT_CONFIG_GLOBAL,
+    GIT_CONFIG_SYSTEM: process.env.GIT_CONFIG_SYSTEM,
+    HOME: process.env.HOME,
+  }
+  process.env.GIT_CONFIG_GLOBAL = '/dev/null'
+  process.env.GIT_CONFIG_SYSTEM = '/dev/null'
+  process.env.HOME = repo
+  try {
+    const r = await localBranchMeta({
+      gitBin: 'git',
+      repoPath: repo,
+      baseRef: d.baseRef,
+      mergeBase: d.mergeBase,
+      head: d.head,
+      intentFile: null,
+    })
+    expect(r.ok).toBe(false)
+    if (!r.ok) expect(r.error).toContain('user.name')
+  } finally {
+    for (const [k, v] of Object.entries(saved)) {
+      if (v === undefined) delete process.env[k]
+      else process.env[k] = v
+    }
+  }
+})
+
+test('localBranchDiff keeps a/ b/ headers and real content despite user diff config', async () => {
+  await makeFeatureBranch()
+  await sh(repo, 'git', 'config', 'diff.noprefix', 'true')
+  await sh(repo, 'git', 'config', 'diff.external', '/usr/bin/true')
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!r.ok) throw new Error(r.error)
+  expect(r.diff).toContain('diff --git a/a.txt b/a.txt')
+  expect(r.diff).toContain('+two')
+  expect(r.diff).toContain('diff --git a/new.txt b/new.txt')
+  expect(r.diff).toContain('+fresh')
+})
+
+test('localBranchDiff and localBranchMeta leave .git/index unwritten', async () => {
+  await makeFeatureBranch()
+  const future = new Date(Date.now() + 60_000)
+  await utimes(join(repo, 'a.txt'), future, future)
+  const indexPath = join(repo, '.git', 'index')
+  const past = new Date(Date.now() - 3_600_000)
+  await utimes(indexPath, past, past)
+  const before = await stat(indexPath)
+  const bytesBefore = await readFile(indexPath)
+  const d = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!d.ok) throw new Error(d.error)
+  const m = await localBranchMeta({
+    gitBin: 'git',
+    repoPath: repo,
+    baseRef: d.baseRef,
+    mergeBase: d.mergeBase,
+    head: d.head,
+    intentFile: null,
+  })
+  expect(m.ok).toBe(true)
+  expect((await stat(indexPath)).mtimeMs).toBe(before.mtimeMs)
+  expect(Buffer.compare(await readFile(indexPath), bytesBefore)).toBe(0)
+})
+
+test('localBranchDiff leaves .git/index unwritten when a tracked file is only stat-dirty', async () => {
+  await makeFeatureBranch()
+  const y2030 = new Date('2030-01-01T00:00:00Z')
+  // .gitignore is unchanged since the merge base, so only its stat info moves.
+  await utimes(join(repo, '.gitignore'), y2030, y2030)
+  const indexPath = join(repo, '.git', 'index')
+  const past = new Date(Date.now() - 3_600_000)
+  await utimes(indexPath, past, past)
+  const before = await stat(indexPath)
+  const bytesBefore = await readFile(indexPath)
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  expect(r.ok).toBe(true)
+  expect((await stat(indexPath)).mtimeMs).toBe(before.mtimeMs)
+  expect(Buffer.compare(await readFile(indexPath), bytesBefore)).toBe(0)
+})
+
+test('localBranchDiff includes a same-size edit made in the same second as the last index write', async () => {
+  // Pinning a.txt and the index to one whole second reproduces the racy case
+  // without waiting on the clock; trustctime=false because ctime cannot be set.
+  await sh(repo, 'git', 'config', 'core.trustctime', 'false')
+  const second = new Date('2020-01-01T00:00:00Z')
+  await utimes(join(repo, 'a.txt'), second, second)
+  await sh(repo, 'git', 'update-index', '--refresh')
+  await writeFile(join(repo, 'a.txt'), 'two\n')
+  await utimes(join(repo, 'a.txt'), second, second)
+  await utimes(join(repo, '.git', 'index'), second, second)
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!r.ok) throw new Error(r.error)
+  expect(r.diff).toContain('-one')
+  expect(r.diff).toContain('+two')
+})
+
+test('localBranchDiff writes non-ASCII paths unquoted', async () => {
+  await writeFile(join(repo, 'naïve.txt'), 'old\n')
+  await sh(repo, 'git', 'add', 'naïve.txt')
+  await sh(repo, 'git', 'commit', '-q', '-m', 'add naive')
+  await makeFeatureBranch()
+  await writeFile(join(repo, 'naïve.txt'), 'new\n')
+  await writeFile(join(repo, 'café.txt'), 'latte\n')
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!r.ok) throw new Error(r.error)
+  expect(r.diff).toContain('diff --git a/café.txt b/café.txt')
+  expect(r.diff).toContain('diff --git a/naïve.txt b/naïve.txt')
+})
+
+test('localBranchMeta lists commits up to the given head, not HEAD', async () => {
+  await makeFeatureBranch()
+  const d = await localBranchDiff({ gitBin: 'git', repoPath: repo, baseRef: 'main' })
+  if (!d.ok) throw new Error(d.error)
+  const r = await localBranchMeta({
+    gitBin: 'git',
+    repoPath: repo,
+    baseRef: d.baseRef,
+    mergeBase: d.mergeBase,
+    head: d.mergeBase,
+    intentFile: null,
+  })
+  if (!r.ok) throw new Error(r.error)
+  expect(r.meta.commits).toEqual([])
+})
+
+test('localBranchDiff refuses a repoPath that is not the repository root', async () => {
+  await makeFeatureBranch()
+  await mkdir(join(repo, 'sub'))
+  const r = await localBranchDiff({ gitBin: 'git', repoPath: join(repo, 'sub'), baseRef: 'main' })
+  expect(r.ok).toBe(false)
+  if (!r.ok) expect(r.error).toContain(join(repo, 'sub'))
+})
+
+test('diffSha256 hashes the UTF-8 bytes as lowercase hex', () => {
+  expect(diffSha256('abc')).toBe('ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad')
+})

package/skills/magpie/scripts/__tests__/pipeline-e2e.test.ts

@@ -41,6 +41,7 @@ afterEach(async () => {
 
 test('setup -> dedupe -> render(progress) -> render(findings) -> cleanup composes', async () => {
   const setupExit = await runSetup({
+    mode: 'pr',
     runDir,
     prNumber: 1234,
     repoPath: repo,

package/skills/magpie/scripts/__tests__/resolve-run.test.ts

@@ -32,6 +32,34 @@ test('resolveRunDir returns the latest run when no id given', async () => {
   expect(r.archived).toBe(false)
 })
 
+test('resolveRunDir skips a newer archived local run when no id given', async () => {
+  await makeRun('pr-1-1000.archived-2000', 0)
+  await new Promise((r) => setTimeout(r, 20))
+  await makeRun('local-release-1.2-rc-2000.archived-3000', 0)
+  const r = await resolveRunDir(undefined, home)
+  expect(r).toEqual({
+    id: 'pr-1-1000.archived-2000',
+    path: join(home, 'pr-1-1000.archived-2000'),
+    archived: true,
+  })
+})
+
+test('resolveRunDir rejects an explicit local run id', async () => {
+  await makeRun('local-feature-x-2000.archived-3000', 0)
+  await expect(resolveRunDir('local-feature-x-2000.archived-3000', home)).rejects.toThrow(
+    'local-feature-x-2000.archived-3000 is a local run; local runs have no report',
+  )
+})
+
+test('resolveRunDir rejects a path to a run whose target is local', async () => {
+  await makeRun('custom-run', 0)
+  const path = join(home, 'custom-run')
+  await Bun.write(join(path, 'target.json'), JSON.stringify({ mode: 'local', root: '/repo' }))
+  await expect(resolveRunDir(path, home)).rejects.toThrow(
+    `${path} is a local run; local runs have no report`,
+  )
+})
+
 test('resolveRunDir picks an archived run as latest if it is newest', async () => {
   await makeRun('pr-1-1000', 0)
   await new Promise((r) => setTimeout(r, 20))