@iceinvein/agent-skills 0.1.40 → 0.3.0

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

@@ -122,3 +122,190 @@ test('runDedupe with threshold 0 keeps everything', async () => {
   const kept = JSON.parse(await readFile(join(runDir, 'findings.deduped.json'), 'utf8'))
   expect(kept).toHaveLength(1)
 })
+
+test('runDedupe collects sharded focus files', async () => {
+  await writeFile(
+    join(runDir, 'findings', 'security.shard-1.json'),
+    JSON.stringify([f('security-1', 'a.ts', 10, 'hardcoded token in the client', 'security')]),
+  )
+  await writeFile(
+    join(runDir, 'findings', 'security.shard-2.json'),
+    JSON.stringify([f('security-1', 'z.ts', 99, 'missing auth check on the handler', 'security')]),
+  )
+  const exit = await runDedupe(runDir, { threshold: 0 })
+  expect(exit).toBe(0)
+  const out = JSON.parse(await readFile(join(runDir, 'findings.deduped.json'), 'utf8'))
+  expect(out).toHaveLength(2)
+  const ids = out.map((x: { id: string }) => x.id).sort()
+  expect(ids).toEqual(['security-s1-1', 'security-s2-1'])
+})
+
+test('runDedupe leaves unsharded ids untouched', async () => {
+  await writeFile(
+    join(runDir, 'findings', 'bugs.json'),
+    JSON.stringify([f('bugs-1', 'a.ts', 10, 'off by one in the loop bound', 'bugs')]),
+  )
+  const exit = await runDedupe(runDir, { threshold: 0 })
+  expect(exit).toBe(0)
+  const out = JSON.parse(await readFile(join(runDir, 'findings.deduped.json'), 'utf8'))
+  expect(out[0]?.id).toBe('bugs-1')
+})
+
+const LLM_FOCUSES = ['security', 'bugs', 'performance', 'code-smells', 'architecture'] as const
+
+/** A manifest with `count` shards, shaped like the one `shardDiff` writes. */
+async function writeManifest(count: number): Promise<void> {
+  await mkdir(join(runDir, 'shards'), { recursive: true })
+  const shards = Array.from({ length: count }, (_, i) => ({
+    id: i + 1,
+    path: count === 1 ? 'diff.patch' : `shards/shard-${i + 1}.patch`,
+    files: [`src/f${i + 1}.ts`],
+    lines: 10,
+  }))
+  await writeFile(
+    join(runDir, 'shards', 'manifest.json'),
+    JSON.stringify({
+      budget: 6000,
+      maxFiles: 80,
+      totalFiles: count,
+      totalLines: 10 * count,
+      shards,
+    }),
+  )
+}
+
+/** Run dedupe with stdout captured, the way a human at the terminal sees it. */
+async function dedupeCapturingStdout(): Promise<{ exit: number; stdout: string }> {
+  const out: string[] = []
+  const origWrite = process.stdout.write.bind(process.stdout)
+  process.stdout.write = ((s: string) => {
+    out.push(s)
+    return true
+  }) as typeof process.stdout.write
+  try {
+    const exit = await runDedupe(runDir, { threshold: 0 })
+    return { exit, stdout: out.join('') }
+  } finally {
+    process.stdout.write = origWrite
+  }
+}
+
+async function dedupeLogEntry(status: string): Promise<Record<string, unknown> | undefined> {
+  const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+  return log
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => JSON.parse(l) as Record<string, unknown>)
+    .find((e) => e.stage === 'dedupe' && e.status === status)
+}
+
+test('runDedupe reports nothing missing when every (focus, shard) file is present', async () => {
+  await writeManifest(3)
+  for (const focus of LLM_FOCUSES) {
+    for (const shard of [1, 2, 3]) {
+      await writeFile(
+        join(runDir, 'findings', `${focus}.shard-${shard}.json`),
+        JSON.stringify([f(`${focus}-1`, `s${shard}.ts`, 1, `${focus} on shard ${shard}`, focus)]),
+      )
+    }
+  }
+  // Setup writes tests.json once for the whole run, never per shard.
+  await writeFile(join(runDir, 'findings', 'tests.json'), JSON.stringify([]))
+  const { exit, stdout } = await dedupeCapturingStdout()
+  expect(exit).toBe(0)
+  expect(stdout).not.toContain('missing')
+  expect(stdout).toContain('15')
+  const done = await dedupeLogEntry('done')
+  expect(done?.coverage).toEqual({ expected: 15, missing: [] })
+})
+
+test('runDedupe names the (focus, shard) pairs that have no findings file', async () => {
+  await writeManifest(2)
+  for (const focus of LLM_FOCUSES) {
+    await writeFile(
+      join(runDir, 'findings', `${focus}.shard-1.json`),
+      JSON.stringify([f(`${focus}-1`, 'a.ts', 1, `${focus} on shard 1`, focus)]),
+    )
+  }
+  // Shard 2 lost security and bugs: two of ten agents never wrote a file.
+  for (const focus of ['performance', 'code-smells', 'architecture']) {
+    await writeFile(
+      join(runDir, 'findings', `${focus}.shard-2.json`),
+      JSON.stringify([f(`${focus}-1`, 'b.ts', 2, `${focus} on shard 2`, focus)]),
+    )
+  }
+  const { exit, stdout } = await dedupeCapturingStdout()
+  expect(exit).toBe(0)
+  expect(stdout).toContain('missing')
+  expect(stdout).toContain('security.shard-2.json')
+  expect(stdout).toContain('bugs.shard-2.json')
+  const done = await dedupeLogEntry('done')
+  expect(done?.coverage).toEqual({
+    expected: 10,
+    missing: ['security.shard-2.json', 'bugs.shard-2.json'],
+  })
+})
+
+test('a single-shard manifest expects the unsharded findings filenames', async () => {
+  await writeManifest(1)
+  for (const focus of ['security', 'bugs', 'performance', 'code-smells']) {
+    await writeFile(
+      join(runDir, 'findings', `${focus}.json`),
+      JSON.stringify([f(`${focus}-1`, 'a.ts', 1, `${focus} finding here`, focus)]),
+    )
+  }
+  const { stdout } = await dedupeCapturingStdout()
+  // Stage 4 takes the unsharded path on a single-shard run, so the expected name
+  // has no shard suffix.
+  expect(stdout).toContain('architecture.json')
+  const done = await dedupeLogEntry('done')
+  expect(done?.coverage).toEqual({ expected: 5, missing: ['architecture.json'] })
+})
+
+test('runDedupe without a manifest reports no coverage at all', async () => {
+  await writeFile(
+    join(runDir, 'findings', 'bugs.json'),
+    JSON.stringify([f('bugs-1', 'a.ts', 10, 'off by one in the loop bound', 'bugs')]),
+  )
+  const { exit, stdout } = await dedupeCapturingStdout()
+  expect(exit).toBe(0)
+  // A run predating the sharder has nothing to reconcile against; behaviour is
+  // exactly as before.
+  expect(stdout).toBe('')
+  const done = await dedupeLogEntry('done')
+  expect(done).toBeDefined()
+  expect(done?.coverage).toBeUndefined()
+})
+
+test('a zero-shard manifest expects nothing (the diff filtered down to nothing)', async () => {
+  await writeManifest(0)
+  const { exit, stdout } = await dedupeCapturingStdout()
+  expect(exit).toBe(0)
+  expect(stdout).toBe('')
+  const done = await dedupeLogEntry('done')
+  expect(done?.coverage).toBeUndefined()
+})
+
+test('a malformed shards/manifest.json is treated as no manifest', async () => {
+  await mkdir(join(runDir, 'shards'), { recursive: true })
+  await writeFile(join(runDir, 'shards', 'manifest.json'), '{ not json')
+  const { exit, stdout } = await dedupeCapturingStdout()
+  expect(exit).toBe(0)
+  expect(stdout).toBe('')
+  const done = await dedupeLogEntry('done')
+  expect(done?.coverage).toBeUndefined()
+})
+
+test('runDedupe still skips files it cannot map to a focus', async () => {
+  await writeFile(join(runDir, 'findings', 'nonsense.json'), JSON.stringify([]))
+  await writeFile(join(runDir, 'findings', 'security.shard-x.json'), JSON.stringify([]))
+  const exit = await runDedupe(runDir)
+  expect(exit).toBe(0)
+  const log = await readFile(join(runDir, 'log.jsonl'), 'utf8')
+  const skips = log
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => JSON.parse(l))
+    .filter((e) => e.status === 'skip' && e.reason === 'unknown-focus')
+  expect(skips.map((s) => s.file).sort()).toEqual(['nonsense.json', 'security.shard-x.json'])
+})

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

@@ -0,0 +1,51 @@
+import { expect, test } from 'bun:test'
+import { chunkPath, splitFileChunks, splitRawChunks } from '../diff-chunks.ts'
+
+/** A file chunk with `bodyLines` added lines, shaped like a real patch. */
+function chunk(path: string, bodyLines: number): string {
+  const body = Array.from({ length: bodyLines }, (_, i) => `+line ${i}`).join('\n')
+  return [
+    `diff --git a/${path} b/${path}`,
+    'index 0000000..1111111 100644',
+    `--- a/${path}`,
+    `+++ b/${path}`,
+    `@@ -0,0 +1,${bodyLines} @@`,
+    body,
+    '',
+  ].join('\n')
+}
+
+test('splitFileChunks finds one chunk per file with its path and line count', () => {
+  const diff = chunk('src/a.ts', 3) + chunk('src/b.ts', 5)
+  const chunks = splitFileChunks(diff)
+  expect(chunks.map((c) => c.path)).toEqual(['src/a.ts', 'src/b.ts'])
+  expect(chunks[0]?.lines).toBeGreaterThan(3)
+  expect(chunks[0]?.text).toContain('diff --git a/src/a.ts')
+})
+
+test('splitFileChunks returns nothing for an empty diff', () => {
+  expect(splitFileChunks('')).toEqual([])
+  expect(splitFileChunks('\n\n')).toEqual([])
+})
+
+test('splitRawChunks keeps a leading preamble as its own element', () => {
+  const diff = `some preamble text\n${chunk('src/a.ts', 2)}`
+  const raw = splitRawChunks(diff)
+  expect(raw[0]).toBe('some preamble text\n')
+  expect(raw[1]?.startsWith('diff --git ')).toBe(true)
+})
+
+test('chunkPath prefers the b-side path when a rename changes it', () => {
+  const rename = [
+    'diff --git a/old/name.ts b/new/name.ts',
+    'similarity index 100%',
+    'rename from old/name.ts',
+    'rename to new/name.ts',
+    '',
+  ].join('\n')
+  expect(chunkPath(rename)).toBe('new/name.ts')
+})
+
+test('chunkPath returns null when the header cannot be parsed', () => {
+  expect(chunkPath('not a diff header at all')).toBeNull()
+})

package/skills/magpie/scripts/__tests__/filter-diff-preservation.test.ts

@@ -0,0 +1,54 @@
+import { expect, test } from 'bun:test'
+import { filterDiff } from '../path-filter.ts'
+
+// filterDiff's refactor onto the shared diff-chunks module (scripts/diff-chunks.ts)
+// must preserve two branches that scripts/__tests__/path-filter.test.ts's DIFF
+// fixture never exercises, because that fixture always starts with a well-formed
+// `diff --git a/... b/...` header:
+//
+//   1. a leading non-`diff --git` preamble chunk is kept in `filtered`
+//   2. a chunk whose header cannot be parsed is kept in `filtered`
+//
+// These tests assert directly on filterDiff's output for both, so a future edit
+// to diff-chunks.ts that breaks either preservation is caught here rather than
+// resting on a manual code trace.
+
+const VALID_CHUNK = [
+  'diff --git a/src/a.ts b/src/a.ts',
+  'index 1..2 100644',
+  '--- a/src/a.ts',
+  '+++ b/src/a.ts',
+  '@@ -1 +1 @@',
+  '-x',
+  '+y',
+  '',
+].join('\n')
+
+test('filterDiff keeps a leading preamble that appears before the first file header', () => {
+  const preamble = 'Note: this diff was truncated by the transport layer\n'
+  const diff = preamble + VALID_CHUNK
+  const { filtered } = filterDiff(diff, { exclude: [], include: [], useDefaults: false })
+  expect(filtered).toContain('Note: this diff was truncated by the transport layer')
+})
+
+test('filterDiff keeps a chunk whose diff --git header cannot be parsed', () => {
+  // No " b/" separator after the a-side path, so FILE_HEADER cannot match and
+  // chunkPath returns null; filterDiff must keep the chunk rather than drop it.
+  const malformed = [
+    'diff --git a/foo.ts b-badformat',
+    'index 1234567..89abcde 100644',
+    '--- a/foo.ts',
+    '+++ b-badformat',
+    '@@ -1 +1 @@',
+    '-x',
+    '+y',
+    '',
+  ].join('\n')
+  const { filtered, excluded } = filterDiff(malformed, {
+    exclude: ['**/*'],
+    include: [],
+    useDefaults: false,
+  })
+  expect(filtered).toContain('b-badformat')
+  expect(excluded).toEqual([])
+})

package/skills/magpie/scripts/__tests__/findings-files.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from 'bun:test'
+import { namespaceId, parseFindingsFilename } from '../findings-files.ts'
+
+test('parseFindingsFilename reads an unsharded focus file', () => {
+  expect(parseFindingsFilename('security.json')).toEqual({ focus: 'security', shard: null })
+  expect(parseFindingsFilename('code-smells.json')).toEqual({ focus: 'code-smells', shard: null })
+})
+
+test('parseFindingsFilename reads a sharded focus file', () => {
+  expect(parseFindingsFilename('security.shard-2.json')).toEqual({ focus: 'security', shard: 2 })
+  expect(parseFindingsFilename('architecture.shard-11.json')).toEqual({
+    focus: 'architecture',
+    shard: 11,
+  })
+})
+
+test('parseFindingsFilename rejects names it cannot read', () => {
+  expect(parseFindingsFilename('notes.txt')).toBeNull()
+  expect(parseFindingsFilename('security.shard-x.json')).toBeNull()
+  expect(parseFindingsFilename('security.shard-2.extra.json')).toBeNull()
+  expect(parseFindingsFilename('.json')).toBeNull()
+})
+
+test('namespaceId leaves unsharded ids alone', () => {
+  expect(namespaceId('security-1', 'security', null)).toBe('security-1')
+})
+
+test('namespaceId inserts the shard tag after the focus prefix', () => {
+  expect(namespaceId('security-1', 'security', 2)).toBe('security-s2-1')
+  expect(namespaceId('code-smells-7', 'code-smells', 3)).toBe('code-smells-s3-7')
+})
+
+test('namespaceId prefixes ids that do not carry the focus', () => {
+  expect(namespaceId('finding-1', 'security', 2)).toBe('s2-finding-1')
+})

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

@@ -3,10 +3,13 @@ import { mkdtemp, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { fetchPr } from '../gh.ts'
+import { createGitFixtureRepo } from './helpers/git-fixture.ts'
 
 const FAKE_GH = new URL('../../fixtures/fake-gh.sh', import.meta.url).pathname
+const FAKE_GH_NODIFF = new URL('../../fixtures/fake-gh-nodiff.sh', import.meta.url).pathname
 
 let runDir: string
+let repo = ''
 
 beforeEach(async () => {
   runDir = await mkdtemp(join(tmpdir(), 'magpie-gh-'))
@@ -14,6 +17,10 @@ beforeEach(async () => {
 
 afterEach(async () => {
   await rm(runDir, { recursive: true, force: true })
+  if (repo) {
+    await rm(repo, { recursive: true, force: true })
+    repo = ''
+  }
 })
 
 test('fetchPr writes pr.json and diff.patch', async () => {
@@ -66,3 +73,65 @@ test('fetchPr carries commits and linked issues into pr.json', async () => {
   expect(Array.isArray(pr.closingIssuesReferences)).toBe(true)
   expect(pr.closingIssuesReferences[0]).toMatchObject({ number: 42 })
 })
+
+test('fetchPr falls back to local git when gh pr diff fails', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await fetchPr({
+    ghBin: FAKE_GH_NODIFF,
+    gitBin: 'git',
+    prNumber: 7,
+    runDir,
+    cwd: repo,
+    env: { MAGPIE_FAKE_HEAD_OID: head },
+  })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.source).toBe('git')
+  expect(result.mergeBase).toMatch(/^[0-9a-f]{40}$/)
+  const diff = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(diff).toContain('export const x = 2')
+})
+
+test('fetchPr falls back when gh returns an empty diff for a non-empty PR', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await fetchPr({
+    ghBin: FAKE_GH_NODIFF,
+    gitBin: 'git',
+    prNumber: 7,
+    runDir,
+    cwd: repo,
+    env: { MAGPIE_FAKE_HEAD_OID: head, MAGPIE_FAKE_DIFF_MODE: 'empty' },
+  })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.source).toBe('git')
+  const diff = await readFile(join(runDir, 'diff.patch'), 'utf8')
+  expect(diff).toContain('export const x = 2')
+})
+
+test('fetchPr reports source gh when gh succeeds', async () => {
+  const result = await fetchPr({ ghBin: FAKE_GH, prNumber: 1234, runDir })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.source).toBe('gh')
+  expect(result.mergeBase).toBeUndefined()
+})
+
+test('fetchPr fails when gh refuses and the head SHA is not local', async () => {
+  const { repoPath } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await fetchPr({
+    ghBin: FAKE_GH_NODIFF,
+    gitBin: 'git',
+    prNumber: 7,
+    runDir,
+    cwd: repo,
+    // No MAGPIE_FAKE_HEAD_OID, so pr.json carries a SHA this repo has never seen.
+  })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('cannot resolve PR head')
+  expect(result.error).toContain('406')
+})

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

@@ -0,0 +1,83 @@
+import { afterEach, expect, test } from 'bun:test'
+import { rm } from 'node:fs/promises'
+import { localPrDiff } from '../git-diff.ts'
+import { createGitFixtureRepo, git } from './helpers/git-fixture.ts'
+
+let repo = ''
+
+afterEach(async () => {
+  if (repo) {
+    await rm(repo, { recursive: true, force: true })
+    repo = ''
+  }
+})
+
+test('localPrDiff produces the three-dot diff from the merge base', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'main',
+    headRefOid: head,
+  })
+  expect(result.ok).toBe(true)
+  if (!result.ok) return
+  expect(result.diff).toContain('export const x = 2')
+  // b.ts landed on main after the branch point. A two-dot diff against the
+  // base tip would show it as a deletion; the three-dot diff must not.
+  expect(result.diff).not.toContain('b.ts')
+})
+
+test('localPrDiff errors when the head SHA is not present locally', async () => {
+  const { repoPath } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'main',
+    headRefOid: '0'.repeat(40),
+  })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('cannot resolve PR head')
+})
+
+test('localPrDiff errors when the base branch is not present locally', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'no-such-branch',
+    headRefOid: head,
+  })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('cannot resolve base branch')
+})
+
+test('localPrDiff errors when a stale refs/magpie/pr-<n> ref points at an older commit', async () => {
+  const { repoPath, head } = await createGitFixtureRepo()
+  repo = repoPath
+  // Simulate a previous run's fetch having landed an older commit under the
+  // PR ref, with no origin remote configured to refresh it from. head~1 is
+  // the pre-branch "base" commit: a valid, resolvable, genuinely older commit.
+  const staleSha = await git(repoPath, 'rev-parse', `${head}~1`)
+  await git(repoPath, 'update-ref', 'refs/magpie/pr-7', staleSha)
+  const result = await localPrDiff({
+    gitBin: 'git',
+    repoPath,
+    prNumber: 7,
+    baseRefName: 'main',
+    headRefOid: head,
+  })
+  expect(result.ok).toBe(false)
+  if (result.ok) return
+  expect(result.error).toContain('stale')
+  expect(result.error).toContain(staleSha)
+  expect(result.error).toContain(head)
+})

package/skills/magpie/scripts/__tests__/helpers/git-fixture.ts

@@ -0,0 +1,47 @@
+import { mkdtemp, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+/** Spawn `git` in `cwd` and return trimmed stdout, throwing on a non-zero exit. */
+export async function git(cwd: string, ...args: string[]): Promise<string> {
+  const proc = Bun.spawn(['git', ...args], { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const stdout = await new Response(proc.stdout).text()
+  const exit = await proc.exited
+  if (exit !== 0) {
+    const stderr = await new Response(proc.stderr).text()
+    throw new Error(`git ${args.join(' ')} exit ${exit}: ${stderr}`)
+  }
+  return stdout.trim()
+}
+
+export type GitFixtureRepo = {
+  repoPath: string
+  head: string
+  baseTip: string
+}
+
+/**
+ * A fresh repo with `main` and a `feature-x` branch one commit ahead, plus a
+ * commit on `main` after the branch point so a two-dot diff would differ
+ * from a three-dot one. Shared by gh.test.ts and git-diff.test.ts, which both
+ * exercise the local-git PR-diff fallback against a real clone.
+ */
+export async function createGitFixtureRepo(): Promise<GitFixtureRepo> {
+  const repoPath = await mkdtemp(join(tmpdir(), 'magpie-git-fixture-'))
+  await git(repoPath, 'init', '-b', 'main')
+  await git(repoPath, 'config', 'user.email', 'test@example.com')
+  await git(repoPath, 'config', 'user.name', 'Test')
+  await writeFile(join(repoPath, 'a.ts'), 'export const x = 1\n')
+  await git(repoPath, 'add', '.')
+  await git(repoPath, 'commit', '-m', 'base')
+  await git(repoPath, 'checkout', '-b', 'feature-x')
+  await writeFile(join(repoPath, 'a.ts'), 'export const x = 2\n')
+  await git(repoPath, 'commit', '-am', 'change x')
+  const head = await git(repoPath, 'rev-parse', 'HEAD')
+  await git(repoPath, 'checkout', 'main')
+  await writeFile(join(repoPath, 'b.ts'), 'export const y = 9\n')
+  await git(repoPath, 'add', '.')
+  await git(repoPath, 'commit', '-m', 'unrelated base commit')
+  const baseTip = await git(repoPath, 'rev-parse', 'HEAD')
+  return { repoPath, head, baseTip }
+}

package/skills/magpie/scripts/__tests__/path-filter.test.ts

@@ -159,3 +159,30 @@ test('filterDiff: include records not-in-include reason', () => {
   })
   expect(excluded.find((e) => e.path === 'bun.lock')?.pattern).toBe('not-in-include')
 })
+
+test('DEFAULT_EXCLUDES covers generated .NET sources', () => {
+  const generated = [
+    'src/Data/Migrations/20260801_AddUsers.Designer.cs',
+    'src/Data/Migrations/AppDbContextModelSnapshot.cs',
+    'src/Generated/Api.g.cs',
+    'src/Generated/Api.g.i.cs',
+    'src/Forms/MainForm.designer.vb',
+  ]
+  for (const path of generated) {
+    expect(matchesAny(path, DEFAULT_EXCLUDES)).not.toBeNull()
+  }
+})
+
+test('DEFAULT_EXCLUDES leaves hand-written C# and docs alone', () => {
+  // The migration itself is reviewable; only its generated designer is not.
+  const reviewable = [
+    'src/Data/Migrations/20260801_AddUsers.cs',
+    'src/Services/UserService.cs',
+    'docs/architecture.md',
+    'docs/work/notes.md',
+    'README.md',
+  ]
+  for (const path of reviewable) {
+    expect(matchesAny(path, DEFAULT_EXCLUDES)).toBeNull()
+  }
+})

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

@@ -192,3 +192,98 @@ test('issue entries with a missing, zero, or negative number are dropped, not de
   expect(html).not.toContain('https://example.test/issues/zero')
   expect(html).not.toContain('https://example.test/issues/negative')
 })
+
+test('progress sums specialist counts across shards', async () => {
+  await mkdir(join(runDir, 'shards'), { recursive: true })
+  await writeFile(
+    join(runDir, 'shards', 'manifest.json'),
+    JSON.stringify({
+      budget: 6000,
+      maxFiles: 80,
+      totalFiles: 2,
+      totalLines: 20,
+      shards: [
+        { id: 1, path: 'shards/shard-1.patch', files: ['a.ts'], lines: 10 },
+        { id: 2, path: 'shards/shard-2.patch', files: ['b.ts'], lines: 10 },
+      ],
+    }),
+  )
+  await writeFile(
+    join(runDir, 'log.jsonl'),
+    [
+      JSON.stringify({ stage: 'specialists', status: 'running' }),
+      JSON.stringify({
+        stage: 'specialist',
+        focus: 'security',
+        shard: 1,
+        status: 'done',
+        findings: 2,
+      }),
+      JSON.stringify({
+        stage: 'specialist',
+        focus: 'security',
+        shard: 2,
+        status: 'done',
+        findings: 3,
+      }),
+      JSON.stringify({ stage: 'specialist', focus: 'bugs', shard: 1, status: 'done', findings: 1 }),
+    ].join('\n'),
+  )
+  const exit = await runRender(runDir, 'progress')
+  expect(exit).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'progress.html'), 'utf8')
+  expect(html).toContain('Five reviewers across 2 shards')
+  // security is 2 + 3, not 3.
+  expect(html).toContain('security <span class="count">5</span>')
+})
+
+/** Log with the specialists stage in flight, which is the only state where the
+ *  shard count reaches the rendered wording. */
+async function specialistsRunning(): Promise<void> {
+  await writeFile(
+    join(runDir, 'log.jsonl'),
+    JSON.stringify({ stage: 'specialists', status: 'running' }),
+  )
+}
+
+test('a malformed shards/manifest.json degrades to the unsharded progress wording', async () => {
+  await mkdir(join(runDir, 'shards'), { recursive: true })
+  await writeFile(join(runDir, 'shards', 'manifest.json'), '{ "shards": [ truncated')
+  await specialistsRunning()
+  expect(await runRender(runDir, 'progress')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'progress.html'), 'utf8')
+  expect(html).toContain('Five reviewers reading the diff in parallel')
+  expect(html).not.toMatch(/across \S+ shards/)
+})
+
+test('a manifest with shards: [] renders the unsharded progress wording', async () => {
+  // A lockfile-only PR filters down to nothing, and shardDiff writes an
+  // otherwise-normal manifest with no shards. Zero must not read as "across 0
+  // shards"; stage 4 treats it as the unsharded path.
+  await mkdir(join(runDir, 'shards'), { recursive: true })
+  await writeFile(
+    join(runDir, 'shards', 'manifest.json'),
+    JSON.stringify({ budget: 6000, maxFiles: 80, totalFiles: 0, totalLines: 0, shards: [] }),
+  )
+  await specialistsRunning()
+  expect(await runRender(runDir, 'progress')).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'progress.html'), 'utf8')
+  expect(html).toContain('Five reviewers reading the diff in parallel')
+  expect(html).not.toContain('across 0 shards')
+  expect(html).not.toMatch(/across \S+ shards/)
+})
+
+test('progress re-dispatch of one shard replaces rather than doubles its count', async () => {
+  await writeFile(
+    join(runDir, 'log.jsonl'),
+    [
+      JSON.stringify({ stage: 'specialists', status: 'running' }),
+      JSON.stringify({ stage: 'specialist', focus: 'bugs', shard: 1, status: 'done', findings: 4 }),
+      JSON.stringify({ stage: 'specialist', focus: 'bugs', shard: 1, status: 'done', findings: 2 }),
+    ].join('\n'),
+  )
+  const exit = await runRender(runDir, 'progress')
+  expect(exit).toBe(0)
+  const html = await readFile(join(runDir, 'screen', 'progress.html'), 'utf8')
+  expect(html).toContain('bugs <span class="count">2</span>')
+})