diff --git a/README.md b/README.md
index b5621455..0adce418 100644
--- a/README.md
+++ b/README.md
@@ -38,6 +38,30 @@ standalone or as a deeper review engine inside metaswarm, Superpowers, and Beads
 **→ New here? Read [USAGE.md](USAGE.md) for a task-oriented walkthrough, and [INSTALL.md](INSTALL.md) to
 get set up.**
 
+## Review a whole repository
+
+From a metareview source checkout, review a repository with Grok:
+
+```bash
+bin/source-review --model grok --repo /path/to/repo
+```
+
+Both `--model` and `--repo` are required. Replace `grok` with `opus` or `astra`
+to use another model; use `--repo .` to review your current directory. The script
+builds metareview automatically. You need Go and a logged-in model CLI (`grok`,
+`claude`, or `codex`).
+
+Each run saves `findings.json` and an offline `review.html` in its own directory
+under `/tmp`; the script prints that directory before starting. It reviews the
+committed first-party source at `HEAD`, skipping tests, docs, dependencies, and
+generated files.
+
+For path filters, concurrency, or timeout controls, use the full command:
+
+```bash
+bin/metareview source-review --model grok --output /tmp/grok-review --jobs 8 --call-timeout 30m /path/to/repo
+```
+
 ## Use Cases
 
 - **Workflow runs.** `metareview fsm` drives `sdlc-loop` (discover → adjudicate → fix → verify) and `review-loop` as an audited state machine: the agent does the host nodes' work in its own warm session, judge calls are auditable and swappable, and resume is a fork. Contract: `metareview fsm --agent-prompt`; guide: `docs/fsm/driving-a-workflow.md`.
diff --git a/bin/ci b/bin/ci
new file mode 100755
index 00000000..9121eef7
--- /dev/null
+++ b/bin/ci
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd "$(dirname "$0")/.."
+exec make cover
diff --git a/bin/source-review b/bin/source-review
new file mode 100755
index 00000000..8de250aa
--- /dev/null
+++ b/bin/source-review
@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  printf 'Usage: %s --model <grok|opus|astra> --repo <path>\n' "$0"
+}
+
+model=""
+repo=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --model|--repo)
+      if [[ $# -lt 2 || -z "$2" || "$2" == --* ]]; then
+        printf 'Missing value for %s\n' "$1" >&2
+        usage >&2
+        exit 2
+      fi
+      case "$1" in
+        --model) model="$2" ;;
+        --repo) repo="$2" ;;
+      esac
+      shift 2
+      ;;
+    --help|-h) usage; exit 0 ;;
+    *) printf 'Unknown argument: %s\n' "$1" >&2; usage >&2; exit 2 ;;
+  esac
+done
+
+if [[ -z "$model" || -z "$repo" ]]; then
+  printf 'Both --model and --repo are required\n' >&2
+  usage >&2
+  exit 2
+fi
+case "$model" in
+  grok|opus|astra) ;;
+  *) printf 'Unknown model: %s\n' "$model" >&2; usage >&2; exit 2 ;;
+esac
+
+# Resolve the caller's repo before moving into the metareview checkout to build.
+repo="$(cd -- "$repo" && pwd -P)"
+root="$(cd -- "$(dirname "${BASH_SOURCE[0]}")/.." && pwd -P)"
+cd -- "$root"
+go build -o bin/metareview ./cmd/metareview
+
+# Each run gets its own reports, outside the repository being reviewed.
+output="$(mktemp -d "/tmp/metareview-${model}-XXXXXX")"
+printf 'Reports: %s\n' "$output" >&2
+exec "$root/bin/metareview" source-review --model "$model" --output "$output" "$repo"
diff --git a/cmd/metareview/main.go b/cmd/metareview/main.go
index fb287a13..37bfa8ff 100644
--- a/cmd/metareview/main.go
+++ b/cmd/metareview/main.go
@@ -36,6 +36,7 @@ import (
 	"github.com/dsifry/metareview/internal/reviewprompt"
 	"github.com/dsifry/metareview/internal/reviewstate"
 	"github.com/dsifry/metareview/internal/setup"
+	"github.com/dsifry/metareview/internal/sourcereview"
 	"github.com/dsifry/metareview/internal/status"
 	"github.com/dsifry/metareview/internal/taskdone"
 	"github.com/dsifry/metareview/internal/version"
@@ -128,6 +129,7 @@ Usage:
   metareview review record-lenses [--scope pr-ready|task-done|epic-ready] [--base <ref>] [--verdict <v>] [--mode subagent-adjudicated|in-session-emulated] [--lenses a,b,c] [--from-run <fsm-run-id>]
   metareview review checkpoint --scope pr-ready|task-done|epic-ready
   metareview learn --post-merge <pr-number> [--base <ref>] [--github-pr <number>] [--session-root <path>]
+  metareview source-review --model astra|opus|grok --output <dir> [--jobs <n>] [--call-timeout <duration>] [--path <path>]... [<repo>]
 
   --base last-reviewed (task-done, epic-ready, pr-ready, record-lenses) reviews only what is new since the
   last passing review of that scope: the head printed by 'review checkpoint'.
@@ -158,6 +160,7 @@ Commands:
   review record-lenses       Record an adjudicated lens review over HEAD (satisfies the require-lenses gate)
   review checkpoint          Print the head of the last passing review of a scope on an ancestor of HEAD
   learn --post-merge         Curate post-merge repository learning
+  source-review              Review first-party source with Astra, Opus, or Grok
 `, version.Version)
 }
 
@@ -183,6 +186,11 @@ func dispatch(args []string) {
 		return
 	}
 
+	if args[0] == "source-review" {
+		exit(sourcereview.CLI(args[1:], workdir, stdout, stderr))
+		return
+	}
+
 	// `review <subcommand> --help` prints usage and runs nothing: without this, the review
 	// subcommands took "--help" as the target and ran (and logged) a full review of it.
 	if args[0] == "review" && slices.ContainsFunc(args[1:], func(a string) bool { return a == "--help" || a == "-h" }) {
diff --git a/cmd/metareview/main_test.go b/cmd/metareview/main_test.go
index 5b5dd3b0..c6d9e5a1 100644
--- a/cmd/metareview/main_test.go
+++ b/cmd/metareview/main_test.go
@@ -86,6 +86,17 @@ func TestRunHelpAndVersion(t *testing.T) {
 	}
 }
 
+func TestRunSourceReviewHelp(t *testing.T) {
+	code, out, errOut := runCLI(t, t.TempDir(), nil, "source-review", "--help")
+	if code != 0 || !strings.Contains(out, "source-review --model astra|opus|grok --output <dir>") || errOut != "" {
+		t.Fatalf("code=%d out=%q err=%q", code, out, errOut)
+	}
+	code, help, _ := runCLI(t, t.TempDir(), nil, "--help")
+	if code != 0 || !strings.Contains(help, "metareview source-review --model astra|opus|grok --output <dir> [--jobs <n>] [--call-timeout <duration>] [--path <path>]... [<repo>]") {
+		t.Fatalf("top-level help missing source-review: %q", help)
+	}
+}
+
 func TestRunUnknownCommand(t *testing.T) {
 	code, _, errOut := runCLI(t, t.TempDir(), nil, "bogus")
 	if code != 2 || !strings.Contains(errOut, "Unknown command") {
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 0e495b6d..95f2800d 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -39,6 +39,28 @@ abbreviated — task-done/epic-ready/pr-ready also take `--evidence <file>` (a v
 | **epic-ready** | `review epic-ready <id>` | the epic's **integration diff** (base..HEAD, the union of the children's changes), **with the roll-up as context** — child evidence present? contradictions? intent drift? registry coverage? | deterministic heuristics (roll-up freshness) **+ a required adjudicated review** over the integration diff (base..HEAD) via the `epic-review-loop` workflow — same require-lenses gate as pr-ready/task-done |
 | **learn** | `learn --post-merge <pr>` | what the merged PR + bot findings teach us | learning extraction |
 
+`source-review` is a separate command (`source-review --model astra|opus|grok --output <dir> [--jobs <n>]
+[--call-timeout <duration>] [--path <path>]... [<repo>]`).
+It reviews the first-party source at HEAD — code `Classify` keeps, minus tests, vendored trees,
+generated files, and non-UTF-8, narrowed to `--path` when given (a sample of the real checkout) — by calling the logged-in `claude`, `codex`, or `grok` CLI, up to `--jobs`
+prompts at once (default 8), each call killed with its process group past `--call-timeout` (default 30m).
+Every model gets the same setup — one system prompt, one findings JSON schema, no tools, one answer — so they
+are compared on the same job: `claude -p --tools "" --system-prompt --json-schema --strict-mcp-config`,
+`grok --prompt-file --verbatim --json-schema --tools read_file --disallowed-tools read_file,search_tool,use_tool
+--max-turns 1 --system-prompt-override --reasoning-effort medium`
+(`grok --tools ""` retains the default tools; a nonempty allowlist followed by denial actually removes them;
+`grok -p` hands a large prompt to its agent as an excerpt it re-reads with tools), and
+`codex exec -s read-only --skip-git-repo-check --output-schema`
+(Codex has no switch to remove its tools or replace its system prompt, so it is the one that differs).
+Calls start in an empty temporary working directory, cleaned after success or failure, so the host project's
+rules are not injected. Per-process settings disable Claude customizations and Grok's Claude/Cursor compatibility
+instructions. Native provider context can still differ. Grok's requested model is also set as its initial
+default: switching models after initialization otherwise replaces the supplied system prompt. Claude's effort
+environment override is set explicitly because it takes precedence over the CLI flag. Neither provider's
+global configuration is edited. Explicit token-limit stops and Grok structured-output failures fail the call,
+even if response text happens to parse as findings JSON.
+It does not use the diff-review anchor gate, `ValidatePayload`, `internal/shardpack`, or `review-lenses`.
+
 `epic-ready` runs *after* every child task is task-done-reviewed. It reviews the epic's **integration diff**
 (base..HEAD, the union of the children's changes) **with the roll-up — child review logs, evidence, parent
 intent — as context**; the roll-up's own freshness is guarded by the deterministic pre-checks (re-read every
@@ -489,7 +511,8 @@ list below is illustrative, omitting e.g. `judge`, `gate`, `converge`, `export`)
   (floor gate).
 - **Context & evidence:** `gitcontext` (exclude-filtered diff), `githubcontext`, `contextpack`,
   `contextprofile`, `shardpack` (shard packs), `evidence`, `mutation` (Stryker/gremlins report), `knowledge`,
-  `markdown`, `classify` (file class), `testconv` (test-file convention).
+  `markdown`, `classify` (file class), `testconv` (test-file convention),
+  `sourcereview` (whole-repo first-party source review; not the diff gate).
 - **FSM:** `fsm/{cli,machine,workflow,run,record,sandbox,kind}`.
 - **Sources & learning:** `tasksource`, `epicsource` (Beads etc.), `learning`, `learnsource`,
   `sessionhistory`, `integration` (metaswarm).
diff --git a/internal/sourcereview/fixture_test.go b/internal/sourcereview/fixture_test.go
new file mode 100644
index 00000000..5c596fbb
--- /dev/null
+++ b/internal/sourcereview/fixture_test.go
@@ -0,0 +1,89 @@
+package sourcereview
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func gitEnv() []string {
+	return append(os.Environ(),
+		"GIT_CONFIG_GLOBAL=/dev/null",
+		"GIT_CONFIG_SYSTEM=/dev/null",
+		"GIT_AUTHOR_NAME=Test",
+		"GIT_AUTHOR_EMAIL=t@example.com",
+		"GIT_COMMITTER_NAME=Test",
+		"GIT_COMMITTER_EMAIL=t@example.com",
+	)
+}
+
+func gitRun(t *testing.T, root string, args ...string) {
+	t.Helper()
+	cmd := exec.Command("git", args...)
+	cmd.Dir = root
+	cmd.Env = gitEnv()
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, out)
+	}
+}
+
+func newRepoBytes(t *testing.T, files map[string][]byte) (root, commit string) {
+	t.Helper()
+	root = t.TempDir()
+	gitRun(t, root, "init", "-b", "main")
+	gitRun(t, root, "config", "user.email", "t@example.com")
+	gitRun(t, root, "config", "user.name", "Test")
+	for p, body := range files {
+		abs := filepath.Join(root, filepath.FromSlash(p))
+		if err := os.MkdirAll(filepath.Dir(abs), 0o755); err != nil {
+			t.Fatal(err)
+		}
+		if err := os.WriteFile(abs, body, 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	gitRun(t, root, "add", "-A")
+	gitRun(t, root, "commit", "-m", "fixture")
+	cmd := exec.Command("git", "rev-parse", "HEAD")
+	cmd.Dir = root
+	cmd.Env = gitEnv()
+	out, err := cmd.Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	return root, strings.TrimSpace(string(out))
+}
+
+func specFiles() map[string][]byte {
+	return map[string][]byte{
+		"pkg/app.go":      []byte("package pkg\n\nfunc App() int { return 1 }\n"),
+		"pkg/note.go":     []byte("DO NOT EDIT\npackage pkg\n\nfunc Note() string { return \"n\" }\n"),
+		"pkg/app_test.go": []byte("package pkg\n\nfunc TestApp(t *testing.T) {}\n"),
+		"vendor/lib.go":   []byte("package vendor\n\nfunc Lib() {}\n// DROPME-vendor\n"),
+		"go.sum":          []byte("example.com/mod v1.0.0 h1:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=\n"),
+		"pkg/gen.go":      []byte("// Code generated by fixture. DO NOT EDIT.\npackage pkg\n\nfunc Gen() {}\n"),
+		"pkg/blob.dat":    {0xff, 0xfe, 0x00, 0x01},
+		"README.md":       []byte("# Demo\n\nDROPME-readme\n"),
+		"config.yaml":     []byte("name: demo\nDROPME-config\n"),
+	}
+}
+
+func droppedOnlyFiles() map[string][]byte {
+	all := specFiles()
+	delete(all, "pkg/app.go")
+	delete(all, "pkg/note.go")
+	return all
+}
+
+var specDropped = []string{
+	"README.md",
+	"config.yaml",
+	"go.sum",
+	"pkg/app_test.go",
+	"pkg/blob.dat",
+	"pkg/gen.go",
+	"vendor/lib.go",
+}
diff --git a/internal/sourcereview/git.go b/internal/sourcereview/git.go
new file mode 100644
index 00000000..c05c3d81
--- /dev/null
+++ b/internal/sourcereview/git.go
@@ -0,0 +1,126 @@
+package sourcereview
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+)
+
+// GitFunc runs git with optional stdin and returns stdout. A nil GitFunc means realGit.
+type GitFunc func(root string, args []string, stdin []byte) ([]byte, error)
+
+// gitBin is the git executable. Tests point it at a missing name to cover a failed start.
+var gitBin = "git"
+
+func realGit(root string, args []string, stdin []byte) ([]byte, error) {
+	cmd := exec.Command(gitBin, append([]string{"-C", root}, args...)...)
+	if stdin != nil {
+		cmd.Stdin = bytes.NewReader(stdin)
+	}
+	out, err := cmd.Output()
+	if err != nil {
+		var ee *exec.ExitError
+		if errors.As(err, &ee) {
+			return nil, fmt.Errorf("git %s: %s", strings.Join(args, " "), bytes.TrimSpace(ee.Stderr))
+		}
+		return nil, err
+	}
+	return out, nil
+}
+
+func resolveTop(root string, git GitFunc) (string, error) {
+	out, err := git(root, []string{"rev-parse", "--show-toplevel"}, nil)
+	if err != nil {
+		return "", err
+	}
+	return strings.TrimSpace(string(out)), nil
+}
+
+type treeBlob struct {
+	path string
+	id   string
+}
+
+// parseTree reads `git ls-tree -r -z` records, preserving arbitrary filenames
+// and the object IDs used to read this exact snapshot.
+func parseTree(out []byte) ([]treeBlob, error) {
+	var blobs []treeBlob
+	rest := out
+	for len(rest) > 0 {
+		rec, next, _ := bytes.Cut(rest, []byte{0})
+		rest = next
+		if len(rec) == 0 {
+			continue
+		}
+		tab := bytes.IndexByte(rec, '\t')
+		if tab < 0 {
+			return nil, fmt.Errorf("bad ls-tree record")
+		}
+		fields := strings.Fields(string(rec[:tab]))
+		if len(fields) < 3 {
+			return nil, fmt.Errorf("bad ls-tree meta")
+		}
+		if fields[1] != "blob" {
+			continue
+		}
+		p := string(rec[tab+1:])
+		if p == "" {
+			continue
+		}
+		blobs = append(blobs, treeBlob{path: p, id: fields[2]})
+	}
+	return blobs, nil
+}
+
+func readBlobs(root string, blobs []treeBlob, git GitFunc) (map[string][]byte, error) {
+	if len(blobs) == 0 {
+		return map[string][]byte{}, nil
+	}
+	var stdin bytes.Buffer
+	paths := make([]string, 0, len(blobs))
+	for _, b := range blobs {
+		// Object IDs avoid line-delimited filenames and any later HEAD lookup.
+		fmt.Fprintln(&stdin, b.id)
+		paths = append(paths, b.path)
+	}
+	out, err := git(root, []string{"cat-file", "--batch"}, stdin.Bytes())
+	if err != nil {
+		return nil, err
+	}
+	return parseBatch(out, paths)
+}
+
+func parseBatch(out []byte, paths []string) (map[string][]byte, error) {
+	files := make(map[string][]byte, len(paths))
+	rest := out
+	for _, p := range paths {
+		nl := bytes.IndexByte(rest, '\n')
+		if nl < 0 {
+			return nil, fmt.Errorf("short cat-file header for %s", p)
+		}
+		header := string(rest[:nl])
+		rest = rest[nl+1:]
+		parts := strings.Split(header, " ")
+		if len(parts) < 3 || parts[1] != "blob" {
+			return nil, fmt.Errorf("cat-file %s: %s", p, header)
+		}
+		size, err := strconv.Atoi(parts[2])
+		if err != nil {
+			return nil, fmt.Errorf("cat-file %s: %w", p, err)
+		}
+		if size < 0 || len(rest) < size+1 {
+			return nil, fmt.Errorf("short cat-file blob %s", p)
+		}
+		if rest[size] != '\n' {
+			return nil, fmt.Errorf("cat-file %s: missing trailing newline", p)
+		}
+		body := make([]byte, size)
+		copy(body, rest[:size])
+		files[p] = body
+		rest = rest[size+1:]
+	}
+	return files, nil
+}
diff --git a/internal/sourcereview/model.go b/internal/sourcereview/model.go
new file mode 100644
index 00000000..94c8083d
--- /dev/null
+++ b/internal/sourcereview/model.go
@@ -0,0 +1,295 @@
+package sourcereview
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"syscall"
+	"time"
+)
+
+// Runner runs one logged-in CLI. stdin is the prompt for claude and codex;
+// grok reads the prompt from the --prompt-file file and stdin is nil. When ctx
+// ends, the process and its children are killed.
+type Runner interface {
+	Run(ctx context.Context, name string, args []string, stdin []byte) ([]byte, error)
+}
+
+// OSRunner is the real process runner. It does not read an API key and does not
+// add a token to the command.
+type OSRunner struct{}
+
+// waitDelay bounds how long Run waits for output pipes after the process group
+// is killed (the internal/fsm/cmdexec pattern).
+const waitDelay = 2 * time.Second
+
+const (
+	grokModelID  = "grok-4.7"
+	reviewEffort = "medium"
+)
+
+func (OSRunner) Run(ctx context.Context, name string, args []string, stdin []byte) ([]byte, error) {
+	// Review only the supplied source. Starting in the host checkout injects
+	// unrelated project rules and skills into the model's conversation.
+	dir, err := os.MkdirTemp("", "metareview-workspace-*")
+	if err != nil {
+		return nil, err
+	}
+	defer func() { _ = os.RemoveAll(dir) }()
+	cmd := exec.CommandContext(ctx, name, args...)
+	cmd.Dir = dir
+	cmd.Env = append(os.Environ(),
+		"CLAUDE_CODE_SAFE_MODE=1",
+		// Claude gives this environment variable precedence over --effort.
+		"CLAUDE_CODE_EFFORT_LEVEL="+reviewEffort,
+		// Selecting a different Grok model after initialization re-renders its
+		// coding-agent system prompt, discarding --system-prompt-override.
+		// Make the requested model the session default before initialization.
+		fmt.Sprintf(`GROK_CONFIG={"models":{"default":%q}}`, grokModelID),
+		"GROK_CLAUDE_AGENTS_ENABLED=false", "GROK_CLAUDE_RULES_ENABLED=false", "GROK_CLAUDE_SKILLS_ENABLED=false",
+		"GROK_CURSOR_AGENTS_ENABLED=false", "GROK_CURSOR_RULES_ENABLED=false", "GROK_CURSOR_SKILLS_ENABLED=false",
+	)
+	if stdin != nil {
+		cmd.Stdin = bytes.NewReader(stdin)
+	}
+	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
+	cmd.Cancel = func() error { return syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL) }
+	cmd.WaitDelay = waitDelay
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err = cmd.Run()
+	if err != nil {
+		// Codex puts the turn failure on stdout and a snapshot warning on
+		// stderr. Keep both so a non-zero exit records the CLI's reason.
+		msg := strings.TrimSpace(stderr.String())
+		if out := strings.TrimSpace(stdout.String()); out != "" {
+			if msg != "" {
+				msg = msg + "\n" + out
+			} else {
+				msg = out
+			}
+		}
+		if msg == "" {
+			msg = err.Error()
+		}
+		return stdout.Bytes(), fmt.Errorf("%s: %s", name, msg)
+	}
+	return stdout.Bytes(), nil
+}
+
+// ModelID is the id shown on the page and passed to the CLI.
+func ModelID(model string) (string, error) {
+	switch strings.ToLower(strings.TrimSpace(model)) {
+	case "opus":
+		return "opus", nil
+	case "astra":
+		return "gpt-6-astra", nil
+	case "grok":
+		return grokModelID, nil
+	default:
+		return "", fmt.Errorf("unknown model %q (want astra, opus, or grok)", model)
+	}
+}
+
+// Every model gets the same review setup: this system prompt, this answer
+// schema, no tools, one answer. The prompt text and the parser are shared too,
+// so the models are compared on the same job.
+
+// findingsSchema constrains the answer to {"findings":[...]} with all eight
+// fields present and no others. Codex's strict schema mode rejects an object
+// without "additionalProperties": false.
+const findingsSchema = `{"type":"object","properties":{"findings":{"type":"array","items":{"type":"object","properties":{"tag":{"type":"string","enum":["bug","advisory"]},"file":{"type":"string"},"start_line":{"type":"integer"},"end_line":{"type":"integer"},"issue":{"type":"string"},"consequence":{"type":"string"},"confidence":{"type":"integer"},"severity":{"type":"string","enum":["P0","P1","P2","P3"]}},"required":["tag","file","start_line","end_line","issue","consequence","confidence","severity"],"additionalProperties":false}}},"required":["findings"],"additionalProperties":false}`
+
+// reviewSystem replaces each CLI's agent system prompt. Without it Grok tries
+// to call tools and --max-turns 1 cancels the turn.
+const reviewSystem = "You are a code reviewer. You have no tools. Everything you need is in the user message. Answer in a single message."
+
+// claudeArgs runs Claude as one turn with no tools, no MCP servers, and no
+// saved session, at medium effort to match Grok's --reasoning-effort medium.
+// The prompt is on stdin.
+func claudeArgs() []string {
+	return []string{
+		"-p", "--model", "opus", "--output-format", "json",
+		"--tools", "", "--system-prompt", reviewSystem, "--json-schema", findingsSchema,
+		"--strict-mcp-config", "--no-session-persistence",
+		"--effort", reviewEffort,
+	}
+}
+
+// codexArgs runs Codex with the shared schema, a read-only sandbox, and no
+// saved session. The prompt is on stdin ("-"). Codex has no switch to remove
+// its tools or replace its system prompt, so it is the one model that differs.
+func codexArgs(schemaFile string) []string {
+	return []string{
+		"exec", "--json", "-m", "gpt-6-astra",
+		"-s", "read-only", "--ephemeral", "--skip-git-repo-check", "--output-schema", schemaFile, "-",
+	}
+}
+
+// grokArgs runs Grok as one turn with no tools. -p hands a large prompt to
+// Grok's agent as an excerpt plus a file to read back with tools, which made
+// one hh prompt take 11 model calls; --prompt-file with --verbatim sends it whole.
+// Effort is shared with Claude. Speed and independently verified quality are
+// measured together; a lower raw finding count alone does not establish a loss.
+// Grok treats --tools "" as the default toolset. Use a non-empty allowlist,
+// then deny that tool and the always-on MCP dispatchers. Deny takes precedence,
+// leaving no tools without maintaining an exhaustive list of built-in tools.
+func grokArgs(promptFile string) []string {
+	return []string{
+		"--prompt-file", promptFile, "--verbatim",
+		"-m", grokModelID, "--output-format", "json",
+		"--json-schema", findingsSchema,
+		"--tools", "read_file", "--disallowed-tools", "read_file,search_tool,use_tool",
+		"--max-turns", "1", "--no-subagents", "--disable-web-search",
+		"--system-prompt-override", reviewSystem,
+		"--reasoning-effort", reviewEffort,
+	}
+}
+
+// Temp-file seams. Production uses the os functions. Tests replace them to
+// cover the error returns.
+var (
+	createTemp = os.CreateTemp
+	removeFile = os.Remove
+)
+
+// writeTempFile writes data to a new file in os.TempDir(), which is never
+// inside the reviewed tree or the output directory.
+func writeTempFile(pattern string, data []byte) (string, error) {
+	f, err := createTemp("", pattern)
+	if err != nil {
+		return "", err
+	}
+	_, werr := f.Write(data)
+	cerr := f.Close()
+	if err := errors.Join(werr, cerr); err != nil {
+		_ = removeFile(f.Name())
+		return "", err
+	}
+	return f.Name(), nil
+}
+
+// Call is the one function that runs claude, codex, or grok. The prompt text
+// and the parser stay the same; only the CLI and the model id change.
+func Call(ctx context.Context, runner Runner, model string, prompt []byte) (string, error) {
+	switch strings.ToLower(strings.TrimSpace(model)) {
+	case "opus":
+		out, err := runner.Run(ctx, "claude", claudeArgs(), prompt)
+		if err != nil {
+			return "", err
+		}
+		return claudeModelText(out)
+	case "astra":
+		schema, err := writeTempFile("metareview-schema-*.json", []byte(findingsSchema))
+		if err != nil {
+			return "", err
+		}
+		defer func() { _ = removeFile(schema) }()
+		out, err := runner.Run(ctx, "codex", codexArgs(schema), prompt)
+		if err != nil {
+			return "", err
+		}
+		return codexModelText(out)
+	case "grok":
+		path, err := writeTempFile("metareview-grok-prompt-*.txt", prompt)
+		if err != nil {
+			return "", err
+		}
+		defer func() { _ = removeFile(path) }()
+		out, err := runner.Run(ctx, "grok", grokArgs(path), nil)
+		if err != nil {
+			return "", err
+		}
+		return grokModelText(out)
+	default:
+		return "", fmt.Errorf("unknown model %q", model)
+	}
+}
+
+func claudeModelText(stdout []byte) (string, error) {
+	var doc struct {
+		IsError          bool            `json:"is_error"`
+		StopReason       string          `json:"stop_reason"`
+		Result           *string         `json:"result"`
+		StructuredOutput json.RawMessage `json:"structured_output"`
+	}
+	if err := json.Unmarshal(stdout, &doc); err != nil {
+		return "", fmt.Errorf("missing model text: %w", err)
+	}
+	if doc.IsError {
+		msg := ""
+		if doc.Result != nil {
+			msg = *doc.Result
+		}
+		return "", fmt.Errorf("claude: is_error: %s", msg)
+	}
+	if doc.StopReason == "max_tokens" {
+		return "", errors.New("claude: incomplete review: max_tokens")
+	}
+	if len(doc.StructuredOutput) > 0 && !bytes.Equal(doc.StructuredOutput, []byte("null")) {
+		if doc.StructuredOutput[0] != '{' {
+			return "", errors.New("claude: structured_output must be an object")
+		}
+		return string(doc.StructuredOutput), nil
+	}
+	if doc.Result == nil || *doc.Result == "" {
+		return "", errors.New("missing model text")
+	}
+	return *doc.Result, nil
+}
+
+func codexModelText(stdout []byte) (string, error) {
+	var text string
+	found := false
+	for _, line := range strings.Split(string(stdout), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		var ev struct {
+			Type string `json:"type"`
+			Item struct {
+				Type string `json:"type"`
+				Text string `json:"text"`
+			} `json:"item"`
+		}
+		if json.Unmarshal([]byte(line), &ev) != nil {
+			continue
+		}
+		if ev.Type == "item.completed" && ev.Item.Type == "agent_message" {
+			text = ev.Item.Text
+			found = true
+		}
+	}
+	if !found || text == "" {
+		return "", errors.New("missing model text")
+	}
+	return text, nil
+}
+
+func grokModelText(stdout []byte) (string, error) {
+	var doc struct {
+		Text                  *string `json:"text"`
+		StopReason            string  `json:"stopReason"`
+		StructuredOutputError string  `json:"structuredOutputError"`
+	}
+	if err := json.Unmarshal(stdout, &doc); err != nil {
+		return "", fmt.Errorf("missing model text: %w", err)
+	}
+	if doc.StopReason == "max_tokens" {
+		return "", errors.New("grok: incomplete review: max_tokens")
+	}
+	if doc.StructuredOutputError != "" {
+		return "", fmt.Errorf("grok: %s", doc.StructuredOutputError)
+	}
+	if doc.Text == nil || *doc.Text == "" {
+		return "", errors.New("missing model text")
+	}
+	return *doc.Text, nil
+}
diff --git a/internal/sourcereview/model_test.go b/internal/sourcereview/model_test.go
new file mode 100644
index 00000000..d2abef54
--- /dev/null
+++ b/internal/sourcereview/model_test.go
@@ -0,0 +1,496 @@
+package sourcereview
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+// fakeRunner records calls. It is safe for concurrent calls: n is the call's
+// start order, active/maxActive count calls running at the same time, and wait
+// (when set) runs inside the call before reply so a test can block on ctx.
+type fakeRunner struct {
+	mu        sync.Mutex
+	calls     []fakeCall
+	active    int
+	maxActive int
+	reply     func(n int, name string, args []string, stdin []byte) ([]byte, error)
+	wait      func(ctx context.Context, prompt []byte) error
+	onRun     func()
+}
+
+type fakeCall struct {
+	name  string
+	args  []string
+	stdin []byte
+	// prompt is the prompt the CLI received: stdin, or the --prompt-file bytes.
+	prompt []byte
+}
+
+func (f *fakeRunner) Run(ctx context.Context, name string, args []string, stdin []byte) ([]byte, error) {
+	if f.onRun != nil {
+		f.onRun()
+	}
+	prompt := append([]byte(nil), stdin...)
+	for i, a := range args {
+		if a == "--prompt-file" && i+1 < len(args) {
+			prompt, _ = os.ReadFile(args[i+1])
+		}
+	}
+	f.mu.Lock()
+	n := len(f.calls)
+	f.calls = append(f.calls, fakeCall{name, append([]string(nil), args...), append([]byte(nil), stdin...), prompt})
+	f.active++
+	if f.active > f.maxActive {
+		f.maxActive = f.active
+	}
+	f.mu.Unlock()
+	defer func() {
+		f.mu.Lock()
+		f.active--
+		f.mu.Unlock()
+	}()
+	if f.wait != nil {
+		if err := f.wait(ctx, prompt); err != nil {
+			return nil, err
+		}
+	}
+	if f.reply == nil {
+		return nil, errors.New("no reply")
+	}
+	return f.reply(n, name, args, stdin)
+}
+
+func (f *fakeRunner) callList() []fakeCall {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return append([]fakeCall(nil), f.calls...)
+}
+
+var bg = context.Background()
+
+func TestModelID(t *testing.T) {
+	cases := map[string]string{"opus": "opus", " astra ": "gpt-6-astra", "GROK": "grok-4.7"}
+	for in, want := range cases {
+		got, err := ModelID(in)
+		if err != nil || got != want {
+			t.Fatalf("%q -> %q %v", in, got, err)
+		}
+	}
+	if _, err := ModelID("sonnet"); err == nil {
+		t.Fatal("expected unknown model")
+	}
+}
+
+func TestCallShapes(t *testing.T) {
+	prompt := []byte("review this")
+	for _, model := range []string{"opus", "astra", "grok"} {
+		var schemaFile string
+		fr := &fakeRunner{reply: func(_ int, _ string, args []string, _ []byte) ([]byte, error) {
+			switch model {
+			case "opus":
+				return []byte(`{"is_error":false,"result":"{\"findings\":[]}"}`), nil
+			case "astra":
+				// The schema file holds the shared schema during the call.
+				schemaFile = args[len(args)-2]
+				if got, err := os.ReadFile(schemaFile); err != nil || string(got) != findingsSchema {
+					t.Fatalf("codex schema file %s: %v %q", schemaFile, err, got)
+				}
+				return []byte("not json\n{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"first\"}}\n{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"{\\\"findings\\\":[]}\"}}\n"), nil
+			default:
+				return []byte(`{"text":"{\"findings\":[]}"}`), nil
+			}
+		}}
+		text, err := Call(bg, fr, model, prompt)
+		if err != nil {
+			t.Fatal(model, err)
+		}
+		if model == "astra" {
+			if text != `{"findings":[]}` {
+				t.Fatalf("astra text %q", text)
+			}
+		} else if text != `{"findings":[]}` {
+			t.Fatalf("%s text %q", model, text)
+		}
+		c := fr.calls[0]
+		switch model {
+		case "opus":
+			want := []string{"-p", "--model", "opus", "--output-format", "json", "--tools", "", "--system-prompt", sharedSystem, "--json-schema", findingsSchema, "--strict-mcp-config", "--no-session-persistence", "--effort", "medium"}
+			if c.name != "claude" || !reflectArgs(c.args, want) || !bytes.Equal(c.stdin, prompt) {
+				t.Fatalf("claude call %+v", c)
+			}
+		case "astra":
+			want := []string{"exec", "--json", "-m", "gpt-6-astra", "-s", "read-only", "--ephemeral", "--skip-git-repo-check", "--output-schema", schemaFile, "-"}
+			if c.name != "codex" || !reflectArgs(c.args, want) || !bytes.Equal(c.stdin, prompt) {
+				t.Fatalf("codex call %+v", c)
+			}
+			if filepath.Dir(schemaFile) != filepath.Clean(os.TempDir()) {
+				t.Fatalf("schema file %s not in os.TempDir()", schemaFile)
+			}
+			if _, err := os.Stat(schemaFile); !os.IsNotExist(err) {
+				t.Fatalf("schema file %s left behind", schemaFile)
+			}
+		case "grok":
+			if c.name != "grok" || len(c.args) < 2 || !reflectArgs(c.args, grokWant(c.args[1])) || c.stdin != nil || !bytes.Equal(c.prompt, prompt) {
+				t.Fatalf("grok call %+v", c)
+			}
+		}
+	}
+}
+
+// sharedSystem is the system prompt every model gets, spelled out so a change
+// to reviewSystem is a visible test change.
+const sharedSystem = "You are a code reviewer. You have no tools. Everything you need is in the user message. Answer in a single message."
+
+// grokWant is the exact Grok argv the goal names, for a given prompt file.
+func grokWant(promptFile string) []string {
+	return []string{
+		"--prompt-file", promptFile, "--verbatim",
+		"-m", "grok-4.7", "--output-format", "json",
+		"--json-schema", findingsSchema,
+		"--tools", "read_file", "--disallowed-tools", "read_file,search_tool,use_tool",
+		"--max-turns", "1", "--no-subagents", "--disable-web-search",
+		"--system-prompt-override", sharedSystem,
+		"--reasoning-effort", "medium",
+	}
+}
+
+func TestGrokPromptFile(t *testing.T) {
+	prompt := []byte("review this ✓\n")
+	tree, out := t.TempDir(), t.TempDir()
+	replies := map[string]func() ([]byte, error){
+		"success":      func() ([]byte, error) { return []byte(`{"text":"{\"findings\":[]}"}`), nil },
+		"nonzero":      func() ([]byte, error) { return nil, errors.New("grok: exit status 1") },
+		"cannot-start": func() ([]byte, error) { return nil, errors.New(`exec: "grok": executable file not found in $PATH`) },
+	}
+	for name, reply := range replies {
+		var path string
+		fr := &fakeRunner{reply: func(_ int, _ string, args []string, _ []byte) ([]byte, error) {
+			path = args[1]
+			got, err := os.ReadFile(path)
+			if err != nil || !bytes.Equal(got, prompt) {
+				t.Fatalf("%s: prompt file during the call: %v %q", name, err, got)
+			}
+			for _, dir := range []string{tree, out} {
+				if strings.HasPrefix(path, dir) {
+					t.Fatalf("%s: prompt file %s inside %s", name, path, dir)
+				}
+			}
+			if filepath.Dir(path) != filepath.Clean(os.TempDir()) {
+				t.Fatalf("%s: prompt file %s not in os.TempDir()", name, path)
+			}
+			return reply()
+		}}
+		_, err := Call(bg, fr, "grok", prompt)
+		if (name == "success") != (err == nil) {
+			t.Fatalf("%s: err %v", name, err)
+		}
+		if _, statErr := os.Stat(path); !os.IsNotExist(statErr) {
+			t.Fatalf("%s: prompt file %s left behind", name, path)
+		}
+	}
+	// A real process that cannot start also removes the file.
+	before, _ := filepath.Glob(filepath.Join(os.TempDir(), "metareview-grok-prompt-*"))
+	t.Setenv("PATH", t.TempDir())
+	if _, err := Call(bg, OSRunner{}, "grok", prompt); err == nil {
+		t.Fatal("grok should not start with an empty PATH")
+	}
+	after, _ := filepath.Glob(filepath.Join(os.TempDir(), "metareview-grok-prompt-*"))
+	if len(after) > len(before) {
+		t.Fatalf("prompt file left behind: %v", after)
+	}
+}
+
+func TestFindingsSchema(t *testing.T) {
+	var s struct {
+		Type                 string `json:"type"`
+		Required             []string
+		AdditionalProperties *bool `json:"additionalProperties"`
+		Properties           struct {
+			Findings struct {
+				Type  string `json:"type"`
+				Items struct {
+					Required             []string                   `json:"required"`
+					AdditionalProperties *bool                      `json:"additionalProperties"`
+					Properties           map[string]json.RawMessage `json:"properties"`
+				} `json:"items"`
+			} `json:"findings"`
+		} `json:"properties"`
+	}
+	if err := json.Unmarshal([]byte(findingsSchema), &s); err != nil {
+		t.Fatal(err)
+	}
+	// Codex's strict mode rejects any object that allows extra properties.
+	if s.AdditionalProperties == nil || *s.AdditionalProperties || s.Properties.Findings.Items.AdditionalProperties == nil || *s.Properties.Findings.Items.AdditionalProperties {
+		t.Fatal("every object must set additionalProperties to false")
+	}
+	want := []string{"tag", "file", "start_line", "end_line", "issue", "consequence", "confidence", "severity"}
+	if !reflectArgs(s.Properties.Findings.Items.Required, want) || s.Properties.Findings.Type != "array" {
+		t.Fatalf("schema required %v", s.Properties.Findings.Items.Required)
+	}
+	for _, f := range want {
+		if _, ok := s.Properties.Findings.Items.Properties[f]; !ok {
+			t.Fatalf("schema has no property %s", f)
+		}
+	}
+	for f, typ := range map[string]string{"start_line": "integer", "end_line": "integer", "confidence": "integer"} {
+		if !strings.Contains(string(s.Properties.Findings.Items.Properties[f]), `"`+typ+`"`) {
+			t.Fatalf("%s is not %s", f, typ)
+		}
+	}
+	for f, enum := range map[string]string{"tag": `["bug","advisory"]`, "severity": `["P0","P1","P2","P3"]`} {
+		if !strings.Contains(string(s.Properties.Findings.Items.Properties[f]), enum) {
+			t.Fatalf("%s enum", f)
+		}
+	}
+}
+
+func TestWritePromptFileErrors(t *testing.T) {
+	prevCreate, prevRemove := createTemp, removeFile
+	t.Cleanup(func() { createTemp, removeFile = prevCreate, prevRemove })
+	createTemp = func(string, string) (*os.File, error) { return nil, errors.New("create") }
+	for _, model := range []string{"grok", "astra"} {
+		fr := &fakeRunner{}
+		if _, err := Call(bg, fr, model, []byte("p")); err == nil || !strings.Contains(err.Error(), "create") || len(fr.callList()) != 0 {
+			t.Fatalf("%s: %v", model, err)
+		}
+	}
+	// A file that is already closed fails Write; the partial file is removed.
+	var made string
+	createTemp = func(dir, pattern string) (*os.File, error) {
+		f, err := prevCreate(dir, pattern)
+		if err != nil {
+			return nil, err
+		}
+		made = f.Name()
+		_ = f.Close()
+		return f, nil
+	}
+	fr := &fakeRunner{}
+	if _, err := Call(bg, fr, "grok", []byte("p")); err == nil {
+		t.Fatal("write to a closed file")
+	}
+	if len(fr.callList()) != 0 {
+		t.Fatal("grok ran without a prompt file")
+	}
+	if _, err := os.Stat(made); !os.IsNotExist(err) {
+		t.Fatal("partial prompt file left behind")
+	}
+}
+
+func reflectArgs(got, want []string) bool {
+	if len(got) != len(want) {
+		return false
+	}
+	for i := range got {
+		if got[i] != want[i] {
+			return false
+		}
+	}
+	return true
+}
+
+func TestCallErrors(t *testing.T) {
+	fr := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+		return nil, errors.New("executable file not found")
+	}}
+	if _, err := Call(bg, fr, "opus", []byte("p")); err == nil {
+		t.Fatal("start failure")
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return []byte(`{"is_error":true,"result":"boom"}`), nil
+	}
+	if _, err := Call(bg, fr, "opus", []byte("p")); err == nil || !strings.Contains(err.Error(), "is_error") {
+		t.Fatal(err)
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return []byte(`{"is_error":false}`), nil
+	}
+	if _, err := Call(bg, fr, "opus", []byte("p")); err == nil {
+		t.Fatal("missing result")
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return []byte(`{"is_error":false,"result":""}`), nil
+	}
+	if _, err := Call(bg, fr, "opus", []byte("p")); err == nil {
+		t.Fatal("empty result")
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return []byte("not-json"), nil
+	}
+	if _, err := Call(bg, fr, "opus", []byte("p")); err == nil {
+		t.Fatal("bad claude json")
+	}
+	if _, err := Call(bg, fr, "grok", []byte("p")); err == nil {
+		t.Fatal("bad grok json")
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return []byte(`{"text":""}`), nil
+	}
+	if _, err := Call(bg, fr, "grok", []byte("p")); err == nil {
+		t.Fatal("empty grok text")
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return []byte(`{}`), nil
+	}
+	if _, err := Call(bg, fr, "grok", []byte("p")); err == nil {
+		t.Fatal("nil grok text")
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return []byte("{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"\"}}\n"), nil
+	}
+	if _, err := Call(bg, fr, "astra", []byte("p")); err == nil {
+		t.Fatal("empty codex text")
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return []byte("nope\n"), nil
+	}
+	if _, err := Call(bg, fr, "astra", []byte("p")); err == nil {
+		t.Fatal("no agent message")
+	}
+	if _, err := Call(bg, fr, "nope", []byte("p")); err == nil {
+		t.Fatal("unknown model")
+	}
+	fr.reply = func(int, string, []string, []byte) ([]byte, error) {
+		return nil, errors.New("exit status 1")
+	}
+	if _, err := Call(bg, fr, "astra", []byte("p")); err == nil {
+		t.Fatal("nonzero")
+	}
+	if _, err := Call(bg, fr, "grok", []byte("p")); err == nil {
+		t.Fatal("grok nonzero")
+	}
+}
+
+func TestModelTextRejectsIncompleteAnswer(t *testing.T) {
+	for _, c := range []struct {
+		model string
+		raw   string
+	}{
+		{"opus", `{"stop_reason":"max_tokens","result":"{\"findings\":[]}"}`},
+		{"grok", `{"stopReason":"max_tokens","text":"{\"findings\":[]}"}`},
+		{"grok", `{"structuredOutputError":"model did not produce structured output","text":"{\"findings\":[]}"}`},
+	} {
+		t.Run(c.model+c.raw, func(t *testing.T) {
+			fr := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+				return []byte(c.raw), nil
+			}}
+			if text, err := Call(bg, fr, c.model, []byte("review source")); err == nil || text != "" {
+				t.Fatalf("incomplete response accepted: text=%q err=%v", text, err)
+			}
+		})
+	}
+}
+
+func TestOSRunner(t *testing.T) {
+	out, err := OSRunner{}.Run(bg, "echo", []string{"hi"}, nil)
+	if err != nil || !bytes.Contains(out, []byte("hi")) {
+		t.Fatalf("echo: %v %q", err, out)
+	}
+	out, err = OSRunner{}.Run(bg, "cat", nil, []byte("yo"))
+	if err != nil || !bytes.Equal(out, []byte("yo")) {
+		t.Fatalf("cat: %v %q", err, out)
+	}
+	if _, err := (OSRunner{}).Run(bg, "false", nil, nil); err == nil {
+		t.Fatal("false should fail")
+	}
+	if _, err := (OSRunner{}).Run(bg, "sh", []string{"-c", "echo boom >&2; exit 1"}, nil); err == nil || !strings.Contains(err.Error(), "boom") {
+		t.Fatal(err)
+	}
+	if _, err := (OSRunner{}).Run(bg, "sh", []string{"-c", "echo usage-limit; exit 1"}, nil); err == nil || !strings.Contains(err.Error(), "usage-limit") {
+		t.Fatal(err)
+	}
+	if _, err := (OSRunner{}).Run(bg, "sh", []string{"-c", "echo out-line; echo err-line >&2; exit 1"}, nil); err == nil || !strings.Contains(err.Error(), "err-line") || !strings.Contains(err.Error(), "out-line") {
+		t.Fatal(err)
+	}
+	if _, err := (OSRunner{}).Run(bg, "no-such-binary-xyz", nil, nil); err == nil {
+		t.Fatal("missing binary")
+	}
+	// exec.Command is used; a lookup failure is *exec.Error, not ExitError.
+	if _, err := exec.LookPath("echo"); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestOSRunnerIsolatesWorkspace(t *testing.T) {
+	t.Setenv("GROK_CLAUDE_SKILLS_ENABLED", "true")
+	t.Setenv("CLAUDE_CODE_SAFE_MODE", "0")
+	t.Setenv("CLAUDE_CODE_EFFORT_LEVEL", "high")
+	t.Setenv("GROK_CONFIG", `{"models":{"default":"a-different-model"}}`)
+	for _, exit := range []string{"0", "1"} {
+		out, err := OSRunner{}.Run(bg, "sh", []string{"-c", `pwd; printf '%s\n' "$GROK_CLAUDE_SKILLS_ENABLED" "$CLAUDE_CODE_SAFE_MODE" "$GROK_CONFIG" "$CLAUDE_CODE_EFFORT_LEVEL"; exit "$1"`, "sh", exit}, nil)
+		if (err == nil) != (exit == "0") {
+			t.Fatalf("exit %s: %v", exit, err)
+		}
+		lines := strings.Split(strings.TrimSpace(string(out)), "\n")
+		if len(lines) != 5 || !strings.HasPrefix(filepath.Base(lines[0]), "metareview-workspace-") || lines[1] != "false" || lines[2] != "1" || lines[3] != `{"models":{"default":"grok-4.7"}}` || lines[4] != "medium" {
+			t.Fatalf("unexpected workspace or environment: %q", out)
+		}
+		if _, err := os.Stat(lines[0]); !os.IsNotExist(err) {
+			t.Fatalf("workspace remains after exit %s: %v", exit, err)
+		}
+	}
+}
+
+func TestOSRunnerWorkspaceFailure(t *testing.T) {
+	t.Setenv("TMPDIR", filepath.Join(t.TempDir(), "missing"))
+	if _, err := (OSRunner{}).Run(bg, "echo", []string{"not started"}, nil); err == nil {
+		t.Fatal("workspace creation failure must fail the call")
+	}
+}
+
+func TestOSRunnerKillsProcessGroup(t *testing.T) {
+	pidFile := filepath.Join(t.TempDir(), "child.pid")
+	ctx, cancel := context.WithTimeout(bg, 300*time.Millisecond)
+	defer cancel()
+	start := time.Now()
+	_, err := OSRunner{}.Run(ctx, "sh", []string{"-c", `sleep 30 & echo $! > "$0"; wait`, pidFile}, nil)
+	if err == nil {
+		t.Fatal("expected a killed process")
+	}
+	if took := time.Since(start); took > 10*time.Second {
+		t.Fatalf("kill took %s", took)
+	}
+	raw, rerr := os.ReadFile(pidFile)
+	if rerr != nil {
+		t.Fatal(rerr)
+	}
+	pid, perr := strconv.Atoi(strings.TrimSpace(string(raw)))
+	if perr != nil {
+		t.Fatal(perr)
+	}
+	deadline := time.Now().Add(5 * time.Second)
+	for exec.Command("kill", "-0", strconv.Itoa(pid)).Run() == nil {
+		if time.Now().After(deadline) {
+			t.Fatalf("child %d still running", pid)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+}
+
+func TestClaudeIsErrorWithoutResult(t *testing.T) {
+	if _, err := claudeModelText([]byte(`{"is_error":true}`)); err == nil {
+		t.Fatal("expected is_error")
+	}
+}
+
+func TestCodexSkipsBlank(t *testing.T) {
+	raw := "\n  \n{\"type\":\"turn.completed\"}\n{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"{\\\"findings\\\":[]}\"}}\n"
+	text, err := codexModelText([]byte(raw))
+	if err != nil || text != `{"findings":[]}` {
+		t.Fatalf("%q %v", text, err)
+	}
+	b, err := json.Marshal(map[string]string{"text": "ok"})
+	if err != nil || !bytes.Contains(b, []byte("ok")) {
+		t.Fatal(err)
+	}
+}
diff --git a/internal/sourcereview/output.go b/internal/sourcereview/output.go
new file mode 100644
index 00000000..69c98de1
--- /dev/null
+++ b/internal/sourcereview/output.go
@@ -0,0 +1,115 @@
+package sourcereview
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+// reportLstat is a seam for filesystem metadata failures.
+var reportLstat = os.Lstat
+
+// publishReports stages both files on the destination filesystem before changing
+// either saved report. Publication errors restore the previous pair. Renaming
+// two files is not an atomic transaction for concurrent readers or process crashes.
+func publishReports(opts Options, findings, page []byte) error {
+	ctx := opts.Context
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	write, rename, remove := opts.WriteFile, opts.Rename, opts.Remove
+	if write == nil {
+		write = os.WriteFile
+	}
+	if rename == nil {
+		rename = os.Rename
+	}
+	if remove == nil {
+		remove = os.Remove
+	}
+	stage, err := os.MkdirTemp(opts.OutputDir, ".metareview-publish-*")
+	if err != nil {
+		return err
+	}
+	cleanup := true
+	defer func() {
+		if cleanup {
+			_ = os.RemoveAll(stage)
+		}
+	}()
+	type report struct {
+		name      string
+		body      []byte
+		exists    bool
+		backedUp  bool
+		published bool
+	}
+	reports := []report{{name: "findings.json", body: findings}, {name: "review.html", body: page}}
+	for i := range reports {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+		r := &reports[i]
+		if err := write(filepath.Join(stage, r.name), r.body, 0o644); err != nil {
+			return err
+		}
+		info, err := reportLstat(filepath.Join(opts.OutputDir, r.name))
+		if err != nil && !os.IsNotExist(err) {
+			return err
+		}
+		r.exists = err == nil
+		if r.exists && info.IsDir() {
+			return fmt.Errorf("report destination is a directory: %s", r.name)
+		}
+	}
+	rollback := func(cause error) error {
+		var restoreErrors []error
+		for i := len(reports) - 1; i >= 0; i-- {
+			r := &reports[i]
+			dest := filepath.Join(opts.OutputDir, r.name)
+			if r.backedUp {
+				if err := rename(filepath.Join(stage, r.name+".previous"), dest); err != nil {
+					restoreErrors = append(restoreErrors, err)
+				}
+			} else if r.published {
+				if err := remove(dest); err != nil {
+					restoreErrors = append(restoreErrors, err)
+				}
+			}
+		}
+		if len(restoreErrors) > 0 {
+			// Never delete the only surviving copy if restoration itself fails.
+			cleanup = false
+			return errors.Join(cause, fmt.Errorf("restore reports (backups retained in %s): %w", stage, errors.Join(restoreErrors...)))
+		}
+		return cause
+	}
+	for i := range reports {
+		if err := ctx.Err(); err != nil {
+			return rollback(err)
+		}
+		r := &reports[i]
+		if r.exists {
+			if err := rename(filepath.Join(opts.OutputDir, r.name), filepath.Join(stage, r.name+".previous")); err != nil {
+				return rollback(err)
+			}
+			r.backedUp = true
+		}
+	}
+	for i := range reports {
+		if err := ctx.Err(); err != nil {
+			return rollback(err)
+		}
+		r := &reports[i]
+		if err := rename(filepath.Join(stage, r.name), filepath.Join(opts.OutputDir, r.name)); err != nil {
+			return rollback(err)
+		}
+		r.published = true
+	}
+	if err := ctx.Err(); err != nil {
+		return rollback(err)
+	}
+	return nil
+}
diff --git a/internal/sourcereview/output_test.go b/internal/sourcereview/output_test.go
new file mode 100644
index 00000000..2ee6f0eb
--- /dev/null
+++ b/internal/sourcereview/output_test.go
@@ -0,0 +1,220 @@
+package sourcereview
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestReportPublicationCancellationPreservesPreviousPair(t *testing.T) {
+	for cancelAfter := 0; cancelAfter <= 6; cancelAfter++ {
+		t.Run(fmt.Sprintf("after-operation-%d", cancelAfter), func(t *testing.T) {
+			dir := t.TempDir()
+			names := []string{"findings.json", "review.html"}
+			seedReports(t, dir, names)
+			ctx, cancel := context.WithCancel(context.Background())
+			defer cancel()
+			n := 0
+			completed := func() {
+				n++
+				if n == cancelAfter {
+					cancel()
+				}
+			}
+			if cancelAfter == 0 {
+				cancel()
+			}
+			err := publishReports(Options{Context: ctx, OutputDir: dir,
+				WriteFile: func(p string, body []byte, mode os.FileMode) error {
+					if err := os.WriteFile(p, body, mode); err != nil {
+						return err
+					}
+					completed()
+					return nil
+				}, Rename: func(from, to string) error {
+					if err := os.Rename(from, to); err != nil {
+						return err
+					}
+					completed()
+					return nil
+				}}, []byte("new findings"), []byte("new page"))
+			if !errors.Is(err, context.Canceled) {
+				t.Fatal(err)
+			}
+			checkOldReports(t, dir, names)
+		})
+	}
+}
+
+func TestRunCancellationDuringReportSetup(t *testing.T) {
+	root, _ := newRepoBytes(t, droppedOnlyFiles())
+	dir := t.TempDir()
+	names := []string{"findings.json", "review.html"}
+	seedReports(t, dir, names)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	err := Run(Options{Context: ctx, Repo: root, Model: "opus", OutputDir: dir,
+		MkdirAll: func(p string, mode os.FileMode) error { cancel(); return os.MkdirAll(p, mode) }})
+	if !errors.Is(err, context.Canceled) {
+		t.Fatal(err)
+	}
+	checkOldReports(t, dir, names)
+}
+
+var oldReports = map[string]string{"findings.json": "old findings", "review.html": "old page"}
+
+func seedReports(t *testing.T, dir string, names []string) {
+	t.Helper()
+	for _, name := range names {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(oldReports[name]), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func checkOldReports(t *testing.T, dir string, names []string) {
+	t.Helper()
+	for _, name := range names {
+		body, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil || string(body) != oldReports[name] {
+			t.Fatalf("lost previous %s: %q %v", name, body, err)
+		}
+	}
+	entries, err := os.ReadDir(dir)
+	if err != nil || len(entries) != len(names) {
+		t.Fatalf("extra or missing files after failure: %v %v", entries, err)
+	}
+}
+
+func TestReportPublicationFailuresPreservePreviousResults(t *testing.T) {
+	for _, names := range [][]string{{"findings.json", "review.html"}, {"findings.json"}, {"review.html"}, nil} {
+		for failWrite := 1; failWrite <= 2; failWrite++ {
+			t.Run(fmt.Sprintf("partial-write-%d-existing-%d-%v", failWrite, len(names), names), func(t *testing.T) {
+				dir := t.TempDir()
+				seedReports(t, dir, names)
+				n := 0
+				failure := errors.New("no space left on device")
+				err := publishReports(Options{OutputDir: dir, WriteFile: func(p string, body []byte, mode os.FileMode) error {
+					n++
+					if n == failWrite {
+						_ = os.WriteFile(p, []byte("partial write"), mode)
+						return failure
+					}
+					return os.WriteFile(p, body, mode)
+				}}, []byte("new findings"), []byte("new page"))
+				if !errors.Is(err, failure) {
+					t.Fatal(err)
+				}
+				checkOldReports(t, dir, names)
+			})
+		}
+		for failRename := 1; failRename <= len(names)+2; failRename++ {
+			t.Run(fmt.Sprintf("rename-%d-existing-%d-%v", failRename, len(names), names), func(t *testing.T) {
+				dir := t.TempDir()
+				seedReports(t, dir, names)
+				n := 0
+				failure := errors.New("rename failed")
+				err := publishReports(Options{OutputDir: dir, Rename: func(from, to string) error {
+					n++
+					if n == failRename {
+						return failure
+					}
+					return os.Rename(from, to)
+				}, Remove: os.Remove}, []byte("new findings"), []byte("new page"))
+				if !errors.Is(err, failure) {
+					t.Fatal(err)
+				}
+				checkOldReports(t, dir, names)
+			})
+		}
+	}
+}
+
+func TestReportPublicationReplacesPreviousPair(t *testing.T) {
+	dir := t.TempDir()
+	seedReports(t, dir, []string{"findings.json", "review.html"})
+	if err := publishReports(Options{OutputDir: dir}, []byte("new findings"), []byte("new page")); err != nil {
+		t.Fatal(err)
+	}
+	for name, want := range map[string]string{"findings.json": "new findings", "review.html": "new page"} {
+		body, err := os.ReadFile(filepath.Join(dir, name))
+		if err != nil || string(body) != want {
+			t.Fatalf("publication failed: %q %v", body, err)
+		}
+	}
+	if entries, _ := os.ReadDir(dir); len(entries) != 2 {
+		t.Fatalf("left staging files: %v", entries)
+	}
+}
+
+func TestReportPublicationKeepsBackupsWhenRestoreFails(t *testing.T) {
+	dir := t.TempDir()
+	seedReports(t, dir, []string{"findings.json", "review.html"})
+	err := publishReports(Options{OutputDir: dir, Rename: func(from, to string) error {
+		if strings.HasSuffix(from, ".previous") {
+			return errors.New("restore failed")
+		}
+		if filepath.Dir(from) != dir && filepath.Base(from) == "review.html" {
+			return errors.New("publish failed")
+		}
+		return os.Rename(from, to)
+	}}, []byte("new findings"), []byte("new page"))
+	if err == nil || !strings.Contains(err.Error(), "backups retained") {
+		t.Fatal(err)
+	}
+	stages, _ := filepath.Glob(filepath.Join(dir, ".metareview-publish-*"))
+	if len(stages) != 1 {
+		t.Fatalf("lost backups: %v", stages)
+	}
+	for name, want := range oldReports {
+		body, err := os.ReadFile(filepath.Join(stages[0], name+".previous"))
+		if err != nil || string(body) != want {
+			t.Fatalf("backup %s lost: %q %v", name, body, err)
+		}
+	}
+}
+
+func TestReportPublicationReportsCleanupFailure(t *testing.T) {
+	dir := t.TempDir()
+	err := publishReports(Options{OutputDir: dir, Rename: func(from, to string) error {
+		if filepath.Base(from) == "review.html" {
+			return errors.New("publish failed")
+		}
+		return os.Rename(from, to)
+	}, Remove: func(string) error { return errors.New("remove failed") }}, []byte("new findings"), []byte("new page"))
+	if err == nil || !strings.Contains(err.Error(), "remove failed") {
+		t.Fatal(err)
+	}
+}
+
+func TestReportPublicationFilesystemErrors(t *testing.T) {
+	dir := t.TempDir()
+	file := filepath.Join(dir, "file")
+	if err := os.WriteFile(file, nil, 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := publishReports(Options{OutputDir: file}, nil, nil); err == nil {
+		t.Fatal("staging under a file accepted")
+	}
+	seedReports(t, dir, []string{"findings.json"})
+	if err := os.Mkdir(filepath.Join(dir, "review.html"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	if err := publishReports(Options{OutputDir: dir}, nil, nil); err == nil || !strings.Contains(err.Error(), "directory") {
+		t.Fatal(err)
+	}
+	body, err := os.ReadFile(filepath.Join(dir, "findings.json"))
+	if err != nil || string(body) != oldReports["findings.json"] {
+		t.Fatal("changed findings despite invalid page destination")
+	}
+	prev := reportLstat
+	reportLstat = func(string) (os.FileInfo, error) { return nil, errors.New("metadata failed") }
+	t.Cleanup(func() { reportLstat = prev })
+	if err := publishReports(Options{OutputDir: dir}, nil, nil); err == nil || !strings.Contains(err.Error(), "metadata failed") {
+		t.Fatal(err)
+	}
+}
diff --git a/internal/sourcereview/pack.go b/internal/sourcereview/pack.go
new file mode 100644
index 00000000..f630b503
--- /dev/null
+++ b/internal/sourcereview/pack.go
@@ -0,0 +1,226 @@
+package sourcereview
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+	"unicode/utf8"
+)
+
+// MaxPromptBytes is the prompt budget. AGENTS.md uses 120000 as the size that
+// cannot be held in one review context.
+const MaxPromptBytes = 120000
+
+// instruction is the same text for every model. Only the CLI and the model id change.
+const instruction = `Review the first-party source below and return only {"findings":[...]}.
+Each finding's tag is bug or advisory. Each finding's severity is P0, P1, P2, or P3.
+Every field is present: tag, file, start_line, end_line, issue, consequence, confidence, severity.
+confidence is an integer from 0 to 100.
+file is one of the paths given below. start_line and end_line are line numbers in that file.
+Return {"findings":[]} when there is nothing to report.
+Do not write anything outside that JSON object.
+Each source line below starts with its line number and "| ". That prefix is not part of the file. Cite those numbers.`
+
+// numberLines prefixes each line of body with its line number and "| ",
+// counting from first. Given the numbers, a model does not have to count lines
+// to cite them: on one hh file this cut Opus from 47 s to 29 s and Grok from
+// 634 s to 540 s per prompt, with no fewer findings.
+func numberLines(body []byte, first int) []byte {
+	var b bytes.Buffer
+	n := first
+	for _, line := range bytes.SplitAfter(body, []byte("\n")) {
+		if len(line) == 0 {
+			continue
+		}
+		fmt.Fprintf(&b, "%d| ", n)
+		b.Write(line)
+		n++
+	}
+	return b.Bytes()
+}
+
+func sliceNote(path string, line int) string {
+	return fmt.Sprintf("This prompt contains a byte slice of %s starting at original line %d. Citations use the original path and the original line numbers.", path, line)
+}
+
+func sliceHeader(path string, line int) string {
+	return instruction + "\n" + sliceNote(path, line) + "\n"
+}
+
+// promptWith writes the instruction header and each path on its own line
+// immediately before that file's numbered lines. A following path stays on its
+// own line when the previous body does not end in a newline.
+func promptWith(header string, files []File) []byte {
+	return promptFrom(header, files, 1)
+}
+
+// promptFrom is promptWith with the first file numbered from first: a slice of
+// a large file is numbered from the original line that holds its first byte.
+func promptFrom(header string, files []File, first int) []byte {
+	var b bytes.Buffer
+	b.WriteString(header)
+	if !strings.HasSuffix(header, "\n") {
+		b.WriteByte('\n')
+	}
+	for i, f := range files {
+		start := 1
+		if i == 0 {
+			start = first
+		}
+		if i > 0 && (len(files[i-1].Body) == 0 || files[i-1].Body[len(files[i-1].Body)-1] != '\n') {
+			b.WriteByte('\n')
+		}
+		b.WriteString(f.Path)
+		b.WriteByte('\n')
+		b.Write(numberLines(f.Body, start))
+	}
+	return b.Bytes()
+}
+
+// Pack packs whole kept files into the smallest number of prompts that stay
+// within budget (first-fit decreasing). A file that cannot fit in one prompt
+// is cut into consecutive non-empty UTF-8 slices that partition it.
+func Pack(files []File, budget int) ([][]byte, error) {
+	if budget <= 0 {
+		return nil, fmt.Errorf("prompt budget must be positive")
+	}
+	var whole []sizedFile
+	var big []File
+	for _, f := range files {
+		size := len(f.Path) + 1 + numberedSize(f.Body)
+		if len(instruction)+1+size <= budget {
+			whole = append(whole, sizedFile{File: f, size: size})
+		} else {
+			big = append(big, f)
+		}
+	}
+	prompts := packWhole(whole, budget)
+	sort.Slice(big, func(i, j int) bool { return big[i].Path < big[j].Path })
+	for _, f := range big {
+		parts, err := sliceFile(f, budget)
+		if err != nil {
+			return nil, err
+		}
+		prompts = append(prompts, parts...)
+	}
+	return prompts, nil
+}
+
+type sizedFile struct {
+	File
+	size int
+}
+
+// numberedSize measures the rendered body without building a prompt.
+func numberedSize(body []byte) int {
+	size := len(body)
+	for line := 1; len(body) > 0; line++ {
+		size += len(strconv.Itoa(line)) + 2
+		_, body, _ = bytes.Cut(body, []byte("\n"))
+	}
+	return size
+}
+
+func packWhole(files []sizedFile, budget int) [][]byte {
+	sorted := append([]sizedFile(nil), files...)
+	sort.Slice(sorted, func(i, j int) bool {
+		if len(sorted[i].Body) == len(sorted[j].Body) {
+			return sorted[i].Path < sorted[j].Path
+		}
+		return len(sorted[i].Body) > len(sorted[j].Body)
+	})
+	type bin struct {
+		files     []File
+		size      int
+		separator bool
+	}
+	var bins []bin
+	for _, f := range sorted {
+		placed := false
+		for i := range bins {
+			size := bins[i].size + f.size
+			if bins[i].separator {
+				size++
+			}
+			if size <= budget {
+				bins[i].files = append(bins[i].files, f.File)
+				bins[i].size = size
+				bins[i].separator = len(f.Body) == 0 || f.Body[len(f.Body)-1] != '\n'
+				placed = true
+				break
+			}
+		}
+		if !placed {
+			bins = append(bins, bin{files: []File{f.File}, size: len(instruction) + 1 + f.size,
+				separator: len(f.Body) == 0 || f.Body[len(f.Body)-1] != '\n'})
+		}
+	}
+	out := make([][]byte, 0, len(bins))
+	for _, bin := range bins {
+		out = append(out, promptWith(instruction, bin.files))
+	}
+	return out
+}
+
+func sliceFile(f File, budget int) ([][]byte, error) {
+	var out [][]byte
+	start := 0
+	for start < len(f.Body) {
+		line := lineAt(f.Body, start)
+		header := sliceHeader(f.Path, line)
+		room := budget - len(header) - len(f.Path) - 1
+		end, err := cutNumbered(f.Body, start, room, line)
+		if err != nil {
+			return nil, fmt.Errorf("%s: %w", f.Path, err)
+		}
+		out = append(out, promptFrom(header, []File{{Path: f.Path, Body: f.Body[start:end]}}, line))
+		start = end
+	}
+	return out, nil
+}
+
+// cutNumbered is cutEnd for a slice whose lines are numbered from line: the
+// numbered slice, not the raw bytes, must fit in room. While it does not, the
+// raw cut shrinks in proportion to the overshoot (numbering can multiply the
+// size of short lines). size > room, so each pass cuts strictly fewer bytes.
+func cutNumbered(content []byte, start, room, line int) (int, error) {
+	raw := room
+	for {
+		end, err := cutEnd(content, start, raw)
+		if err != nil {
+			return 0, err
+		}
+		size := len(numberLines(content[start:end], line))
+		if size <= room {
+			return end, nil
+		}
+		raw = (end - start) * room / size
+	}
+}
+
+func lineAt(content []byte, offset int) int {
+	return bytes.Count(content[:offset], []byte("\n")) + 1
+}
+
+// cutEnd returns the byte end of a non-empty slice that starts at start, is at
+// most room bytes, and ends on a UTF-8 character boundary.
+func cutEnd(content []byte, start, room int) (int, error) {
+	if room < 1 {
+		return 0, fmt.Errorf("prompt overhead exceeds the budget")
+	}
+	end := start + room
+	// end == len(content) takes the rest of the file; content[end] would be out of range.
+	if end >= len(content) {
+		end = len(content)
+	} else {
+		for end > start && !utf8.RuneStart(content[end]) {
+			end--
+		}
+	}
+	if end == start {
+		return 0, fmt.Errorf("a character does not fit in one prompt")
+	}
+	return end, nil
+}
diff --git a/internal/sourcereview/pack_test.go b/internal/sourcereview/pack_test.go
new file mode 100644
index 00000000..1c26b300
--- /dev/null
+++ b/internal/sourcereview/pack_test.go
@@ -0,0 +1,263 @@
+package sourcereview
+
+import (
+	"bytes"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+	"unicode/utf8"
+)
+
+func TestPackWholeFilesSmallest(t *testing.T) {
+	files := []File{
+		{Path: "a.go", Body: bytes.Repeat([]byte("x"), 100000)},
+		{Path: "b.go", Body: bytes.Repeat([]byte("y"), 50000)},
+		{Path: "c.go", Body: bytes.Repeat([]byte("z"), 60000)},
+	}
+	prompts, err := Pack(files, MaxPromptBytes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(prompts) != 2 {
+		t.Fatalf("prompts = %d, want 2", len(prompts))
+	}
+	seen := map[string]int{}
+	for _, p := range prompts {
+		if len(p) > MaxPromptBytes {
+			t.Fatalf("prompt is %d bytes", len(p))
+		}
+		if !bytes.Contains(p, []byte(instruction)) {
+			t.Fatal("missing instruction")
+		}
+		if bytes.Contains(p, []byte("byte slice of")) {
+			t.Fatal("whole file prompt has a slice note")
+		}
+		for _, f := range files {
+			needle := append([]byte(f.Path+"\n"), numberLines(f.Body, 1)...)
+			if bytes.Contains(p, needle) {
+				seen[f.Path]++
+			}
+		}
+	}
+	for _, f := range files {
+		if seen[f.Path] != 1 {
+			t.Fatalf("%s seen %d times", f.Path, seen[f.Path])
+		}
+	}
+}
+
+func TestPackSlicesPartitionUTF8(t *testing.T) {
+	body := bytes.Repeat([]byte("世"), 70000)
+	f := File{Path: "pkg/wide.go", Body: body}
+	prompts, err := Pack([]File{f}, MaxPromptBytes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(prompts) < 2 {
+		t.Fatalf("prompts = %d", len(prompts))
+	}
+	off := 0
+	files := map[string][]byte{f.Path: body}
+	for _, p := range prompts {
+		if len(p) > MaxPromptBytes {
+			t.Fatalf("prompt is %d bytes", len(p))
+		}
+		header := sliceHeader(f.Path, lineAt(body, off))
+		prefix := header + f.Path + "\n"
+		if !strings.HasPrefix(string(p), prefix) {
+			t.Fatalf("prompt missing slice header at offset %d", off)
+		}
+		// The body has no newlines, so each slice is one numbered line: the
+		// original line that holds the slice's first byte.
+		numbered := p[len(prefix):]
+		mark := strconv.Itoa(lineAt(body, off)) + "| "
+		if !bytes.HasPrefix(numbered, []byte(mark)) {
+			t.Fatalf("slice at offset %d is not numbered %q", off, mark)
+		}
+		part := numbered[len(mark):]
+		if len(part) == 0 {
+			t.Fatal("empty slice")
+		}
+		if !utf8.Valid(part) {
+			t.Fatal("slice is not valid UTF-8")
+		}
+		if !bytes.HasPrefix(body[off:], part) {
+			t.Fatal("slice is not the next bytes of the file")
+		}
+		line := lineAt(body, off)
+		text := `{"findings":[{"tag":"bug","file":"pkg/wide.go","start_line":` + strconv.Itoa(line) + `,"end_line":` + strconv.Itoa(line) + `,"issue":"i","consequence":"c","confidence":80,"severity":"P1"}]}`
+		got, _, err := Parse(text, files)
+		if err != nil {
+			t.Fatalf("finding at original line %d: %v", line, err)
+		}
+		if got[0].File != f.Path || got[0].StartLine != line {
+			t.Fatalf("citation %+v", got[0])
+		}
+		off += len(part)
+	}
+	if off != len(body) {
+		t.Fatalf("partition covered %d of %d", off, len(body))
+	}
+}
+
+func TestPackMixedAndSeparators(t *testing.T) {
+	small := File{Path: "small.go", Body: []byte("package small\n")}
+	empty := File{Path: "empty.go", Body: nil}
+	nonl := File{Path: "nonl.go", Body: []byte("package nonl")}
+	big := File{Path: "big.go", Body: bytes.Repeat([]byte("世"), 70000)}
+	prompts, err := Pack([]File{small, empty, nonl, big}, MaxPromptBytes)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var whole, slices int
+	for _, p := range prompts {
+		if bytes.Contains(p, []byte("byte slice of")) {
+			slices++
+			if !bytes.Contains(p, []byte("big.go\n")) {
+				t.Fatal("slice prompt missing path")
+			}
+			continue
+		}
+		whole++
+		for _, f := range []File{small, empty, nonl} {
+			if !bytes.Contains(p, []byte(f.Path+"\n")) {
+				t.Fatalf("whole prompt missing %s", f.Path)
+			}
+		}
+		if bytes.Contains(p, []byte("big.go\n")) {
+			t.Fatal("big file packed whole")
+		}
+	}
+	if whole != 1 || slices < 2 {
+		t.Fatalf("whole=%d slices=%d", whole, slices)
+	}
+}
+
+func TestCutEndAndSliceErrors(t *testing.T) {
+	if _, err := cutEnd([]byte("世"), 0, 0); err == nil {
+		t.Fatal("room 0")
+	}
+	if _, err := cutEnd([]byte("世"), 0, 1); err == nil {
+		t.Fatal("rune does not fit")
+	}
+	end, err := cutEnd([]byte("世世"), 0, 4)
+	if err != nil || end != 3 {
+		t.Fatalf("end=%d err=%v", end, err)
+	}
+	end, err = cutEnd([]byte("ab"), 0, 10)
+	if err != nil || end != 2 {
+		t.Fatalf("short end=%d err=%v", end, err)
+	}
+	// Room exactly equal to the bytes left takes the rest without reading past the end.
+	end, err = cutEnd([]byte("abc"), 1, 2)
+	if err != nil || end != 3 {
+		t.Fatalf("exact end=%d err=%v", end, err)
+	}
+	header := sliceHeader("p.go", 1)
+	if _, err := sliceFile(File{Path: "p.go", Body: []byte("世")}, len(header)+len("p.go")+1+1); err == nil {
+		t.Fatal("sliceFile should reject a rune that does not fit")
+	}
+	if _, err := sliceFile(File{Path: "p.go", Body: []byte("hello")}, 10); err == nil {
+		t.Fatal("sliceFile should reject a tiny budget")
+	}
+	if _, err := Pack([]File{{Path: "a.go", Body: []byte("package a\n")}}, 0); err == nil {
+		t.Fatal("budget 0")
+	}
+	if _, err := Pack([]File{{Path: "a.go", Body: bytes.Repeat([]byte("x"), 50)}}, 10); err == nil {
+		t.Fatal("pack should surface the slice error")
+	}
+	if prompts, err := Pack(nil, MaxPromptBytes); err != nil || len(prompts) != 0 {
+		t.Fatalf("empty pack %v %v", prompts, err)
+	}
+	two, err := Pack([]File{
+		{Path: "z.go", Body: bytes.Repeat([]byte("世"), 70000)},
+		{Path: "a.go", Body: bytes.Repeat([]byte("世"), 70000)},
+	}, MaxPromptBytes)
+	if err != nil || len(two) < 2 {
+		t.Fatalf("two big files: %v %d", err, len(two))
+	}
+}
+
+func TestPromptNamesPathBeforeBody(t *testing.T) {
+	body := []byte("package pkg\nfunc A() {}\n")
+	p := promptWith(instruction, []File{{Path: "pkg/app.go", Body: body}})
+	if !bytes.Contains(p, []byte("pkg/app.go\n1| package pkg\n2| func A() {}\n")) {
+		t.Fatalf("path is not immediately before the numbered body:\n%s", p)
+	}
+	if !bytes.Contains(p, []byte(`{"findings":[...]}`)) || !bytes.Contains(p, []byte("Cite those numbers.")) {
+		t.Fatal("instruction missing findings object or line-number note")
+	}
+}
+
+func TestNumberLines(t *testing.T) {
+	cases := []struct {
+		body  string
+		first int
+		want  string
+	}{
+		{"", 1, ""},
+		{"a\n", 1, "1| a\n"},
+		{"a\nb", 1, "1| a\n2| b"},
+		{"a\n\nb\n", 7, "7| a\n8| \n9| b\n"},
+	}
+	for _, c := range cases {
+		if got := string(numberLines([]byte(c.body), c.first)); got != c.want {
+			t.Fatalf("numberLines(%q, %d) = %q, want %q", c.body, c.first, got, c.want)
+		}
+	}
+}
+
+func TestSliceNumbersFromOriginalLine(t *testing.T) {
+	// 30,000 two-byte lines do not fit one prompt, and numbering more than
+	// doubles their size, so each cut has to shrink to fit the numbered text.
+	var body bytes.Buffer
+	for i := 1; i <= 30000; i++ {
+		body.WriteString("x\n")
+	}
+	f := File{Path: "short.go", Body: body.Bytes()}
+	const budget = 20000
+	prompts, err := sliceFile(f, budget)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(prompts) < 2 {
+		t.Fatalf("prompts = %d", len(prompts))
+	}
+	number := regexp.MustCompile(`(?m)^(\d+)\| `)
+	off := 0
+	for _, p := range prompts {
+		if len(p) > budget {
+			t.Fatalf("prompt is %d bytes", len(p))
+		}
+		numbered := p[bytes.Index(p, []byte("short.go\n"))+len("short.go\n"):]
+		first := number.FindSubmatch(numbered)
+		if first == nil || string(first[1]) != strconv.Itoa(lineAt(f.Body, off)) {
+			t.Fatalf("slice at offset %d starts at %q, want line %d", off, first, lineAt(f.Body, off))
+		}
+		part := number.ReplaceAll(numbered, nil)
+		if !bytes.HasPrefix(f.Body[off:], part) {
+			t.Fatalf("slice at offset %d is not the next bytes of the file", off)
+		}
+		off += len(part)
+	}
+	if off != len(f.Body) {
+		t.Fatalf("partition covered %d of %d", off, len(f.Body))
+	}
+}
+
+func TestCutNumbered(t *testing.T) {
+	// Numbered, "a\nb\nc" is 14 bytes for a room of 5; the cut shrinks until
+	// the numbered text fits.
+	end, err := cutNumbered([]byte("a\nb\nc\n"), 0, 5, 1)
+	if err != nil || end != 1 {
+		t.Fatalf("end=%d err=%v", end, err)
+	}
+	end, err = cutNumbered([]byte("abcdef"), 0, 5, 1)
+	if err != nil || end != 2 {
+		t.Fatalf("end=%d err=%v", end, err)
+	}
+	if _, err := cutNumbered([]byte("abc"), 0, 3, 100000); err == nil {
+		t.Fatal("a number wider than the room cannot fit")
+	}
+}
diff --git a/internal/sourcereview/page.go b/internal/sourcereview/page.go
new file mode 100644
index 00000000..2e3fc2fd
--- /dev/null
+++ b/internal/sourcereview/page.go
@@ -0,0 +1,711 @@
+package sourcereview
+
+import (
+	"fmt"
+	"html"
+	"path"
+	"sort"
+	"strings"
+
+	"github.com/dsifry/metareview/internal/lensoutput"
+)
+
+// Page is the input to the self-contained HTML file.
+type Page struct {
+	Repo     string
+	Commit   string
+	ModelID  string
+	Findings []lensoutput.TypedFinding
+	Files    map[string][]byte
+}
+
+var severities = []string{"P0", "P1", "P2", "P3"}
+
+func severityCounts(fs []lensoutput.TypedFinding) (p0, p1, p2, p3 int) {
+	for _, f := range fs {
+		switch f.Severity {
+		case "P0":
+			p0++
+		case "P1":
+			p1++
+		case "P2":
+			p2++
+		case "P3":
+			p3++
+		}
+	}
+	return p0, p1, p2, p3
+}
+
+func findingDirs(fs []lensoutput.TypedFinding) []string {
+	seen := map[string]bool{}
+	var dirs []string
+	for _, f := range fs {
+		d := path.Dir(f.File)
+		if !seen[d] {
+			seen[d] = true
+			dirs = append(dirs, d)
+		}
+	}
+	sort.Strings(dirs)
+	return dirs
+}
+
+func excerpt(body []byte, start, end int) string {
+	lines := splitLines(body)
+	if start < 1 || end > len(lines) || end < start {
+		return ""
+	}
+	return strings.Join(lines[start-1:end], "\n")
+}
+
+// area is the part of the tree a finding belongs to on the map: the first two
+// segments of its directory ("app/models" for app/models/concerns/x.rb).
+func area(file string) string {
+	parts := strings.Split(path.Dir(file), "/")
+	if len(parts) > 2 {
+		parts = parts[:2]
+	}
+	return strings.Join(parts, "/")
+}
+
+// summary is the first sentence of an issue, for the collapsed row. The full
+// issue is shown when the finding is opened.
+func summary(issue string) string {
+	s := strings.TrimSpace(issue)
+	if i := strings.Index(s, ". "); i >= 0 {
+		s = s[:i+1]
+	}
+	return s
+}
+
+func severityRank(s string) int {
+	for i, v := range severities {
+		if v == s {
+			return i
+		}
+	}
+	return len(severities)
+}
+
+// fileGroup is every finding in one file, in the order the page shows them.
+type fileGroup struct {
+	file     string
+	findings []lensoutput.TypedFinding
+	worst    int
+}
+
+// groupByFile puts the files with the most severe findings first, then the
+// files with the most findings. Inside a file, findings go by severity, then line.
+func groupByFile(fs []lensoutput.TypedFinding) []fileGroup {
+	index := map[string]int{}
+	var groups []fileGroup
+	for _, f := range fs {
+		i, ok := index[f.File]
+		if !ok {
+			i = len(groups)
+			index[f.File] = i
+			groups = append(groups, fileGroup{file: f.File, worst: len(severities)})
+		}
+		groups[i].findings = append(groups[i].findings, f)
+		if r := severityRank(f.Severity); r < groups[i].worst {
+			groups[i].worst = r
+		}
+	}
+	for _, g := range groups {
+		sort.SliceStable(g.findings, func(a, b int) bool {
+			ra, rb := severityRank(g.findings[a].Severity), severityRank(g.findings[b].Severity)
+			if ra != rb {
+				return ra < rb
+			}
+			return g.findings[a].StartLine < g.findings[b].StartLine
+		})
+	}
+	sort.SliceStable(groups, func(a, b int) bool {
+		if groups[a].worst != groups[b].worst {
+			return groups[a].worst < groups[b].worst
+		}
+		if len(groups[a].findings) != len(groups[b].findings) {
+			return len(groups[a].findings) > len(groups[b].findings)
+		}
+		return groups[a].file < groups[b].file
+	})
+	return groups
+}
+
+// areaRow is one line of the map: an area and its findings' severities, worst first.
+type areaRow struct {
+	name       string
+	severities []string
+}
+
+func areaRows(fs []lensoutput.TypedFinding) []areaRow {
+	index := map[string]int{}
+	var rows []areaRow
+	for _, f := range fs {
+		a := area(f.File)
+		i, ok := index[a]
+		if !ok {
+			i = len(rows)
+			index[a] = i
+			rows = append(rows, areaRow{name: a})
+		}
+		rows[i].severities = append(rows[i].severities, f.Severity)
+	}
+	for _, r := range rows {
+		sort.SliceStable(r.severities, func(a, b int) bool {
+			return severityRank(r.severities[a]) < severityRank(r.severities[b])
+		})
+	}
+	sort.SliceStable(rows, func(a, b int) bool {
+		if len(rows[a].severities) != len(rows[b].severities) {
+			return len(rows[a].severities) > len(rows[b].severities)
+		}
+		return rows[a].name < rows[b].name
+	})
+	return rows
+}
+
+// thousands writes n with comma separators: 1346 -> "1,346".
+func thousands(n int) string {
+	s := fmt.Sprint(n)
+	for i := len(s) - 3; i > 0; i -= 3 {
+		s = s[:i] + "," + s[i:]
+	}
+	return s
+}
+
+// lede is the one sentence at the top of the page: what ran, what it found,
+// and where to start.
+func lede(model string, reviewed int, counts []int) string {
+	total := 0
+	for _, c := range counts {
+		total += c
+	}
+	s := fmt.Sprintf("Reviewed %s with %s", plural(reviewed, "file", "files"), model)
+	if total == 0 {
+		return s + " and found nothing to report."
+	}
+	s += "."
+	worst := 0
+	for counts[worst] == 0 {
+		worst++
+	}
+	switch c := counts[worst]; {
+	case total == 1:
+		return s + fmt.Sprintf(" The one finding is a %s.", severities[worst])
+	case c == total:
+		return s + fmt.Sprintf(" All %s findings are %s.", thousands(c), severities[worst])
+	default:
+		return s + fmt.Sprintf(" Start with the %s at %s.", thousands(c), severities[worst])
+	}
+}
+
+func plural(n int, one, many string) string {
+	if n == 1 {
+		return "1 " + one
+	}
+	return thousands(n) + " " + many
+}
+
+const pageScript = `
+(function () {
+  var severity = document.getElementById("severity");
+  var directory = document.getElementById("directory");
+  var search = document.getElementById("search");
+  var shown = document.getElementById("shown");
+  var findings = document.querySelectorAll("#findings .finding");
+  var groups = document.querySelectorAll("#findings .group");
+  var areas = document.querySelectorAll("#map .area");
+  var segments = document.querySelectorAll("#bar .seg");
+  var area = "";
+  function press(list, attr, value) {
+    for (var i = 0; i < list.length; i++) {
+      list[i].setAttribute("aria-pressed", list[i].getAttribute(attr) === value ? "true" : "false");
+    }
+  }
+  function apply() {
+    var s = severity.value;
+    var d = directory.value;
+    var q = search ? search.value.toLowerCase() : "";
+    var n = 0;
+    for (var i = 0; i < findings.length; i++) {
+      var el = findings[i];
+      var okS = s === "" || el.getAttribute("data-severity") === s;
+      var okD = d === "" || el.getAttribute("data-dir") === d;
+      var okA = area === "" || el.getAttribute("data-area") === area;
+      var file = el.getAttribute("data-file") || "";
+      var okQ = q === "" || file.toLowerCase().indexOf(q) >= 0 || el.textContent.toLowerCase().indexOf(q) >= 0;
+      var ok = okS && okD && okA && okQ;
+      el.style.display = ok ? "" : "none";
+      if (ok) n++;
+    }
+    for (var g = 0; g < groups.length; g++) {
+      var items = groups[g].querySelectorAll(".finding");
+      var any = false;
+      for (var k = 0; k < items.length; k++) {
+        if (items[k].style.display !== "none") any = true;
+      }
+      groups[g].style.display = any ? "" : "none";
+    }
+    press(segments, "data-severity", s);
+    press(areas, "data-area", area);
+    if (shown) {
+      shown.textContent = n === findings.length
+        ? "Showing all " + n
+        : "Showing " + n + " of " + findings.length;
+    }
+  }
+  severity.addEventListener("change", apply);
+  directory.addEventListener("change", apply);
+  if (search) search.addEventListener("input", apply);
+  for (var a = 0; a < segments.length; a++) {
+    segments[a].addEventListener("click", function () {
+      var v = this.getAttribute("data-severity");
+      severity.value = severity.value === v ? "" : v;
+      apply();
+    });
+  }
+  for (var b = 0; b < areas.length; b++) {
+    areas[b].addEventListener("click", function () {
+      var v = this.getAttribute("data-area");
+      area = area === v ? "" : v;
+      apply();
+    });
+  }
+  var buttons = document.querySelectorAll("#findings .finding > button");
+  for (var j = 0; j < buttons.length; j++) {
+    buttons[j].addEventListener("click", function () {
+      var detail = this.parentNode.querySelector(".detail");
+      detail.hidden = !detail.hidden;
+      this.setAttribute("aria-expanded", detail.hidden ? "false" : "true");
+    });
+  }
+})();
+`
+
+const pageCSS = `
+:root {
+  color-scheme: light;
+  --ground: #ffffff;
+  --ink: #1f232b;
+  --soft: #5b6472;
+  --faint: #8b93a0;
+  --rule: #e3e6eb;
+  --well: #f4f5f7;
+  --hover: #f7f8fa;
+  --p0: #b3122e;
+  --p1: #d9480f;
+  --p2: #c08a1e;
+  --p3: #4a7fa3;
+  --empty: #e3e6eb;
+  --focus: #1f232b;
+  --display: "Avenir Next Condensed", "Avenir Next", "Helvetica Neue", Arial, sans-serif;
+  --ui: "Avenir Next", "Helvetica Neue", "Segoe UI", Arial, sans-serif;
+  --prose: Charter, "Iowan Old Style", "Sitka Text", Georgia, serif;
+  --code: "SF Mono", ui-monospace, Menlo, Consolas, monospace;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    color-scheme: dark;
+    --ground: #16191e;
+    --ink: #e8eaee;
+    --soft: #a9b0bb;
+    --faint: #737b87;
+    --rule: #2b3038;
+    --well: #1e2228;
+    --hover: #1c2026;
+    --p0: #f0506b;
+    --p1: #f57c3a;
+    --p2: #e0b14a;
+    --p3: #74a9cf;
+    --empty: #2b3038;
+    --focus: #e8eaee;
+  }
+}
+* { box-sizing: border-box; }
+html { background: var(--ground); }
+body {
+  margin: 0;
+  padding: 3rem clamp(1rem, 3vw, 3.5rem) 5rem;
+  color: var(--ink);
+  font: 16px/1.5 var(--ui);
+  -webkit-font-smoothing: antialiased;
+}
+button, input, select { font: inherit; color: inherit; }
+:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; }
+
+/* Masthead: the repo, what reviewed it, and how much it found. */
+.masthead {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) auto;
+  gap: 0.5rem 2rem;
+  align-items: end;
+}
+.masthead h1 {
+  margin: 0;
+  font-family: var(--display);
+  font-size: clamp(2.6rem, 6vw, 4.5rem);
+  font-weight: 700;
+  line-height: 0.95;
+  letter-spacing: -0.02em;
+}
+#repo { margin: 0.5rem 0 0; color: var(--soft); overflow-wrap: anywhere; }
+.lede {
+  max-width: 34rem;
+  margin: 1.4rem 0 0;
+  font-family: var(--prose);
+  font-size: 1.3rem;
+  line-height: 1.4;
+}
+.facts {
+  display: grid;
+  grid-template-columns: auto minmax(0, 1fr);
+  gap: 0.15rem 1rem;
+  margin: 0;
+  font-size: 0.9rem;
+}
+.facts dt { color: var(--faint); }
+.facts dd { margin: 0; font-variant-numeric: tabular-nums; }
+#commit { font-family: var(--code); font-size: 0.82rem; overflow-wrap: anywhere; }
+
+/* The tally: one bar split by severity, with the four counts under it. */
+.tally { margin: 2.5rem 0 0; }
+.total {
+  margin: 0 0 0.6rem;
+  font-family: var(--display);
+  font-size: 1.5rem;
+  font-weight: 600;
+}
+.total span { color: var(--soft); font-weight: 500; }
+#bar {
+  display: flex;
+  gap: 3px;
+  height: 0.9rem;
+}
+#bar .seg {
+  min-width: 0.5rem;
+  padding: 0;
+  border: 0;
+  border-radius: 2px;
+  cursor: pointer;
+}
+#bar .seg[aria-pressed="true"] { box-shadow: 0 0 0 2px var(--ground), 0 0 0 4px var(--ink); }
+#bar .seg:hover { filter: brightness(1.1); }
+.counts {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.3rem 1.8rem;
+  margin: 0.7rem 0 0;
+  padding: 0;
+  list-style: none;
+  font-size: 0.95rem;
+  font-variant-numeric: tabular-nums;
+}
+.counts li::before {
+  content: "";
+  display: inline-block;
+  width: 0.65rem;
+  height: 0.65rem;
+  margin-right: 0.45rem;
+  border-radius: 2px;
+  background: var(--empty);
+}
+#count-p0::before, .sev-P0 { background: var(--p0); }
+#count-p1::before, .sev-P1 { background: var(--p1); }
+#count-p2::before, .sev-P2 { background: var(--p2); }
+#count-p3::before, .sev-P3 { background: var(--p3); }
+
+/* The map: where in the tree the findings sit, one tick per finding. */
+.map-head {
+  margin: 3rem 0 0.25rem;
+  font-family: var(--display);
+  font-size: 1.5rem;
+  font-weight: 600;
+}
+.hint { margin: 0 0 1rem; color: var(--soft); font-size: 0.9rem; }
+#map {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(min(30rem, 100%), 1fr));
+  gap: 0 2.5rem;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+#map .area {
+  display: grid;
+  grid-template-columns: 9.5rem minmax(0, 1fr) 2.2rem;
+  gap: 0.9rem;
+  align-items: center;
+  width: 100%;
+  padding: 0.3rem 0.4rem;
+  background: transparent;
+  border: 0;
+  border-radius: 3px;
+  cursor: pointer;
+  text-align: left;
+}
+#map .area:hover { background: var(--hover); }
+#map .area[aria-pressed="true"] { background: var(--well); box-shadow: inset 3px 0 0 var(--ink); }
+.area-name {
+  overflow: hidden;
+  font-family: var(--code);
+  font-size: 0.8rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.track { display: block; }
+.ticks { display: flex; gap: 1px; min-width: 4px; }
+.tick { flex: 1 1 0; min-width: 1px; height: 1rem; border-radius: 1px; }
+.area-count { color: var(--soft); font-size: 0.85rem; text-align: right; font-variant-numeric: tabular-nums; }
+
+/* Controls stay on screen while the list scrolls. */
+.controls {
+  position: sticky;
+  top: 0;
+  z-index: 2;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.6rem 1.2rem;
+  align-items: center;
+  margin: 3rem 0 0;
+  padding: 0.9rem 0;
+  background: var(--ground);
+  border-bottom: 1px solid var(--rule);
+}
+.controls label { display: flex; gap: 0.45rem; align-items: center; color: var(--soft); font-size: 0.9rem; }
+select, input[type="search"] {
+  padding: 0.35rem 0.55rem;
+  color: var(--ink);
+  background: var(--ground);
+  border: 1px solid var(--rule);
+  border-radius: 4px;
+}
+select { max-width: 17rem; }
+input[type="search"] { width: 16rem; }
+#shown { margin-left: auto; color: var(--soft); font-size: 0.9rem; font-variant-numeric: tabular-nums; }
+
+/* Findings, grouped by file. */
+#findings { margin-top: 0.5rem; }
+.group { padding: 1.4rem 0 0.4rem; border-bottom: 1px solid var(--rule); }
+.group-head {
+  display: flex;
+  gap: 1rem;
+  align-items: baseline;
+  justify-content: space-between;
+  margin: 0 0 0.35rem;
+  font-family: var(--code);
+  font-size: 0.86rem;
+  font-weight: 600;
+  overflow-wrap: anywhere;
+}
+.group-head .dir { color: var(--faint); font-weight: 400; }
+.group-head .n { flex: none; color: var(--faint); font-family: var(--ui); font-weight: 400; }
+article.finding { margin: 0; }
+article.finding > button {
+  display: grid;
+  grid-template-columns: 2.6rem 5.2rem minmax(0, 1fr) auto;
+  gap: 0.9rem;
+  align-items: baseline;
+  width: 100%;
+  padding: 0.55rem 0.5rem;
+  background: transparent;
+  border: 0;
+  border-radius: 4px;
+  cursor: pointer;
+  text-align: left;
+}
+article.finding > button:hover { background: var(--hover); }
+.badge {
+  justify-self: start;
+  padding: 0.05rem 0.4rem;
+  border-radius: 3px;
+  color: #fff;
+  font-size: 0.75rem;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+}
+@media (prefers-color-scheme: dark) { .badge { color: #16191e; } }
+.lines { color: var(--faint); font-family: var(--code); font-size: 0.8rem; font-variant-numeric: tabular-nums; }
+.summary { font-family: var(--prose); font-size: 1rem; line-height: 1.45; overflow-wrap: anywhere; }
+.consequence { overflow-wrap: anywhere; }
+.tag { color: var(--faint); font-size: 0.8rem; }
+.tag-bug { color: var(--soft); }
+/* Open: the rest of the issue appears in place, and the impact and code sit under it. */
+.rest { display: none; }
+article.finding > button[aria-expanded="true"] { background: var(--well); border-radius: 4px 4px 0 0; }
+article.finding > button[aria-expanded="true"] .rest { display: inline; }
+article.finding > button[aria-expanded="true"] .lead { font-weight: 600; }
+.detail { display: none; }
+.detail:not([hidden]) {
+  display: grid;
+  grid-template-columns: minmax(0, 36rem) minmax(0, 1fr);
+  gap: 2rem;
+  margin: 0 0 1rem;
+  padding: 0.6rem 0.5rem 1.2rem 10.1rem;
+  background: var(--well);
+  border-radius: 0 0 4px 4px;
+}
+.prose { font-family: var(--prose); max-width: 38rem; }
+.consequence { margin: 0; color: var(--ink); line-height: 1.55; }
+.consequence::before { content: "Impact: "; color: var(--ink); font-family: var(--ui); font-size: 0.85rem; font-weight: 600; }
+.confidence { margin: 0.9rem 0 0; color: var(--faint); font-family: var(--ui); font-size: 0.82rem; }
+.code {
+  display: flex;
+  max-height: 24rem;
+  overflow: auto;
+  background: var(--ground);
+  border: 1px solid var(--rule);
+  border-radius: 5px;
+  align-self: start;
+}
+.gutter, .quote {
+  margin: 0;
+  padding: 0.8rem 0.9rem;
+  font-family: var(--code);
+  font-size: 0.78rem;
+  line-height: 1.55;
+  white-space: pre;
+}
+.gutter {
+  position: sticky;
+  left: 0;
+  flex: none;
+  padding-right: 0.7rem;
+  color: var(--faint);
+  background: var(--ground);
+  border-right: 1px solid var(--rule);
+  text-align: right;
+  user-select: none;
+}
+.quote { flex: 1; color: var(--ink); }
+.empty {
+  margin: 3rem 0;
+  font-family: var(--prose);
+  font-size: 1.15rem;
+  color: var(--soft);
+}
+@media (max-width: 760px) {
+  body { padding: 1.5rem 1rem 3rem; }
+  .masthead { grid-template-columns: 1fr; }
+  #map { grid-template-columns: 1fr; }
+  #map .area { grid-template-columns: 7rem minmax(0, 1fr) 2rem; }
+  article.finding > button { grid-template-columns: 2.6rem minmax(0, 1fr); }
+  .lines { grid-column: 2; grid-row: 2; }
+  .summary { grid-column: 2; grid-row: 1; }
+  .tag { display: none; }
+  .detail:not([hidden]) { grid-template-columns: 1fr; padding-left: 0.5rem; }
+  input[type="search"] { width: 100%; }
+  #shown { margin-left: 0; }
+}
+@media (prefers-reduced-motion: no-preference) {
+  article.finding > button, #map .area { transition: background-color 120ms ease; }
+}
+`
+
+// Render returns one HTML document. It has no external assets. The quote is the
+// excerpt of the cited lines; it is not a field of the findings file.
+func Render(p Page) []byte {
+	p0, p1, p2, p3 := severityCounts(p.Findings)
+	counts := []int{p0, p1, p2, p3}
+	total := len(p.Findings)
+	groups := groupByFile(p.Findings)
+	name := path.Base(p.Repo)
+	var b strings.Builder
+	fmt.Fprintf(&b, "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<title>%s source review</title>\n<style>", html.EscapeString(name))
+	b.WriteString(pageCSS)
+	b.WriteString("</style>\n</head>\n<body>\n<header class=\"masthead\">\n<div>\n")
+	fmt.Fprintf(&b, "<h1>%s</h1>\n", html.EscapeString(name))
+	fmt.Fprintf(&b, "<p class=\"meta\" id=\"repo\">%s</p>\n", html.EscapeString(p.Repo))
+	fmt.Fprintf(&b, "<p class=\"lede\">%s</p>\n", html.EscapeString(lede(p.ModelID, len(p.Files), counts)))
+	b.WriteString("</div>\n<dl class=\"facts\">\n")
+	fmt.Fprintf(&b, "<dt>Model</dt><dd class=\"meta\" id=\"model\">%s</dd>\n", html.EscapeString(p.ModelID))
+	fmt.Fprintf(&b, "<dt>Commit</dt><dd class=\"meta\" id=\"commit\">%s</dd>\n", html.EscapeString(p.Commit))
+	fmt.Fprintf(&b, "<dt>Reviewed</dt><dd>%s</dd>\n", plural(len(p.Files), "file", "files"))
+	b.WriteString("</dl>\n</header>\n")
+
+	b.WriteString("<section class=\"tally\">\n")
+	fmt.Fprintf(&b, "<p class=\"total\">%s <span>in %s</span></p>\n", plural(total, "finding", "findings"), plural(len(groups), "file", "files"))
+	b.WriteString("<div id=\"bar\">\n")
+	for i, s := range severities {
+		if counts[i] == 0 {
+			continue
+		}
+		fmt.Fprintf(&b, "<button type=\"button\" class=\"seg sev-%s\" data-severity=\"%s\" style=\"flex-grow:%d\" aria-pressed=\"false\" title=\"Show only %s\"><span hidden>%s</span></button>\n", s, s, counts[i], s, s)
+	}
+	b.WriteString("</div>\n<ul class=\"counts\">\n")
+	for i, s := range severities {
+		fmt.Fprintf(&b, "<li id=\"count-%s\">%s %d</li>\n", strings.ToLower(s), s, counts[i])
+	}
+	b.WriteString("</ul>\n</section>\n")
+
+	if total > 0 {
+		b.WriteString("<section>\n<h2 class=\"map-head\">Where the findings are</h2>\n")
+		b.WriteString("<p class=\"hint\">One mark per finding, worst first. Select an area to show only its findings.</p>\n<ul id=\"map\">\n")
+		rows := areaRows(p.Findings)
+		most := len(rows[0].severities)
+		for _, r := range rows {
+			fmt.Fprintf(&b, "<li><button type=\"button\" class=\"area\" data-area=\"%s\" aria-pressed=\"false\"><span class=\"area-name\">%s</span><span class=\"track\"><span class=\"ticks\" style=\"width:%.2f%%\">", html.EscapeString(r.name), html.EscapeString(r.name), 100*float64(len(r.severities))/float64(most))
+			for _, s := range r.severities {
+				fmt.Fprintf(&b, "<i class=\"tick sev-%s\"></i>", html.EscapeString(s))
+			}
+			fmt.Fprintf(&b, "</span></span><span class=\"area-count\">%d</span></button></li>\n", len(r.severities))
+		}
+		b.WriteString("</ul>\n</section>\n")
+	}
+
+	b.WriteString("<div class=\"controls\">\n")
+	b.WriteString("<label>Severity <select id=\"severity\">\n")
+	b.WriteString("<option value=\"\">all</option>\n<option value=\"P0\">P0</option>\n<option value=\"P1\">P1</option>\n<option value=\"P2\">P2</option>\n<option value=\"P3\">P3</option>\n")
+	b.WriteString("</select></label>\n")
+	b.WriteString("<label>Directory <select id=\"directory\">\n<option value=\"\">all</option>\n")
+	for _, d := range findingDirs(p.Findings) {
+		fmt.Fprintf(&b, "<option value=\"%s\">%s</option>\n", html.EscapeString(d), html.EscapeString(d))
+	}
+	b.WriteString("</select></label>\n")
+	b.WriteString("<label>Search <input type=\"search\" id=\"search\" placeholder=\"Words in the issue, file, or code\"></label>\n")
+	fmt.Fprintf(&b, "<p id=\"shown\">Showing all %d</p>\n", total)
+	b.WriteString("</div>\n<div id=\"findings\">\n")
+	if total == 0 {
+		fmt.Fprintf(&b, "<p class=\"empty\">No findings. %s reviewed %s and reported nothing to fix.</p>\n", html.EscapeString(p.ModelID), plural(len(p.Files), "file", "files"))
+	}
+	for _, g := range groups {
+		b.WriteString("<section class=\"group\">\n")
+		dirPart, base := path.Split(g.file)
+		fmt.Fprintf(&b, "<h3 class=\"group-head\"><span><span class=\"dir\">%s</span>%s</span><span class=\"n\">%s</span></h3>\n", html.EscapeString(dirPart), html.EscapeString(base), plural(len(g.findings), "finding", "findings"))
+		for _, f := range g.findings {
+			dir := path.Dir(f.File)
+			quote := ""
+			if p.Files != nil {
+				quote = excerpt(p.Files[f.File], f.StartLine, f.EndLine)
+			}
+			lines := fmt.Sprintf("L%d", f.StartLine)
+			if f.EndLine != f.StartLine {
+				lines = fmt.Sprintf("L%d–%d", f.StartLine, f.EndLine)
+			}
+			tag := string(f.Tag)
+			fmt.Fprintf(&b, "<article class=\"finding\" data-file=\"%s\" data-severity=\"%s\" data-dir=\"%s\" data-area=\"%s\">\n", html.EscapeString(f.File), html.EscapeString(f.Severity), html.EscapeString(dir), html.EscapeString(area(f.File)))
+			// The row shows the issue's first sentence; opening it reveals the rest in place.
+			issue := strings.TrimSpace(f.Issue)
+			lead := summary(issue)
+			fmt.Fprintf(&b, "<button type=\"button\" aria-expanded=\"false\"><span class=\"badge sev-%s\">%s</span><span class=\"lines\">%s</span><span class=\"summary issue\"><span class=\"lead\">%s</span><span class=\"rest\">%s</span></span><span class=\"tag tag-%s\">%s</span></button>\n",
+				html.EscapeString(f.Severity), html.EscapeString(f.Severity), lines, html.EscapeString(lead), html.EscapeString(issue[len(lead):]), html.EscapeString(tag), html.EscapeString(tag))
+			b.WriteString("<div class=\"detail\" hidden>\n<div class=\"prose\">\n")
+			fmt.Fprintf(&b, "<p class=\"consequence\">%s</p>\n", html.EscapeString(f.Consequence))
+			fmt.Fprintf(&b, "<p class=\"confidence\">Model confidence %d of 100</p>\n", f.Confidence)
+			b.WriteString("</div>\n<div class=\"code\">")
+			var gutter []string
+			for n := f.StartLine; quote != "" && n <= f.EndLine; n++ {
+				gutter = append(gutter, fmt.Sprint(n))
+			}
+			fmt.Fprintf(&b, "<pre class=\"gutter\" aria-hidden=\"true\">%s</pre>", strings.Join(gutter, "\n"))
+			fmt.Fprintf(&b, "<pre class=\"quote\">%s</pre>", html.EscapeString(quote))
+			b.WriteString("</div>\n</div>\n</article>\n")
+		}
+		b.WriteString("</section>\n")
+	}
+	b.WriteString("</div>\n<script id=\"page\">")
+	b.WriteString(pageScript)
+	b.WriteString("</script>\n</body>\n</html>\n")
+	return []byte(b.String())
+}
diff --git a/internal/sourcereview/page_test.go b/internal/sourcereview/page_test.go
new file mode 100644
index 00000000..bf82b92d
--- /dev/null
+++ b/internal/sourcereview/page_test.go
@@ -0,0 +1,426 @@
+package sourcereview
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/dsifry/metareview/internal/lensoutput"
+)
+
+func TestRenderFiltersAndQuote(t *testing.T) {
+	files := map[string][]byte{
+		"main.go":    []byte("package main\n"),
+		"pkg/app.go": []byte("alpha\nbeta\n"),
+		"a.go":       []byte("a\n"),
+		"b/c.go":     []byte("c\n"),
+	}
+	findings := []lensoutput.TypedFinding{
+		{Tag: lensoutput.TagBug, File: "main.go", StartLine: 1, EndLine: 1, Issue: "root broke", Consequence: "no entry", Confidence: 90, Severity: "P0"},
+		{Tag: lensoutput.TagAdvisory, File: "pkg/app.go", StartLine: 1, EndLine: 2, Issue: "alpha broke", Consequence: "wrong answer", Confidence: 70, Severity: "P1"},
+		{Tag: lensoutput.TagBug, File: "a.go", StartLine: 1, EndLine: 1, Issue: "a", Consequence: "a", Confidence: 60, Severity: "P2"},
+		{Tag: lensoutput.TagBug, File: "b/c.go", StartLine: 1, EndLine: 1, Issue: "c", Consequence: "c", Confidence: 50, Severity: "P3"},
+	}
+	page := Render(Page{Repo: "/repo", Commit: "abc123", ModelID: "opus", Findings: findings, Files: files})
+	html := string(page)
+	for _, want := range []string{
+		`id="repo">/repo`, `id="commit">abc123`, `id="model">opus`,
+		`id="count-p0">P0 1`, `id="count-p1">P1 1`, `id="count-p2">P2 1`, `id="count-p3">P3 1`,
+		`id="severity"`, `id="directory"`, `value="."`, `value="pkg"`,
+		"root broke", "no entry", "package main", "alpha broke", "wrong answer", "alpha\nbeta",
+	} {
+		if !strings.Contains(html, want) {
+			t.Fatalf("page missing %q", want)
+		}
+	}
+	if strings.Contains(html, "http://") || strings.Contains(html, "https://") || strings.Contains(html, "fetch(") || strings.Contains(html, "<form") || strings.Contains(html, "src=") {
+		t.Fatal("page is not self-contained")
+	}
+	if !strings.Contains(html, `<script id="page">`) {
+		t.Fatal("shipped script missing")
+	}
+	report := runPage(t, page)
+	if report.Counts["p0"] != "P0 1" || report.Counts["p3"] != "P3 1" {
+		t.Fatalf("counts %+v", report.Counts)
+	}
+	// The two findings the filter drives are the first two, which differ in
+	// severity and directory. The harness records what the shipped script did.
+	if len(report.Steps) < 2 {
+		t.Fatalf("steps %+v", report)
+	}
+	sev := report.Steps[0]
+	if sev.Displays[0] != "" || sev.Displays[1] != "none" {
+		t.Fatalf("severity filter displays %v", sev.Displays)
+	}
+	dir := report.Steps[1]
+	if dir.Displays[0] != "" || dir.Displays[1] != "none" {
+		t.Fatalf("directory filter displays %v", dir.Displays)
+	}
+	if report.Opened.Hidden || report.Opened.Expanded != "true" || report.Opened.Issue != "root broke" || report.Opened.Consequence != "no entry" || report.Opened.Quote != "package main" {
+		t.Fatalf("opened %+v", report.Opened)
+	}
+	if !report.Closed.Hidden || report.Closed.Expanded != "false" {
+		t.Fatalf("closed %+v", report.Closed)
+	}
+	all := []string{"", "", "", ""}
+	if report.Bar.Severity != "P0" || !reflectArgs(report.Bar.Displays, []string{"", "none", "none", "none"}) || report.Bar.Pressed != "true" || report.Bar.Shown != "Showing 1 of 4" {
+		t.Fatalf("bar %+v", report.Bar)
+	}
+	if report.BarCleared.Severity != "" || !reflectArgs(report.BarCleared.Displays, all) || report.BarCleared.Shown != "Showing all 4" {
+		t.Fatalf("bar cleared %+v", report.BarCleared)
+	}
+	// The biggest area is the repo root: main.go and a.go.
+	if report.Area.Name != "." || !reflectArgs(report.Area.Displays, []string{"", "none", "", "none"}) || !reflectArgs(report.Area.Groups, []string{"", "none", "", "none"}) || report.Area.Pressed != "true" {
+		t.Fatalf("area %+v", report.Area)
+	}
+	if !reflectArgs(report.AreaCleared.Displays, all) || report.AreaCleared.Pressed != "false" {
+		t.Fatalf("area cleared %+v", report.AreaCleared)
+	}
+	if !reflectArgs(report.Search.Displays, []string{"none", "", "none", "none"}) || report.Search.Shown != "Showing 1 of 4" {
+		t.Fatalf("search %+v", report.Search)
+	}
+	if !reflectArgs(report.FileSearch.Displays, []string{"none", "", "none", "none"}) || report.FileSearch.Shown != "Showing 1 of 4" {
+		t.Fatalf("filename search %+v", report.FileSearch)
+	}
+}
+
+func TestPageHelpers(t *testing.T) {
+	for n, want := range map[int]string{0: "0", 7: "7", 999: "999", 1000: "1,000", 1346: "1,346", 1234567: "1,234,567"} {
+		if got := thousands(n); got != want {
+			t.Fatalf("thousands(%d) = %q", n, got)
+		}
+	}
+	if plural(1, "file", "files") != "1 file" || plural(1346, "file", "files") != "1,346 files" {
+		t.Fatal("plural")
+	}
+	for _, c := range []struct {
+		counts []int
+		want   string
+	}{
+		{[]int{0, 0, 0, 0}, "Reviewed 3 files with opus and found nothing to report."},
+		{[]int{0, 37, 136, 123}, "Reviewed 3 files with opus. Start with the 37 at P1."},
+		{[]int{0, 0, 1, 0}, "Reviewed 3 files with opus. The one finding is a P2."},
+		{[]int{0, 0, 0, 2}, "Reviewed 3 files with opus. All 2 findings are P3."},
+	} {
+		if got := lede("opus", 3, c.counts); got != c.want {
+			t.Fatalf("lede %v = %q", c.counts, got)
+		}
+	}
+	if summary(" One. Two. ") != "One." || summary("No period") != "No period" || summary("v1.2 is out") != "v1.2 is out" {
+		t.Fatal("summary")
+	}
+	if area("main.go") != "." || area("app/x.rb") != "app" || area("app/models/concerns/x.rb") != "app/models" {
+		t.Fatal("area")
+	}
+	if severityRank("P0") != 0 || severityRank("P3") != 3 || severityRank("bogus") != 4 {
+		t.Fatal("severityRank")
+	}
+	f := func(file, sev string, line int) lensoutput.TypedFinding {
+		return lensoutput.TypedFinding{File: file, Severity: sev, StartLine: line, EndLine: line}
+	}
+	groups := groupByFile([]lensoutput.TypedFinding{
+		f("z.go", "P2", 9), f("z.go", "P2", 3), f("z.go", "P1", 5),
+		f("b.go", "P1", 1),
+		f("a.go", "P1", 1),
+		f("c.go", "P3", 1),
+	})
+	var order []string
+	for _, g := range groups {
+		order = append(order, g.file)
+	}
+	// Worst severity first; among equals, more findings first; then by path.
+	if !reflectArgs(order, []string{"z.go", "a.go", "b.go", "c.go"}) {
+		t.Fatalf("group order %v", order)
+	}
+	z := groups[0].findings
+	if z[0].StartLine != 5 || z[1].StartLine != 3 || z[2].StartLine != 9 {
+		t.Fatalf("findings in z.go %+v", z)
+	}
+	rows := areaRows([]lensoutput.TypedFinding{f("b/x.go", "P3", 1), f("a/x.go", "P3", 1), f("c/x.go", "P2", 1), f("c/y.go", "P1", 1)})
+	if rows[0].name != "c" || !reflectArgs(rows[0].severities, []string{"P1", "P2"}) || rows[1].name != "a" || rows[2].name != "b" {
+		t.Fatalf("area rows %+v", rows)
+	}
+}
+
+func TestRenderRangesAndGutter(t *testing.T) {
+	files := map[string][]byte{"pkg/app.go": []byte("alpha\nbeta\ngamma\n")}
+	page := string(Render(Page{Repo: "/src/app", Commit: "c", ModelID: "grok-4.7", Files: files, Findings: []lensoutput.TypedFinding{
+		{Tag: lensoutput.TagBug, File: "pkg/app.go", StartLine: 2, EndLine: 3, Issue: "First sentence. Second sentence.", Consequence: "bad", Confidence: 80, Severity: "P2"},
+	}}))
+	for _, want := range []string{
+		"<h1>app</h1>", "L2–3", `<pre class="gutter" aria-hidden="true">2` + "\n3</pre>", `<pre class="quote">beta` + "\ngamma</pre>",
+		`<span class="lead">First sentence.</span><span class="rest"> Second sentence.</span>`,
+		`<span class="dir">pkg/</span>app.go`, "Model confidence 80 of 100", "The one finding is a P2.", `data-area="pkg"`, `data-file="pkg/app.go"`,
+	} {
+		if !strings.Contains(page, want) {
+			t.Fatalf("page missing %q", want)
+		}
+	}
+}
+
+func TestRenderEmpty(t *testing.T) {
+	page := Render(Page{Repo: "r", Commit: "c", ModelID: "gpt-6-astra", Findings: nil, Files: nil})
+	html := string(page)
+	for _, id := range []string{"count-p0", "count-p1", "count-p2", "count-p3"} {
+		if !strings.Contains(html, `id="`+id+`">`) || !strings.Contains(html, "0") {
+			t.Fatalf("missing zero %s", id)
+		}
+	}
+	if strings.Contains(html, `class="finding"`) {
+		t.Fatal("empty page has a finding")
+	}
+	if !strings.Contains(html, `id="severity"`) || !strings.Contains(html, `id="directory"`) {
+		t.Fatal("filters missing")
+	}
+	if !strings.Contains(html, "No findings. gpt-6-astra reviewed 0 files and reported nothing to fix.") || strings.Contains(html, `id="map"`) || strings.Contains(html, `class="seg`) {
+		t.Fatal("empty page should explain itself and draw no map or bar segments")
+	}
+	report := runPage(t, page)
+	if report.FindingCount != 0 {
+		t.Fatalf("findings %d", report.FindingCount)
+	}
+	for _, k := range []string{"p0", "p1", "p2", "p3"} {
+		if !strings.HasSuffix(report.Counts[k], " 0") {
+			t.Fatalf("%s = %s", k, report.Counts[k])
+		}
+	}
+}
+
+type pageReport struct {
+	FindingCount int               `json:"findingCount"`
+	Counts       map[string]string `json:"counts"`
+	Steps        []struct {
+		Displays []string `json:"displays"`
+	} `json:"steps"`
+	Opened struct {
+		Hidden      bool   `json:"hidden"`
+		Expanded    string `json:"expanded"`
+		Issue       string `json:"issue"`
+		Consequence string `json:"consequence"`
+		Quote       string `json:"quote"`
+	} `json:"opened"`
+	Closed struct {
+		Hidden   bool   `json:"hidden"`
+		Expanded string `json:"expanded"`
+	} `json:"closed"`
+	Bar struct {
+		Severity string   `json:"severity"`
+		Displays []string `json:"displays"`
+		Pressed  string   `json:"pressed"`
+		Shown    string   `json:"shown"`
+	} `json:"bar"`
+	BarCleared struct {
+		Severity string   `json:"severity"`
+		Displays []string `json:"displays"`
+		Shown    string   `json:"shown"`
+	} `json:"barCleared"`
+	Area struct {
+		Name     string   `json:"name"`
+		Displays []string `json:"displays"`
+		Groups   []string `json:"groups"`
+		Pressed  string   `json:"pressed"`
+	} `json:"area"`
+	AreaCleared struct {
+		Displays []string `json:"displays"`
+		Pressed  string   `json:"pressed"`
+	} `json:"areaCleared"`
+	Search struct {
+		Displays []string `json:"displays"`
+		Shown    string   `json:"shown"`
+	} `json:"search"`
+	FileSearch struct {
+		Displays []string `json:"displays"`
+		Shown    string   `json:"shown"`
+	} `json:"fileSearch"`
+}
+
+func runPage(t *testing.T, page []byte) pageReport {
+	t.Helper()
+	dir := t.TempDir()
+	htmlPath := filepath.Join(dir, "page.html")
+	scriptPath := filepath.Join(dir, "dom.js")
+	if err := os.WriteFile(htmlPath, page, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(scriptPath, []byte(pageHarness), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	cmd := exec.Command("node", scriptPath, htmlPath)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("node: %v\n%s", err, out)
+	}
+	var report pageReport
+	if err := json.Unmarshal(out, &report); err != nil {
+		t.Fatalf("report: %v\n%s", err, out)
+	}
+	return report
+}
+
+const pageHarness = `
+const fs = require("fs");
+const html = fs.readFileSync(process.argv[2], "utf8");
+const m = html.match(/<script id="page">([\s\S]*)<\/script>/);
+if (!m) { console.error("no shipped script"); process.exit(1); }
+const script = m[1];
+
+function decode(s) {
+  return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+}
+function parseAttrs(s) {
+  const attrs = {};
+  const re = /([A-Za-z0-9:-]+)(?:\s*=\s*"([^"]*)")?/g;
+  let mm;
+  while ((mm = re.exec(s))) attrs[mm[1]] = decode(mm[2] ?? "");
+  return attrs;
+}
+class El {
+  constructor(name, attrs) {
+    this.name = name;
+    this.attrs = attrs || {};
+    this.children = [];
+    this.parentNode = null;
+    this.style = { display: "" };
+    this.hidden = Object.prototype.hasOwnProperty.call(this.attrs, "hidden");
+    this.value = this.attrs.value || "";
+    this._listeners = {};
+  }
+  getAttribute(k) { return Object.prototype.hasOwnProperty.call(this.attrs, k) ? this.attrs[k] : null; }
+  setAttribute(k, v) { this.attrs[k] = String(v); }
+  addEventListener(type, fn) { (this._listeners[type] ||= []).push(fn); }
+  dispatchEvent(type) { for (const fn of this._listeners[type] || []) fn.call(this); }
+  get textContent() { return this.children.map(c => c.textContent || "").join(""); }
+  set textContent(v) { this.children = [{ textContent: String(v), name: "" }]; }
+  querySelector(sel) { const a = queryAll(this, sel); return a[0] || null; }
+  querySelectorAll(sel) { return queryAll(this, sel); }
+}
+function classHas(n, c) { return (" " + (n.attrs.class || "") + " ").includes(" " + c + " "); }
+function matchesSimple(n, sel) {
+  if (!n || !n.name) return false;
+  if (sel.startsWith("#")) return n.attrs.id === sel.slice(1);
+  if (sel.startsWith(".")) return classHas(n, sel.slice(1));
+  return n.name === sel;
+}
+function descendants(n) {
+  const out = [];
+  for (const c of n.children || []) {
+    if (!c.name) continue;
+    out.push(c);
+    out.push(...descendants(c));
+  }
+  return out;
+}
+function queryAll(root, sel) {
+  sel = sel.trim();
+  const gt = sel.indexOf(">");
+  if (gt >= 0) {
+    const left = sel.slice(0, gt).trim();
+    const right = sel.slice(gt + 1).trim();
+    const out = [];
+    for (const p of queryAll(root, left)) {
+      for (const c of p.children) if (c.name && matchesSimple(c, right)) out.push(c);
+    }
+    return out;
+  }
+  const parts = sel.split(/\s+/).filter(Boolean);
+  let cur = [root];
+  for (const part of parts) {
+    const next = [];
+    for (const n of cur) for (const d of descendants(n)) if (matchesSimple(d, part)) next.push(d);
+    cur = next;
+  }
+  return cur;
+}
+const voidTags = new Set(["meta", "link", "br", "img", "input"]);
+function parseHTML(src) {
+  const root = new El("#document", {});
+  const stack = [root];
+  const re = /<!DOCTYPE[^>]*>|<!--[\s\S]*?-->|<\/([A-Za-z0-9]+)>|<([A-Za-z0-9]+)([^>]*)>|([^<]+)/g;
+  let mm;
+  while ((mm = re.exec(src))) {
+    if (mm[1]) {
+      const name = mm[1].toLowerCase();
+      while (stack.length > 1 && stack[stack.length - 1].name !== name) stack.pop();
+      if (stack.length > 1) stack.pop();
+    } else if (mm[2]) {
+      const name = mm[2].toLowerCase();
+      const el = new El(name, parseAttrs(mm[3] || ""));
+      const parent = stack[stack.length - 1];
+      parent.children.push(el);
+      el.parentNode = parent;
+      const selfClose = /\/\s*$/.test(mm[3] || "") || voidTags.has(name);
+      if (!selfClose) stack.push(el);
+    } else if (mm[4]) {
+      stack[stack.length - 1].children.push({ textContent: decode(mm[4]), name: "" });
+    }
+  }
+  return root;
+}
+const root = parseHTML(html);
+const document = {
+  getElementById(id) {
+    const hit = descendants(root).filter(n => n.attrs && n.attrs.id === id);
+    return hit[0] || null;
+  },
+  querySelectorAll(sel) { return queryAll(root, sel); },
+};
+try { new Function("document", script)(document); }
+catch (e) { console.error(String(e)); process.exit(1); }
+const findings = document.querySelectorAll("#findings .finding");
+const counts = {};
+for (const id of ["p0", "p1", "p2", "p3"]) counts[id] = document.getElementById("count-" + id).textContent.trim();
+const report = { findingCount: findings.length, counts, steps: [], opened: {} };
+if (findings.length >= 2) {
+  const sev = document.getElementById("severity");
+  sev.value = findings[0].getAttribute("data-severity");
+  sev.dispatchEvent("change");
+  report.steps.push({ displays: findings.map(f => f.style.display) });
+  sev.value = "";
+  const dir = document.getElementById("directory");
+  dir.value = findings[0].getAttribute("data-dir");
+  dir.dispatchEvent("change");
+  report.steps.push({ displays: findings.map(f => f.style.display) });
+  dir.value = "";
+  dir.dispatchEvent("change");
+  const btn = findings[0].querySelector("button");
+  btn.dispatchEvent("click");
+  const detail = findings[0].querySelector(".detail");
+  report.opened = {
+    hidden: detail.hidden,
+    expanded: btn.getAttribute("aria-expanded"),
+    issue: findings[0].querySelector(".issue").textContent.trim(),
+    consequence: findings[0].querySelector(".consequence").textContent.trim(),
+    quote: findings[0].querySelector(".quote").textContent.trim(),
+  };
+  btn.dispatchEvent("click");
+  report.closed = { hidden: detail.hidden, expanded: btn.getAttribute("aria-expanded") };
+  const displays = () => findings.map(f => f.style.display);
+  const groupDisplays = () => document.querySelectorAll("#findings .group").map(g => g.style.display);
+  const shown = () => document.getElementById("shown").textContent;
+  // The severity bar: one click selects that severity, a second click clears it.
+  const seg = document.querySelectorAll("#bar .seg")[0];
+  seg.dispatchEvent("click");
+  report.bar = { severity: sev.value, displays: displays(), pressed: seg.getAttribute("aria-pressed"), shown: shown() };
+  seg.dispatchEvent("click");
+  report.barCleared = { severity: sev.value, displays: displays(), shown: shown() };
+  // The map: one click shows only that area and hides the other files' groups.
+  const areaBtn = document.querySelectorAll("#map .area")[0];
+  areaBtn.dispatchEvent("click");
+  report.area = { name: areaBtn.getAttribute("data-area"), displays: displays(), groups: groupDisplays(), pressed: areaBtn.getAttribute("aria-pressed") };
+  areaBtn.dispatchEvent("click");
+  report.areaCleared = { displays: displays(), pressed: areaBtn.getAttribute("aria-pressed") };
+  // Search matches the finding's text, case-insensitively.
+  const search = document.getElementById("search");
+  search.value = findings[1].querySelector(".issue").textContent.trim().toUpperCase();
+  search.dispatchEvent("input");
+  report.search = { displays: displays(), shown: shown() };
+  // Filename matching is separate from issue/snippet text and ignores case.
+  search.value = findings[1].getAttribute("data-file").split("/").pop().toUpperCase();
+  search.dispatchEvent("input");
+  report.fileSearch = { displays: displays(), shown: shown() };
+}
+process.stdout.write(JSON.stringify(report));
+`
diff --git a/internal/sourcereview/parse.go b/internal/sourcereview/parse.go
new file mode 100644
index 00000000..be9a3f86
--- /dev/null
+++ b/internal/sourcereview/parse.go
@@ -0,0 +1,233 @@
+package sourcereview
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"path"
+	"strings"
+
+	"github.com/dsifry/metareview/internal/lensoutput"
+)
+
+// wireEntry matches internal/lensoutput.wireEntry: a missing field is a nil
+// pointer. This command fails the run on that pointer; it does not call
+// ValidatePayload.
+type wireEntry struct {
+	Tag         *string `json:"tag"`
+	File        *string `json:"file"`
+	StartLine   *int    `json:"start_line"`
+	EndLine     *int    `json:"end_line"`
+	Issue       *string `json:"issue"`
+	Consequence *string `json:"consequence"`
+	Confidence  *int    `json:"confidence"`
+	Severity    *string `json:"severity"`
+}
+
+// Parse reads model text as {"findings":[...]}. files maps a kept path to its
+// committed bytes so line numbers can be checked against that file. A finding
+// that does not resolve to one kept file is skipped. The skipped messages are
+// the second result. The whole text fails only when it has no findings object.
+func Parse(text string, files map[string][]byte) ([]lensoutput.TypedFinding, []string, error) {
+	body, err := extractFindings(text)
+	if err != nil {
+		return nil, nil, err
+	}
+	var top struct {
+		Findings []json.RawMessage `json:"findings"`
+	}
+	_ = json.Unmarshal([]byte(body), &top)
+	out := make([]lensoutput.TypedFinding, 0, len(top.Findings))
+	var skipped []string
+	for _, raw := range top.Findings {
+		f, err := decodeEntry(raw)
+		if err != nil {
+			skipped = append(skipped, err.Error())
+			continue
+		}
+		if err := f.Validate(); err != nil {
+			skipped = append(skipped, err.Error())
+			continue
+		}
+		kept, err := resolveKept(f.File, files)
+		if err != nil {
+			skipped = append(skipped, err.Error())
+			continue
+		}
+		f.File = kept
+		if f.EndLine > lineCount(files[kept]) {
+			skipped = append(skipped, fmt.Sprintf("line numbers do not exist in %s", f.File))
+			continue
+		}
+		out = append(out, f)
+	}
+	return out, skipped, nil
+}
+
+// resolveKept accepts the path the model wrote. An exact kept path wins.
+// Otherwise a path matches when exactly one kept path ends with "/" plus the
+// citation, so "vite.config.js" means "web/vite.config.js" when that is the
+// only such file. Zero matches or two matches fail the run.
+func resolveKept(cited string, files map[string][]byte) (string, error) {
+	if _, ok := files[cited]; ok {
+		return cited, nil
+	}
+	shown := cited
+	cited = strings.ReplaceAll(strings.TrimSpace(cited), "\\", "/")
+	// Only a complete parent-directory component is traversal. Literal dots
+	// in a kept file or directory name must not discard a valid citation.
+	if cited == "" || strings.Contains("/"+cited+"/", "/../") {
+		return "", fmt.Errorf("file is not kept: %s", shown)
+	}
+	cited = strings.TrimPrefix(cited, "./")
+	cited = strings.TrimPrefix(cited, "/")
+	cited = path.Clean(cited)
+	if cited == "." {
+		return "", fmt.Errorf("file is not kept: %s", shown)
+	}
+	if _, ok := files[cited]; ok {
+		return cited, nil
+	}
+	match := ""
+	for p := range files {
+		if strings.HasSuffix(p, "/"+cited) {
+			if match != "" {
+				return "", fmt.Errorf("file matches more than one kept path: %s", cited)
+			}
+			match = p
+		}
+	}
+	if match == "" {
+		return "", fmt.Errorf("file is not kept: %s", cited)
+	}
+	return match, nil
+}
+
+func decodeEntry(raw json.RawMessage) (lensoutput.TypedFinding, error) {
+	var w wireEntry
+	if err := json.Unmarshal(raw, &w); err != nil {
+		return lensoutput.TypedFinding{}, fmt.Errorf("finding: %w", err)
+	}
+	if w.Tag == nil || w.File == nil || w.StartLine == nil || w.EndLine == nil ||
+		w.Issue == nil || w.Consequence == nil || w.Confidence == nil || w.Severity == nil {
+		return lensoutput.TypedFinding{}, errors.New("missing field")
+	}
+	return lensoutput.TypedFinding{
+		Tag:         lensoutput.Tag(*w.Tag),
+		File:        *w.File,
+		StartLine:   *w.StartLine,
+		EndLine:     *w.EndLine,
+		Issue:       *w.Issue,
+		Consequence: *w.Consequence,
+		Confidence:  *w.Confidence,
+		Severity:    *w.Severity,
+	}, nil
+}
+
+// extractFindings returns the findings object. A clean object or one fence is
+// preferred. If the model wrote prose around the object, the first JSON value
+// that contains a findings array is used.
+func extractFindings(text string) (string, error) {
+	if body, err := objectText(text); err == nil && findingsObject(body) {
+		return body, nil
+	}
+	for i := 0; i < len(text); i++ {
+		if text[i] != '{' {
+			continue
+		}
+		dec := json.NewDecoder(strings.NewReader(text[i:]))
+		var raw json.RawMessage
+		if err := dec.Decode(&raw); err != nil {
+			continue
+		}
+		if findingsObject(string(raw)) {
+			return string(raw), nil
+		}
+	}
+	if strings.TrimSpace(text) == "" {
+		return "", errors.New("missing model text")
+	}
+	return "", errors.New("missing findings object")
+}
+
+func findingsObject(s string) bool {
+	dec := json.NewDecoder(strings.NewReader(s))
+	var top struct {
+		Findings []json.RawMessage `json:"findings"`
+	}
+	if err := dec.Decode(&top); err != nil || top.Findings == nil {
+		return false
+	}
+	var extra struct{}
+	return errors.Is(dec.Decode(&extra), io.EOF)
+}
+
+// objectText trims surrounding whitespace and, when the text is one fence whose
+// body is the object, returns that body. Any other extra text fails.
+func objectText(text string) (string, error) {
+	s := strings.TrimSpace(text)
+	if s == "" {
+		return "", errors.New("missing model text")
+	}
+	s = strings.ReplaceAll(s, "\r\n", "\n")
+	lines := strings.Split(s, "\n")
+	for i := range lines {
+		lines[i] = strings.TrimSuffix(lines[i], "\r")
+	}
+	if strings.HasPrefix(lines[0], "```") {
+		word := strings.TrimSpace(lines[0][3:])
+		if word != "" && !lettersOnly(word) {
+			return "", errors.New("malformed fence")
+		}
+		if len(lines) < 2 || strings.TrimSpace(lines[len(lines)-1]) != "```" {
+			return "", errors.New("malformed fence")
+		}
+		body := strings.TrimSpace(strings.Join(lines[1:len(lines)-1], "\n"))
+		if body == "" {
+			return "", errors.New("missing findings object")
+		}
+		return body, nil
+	}
+	return s, nil
+}
+
+func lettersOnly(s string) bool {
+	for _, r := range s {
+		if r < 'A' || (r > 'Z' && r < 'a') || r > 'z' {
+			return false
+		}
+	}
+	return true
+}
+
+func lineCount(b []byte) int {
+	if len(b) == 0 {
+		return 0
+	}
+	n := bytes.Count(b, []byte("\n"))
+	if b[len(b)-1] != '\n' {
+		n++
+	}
+	return n
+}
+
+func splitLines(body []byte) []string {
+	n := lineCount(body)
+	if n == 0 {
+		return nil
+	}
+	lines := make([]string, 0, n)
+	rest := body
+	for len(lines) < n {
+		i := bytes.IndexByte(rest, '\n')
+		if i < 0 {
+			lines = append(lines, string(rest))
+			break
+		}
+		lines = append(lines, string(rest[:i]))
+		rest = rest[i+1:]
+	}
+	return lines
+}
diff --git a/internal/sourcereview/parse_test.go b/internal/sourcereview/parse_test.go
new file mode 100644
index 00000000..534d9df5
--- /dev/null
+++ b/internal/sourcereview/parse_test.go
@@ -0,0 +1,213 @@
+package sourcereview
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/dsifry/metareview/internal/lensoutput"
+)
+
+func keptFiles() map[string][]byte {
+	return map[string][]byte{
+		"pkg/app.go": []byte("package pkg\nfunc App() int { return 1 }\n"),
+		"main.go":    []byte("package main\n"),
+	}
+}
+
+func validEntry() string {
+	return `{"tag":"bug","file":"pkg/app.go","start_line":1,"end_line":2,"issue":"off by one","consequence":"wrong answer","confidence":80,"severity":"P1"}`
+}
+
+func TestParseAccepts(t *testing.T) {
+	files := keptFiles()
+	got, _, err := Parse(`{"findings":[]}`, files)
+	if err != nil || len(got) != 0 {
+		t.Fatalf("empty: %v %v", got, err)
+	}
+	got, _, err = Parse(" \n"+`{"findings":[`+validEntry()+"]}\n", files)
+	if err != nil || len(got) != 1 {
+		t.Fatal(err)
+	}
+	if err := got[0].Validate(); err != nil {
+		t.Fatal(err)
+	}
+	if got[0].File != "pkg/app.go" || got[0].StartLine != 1 || got[0].EndLine != 2 || got[0].Confidence != 80 {
+		t.Fatalf("%+v", got[0])
+	}
+	fenced := "```json\n{\"findings\":[" + validEntry() + "]}\n```"
+	if _, _, err := Parse(fenced, files); err != nil {
+		t.Fatal(err)
+	}
+	bare := "```\n{\"findings\":[]}\n```"
+	if _, _, err := Parse(bare, files); err != nil {
+		t.Fatal(err)
+	}
+	crlf := "```json\r\n{\"findings\":[]}\r\n```"
+	if _, _, err := Parse(crlf, files); err != nil {
+		t.Fatal(err)
+	}
+	adv := strings.Replace(validEntry(), `"tag":"bug"`, `"tag":"advisory"`, 1)
+	adv = strings.Replace(adv, `"confidence":80`, `"confidence":0`, 1)
+	adv = strings.Replace(adv, `"severity":"P1"`, `"severity":"P0"`, 1)
+	if _, _, err := Parse(`{"findings":[`+adv+`]}`, files); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestParseRejects(t *testing.T) {
+	files := keptFiles()
+	bad := []string{
+		"",
+		"   ",
+		`{"findings":null}`,
+		`{}`,
+		"```\n```",
+		"```json\nnot json\n```",
+		`not json`,
+		`{not json`,
+	}
+	for _, text := range bad {
+		if _, _, err := Parse(text, files); err == nil {
+			t.Fatalf("accepted %q", text)
+		}
+	}
+	for _, text := range []string{
+		"```json5\n{\"findings\":[]}\n```",
+		"```json\n{\"findings\":[]}",
+		`{"findings":[]} trailing`,
+		`{"nope":1} {"findings":[]}`,
+	} {
+		if _, _, err := Parse(text, files); err != nil {
+			t.Fatalf("object inside fence: %v %q", err, text)
+		}
+	}
+	prose := "The review follows.\n" + `{"findings":[]}` + "\nThanks."
+	if got, _, err := Parse(prose, files); err != nil || len(got) != 0 {
+		t.Fatalf("prose around object: %v %v", got, err)
+	}
+}
+
+func TestParseSkipsBadFindings(t *testing.T) {
+	files := keptFiles()
+	good := validEntry()
+	bad := strings.Replace(validEntry(), `"pkg/app.go"`, `"missing.go"`, 1)
+	got, skipped, err := Parse(`{"findings":[`+good+`,`+bad+`]}`, files)
+	if err != nil || len(got) != 1 || got[0].File != "pkg/app.go" || len(skipped) != 1 {
+		t.Fatalf("got %d skipped %v err %v", len(got), skipped, err)
+	}
+	over := strings.Replace(validEntry(), `"confidence":80`, `"confidence":101`, 1)
+	got, skipped, err = Parse(`{"findings":[`+over+`]}`, files)
+	if err != nil || len(got) != 0 || len(skipped) != 1 {
+		t.Fatalf("confidence 101: got %d skipped %v err %v", len(got), skipped, err)
+	}
+	full := strings.Replace(validEntry(), `"confidence":80`, `"confidence":100`, 1)
+	got, _, err = Parse(`{"findings":[`+full+`]}`, files)
+	if err != nil || got[0].Confidence != 100 || got[0].Tag != lensoutput.TagBug {
+		t.Fatal(err)
+	}
+	line := strings.Replace(validEntry(), `"end_line":2`, `"end_line":9`, 1)
+	if _, skipped, err = Parse(`{"findings":[`+line+`]}`, files); err != nil || len(skipped) != 1 {
+		t.Fatal(err, skipped)
+	}
+	if _, skipped, err = Parse(`{"findings":[1]}`, files); err != nil || len(skipped) != 1 {
+		t.Fatal(err, skipped)
+	}
+	if _, skipped, err = Parse(`{"findings":[{"tag":"bug"}]}`, files); err != nil || len(skipped) != 1 {
+		t.Fatal(err, skipped)
+	}
+}
+
+func TestResolveShortPath(t *testing.T) {
+	files := map[string][]byte{
+		"web/vite.config.js": []byte("export default {}\n"),
+		"pkg/app.go":         []byte("package pkg\n"),
+		"cmd/app.go":         []byte("package cmd\n"),
+	}
+	text := `{"findings":[{"tag":"bug","file":"vite.config.js","start_line":1,"end_line":1,"issue":"i","consequence":"c","confidence":80,"severity":"P1"}]}`
+	got, _, err := Parse(text, files)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got[0].File != "web/vite.config.js" {
+		t.Fatalf("file %s", got[0].File)
+	}
+	dotted := strings.Replace(text, `"vite.config.js"`, `"./web/vite.config.js"`, 1)
+	got, _, err = Parse(dotted, files)
+	if err != nil || got[0].File != "web/vite.config.js" {
+		t.Fatalf("%v %+v", err, got)
+	}
+	slash := strings.Replace(text, `"vite.config.js"`, `"web\\\\vite.config.js"`, 1)
+	got, _, err = Parse(slash, files)
+	if err != nil || got[0].File != "web/vite.config.js" {
+		t.Fatalf("backslash %v %+v", err, got)
+	}
+	short := strings.Replace(text, `"vite.config.js"`, `"app.go"`, 1)
+	if _, skipped, err := Parse(short, files); err != nil || len(skipped) != 1 || !strings.Contains(skipped[0], "more than one") {
+		t.Fatal(err, skipped)
+	}
+	missing := strings.Replace(text, `"vite.config.js"`, `"nope.js"`, 1)
+	if _, skipped, err := Parse(missing, files); err != nil || len(skipped) != 1 || !strings.Contains(skipped[0], "not kept") {
+		t.Fatal(err, skipped)
+	}
+	escape := strings.Replace(text, `"vite.config.js"`, `"../vite.config.js"`, 1)
+	if _, skipped, err := Parse(escape, files); err != nil || len(skipped) != 1 {
+		t.Fatal(err, skipped)
+	}
+	if _, err := resolveKept("  ", files); err == nil {
+		t.Fatal("blank")
+	}
+	if _, err := resolveKept("./", files); err == nil {
+		t.Fatal("dot")
+	}
+}
+
+func TestResolveKeptLiteralDoubleDots(t *testing.T) {
+	files := map[string][]byte{
+		"web/.. -t=silently/coverage/index.html": []byte("source\n"),
+		"pkg/file..name.go":                      []byte("source\n"),
+	}
+	for p := range files {
+		got, err := resolveKept(p, files)
+		if err != nil || got != p {
+			t.Fatalf("valid kept path %q was rejected: %q %v", p, got, err)
+		}
+	}
+	for _, p := range []string{"..", "../pkg/file..name.go", "other/../pkg/file..name.go", "pkg/..", `other\..\pkg\file..name.go`} {
+		if _, err := resolveKept(p, files); err == nil {
+			t.Fatalf("parent traversal accepted: %q", p)
+		}
+	}
+}
+
+func TestLineCountAndSplit(t *testing.T) {
+	if lineCount(nil) != 0 || splitLines(nil) != nil {
+		t.Fatal("empty")
+	}
+	if lineCount([]byte("a\n")) != 1 || len(splitLines([]byte("a\n"))) != 1 {
+		t.Fatal("one line")
+	}
+	if lineCount([]byte("a\nb")) != 2 {
+		t.Fatal("no trailing newline")
+	}
+	if lineCount([]byte("\n")) != 1 || splitLines([]byte("\n"))[0] != "" {
+		t.Fatal("blank line")
+	}
+	if lineCount([]byte("\n\n")) != 2 || len(splitLines([]byte("\n\n"))) != 2 {
+		t.Fatal("two blanks")
+	}
+	if excerpt([]byte("a\nb\n"), 1, 2) != "a\nb" {
+		t.Fatal(excerpt([]byte("a\nb\n"), 1, 2))
+	}
+	if excerpt([]byte("a\n"), 0, 1) != "" || excerpt([]byte("a\n"), 1, 3) != "" || excerpt([]byte("a\n"), 2, 1) != "" {
+		t.Fatal("excerpt guards")
+	}
+}
+
+func TestObjectTextFenceWord(t *testing.T) {
+	if _, err := objectText("```JSON\n{\"findings\":[]}\n```"); err != nil {
+		t.Fatal(err)
+	}
+	if lettersOnly("json") != true || lettersOnly("json5") != false || lettersOnly("") != true {
+		t.Fatal("lettersOnly")
+	}
+}
diff --git a/internal/sourcereview/regression_test.go b/internal/sourcereview/regression_test.go
new file mode 100644
index 00000000..2ed0e1f0
--- /dev/null
+++ b/internal/sourcereview/regression_test.go
@@ -0,0 +1,360 @@
+package sourcereview
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+	"syscall"
+	"testing"
+	"time"
+)
+
+func TestClaudeStructuredOutput(t *testing.T) {
+	for _, envelope := range []string{
+		`{"structured_output":{"findings":[]}}`,
+		`{"result":"","structured_output":{"findings":[]}}`,
+		`{"result":"Review complete","structured_output":{"findings":[]}}`,
+		`{"result":"{\"findings\":[]}","structured_output":null}`,
+	} {
+		got, err := claudeModelText([]byte(envelope))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, _, err := Parse(got, keptFiles()); err != nil {
+			t.Fatalf("valid output rejected: %s: %v", envelope, err)
+		}
+	}
+	for _, envelope := range []string{
+		`{"structured_output":"not an object","result":"{\"findings\":[]}"}`,
+		`{"structured_output":{"findings":[]},"is_error":true}`,
+		`{"structured_output":{"findings":[]},"stop_reason":"max_tokens"}`,
+	} {
+		if _, err := claudeModelText([]byte(envelope)); err == nil {
+			t.Fatalf("accepted failed/malformed response: %s", envelope)
+		}
+	}
+}
+
+func TestEmptyPathIsRejected(t *testing.T) {
+	for _, files := range [][]File{nil, {{Path: "a.go"}}} {
+		if _, err := onlyPaths(files, []string{""}); err == nil {
+			t.Fatal("empty filter accepted")
+		}
+	}
+	if _, _, _, err := selectPaths("", nil, []string{""}); err == nil {
+		t.Fatal("empty filter reached git")
+	}
+	if _, err := parseArgs([]string{"--model", "grok", "--output", "/tmp/out", "--path", ""}); err == nil {
+		t.Fatal("CLI accepted empty filter")
+	}
+}
+
+func TestSelectPinnedCommit(t *testing.T) {
+	old := []byte("package a\n// old revision\n")
+	root, first := newRepoBytes(t, map[string][]byte{"a.go": old})
+	changed := false
+	git := func(dir string, args []string, stdin []byte) ([]byte, error) {
+		if args[0] == "ls-tree" && !changed {
+			changed = true
+			if err := os.WriteFile(filepath.Join(root, "a.go"), []byte("package a\n// new revision\n"), 0o600); err != nil {
+				t.Fatal(err)
+			}
+			gitRun(t, root, "add", "a.go")
+			gitRun(t, root, "commit", "-m", "concurrent update")
+		}
+		return realGit(dir, args, stdin)
+	}
+	kept, _, commit, err := Select(root, git)
+	if err != nil || commit != first || len(kept) != 1 || !bytes.Equal(kept[0].Body, old) {
+		t.Fatalf("snapshot changed: %v %s %v", err, commit, kept)
+	}
+}
+
+func TestSelectFiltersBeforeBlobReads(t *testing.T) {
+	root, commit := newRepoBytes(t, map[string][]byte{
+		"a.go":          []byte("package a\n"),
+		"other.go":      []byte("package other\n"),
+		"vendor/lib.go": bytes.Repeat([]byte("x"), 1<<20),
+		"docs/a\nb.md":  []byte("documentation\n"),
+	})
+	id, err := realGit(root, []string{"rev-parse", commit + ":a.go"}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var request []byte
+	git := func(dir string, args []string, stdin []byte) ([]byte, error) {
+		if args[0] == "cat-file" {
+			request = append(request, stdin...)
+		}
+		return realGit(dir, args, stdin)
+	}
+	kept, _, _, err := selectPaths(root, git, []string{"a.go"})
+	if err != nil || len(kept) != 1 || !bytes.Equal(request, id) {
+		t.Fatalf("loaded blobs outside the selected scope: %q want %q; %v", request, id, err)
+	}
+}
+
+func TestSelectNewlineFilenames(t *testing.T) {
+	body := []byte("package a\n")
+	root, _ := newRepoBytes(t, map[string][]byte{"pkg/a\nb.go": body, "docs/a\nb.md": []byte("docs\n")})
+	kept, dropped, _, err := Select(root, nil)
+	if err != nil || len(kept) != 1 || kept[0].Path != "pkg/a\nb.go" || !bytes.Equal(kept[0].Body, body) || len(dropped) != 1 {
+		t.Fatalf("newline paths: kept=%v dropped=%v err=%v", kept, dropped, err)
+	}
+}
+
+func TestExactFindingFilenameWinsOverNormalization(t *testing.T) {
+	files := map[string][]byte{
+		"\napp.go": []byte("package newline\n"), "app.go": []byte("package app\n"),
+		"pkg/a\\b.go": []byte("package backslash\n"), "pkg/a/b.go": []byte("package slash\n"),
+		" app.go ": []byte("package spaced\n"),
+	}
+	for cited := range files {
+		text := fmt.Sprintf(`{"findings":[{"tag":"bug","file":%q,"start_line":1,"end_line":1,"issue":"i","consequence":"c","confidence":80,"severity":"P1"}]}`, cited)
+		got, skipped, err := Parse(text, files)
+		if err != nil || len(skipped) != 0 || len(got) != 1 || got[0].File != cited {
+			t.Fatalf("exact filename changed: cited=%q got=%v skipped=%v err=%v", cited, got, skipped, err)
+		}
+	}
+}
+
+func TestRunContextCancellation(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	if err := Run(Options{Context: ctx}); !errors.Is(err, context.Canceled) {
+		t.Fatal(err)
+	}
+	// Cancellation and an available worker slot can both be selected. Neither
+	// outcome may launch a call or turn an already canceled review into success.
+	for i := 0; i < 64; i++ {
+		if _, err := review(Options{Context: ctx}, [][]byte{[]byte("unused")}, nil); !errors.Is(err, context.Canceled) {
+			t.Fatal(err)
+		}
+	}
+	if err := writeOutputs(Options{Context: ctx}, "", "", "opus", nil, nil); !errors.Is(err, context.Canceled) {
+		t.Fatal(err)
+	}
+	root, _ := newRepoBytes(t, specFiles())
+	ctx, cancel = context.WithCancel(context.Background())
+	defer cancel()
+	git := func(dir string, args []string, stdin []byte) ([]byte, error) {
+		out, err := realGit(dir, args, stdin)
+		if args[0] == "cat-file" {
+			cancel()
+		}
+		return out, err
+	}
+	if err := Run(Options{Context: ctx, Repo: root, Model: "grok", OutputDir: t.TempDir(), Git: git}); !errors.Is(err, context.Canceled) {
+		t.Fatal(err)
+	}
+}
+
+func TestRunCancellationStopsQueuedCalls(t *testing.T) {
+	root, _ := fivePrompts(t)
+	out := t.TempDir()
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	runner := &fakeRunner{wait: func(context.Context, []byte) error {
+		cancel()
+		return nil // Even a runner that ignores cancellation must not publish.
+	}, reply: func(int, string, []string, []byte) ([]byte, error) {
+		return cliStdout("opus", `{"findings":[]}`), nil
+	}}
+	err := Run(Options{Context: ctx, Repo: root, Model: "opus", OutputDir: out, Jobs: 1, Runner: runner})
+	if !errors.Is(err, context.Canceled) || len(runner.callList()) != 1 {
+		t.Fatalf("err=%v calls=%d", err, len(runner.callList()))
+	}
+	if entries, _ := os.ReadDir(out); len(entries) != 0 {
+		t.Fatal("published canceled review")
+	}
+}
+
+type cancelWriter struct{ cancel context.CancelFunc }
+
+func (w cancelWriter) Write(p []byte) (int, error) {
+	w.cancel()
+	return len(p), nil
+}
+
+func TestReviewCanceledAfterResponse(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	runner := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+		return cliStdout("opus", `{"findings":[]}`), nil
+	}}
+	_, err := review(Options{Context: ctx, Model: "opus", Runner: runner, Stdout: io.Discard, Stderr: cancelWriter{cancel}}, [][]byte{[]byte("prompt")}, nil)
+	if !errors.Is(err, context.Canceled) {
+		t.Fatal(err)
+	}
+}
+
+func TestSourceReviewSignalHelper(t *testing.T) {
+	if os.Getenv("METAREVIEW_SIGNAL_CHILD") != "1" {
+		return
+	}
+	os.Exit(CLI([]string{"--model", "grok", "--output", os.Getenv("METAREVIEW_SIGNAL_OUT"), "--call-timeout", "30s"}, os.Getenv("METAREVIEW_SIGNAL_ROOT"), io.Discard, os.Stderr))
+}
+
+func TestCLISignalsCleanUpModel(t *testing.T) {
+	for _, signal := range []os.Signal{os.Interrupt, syscall.SIGTERM} {
+		t.Run(signal.String(), func(t *testing.T) {
+			root, _ := newRepoBytes(t, map[string][]byte{"a.go": []byte("package a\n")})
+			dir := t.TempDir()
+			pidFile, promptFile := filepath.Join(dir, "pid"), filepath.Join(dir, "prompt")
+			script := "#!/bin/sh\nprintf '%s\\n' \"$$\" > \"$METAREVIEW_SIGNAL_PID\"\nprintf '%s\\n' \"$2\" > \"$METAREVIEW_SIGNAL_PROMPT\"\nsleep 60\n"
+			if err := os.WriteFile(filepath.Join(dir, "grok"), []byte(script), 0o700); err != nil {
+				t.Fatal(err)
+			}
+			cmd := exec.Command(os.Args[0], "-test.run=^TestSourceReviewSignalHelper$")
+			var stderr bytes.Buffer
+			cmd.Stderr = &stderr
+			cmd.Env = append(os.Environ(), "METAREVIEW_SIGNAL_CHILD=1", "METAREVIEW_SIGNAL_ROOT="+root,
+				"METAREVIEW_SIGNAL_OUT="+filepath.Join(dir, "out"), "METAREVIEW_SIGNAL_PID="+pidFile,
+				"METAREVIEW_SIGNAL_PROMPT="+promptFile, "PATH="+dir+string(os.PathListSeparator)+os.Getenv("PATH"), "TMPDIR="+dir)
+			if err := cmd.Start(); err != nil {
+				t.Fatal(err)
+			}
+			defer func() { _ = cmd.Process.Kill() }()
+			var pid int
+			var prompt string
+			deadline := time.Now().Add(5 * time.Second)
+			for time.Now().Before(deadline) {
+				p, _ := os.ReadFile(pidFile)
+				pid, _ = strconv.Atoi(strings.TrimSpace(string(p)))
+				p, _ = os.ReadFile(promptFile)
+				prompt = strings.TrimSpace(string(p))
+				if pid > 0 && prompt != "" {
+					break
+				}
+				time.Sleep(10 * time.Millisecond)
+			}
+			if pid == 0 || prompt == "" {
+				_ = cmd.Process.Kill()
+				_ = cmd.Wait()
+				t.Fatalf("fake model did not start: %s", stderr.Bytes())
+			}
+			defer func() { _ = syscall.Kill(-pid, syscall.SIGKILL) }()
+			if err := cmd.Process.Signal(signal); err != nil {
+				t.Fatal(err)
+			}
+			done := make(chan error, 1)
+			go func() { done <- cmd.Wait() }()
+			select {
+			case err := <-done:
+				var exitErr *exec.ExitError
+				if !errors.As(err, &exitErr) || exitErr.ExitCode() != 1 {
+					t.Fatalf("CLI exit: %v", err)
+				}
+			case <-time.After(5 * time.Second):
+				t.Fatal("CLI failed to stop")
+			}
+			state, _ := exec.Command("ps", "-o", "stat=", "-p", strconv.Itoa(pid)).Output()
+			if s := strings.TrimSpace(string(state)); s != "" && !strings.HasPrefix(s, "Z") {
+				t.Fatalf("model still running: %s", state)
+			}
+			if _, err := os.Stat(prompt); !os.IsNotExist(err) {
+				t.Fatalf("prompt not removed: %v", err)
+			}
+			workspaces, _ := filepath.Glob(filepath.Join(dir, "metareview-workspace-*"))
+			if len(workspaces) != 0 {
+				t.Fatalf("workspaces left behind: %v", workspaces)
+			}
+		})
+	}
+}
+
+func TestPackPreservesPromptBytes(t *testing.T) {
+	var files []File
+	for i := 0; i < 24; i++ {
+		body := bytes.Repeat([]byte("x\n"), i*3)
+		if i%2 == 1 {
+			body = append(body, 'x')
+		}
+		if numberedSize(body) != len(numberLines(body, 1)) {
+			t.Fatal("wrong rendered size")
+		}
+		files = append(files, File{Path: fmt.Sprintf("%02d.go", i), Body: body})
+	}
+	const budget = 2000
+	// Reference the previous packing algorithm to require identical prompt bytes,
+	// including boundaries, ordering, separators, and source line numbers.
+	sort.Slice(files, func(i, j int) bool {
+		if len(files[i].Body) == len(files[j].Body) {
+			return files[i].Path < files[j].Path
+		}
+		return len(files[i].Body) > len(files[j].Body)
+	})
+	var bins [][]File
+	for _, f := range files {
+		placed := false
+		for i := range bins {
+			candidate := append(append([]File(nil), bins[i]...), f)
+			if len(promptWith(instruction, candidate)) <= budget {
+				bins[i], placed = candidate, true
+				break
+			}
+		}
+		if !placed {
+			bins = append(bins, []File{f})
+		}
+	}
+	got, err := Pack(files, budget)
+	if err != nil || len(got) != len(bins) {
+		t.Fatalf("prompt count changed: %v", err)
+	}
+	for i := range bins {
+		if !bytes.Equal(got[i], promptWith(instruction, bins[i])) {
+			t.Fatalf("prompt %d changed", i)
+		}
+	}
+}
+
+func packScalingFiles() []File {
+	var files []File
+	for i := 0; i < 30; i++ {
+		files = append(files, File{Path: fmt.Sprintf("big-%03d.go", i), Body: bytes.Repeat([]byte("x"), 100000)})
+	}
+	for i := 0; i < 300; i++ {
+		files = append(files, File{Path: fmt.Sprintf("small-%03d.go", i), Body: bytes.Repeat([]byte("y"), 4000)})
+	}
+	return files
+}
+
+func TestPackWholeRepoAllocation(t *testing.T) {
+	files := packScalingFiles()
+	runtime.GC()
+	var before, after runtime.MemStats
+	runtime.ReadMemStats(&before)
+	start := time.Now()
+	prompts, err := Pack(files, MaxPromptBytes)
+	runtime.ReadMemStats(&after)
+	allocated := after.TotalAlloc - before.TotalAlloc
+	t.Logf("files=330 source_bytes=4200000 prompts=%d allocated_bytes=%d elapsed=%s", len(prompts), allocated, time.Since(start))
+	if err != nil || len(prompts) != 37 {
+		t.Fatalf("pack: %d prompts, %v", len(prompts), err)
+	}
+	// Bound gross regressions generously, even with coverage instrumentation.
+	if allocated > 128<<20 {
+		t.Fatalf("packing allocated %d bytes for 4.2 MB of source", allocated)
+	}
+}
+
+func BenchmarkPackWholeRepo(b *testing.B) {
+	files := packScalingFiles()
+	b.ReportAllocs()
+	b.ResetTimer()
+	for b.Loop() {
+		if _, err := Pack(files, MaxPromptBytes); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
diff --git a/internal/sourcereview/run.go b/internal/sourcereview/run.go
new file mode 100644
index 00000000..4eb28f0f
--- /dev/null
+++ b/internal/sourcereview/run.go
@@ -0,0 +1,510 @@
+package sourcereview
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/signal"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/dsifry/metareview/internal/lensoutput"
+)
+
+const usageText = `Usage: metareview source-review --model astra|opus|grok --output <dir>
+                              [--jobs <n>] [--call-timeout <duration>] [--path <path>]... [<repo>]
+
+Reviews the first-party source at HEAD. Prints the kept list and the dropped
+list before any model call. Writes <dir>/findings.json and <dir>/review.html.
+The output directory must be outside the repository.
+
+--jobs runs up to n prompts at once (default 8). --call-timeout limits each
+model call (default 30m); a call that runs past it fails the run. --path
+reviews only the kept files at that path or under that directory; repeat it
+to review several. A --path that matches no kept file fails the run.`
+
+// DefaultJobs and DefaultCallTimeout apply when Options leaves them zero.
+const (
+	DefaultJobs        = 8
+	DefaultCallTimeout = 30 * time.Minute
+)
+
+var errHelp = errors.New("help")
+
+// Path seams. Production uses the stdlib functions. Tests replace them to
+// cover the error returns filepath and os do not produce on this OS.
+var (
+	pathAbs  = filepath.Abs
+	pathEval = filepath.EvalSymlinks
+	pathRel  = filepath.Rel
+	statPath = os.Stat
+)
+
+// Options is one source-review run. A nil Git, MkdirAll, WriteFile, Remove or
+// Rename uses the real git or filesystem. CLI supplies the OSRunner. A nil Context uses
+// context.Background. Budget 0 means MaxPromptBytes.
+// Jobs 0 means DefaultJobs and CallTimeout 0 means DefaultCallTimeout.
+type Options struct {
+	Context     context.Context
+	Repo        string
+	Model       string
+	OutputDir   string
+	Stdout      io.Writer
+	Stderr      io.Writer
+	Budget      int
+	Jobs        int
+	CallTimeout time.Duration
+	// Paths, when set, limits the review to kept files at or under these
+	// repo-relative paths. Every path must match at least one kept file.
+	Paths     []string
+	Runner    Runner
+	Git       GitFunc
+	MkdirAll  func(string, os.FileMode) error
+	WriteFile func(string, []byte, os.FileMode) error
+	Remove    func(string) error
+	Rename    func(string, string) error
+}
+
+// Run reviews one repository. It writes the findings file and the page only
+// after every prompt succeeds. A failed run preserves any previously saved reports.
+func Run(opts Options) error {
+	if opts.Context == nil {
+		opts.Context = context.Background()
+	}
+	if err := opts.Context.Err(); err != nil {
+		return err
+	}
+	if opts.Stdout == nil {
+		opts.Stdout = io.Discard
+	}
+	if opts.Stderr == nil {
+		opts.Stderr = io.Discard
+	}
+	if strings.TrimSpace(opts.OutputDir) == "" {
+		return errors.New("missing output directory")
+	}
+	modelID, err := ModelID(opts.Model)
+	if err != nil {
+		return err
+	}
+	git := opts.Git
+	if git == nil {
+		git = realGit
+	}
+	top, err := resolveTop(opts.Repo, git)
+	if err != nil {
+		return err
+	}
+	if err := refuseInside(top, opts.OutputDir); err != nil {
+		return err
+	}
+	kept, dropped, commit, err := selectPaths(top, git, opts.Paths)
+	if err != nil {
+		return err
+	}
+	if err := opts.Context.Err(); err != nil {
+		return err
+	}
+	writeLists(opts.Stdout, kept, dropped)
+	files := make(map[string][]byte, len(kept))
+	for _, f := range kept {
+		files[f.Path] = f.Body
+	}
+	if len(kept) == 0 {
+		return writeOutputs(opts, top, commit, modelID, nil, files)
+	}
+	budget := opts.Budget
+	if budget == 0 {
+		budget = MaxPromptBytes
+	}
+	prompts, err := Pack(kept, budget)
+	if err != nil {
+		return err
+	}
+	if opts.Runner == nil {
+		return errors.New("no runner")
+	}
+	all, err := review(opts, prompts, files)
+	if err != nil {
+		return err
+	}
+	return writeOutputs(opts, top, commit, modelID, all, files)
+}
+
+// review runs the prompts up to opts.Jobs at a time and returns the accepted
+// findings in prompt order. Each prompt block is printed whole, in prompt
+// order, before its call starts. After the first failure no new call starts,
+// running calls are cancelled, and that failure is returned.
+func review(opts Options, prompts [][]byte, files map[string][]byte) ([]lensoutput.TypedFinding, error) {
+	jobs := opts.Jobs
+	if jobs == 0 {
+		jobs = DefaultJobs
+	}
+	if jobs < 1 {
+		return nil, fmt.Errorf("jobs must be at least 1, got %d", jobs)
+	}
+	timeout := opts.CallTimeout
+	if timeout == 0 {
+		timeout = DefaultCallTimeout
+	}
+	if timeout < 0 {
+		return nil, fmt.Errorf("call timeout must be positive, got %s", timeout)
+	}
+	ctx, cancel := context.WithCancel(opts.Context)
+	defer cancel()
+	var (
+		mu       sync.Mutex
+		wg       sync.WaitGroup
+		firstErr error
+	)
+	fail := func(err error) {
+		mu.Lock()
+		defer mu.Unlock()
+		if firstErr == nil {
+			firstErr = err
+			cancel()
+		}
+	}
+	n := len(prompts)
+	results := make([][]lensoutput.TypedFinding, n)
+	sem := make(chan struct{}, jobs)
+schedule:
+	for i, p := range prompts {
+		select {
+		case sem <- struct{}{}:
+		case <-ctx.Done():
+			break schedule
+		}
+		if ctx.Err() != nil {
+			<-sem
+			break
+		}
+		mu.Lock()
+		writePrompt(opts.Stdout, p)
+		mu.Unlock()
+		wg.Add(1)
+		go func(i int, p []byte) {
+			defer wg.Done()
+			defer func() { <-sem }()
+			start := time.Now()
+			callCtx, callCancel := context.WithTimeout(ctx, timeout)
+			defer callCancel()
+			text, err := Call(callCtx, opts.Runner, opts.Model, p)
+			if err == nil {
+				err = callCtx.Err()
+			}
+			if err != nil {
+				if errors.Is(callCtx.Err(), context.DeadlineExceeded) {
+					err = fmt.Errorf("call timed out after %s: %w", timeout, err)
+				}
+				fail(fmt.Errorf("prompt %d/%d: %w", i+1, n, err))
+				return
+			}
+			got, skipped, err := Parse(text, files)
+			if err != nil {
+				fail(fmt.Errorf("prompt %d/%d: %w", i+1, n, err))
+				return
+			}
+			results[i] = got
+			mu.Lock()
+			defer mu.Unlock()
+			for _, msg := range skipped {
+				fmt.Fprintln(opts.Stderr, msg)
+			}
+			fmt.Fprintf(opts.Stderr, "prompt %d/%d done in %ds (%d findings)\n", i+1, n, int(time.Since(start).Round(time.Second)/time.Second), len(got))
+		}(i, p)
+	}
+	wg.Wait()
+	if firstErr != nil {
+		return nil, firstErr
+	}
+	if err := ctx.Err(); err != nil {
+		return nil, err
+	}
+	var all []lensoutput.TypedFinding
+	for _, r := range results {
+		all = append(all, r...)
+	}
+	return all, nil
+}
+
+func writePrompt(w io.Writer, p []byte) {
+	fmt.Fprintln(w, "prompt-begin")
+	_, _ = w.Write(p)
+	if len(p) == 0 || p[len(p)-1] != '\n' {
+		fmt.Fprintln(w)
+	}
+	fmt.Fprintln(w, "prompt-end")
+}
+
+// onlyPaths keeps the files at or under any of paths. No paths keeps every
+// file. A path that matches no kept file is an error, so a typo or a file the
+// source cut dropped is reported instead of reviewing nothing.
+func onlyPaths(kept []File, paths []string) ([]File, error) {
+	var err error
+	paths, err = cleanPaths(paths)
+	if err != nil {
+		return nil, err
+	}
+	if len(paths) == 0 {
+		return kept, nil
+	}
+	var out []File
+	matched := make([]bool, len(paths))
+	for _, f := range kept {
+		hit := false
+		for i, p := range paths {
+			if pathSelected(f.Path, []string{p}) {
+				matched[i] = true
+				hit = true
+			}
+		}
+		if hit {
+			out = append(out, f)
+		}
+	}
+	for i, ok := range matched {
+		if !ok {
+			return nil, fmt.Errorf("--path %s matches no kept file", paths[i])
+		}
+	}
+	return out, nil
+}
+
+func cleanPaths(paths []string) ([]string, error) {
+	cleaned := make([]string, 0, len(paths))
+	for _, p := range paths {
+		if p == "" {
+			return nil, errors.New("--path must not be empty")
+		}
+		cleaned = append(cleaned, path.Clean(p))
+	}
+	return cleaned, nil
+}
+
+func pathSelected(file string, paths []string) bool {
+	if len(paths) == 0 {
+		return true
+	}
+	for _, p := range paths {
+		if file == p || strings.HasPrefix(file, p+"/") || p == "." {
+			return true
+		}
+	}
+	return false
+}
+
+func writeLists(w io.Writer, kept []File, dropped []string) {
+	fmt.Fprintln(w, "kept:")
+	for _, f := range kept {
+		fmt.Fprintln(w, f.Path)
+	}
+	fmt.Fprintln(w, "dropped:")
+	for _, p := range dropped {
+		fmt.Fprintln(w, p)
+	}
+}
+
+func writeOutputs(opts Options, repo, commit, modelID string, findings []lensoutput.TypedFinding, files map[string][]byte) error {
+	if opts.Context != nil {
+		if err := opts.Context.Err(); err != nil {
+			return err
+		}
+	}
+	body := findingsJSON(findings)
+	page := Render(Page{Repo: repo, Commit: commit, ModelID: modelID, Findings: findings, Files: files})
+	mkdir := opts.MkdirAll
+	if mkdir == nil {
+		mkdir = os.MkdirAll
+	}
+	if err := mkdir(opts.OutputDir, 0o755); err != nil {
+		return err
+	}
+	return publishReports(opts, body, page)
+}
+
+func findingsJSON(fs []lensoutput.TypedFinding) []byte {
+	if fs == nil {
+		fs = []lensoutput.TypedFinding{}
+	}
+	body, _ := json.Marshal(struct {
+		Findings []lensoutput.TypedFinding `json:"findings"`
+	}{Findings: fs})
+	return append(body, '\n')
+}
+
+func refuseInside(repo, out string) error {
+	repoAbs, outAbs, err := absBoth(repo, out)
+	if err != nil {
+		return err
+	}
+	repoReal, err := pathEval(repoAbs)
+	if err != nil {
+		return err
+	}
+	outReal, err := evalExisting(outAbs)
+	if err != nil {
+		return err
+	}
+	rel, err := pathRel(repoReal, outReal)
+	if err != nil {
+		return err
+	}
+	if insideRel(rel) {
+		return fmt.Errorf("refusing output directory inside the tree under review: %s", out)
+	}
+	return nil
+}
+
+func absBoth(a, b string) (string, string, error) {
+	aa, err := pathAbs(a)
+	if err != nil {
+		return "", "", err
+	}
+	bb, err := pathAbs(b)
+	if err != nil {
+		return "", "", err
+	}
+	return aa, bb, nil
+}
+
+func evalExisting(p string) (string, error) {
+	cur := p
+	var tail []string
+	for {
+		if _, err := statPath(cur); err == nil {
+			real, err := pathEval(cur)
+			if err != nil {
+				return "", err
+			}
+			for i := len(tail) - 1; i >= 0; i-- {
+				real = filepath.Join(real, tail[i])
+			}
+			return real, nil
+		}
+		parent := filepath.Dir(cur)
+		if parent == cur {
+			return "", fmt.Errorf("cannot resolve %s", p)
+		}
+		tail = append(tail, filepath.Base(cur))
+		cur = parent
+	}
+}
+
+func insideRel(rel string) bool {
+	if rel == "." {
+		return true
+	}
+	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return false
+	}
+	return true
+}
+
+// CLI is the source-review command. repo defaults to cwd.
+func CLI(args []string, cwd string, stdout, stderr io.Writer) int {
+	a, err := parseArgs(args)
+	if err != nil {
+		if errors.Is(err, errHelp) {
+			fmt.Fprintln(stdout, usageText)
+			return 0
+		}
+		fmt.Fprintln(stderr, err.Error())
+		fmt.Fprintln(stderr, usageText)
+		return 2
+	}
+	if a.repo == "" {
+		a.repo = cwd
+	}
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+	err = Run(Options{
+		Context:     ctx,
+		Repo:        a.repo,
+		Model:       a.model,
+		OutputDir:   a.out,
+		Stdout:      stdout,
+		Stderr:      stderr,
+		Jobs:        a.jobs,
+		Paths:       a.paths,
+		CallTimeout: a.timeout,
+		Runner:      OSRunner{},
+	})
+	if err != nil {
+		fmt.Fprintln(stderr, err.Error())
+		return 1
+	}
+	return 0
+}
+
+type cliArgs struct {
+	model, out, repo string
+	jobs             int
+	timeout          time.Duration
+	paths            []string
+}
+
+func parseArgs(args []string) (cliArgs, error) {
+	a := cliArgs{jobs: DefaultJobs, timeout: DefaultCallTimeout}
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		switch {
+		case arg == "--help" || arg == "-h":
+			return cliArgs{}, errHelp
+		case arg == "--model" || arg == "--output" || arg == "--jobs" || arg == "--call-timeout" || arg == "--path":
+			if i+1 >= len(args) {
+				return cliArgs{}, fmt.Errorf("missing value for %s", arg)
+			}
+			i++
+			if err := a.set(arg, args[i]); err != nil {
+				return cliArgs{}, err
+			}
+		case strings.HasPrefix(arg, "--"):
+			return cliArgs{}, fmt.Errorf("unknown option: %s", arg)
+		default:
+			if a.repo != "" {
+				return cliArgs{}, fmt.Errorf("unexpected argument: %s", arg)
+			}
+			a.repo = arg
+		}
+	}
+	if a.model == "" || a.out == "" {
+		return cliArgs{}, errors.New("missing --model or --output")
+	}
+	return a, nil
+}
+
+func (a *cliArgs) set(flag, v string) error {
+	switch flag {
+	case "--model":
+		a.model = v
+	case "--output":
+		a.out = v
+	case "--path":
+		if v == "" {
+			return errors.New("--path must not be empty")
+		}
+		a.paths = append(a.paths, v)
+	case "--jobs":
+		n, err := strconv.Atoi(v)
+		if err != nil || n < 1 {
+			return fmt.Errorf("--jobs must be an integer of at least 1, got %q", v)
+		}
+		a.jobs = n
+	default:
+		d, err := time.ParseDuration(v)
+		if err != nil || d <= 0 {
+			return fmt.Errorf("--call-timeout must be a positive duration such as 30m, got %q", v)
+		}
+		a.timeout = d
+	}
+	return nil
+}
diff --git a/internal/sourcereview/run_test.go b/internal/sourcereview/run_test.go
new file mode 100644
index 00000000..278396e1
--- /dev/null
+++ b/internal/sourcereview/run_test.go
@@ -0,0 +1,795 @@
+package sourcereview
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/dsifry/metareview/internal/lensoutput"
+)
+
+func cliStdout(model, text string) []byte {
+	switch model {
+	case "opus":
+		b, _ := json.Marshal(map[string]any{"is_error": false, "result": text})
+		return b
+	case "grok":
+		b, _ := json.Marshal(map[string]any{"text": text})
+		return b
+	default:
+		quoted, _ := json.Marshal(text)
+		return []byte(`{"type":"item.completed","item":{"type":"agent_message","text":` + string(quoted) + "}}\n")
+	}
+}
+
+func TestRunSpecFixtureThreeModels(t *testing.T) {
+	const sentinel = "super-secret-api-key-9f3a"
+	t.Setenv("ANTHROPIC_API_KEY", sentinel)
+	t.Setenv("OPENAI_API_KEY", sentinel)
+	t.Setenv("XAI_API_KEY", sentinel)
+	root, commit := newRepoBytes(t, specFiles())
+	for _, model := range []string{"opus", "astra", "grok"} {
+		var buf bytes.Buffer
+		var prompts [][]byte
+		fr := &fakeRunner{
+			onRun: func() {
+				out := buf.String()
+				if !strings.Contains(out, "kept:\npkg/app.go\npkg/note.go\n") || !strings.Contains(out, "dropped:\n") {
+					t.Fatalf("%s lists before model call:\n%s", model, out)
+				}
+				idx := strings.Index(out, "prompt-begin")
+				keptAt := strings.Index(out, "kept:")
+				if keptAt < 0 || idx < 0 || keptAt > idx {
+					t.Fatalf("%s kept list is not before the prompt", model)
+				}
+				for _, p := range specDropped {
+					if !strings.Contains(out[:idx], p) {
+						t.Fatalf("%s dropped list missing %s", model, p)
+					}
+				}
+			},
+			reply: func(_ int, name string, args []string, stdin []byte) ([]byte, error) {
+				var prompt []byte
+				if model == "grok" {
+					if stdin != nil || args[0] != "--prompt-file" {
+						t.Fatal("grok prompt must be a --prompt-file")
+					}
+					prompt, _ = os.ReadFile(args[1])
+				} else {
+					prompt = stdin
+				}
+				prompts = append(prompts, append([]byte(nil), prompt...))
+				if name == "" {
+					t.Fatal("empty binary")
+				}
+				return cliStdout(model, `{"findings":[]}`), nil
+			},
+		}
+		outDir := t.TempDir()
+		err := Run(Options{Repo: root, Model: model, OutputDir: outDir, Stdout: &buf, Runner: fr})
+		if err != nil {
+			t.Fatal(model, err)
+		}
+		if strings.Contains(buf.String(), sentinel) {
+			t.Fatal("api key leaked into stdout")
+		}
+		if len(prompts) != 1 {
+			t.Fatalf("%s prompts %d", model, len(prompts))
+		}
+		p := prompts[0]
+		if len(p) > MaxPromptBytes {
+			t.Fatalf("%s prompt %d", model, len(p))
+		}
+		if !bytes.Contains(p, []byte(instruction)) || !bytes.Contains(p, []byte(`{"findings":[...]}`)) {
+			t.Fatal("instruction missing")
+		}
+		for path, body := range specFiles() {
+			needle := append([]byte(path+"\n"), numberLines(body, 1)...)
+			has := bytes.Contains(p, needle)
+			if path == "pkg/app.go" || path == "pkg/note.go" {
+				if !has {
+					t.Fatalf("%s prompt missing %s immediately before its text", model, path)
+				}
+			} else if bytes.Contains(p, []byte(path)) || bytes.Contains(p, []byte("DROPME")) {
+				t.Fatalf("%s prompt contains dropped %s", model, path)
+			}
+		}
+		raw, err := os.ReadFile(filepath.Join(outDir, "findings.json"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if strings.TrimSpace(string(raw)) != `{"findings":[]}` {
+			t.Fatalf("findings %s", raw)
+		}
+		page, err := os.ReadFile(filepath.Join(outDir, "review.html"))
+		if err != nil {
+			t.Fatal(err)
+		}
+		html := string(page)
+		id, _ := ModelID(model)
+		for _, want := range []string{id, commit, `id="severity"`, `id="directory"`, "P0 0", "P1 0", "P2 0", "P3 0"} {
+			if !strings.Contains(html, want) {
+				t.Fatalf("%s page missing %q", model, want)
+			}
+		}
+		if strings.Contains(html, `class="finding"`) {
+			t.Fatal("empty findings rendered a finding")
+		}
+		entries, _ := os.ReadDir(outDir)
+		if len(entries) != 2 {
+			t.Fatalf("output entries %d", len(entries))
+		}
+	}
+	srcHasGetenv(t)
+}
+
+func srcHasGetenv(t *testing.T) {
+	t.Helper()
+	ents, err := os.ReadDir(".")
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, e := range ents {
+		if !strings.HasSuffix(e.Name(), ".go") || strings.HasSuffix(e.Name(), "_test.go") {
+			continue
+		}
+		b, err := os.ReadFile(e.Name())
+		if err != nil {
+			t.Fatal(err)
+		}
+		if bytes.Contains(b, []byte("Getenv")) || bytes.Contains(b, []byte("API_KEY")) {
+			t.Fatalf("%s reads an API key", e.Name())
+		}
+	}
+}
+
+func TestRunEmptyKeptWritesZeros(t *testing.T) {
+	root, commit := newRepoBytes(t, droppedOnlyFiles())
+	outDir := t.TempDir()
+	var buf bytes.Buffer
+	fr := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+		t.Fatal("model called")
+		return nil, nil
+	}}
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &buf, Runner: fr}); err != nil {
+		t.Fatal(err)
+	}
+	if len(fr.calls) != 0 {
+		t.Fatal("model called")
+	}
+	out := buf.String()
+	if !strings.HasPrefix(out, "kept:\ndropped:\n") {
+		t.Fatalf("lists:\n%s", out)
+	}
+	for _, p := range specDropped {
+		if !strings.Contains(out, p+"\n") {
+			t.Fatalf("missing dropped %s", p)
+		}
+	}
+	raw, _ := os.ReadFile(filepath.Join(outDir, "findings.json"))
+	if strings.TrimSpace(string(raw)) != `{"findings":[]}` {
+		t.Fatalf("%s", raw)
+	}
+	page, _ := os.ReadFile(filepath.Join(outDir, "review.html"))
+	html := string(page)
+	for _, want := range []string{commit, "opus", `id="severity"`, `id="directory"`, "P0 0", "P1 0", "P2 0", "P3 0"} {
+		if !strings.Contains(html, want) {
+			t.Fatalf("page missing %s\n%s", want, html)
+		}
+	}
+}
+
+func TestRunMergesPromptOrder(t *testing.T) {
+	files := map[string][]byte{
+		"a.go": bytes.Repeat([]byte("a"), 100000),
+		"b.go": bytes.Repeat([]byte("b"), 50000),
+		"c.go": bytes.Repeat([]byte("c"), 60000),
+	}
+	root, _ := newRepoBytes(t, files)
+	var order []string
+	fr := &fakeRunner{reply: func(_ int, _ string, _ []string, stdin []byte) ([]byte, error) {
+		var path string
+		for _, p := range []string{"a.go", "b.go", "c.go"} {
+			if bytes.Contains(stdin, []byte(p+"\n")) {
+				path = p
+				break
+			}
+		}
+		order = append(order, path)
+		text := `{"findings":[{"tag":"bug","file":"` + path + `","start_line":1,"end_line":1,"issue":"i-` + path + `","consequence":"c","confidence":80,"severity":"P2"}]}`
+		return cliStdout("opus", text), nil
+	}}
+	outDir := t.TempDir()
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{}, Jobs: 1, Runner: fr}); err != nil {
+		t.Fatal(err)
+	}
+	raw, _ := os.ReadFile(filepath.Join(outDir, "findings.json"))
+	var doc struct {
+		Findings []lensoutput.TypedFinding `json:"findings"`
+	}
+	if err := json.Unmarshal(raw, &doc); err != nil {
+		t.Fatal(err)
+	}
+	if len(doc.Findings) != len(order) {
+		t.Fatalf("findings %d order %v", len(doc.Findings), order)
+	}
+	for i, f := range doc.Findings {
+		if err := f.Validate(); err != nil {
+			t.Fatal(err)
+		}
+		if f.File != order[i] || f.Issue != "i-"+order[i] {
+			t.Fatalf("order[%d]=%s finding %+v", i, order[i], f)
+		}
+		blob, ok := files[f.File]
+		if !ok || f.EndLine > lineCount(blob) {
+			t.Fatal("line missing")
+		}
+		asMap := map[string]any{}
+		one, _ := json.Marshal(f)
+		_ = json.Unmarshal(one, &asMap)
+		if _, ok := asMap["model"]; ok {
+			t.Fatal("model field")
+		}
+	}
+	page, _ := os.ReadFile(filepath.Join(outDir, "review.html"))
+	if !bytes.Contains(page, []byte("opus")) || bytes.Count(page, []byte(`class="finding"`)) != len(order) {
+		t.Fatal("page findings")
+	}
+}
+
+// fivePrompts is a repo whose kept files pack into five prompts, one file
+// each, in path order p1.go..p5.go. Each is 100,000 bytes in 1,000 lines, so
+// numbered it still fits one prompt but two never share one.
+func fivePrompts(t *testing.T) (string, []string) {
+	t.Helper()
+	files := map[string][]byte{}
+	var paths []string
+	for i := 1; i <= 5; i++ {
+		p := fmt.Sprintf("p%d.go", i)
+		files[p] = bytes.Repeat(append(bytes.Repeat([]byte("x"), 99), '\n'), 1000)
+		paths = append(paths, p)
+	}
+	root, _ := newRepoBytes(t, files)
+	return root, paths
+}
+
+// promptPath is the one pN.go path a prompt carries.
+func promptPath(prompt []byte, paths []string) (int, string) {
+	for i, p := range paths {
+		if bytes.Contains(prompt, []byte("\n"+p+"\n")) {
+			return i, p
+		}
+	}
+	return -1, ""
+}
+
+func oneFinding(path string) []byte {
+	return cliStdout("opus", `{"findings":[{"tag":"bug","file":"`+path+`","start_line":1,"end_line":1,"issue":"i-`+path+`","consequence":"c","confidence":80,"severity":"P2"}]}`)
+}
+
+func TestRunJobsKeepPromptOrder(t *testing.T) {
+	root, paths := fivePrompts(t)
+	var mu sync.Mutex
+	var finished []string
+	fr := &fakeRunner{}
+	fr.reply = func(_ int, _ string, _ []string, stdin []byte) ([]byte, error) {
+		i, p := promptPath(stdin, paths)
+		// Later prompts answer first: prompt 5 finishes before prompt 1.
+		time.Sleep(time.Duration(len(paths)-i) * 60 * time.Millisecond)
+		mu.Lock()
+		finished = append(finished, p)
+		mu.Unlock()
+		return oneFinding(p), nil
+	}
+	outDir := t.TempDir()
+	var stdout, stderr bytes.Buffer
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &stdout, Stderr: &stderr, Jobs: 3, Runner: fr}); err != nil {
+		t.Fatal(err)
+	}
+	if fr.maxActive != 3 {
+		t.Fatalf("max concurrent calls %d, want 3", fr.maxActive)
+	}
+	if finished[0] == paths[0] {
+		t.Fatalf("calls finished in prompt order %v; the test needs reverse", finished)
+	}
+	raw, _ := os.ReadFile(filepath.Join(outDir, "findings.json"))
+	var doc struct {
+		Findings []lensoutput.TypedFinding `json:"findings"`
+	}
+	if err := json.Unmarshal(raw, &doc); err != nil {
+		t.Fatal(err)
+	}
+	if len(doc.Findings) != len(paths) {
+		t.Fatalf("findings %d", len(doc.Findings))
+	}
+	for i, f := range doc.Findings {
+		if f.File != paths[i] {
+			t.Fatalf("finding %d is %s, want %s (finished %v)", i, f.File, paths[i], finished)
+		}
+	}
+	// Prompt blocks are whole and in prompt order.
+	out := stdout.String()
+	last := -1
+	for _, p := range paths {
+		at := strings.Index(out, "\n"+p+"\n")
+		if at < last {
+			t.Fatalf("prompt for %s printed out of order", p)
+		}
+		last = at
+	}
+	if strings.Count(out, "prompt-begin\n") != len(paths) || strings.Count(out, "prompt-end\n") != len(paths) {
+		t.Fatal("prompt markers")
+	}
+	for _, block := range strings.Split(out, "prompt-begin\n")[1:] {
+		if strings.Count(block, "prompt-end\n") != 1 || !strings.HasSuffix(block, "prompt-end\n") {
+			t.Fatal("a prompt block was interleaved")
+		}
+	}
+	for i := 1; i <= len(paths); i++ {
+		re := regexp.MustCompile(fmt.Sprintf(`(?m)^prompt %d/5 done in \d+s \(1 findings\)$`, i))
+		if n := len(re.FindAllString(stderr.String(), -1)); n != 1 {
+			t.Fatalf("progress line for prompt %d appears %d times:\n%s", i, n, stderr.String())
+		}
+	}
+}
+
+func TestRunCallTimeout(t *testing.T) {
+	root, _ := newRepoBytes(t, specFiles())
+	outDir := t.TempDir()
+	fr := &fakeRunner{wait: func(ctx context.Context, _ []byte) error {
+		<-ctx.Done()
+		return errors.New("signal: killed")
+	}}
+	err := Run(Options{Repo: root, Model: "grok", OutputDir: outDir, Stdout: &bytes.Buffer{}, CallTimeout: 50 * time.Millisecond, Runner: fr})
+	if err == nil || !strings.Contains(err.Error(), "prompt 1/1") || !strings.Contains(err.Error(), "timed out after 50ms") {
+		t.Fatal(err)
+	}
+	if ents, _ := os.ReadDir(outDir); len(ents) != 0 {
+		t.Fatal("wrote after a timeout")
+	}
+}
+
+func TestRunFailureStopsNewCalls(t *testing.T) {
+	root, paths := fivePrompts(t)
+	// One job: the first prompt fails, so no other prompt starts.
+	fr := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+		return nil, errors.New("exit status 1")
+	}}
+	outDir := t.TempDir()
+	err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{}, Jobs: 1, Runner: fr})
+	if err == nil || !strings.Contains(err.Error(), "prompt 1/5") {
+		t.Fatal(err)
+	}
+	if n := len(fr.callList()); n != 1 {
+		t.Fatalf("calls after the failure: %d", n)
+	}
+	if ents, _ := os.ReadDir(outDir); len(ents) != 0 {
+		t.Fatal("wrote after a failure")
+	}
+	// Two jobs: prompt 1 fails while prompt 2 is running; prompt 2 is
+	// cancelled, nothing else starts, and prompt 1's error is returned.
+	fr = &fakeRunner{}
+	fr.wait = func(ctx context.Context, prompt []byte) error {
+		if i, _ := promptPath(prompt, paths); i == 0 {
+			time.Sleep(50 * time.Millisecond)
+			return errors.New("first failed")
+		}
+		<-ctx.Done()
+		return ctx.Err()
+	}
+	err = Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{}, Jobs: 2, Runner: fr})
+	if err == nil || !strings.Contains(err.Error(), "first failed") {
+		t.Fatal(err)
+	}
+	if n := len(fr.callList()); n != 2 {
+		t.Fatalf("calls %d, want 2", n)
+	}
+	if ents, _ := os.ReadDir(outDir); len(ents) != 0 {
+		t.Fatal("wrote after a failure")
+	}
+}
+
+func TestRunPaths(t *testing.T) {
+	root, _ := newRepoBytes(t, specFiles())
+	run := func(paths ...string) (string, [][]byte, error) {
+		var buf bytes.Buffer
+		fr := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+			return cliStdout("opus", `{"findings":[]}`), nil
+		}}
+		err := Run(Options{Repo: root, Model: "opus", OutputDir: t.TempDir(), Stdout: &buf, Paths: paths, Runner: fr})
+		var prompts [][]byte
+		for _, c := range fr.callList() {
+			prompts = append(prompts, c.prompt)
+		}
+		return buf.String(), prompts, err
+	}
+	// One file: only it is listed as kept and only it is sent.
+	out, prompts, err := run("pkg/app.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(out, "kept:\npkg/app.go\ndropped:\n") || len(prompts) != 1 || !bytes.Contains(prompts[0], []byte("pkg/app.go\n")) || bytes.Contains(prompts[0], []byte("pkg/note.go")) {
+		t.Fatalf("one file:\n%s", out)
+	}
+	// A directory, written with a trailing slash, and "." both keep everything under them.
+	for _, p := range []string{"pkg/", "."} {
+		out, _, err = run(p)
+		if err != nil || !strings.Contains(out, "kept:\npkg/app.go\npkg/note.go\ndropped:\n") {
+			t.Fatalf("%s: %v\n%s", p, err, out)
+		}
+	}
+	// Repeated paths add up.
+	out, _, err = run("pkg/note.go", "pkg/app.go")
+	if err != nil || !strings.Contains(out, "kept:\npkg/app.go\npkg/note.go\n") {
+		t.Fatalf("two paths: %v\n%s", err, out)
+	}
+	// A partial name, a dropped file, and a missing file match nothing and call no model.
+	for _, p := range []string{"pkg/ap", "vendor/lib.go", "nope.go"} {
+		_, prompts, err = run("pkg/app.go", p)
+		if err == nil || !strings.Contains(err.Error(), "--path "+p+" matches no kept file") || len(prompts) != 0 {
+			t.Fatalf("%s: err=%v prompts=%d", p, err, len(prompts))
+		}
+	}
+}
+
+func TestRunBadJobsAndTimeout(t *testing.T) {
+	root, _ := newRepoBytes(t, specFiles())
+	fr := &fakeRunner{}
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: t.TempDir(), Jobs: -1, Runner: fr}); err == nil || !strings.Contains(err.Error(), "jobs") {
+		t.Fatal(err)
+	}
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: t.TempDir(), CallTimeout: -time.Second, Runner: fr}); err == nil || !strings.Contains(err.Error(), "timeout") {
+		t.Fatal(err)
+	}
+	if len(fr.callList()) != 0 {
+		t.Fatal("model called")
+	}
+}
+
+func TestRunFailuresLeaveDirEmpty(t *testing.T) {
+	root, _ := newRepoBytes(t, specFiles())
+	cases := []struct {
+		name  string
+		reply func() ([]byte, error)
+	}{
+		{"nonzero", func() ([]byte, error) { return nil, errors.New("exit status 1") }},
+		{"cannot-start", func() ([]byte, error) { return nil, errors.New("executable file not found") }},
+		{"is-error", func() ([]byte, error) { return []byte(`{"is_error":true,"result":"boom"}`), nil }},
+		{"null", func() ([]byte, error) { return cliStdout("opus", `{"findings":null}`), nil }},
+		{"prose", func() ([]byte, error) { return cliStdout("opus", "There are no findings."), nil }},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			outDir := t.TempDir()
+			before, _ := os.ReadDir(outDir)
+			fr := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) { return tc.reply() }}
+			err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{}, Runner: fr})
+			if err == nil {
+				t.Fatal("expected error")
+			}
+			after, _ := os.ReadDir(outDir)
+			if len(before) != 0 || len(after) != 0 {
+				t.Fatalf("dir before %d after %d", len(before), len(after))
+			}
+		})
+	}
+}
+
+func TestRunSkipsABadFinding(t *testing.T) {
+	root, _ := newRepoBytes(t, specFiles())
+	var stderr bytes.Buffer
+	fr := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+		return cliStdout("opus", `{"findings":[{"tag":"bug","file":"vite.config.js","start_line":1,"end_line":1,"issue":"i","consequence":"c","confidence":10,"severity":"P1"},{"tag":"bug","file":"pkg/app.go","start_line":1,"end_line":1,"issue":"real","consequence":"c","confidence":10,"severity":"P1"}]}`), nil
+	}}
+	outDir := t.TempDir()
+	err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{}, Stderr: &stderr, Runner: fr})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(stderr.String(), "not kept") {
+		t.Fatalf("stderr %q", stderr.String())
+	}
+	raw, err := os.ReadFile(filepath.Join(outDir, "findings.json"))
+	if err != nil || !bytes.Contains(raw, []byte(`"file":"pkg/app.go"`)) || bytes.Contains(raw, []byte("vite.config.js")) {
+		t.Fatalf("%v %s", err, raw)
+	}
+}
+
+func TestRunSecondPromptFails(t *testing.T) {
+	files := map[string][]byte{
+		"a.go": bytes.Repeat([]byte("a"), 100000),
+		"b.go": bytes.Repeat([]byte("b"), 100000),
+	}
+	root, _ := newRepoBytes(t, files)
+	fr := &fakeRunner{reply: func(n int, _ string, _ []string, _ []byte) ([]byte, error) {
+		if n == 0 {
+			return cliStdout("opus", `{"findings":[]}`), nil
+		}
+		return nil, errors.New("exit status 1")
+	}}
+	outDir := t.TempDir()
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{}, Runner: fr}); err == nil {
+		t.Fatal("expected error")
+	}
+	ents, _ := os.ReadDir(outDir)
+	if len(ents) != 0 {
+		t.Fatal("wrote files after a failed prompt")
+	}
+}
+
+func TestRunRefusesInsideAndWritesOutside(t *testing.T) {
+	root, _ := newRepoBytes(t, droppedOnlyFiles())
+	inside := filepath.Join(root, "out")
+	if err := os.MkdirAll(inside, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	err := Run(Options{Repo: root, Model: "opus", OutputDir: inside, Stdout: &bytes.Buffer{}, Runner: OSRunner{}})
+	if err == nil || !strings.Contains(err.Error(), "refusing") {
+		t.Fatal(err)
+	}
+	ents, _ := os.ReadDir(inside)
+	if len(ents) != 0 {
+		t.Fatal("wrote inside the tree")
+	}
+	nested := filepath.Join(t.TempDir(), "nested", "out")
+	if err := Run(Options{Repo: root, Model: "grok", OutputDir: nested, Stdout: ioDiscard(), Runner: &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+		t.Fatal("model called")
+		return nil, nil
+	}}}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := os.Stat(filepath.Join(nested, "review.html")); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func ioDiscard() *bytes.Buffer { return &bytes.Buffer{} }
+
+func TestRunSelectError(t *testing.T) {
+	root, _ := newRepoBytes(t, map[string][]byte{"a.go": []byte("package a\n")})
+	git := func(dir string, args []string, stdin []byte) ([]byte, error) {
+		if args[0] == "ls-tree" {
+			return nil, errors.New("ls-tree")
+		}
+		return realGit(dir, args, stdin)
+	}
+	err := Run(Options{Repo: root, Model: "opus", OutputDir: t.TempDir(), Stdout: &bytes.Buffer{}, Git: git, Runner: &fakeRunner{}})
+	if err == nil || !strings.Contains(err.Error(), "ls-tree") {
+		t.Fatal(err)
+	}
+}
+
+func TestRunBudgetAndMissingRunner(t *testing.T) {
+	root, _ := newRepoBytes(t, map[string][]byte{"a.go": []byte("package a\n")})
+	outDir := t.TempDir()
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Budget: -1, Stdout: &bytes.Buffer{}, Runner: &fakeRunner{}}); err == nil {
+		t.Fatal("negative budget")
+	}
+	ents, _ := os.ReadDir(outDir)
+	if len(ents) != 0 {
+		t.Fatal("wrote on pack error")
+	}
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{}}); err == nil || !strings.Contains(err.Error(), "no runner") {
+		t.Fatal(err)
+	}
+	if err := Run(Options{Repo: root, Model: "nope", OutputDir: outDir}); err == nil {
+		t.Fatal("bad model")
+	}
+	if err := Run(Options{Repo: root, Model: "opus", Stdout: nil}); err == nil {
+		t.Fatal("missing output")
+	}
+	if err := Run(Options{Repo: t.TempDir(), Model: "opus", OutputDir: outDir, Stdout: nil}); err == nil {
+		t.Fatal("not a repo")
+	}
+}
+
+func TestRunWriteErrors(t *testing.T) {
+	root, _ := newRepoBytes(t, droppedOnlyFiles())
+	outDir := t.TempDir()
+	err := Run(Options{
+		Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{},
+		MkdirAll: func(string, os.FileMode) error { return errors.New("mkdir") },
+	})
+	if err == nil || !strings.Contains(err.Error(), "mkdir") {
+		t.Fatal(err)
+	}
+	err = Run(Options{
+		Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{},
+		WriteFile: func(string, []byte, os.FileMode) error { return errors.New("write") },
+	})
+	if err == nil || !strings.Contains(err.Error(), "write") {
+		t.Fatal(err)
+	}
+	n := 0
+	err = Run(Options{
+		Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{},
+		WriteFile: func(path string, data []byte, mode os.FileMode) error {
+			n++
+			if n == 2 {
+				return errors.New("page")
+			}
+			return os.WriteFile(path, data, mode)
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "page") {
+		t.Fatalf("err=%v", err)
+	}
+	// Neither staged file is published when the page write fails.
+	n = 0
+	err = Run(Options{
+		Repo: root, Model: "opus", OutputDir: outDir, Stdout: &bytes.Buffer{},
+		WriteFile: func(path string, data []byte, mode os.FileMode) error {
+			n++
+			if strings.HasSuffix(path, "review.html") {
+				return errors.New("page")
+			}
+			return os.WriteFile(path, data, mode)
+		},
+	})
+	if err == nil {
+		t.Fatal("expected page error")
+	}
+	if _, statErr := os.Stat(filepath.Join(outDir, "findings.json")); !os.IsNotExist(statErr) {
+		t.Fatal("findings file left behind")
+	}
+}
+
+func TestRefuseSeams(t *testing.T) {
+	root, _ := newRepoBytes(t, map[string][]byte{"a.go": []byte("package a\n")})
+	out := t.TempDir()
+	prevAbs, prevEval, prevRel, prevStat := pathAbs, pathEval, pathRel, statPath
+	t.Cleanup(func() {
+		pathAbs, pathEval, pathRel, statPath = prevAbs, prevEval, prevRel, prevStat
+	})
+	pathAbs = func(string) (string, error) { return "", errors.New("abs") }
+	if err := refuseInside(root, out); err == nil {
+		t.Fatal("abs1")
+	}
+	n := 0
+	pathAbs = func(p string) (string, error) {
+		n++
+		if n == 2 {
+			return "", errors.New("abs2")
+		}
+		return prevAbs(p)
+	}
+	if err := refuseInside(root, out); err == nil {
+		t.Fatal("abs2")
+	}
+	pathAbs = prevAbs
+	pathEval = func(string) (string, error) { return "", errors.New("eval") }
+	if err := refuseInside(root, out); err == nil {
+		t.Fatal("eval repo")
+	}
+	calls := 0
+	pathEval = func(p string) (string, error) {
+		calls++
+		if calls > 1 {
+			return "", errors.New("eval out")
+		}
+		return prevEval(p)
+	}
+	if err := refuseInside(root, out); err == nil {
+		t.Fatal("eval out")
+	}
+	pathEval = prevEval
+	pathRel = func(string, string) (string, error) { return "", errors.New("rel") }
+	if err := refuseInside(root, out); err == nil {
+		t.Fatal("rel")
+	}
+	pathRel = prevRel
+	statPath = func(string) (os.FileInfo, error) { return nil, errors.New("stat") }
+	if _, err := evalExisting(out); err == nil {
+		t.Fatal("stat walk")
+	}
+	if !insideRel(".") || insideRel("..") || insideRel("../x") || !insideRel("foo") {
+		t.Fatal("insideRel")
+	}
+}
+
+func TestPromptWithoutTrailingNewline(t *testing.T) {
+	root, _ := newRepoBytes(t, map[string][]byte{"nonl.go": []byte("package nonl")})
+	var buf bytes.Buffer
+	fr := &fakeRunner{reply: func(int, string, []string, []byte) ([]byte, error) {
+		return cliStdout("opus", `{"findings":[]}`), nil
+	}}
+	outDir := t.TempDir()
+	if err := Run(Options{Repo: root, Model: "opus", OutputDir: outDir, Stdout: &buf, Runner: fr}); err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(buf.String(), "prompt-end\n") {
+		t.Fatalf("prompt marker missing:\n%s", buf.String())
+	}
+	if !bytes.Contains(fr.calls[0].stdin, []byte("nonl.go\n1| package nonl")) {
+		t.Fatal("path not immediately before text")
+	}
+}
+
+func TestCLI(t *testing.T) {
+	code, _ := cliCapture(t, "", "--help")
+	if code != 0 {
+		t.Fatal(code)
+	}
+	code, errOut := cliCapture(t, "", "-h")
+	if code != 0 || errOut != "" {
+		t.Fatalf("h code=%d err=%q", code, errOut)
+	}
+	for _, args := range [][]string{
+		{},
+		{"--model"},
+		{"--output"},
+		{"--model", "opus"},
+		{"--output", t.TempDir()},
+		{"--nope"},
+		{"--model", "opus", "--output", t.TempDir(), "extra", "more"},
+		{"--model", "opus", "--output", t.TempDir(), "--jobs"},
+		{"--model", "opus", "--output", t.TempDir(), "--jobs", "0"},
+		{"--model", "opus", "--output", t.TempDir(), "--jobs", "two"},
+		{"--model", "opus", "--output", t.TempDir(), "--call-timeout"},
+		{"--model", "opus", "--output", t.TempDir(), "--call-timeout", "0"},
+		{"--model", "opus", "--output", t.TempDir(), "--call-timeout", "-5m"},
+		{"--model", "opus", "--output", t.TempDir(), "--call-timeout", "soon"},
+	} {
+		code, errOut = cliCapture(t, "", args...)
+		if code != 2 || errOut == "" || !strings.Contains(errOut, "Usage:") {
+			t.Fatalf("args %v code=%d err=%q", args, code, errOut)
+		}
+	}
+	a, err := parseArgs([]string{"--model", "grok", "--output", "o"})
+	if err != nil || DefaultJobs != 8 || DefaultCallTimeout != 30*time.Minute || a.jobs != DefaultJobs || a.timeout != DefaultCallTimeout {
+		t.Fatalf("defaults %+v %v", a, err)
+	}
+	a, err = parseArgs([]string{"--model", "grok", "--output", "o", "--jobs", "3", "--call-timeout", "90s", "--path", "a.go", "--path", "web/src", "repo"})
+	if err != nil || a.jobs != 3 || a.timeout != 90*time.Second || a.repo != "repo" || !reflectArgs(a.paths, []string{"a.go", "web/src"}) {
+		t.Fatalf("flags %+v %v", a, err)
+	}
+	if _, err := parseArgs([]string{"--model", "grok", "--output", "o", "--path"}); err == nil {
+		t.Fatal("--path needs a value")
+	}
+	root, commit := newRepoBytes(t, droppedOnlyFiles())
+	outDir := t.TempDir()
+	code, errOut = cliCapture(t, root, "--model", "opus", "--output", outDir, "--jobs", "2", "--call-timeout", "1m")
+	if code != 0 || errOut != "" {
+		t.Fatalf("cli code=%d err=%q", code, errOut)
+	}
+	page, err := os.ReadFile(filepath.Join(outDir, "review.html"))
+	if err != nil || !bytes.Contains(page, []byte(commit)) {
+		t.Fatal(err)
+	}
+	code, errOut = cliCapture(t, root, "--model", "opus", "--output", root)
+	if code != 1 || !strings.Contains(errOut, "refusing") {
+		t.Fatalf("refuse code=%d err=%q", code, errOut)
+	}
+}
+
+func cliCapture(t *testing.T, cwd string, args ...string) (int, string) {
+	t.Helper()
+	if cwd == "" {
+		cwd = t.TempDir()
+	}
+	var stdout, stderr bytes.Buffer
+	code := CLI(args, cwd, &stdout, &stderr)
+	return code, stderr.String()
+}
+
+func TestFindingsJSONNil(t *testing.T) {
+	if strings.TrimSpace(string(findingsJSON(nil))) != `{"findings":[]}` {
+		t.Fatal(findingsJSON(nil))
+	}
+	body := findingsJSON([]lensoutput.TypedFinding{{
+		Tag: lensoutput.TagBug, File: "a.go", StartLine: 1, EndLine: 1,
+		Issue: "i", Consequence: "c", Confidence: 1, Severity: "P3",
+	}})
+	if !bytes.Contains(body, []byte(`"severity":"P3"`)) || bytes.Contains(body, []byte(`"model"`)) {
+		t.Fatalf("%s", body)
+	}
+}
diff --git a/internal/sourcereview/select.go b/internal/sourcereview/select.go
new file mode 100644
index 00000000..7e35bb29
--- /dev/null
+++ b/internal/sourcereview/select.go
@@ -0,0 +1,169 @@
+package sourcereview
+
+import (
+	"regexp"
+	"sort"
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/dsifry/metareview/internal/claimcheck"
+	"github.com/dsifry/metareview/internal/classify"
+)
+
+// File is one kept source file. Body is the committed blob, untrimmed.
+type File struct {
+	Path string
+	Body []byte
+}
+
+// generatedLine is the Go generated-file marker. A line that only says
+// "DO NOT EDIT" does not match.
+var generatedLine = regexp.MustCompile(`^// Code generated .* DO NOT EDIT\.$`)
+
+// Select lists HEAD blobs and splits them into kept first-party source and
+// everything this command drops. Classify is unchanged: config and docs are
+// still Code/Config/Docs for the diff review; this command drops Config and Docs.
+func Select(root string, git GitFunc) (kept []File, dropped []string, commit string, err error) {
+	return selectPaths(root, git, nil)
+}
+
+func selectPaths(root string, git GitFunc, filters []string) (kept []File, dropped []string, commit string, err error) {
+	filters, err = cleanPaths(filters)
+	if err != nil {
+		return nil, nil, "", err
+	}
+	if git == nil {
+		git = realGit
+	}
+	top, err := resolveTop(root, git)
+	if err != nil {
+		return nil, nil, "", err
+	}
+	head, err := git(top, []string{"rev-parse", "HEAD"}, nil)
+	if err != nil {
+		return nil, nil, "", err
+	}
+	commit = strings.TrimSpace(string(head))
+	tree, err := git(top, []string{"ls-tree", "-r", "-z", commit}, nil)
+	if err != nil {
+		return nil, nil, "", err
+	}
+	entries, err := parseTree(tree)
+	if err != nil {
+		return nil, nil, "", err
+	}
+	var selected []treeBlob
+	for _, entry := range entries {
+		if !eligiblePath(entry.path) {
+			dropped = append(dropped, entry.path)
+		} else if pathSelected(entry.path, filters) {
+			selected = append(selected, entry)
+		}
+	}
+	blobs, err := readBlobs(top, selected, git)
+	if err != nil {
+		return nil, nil, "", err
+	}
+	for _, entry := range selected {
+		p := entry.path
+		body := blobs[p]
+		if keepPath(p, body) {
+			kept = append(kept, File{Path: p, Body: body})
+		} else {
+			dropped = append(dropped, p)
+		}
+	}
+	sort.Slice(kept, func(i, j int) bool { return kept[i].Path < kept[j].Path })
+	sort.Strings(dropped)
+	kept, err = onlyPaths(kept, filters)
+	if err != nil {
+		return nil, nil, "", err
+	}
+	return kept, dropped, commit, nil
+}
+
+// keepPath is the whole-repo cut. An unrecognised path is still Code to Classify
+// and is kept when the other cuts do not apply.
+func keepPath(p string, body []byte) bool {
+	if !eligiblePath(p) {
+		return false
+	}
+	if !utf8.Valid(body) {
+		return false
+	}
+	if isGenerated(body) {
+		return false
+	}
+	return true
+}
+
+func eligiblePath(p string) bool {
+	return classify.Classify(p) == classify.Code && !claimcheck.IsTestPath(p) && !vendored(p)
+}
+
+func vendored(p string) bool {
+	for _, s := range strings.Split(p, "/") {
+		switch s {
+		case "vendor", "node_modules", "third_party":
+			return true
+		}
+	}
+	return false
+}
+
+// isGenerated reports whether a line matches the generated marker and every
+// line before that match is blank or a comment.
+func isGenerated(body []byte) bool {
+	inBlock := false
+	allComment := true
+	for _, line := range strings.Split(string(body), "\n") {
+		line = strings.TrimSuffix(line, "\r")
+		if allComment && generatedLine.MatchString(line) {
+			return true
+		}
+		comment, next := classifyLine(line, inBlock)
+		inBlock = next
+		if !comment {
+			allComment = false
+		}
+	}
+	return false
+}
+
+// classifyLine reports whether line has no code outside a comment, and whether
+// a block comment remains open. A blank line is a comment line. A line whose
+// first non-whitespace characters are // is a comment line. /* opens a block
+// and */ closes it. Code before /* or after */ means the line is not a comment,
+// and the block still runs from /* to */.
+func classifyLine(line string, inBlock bool) (comment bool, still bool) {
+	code := false
+	i := 0
+	for i < len(line) {
+		if inBlock {
+			j := strings.Index(line[i:], "*/")
+			if j < 0 {
+				return !code, true
+			}
+			i += j + 2
+			inBlock = false
+			continue
+		}
+		r, size := utf8.DecodeRuneInString(line[i:])
+		if unicode.IsSpace(r) {
+			i += size
+			continue
+		}
+		if strings.HasPrefix(line[i:], "//") {
+			return !code, false
+		}
+		if strings.HasPrefix(line[i:], "/*") {
+			inBlock = true
+			i += 2
+			continue
+		}
+		code = true
+		i += size
+	}
+	return !code, inBlock
+}
diff --git a/internal/sourcereview/select_test.go b/internal/sourcereview/select_test.go
new file mode 100644
index 00000000..7d0e9f3b
--- /dev/null
+++ b/internal/sourcereview/select_test.go
@@ -0,0 +1,323 @@
+package sourcereview
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestSelectSpecFixture(t *testing.T) {
+	root, commit := newRepoBytes(t, specFiles())
+	kept, dropped, gotCommit, err := Select(root, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if gotCommit != commit {
+		t.Fatalf("commit %s want %s", gotCommit, commit)
+	}
+	var paths []string
+	for _, f := range kept {
+		paths = append(paths, f.Path)
+		if !bytes.Equal(f.Body, specFiles()[f.Path]) {
+			t.Fatalf("%s body = %q", f.Path, f.Body)
+		}
+	}
+	if !reflect.DeepEqual(paths, []string{"pkg/app.go", "pkg/note.go"}) {
+		t.Fatalf("kept %v", paths)
+	}
+	if !reflect.DeepEqual(dropped, specDropped) {
+		t.Fatalf("dropped %v", dropped)
+	}
+}
+
+func TestSelectDroppedOnlyFixture(t *testing.T) {
+	root, _ := newRepoBytes(t, droppedOnlyFiles())
+	kept, dropped, _, err := Select(root, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(kept) != 0 {
+		t.Fatalf("kept %v", kept)
+	}
+	if !reflect.DeepEqual(dropped, specDropped) {
+		t.Fatalf("dropped %v", dropped)
+	}
+}
+
+func TestSelectEdges(t *testing.T) {
+	files := map[string][]byte{
+		"node_modules/x.go":    []byte("package x\n"),
+		"third_party/y.go":     []byte("package y\n"),
+		"internal/foo_test.go": []byte("package internal\n"),
+		"fixtures/a.go":        []byte("package fixtures\nfunc A() {}\n"),
+		"pkg/after_code.go":    []byte("package pkg\n// Code generated by x. DO NOT EDIT.\n"),
+		"pkg/after_comment.go": []byte("\n// header\n// Code generated by x. DO NOT EDIT.\npackage pkg\n"),
+		"pkg/block.go":         []byte("/*\n header\n*/\n// Code generated by x. DO NOT EDIT.\npackage pkg\n"),
+		"pkg/code_block.go":    []byte("x := 1 /* comment\n*/\n// Code generated by x. DO NOT EDIT.\n"),
+		"pkg/after_close.go":   []byte("/* c */ code\n// Code generated by x. DO NOT EDIT.\n"),
+		"pkg/not_marker.go":    []byte("// Code generated by x. DO NOT EDIT. extra\npackage pkg\n"),
+		"pkg/crlf.go":          []byte("// note\r\n// Code generated by x. DO NOT EDIT.\r\n"),
+		"Gemfile.lock":         []byte("GEM\n"),
+		"pkg/empty.go":         {},
+		"pkg/nbsp.go":          []byte("\u00a0// comment\n世\n"),
+	}
+	root, _ := newRepoBytes(t, files)
+	kept, dropped, _, err := Select(root, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wantKept := []string{"fixtures/a.go", "pkg/after_close.go", "pkg/after_code.go", "pkg/code_block.go", "pkg/empty.go", "pkg/nbsp.go", "pkg/not_marker.go"}
+	var got []string
+	for _, f := range kept {
+		got = append(got, f.Path)
+	}
+	if !reflect.DeepEqual(got, wantKept) {
+		t.Fatalf("kept %v\ndropped %v", got, dropped)
+	}
+}
+
+func TestClassifyLine(t *testing.T) {
+	cases := []struct {
+		line    string
+		in      bool
+		comment bool
+		still   bool
+	}{
+		{"", false, true, false},
+		{"   \t", false, true, false},
+		{"// hi", false, true, false},
+		{"  // hi", false, true, false},
+		{"code // hi", false, false, false},
+		{"/* c */", false, true, false},
+		{"/* c", false, true, true},
+		{"still", true, true, true},
+		{"*/", true, true, false},
+		{"*/ code", true, false, false},
+		{"code /* c", false, false, true},
+		{"a /* b */ c", false, false, false},
+		{"/* a */ // tail", false, true, false},
+		{"/*/", false, true, true},
+		{"/**/", false, true, false},
+		{"世", false, false, false},
+	}
+	for _, tc := range cases {
+		comment, still := classifyLine(tc.line, tc.in)
+		if comment != tc.comment || still != tc.still {
+			t.Errorf("%q in=%v -> comment=%v still=%v, want %v %v", tc.line, tc.in, comment, still, tc.comment, tc.still)
+		}
+	}
+}
+
+func TestVendored(t *testing.T) {
+	if !vendored("vendor/lib.go") || !vendored("a/node_modules/b.go") || !vendored("third_party/c.go") {
+		t.Fatal("expected vendor segments")
+	}
+	if vendored("pkg/app.go") || vendored("notvendor/a.go") {
+		t.Fatal("unexpected vendor")
+	}
+}
+
+func TestSelectNotARepo(t *testing.T) {
+	if _, _, _, err := Select(t.TempDir(), nil); err == nil {
+		t.Fatal("expected error")
+	}
+}
+
+func TestSelectNoCommit(t *testing.T) {
+	root := t.TempDir()
+	gitRun(t, root, "init", "-b", "main")
+	if _, _, _, err := Select(root, nil); err == nil {
+		t.Fatal("expected error")
+	}
+}
+
+func TestSelectEmptyCommit(t *testing.T) {
+	root := t.TempDir()
+	gitRun(t, root, "init", "-b", "main")
+	gitRun(t, root, "config", "user.email", "t@example.com")
+	gitRun(t, root, "config", "user.name", "Test")
+	gitRun(t, root, "commit", "--allow-empty", "-m", "empty")
+	kept, dropped, commit, err := Select(root, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if commit == "" || len(kept) != 0 || len(dropped) != 0 {
+		t.Fatalf("kept=%v dropped=%v commit=%q", kept, dropped, commit)
+	}
+}
+
+func TestParseTree(t *testing.T) {
+	in := []byte("\x00100644 blob abc\tfile.go\x00120000 blob def\tlink\x00160000 commit zzz\tsub\x00100644 blob hash\t\x00")
+	paths, err := parseTree(in)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(paths, []treeBlob{{path: "file.go", id: "abc"}, {path: "link", id: "def"}}) {
+		t.Fatalf("%v", paths)
+	}
+	if _, err := parseTree([]byte("no-tab\x00")); err == nil {
+		t.Fatal("expected bad record")
+	}
+	if _, err := parseTree([]byte("only\tpath\x00")); err == nil {
+		t.Fatal("expected bad meta")
+	}
+}
+
+func TestParseBatch(t *testing.T) {
+	body := []byte("hello")
+	var buf bytes.Buffer
+	buf.WriteString("abc blob 5\n")
+	buf.Write(body)
+	buf.WriteByte('\n')
+	got, err := parseBatch(buf.Bytes(), []string{"a.go"})
+	if err != nil || !bytes.Equal(got["a.go"], body) {
+		t.Fatalf("%v %q", err, got["a.go"])
+	}
+	empty, err := parseBatch([]byte("abc blob 0\n\n"), []string{"e.go"})
+	if err != nil || len(empty["e.go"]) != 0 {
+		t.Fatalf("empty: %v %q", err, empty["e.go"])
+	}
+	if _, err := parseBatch(nil, []string{"a"}); err == nil {
+		t.Fatal("short header")
+	}
+	if _, err := parseBatch([]byte("abc missing\n"), []string{"a"}); err == nil {
+		t.Fatal("missing blob")
+	}
+	if _, err := parseBatch([]byte("abc blob zz\n"), []string{"a"}); err == nil {
+		t.Fatal("bad size")
+	}
+	if _, err := parseBatch([]byte("abc blob 1\nXY"), []string{"a"}); err == nil {
+		t.Fatal("missing newline")
+	}
+	if _, err := parseBatch([]byte("abc blob -1\n"), []string{"a"}); err == nil {
+		t.Fatal("negative size")
+	}
+}
+
+func TestReadBlobsErrors(t *testing.T) {
+	boom := func(string, []string, []byte) ([]byte, error) {
+		return nil, errors.New("git down")
+	}
+	if _, err := readBlobs(".", []treeBlob{{path: "a.go", id: "abc"}}, boom); err == nil {
+		t.Fatal("git error")
+	}
+	if files, err := readBlobs(".", nil, boom); err != nil || len(files) != 0 {
+		t.Fatalf("empty paths: %v %v", files, err)
+	}
+}
+
+func TestRealGitCannotStart(t *testing.T) {
+	prev := gitBin
+	gitBin = "no-such-git-binary-xyz"
+	t.Cleanup(func() { gitBin = prev })
+	if _, err := realGit(t.TempDir(), []string{"rev-parse", "HEAD"}, nil); err == nil {
+		t.Fatal("expected start failure")
+	}
+}
+
+func TestSelectFromSubdir(t *testing.T) {
+	root, commit := newRepoBytes(t, specFiles())
+	sub := filepath.Join(root, "pkg")
+	kept, _, got, err := Select(sub, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != commit || len(kept) != 2 {
+		t.Fatalf("kept %d commit %s", len(kept), got)
+	}
+}
+
+func TestSelectGitCommandErrors(t *testing.T) {
+	git := func(_ string, args []string, _ []byte) ([]byte, error) {
+		switch args[0] {
+		case "rev-parse":
+			if args[1] == "--show-toplevel" {
+				return []byte("/repo\n"), nil
+			}
+			return []byte("abc\n"), nil
+		case "ls-tree":
+			return nil, errors.New("ls-tree")
+		default:
+			return nil, errors.New("unexpected")
+		}
+	}
+	if _, _, _, err := Select("/repo", git); err == nil {
+		t.Fatal("ls-tree")
+	}
+	git = func(_ string, args []string, _ []byte) ([]byte, error) {
+		switch args[0] {
+		case "rev-parse":
+			if args[1] == "--show-toplevel" {
+				return []byte("/repo\n"), nil
+			}
+			return []byte("abc\n"), nil
+		case "ls-tree":
+			return []byte("100644 blob abc\ta.go\x00"), nil
+		default:
+			return nil, errors.New("cat-file")
+		}
+	}
+	if _, _, _, err := Select("/repo", git); err == nil {
+		t.Fatal("cat-file")
+	}
+}
+
+func TestSelectBadTree(t *testing.T) {
+	git := func(_ string, args []string, _ []byte) ([]byte, error) {
+		if args[0] == "rev-parse" && args[1] == "--show-toplevel" {
+			return []byte("/repo\n"), nil
+		}
+		if args[0] == "rev-parse" {
+			return []byte("abc\n"), nil
+		}
+		return []byte("no-tab\x00"), nil
+	}
+	if _, _, _, err := Select("/repo", git); err == nil {
+		t.Fatal("expected bad tree")
+	}
+}
+
+func TestKeepPathInvalidUTF8(t *testing.T) {
+	if keepPath("pkg/a.go", []byte{0xff}) {
+		t.Fatal("invalid utf-8 kept")
+	}
+	if !keepPath("pkg/a.go", []byte("package pkg\n")) {
+		t.Fatal("code dropped")
+	}
+	if keepPath("README.md", []byte("hi\n")) {
+		t.Fatal("docs kept")
+	}
+}
+
+func TestIsGeneratedBareDoNotEdit(t *testing.T) {
+	if isGenerated([]byte("DO NOT EDIT\n")) {
+		t.Fatal("bare DO NOT EDIT matched")
+	}
+	if !isGenerated([]byte("// Code generated by x. DO NOT EDIT.\n")) {
+		t.Fatal("marker did not match")
+	}
+	if isGenerated([]byte("package p\n")) {
+		t.Fatal("plain code matched")
+	}
+}
+
+func TestResolveTopTrims(t *testing.T) {
+	root, _ := newRepoBytes(t, map[string][]byte{"a.go": []byte("package a\n")})
+	top, err := resolveTop(root, realGit)
+	if err != nil || top != root && !strings.HasPrefix(top, root) {
+		// macOS may resolve /var -> /private/var; accept either the temp dir or its eval.
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	if top == "" {
+		t.Fatal("empty top")
+	}
+	if _, err := os.Stat(filepath.Join(top, "a.go")); err != nil {
+		t.Fatal(err)
+	}
+}