@iceinvein/agent-skills 0.1.39 → 0.2.0

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

@@ -0,0 +1,111 @@
+export type LocalDiffInput = {
+  gitBin: string
+  repoPath: string
+  prNumber: number
+  baseRefName: string
+  headRefOid: string
+}
+
+export type LocalDiffResult =
+  | { ok: true; diff: string; mergeBase: string }
+  | { ok: false; error: string }
+
+async function git(
+  gitBin: string,
+  cwd: string,
+  args: string[],
+): Promise<{ exit: number; stdout: string; stderr: string }> {
+  const proc = Bun.spawn([gitBin, ...args], { cwd, stdout: 'pipe', stderr: 'pipe' })
+  const stdout = await new Response(proc.stdout).text()
+  const stderr = await new Response(proc.stderr).text()
+  const exit = await proc.exited
+  return { exit, stdout, stderr }
+}
+
+async function resolveCommit(gitBin: string, cwd: string, ref: string): Promise<string | null> {
+  const r = await git(gitBin, cwd, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`])
+  const sha = r.stdout.trim()
+  return r.exit === 0 && sha.length > 0 ? sha : null
+}
+
+/**
+ * Render a fetch's outcome for an error message, so a genuine failure (wrong
+ * remote, auth failure, rate limiting) can be told apart from a benign one
+ * (no origin, offline, non-GitHub remote) when resolution ends up failing.
+ * Empty when the fetch succeeded, since a successful fetch explains nothing.
+ */
+function fetchDiagnostic(result: { exit: number; stderr: string }): string {
+  if (result.exit === 0) return ''
+  const stderr = result.stderr.trim()
+  return stderr ? `; git fetch: ${stderr}` : `; git fetch exited ${result.exit}`
+}
+
+/**
+ * Reproduce `gh pr diff` from the local clone. GitHub refuses the `.diff` media
+ * type above roughly 300 files, and a review that cannot get a diff is worth
+ * less than one built from local objects.
+ *
+ * Diffs from the merge base rather than the base tip so the output matches
+ * `gh pr diff`'s three-dot semantics: the PR's own changes, not every commit
+ * the base branch gained since the branch point.
+ */
+export async function localPrDiff(input: LocalDiffInput): Promise<LocalDiffResult> {
+  const { gitBin, repoPath, prNumber, baseRefName, headRefOid } = input
+  const prRef = `refs/magpie/pr-${prNumber}`
+
+  // Best effort. `pull/<n>/head` is a GitHub convention and resolves fork PRs
+  // that `headRefName` cannot, but a repo with no `origin`, an offline run, or
+  // a non-GitHub remote must still work when the commits are already local.
+  // Each fetch's own result is kept (not discarded) so, if resolution below
+  // still fails, the error can say why the fetch didn't help.
+  const headFetch = await git(gitBin, repoPath, [
+    'fetch',
+    'origin',
+    `pull/${prNumber}/head:${prRef}`,
+  ])
+  const baseFetch = await git(gitBin, repoPath, ['fetch', 'origin', baseRefName])
+
+  let head: string | null = null
+  for (const ref of [prRef, headRefOid]) {
+    head = await resolveCommit(gitBin, repoPath, ref)
+    if (head) break
+  }
+  if (!head) {
+    return {
+      ok: false,
+      error: `cannot resolve PR head ${headRefOid} locally (tried ${prRef} and the SHA); fetch the PR branch and retry${fetchDiagnostic(headFetch)}`,
+    }
+  }
+  // Reviewing a stale local ref and reporting it as a review of the PR is worse
+  // than failing, so a mismatch is fatal rather than a warning.
+  if (head !== headRefOid) {
+    return {
+      ok: false,
+      error: `local PR head ${head} does not match the PR head ${headRefOid}; the local ref is stale`,
+    }
+  }
+
+  let base: string | null = null
+  for (const ref of [`origin/${baseRefName}`, baseRefName]) {
+    base = await resolveCommit(gitBin, repoPath, ref)
+    if (base) break
+  }
+  if (!base) {
+    return {
+      ok: false,
+      error: `cannot resolve base branch ${baseRefName} locally (tried origin/${baseRefName} and ${baseRefName})${fetchDiagnostic(baseFetch)}`,
+    }
+  }
+
+  const mb = await git(gitBin, repoPath, ['merge-base', base, head])
+  if (mb.exit !== 0) {
+    return { ok: false, error: `git merge-base exit ${mb.exit}: ${mb.stderr.trim()}` }
+  }
+  const mergeBase = mb.stdout.trim()
+
+  const d = await git(gitBin, repoPath, ['diff', '--no-color', '--find-renames', mergeBase, head])
+  if (d.exit !== 0) {
+    return { ok: false, error: `git diff exit ${d.exit}: ${d.stderr.trim()}` }
+  }
+  return { ok: true, diff: d.stdout, mergeBase }
+}

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

@@ -1,6 +1,7 @@
 import { existsSync } from 'node:fs'
 import { readFile } from 'node:fs/promises'
 import { join } from 'node:path'
+import { chunkPath, splitRawChunks } from './diff-chunks.ts'
 
 export type PathFilterConfig = {
   exclude: string[]
@@ -43,6 +44,12 @@ export const DEFAULT_EXCLUDES: readonly string[] = [
   '**/*.min.js',
   '**/*.min.css',
   '**/*.map',
+  // Generated .NET / C#
+  '**/*.Designer.cs',
+  '**/*ModelSnapshot.cs',
+  '**/*.g.cs',
+  '**/*.g.i.cs',
+  '**/*.designer.vb',
   // Snapshot fixtures
   '**/*.snap',
   '**/__snapshots__/**',
@@ -113,11 +120,9 @@ export async function loadPathFilterConfig(cwd: string): Promise<PathFilterConfi
 export type ExcludedFile = { path: string; pattern: string }
 export type FilterDiffResult = { filtered: string; excluded: ExcludedFile[] }
 
-const FILE_HEADER = /^diff --git a\/(.+?) b\/(.+?)$/m
-
 export function filterDiff(rawDiff: string, config: PathFilterConfig): FilterDiffResult {
   if (!rawDiff) return { filtered: '', excluded: [] }
-  const chunks = rawDiff.split(/^(?=diff --git )/m)
+  const chunks = splitRawChunks(rawDiff)
   const kept: string[] = []
   const excluded: ExcludedFile[] = []
   for (const chunk of chunks) {
@@ -125,8 +130,7 @@ export function filterDiff(rawDiff: string, config: PathFilterConfig): FilterDif
       if (chunk.trim()) kept.push(chunk)
       continue
     }
-    const m = chunk.match(FILE_HEADER)
-    const path = m?.[2] ?? m?.[1]
+    const path = chunkPath(chunk)
     if (!path) {
       kept.push(chunk)
       continue

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

@@ -4,7 +4,7 @@ import type { PostStatusMap } from './render-findings.ts'
 import { renderFindingsToDisk } from './render-findings.ts'
 import type { RenderProgressInput, StageId, StageStatus } from './render-progress.ts'
 import { renderProgressToDisk } from './render-progress.ts'
-import { parseFinding } from './types.ts'
+import { type PrBrief, parseBrief, parseFinding } from './types.ts'
 
 export type PreviewPage = 'findings' | 'progress' | 'both'
 
@@ -181,6 +181,7 @@ async function readFixture(fixtureDir: string): Promise<{
   postStatus: PostStatusMap
   files: Array<{ path: string; additions: number; deletions: number }>
   diff: string
+  brief: PrBrief | undefined
 }> {
   const prRaw = JSON.parse(await readFile(join(fixtureDir, 'pr.json'), 'utf8')) as Record<
     string,
@@ -214,6 +215,13 @@ async function readFixture(fixtureDir: string): Promise<{
   } catch {
     // optional file
   }
+  let brief: PrBrief | undefined
+  try {
+    const briefRaw = JSON.parse(await readFile(join(fixtureDir, 'brief.json'), 'utf8'))
+    brief = parseBrief(briefRaw) ?? undefined
+  } catch {
+    // optional file
+  }
   return {
     pr: {
       number: Number(prRaw.number ?? 0),
@@ -224,6 +232,7 @@ async function readFixture(fixtureDir: string): Promise<{
     postStatus: postStatusRaw as PostStatusMap,
     files: filesArray,
     diff,
+    brief,
   }
 }
 
@@ -270,6 +279,7 @@ export async function runPreview(opts: PreviewOptions): Promise<PreviewResult> {
         pr: fixture.pr,
         files: fixture.files,
         diff: fixture.diff,
+        brief: fixture.brief,
       },
       findingsPath,
     )

package/skills/magpie/scripts/refresh.ts

@@ -1,7 +1,7 @@
 import { readdir, readFile, unlink } from 'node:fs/promises'
 import { basename, join } from 'node:path'
-import { type PostStatusMap, renderFindingsToDisk } from './render-findings.ts'
-import { type PrFileEntry, parseFinding } from './types.ts'
+import { type PostStatusMap, parseClosingIssues, renderFindingsToDisk } from './render-findings.ts'
+import { type PrFileEntry, parseBrief, parseFinding } from './types.ts'
 
 export type RefreshResult = {
   refreshed: boolean
@@ -61,6 +61,7 @@ export async function refreshFindings(runDir: string): Promise<RefreshResult> {
 
   let pr: { number: number; branch: string; headSha: string } | undefined
   let files: PrFileEntry[] = []
+  let issues: ReturnType<typeof parseClosingIssues> = []
   try {
     const prJson = (await Bun.file(join(runDir, 'pr.json')).json()) as Record<string, unknown>
     const prNumber = Number(prJson.number ?? 0)
@@ -80,14 +81,42 @@ export async function refreshFindings(runDir: string): Promise<RefreshResult> {
         deletions: Number(entry.deletions ?? 0),
       }
     })
+    issues = parseClosingIssues(prJson)
   } catch {
     // optional file; archived runs may not include pr.json
   }
 
+  // Scout-produced summary. Same lenient-degrade contract as render-cmd.ts: a
+  // missing or malformed brief.json simply omits the header rather than
+  // failing the refresh (older archives predate the scout stage entirely).
+  let brief: ReturnType<typeof parseBrief> | undefined
+  try {
+    brief = parseBrief(await Bun.file(join(runDir, 'brief.json')).json())
+  } catch {
+    // optional file
+  }
+
   const diff = await readFile(join(runDir, 'diff.patch'), 'utf8').catch(() => '')
 
+  let diffSource: { source: 'gh' | 'git'; mergeBase: string | null } | undefined
+  try {
+    diffSource = (await Bun.file(join(runDir, 'diff-source.json')).json()) as typeof diffSource
+  } catch {
+    diffSource = undefined
+  }
+
   await renderFindingsToDisk(
-    { findings, postStatus, runId: basename(runDir), pr, files, diff },
+    {
+      findings,
+      postStatus,
+      runId: basename(runDir),
+      pr,
+      files,
+      diff,
+      brief: brief ?? undefined,
+      issues,
+      diffSource,
+    },
     join(screenDir, 'findings.html'),
   )
 

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

@@ -1,8 +1,8 @@
 import { readdir, readFile } from 'node:fs/promises'
 import { basename, join } from 'node:path'
-import { type PostStatusMap, renderFindingsToDisk } from './render-findings.ts'
+import { type PostStatusMap, parseClosingIssues, renderFindingsToDisk } from './render-findings.ts'
 import { renderProgressToDisk } from './render-progress.ts'
-import { parseFinding } from './types.ts'
+import { parseBrief, parseFinding } from './types.ts'
 
 async function nextVersionedPath(screenDir: string, base: string): Promise<string> {
   const entries: string[] = await readdir(screenDir).catch(() => [] as string[])
@@ -48,12 +48,15 @@ function summarizeStages(log: Array<Record<string, unknown>>): {
     report: 'pending',
     post: 'pending',
   }
-  const specialistCounts: Record<string, number> = {
-    security: 0,
-    bugs: 0,
-    performance: 0,
-    'code-smells': 0,
-    architecture: 0,
+  // focus -> shard key -> count. Keyed by shard so a re-dispatched (focus, shard)
+  // pair replaces its own count rather than doubling it, while distinct shards
+  // of the same focus add up.
+  const perShard: Record<string, Record<string, number>> = {
+    security: {},
+    bugs: {},
+    performance: {},
+    'code-smells': {},
+    architecture: {},
   }
   for (const entry of log) {
     const stage = entry.stage as string
@@ -63,11 +66,16 @@ function summarizeStages(log: Array<Record<string, unknown>>): {
     if (stage in stages && status === 'error') stages[stage] = 'error'
     if (stage in stages && status === 'skipped') stages[stage] = 'skipped'
     if (stage === 'specialist' && typeof entry.focus === 'string') {
-      if (entry.focus in specialistCounts && typeof entry.findings === 'number') {
-        specialistCounts[entry.focus] = entry.findings
+      const bucket = perShard[entry.focus]
+      if (bucket && typeof entry.findings === 'number') {
+        bucket[String(entry.shard ?? 'all')] = entry.findings
       }
     }
   }
+  const specialistCounts: Record<string, number> = {}
+  for (const [focus, bucket] of Object.entries(perShard)) {
+    specialistCounts[focus] = Object.values(bucket).reduce((a, b) => a + b, 0)
+  }
   return { stages, specialistCounts }
 }
 
@@ -81,6 +89,11 @@ export async function runRender(runDir: string, page: 'progress' | 'findings'):
     })
     const log = await readLog(runDir)
     const summary = summarizeStages(log)
+    const manifest = await readJson<{ shards?: unknown[] }>(
+      join(runDir, 'shards', 'manifest.json'),
+      {},
+    )
+    const shardCount = Array.isArray(manifest.shards) ? manifest.shards.length : 1
     const outPath = await nextVersionedPath(screenDir, 'progress')
     await renderProgressToDisk(
       {
@@ -89,6 +102,7 @@ export async function runRender(runDir: string, page: 'progress' | 'findings'):
         branch: String(prJson.headRefName ?? '?'),
         stages: summary.stages as never,
         specialistCounts: summary.specialistCounts,
+        shardCount,
       },
       outPath,
     )
@@ -119,9 +133,19 @@ export async function runRender(runDir: string, page: 'progress' | 'findings'):
     }
   })
   const diff = await readFile(join(runDir, 'diff.patch'), 'utf8').catch(() => '')
+  // `readJson` swallows both a missing file and malformed JSON, and `parseBrief`
+  // returns null for a brief that parsed but is unusable. Either way the header
+  // is simply omitted.
+  const brief = parseBrief(await readJson<unknown>(join(runDir, 'brief.json'), null)) ?? undefined
+  const issues = parseClosingIssues(prJson)
+  const diffSource =
+    (await readJson<{ source: 'gh' | 'git'; mergeBase: string | null } | null>(
+      join(runDir, 'diff-source.json'),
+      null,
+    )) ?? undefined
   const outPath = await nextVersionedPath(screenDir, 'findings')
   await renderFindingsToDisk(
-    { findings, postStatus, runId: basename(runDir), pr, files, diff },
+    { findings, postStatus, runId: basename(runDir), pr, files, diff, brief, issues, diffSource },
     outPath,
   )
   return 0

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

@@ -7,7 +7,7 @@ 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 type { PostStatusMap, PrFileEntry, ReviewFinding } from './types.ts'
+import type { PostStatusMap, PrBrief, PrFileEntry, ReviewFinding } from './types.ts'
 
 export type { PostStatusEntry, PostStatusMap } from './types.ts'
 
@@ -17,6 +17,31 @@ export type FindingsPrMeta = {
   headSha: string
 }
 
+export type BriefIssue = {
+  number: number
+  title: string
+  url: string
+}
+
+/**
+ * Maps pr.json's `closingIssuesReferences` into the brief header's issue links.
+ * Shared by render-cmd's findings branch and refresh (which re-renders
+ * findings.html for `magpie open` / `magpie serve <archived-id>`), so both
+ * call sites stay in lockstep instead of drifting apart.
+ */
+export function parseClosingIssues(prJson: Record<string, unknown>): BriefIssue[] {
+  const issuesRaw = Array.isArray(prJson.closingIssuesReferences)
+    ? (prJson.closingIssuesReferences as unknown[])
+    : []
+  return issuesRaw.flatMap((entry) => {
+    if (!entry || typeof entry !== 'object') return []
+    const e = entry as Record<string, unknown>
+    const number = Number(e.number ?? 0)
+    if (!Number.isFinite(number) || number <= 0) return []
+    return [{ number, title: String(e.title ?? ''), url: String(e.url ?? '') }]
+  })
+}
+
 export type RenderFindingsInput = {
   findings: ReviewFinding[]
   postStatus: PostStatusMap
@@ -28,8 +53,14 @@ export type RenderFindingsInput = {
   files?: PrFileEntry[]
   /** Raw unified diff text for the PR. */
   diff?: string
+  /** Scout-produced PR summary. When absent, the report renders no brief header. */
+  brief?: PrBrief
+  /** Issues this PR closes, from pr.json's closingIssuesReferences. */
+  issues?: BriefIssue[]
   /** Shiki highlighter, prepared by the caller. */
   highlighter: Highlighter
+  /** Where diff.patch came from. Absent means gh, which needs no note. */
+  diffSource?: { source: 'gh' | 'git'; mergeBase: string | null }
 }
 
 function esc(s: string): string {
@@ -57,13 +88,21 @@ function brandBlock(): string {
 
 function prHeader(input: RenderFindingsInput): string {
   const pr = input.pr
+  const src = input.diffSource
+  const diffNote =
+    src?.source === 'git'
+      ? `<span class="diff-source" title="gh pr diff could not serve this PR, so the diff was rebuilt from the local clone">diff from local clone${
+          src.mergeBase ? ` at <code>${esc(src.mergeBase.slice(0, 12))}</code>` : ''
+        }</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}
       </div>`
-    : `<div class="pr-meta"></div>`
+    : `<div class="pr-meta">${diffNote}</div>`
   const total = input.findings.length
   return `<header class="pr-header">
     ${brandBlock()}
@@ -76,6 +115,40 @@ function prHeader(input: RenderFindingsInput): string {
   </header>`
 }
 
+function briefBlock(brief: PrBrief | undefined, issues: BriefIssue[]): string {
+  // Absent brief renders nothing: archived runs from before the scout stage
+  // existed must still open cleanly.
+  if (!brief) return ''
+  const changes =
+    brief.changes.length > 0
+      ? `<ul class="brief-changes">${brief.changes.map((c) => `<li>${esc(c)}</li>`).join('')}</ul>`
+      : ''
+  const subsystems =
+    brief.subsystems.length > 0
+      ? `<div class="brief-subsystems">${brief.subsystems
+          .map((s) => `<span class="brief-chip" title="${esc(s.role)}">${esc(s.name)}</span>`)
+          .join('')}</div>`
+      : ''
+  const issueLinks =
+    issues.length > 0
+      ? `<div class="brief-issues">${issues
+          .map(
+            (i) =>
+              `<a class="brief-issue" href="${esc(i.url)}" title="${esc(i.title)}">#${i.number}</a>`,
+          )
+          .join('')}</div>`
+      : ''
+  return `<details class="pr-brief" open>
+    <summary class="brief-summary">What this PR is for</summary>
+    <div class="brief-body">
+      <p class="brief-purpose">${esc(brief.purpose)}</p>
+      ${changes}
+      ${subsystems}
+      ${issueLinks}
+    </div>
+  </details>`
+}
+
 function filePane(opts: {
   file: PrFileEntry
   fileDiff: string
@@ -163,6 +236,7 @@ export function renderFindingsHtml(input: RenderFindingsInput): string {
   const diff = input.diff ?? ''
   const splitDiffs = splitDiffByFile(diff)
   const selectedIds = new Set<string>()
+  const briefHtml = briefBlock(input.brief, input.issues ?? [])
 
   if (input.findings.length === 0) {
     return `<!DOCTYPE html>
@@ -175,6 +249,7 @@ export function renderFindingsHtml(input: RenderFindingsInput): string {
 </head>
 <body data-run-id="${esc(runId)}" data-page="findings" data-view="files" data-diff-mode="unified" data-show-suggestions="false">
 ${prHeader(input)}
+${briefHtml}
 <main class="page-main">
   <div class="empty-state"><h1>No findings</h1><p>All specialists returned cleanly.</p></div>
 </main>
@@ -223,6 +298,7 @@ ${prHeader(input)}
 </head>
 <body data-run-id="${esc(runId)}" data-page="findings" data-view="files" data-diff-mode="unified" data-show-suggestions="false">
 ${prHeader(input)}
+${briefHtml}
 <main class="page-main">
   <div class="view files-view">
     ${tree}

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

@@ -41,6 +41,8 @@ export type RenderProgressInput = {
   branch: string
   stages: Record<StageId, StageStatus>
   specialistCounts: Record<string, number>
+  /** Shard count from shards/manifest.json. Absent or 1 means unsharded. */
+  shardCount?: number
 }
 
 function esc(s: string): string {
@@ -82,7 +84,10 @@ function progressPane(input: RenderProgressInput): string {
   const cur = current(input.stages)
   let lead: string
   if (cur.status === 'running') {
-    lead = STAGE_NOW_DOING[cur.id]
+    lead =
+      cur.id === 'specialists' && (input.shardCount ?? 1) > 1
+        ? `Five reviewers across ${input.shardCount} shards`
+        : STAGE_NOW_DOING[cur.id]
   } else if (cur.status === 'error') {
     lead = `${STAGE_NOW_DOING[cur.id]} stalled`
   } else if (cur.status === 'pending') {

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

@@ -4,6 +4,7 @@ import { fetchPr } from './gh.ts'
 import { buildIncrementalContext, findPreviousRun } from './incremental.ts'
 import { filterDiff, loadPathFilterConfig } from './path-filter.ts'
 import { type Deps, defaultDeps, preflight, renderInstallHint } from './preflight.ts'
+import { shardDiff } from './shard.ts'
 import { detectMissingTests } from './tests-check.ts'
 import { createWorktree } from './worktree.ts'
 
@@ -47,6 +48,7 @@ export async function runSetup(input: RunSetupInput): Promise<number> {
 
   const fetched = await fetchPr({
     ghBin: deps.gh,
+    gitBin: deps.git,
     prNumber: input.prNumber,
     runDir: input.runDir,
     cwd: input.repoPath,
@@ -57,10 +59,31 @@ export async function runSetup(input: RunSetupInput): Promise<number> {
     await cleanup(input.runDir)
     return 4
   }
-  await logLine(input.runDir, { stage: 'fetch-pr', status: 'done' })
+  await logLine(input.runDir, {
+    stage: 'fetch-pr',
+    status: 'done',
+    source: fetched.source,
+    ...(fetched.mergeBase ? { mergeBase: fetched.mergeBase } : {}),
+  })
+  // Sidecar so the report can say where the diff came from without re-parsing
+  // log.jsonl, the same way incremental.json carries the incremental context.
+  await writeFile(
+    join(input.runDir, 'diff-source.json'),
+    `${JSON.stringify({ source: fetched.source, mergeBase: fetched.mergeBase ?? null }, null, 2)}\n`,
+  )
 
   await applyPathFilter(input.runDir, input.repoPath)
 
+  try {
+    await runShard(input.runDir)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err)
+    await logLine(input.runDir, { stage: 'shard', status: 'error', error: message })
+    process.stderr.write(`magpie: ${message}\n`)
+    await cleanup(input.runDir)
+    return 6
+  }
+
   await runTestsCheck(input.runDir)
 
   await detectIncrementalReview(input.runDir, input.prNumber)
@@ -90,7 +113,9 @@ async function cleanup(runDir: string): Promise<void> {
     'pr.json',
     'diff.patch',
     'diff.full.patch',
+    'diff-source.json',
     'excluded-files.json',
+    'shards',
     'incremental.json',
     'findings',
     'screen',
@@ -100,6 +125,18 @@ async function cleanup(runDir: string): Promise<void> {
   }
 }
 
+async function runShard(runDir: string): Promise<void> {
+  const manifest = await shardDiff(runDir)
+  await logLine(runDir, {
+    stage: 'shard',
+    status: 'done',
+    shards: manifest.shards.length,
+    budget: manifest.budget,
+    files: manifest.totalFiles,
+    lines: manifest.totalLines,
+  })
+}
+
 async function runTestsCheck(runDir: string): Promise<void> {
   const diff = await Bun.file(join(runDir, 'diff.patch')).text()
   const findings = detectMissingTests(diff)