diffowl 0.3.2 → 0.3.3

package/dist/cli.js

@@ -129,7 +129,8 @@ async function loadConfigFromRoot(root) {
 }
 async function saveConfig(config) {
   const configPath = findConfigPath();
-  const content = stringify(DiffOwlConfigSchema.parse(config), { lineWidth: 0 });
+  const { model: _legacyModel, ...projectConfig } = DiffOwlConfigSchema.parse(config);
+  const content = stringify(projectConfig, { lineWidth: 0 });
   await writeFile(configPath, content, "utf-8");
   return configPath;
 }
@@ -152,14 +153,191 @@ function configExists() {
   return existsSync(findConfigPath());
 }
 
+// src/model-preference.ts
+import { mkdir as mkdir2, readFile as readFile2, rename, rm, writeFile as writeFile2 } from "fs/promises";
+import { join as join3 } from "path";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+import { z as z2 } from "zod";
+
+// src/git/state-root.ts
+import { existsSync as existsSync2 } from "fs";
+import { basename, dirname as dirname2, isAbsolute, join as join2, relative, resolve } from "path";
+import { execa } from "execa";
+var sharedDiffOwlDirPromise;
+var warnedStateMove = false;
+async function getSharedDiffOwlDir() {
+  if (!sharedDiffOwlDirPromise) {
+    sharedDiffOwlDirPromise = resolveSharedDiffOwlDir();
+  }
+  const resolution = sharedDiffOwlDirPromise;
+  try {
+    return await resolution;
+  } catch (error) {
+    if (sharedDiffOwlDirPromise === resolution) {
+      sharedDiffOwlDirPromise = void 0;
+    }
+    throw error;
+  }
+}
+async function resolveSharedDiffOwlDir() {
+  const projectRoot = getProjectRoot();
+  const localDir = getDiffOwlDir();
+  let insideWorkTree;
+  try {
+    ({ stdout: insideWorkTree } = await execa("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: projectRoot
+    }));
+  } catch (error) {
+    if (isRecoverableGitLookupError(error)) {
+      return localDir;
+    }
+    throw error;
+  }
+  if (insideWorkTree.trim() !== "true") {
+    return localDir;
+  }
+  let toplevelRaw;
+  let commonRaw;
+  try {
+    [{ stdout: toplevelRaw }, { stdout: commonRaw }] = await Promise.all([
+      gitRevParse(projectRoot, ["--show-toplevel"]),
+      gitRevParse(projectRoot, ["--git-common-dir"])
+    ]);
+  } catch (error) {
+    if (isRecoverableGitLookupError(error)) {
+      return localDir;
+    }
+    throw error;
+  }
+  const toplevel = resolveGitPath(projectRoot, toplevelRaw);
+  const commonDir = resolveGitPath(projectRoot, commonRaw);
+  const rel = relative(toplevel, projectRoot);
+  if (rel.startsWith("..")) {
+    return localDir;
+  }
+  let sharedDiffOwlDir;
+  if (basename(commonDir) !== ".git") {
+    sharedDiffOwlDir = join2(commonDir, "diffowl", rel, ".diffowl");
+  } else {
+    sharedDiffOwlDir = join2(dirname2(commonDir), rel, ".diffowl");
+  }
+  warnIfIgnoringLocalState(localDir, sharedDiffOwlDir);
+  return sharedDiffOwlDir;
+}
+function warnIfIgnoringLocalState(localDir, sharedDir) {
+  if (warnedStateMove || localDir === sharedDir) {
+    return;
+  }
+  const localDb = join2(localDir, "state.db");
+  if (!existsSync2(localDb)) {
+    return;
+  }
+  warnedStateMove = true;
+  console.warn(
+    `DiffOwl state moved: using ${join2(
+      sharedDir,
+      "state.db"
+    )}; ignoring checkout-local ${localDb}. Delete the checkout-local database if this worktree should use only the shared state.`
+  );
+}
+async function gitRevParse(projectRoot, args) {
+  try {
+    return await execa("git", ["rev-parse", "--path-format=absolute", ...args], {
+      cwd: projectRoot
+    });
+  } catch (error) {
+    if (!isUnsupportedGitOptionError(error)) {
+      throw error;
+    }
+    return await execa("git", ["rev-parse", ...args], { cwd: projectRoot });
+  }
+}
+function resolveGitPath(projectRoot, raw) {
+  const trimmed = raw.trim();
+  return isAbsolute(trimmed) ? trimmed : resolve(projectRoot, trimmed);
+}
+function isRecoverableGitLookupError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  return err.code === "ENOENT" || err.exitCode === 128;
+}
+function isUnsupportedGitOptionError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  if (err.exitCode !== 129 && err.exitCode !== 128) {
+    return false;
+  }
+  const stderr = err.stderr ?? "";
+  return stderr.includes("path-format") || stderr.includes("unknown option");
+}
+
+// src/model-preference.ts
+var ModelPreferenceSchema = z2.object({ model: ModelSchema }).strict();
+var PREFERENCES_FILENAME = "preferences.yml";
+async function loadModelPreference() {
+  const path = join3(await getSharedDiffOwlDir(), PREFERENCES_FILENAME);
+  try {
+    return ModelPreferenceSchema.parse(parse2(await readFile2(path, "utf8"))).model;
+  } catch (err) {
+    if (isMissingFile(err)) return void 0;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load ${path}: ${message}`);
+  }
+}
+async function saveModelPreference(model) {
+  const dir = await getSharedDiffOwlDir();
+  const path = join3(dir, PREFERENCES_FILENAME);
+  const temporaryPath = `${path}.${process.pid}.tmp`;
+  const preference = ModelPreferenceSchema.parse({ model });
+  await mkdir2(dir, { recursive: true });
+  await writeFile2(temporaryPath, stringify2(preference), { encoding: "utf8", mode: 384 });
+  await rename(temporaryPath, path);
+  return path;
+}
+async function resetModelPreference() {
+  await rm(join3(await getSharedDiffOwlDir(), PREFERENCES_FILENAME), { force: true });
+}
+function isMissingFile(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+
+// src/effective-config.ts
+var MissingModelError = class extends Error {
+  constructor() {
+    super("No model selected. Run `diffowl model <provider/model>`.");
+  }
+};
+async function loadEffectiveConfig(commandModel, env = process.env) {
+  const config = await loadConfig();
+  const environmentModel = env["DIFFOWL_MODEL"]?.trim() || void 0;
+  if (commandModel !== void 0) {
+    config.model = parseModel(commandModel);
+    return { config, modelSource: "command" };
+  }
+  if (environmentModel !== void 0) {
+    config.model = parseModel(environmentModel);
+    return { config, modelSource: "environment" };
+  }
+  const localModel = await loadModelPreference();
+  if (localModel !== void 0) {
+    config.model = localModel;
+    return { config, modelSource: "local" };
+  }
+  throw new MissingModelError();
+}
+
 // src/opencode/client.ts
 import { createOpencodeClient as createOpencodeClient2 } from "@opencode-ai/sdk";
 
 // src/opencode/server.ts
-import { execa } from "execa";
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile2, writeFile as writeFile2, unlink } from "fs/promises";
-import { join as join2 } from "path";
+import { execa as execa2 } from "execa";
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3, writeFile as writeFile3, unlink } from "fs/promises";
+import { join as join4 } from "path";
 var HEALTH_TIMEOUT_MS = 2e3;
 var STARTUP_WAIT_MS = 3e3;
 var MAX_RETRIES = 10;
@@ -188,7 +366,7 @@ async function getServerHealth(port) {
 }
 async function getInstalledOpencodeVersion() {
   try {
-    const { stdout } = await execa("opencode", ["--version"], { timeout: 5e3 });
+    const { stdout } = await execa2("opencode", ["--version"], { timeout: 5e3 });
     const trimmed = stdout.trim();
     if (!trimmed) {
       return null;
@@ -243,10 +421,10 @@ async function checkOpencodeInstalled() {
   const isWin = process.platform === "win32";
   const checkCmd = isWin ? "where" : "which";
   try {
-    await execa(checkCmd, ["opencode"]);
+    await execa2(checkCmd, ["opencode"]);
   } catch {
     try {
-      await execa("opencode", ["--version"], { timeout: 5e3 });
+      await execa2("opencode", ["--version"], { timeout: 5e3 });
     } catch {
       throw new Error(
         "opencode not found. Install it: npm i -g opencode-ai\nSee: https://opencode.ai/docs/"
@@ -256,9 +434,9 @@ async function checkOpencodeInstalled() {
 }
 async function spawnServer(port) {
   const dir = await ensureDiffOwlDir();
-  const pidFile = join2(dir, "server.pid");
+  const pidFile = join4(dir, "server.pid");
   await checkOpencodeInstalled();
-  const subprocess = execa("opencode", ["serve", "--port", String(port)], {
+  const subprocess = execa2("opencode", ["serve", "--port", String(port)], {
     detached: true,
     stdio: "ignore",
     cleanup: false
@@ -266,7 +444,7 @@ async function spawnServer(port) {
   void subprocess.catch(() => {
   });
   if (subprocess.pid) {
-    await writeFile2(pidFile, String(subprocess.pid), "utf-8");
+    await writeFile3(pidFile, String(subprocess.pid), "utf-8");
   }
   subprocess.unref();
 }
@@ -293,13 +471,13 @@ async function stopServer(port) {
 }
 async function stopManagedServer() {
   const dir = getDiffOwlDir();
-  const pidFile = join2(dir, "server.pid");
-  if (!existsSync2(pidFile)) {
+  const pidFile = join4(dir, "server.pid");
+  if (!existsSync3(pidFile)) {
     return false;
   }
   let pid;
   try {
-    pid = parseInt(await readFile2(pidFile, "utf-8"), 10);
+    pid = parseInt(await readFile3(pidFile, "utf-8"), 10);
   } catch {
     try {
       await unlink(pidFile);
@@ -353,8 +531,8 @@ async function stopUnhealthyServerListener(port) {
   return true;
 }
 async function cleanupPidFile() {
-  const pidFile = join2(getDiffOwlDir(), "server.pid");
-  if (!existsSync2(pidFile)) {
+  const pidFile = join4(getDiffOwlDir(), "server.pid");
+  if (!existsSync3(pidFile)) {
     return;
   }
   try {
@@ -379,7 +557,7 @@ async function findListenerPids(port) {
     return findListenerPidsWindows(port);
   }
   try {
-    const { stdout } = await execa("lsof", ["-tiTCP:" + String(port), "-sTCP:LISTEN"], {
+    const { stdout } = await execa2("lsof", ["-tiTCP:" + String(port), "-sTCP:LISTEN"], {
       timeout: 5e3
     });
     return parsePids(stdout);
@@ -389,7 +567,7 @@ async function findListenerPids(port) {
 }
 async function findListenerPidsWindows(port) {
   try {
-    const { stdout } = await execa("netstat", ["-ano"], { timeout: 5e3 });
+    const { stdout } = await execa2("netstat", ["-ano"], { timeout: 5e3 });
     const portToken = `:${port}`;
     const lines = stdout.split(/\r?\n/);
     const pids = /* @__PURE__ */ new Set();
@@ -431,7 +609,7 @@ async function isOpencodeProcess(pid) {
   try {
     if (isWin) {
       try {
-        const { stdout: stdout3 } = await execa("powershell", [
+        const { stdout: stdout3 } = await execa2("powershell", [
           "-NoProfile",
           "-Command",
           `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' | Select-Object -ExpandProperty CommandLine`
@@ -442,7 +620,7 @@ async function isOpencodeProcess(pid) {
       } catch {
       }
       try {
-        const { stdout: stdout3 } = await execa("wmic", [
+        const { stdout: stdout3 } = await execa2("wmic", [
           "process",
           "where",
           `ProcessId=${pid}`,
@@ -454,10 +632,10 @@ async function isOpencodeProcess(pid) {
         }
       } catch {
       }
-      const { stdout: stdout2 } = await execa("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"]);
+      const { stdout: stdout2 } = await execa2("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"]);
       return stdout2.toLowerCase().includes("opencode");
     }
-    const { stdout } = await execa("ps", ["-p", String(pid), "-o", "command="]);
+    const { stdout } = await execa2("ps", ["-p", String(pid), "-o", "command="]);
     return stdout.toLowerCase().includes("opencode");
   } catch {
     return false;
@@ -548,7 +726,7 @@ Do not force these passes onto unrelated changes; skip surfaces that are not pre
 - Data filtering/loss: Look for data silently dropped, hidden, duplicated, parsed with a fallback, or reported inconsistently.
 `;
 function buildReviewPrompt(target, customRules, include, exclude, localContext, depth = "default") {
-  const modeInstruction = target.kind === "staged" ? "Review the currently staged changes." : target.kind === "commit" ? "Review the selected commit." : "Review the last commit.";
+  const modeInstruction = target.kind === "staged" ? "Review the currently staged changes." : target.kind === "commit" ? "Review the selected commit." : target.kind === "base" ? "Review the committed branch changes since the merge base." : "Review the last commit.";
   let prompt = `${modeInstruction}
 
 DiffOwl has already collected the diff and likely-relevant local context below. Use this context first.
@@ -606,39 +784,39 @@ function reviewDepthInstruction(depth) {
 }
 
 // src/opencode/review-parser.ts
-import { z as z2 } from "zod";
-var ReviewSeveritySchema = z2.preprocess(
+import { z as z3 } from "zod";
+var ReviewSeveritySchema = z3.preprocess(
   (value) => typeof value === "string" ? value.toLowerCase() : value,
-  z2.enum(["error", "warning", "info"])
+  z3.enum(["error", "warning", "info"])
 );
-var ReviewConfidenceSchema2 = z2.preprocess(
+var ReviewConfidenceSchema2 = z3.preprocess(
   (value) => typeof value === "string" ? value.toLowerCase() : value,
   ReviewConfidenceSchema
 ).catch("low");
-var ReviewFindingLineSchema = z2.preprocess(
+var ReviewFindingLineSchema = z3.preprocess(
   (value) => typeof value === "string" ? Number(value) : value,
-  z2.number().int().positive()
+  z3.number().int().positive()
 );
-var ReviewFindingPathSchema = z2.preprocess((value) => {
+var ReviewFindingPathSchema = z3.preprocess((value) => {
   if (typeof value !== "string") return value;
   const normalized = value.trim().replaceAll("\\", "/").replace(/^(?:\.\/)+/, "");
   if (normalized === "" || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || normalized.split("/").includes("..")) {
     return void 0;
   }
   return normalized;
-}, z2.string().min(1));
-var ReviewFindingSchema = z2.object({
+}, z3.string().min(1));
+var ReviewFindingSchema = z3.object({
   severity: ReviewSeveritySchema,
   file: ReviewFindingPathSchema,
   line: ReviewFindingLineSchema,
-  evidence: z2.string().nullish(),
-  title: z2.string().trim().min(1),
-  body: z2.string().trim().min(1),
+  evidence: z3.string().nullish(),
+  title: z3.string().trim().min(1),
+  body: z3.string().trim().min(1),
   confidence: ReviewConfidenceSchema2
 });
-var ReviewJsonSchema = z2.object({
-  summary: z2.string(),
-  findings: z2.array(z2.unknown())
+var ReviewJsonSchema = z3.object({
+  summary: z3.string(),
+  findings: z3.array(z3.unknown())
 });
 function parseStructuredReview(raw) {
   const marker = "FINAL_REVIEW_JSON";
@@ -977,19 +1155,19 @@ async function withTimeout(promise, ms) {
 }
 
 // src/opencode/provider-payload.ts
-import { z as z3 } from "zod";
-var ProviderModelSchema = z3.object({
-  id: z3.string(),
-  status: z3.string().nullish().transform((value) => value ?? void 0),
-  reasoning: z3.boolean().nullish().transform((value) => value ?? void 0),
-  capabilities: z3.object({
-    reasoning: z3.boolean().nullish().transform((value) => value ?? void 0)
+import { z as z4 } from "zod";
+var ProviderModelSchema = z4.object({
+  id: z4.string(),
+  status: z4.string().nullish().transform((value) => value ?? void 0),
+  reasoning: z4.boolean().nullish().transform((value) => value ?? void 0),
+  capabilities: z4.object({
+    reasoning: z4.boolean().nullish().transform((value) => value ?? void 0)
   }).nullish().transform((value) => value ?? void 0),
-  variants: z3.record(z3.string(), z3.unknown()).nullish().transform((value) => value ?? void 0)
+  variants: z4.record(z4.string(), z4.unknown()).nullish().transform((value) => value ?? void 0)
 }).passthrough();
-var ProviderSchema = z3.object({
-  id: z3.string(),
-  models: z3.record(z3.string(), z3.unknown()).nullish().transform((models) => {
+var ProviderSchema = z4.object({
+  id: z4.string(),
+  models: z4.record(z4.string(), z4.unknown()).nullish().transform((models) => {
     if (!models) return void 0;
     return Object.fromEntries(
       Object.entries(models).flatMap(([key, model]) => {
@@ -999,9 +1177,9 @@ var ProviderSchema = z3.object({
     );
   })
 }).passthrough();
-var ProviderPayloadSchema = z3.object({
-  connected: z3.array(z3.string()).nullish().transform((value) => value ?? []),
-  all: z3.array(z3.unknown()).nullish().transform(
+var ProviderPayloadSchema = z4.object({
+  connected: z4.array(z4.string()).nullish().transform((value) => value ?? []),
+  all: z4.array(z4.unknown()).nullish().transform(
     (providers) => (providers ?? []).flatMap((provider) => {
       const parsed = ProviderSchema.safeParse(provider);
       return parsed.success ? [parsed.data] : [];
@@ -1057,19 +1235,19 @@ function listAvailableModels(payload) {
 }
 
 // src/review/usage.ts
-import { z as z4 } from "zod";
-var ReviewUsageTokensSchema = z4.object({
-  input: z4.number(),
-  output: z4.number(),
-  reasoning: z4.number(),
-  cache: z4.object({
-    read: z4.number(),
-    write: z4.number()
+import { z as z5 } from "zod";
+var ReviewUsageTokensSchema = z5.object({
+  input: z5.number(),
+  output: z5.number(),
+  reasoning: z5.number(),
+  cache: z5.object({
+    read: z5.number(),
+    write: z5.number()
   })
 });
-var ReviewUsageSchema = z4.object({
+var ReviewUsageSchema = z5.object({
   tokens: ReviewUsageTokensSchema,
-  cost: z4.number().nullable()
+  cost: z5.number().nullable()
 });
 function parseAssistantUsage(info) {
   if (!info || typeof info !== "object") return void 0;
@@ -1649,13 +1827,13 @@ function getOpenCodeFailureGuidance(message) {
 }
 
 // src/eval/command.ts
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { join as join13 } from "path";
+import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { join as join14 } from "path";
 import chalk2 from "chalk";
 import ora from "ora";
 
 // src/eval/command-types.ts
-import { isAbsolute, join as join3 } from "path";
+import { isAbsolute as isAbsolute2, join as join5 } from "path";
 function parseEvalOutputFormat(value) {
   if (value === void 0 || value === "text") {
     return "text";
@@ -1694,40 +1872,39 @@ function resolveEvalOutDir(cwd, out, timestamp) {
   if (out) {
     return joinPath(cwd, out);
   }
-  return joinPath(cwd, join3("eval", "results", timestamp));
+  return joinPath(cwd, join5("eval", "results", timestamp));
 }
 function joinPath(cwd, target) {
-  return isAbsolute(target) ? target : join3(cwd, target);
+  return isAbsolute2(target) ? target : join5(cwd, target);
 }
 
 // src/eval/corpus.ts
 import { createHash } from "crypto";
-import { cp, readdir, readFile as readFile3, stat } from "fs/promises";
-import { basename, join as join4, relative, sep } from "path";
-import { execa as execa2 } from "execa";
+import { cp, readdir, readFile as readFile4, stat } from "fs/promises";
+import { basename as basename2, join as join6, relative as relative2, sep } from "path";
+import { execa as execa3 } from "execa";
 
 // src/eval/case-types.ts
-import { z as z5 } from "zod";
-var EvalCaseCategorySchema = z5.enum(["bug", "clean", "mixed"]);
-var EvalCaseLanguageSchema = z5.enum(["typescript"]);
-var EvalCaseTargetSchema = z5.enum(["staged", "commit"]);
-var EvalSeveritySchema = z5.enum(["error", "warning", "info"]);
-var EvalExpectedFindingSchema = z5.object({
-  file: z5.string().trim().min(1),
-  line: z5.number().int().positive(),
-  line_tolerance: z5.number().int().nonnegative().default(2),
-  category: z5.string().trim().min(1).optional(),
+import { z as z6 } from "zod";
+var EvalCaseCategorySchema = z6.enum(["bug", "clean", "mixed"]);
+var EvalCaseLanguageSchema = z6.enum(["typescript"]);
+var EvalCaseTargetSchema = z6.enum(["staged", "commit"]);
+var EvalSeveritySchema = z6.enum(["error", "warning", "info"]);
+var EvalExpectedFindingSchema = z6.object({
+  file: z6.string().trim().min(1),
+  line: z6.number().int().positive(),
+  line_tolerance: z6.number().int().nonnegative().default(2),
   min_severity: EvalSeveritySchema.default("warning"),
-  must_detect: z5.boolean().default(true)
-});
-var EvalCaseJsonSchema = z5.object({
-  id: z5.string().trim().min(1),
+  must_detect: z6.boolean().default(true)
+}).strict();
+var EvalCaseJsonSchema = z6.object({
+  id: z6.string().trim().min(1),
   category: EvalCaseCategorySchema,
   language: EvalCaseLanguageSchema,
-  description: z5.string().trim().min(1),
+  description: z6.string().trim().min(1),
   target: EvalCaseTargetSchema.default("commit"),
-  expected: z5.array(EvalExpectedFindingSchema).default([]),
-  tags: z5.array(z5.string().trim().min(1)).default([])
+  expected: z6.array(EvalExpectedFindingSchema).default([]),
+  tags: z6.array(z6.string().trim().min(1)).default([])
 });
 function parseEvalCaseJson(raw) {
   return EvalCaseJsonSchema.parse(raw);
@@ -1746,13 +1923,13 @@ function validateEvalCaseSemantics(caseJson) {
 
 // src/eval/corpus.ts
 async function loadEvalCase(caseDir) {
-  const caseJsonPath = join4(caseDir, "case.json");
-  const baseDir = join4(caseDir, "base");
-  const patchPath = join4(caseDir, "change.patch");
-  const id = basename(caseDir);
+  const caseJsonPath = join6(caseDir, "case.json");
+  const baseDir = join6(caseDir, "base");
+  const patchPath = join6(caseDir, "change.patch");
+  const id = basename2(caseDir);
   let raw;
   try {
-    raw = JSON.parse(await readFile3(caseJsonPath, "utf8"));
+    raw = JSON.parse(await readFile4(caseJsonPath, "utf8"));
   } catch (error) {
     throw new Error(`Failed to read case.json for "${id}": ${describeError2(error)}`);
   }
@@ -1788,7 +1965,7 @@ async function copyCaseBase(evalCase, workDir) {
 }
 async function applyCasePatch(evalCase, workDir) {
   try {
-    await execa2("git", ["apply", "--whitespace=nowarn", evalCase.patchPath], {
+    await execa3("git", ["apply", "--whitespace=nowarn", evalCase.patchPath], {
       cwd: workDir,
       reject: false
     }).then((result) => {
@@ -1801,8 +1978,8 @@ async function applyCasePatch(evalCase, workDir) {
   }
 }
 async function hashCase(caseDir) {
-  const caseJson = await readFile3(join4(caseDir, "case.json"));
-  const patch = await readFile3(join4(caseDir, "change.patch"));
+  const caseJson = await readFile4(join6(caseDir, "case.json"));
+  const patch = await readFile4(join6(caseDir, "change.patch"));
   return {
     caseJsonHash: hashBuffer(caseJson),
     patchHash: hashBuffer(patch)
@@ -1813,7 +1990,7 @@ async function hashCorpus(corpusDir) {
   const lines = [];
   const posixFiles = files.map((filePath) => filePath.split(sep).join("/")).sort();
   for (const filePath of posixFiles) {
-    const content = await readFile3(join4(corpusDir, filePath));
+    const content = await readFile4(join6(corpusDir, filePath));
     lines.push(`${filePath}:${hashBuffer(content)}`);
   }
   return hashText(lines.join("\n"));
@@ -1823,27 +2000,27 @@ async function listCaseDirectories(corpusDir) {
   const caseDirs = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const caseDir = join4(corpusDir, entry.name);
+    const caseDir = join6(corpusDir, entry.name);
     try {
-      await stat(join4(caseDir, "case.json"));
+      await stat(join6(caseDir, "case.json"));
       caseDirs.push(caseDir);
     } catch {
       continue;
     }
   }
-  return caseDirs.sort((left, right) => basename(left).localeCompare(basename(right)));
+  return caseDirs.sort((left, right) => basename2(left).localeCompare(basename2(right)));
 }
 async function listFilesRecursive(rootDir, currentDir = rootDir) {
   const entries = await readdir(currentDir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const absolutePath = join4(currentDir, entry.name);
+    const absolutePath = join6(currentDir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listFilesRecursive(rootDir, absolutePath));
       continue;
     }
     if (entry.isFile()) {
-      files.push(relative(rootDir, absolutePath));
+      files.push(relative2(rootDir, absolutePath));
     }
   }
   return files;
@@ -1889,36 +2066,84 @@ function describeError2(error) {
 }
 
 // src/eval/gates-types.ts
-import { z as z6 } from "zod";
-var EvalGateThresholdsSchema = z6.object({
-  min_precision: z6.number().min(0).max(1).optional(),
-  min_recall_must_detect: z6.number().min(0).max(1).optional(),
-  max_repeated_fp_rate: z6.number().min(0).max(1).optional(),
-  min_empty_on_clean_rate: z6.number().min(0).max(1).optional()
+import { z as z7 } from "zod";
+var EvalGateThresholdsSchema = z7.object({
+  min_precision: z7.number().min(0).max(1).optional(),
+  min_recall_must_detect: z7.number().min(0).max(1).optional(),
+  max_repeated_fp_rate: z7.number().min(0).max(1).optional(),
+  min_empty_on_clean_rate: z7.number().min(0).max(1).optional()
 });
-var EvalGateResultSchema = z6.object({
-  passed: z6.boolean(),
-  failures: z6.array(z6.string())
+var EvalGateResultSchema = z7.object({
+  passed: z7.boolean(),
+  failures: z7.array(z7.string())
 });
 function parseEvalGateThresholds(raw) {
   return EvalGateThresholdsSchema.parse(raw);
 }
 
 // src/eval/manifest.ts
-import { readFile as readFile5 } from "fs/promises";
-import { join as join11 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join12 } from "path";
 
 // src/eval/runner.ts
 import { performance as performance2 } from "perf_hooks";
 
 // src/review/context.ts
-import { basename as basename4, dirname as dirname2, extname as extname5, join as join7 } from "path";
+import { basename as basename5, dirname as dirname3, extname as extname5, join as join9 } from "path";
 import picomatch from "picomatch";
 
 // src/git/diff.ts
-import { execa as execa3 } from "execa";
-import { basename as basename2, extname } from "path";
+import { execa as execa4 } from "execa";
+import { basename as basename3, extname } from "path";
 var MAX_DIFF_OUTPUT_BYTES = 2 * 1024 * 1024;
+async function getBranchDiff(baseRef, cwd) {
+  const selectedBaseRef = baseRef ?? await resolveDefaultBranchRef(cwd);
+  const baseCommit = await resolveCommitRef(selectedBaseRef, cwd);
+  const headCommit = await resolveCommitRef("HEAD", cwd);
+  const { stdout } = await execa4("git", ["merge-base", baseCommit, headCommit], cwd ? { cwd } : {});
+  const mergeBaseCommit = stdout.trim();
+  const raw = await collectGitDiff(
+    [
+      "-c",
+      "diff.noprefix=false",
+      "-c",
+      "diff.mnemonicprefix=false",
+      "diff",
+      "--stat",
+      "--patch",
+      `${mergeBaseCommit}..${headCommit}`
+    ],
+    cwd
+  );
+  return {
+    baseRef: selectedBaseRef,
+    baseCommit,
+    mergeBaseCommit,
+    headCommit,
+    diff: parseDiff(raw.stdout, raw.diagnostics)
+  };
+}
+async function resolveDefaultBranchRef(cwd) {
+  try {
+    const { stdout } = await execa4(
+      "git",
+      ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+      cwd ? { cwd } : {}
+    );
+    if (stdout.trim() !== "") return stdout.trim();
+  } catch {
+  }
+  for (const ref of ["main", "master"]) {
+    try {
+      await resolveCommitRef(ref, cwd);
+      return ref;
+    } catch {
+    }
+  }
+  throw new Error(
+    "Could not detect a default branch. Set origin/HEAD or pass an explicit base ref."
+  );
+}
 async function getResolvedCommitDiff(commit, cwd) {
   const raw = await collectGitDiff(
     [
@@ -1943,7 +2168,7 @@ async function resolveCommitRef(ref, cwd) {
     throw new Error("Commit ref must not be empty.");
   }
   try {
-    const { stdout } = await execa3(
+    const { stdout } = await execa4(
       "git",
       ["rev-parse", "--verify", "--quiet", "--end-of-options", `${trimmed}^{commit}`],
       cwd ? { cwd } : {}
@@ -1971,7 +2196,7 @@ async function getStagedDiff(cwd) {
 }
 async function collectGitDiff(args, cwd) {
   try {
-    const { stdout } = await execa3("git", args, {
+    const { stdout } = await execa4("git", args, {
       maxBuffer: MAX_DIFF_OUTPUT_BYTES,
       ...cwd ? { cwd } : {}
     });
@@ -1990,7 +2215,7 @@ async function collectGitDiff(args, cwd) {
 }
 async function isGitRepo() {
   try {
-    await execa3("git", ["rev-parse", "--is-inside-work-tree"]);
+    await execa4("git", ["rev-parse", "--is-inside-work-tree"]);
     return true;
   } catch {
     return false;
@@ -1998,7 +2223,7 @@ async function isGitRepo() {
 }
 async function hasCommits() {
   try {
-    await execa3("git", ["rev-parse", "HEAD"]);
+    await execa4("git", ["rev-parse", "HEAD"]);
     return true;
   } catch {
     return false;
@@ -2217,7 +2442,7 @@ var DOC_BASENAME_PATTERNS = [
   /^TODO/i
 ];
 function isDocFile(path) {
-  const base = basename2(path);
+  const base = basename3(path);
   const extension = extname(base).toLowerCase();
   if (DOC_EXTENSIONS.has(extension)) return true;
   if (extension) return false;
@@ -2232,7 +2457,7 @@ import { extname as extname2 } from "path";
 
 // src/review/ast/typescript.ts
 import { createRequire } from "module";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 import { pathToFileURL } from "url";
 var MAX_AST_SYMBOL_CHARS = 8e3;
 var cachedTs = null;
@@ -2249,7 +2474,7 @@ var typescriptAstParser = {
 function tryLoadUserTypescript() {
   if (cachedTs !== null) return cachedTs;
   try {
-    const require2 = createRequire(pathToFileURL(join5(process.cwd(), "package.json")));
+    const require2 = createRequire(pathToFileURL(join7(process.cwd(), "package.json")));
     cachedTs = require2("typescript");
   } catch {
     try {
@@ -2424,7 +2649,7 @@ function isCodePath(path) {
 }
 
 // src/review/context-references.ts
-import { basename as basename3, extname as extname3 } from "path";
+import { basename as basename4, extname as extname3 } from "path";
 var MAX_REFERENCES_PER_TERM = 8;
 var MAX_REFERENCE_TERMS = 8;
 var MAX_REFERENCE_LINE_CHARS = 220;
@@ -2439,7 +2664,7 @@ async function buildReferenceContexts(source, changedFiles, skippedFiles, diagno
     ...skippedFiles.map((file) => file.path)
   ]);
   for (const file of changedFiles) {
-    terms.add(basename3(file.file.path, extname3(file.file.path)));
+    terms.add(basename4(file.file.path, extname3(file.file.path)));
     for (const symbol of file.symbols.slice(0, 4)) {
       terms.add(symbol);
     }
@@ -2542,19 +2767,19 @@ function truncateSnippet(snippet) {
 }
 
 // src/review/context-source.ts
-import { readFile as readFile4, stat as stat2 } from "fs/promises";
-import { join as join6 } from "path";
-import { execa as execa4 } from "execa";
+import { readFile as readFile5, stat as stat2 } from "fs/promises";
+import { join as join8 } from "path";
+import { execa as execa5 } from "execa";
 var REFERENCE_SEARCH_TIMEOUT_MS = 5e3;
 function createFilesystemContextSource(root) {
   return {
     async read(path, maxBytes) {
       try {
-        const absolutePath = join6(root, path);
+        const absolutePath = join8(root, path);
         const info = await stat2(absolutePath);
         if (!info.isFile()) return { status: "skipped", reason: "not a regular file" };
         if (info.size > maxBytes) return tooLarge(info.size, maxBytes);
-        return { status: "loaded", content: await readFile4(absolutePath, "utf-8") };
+        return { status: "loaded", content: await readFile5(absolutePath, "utf-8") };
       } catch (err) {
         return { status: "skipped", reason: formatReadError(err) };
       }
@@ -2570,12 +2795,12 @@ function createGitContextSource(root, target) {
     async read(path, maxBytes) {
       const object = `${treeish}${path}`;
       try {
-        const { stdout: sizeOutput } = await execa4("git", ["cat-file", "-s", object], {
+        const { stdout: sizeOutput } = await execa5("git", ["cat-file", "-s", object], {
           cwd: root
         });
         const size = Number(sizeOutput.trim());
         if (Number.isFinite(size) && size > maxBytes) return tooLarge(size, maxBytes);
-        const { stdout } = await execa4("git", ["show", object], {
+        const { stdout } = await execa5("git", ["show", object], {
           cwd: root,
           maxBuffer: maxBytes,
           stripFinalNewline: false
@@ -2602,7 +2827,7 @@ async function runGitGrep(root, args, terms, commit) {
   if (commit) args.push(commit);
   args.push("--");
   try {
-    const { stdout } = await execa4("git", args, {
+    const { stdout } = await execa5("git", args, {
       cwd: root,
       timeout: REFERENCE_SEARCH_TIMEOUT_MS
     });
@@ -2858,6 +3083,7 @@ async function loadReviewSnapshot(root, target) {
       return {
         root,
         target,
+        targetCommit: null,
         diff: await getStagedDiff(root),
         source: createGitContextSource(root, { kind: "staged" })
       };
@@ -2866,6 +3092,7 @@ async function loadReviewSnapshot(root, target) {
       return {
         root,
         target,
+        targetCommit: sha,
         diff: await getResolvedCommitDiff(sha, root),
         source: createGitContextSource(root, { kind: "commit", sha })
       };
@@ -2875,10 +3102,21 @@ async function loadReviewSnapshot(root, target) {
       return {
         root,
         target,
+        targetCommit: sha,
         diff: await getResolvedCommitDiff(sha, root),
         source: createGitContextSource(root, { kind: "commit", sha })
       };
     }
+    case "base": {
+      const branch = await getBranchDiff(target.ref, root);
+      return {
+        root,
+        target: { kind: "base", ref: branch.baseRef },
+        targetCommit: branch.headCommit,
+        diff: branch.diff,
+        source: createGitContextSource(root, { kind: "commit", sha: branch.headCommit })
+      };
+    }
   }
 }
 async function buildReviewContextFromDiff(snapshot, config, depth = config.context.depth) {
@@ -2981,7 +3219,7 @@ async function buildRelatedFileContexts(source, files) {
   return related;
 }
 function shouldReviewFile(path, config) {
-  if (LOCKFILE_EXCLUDES.has(basename4(path))) return false;
+  if (LOCKFILE_EXCLUDES.has(basename5(path))) return false;
   const include = config.include.length > 0 ? config.include : ["**/*"];
   if (!include.some((pattern) => picomatch.isMatch(path, pattern))) {
     return false;
@@ -3100,14 +3338,14 @@ function getChangedLinesByFile(rawDiff) {
   return changed;
 }
 function testCandidates(path) {
-  const dir = dirname2(path);
+  const dir = dirname3(path);
   const ext = extname5(path);
-  const base = basename4(path, ext);
+  const base = basename5(path, ext);
   return [
-    join7(dir, `${base}.test${ext}`),
-    join7(dir, `${base}.spec${ext}`),
-    join7(dir, "__tests__", `${base}.test${ext}`),
-    join7(dir, "__tests__", `${base}.spec${ext}`)
+    join9(dir, `${base}.test${ext}`),
+    join9(dir, `${base}.spec${ext}`),
+    join9(dir, "__tests__", `${base}.test${ext}`),
+    join9(dir, "__tests__", `${base}.spec${ext}`)
   ];
 }
 function truncateText3(text, maxChars) {
@@ -3154,80 +3392,11 @@ function filterFindingsByChangedFiles(findings, changedFiles) {
 
 // src/review/formatter.ts
 import chalk from "chalk";
-import { writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { rename as rename2, unlink as unlink2, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
+import { randomUUID } from "crypto";
 import { existsSync as existsSync4 } from "fs";
-import { join as join9 } from "path";
-import { parse as parse2, stringify as stringify2 } from "yaml";
-
-// src/git/state-root.ts
-import { existsSync as existsSync3 } from "fs";
-import { basename as basename5, dirname as dirname3, join as join8, relative as relative2, resolve } from "path";
-import { execa as execa5 } from "execa";
-var sharedDiffOwlDirPromise;
-var warnedStateMove = false;
-async function getSharedDiffOwlDir() {
-  if (!sharedDiffOwlDirPromise) {
-    sharedDiffOwlDirPromise = resolveSharedDiffOwlDir();
-  }
-  return sharedDiffOwlDirPromise;
-}
-async function resolveSharedDiffOwlDir() {
-  const projectRoot = getProjectRoot();
-  const localDir = getDiffOwlDir();
-  let insideWorkTree;
-  try {
-    ({ stdout: insideWorkTree } = await execa5("git", ["rev-parse", "--is-inside-work-tree"], {
-      cwd: projectRoot
-    }));
-  } catch {
-    return localDir;
-  }
-  if (insideWorkTree.trim() !== "true") {
-    return localDir;
-  }
-  let toplevelRaw;
-  let commonRaw;
-  try {
-    [{ stdout: toplevelRaw }, { stdout: commonRaw }] = await Promise.all([
-      execa5("git", ["rev-parse", "--show-toplevel"], { cwd: projectRoot }),
-      execa5("git", ["rev-parse", "--git-common-dir"], { cwd: projectRoot })
-    ]);
-  } catch {
-    return localDir;
-  }
-  const toplevel = resolve(projectRoot, toplevelRaw.trim());
-  const commonDir = resolve(projectRoot, commonRaw.trim());
-  const rel = relative2(toplevel, projectRoot);
-  if (rel.startsWith("..")) {
-    return localDir;
-  }
-  let sharedDiffOwlDir;
-  if (basename5(commonDir) !== ".git") {
-    sharedDiffOwlDir = join8(commonDir, "diffowl", rel, ".diffowl");
-  } else {
-    sharedDiffOwlDir = join8(dirname3(commonDir), rel, ".diffowl");
-  }
-  warnIfIgnoringLocalState(localDir, sharedDiffOwlDir);
-  return sharedDiffOwlDir;
-}
-function warnIfIgnoringLocalState(localDir, sharedDir) {
-  if (warnedStateMove || localDir === sharedDir) {
-    return;
-  }
-  const localDb = join8(localDir, "state.db");
-  if (!existsSync3(localDb)) {
-    return;
-  }
-  warnedStateMove = true;
-  console.warn(
-    `DiffOwl state moved: using ${join8(
-      sharedDir,
-      "state.db"
-    )}; ignoring checkout-local ${localDb} (delete it, or see plan 025).`
-  );
-}
-
-// src/review/formatter.ts
+import { join as join10 } from "path";
+import { parse as parse3, stringify as stringify3 } from "yaml";
 var REPORT_SCHEMA_VERSION = 1;
 function formatFindingHeading(index, finding) {
   const ordinal = `Finding ${index + 1}`;
@@ -3294,32 +3463,52 @@ function renderMarkdown(report) {
   }
   lines.push("");
   lines.push("### Status");
-  lines.push(report.findings.length > 0 ? "Open" : "Resolved");
+  lines.push(resolveMarkdownReviewStatus(report.findings));
   return lines.join("\n");
 }
+function resolveMarkdownReviewStatus(findings) {
+  if (findings.length === 0) {
+    return "Resolved";
+  }
+  if (findings.some((finding) => finding.severity === "error" || finding.severity === "warning")) {
+    return "Open";
+  }
+  return "Advisory";
+}
 async function writeMarkdownReport(review, metadata) {
-  const dir = join9(await getSharedDiffOwlDir(), "reviews");
+  const dir = join10(await getSharedDiffOwlDir(), "reviews");
   if (!existsSync4(dir)) {
-    await mkdir2(dir, { recursive: true });
+    await mkdir3(dir, { recursive: true });
   }
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const filename = `review-${timestamp}.md`;
-  const filepath = join9(dir, filename);
+  const filepath = join10(dir, filename);
   const content = `${metadata ? renderReviewFrontmatter(metadata) : ""}# DiffOwl Review
 _${(/* @__PURE__ */ new Date()).toLocaleString()}_
 
 ${review}
 `;
-  await writeFile3(filepath, content, "utf-8");
-  const latestPath = join9(dir, "latest.md");
-  await writeFile3(latestPath, content, "utf-8");
+  await writeFileAtomic(filepath, content);
+  const latestPath = join10(dir, "latest.md");
+  await writeFileAtomic(latestPath, content);
   return filepath;
 }
+async function writeFileAtomic(filepath, content) {
+  const tempPath = `${filepath}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile4(tempPath, content, "utf-8");
+  try {
+    await rename2(tempPath, filepath);
+  } catch (error) {
+    await unlink2(tempPath).catch(() => {
+    });
+    throw error;
+  }
+}
 function parseReviewMetadata(content) {
   if (!content.startsWith("---\n")) return void 0;
   const end = content.indexOf("\n---\n", 4);
   if (end === -1) return void 0;
-  const parsed = parse2(content.slice(4, end));
+  const parsed = parse3(content.slice(4, end));
   if (!parsed || typeof parsed !== "object") return void 0;
   const diffowl = parsed.diffowl;
   if (!diffowl || typeof diffowl !== "object") return void 0;
@@ -3344,7 +3533,7 @@ function parseReviewMetadata(content) {
 }
 function renderReviewFrontmatter(metadata) {
   return `---
-${stringify2({ diffowl: metadata }, { lineWidth: 0 })}---
+${stringify3({ diffowl: metadata }, { lineWidth: 0 })}---
 
 `;
 }
@@ -3387,38 +3576,6 @@ function printFooter(report, reportPath) {
   }
   console.log();
 }
-function colorizeMarkdown(text) {
-  const lines = text.split("\n");
-  const colorizedLines = [];
-  let inCodeBlock = false;
-  for (const line of lines) {
-    if (line.trim().startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      colorizedLines.push(chalk.dim(line));
-      continue;
-    }
-    if (inCodeBlock) {
-      colorizedLines.push(line);
-    } else {
-      const colorized = line.replace(
-        /\*\*\[(ERROR|WARNING|INFO)\]([^*]*)\*\*/g,
-        (_match, label, rest) => `${colorizeSeverity(label)}${chalk.bold(rest)}`
-      ).replace(/^### (.*)/g, (_match, title) => chalk.bold.underline(title)).replace(/\*\*([^*]+)\*\*/g, (_match, content) => chalk.bold(content));
-      colorizedLines.push(colorized);
-    }
-  }
-  return colorizedLines.join("\n");
-}
-function colorizeSeverity(label) {
-  switch (label) {
-    case "ERROR":
-      return chalk.red.bold(`[${label}]`);
-    case "WARNING":
-      return chalk.yellow.bold(`[${label}]`);
-    default:
-      return chalk.blue.bold(`[${label}]`);
-  }
-}
 function formatMarkdownCodeSpan(text) {
   const trimmed = text.trim();
   let maxRun = 0;
@@ -3541,14 +3698,14 @@ ${content.replaceAll("```", "'''")}
 }
 
 // src/eval/repo.ts
-import { mkdtemp, rm } from "fs/promises";
+import { mkdtemp, rm as rm2 } from "fs/promises";
 import { tmpdir } from "os";
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 import { execa as execa6 } from "execa";
 var CLEANUP_RETRIES = 5;
 var CLEANUP_RETRY_DELAY_MS = 100;
 async function materializeEvalCaseRepo(evalCase) {
-  const workDir = await mkdtemp(join10(tmpdir(), `diffowl-eval-${evalCase.id}-`));
+  const workDir = await mkdtemp(join11(tmpdir(), `diffowl-eval-${evalCase.id}-`));
   try {
     await copyCaseBase(evalCase, workDir);
     await initEvalGitRepo(workDir);
@@ -3562,7 +3719,7 @@ async function materializeEvalCaseRepo(evalCase) {
   }
 }
 async function cleanupMaterializedRepo(workDir) {
-  await rm(workDir, {
+  await rm2(workDir, {
     recursive: true,
     force: true,
     maxRetries: CLEANUP_RETRIES,
@@ -3776,7 +3933,7 @@ async function buildEvalManifest(input) {
   };
 }
 async function readDiffOwlVersion(rootDir = process.cwd()) {
-  const packageJson = JSON.parse(await readFile5(join11(rootDir, "package.json"), "utf8"));
+  const packageJson = JSON.parse(await readFile6(join12(rootDir, "package.json"), "utf8"));
   if (!packageJson.version) {
     throw new Error("package.json is missing a version field.");
   }
@@ -3784,18 +3941,18 @@ async function readDiffOwlVersion(rootDir = process.cwd()) {
 }
 
 // src/eval/report.ts
-import { mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
-import { join as join12 } from "path";
+import { mkdir as mkdir4, writeFile as writeFile5 } from "fs/promises";
+import { join as join13 } from "path";
 
 // src/eval/delta.ts
-import { z as z7 } from "zod";
-var EvalModeDeltaMetricSchema = z7.object({
-  diffowl: z7.number().nullable(),
-  baseline: z7.number().nullable(),
-  delta: z7.number().nullable()
+import { z as z8 } from "zod";
+var EvalModeDeltaMetricSchema = z8.object({
+  diffowl: z8.number().nullable(),
+  baseline: z8.number().nullable(),
+  delta: z8.number().nullable()
 });
-var EvalCaseModeDeltaSchema = z7.object({
-  caseId: z7.string(),
+var EvalCaseModeDeltaSchema = z8.object({
+  caseId: z8.string(),
   precision: EvalModeDeltaMetricSchema,
   recall: EvalModeDeltaMetricSchema,
   fBeta: EvalModeDeltaMetricSchema,
@@ -3803,15 +3960,15 @@ var EvalCaseModeDeltaSchema = z7.object({
   latencyP50: EvalModeDeltaMetricSchema,
   usageMeanCost: EvalModeDeltaMetricSchema
 });
-var EvalCorpusModeDeltaSchema = z7.object({
-  caseCount: z7.number(),
+var EvalCorpusModeDeltaSchema = z8.object({
+  caseCount: z8.number(),
   precision: EvalModeDeltaMetricSchema,
   recall: EvalModeDeltaMetricSchema,
   fBeta: EvalModeDeltaMetricSchema,
   repeatedFpRate: EvalModeDeltaMetricSchema,
   latencyP50: EvalModeDeltaMetricSchema,
   usageMeanCost: EvalModeDeltaMetricSchema,
-  cases: z7.array(EvalCaseModeDeltaSchema)
+  cases: z8.array(EvalCaseModeDeltaSchema)
 });
 function summaryMean(summary) {
   return summary?.mean ?? null;
@@ -3958,70 +4115,70 @@ function evaluateEvalGates(doc, thresholds) {
 }
 
 // src/eval/metrics-types.ts
-import { z as z8 } from "zod";
-var StatSummarySchema = z8.object({
-  mean: z8.number(),
-  stddev: z8.number(),
-  values: z8.array(z8.number())
+import { z as z9 } from "zod";
+var StatSummarySchema = z9.object({
+  mean: z9.number(),
+  stddev: z9.number(),
+  values: z9.array(z9.number())
 });
 var DEFAULT_EVAL_METRICS_OPTIONS = {
   beta: 1
 };
-var EvalTrialMetricsSchema = z8.object({
-  trial: z8.number(),
-  precision: z8.number(),
-  recall: z8.number(),
-  fBeta: z8.number(),
-  durationMs: z8.number(),
-  usageCost: z8.number().nullable(),
-  totalTokens: z8.number().nullable(),
-  emptyOnClean: z8.boolean()
+var EvalTrialMetricsSchema = z9.object({
+  trial: z9.number(),
+  precision: z9.number(),
+  recall: z9.number(),
+  fBeta: z9.number(),
+  durationMs: z9.number(),
+  usageCost: z9.number().nullable(),
+  totalTokens: z9.number().nullable(),
+  emptyOnClean: z9.boolean()
 });
-var EvalLatencyMetricsSchema = z8.object({
-  p50: z8.number().nullable(),
-  p95: z8.number().nullable(),
-  values: z8.array(z8.number())
+var EvalLatencyMetricsSchema = z9.object({
+  p50: z9.number().nullable(),
+  p95: z9.number().nullable(),
+  values: z9.array(z9.number())
 });
-var EvalUsageMetricsSchema = z8.object({
-  meanCost: z8.number().nullable(),
-  totalCost: z8.number().nullable(),
-  meanTokens: z8.number().nullable(),
-  coverage: z8.number()
+var EvalUsageMetricsSchema = z9.object({
+  meanCost: z9.number().nullable(),
+  totalCost: z9.number().nullable(),
+  meanTokens: z9.number().nullable(),
+  coverage: z9.number()
 });
-var EvalCaseMetricsSchema = z8.object({
-  caseId: z8.string(),
+var EvalCaseMetricsSchema = z9.object({
+  caseId: z9.string(),
   category: EvalCaseCategorySchema,
-  tags: z8.array(z8.string()),
-  trialCount: z8.number(),
+  tags: z9.array(z9.string()),
+  trialCount: z9.number(),
   precision: StatSummarySchema.nullable(),
   recall: StatSummarySchema.nullable(),
   fBeta: StatSummarySchema.nullable(),
-  repeatedFpRate: z8.number(),
-  emptyOnCleanRate: z8.number().nullable(),
+  repeatedFpRate: z9.number(),
+  emptyOnCleanRate: z9.number().nullable(),
   latencyMs: EvalLatencyMetricsSchema,
   usage: EvalUsageMetricsSchema,
-  trials: z8.array(EvalTrialMetricsSchema)
+  trials: z9.array(EvalTrialMetricsSchema)
 });
-var EvalCategoryMetricsSchema = z8.object({
+var EvalCategoryMetricsSchema = z9.object({
   category: EvalCaseCategorySchema,
-  caseCount: z8.number(),
+  caseCount: z9.number(),
   precision: StatSummarySchema.nullable(),
   recall: StatSummarySchema.nullable(),
   fBeta: StatSummarySchema.nullable(),
-  repeatedFpRate: z8.number().nullable(),
-  emptyOnCleanRate: z8.number().nullable()
+  repeatedFpRate: z9.number().nullable(),
+  emptyOnCleanRate: z9.number().nullable()
 });
-var EvalCorpusMetricsSchema = z8.object({
-  caseCount: z8.number(),
-  trialCount: z8.number(),
+var EvalCorpusMetricsSchema = z9.object({
+  caseCount: z9.number(),
+  trialCount: z9.number(),
   precision: StatSummarySchema.nullable(),
   recall: StatSummarySchema.nullable(),
   fBeta: StatSummarySchema.nullable(),
-  repeatedFpRate: z8.number().nullable(),
-  emptyOnCleanRate: z8.number().nullable(),
+  repeatedFpRate: z9.number().nullable(),
+  emptyOnCleanRate: z9.number().nullable(),
   latencyMs: EvalLatencyMetricsSchema,
   usage: EvalUsageMetricsSchema,
-  byCategory: z8.array(EvalCategoryMetricsSchema)
+  byCategory: z9.array(EvalCategoryMetricsSchema)
 });
 
 // src/eval/metrics.ts
@@ -4189,147 +4346,146 @@ function computeCorpusMetrics(caseMetrics) {
 }
 
 // src/eval/report-types.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // src/eval/manifest-types.ts
-import { z as z9 } from "zod";
-var EvalReportModeSchema = z9.enum(["diffowl", "baseline", "both"]);
-var EvalManifestCaseSchema = z9.object({
-  id: z9.string(),
-  case_json_hash: z9.string(),
-  patch_hash: z9.string()
+import { z as z10 } from "zod";
+var EvalReportModeSchema = z10.enum(["diffowl", "baseline", "both"]);
+var EvalManifestCaseSchema = z10.object({
+  id: z10.string(),
+  case_json_hash: z10.string(),
+  patch_hash: z10.string()
 });
-var EvalRunManifestSchema = z9.object({
-  corpus_version: z9.string(),
-  cases: z9.array(EvalManifestCaseSchema),
-  model: z9.string(),
+var EvalRunManifestSchema = z10.object({
+  corpus_version: z10.string(),
+  cases: z10.array(EvalManifestCaseSchema),
+  model: z10.string(),
   reasoning: ReasoningEffortSchema,
   depth: ReviewContextDepthSchema,
   min_confidence: ReviewConfidenceSchema,
-  trials: z9.number().int().positive(),
+  trials: z10.number().int().positive(),
   mode: EvalReportModeSchema,
-  diffowl_version: z9.string(),
-  node_version: z9.string(),
-  opencode_version: z9.string().nullable(),
-  started_at: z9.string(),
-  finished_at: z9.string()
+  diffowl_version: z10.string(),
+  node_version: z10.string(),
+  opencode_version: z10.string().nullable(),
+  started_at: z10.string(),
+  finished_at: z10.string()
 });
 
 // src/eval/runner-types.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/review/types.ts
-import { z as z10 } from "zod";
-var ReviewSeveritySchema2 = z10.enum(["error", "warning", "info"]);
-var DurableFindingMetadataSchema = z10.object({
-  id: z10.string(),
-  classification: z10.enum(["new", "existing", "regressed"]),
-  status: z10.enum(["open", "deferred", "dismissed", "fixed", "regressed"]),
-  lifecycleSuppressed: z10.boolean().optional()
+import { z as z11 } from "zod";
+var ReviewSeveritySchema2 = z11.enum(["error", "warning", "info"]);
+var DurableFindingMetadataSchema = z11.object({
+  id: z11.string(),
+  classification: z11.enum(["new", "existing", "regressed"]),
+  status: z11.enum(["open", "deferred", "dismissed", "fixed", "regressed"]),
+  lifecycleSuppressed: z11.boolean().optional()
 });
-var ReviewFindingSchema2 = z10.object({
+var ReviewFindingSchema2 = z11.object({
   severity: ReviewSeveritySchema2,
-  file: z10.string(),
-  line: z10.number(),
-  evidence: z10.string().optional(),
-  title: z10.string(),
-  body: z10.string(),
+  file: z11.string(),
+  line: z11.number(),
+  evidence: z11.string().optional(),
+  title: z11.string(),
+  body: z11.string(),
   confidence: ReviewConfidenceSchema,
   durable: DurableFindingMetadataSchema.optional()
 });
-var ReviewTimingSchema = z10.object({
-  phase: z10.string(),
-  label: z10.string(),
-  ms: z10.number()
+var ReviewTimingSchema = z11.object({
+  phase: z11.string(),
+  label: z11.string(),
+  ms: z11.number()
 });
 
 // src/eval/runner-types.ts
-var EvalRunModeSchema = z11.enum(["diffowl", "baseline"]);
-var EvalTrialResultSchema = z11.object({
-  caseId: z11.string(),
-  trial: z11.number(),
+var EvalRunModeSchema = z12.enum(["diffowl", "baseline"]);
+var EvalTrialResultSchema = z12.object({
+  caseId: z12.string(),
+  trial: z12.number(),
   mode: EvalRunModeSchema,
-  findings: z11.array(ReviewFindingSchema2),
-  timings: z11.array(ReviewTimingSchema),
+  findings: z12.array(ReviewFindingSchema2),
+  timings: z12.array(ReviewTimingSchema),
   usage: ReviewUsageSchema.optional(),
-  sessionId: z11.string(),
-  summary: z11.string(),
-  diagnostics: z11.array(z11.string()),
-  durationMs: z11.number(),
-  error: z11.string().optional()
+  sessionId: z12.string(),
+  summary: z12.string(),
+  diagnostics: z12.array(z12.string()),
+  durationMs: z12.number(),
+  error: z12.string().optional()
 });
-var EvalCaseRunResultSchema = z11.object({
-  caseId: z11.string(),
+var EvalCaseRunResultSchema = z12.object({
+  caseId: z12.string(),
   mode: EvalRunModeSchema,
-  trials: z11.array(EvalTrialResultSchema)
+  trials: z12.array(EvalTrialResultSchema)
 });
 
 // src/eval/score-types.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var DEFAULT_EVAL_SCORE_OPTIONS = {
-  categoryMatch: false,
   fnMode: "must_detect",
   repeatedFpThreshold: 2
 };
-var EvalMatchSchema = z12.object({
-  expectedIndex: z12.number(),
-  reportedIndex: z12.number(),
-  lineDistance: z12.number()
+var EvalMatchSchema = z13.object({
+  expectedIndex: z13.number(),
+  reportedIndex: z13.number(),
+  lineDistance: z13.number()
 });
-var EvalTrialScoreSchema = z12.object({
-  caseId: z12.string(),
-  trial: z12.number(),
-  truePositives: z12.array(EvalMatchSchema),
-  falsePositives: z12.array(ReviewFindingSchema2),
-  falseNegatives: z12.array(EvalExpectedFindingSchema),
-  redundancies: z12.array(ReviewFindingSchema2),
-  counts: z12.object({
-    tp: z12.number(),
-    fp: z12.number(),
-    fn: z12.number(),
-    redundancy: z12.number()
+var EvalTrialScoreSchema = z13.object({
+  caseId: z13.string(),
+  trial: z13.number(),
+  truePositives: z13.array(EvalMatchSchema),
+  falsePositives: z13.array(ReviewFindingSchema2),
+  falseNegatives: z13.array(EvalExpectedFindingSchema),
+  redundancies: z13.array(ReviewFindingSchema2),
+  counts: z13.object({
+    tp: z13.number(),
+    fp: z13.number(),
+    fn: z13.number(),
+    redundancy: z13.number()
   })
 });
-var RepeatedFalsePositiveSchema = z12.object({
-  fingerprint: z12.string(),
-  trialCount: z12.number(),
+var RepeatedFalsePositiveSchema = z13.object({
+  fingerprint: z13.string(),
+  trialCount: z13.number(),
   example: ReviewFindingSchema2
 });
-var EvalCaseScoreSchema = z12.object({
-  caseId: z12.string(),
+var EvalCaseScoreSchema = z13.object({
+  caseId: z13.string(),
   category: EvalCaseCategorySchema,
-  tags: z12.array(z12.string()),
-  trials: z12.array(EvalTrialScoreSchema),
-  repeatedFalsePositives: z12.array(RepeatedFalsePositiveSchema)
+  tags: z13.array(z13.string()),
+  trials: z13.array(EvalTrialScoreSchema),
+  repeatedFalsePositives: z13.array(RepeatedFalsePositiveSchema)
 });
 
 // src/eval/report-types.ts
 var EVAL_RESULTS_SCHEMA_VERSION = 1;
-var EvalCaseModeResultV1Schema = z13.object({
+var EvalCaseModeResultV1Schema = z14.object({
   run: EvalCaseRunResultSchema,
   score: EvalCaseScoreSchema,
   metrics: EvalCaseMetricsSchema
 });
-var EvalCaseResultV1Schema = z13.object({
-  id: z13.string(),
+var EvalCaseResultV1Schema = z14.object({
+  id: z14.string(),
   category: EvalCaseCategorySchema,
-  tags: z13.array(z13.string()),
-  expected: z13.array(EvalExpectedFindingSchema),
-  case_json_hash: z13.string(),
-  patch_hash: z13.string(),
+  tags: z14.array(z14.string()),
+  expected: z14.array(EvalExpectedFindingSchema),
+  case_json_hash: z14.string(),
+  patch_hash: z14.string(),
   diffowl: EvalCaseModeResultV1Schema.optional(),
   baseline: EvalCaseModeResultV1Schema.optional(),
   delta: EvalCaseModeDeltaSchema.optional()
 });
-var EvalResultsAggregateV1Schema = z13.object({
+var EvalResultsAggregateV1Schema = z14.object({
   diffowl: EvalCorpusMetricsSchema.optional(),
   baseline: EvalCorpusMetricsSchema.optional(),
   delta: EvalCorpusModeDeltaSchema.optional()
 });
-var EvalResultsDocumentV1Schema = z13.object({
-  schema_version: z13.literal(EVAL_RESULTS_SCHEMA_VERSION),
+var EvalResultsDocumentV1Schema = z14.object({
+  schema_version: z14.literal(EVAL_RESULTS_SCHEMA_VERSION),
   manifest: EvalRunManifestSchema,
-  cases: z13.array(EvalCaseResultV1Schema),
+  cases: z14.array(EvalCaseResultV1Schema),
   aggregate: EvalResultsAggregateV1Schema,
   gates: EvalGateResultSchema.optional()
 });
@@ -4383,20 +4539,11 @@ function severityRank(severity) {
 }
 function resolveScoreOptions(options) {
   return {
-    categoryMatch: options?.categoryMatch ?? DEFAULT_EVAL_SCORE_OPTIONS.categoryMatch,
     fnMode: options?.fnMode ?? DEFAULT_EVAL_SCORE_OPTIONS.fnMode,
     repeatedFpThreshold: options?.repeatedFpThreshold ?? DEFAULT_EVAL_SCORE_OPTIONS.repeatedFpThreshold
   };
 }
-function categoryMatches(expected, reported) {
-  if (!expected.category) {
-    return true;
-  }
-  const needle = expected.category.toLowerCase();
-  const haystack = `${reported.title} ${reported.body}`.toLowerCase();
-  return haystack.includes(needle);
-}
-function findingMatchesExpected(expected, reported, options) {
+function findingMatchesExpected(expected, reported) {
   if (reported.file !== expected.file) {
     return false;
   }
@@ -4407,13 +4554,9 @@ function findingMatchesExpected(expected, reported, options) {
   if (severityRank(reported.severity) < severityRank(expected.min_severity)) {
     return false;
   }
-  const resolved = resolveScoreOptions(options);
-  if (resolved.categoryMatch && !categoryMatches(expected, reported)) {
-    return false;
-  }
   return true;
 }
-function buildMatchCandidates(expected, reported, options) {
+function buildMatchCandidates(expected, reported) {
   const candidates = [];
   for (let expectedIndex = 0; expectedIndex < expected.length; expectedIndex++) {
     const expectedEntry = expected[expectedIndex];
@@ -4425,7 +4568,7 @@ function buildMatchCandidates(expected, reported, options) {
       if (!reportedFinding) {
         continue;
       }
-      if (!findingMatchesExpected(expectedEntry, reportedFinding, options)) {
+      if (!findingMatchesExpected(expectedEntry, reportedFinding)) {
         continue;
       }
       candidates.push({
@@ -4473,7 +4616,7 @@ function scoreEvalTrial(evalCase, trial, options) {
   const resolved = resolveScoreOptions(options);
   const reported = trial.findings;
   const expected = evalCase.expected;
-  const candidates = buildMatchCandidates(expected, reported, resolved);
+  const candidates = buildMatchCandidates(expected, reported);
   const truePositives = assignTruePositives(candidates, reported);
   const matchedExpected = new Set(truePositives.map((match) => match.expectedIndex));
   const matchedReported = new Set(truePositives.map((match) => match.reportedIndex));
@@ -4487,7 +4630,7 @@ function scoreEvalTrial(evalCase, trial, options) {
       continue;
     }
     const matchesAssignedExpected = expected.some(
-      (entry, expectedIndex) => matchedExpected.has(expectedIndex) && findingMatchesExpected(entry, reportedFinding, resolved)
+      (entry, expectedIndex) => matchedExpected.has(expectedIndex) && findingMatchesExpected(entry, reportedFinding)
     );
     if (matchesAssignedExpected) {
       redundancies.push(reportedFinding);
@@ -4497,7 +4640,7 @@ function scoreEvalTrial(evalCase, trial, options) {
     if (!finding || matchedReported.has(reportedIndex)) {
       return false;
     }
-    return !expected.some((entry) => findingMatchesExpected(entry, finding, resolved));
+    return !expected.some((entry) => findingMatchesExpected(entry, finding));
   });
   const falseNegatives = expected.filter(
     (entry, expectedIndex) => !matchedExpected.has(expectedIndex) && expectedCountsAsFalseNegative(entry, resolved.fnMode)
@@ -4659,6 +4802,25 @@ function renderEvalSummary(document) {
   const { manifest, aggregate } = document;
   lines.push("# DiffOwl Eval Summary");
   lines.push("");
+  lines.push("## At a Glance");
+  lines.push("");
+  lines.push(`- Model: ${manifest.model}`);
+  lines.push(`- Corpus: \`${manifest.corpus_version}\``);
+  lines.push(`- Scope: ${document.cases.length} cases, ${manifest.trials} trial${manifest.trials === 1 ? "" : "s"}, ${manifest.mode} mode`);
+  if (aggregate.diffowl) {
+    lines.push(`- DiffOwl precision: ${formatStatSummary(aggregate.diffowl.precision)}`);
+    lines.push(`- DiffOwl recall: ${formatStatSummary(aggregate.diffowl.recall)}`);
+    lines.push(`- Repeated false-positive rate: ${formatNullableNumber(aggregate.diffowl.repeatedFpRate)}`);
+  }
+  if (aggregate.delta) {
+    lines.push(`- F-beta delta vs baseline: ${formatDelta(aggregate.delta.fBeta.delta)}`);
+  }
+  if (document.gates) {
+    lines.push(`- Gate check: ${document.gates.passed ? "passed" : "recorded with observations"}`);
+  }
+  lines.push("");
+  lines.push("## Run Details");
+  lines.push("");
   lines.push(`- Corpus version: \`${manifest.corpus_version}\``);
   lines.push(`- Mode: ${manifest.mode}`);
   lines.push(`- Model: ${manifest.model}`);
@@ -4686,7 +4848,7 @@ function renderEvalSummary(document) {
     `| Empty-on-clean rate | ${formatNullableNumber(aggregate.diffowl?.emptyOnCleanRate)} | ${formatNullableNumber(aggregate.baseline?.emptyOnCleanRate)} | n/a |`
   );
   lines.push(
-    `| Latency p50 (ms) | ${formatNullableNumber(aggregate.diffowl?.latencyMs.p50)} | ${formatNullableNumber(aggregate.baseline?.latencyMs.p50)} | ${formatDelta(aggregate.delta?.latencyP50.delta)} |`
+    `| Latency p50 (ms) | ${formatNullableNumber(aggregate.delta?.latencyP50.diffowl ?? aggregate.diffowl?.latencyMs.p50)} | ${formatNullableNumber(aggregate.delta?.latencyP50.baseline ?? aggregate.baseline?.latencyMs.p50)} | ${formatDelta(aggregate.delta?.latencyP50.delta)} |`
   );
   lines.push(
     `| Usage mean cost | ${formatNullableNumber(aggregate.diffowl?.usage.meanCost)} | ${formatNullableNumber(aggregate.baseline?.usage.meanCost)} | ${formatDelta(aggregate.delta?.usageMeanCost.delta)} |`
@@ -4738,9 +4900,9 @@ function renderEvalSummary(document) {
   }
   lines.push("");
   if (document.gates) {
-    lines.push("## Gates");
+    lines.push("## Gate Observations");
     lines.push("");
-    lines.push(document.gates.passed ? "Status: **passed**" : "Status: **failed**");
+    lines.push(document.gates.passed ? "Status: **passed**" : "Status: **recorded**");
     if (document.gates.failures.length > 0) {
       lines.push("");
       for (const failure of document.gates.failures) {
@@ -4755,13 +4917,45 @@ function renderEvalResultsJson(document) {
   return `${JSON.stringify(document, null, 2)}
 `;
 }
+function renderEvalMetricsJson(document) {
+  return `${JSON.stringify(toEvalMetricsDocument(document), null, 2)}
+`;
+}
 async function writeEvalResults(outDir, document) {
-  await mkdir3(outDir, { recursive: true });
-  const jsonPath = join12(outDir, "eval-results.json");
-  const summaryPath = join12(outDir, "eval-summary.md");
-  await writeFile4(jsonPath, renderEvalResultsJson(document), "utf8");
-  await writeFile4(summaryPath, renderEvalSummary(document), "utf8");
-  return { jsonPath, summaryPath };
+  await mkdir4(outDir, { recursive: true });
+  const jsonPath = join13(outDir, "eval-results.json");
+  const metricsPath = join13(outDir, "eval-metrics.json");
+  const summaryPath = join13(outDir, "eval-summary.md");
+  await writeFile5(jsonPath, renderEvalResultsJson(document), "utf8");
+  await writeFile5(metricsPath, renderEvalMetricsJson(document), "utf8");
+  await writeFile5(summaryPath, renderEvalSummary(document), "utf8");
+  return { jsonPath, metricsPath, summaryPath };
+}
+function toEvalMetricsDocument(document) {
+  return {
+    schema_version: document.schema_version,
+    manifest: document.manifest,
+    aggregate: document.aggregate,
+    gates: document.gates,
+    cases: document.cases.map((entry) => ({
+      id: entry.id,
+      category: entry.category,
+      case_json_hash: entry.case_json_hash,
+      patch_hash: entry.patch_hash,
+      diffowl: entry.diffowl ? {
+        metrics: entry.diffowl.metrics,
+        error_count: countErrors(entry.diffowl.run.trials)
+      } : void 0,
+      baseline: entry.baseline ? {
+        metrics: entry.baseline.metrics,
+        error_count: countErrors(entry.baseline.run.trials)
+      } : void 0,
+      delta: entry.delta
+    }))
+  };
+}
+function countErrors(trials) {
+  return trials.filter((trial) => trial.error).length;
 }
 function formatNullableNumber(value) {
   if (value === null || value === void 0) {
@@ -4934,7 +5128,7 @@ function renderEvalComparisonSummary(comparison) {
   for (const entry of comparison.aggregate.cases) {
     lines.push(`- **${entry.caseId}** (${entry.category})`);
     if (entry.recall.delta !== null) {
-      lines.push(`  - Recall delta: ${formatSigned(entry.recall.delta)}`);
+      lines.push(`  - Overall recall delta: ${formatSigned(entry.recall.delta)}`);
     }
     if (entry.regressions.length > 0) {
       for (const regression of entry.regressions) {
@@ -5223,7 +5417,7 @@ async function runEvalCommand(rawOptions, dependencies = {}) {
     const gatePassed = document.gates?.passed ?? true;
     let comparison;
     if (options.comparePath) {
-      const referenceRaw = JSON.parse(await readFile6(options.comparePath, "utf8"));
+      const referenceRaw = JSON.parse(await readFile7(options.comparePath, "utf8"));
       const reference = parseEvalResultsDocument(referenceRaw);
       comparison = compareEvalResults(reference, document);
     }
@@ -5240,15 +5434,17 @@ async function runEvalCommand(rawOptions, dependencies = {}) {
     const paths = await deps.writeResults(outDir, document);
     if (comparison) {
       const comparisonSummary = renderEvalComparisonSummary(comparison);
-      await writeFile5(join13(outDir, "eval-comparison.md"), comparisonSummary, "utf8");
+      await writeFile6(join14(outDir, "eval-comparison.md"), comparisonSummary, "utf8");
     }
     spinner?.succeed(`Eval complete (${cases.length} case${cases.length === 1 ? "" : "s"})`);
-    deps.stdoutWrite(`${chalk2.dim("Results:")} ${paths.jsonPath}
+    deps.stdoutWrite(`${chalk2.dim("Metrics:")} ${paths.metricsPath}
+`);
+    deps.stdoutWrite(`${chalk2.dim("Full report:")} ${paths.jsonPath}
 `);
     deps.stdoutWrite(`${chalk2.dim("Summary:")} ${paths.summaryPath}
 `);
     if (comparison) {
-      deps.stdoutWrite(`${chalk2.dim("Comparison:")} ${join13(outDir, "eval-comparison.md")}
+      deps.stdoutWrite(`${chalk2.dim("Comparison:")} ${join14(outDir, "eval-comparison.md")}
 `);
       if (comparison.hasRegressions) {
         deps.stdoutWrite(chalk2.yellow("Regressions detected vs baseline\n"));
@@ -5303,7 +5499,7 @@ async function runEvalCases(cases, options, runnerOptions, deps, spinner) {
   return bundles;
 }
 async function loadEvalGateThresholds(gatePath) {
-  const raw = JSON.parse(await readFile6(gatePath, "utf8"));
+  const raw = JSON.parse(await readFile7(gatePath, "utf8"));
   return parseEvalGateThresholds(raw);
 }
 function failEval(deps, format, error) {
@@ -5336,7 +5532,7 @@ function selectModel(models, currentModel, answer, allowKeepCurrent) {
 }
 
 // src/git/hooks.ts
-import { appendFile, chmod, mkdir as mkdir4, readFile as readFile8, readdir as readdir2, unlink as unlink2, writeFile as writeFile7 } from "fs/promises";
+import { appendFile, chmod, mkdir as mkdir5, readFile as readFile9, readdir as readdir2, unlink as unlink3, writeFile as writeFile8 } from "fs/promises";
 import {
   closeSync,
   existsSync as existsSync5,
@@ -5346,19 +5542,19 @@ import {
   writeFileSync,
   writeSync
 } from "fs";
-import { basename as basename6, dirname as dirname4, join as join14 } from "path";
+import { basename as basename6, dirname as dirname4, join as join15 } from "path";
 import { fileURLToPath } from "url";
 import { execa as execa7 } from "execa";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 
 // src/review/retention.ts
-import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
 async function trimHookLog(logFile, maxBytes) {
   if (maxBytes === 0) return;
   try {
-    const content = await readFile7(logFile);
+    const content = await readFile8(logFile);
     if (content.length <= maxBytes) return;
-    await writeFile6(logFile, content.subarray(content.length - maxBytes));
+    await writeFile7(logFile, content.subarray(content.length - maxBytes));
   } catch {
   }
 }
@@ -5386,24 +5582,24 @@ async function getHooksDir() {
 async function getHookPath() {
   const hooksDir = await getHooksDir();
   if (basename6(hooksDir) === "_" && basename6(dirname4(hooksDir)) === ".husky") {
-    return join14(dirname4(hooksDir), "post-commit");
+    return join15(dirname4(hooksDir), "post-commit");
   }
-  return join14(hooksDir, "post-commit");
+  return join15(hooksDir, "post-commit");
 }
 async function installHook() {
   const hookPath = await getHookPath();
-  await mkdir4(dirname4(hookPath), { recursive: true });
+  await mkdir5(dirname4(hookPath), { recursive: true });
   const command = await resolveHookCommand();
   if (existsSync5(hookPath)) {
-    const existing = await readFile8(hookPath, "utf-8");
+    const existing = await readFile9(hookPath, "utf-8");
     const base = existing.includes(HOOK_MARKER) ? removeManagedSection(existing) : existing.trimEnd();
     const hookSection = generateManagedSection(command);
     const updated = base && !isOnlyShebangs(base) ? `${base}
 
 ${hookSection}` : generateHookScript(command);
-    await writeFile7(hookPath, updated, "utf-8");
+    await writeFile8(hookPath, updated, "utf-8");
   } else {
-    await writeFile7(hookPath, generateHookScript(command), "utf-8");
+    await writeFile8(hookPath, generateHookScript(command), "utf-8");
   }
   await chmod(hookPath, 493);
   return hookPath;
@@ -5411,43 +5607,43 @@ ${hookSection}` : generateHookScript(command);
 async function uninstallHook() {
   const hookPath = await getHookPath();
   if (!existsSync5(hookPath)) return false;
-  const content = await readFile8(hookPath, "utf-8");
+  const content = await readFile9(hookPath, "utf-8");
   if (!content.includes(HOOK_MARKER)) return false;
   const cleaned = removeManagedSection(content);
   if (isOnlyShebangs(cleaned) || cleaned === "") {
-    await unlink2(hookPath);
+    await unlink3(hookPath);
   } else {
-    await writeFile7(hookPath, cleaned + "\n", "utf-8");
+    await writeFile8(hookPath, cleaned + "\n", "utf-8");
   }
   return true;
 }
 async function isHookInstalled() {
   const hookPath = await getHookPath();
   if (!existsSync5(hookPath)) return false;
-  const content = await readFile8(hookPath, "utf-8");
+  const content = await readFile9(hookPath, "utf-8");
   return content.includes(HOOK_MARKER);
 }
-var HookFailureSchema = z14.object({
-  commit: z14.string().min(1).optional(),
-  exitCode: z14.number().int(),
-  timestamp: z14.string(),
-  message: z14.string().optional()
+var HookFailureSchema = z15.object({
+  commit: z15.string().min(1).optional(),
+  exitCode: z15.number().int(),
+  timestamp: z15.string(),
+  message: z15.string().optional()
 });
 async function checkRecentHookFailure() {
   const dir = getDiffOwlDir();
   const pending = await listPendingReviews(dir);
   for (const item of pending) {
-    const result = await readHookResult(join14(dir, "pending-reviews", `${item.sha}.result.json`));
+    const result = await readHookResult(join15(dir, "pending-reviews", `${item.sha}.result.json`));
     if (result && result.exitCode !== 0 && result.message !== "Review started.") {
       return result;
     }
   }
-  const statusPath = join14(dir, "last-hook-status.json");
+  const statusPath = join15(dir, "last-hook-status.json");
   if (!existsSync5(statusPath)) {
     return void 0;
   }
   try {
-    const raw = await readFile8(statusPath, "utf-8");
+    const raw = await readFile9(statusPath, "utf-8");
     const parsed = HookFailureSchema.safeParse(JSON.parse(raw));
     if (!parsed.success) return void 0;
     const { commit, exitCode, timestamp, message } = parsed.data;
@@ -5483,18 +5679,18 @@ async function writeHookStatus(exitCode, commit, message, resultPath = process.e
       2
     );
     if (resultPath) {
-      await writeFile7(resultPath, content, "utf-8");
+      await writeFile8(resultPath, content, "utf-8");
       return;
     }
-    await writeFile7(join14(statusDir, "last-hook-status.json"), content, "utf-8");
+    await writeFile8(join15(statusDir, "last-hook-status.json"), content, "utf-8");
   } catch {
   }
 }
 async function clearHookFailure(dir, commit) {
-  const statusPath = join14(dir, "last-hook-status.json");
+  const statusPath = join15(dir, "last-hook-status.json");
   const status = await readHookResult(statusPath);
   if (status?.commit !== commit || status.exitCode === 0) return;
-  await unlink2(statusPath).catch(() => {
+  await unlink3(statusPath).catch(() => {
   });
 }
 function formatHookFailure(failure) {
@@ -5527,9 +5723,9 @@ function isHookQueueStopFailure(message) {
 }
 async function runHookReview() {
   const dir = await ensureDiffOwlDir();
-  const logFile = join14(dir, "hook.log");
-  const latestReport = join14(await getSharedDiffOwlDir(), "reviews", "latest.md");
-  const lockFile = join14(dir, "hook-review.lock");
+  const logFile = join15(dir, "hook.log");
+  const latestReport = join15(await getSharedDiffOwlDir(), "reviews", "latest.md");
+  const lockFile = join15(dir, "hook-review.lock");
   const commit = await getHeadCommit();
   await enqueuePendingReview(dir, commit);
   if (!acquireHookReviewLock(lockFile)) {
@@ -5578,7 +5774,7 @@ async function runHookReview() {
 }
 async function runPendingHookReviews() {
   const dir = await ensureDiffOwlDir();
-  const logFile = join14(dir, "hook.log");
+  const logFile = join15(dir, "hook.log");
   const cli = fileURLToPath(import.meta.url);
   const attempted = /* @__PURE__ */ new Set();
   while (true) {
@@ -5587,12 +5783,12 @@ async function runPendingHookReviews() {
     if (!next) return;
     attempted.add(next.sha);
     const outFd = openSync(logFile, "a");
-    const resultPath = join14(dir, "pending-reviews", `${next.sha}.result.json`);
+    const resultPath = join15(dir, "pending-reviews", `${next.sha}.result.json`);
     try {
       writeSync(outFd, `diffowl: reviewing queued commit ${next.sha}
 `);
       try {
-        await unlink2(resultPath);
+        await unlink3(resultPath);
       } catch {
       }
       const env = { ...process.env };
@@ -5633,7 +5829,7 @@ async function runPendingHookReviews() {
       continue;
     }
     try {
-      await unlink2(next.path);
+      await unlink3(next.path);
     } catch (error) {
       await appendFile(
         logFile,
@@ -5645,25 +5841,25 @@ async function runPendingHookReviews() {
       continue;
     }
     try {
-      await unlink2(resultPath);
+      await unlink3(resultPath);
     } catch {
     }
     await clearHookFailure(dir, next.sha);
   }
 }
 async function enqueuePendingReview(dir, sha) {
-  const pendingDir = join14(dir, "pending-reviews");
-  await mkdir4(pendingDir, { recursive: true });
-  const marker = join14(pendingDir, sha);
+  const pendingDir = join15(dir, "pending-reviews");
+  await mkdir5(pendingDir, { recursive: true });
+  const marker = join15(pendingDir, sha);
   if (existsSync5(marker)) return;
-  await writeFile7(
+  await writeFile8(
     marker,
     JSON.stringify({ sha, queuedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
     "utf-8"
   );
 }
 async function listPendingReviews(dir) {
-  const pendingDir = join14(dir, "pending-reviews");
+  const pendingDir = join15(dir, "pending-reviews");
   let files;
   try {
     files = await readdir2(pendingDir);
@@ -5672,14 +5868,14 @@ async function listPendingReviews(dir) {
   }
   const markerFiles = new Set(files.filter((file) => !file.endsWith(".result.json")));
   await Promise.all(
-    files.filter((file) => file.endsWith(".result.json")).filter((file) => !markerFiles.has(file.slice(0, -".result.json".length))).map((file) => unlink2(join14(pendingDir, file)).catch(() => {
+    files.filter((file) => file.endsWith(".result.json")).filter((file) => !markerFiles.has(file.slice(0, -".result.json".length))).map((file) => unlink3(join15(pendingDir, file)).catch(() => {
     }))
   );
   const pending = await Promise.all(
     [...markerFiles].map(async (file) => {
-      const path = join14(pendingDir, file);
+      const path = join15(pendingDir, file);
       try {
-        const parsed = JSON.parse(await readFile8(path, "utf-8"));
+        const parsed = JSON.parse(await readFile9(path, "utf-8"));
         if (typeof parsed.sha !== "string" || typeof parsed.queuedAt !== "string") {
           return void 0;
         }
@@ -5697,7 +5893,7 @@ async function getHeadCommit() {
 }
 async function readHookResult(path) {
   try {
-    const parsed = HookFailureSchema.safeParse(JSON.parse(await readFile8(path, "utf-8")));
+    const parsed = HookFailureSchema.safeParse(JSON.parse(await readFile9(path, "utf-8")));
     if (!parsed.success) return void 0;
     return {
       ...parsed.data.commit ? { commit: parsed.data.commit } : {},
@@ -5766,7 +5962,7 @@ async function checkHookStale() {
   }
   let content;
   try {
-    content = await readFile8(hookPath, "utf-8");
+    content = await readFile9(hookPath, "utf-8");
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { installed: true, stale: false, reason: `Cannot read hook file: ${message}` };
@@ -5908,20 +6104,20 @@ function shellQuote(value) {
 }
 
 // src/review/report-path.ts
-import { readFile as readFile9, readdir as readdir3 } from "fs/promises";
-import { basename as basename7, isAbsolute as isAbsolute2, join as join15, resolve as resolve2 } from "path";
+import { readFile as readFile10, readdir as readdir3 } from "fs/promises";
+import { basename as basename7, isAbsolute as isAbsolute3, join as join16, resolve as resolve2 } from "path";
 async function resolveReviewReportPath(report) {
-  if (isAbsolute2(report)) return report;
+  if (isAbsolute3(report)) return report;
   if (report.includes("/") || report.includes("\\")) {
     return resolve2(report);
   }
-  return join15(await getSharedDiffOwlDir(), "reviews", report);
+  return join16(await getSharedDiffOwlDir(), "reviews", report);
 }
 async function listReviewReportPaths() {
-  const reviews = join15(await getSharedDiffOwlDir(), "reviews");
+  const reviews = join16(await getSharedDiffOwlDir(), "reviews");
   const entries = await Promise.all([
     listMarkdownFiles(reviews),
-    listMarkdownFiles(join15(reviews, "resolved"))
+    listMarkdownFiles(join16(reviews, "resolved"))
   ]);
   return entries.flat().filter((path) => basename7(path) !== "latest.md").sort((a, b) => basename7(b).localeCompare(basename7(a)));
 }
@@ -5936,14 +6132,14 @@ function selectReviewReportPath(paths, answer) {
 async function listMarkdownFiles(dir) {
   let paths;
   try {
-    paths = (await readdir3(dir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => join15(dir, entry.name));
+    paths = (await readdir3(dir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => join16(dir, entry.name));
   } catch {
     return [];
   }
   const reports = await Promise.all(
     paths.map(async (path) => {
       try {
-        return parseReviewMetadata(await readFile9(path, "utf-8")) ? path : void 0;
+        return parseReviewMetadata(await readFile10(path, "utf-8")) ? path : void 0;
       } catch {
         return void 0;
       }
@@ -5956,8 +6152,8 @@ async function listMarkdownFiles(dir) {
 import { createHash as createHash3 } from "crypto";
 
 // src/state/db.ts
-import { mkdir as mkdir5 } from "fs/promises";
-import { join as join16 } from "path";
+import { mkdir as mkdir6 } from "fs/promises";
+import { join as join17 } from "path";
 
 // src/state/migrations/001-initial-schema.ts
 var MIGRATION_001_INITIAL_SCHEMA = `
@@ -6029,6 +6225,36 @@ CREATE TABLE finding_events (
 CREATE INDEX idx_finding_events_finding_id ON finding_events(finding_id);
 `;
 
+// src/state/migrations/002-base-review-target.ts
+var MIGRATION_002_BASE_REVIEW_TARGET = `
+PRAGMA legacy_alter_table = ON;
+
+ALTER TABLE reviews RENAME TO reviews_old;
+
+CREATE TABLE reviews (
+  id TEXT PRIMARY KEY,
+  created_at TEXT NOT NULL,
+  target_kind TEXT NOT NULL CHECK (target_kind IN ('staged', 'commit', 'last-commit', 'base')),
+  target_ref TEXT,
+  target_commit TEXT,
+  diff_hash TEXT NOT NULL,
+  model TEXT NOT NULL,
+  reasoning TEXT NOT NULL,
+  depth TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  summary TEXT NOT NULL,
+  report_path TEXT,
+  diagnostics_json TEXT NOT NULL DEFAULT '[]',
+  timings_json TEXT NOT NULL DEFAULT '[]',
+  skipped_reason TEXT
+);
+
+INSERT INTO reviews SELECT * FROM reviews_old;
+DROP TABLE reviews_old;
+
+PRAGMA legacy_alter_table = OFF;
+`;
+
 // src/state/sqlite.ts
 var sqliteModule;
 async function openSqliteDatabase(path) {
@@ -6141,19 +6367,20 @@ function normalizeRow(row) {
 }
 
 // src/state/types.ts
-import { randomUUID } from "crypto";
-var CURRENT_SCHEMA_VERSION = 1;
+import { randomUUID as randomUUID2 } from "crypto";
+var CURRENT_SCHEMA_VERSION = 2;
 function createReviewId() {
-  return `rev_${randomUUID()}`;
+  return `rev_${randomUUID2()}`;
 }
 function createFindingId() {
-  return `fnd_${randomUUID()}`;
+  return `fnd_${randomUUID2()}`;
 }
 
 // src/state/db.ts
 var BUSY_TIMEOUT_MS = 5e3;
 var MIGRATIONS = {
-  1: MIGRATION_001_INITIAL_SCHEMA
+  1: MIGRATION_001_INITIAL_SCHEMA,
+  2: MIGRATION_002_BASE_REVIEW_TARGET
 };
 var StateDatabaseError = class extends Error {
   name = "StateDatabaseError";
@@ -6162,10 +6389,10 @@ var InvalidFindingTransitionError = class extends StateDatabaseError {
   name = "InvalidFindingTransitionError";
 };
 function getStateDbPath(diffOwlDir) {
-  return join16(diffOwlDir, "state.db");
+  return join17(diffOwlDir, "state.db");
 }
 async function openStateDatabase(diffOwlDir) {
-  await mkdir5(diffOwlDir, { recursive: true });
+  await mkdir6(diffOwlDir, { recursive: true });
   const path = getStateDbPath(diffOwlDir);
   const db = await openSqliteDatabase(path);
   try {
@@ -6225,12 +6452,22 @@ function applyMigrations(db, targetVersion, migrations = MIGRATIONS) {
     }
     const migrate = db.transaction(() => {
       db.exec(sql);
+      const violations = db.pragma("foreign_key_check");
+      if (violations.length > 0) {
+        throw new StateDatabaseError(`Migration ${version} introduced foreign key violations`);
+      }
       db.prepare("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)").run(
         version,
         (/* @__PURE__ */ new Date()).toISOString()
       );
     });
-    migrate();
+    const foreignKeysEnabled = db.pragma("foreign_keys", { simple: true }) === 1;
+    if (foreignKeysEnabled) db.pragma("foreign_keys = OFF");
+    try {
+      migrate();
+    } finally {
+      if (foreignKeysEnabled) db.pragma("foreign_keys = ON");
+    }
   }
 }
 function listAppliedMigrationVersions(db) {
@@ -7029,6 +7266,8 @@ function mapReviewTarget(target) {
       return { targetKind: "last-commit", targetRef: null };
     case "commit":
       return { targetKind: "commit", targetRef: target.ref ?? null };
+    case "base":
+      return { targetKind: "base", targetRef: target.ref ?? null };
   }
 }
 
@@ -7048,9 +7287,11 @@ function buildReviewJsonDocument(input) {
     input.persisted.reconcile.observations,
     input.verbose
   );
-  const actionableCount = input.persisted.reconcile.observations.filter(
-    (item) => !item.suppressed
+  const unsuppressed = input.persisted.reconcile.observations.filter((item) => !item.suppressed);
+  const actionableCount = unsuppressed.filter(
+    (item) => item.observation.severity !== "info"
   ).length;
+  const advisoryCount = unsuppressed.filter((item) => item.observation.severity === "info").length;
   return {
     schema_version: JSON_OUTPUT_SCHEMA_VERSION,
     review: {
@@ -7066,7 +7307,7 @@ function buildReviewJsonDocument(input) {
       depth: input.review.depth,
       session_id: input.review.sessionId,
       summary: input.review.summary,
-      status: resolveReviewJsonStatus(input.review, actionableCount),
+      status: resolveReviewJsonStatus(input.review, actionableCount, advisoryCount),
       report_path: input.review.reportPath,
       skipped_reason: input.review.skippedReason
     },
@@ -7105,11 +7346,17 @@ function selectJsonObservations(observations, verbose = false) {
   }
   return observations.filter((item) => !item.suppressed);
 }
-function resolveReviewJsonStatus(review, actionableCount) {
+function resolveReviewJsonStatus(review, actionableCount, advisoryCount) {
   if (review.skippedReason) {
     return "skipped";
   }
-  return actionableCount > 0 ? "open" : "resolved";
+  if (actionableCount > 0) {
+    return "open";
+  }
+  if (advisoryCount > 0) {
+    return "advisory";
+  }
+  return "resolved";
 }
 function mapJsonFinding(item, occurrenceCounts) {
   const { observation, finding, fingerprint, suppressed } = item;
@@ -7232,6 +7479,14 @@ function renderFindingDetailJson(detail) {
   return `${JSON.stringify(detail, null, 2)}
 `;
 }
+function renderFindingListJson(items) {
+  return `${JSON.stringify(
+    { schema_version: 1, count: items.length, findings: items },
+    null,
+    2
+  )}
+`;
+}
 function computeListLayout(columns) {
   const fixedWidth = fixedPrefixWidth();
   const flexibleWidth = Math.max(
@@ -7539,15 +7794,245 @@ function toFindingDetail(db, finding) {
   };
 }
 
+// src/review/run.ts
+var defaultReviewPipelineDeps = {
+  buildReviewContextFromDiff,
+  computeDiffHash,
+  enrichReviewFindingsWithDurableMetadata,
+  ensureServer,
+  filterFindingsByChangedFiles,
+  filterFindingsByConfidence,
+  formatExcludedCandidateSummary,
+  formatLifecycleSuppressedSummary,
+  isServerRunning,
+  loadFindingOccurrenceCounts,
+  loadReviewSnapshot,
+  mapReviewTarget,
+  persistReviewRun,
+  renderMarkdown,
+  renderReviewContext,
+  resolveTargetCommit,
+  runReview,
+  updatePersistedReview,
+  writeMarkdownReport
+};
+async function runReviewPipeline(input, deps = defaultReviewPipelineDeps) {
+  const outcome = await runReviewSkipChecks(input, deps);
+  if (outcome.kind !== "continue") {
+    return outcome;
+  }
+  const { snapshot, timings } = outcome;
+  const { diff } = snapshot;
+  const contextStart = performance.now();
+  const reviewContext = await deps.buildReviewContextFromDiff(snapshot, input.config, input.depth);
+  recordReviewTiming(timings, "context-build", "Local review context build", contextStart);
+  const contextRenderStart = performance.now();
+  const localContext = deps.renderReviewContext(reviewContext, { depth: input.depth });
+  recordReviewTiming(timings, "context-render", "Local review context render", contextRenderStart);
+  if (reviewContext.diagnostics.length > 0) {
+    input.onDiagnostics?.(reviewContext.diagnostics);
+  }
+  const serverStart = performance.now();
+  input.onStatus?.("Connecting to OpenCode...");
+  await prepareReviewServer2(input.config, deps);
+  recordReviewTiming(timings, "server-ensure", "OpenCode server ensure", serverStart);
+  const reviewStart = performance.now();
+  input.onStatus?.("Reviewing changes...");
+  const reviewResult = await deps.runReview({
+    target: snapshot.target,
+    directory: input.projectRoot,
+    config: input.config,
+    localContext,
+    depth: input.depth,
+    ...input.signal ? { signal: input.signal } : {},
+    ...input.onProgress ? { onProgress: input.onProgress } : {}
+  });
+  const report = reviewResult.report;
+  recordReviewTiming(timings, "review-run", "OpenCode review run", reviewStart);
+  const diagnostics = report.diagnostics ?? [];
+  const confidenceFilter = deps.filterFindingsByConfidence(report.findings, input.config.min_confidence);
+  report.findings = confidenceFilter.findings;
+  const changedFilesSet = new Set(reviewContext.changedFiles.map((file) => file.file.path));
+  const changedFileFilter = deps.filterFindingsByChangedFiles(report.findings, changedFilesSet);
+  report.findings = changedFileFilter.findings;
+  if (changedFileFilter.suppressed.length > 0 && input.verbose) {
+    report.suppressedFindings = changedFileFilter.suppressed;
+  }
+  if (confidenceFilter.dropped > 0 || changedFileFilter.suppressed.length > 0) {
+    diagnostics.push(deps.formatExcludedCandidateSummary(
+      confidenceFilter.dropped,
+      changedFileFilter.suppressed.length
+    ));
+  }
+  if (diagnostics.length > 0) {
+    report.diagnostics = diagnostics;
+  }
+  const persistStart = performance.now();
+  const persisted = await deps.persistReviewRun(input.diffOwlDir, {
+    ...deps.mapReviewTarget(snapshot.target),
+    targetCommit: snapshot.targetCommit,
+    diffHash: deps.computeDiffHash(diff.raw),
+    model: input.config.model,
+    reasoning: input.config.reasoning.effort,
+    depth: input.depth,
+    sessionId: reviewResult.sessionId,
+    summary: report.summary,
+    diagnostics,
+    timings: [...timings, ...report.timings ?? []],
+    findings: report.findings
+  });
+  recordReviewTiming(timings, "persist-state", "Persist review state", persistStart);
+  report.findings = persisted.actionableFindings;
+  const lifecycleSummary = deps.formatLifecycleSuppressedSummary(persisted.reconcile.suppressedCounts);
+  if (lifecycleSummary) {
+    diagnostics.push(lifecycleSummary);
+    report.diagnostics = diagnostics;
+  }
+  if (input.verbose && persisted.lifecycleSuppressedFindings.length > 0) {
+    report.suppressedFindings = [
+      ...report.suppressedFindings ?? [],
+      ...persisted.lifecycleSuppressedFindings
+    ];
+  }
+  report.findings = deps.enrichReviewFindingsWithDurableMetadata(report.findings, persisted.reconcile);
+  if (report.suppressedFindings) {
+    report.suppressedFindings = deps.enrichReviewFindingsWithDurableMetadata(report.suppressedFindings, persisted.reconcile);
+  }
+  const renderStart = performance.now();
+  const markdown = deps.renderMarkdown(report);
+  recordReviewTiming(timings, "render-report", "Markdown render", renderStart);
+  const writeStart = performance.now();
+  let reportPath;
+  try {
+    reportPath = await deps.writeMarkdownReport(markdown, {
+      schema_version: REPORT_SCHEMA_VERSION,
+      review_id: persisted.reviewId,
+      session_id: reviewResult.sessionId,
+      project_root: input.projectRoot
+    });
+    await deps.updatePersistedReview(input.diffOwlDir, persisted.reviewId, { reportPath, diagnostics });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    diagnostics.push(`Report write failed: ${message}`);
+    report.diagnostics = diagnostics;
+    await deps.updatePersistedReview(input.diffOwlDir, persisted.reviewId, { reportPath: null, diagnostics });
+    throw err;
+  }
+  recordReviewTiming(timings, "write-report", "Report write", writeStart);
+  return {
+    kind: "completed",
+    report,
+    persisted,
+    reportPath,
+    sessionId: reviewResult.sessionId,
+    suppressed: {
+      outsideChangedFiles: changedFileFilter.suppressed.length,
+      belowConfidence: confidenceFilter.dropped
+    },
+    timings: [...timings, ...report.timings ?? []],
+    usage: reviewResult.usage ?? null
+  };
+}
+async function runReviewSkipChecks(input, deps = defaultReviewPipelineDeps) {
+  const timings = [...input.timings];
+  const snapshot = await deps.loadReviewSnapshot(input.projectRoot, input.target);
+  const { diff } = snapshot;
+  const skippedReview = {
+    ...deps.mapReviewTarget(snapshot.target),
+    diffHash: deps.computeDiffHash(diff.raw),
+    model: input.config.model,
+    reasoning: input.config.reasoning.effort,
+    depth: input.depth,
+    sessionId: "",
+    diagnostics: [],
+    timings,
+    findings: []
+  };
+  if ((snapshot.target.kind === "staged" || snapshot.target.kind === "base") && diff.files.length === 0) {
+    if (!input.persistEmptyDiff) {
+      return { kind: "empty-diff", timings };
+    }
+    const summary = snapshot.target.kind === "staged" ? "No staged changes to review." : "No committed branch changes to review.";
+    return {
+      kind: "skipped",
+      reason: "empty-diff",
+      persisted: await deps.persistReviewRun(input.diffOwlDir, {
+        ...skippedReview,
+        targetCommit: snapshot.targetCommit,
+        summary,
+        skippedReason: "empty-diff"
+      }),
+      reportPath: null,
+      timings
+    };
+  }
+  if (!input.config.skip_doc_only || !isDocOnlyDiff(diff)) {
+    return { kind: "continue", snapshot, timings };
+  }
+  const persisted = await deps.persistReviewRun(input.diffOwlDir, {
+    ...skippedReview,
+    targetCommit: snapshot.targetCommit,
+    summary: "Documentation-only changes detected. No code review performed.",
+    skippedReason: "documentation-only"
+  });
+  try {
+    const reportPath = await deps.writeMarkdownReport(buildDocOnlySkipMarkdown(diff));
+    await deps.updatePersistedReview(input.diffOwlDir, persisted.reviewId, { reportPath });
+    return { kind: "skipped", reason: "documentation-only", persisted, reportPath, timings };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await deps.updatePersistedReview(input.diffOwlDir, persisted.reviewId, {
+      reportPath: null,
+      diagnostics: [`Report write failed: ${message}`]
+    });
+    throw err;
+  }
+}
+function buildDocOnlySkipMarkdown(diff) {
+  return [
+    "### Summary",
+    "Documentation-only changes detected. No code review performed.",
+    "",
+    "### Changed Files",
+    ...diff.files.map((file) => `- ${file.path} (+${file.additions}/-${file.deletions})`)
+  ].join("\n");
+}
+async function resolveTargetCommit(target, resolveCommit = resolveCommitRef) {
+  switch (target.kind) {
+    case "staged":
+      return null;
+    case "last-commit":
+    case "base":
+      return resolveCommit("HEAD");
+    case "commit":
+      return resolveCommit(target.ref);
+  }
+}
+async function prepareReviewServer2(config, deps = defaultReviewPipelineDeps) {
+  if (config.server.auto_start) {
+    await deps.ensureServer(config.server.port);
+    return;
+  }
+  if (await deps.isServerRunning(config.server.port)) {
+    return;
+  }
+  throw new Error(
+    `OpenCode server is not running on port ${config.server.port}. Start it with \`diffowl server start\` or set server.auto_start: true.`
+  );
+}
+function recordReviewTiming(timings, phase, label, start) {
+  timings.push({ phase, label, ms: Math.max(0, Math.round(performance.now() - start)) });
+}
+
 // src/cli.ts
-import { readFile as readFile10 } from "fs/promises";
+import { readFile as readFile11 } from "fs/promises";
 import { basename as basename8, dirname as dirname5 } from "path";
 import { execa as execa8 } from "execa";
 
 // package.json
 var package_default = {
   name: "diffowl",
-  version: "0.3.2",
+  version: "0.3.3",
   description: "Local AI code review agent powered by OpenCode",
   keywords: [
     "ai",
@@ -7585,7 +8070,6 @@ var package_default = {
     lint: "oxlint . && pnpm run typecheck",
     format: "oxfmt --write .",
     "format:check": "oxfmt --check .",
-    "dogfood:0.3": "pnpm run build && node scripts/dogfood-0.3.mjs",
     eval: "pnpm run build && node dist/cli.js eval",
     prepack: "npm run build"
   },
@@ -7617,10 +8101,10 @@ var package_default = {
 // src/cli.ts
 var program = new Command();
 program.name("diffowl").description("Local AI code review agent powered by OpenCode").version(package_default.version);
-program.command("review", { isDefault: true }).description("Review the last commit or staged changes").option("--staged", "Review staged changes instead of last commit").option("--commit <ref>", "Review a specific commit ref instead of HEAD").option("--hook", "Running from git hook (non-blocking mode)").option("--depth <depth>", "Review context depth: shallow or default").option(
+program.command("review", { isDefault: true }).description("Review the last commit, staged changes, or committed branch changes").option("--staged", "Review staged changes instead of last commit").option("--commit <ref>", "Review a specific commit ref instead of HEAD").option("--base [ref]", "Review committed branch changes since the merge base").option("--hook", "Running from git hook (non-blocking mode)").option("--depth <depth>", "Review context depth: shallow or default").option(
   "--reasoning <effort>",
   "Reasoning variant: auto, none, minimal, low, medium, high, max, or xhigh"
-).option("--verbose", "Include suppressed findings and extra review details").option("--format <format>", "Output format: text or json", "text").action(async (options) => {
+).option("--model <id>", "Review model override").option("--verbose", "Include suppressed findings and extra review details").option("--format <format>", "Output format: text or json", "text").action(async (options) => {
   const format = resolveReviewOutputFormat(options.format);
   const jsonMode = format === "json";
   const hookCommit = options.hook && options.commit ? String(options.commit) : void 0;
@@ -7635,7 +8119,7 @@ program.command("review", { isDefault: true }).description("Review the last comm
   const timings = [];
   const gitRepoStart = performance.now();
   const isRepo = await isGitRepo();
-  recordCliTiming(timings, "git-repo-check", "Git repository check", gitRepoStart);
+  timings.push(createCliTiming("git-repo-check", "Git repository check", gitRepoStart));
   if (!isRepo) {
     await failReview(format, "Not a git repository", { hook: options.hook, hookCommit });
   }
@@ -7643,23 +8127,39 @@ program.command("review", { isDefault: true }).description("Review the last comm
     console.log(chalk4.yellow("No .diffowl.yml found. Running first-time setup...\n"));
     await runInit();
   }
-  const config = await loadConfigOrExit();
+  const config = (await loadEffectiveConfigOrExit(options.model)).config;
   const projectRoot = getProjectRoot();
   const diffOwlDir = await getSharedDiffOwlDir();
+  const baseRequested = options.base !== void 0;
   if (options.staged && options.commit) {
     await failReview(format, "Cannot use --staged and --commit together", {
       hook: options.hook,
       hookCommit
     });
   }
-  const target = options.staged ? { kind: "staged" } : options.commit ? { kind: "commit", ref: String(options.commit) } : { kind: "last-commit" };
+  if (options.staged && baseRequested) {
+    await failReview(format, "Cannot use --staged and --base together", {
+      hook: options.hook,
+      hookCommit
+    });
+  }
+  if (options.commit && baseRequested) {
+    await failReview(format, "Cannot use --commit and --base together", {
+      hook: options.hook,
+      hookCommit
+    });
+  }
+  const target = options.staged ? { kind: "staged" } : options.commit ? { kind: "commit", ref: String(options.commit) } : baseRequested ? {
+    kind: "base",
+    ...typeof options.base === "string" ? { ref: options.base } : {}
+  } : { kind: "last-commit" };
   const depth = resolveReviewDepth(options.depth, config);
   config.reasoning.effort = resolveReasoningEffort(options.reasoning, config);
   const verbose = Boolean(config.verbose || options.verbose);
   if (target.kind !== "staged") {
     const hasCommitsStart = performance.now();
     const commitsExist = await hasCommits();
-    recordCliTiming(timings, "git-commit-check", "Git commit check", hasCommitsStart);
+    timings.push(createCliTiming("git-commit-check", "Git commit check", hasCommitsStart));
     if (!commitsExist) {
       await failReview(format, "No commits found in this repository", {
         hook: options.hook,
@@ -7704,247 +8204,108 @@ program.command("review", { isDefault: true }).description("Review the last comm
     });
   });
   try {
-    const snapshot = await loadReviewSnapshot(projectRoot, target);
-    const { diff } = snapshot;
-    if (target.kind === "staged" && diff.files.length === 0) {
+    const outcome = await runReviewPipeline({
+      target,
+      config,
+      depth,
+      verbose,
+      projectRoot,
+      diffOwlDir,
+      timings,
+      persistEmptyDiff: jsonMode,
+      signal: cancelController.signal,
+      onProgress: (event) => {
+        if (spinner) {
+          spinner.text = formatReviewProgress(event);
+        }
+      },
+      onDiagnostics: (diagnostics) => {
+        if (!spinner) {
+          return;
+        }
+        spinner.warn("Local review context built with warnings.");
+        for (const diagnostic of diagnostics) {
+          console.log(chalk4.yellow(`  - ${diagnostic}`));
+        }
+        console.log();
+        spinner.start("Connecting to OpenCode...");
+      },
+      onStatus: (message) => {
+        if (spinner) {
+          spinner.text = message;
+        }
+      }
+    });
+    if (outcome.kind === "empty-diff") {
       spinner?.stop();
-      if (jsonMode) {
-        const persisted2 = await persistReviewRun(diffOwlDir, {
-          ...mapReviewTarget(target),
-          targetCommit: null,
-          diffHash: computeDiffHash(diff.raw),
-          model: config.model,
-          reasoning: config.reasoning.effort,
-          depth,
-          sessionId: "",
-          summary: "No staged changes to review.",
-          diagnostics: [],
-          timings,
-          findings: [],
-          skippedReason: "empty-diff"
-        });
-        await emitReviewJsonSuccess({
-          diffOwlDir,
-          reviewId: persisted2.reviewId,
-          persisted: persisted2,
-          suppressed: { outsideChangedFiles: 0, belowConfidence: 0 },
-          verbose,
-          timings
-        });
-        process.exit(0);
+      console.log(chalk4.yellow("No changes to review"));
+      if (options.hook) {
+        await writeHookStatus(0, hookCommit);
+      }
+      process.exit(0);
+    }
+    if (outcome.kind === "skipped" && outcome.reason === "empty-diff") {
+      spinner?.stop();
+      await emitReviewJsonSuccess({
+        diffOwlDir,
+        reviewId: outcome.persisted.reviewId,
+        persisted: outcome.persisted,
+        suppressed: { outsideChangedFiles: 0, belowConfidence: 0 },
+        verbose,
+        timings: outcome.timings
+      });
+      if (options.hook) {
+        await writeHookStatus(0, hookCommit);
       }
-      console.log(chalk4.yellow("No staged changes to review"));
       process.exit(0);
     }
-    if (config.skip_doc_only && isDocOnlyDiff(diff)) {
+    if (outcome.kind === "skipped" && outcome.reason === "documentation-only") {
       spinner?.stop();
       if (!jsonMode) {
         console.warn(chalk4.yellow("Documentation-only changes detected. Skipping review."));
       }
-      const skipContent = buildDocOnlySkipMarkdown(diff);
-      const diffHash2 = computeDiffHash(diff.raw);
-      const targetFields2 = mapReviewTarget(target);
-      const targetCommit2 = await resolveTargetCommit(target);
-      const persisted2 = await persistReviewRun(diffOwlDir, {
-        ...targetFields2,
-        targetCommit: targetCommit2,
-        diffHash: diffHash2,
-        model: config.model,
-        reasoning: config.reasoning.effort,
-        depth,
-        sessionId: "",
-        summary: "Documentation-only changes detected. No code review performed.",
-        diagnostics: [],
-        timings,
-        findings: [],
-        skippedReason: "documentation-only"
-      });
-      let reportPath2;
-      try {
-        reportPath2 = await writeMarkdownReport(skipContent);
-        await updatePersistedReview(diffOwlDir, persisted2.reviewId, {
-          reportPath: reportPath2
-        });
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        await updatePersistedReview(diffOwlDir, persisted2.reviewId, {
-          reportPath: null,
-          diagnostics: [`Report write failed: ${message}`]
-        });
-        throw err;
-      }
       if (jsonMode) {
         await emitReviewJsonSuccess({
           diffOwlDir,
-          reviewId: persisted2.reviewId,
-          persisted: persisted2,
+          reviewId: outcome.persisted.reviewId,
+          persisted: outcome.persisted,
           suppressed: { outsideChangedFiles: 0, belowConfidence: 0 },
           verbose,
-          timings
+          timings: outcome.timings
         });
       } else {
-        console.log(chalk4.dim(`Report saved: ${reportPath2}`));
+        console.log(chalk4.dim(`Report saved: ${outcome.reportPath}`));
       }
       if (options.hook) {
         await writeHookStatus(0, hookCommit);
       }
       process.exit(0);
     }
-    const contextStart = performance.now();
-    const reviewContext = await buildReviewContextFromDiff(snapshot, config, depth);
-    recordCliTiming(timings, "context-build", "Local review context build", contextStart);
-    const contextRenderStart = performance.now();
-    const localContext = renderReviewContext(reviewContext, { depth });
-    recordCliTiming(timings, "context-render", "Local review context render", contextRenderStart);
-    if (reviewContext.diagnostics.length > 0 && spinner) {
-      spinner.warn("Local review context built with warnings.");
-      for (const diagnostic of reviewContext.diagnostics) {
-        console.log(chalk4.yellow(`  - ${diagnostic}`));
-      }
-      console.log();
-      spinner.start("Connecting to OpenCode...");
-    }
-    if (spinner) {
-      spinner.text = "Connecting to OpenCode...";
-    }
-    const serverStart = performance.now();
-    await prepareReviewServer2(config);
-    recordCliTiming(timings, "server-ensure", "OpenCode server ensure", serverStart);
-    if (spinner) {
-      spinner.text = "Reviewing changes...";
+    if (outcome.kind !== "completed") {
+      process.exit(0);
     }
-    const reviewStart = performance.now();
-    const reviewResult = await runReview({
-      target,
-      directory: projectRoot,
-      config,
-      localContext,
-      depth,
-      signal: cancelController.signal,
-      onProgress: (event) => {
-        if (spinner) {
-          spinner.text = formatReviewProgress(event);
-        }
-      }
-    });
-    const report = reviewResult.report;
-    recordCliTiming(timings, "review-run", "OpenCode review run", reviewStart);
+    const report = outcome.report;
     spinner?.succeed("Review complete.");
     if (!jsonMode) {
       console.log();
     }
-    const diagnostics = report.diagnostics ?? [];
-    const confidenceFilter = filterFindingsByConfidence(report.findings, config.min_confidence);
-    report.findings = confidenceFilter.findings;
-    const changedFilesSet = /* @__PURE__ */ new Set();
-    for (const file of reviewContext.changedFiles) {
-      changedFilesSet.add(file.file.path);
-    }
-    const changedFileFilter = filterFindingsByChangedFiles(report.findings, changedFilesSet);
-    report.findings = changedFileFilter.findings;
-    if (changedFileFilter.suppressed.length > 0) {
-      if (verbose) {
-        report.suppressedFindings = changedFileFilter.suppressed;
-      }
-    }
-    if (confidenceFilter.dropped > 0 || changedFileFilter.suppressed.length > 0) {
-      diagnostics.push(
-        formatExcludedCandidateSummary(
-          confidenceFilter.dropped,
-          changedFileFilter.suppressed.length
-        )
-      );
-    }
-    if (diagnostics.length > 0) {
-      report.diagnostics = diagnostics;
-    }
-    const diffHash = computeDiffHash(diff.raw);
-    const targetFields = mapReviewTarget(target);
-    const targetCommit = await resolveTargetCommit(target);
-    const persistStart = performance.now();
-    const persisted = await persistReviewRun(diffOwlDir, {
-      ...targetFields,
-      targetCommit,
-      diffHash,
-      model: config.model,
-      reasoning: config.reasoning.effort,
-      depth,
-      sessionId: reviewResult.sessionId,
-      summary: report.summary,
-      diagnostics,
-      timings: [...timings, ...report.timings ?? []],
-      findings: report.findings
-    });
-    recordCliTiming(timings, "persist-state", "Persist review state", persistStart);
-    report.findings = persisted.actionableFindings;
-    const lifecycleSummary = formatLifecycleSuppressedSummary(
-      persisted.reconcile.suppressedCounts
-    );
-    if (lifecycleSummary) {
-      diagnostics.push(lifecycleSummary);
-      report.diagnostics = diagnostics;
-    }
-    if (verbose && persisted.lifecycleSuppressedFindings.length > 0) {
-      report.suppressedFindings = [
-        ...report.suppressedFindings ?? [],
-        ...persisted.lifecycleSuppressedFindings
-      ];
-    }
-    report.findings = enrichReviewFindingsWithDurableMetadata(
-      report.findings,
-      persisted.reconcile
-    );
-    if (report.suppressedFindings) {
-      report.suppressedFindings = enrichReviewFindingsWithDurableMetadata(
-        report.suppressedFindings,
-        persisted.reconcile
-      );
-    }
-    const renderStart = performance.now();
-    const markdown = renderMarkdown(report);
-    recordCliTiming(timings, "render-report", "Markdown render", renderStart);
-    const writeStart = performance.now();
-    let reportPath;
-    try {
-      reportPath = await writeMarkdownReport(markdown, {
-        schema_version: REPORT_SCHEMA_VERSION,
-        review_id: persisted.reviewId,
-        session_id: reviewResult.sessionId,
-        project_root: projectRoot
-      });
-      await updatePersistedReview(diffOwlDir, persisted.reviewId, {
-        reportPath,
-        diagnostics
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      diagnostics.push(`Report write failed: ${message}`);
-      report.diagnostics = diagnostics;
-      await updatePersistedReview(diffOwlDir, persisted.reviewId, {
-        reportPath: null,
-        diagnostics
-      });
-      throw err;
-    }
-    recordCliTiming(timings, "write-report", "Report write", writeStart);
-    recordCliTiming(timings, "total", "Total review command", totalStart);
+    const outputTimings = [
+      ...outcome.timings,
+      createCliTiming("total", "Total review command", totalStart)
+    ];
     if (jsonMode) {
       await emitReviewJsonSuccess({
         diffOwlDir,
-        reviewId: persisted.reviewId,
-        persisted,
-        suppressed: {
-          outsideChangedFiles: changedFileFilter.suppressed.length,
-          belowConfidence: confidenceFilter.dropped
-        },
+        reviewId: outcome.persisted.reviewId,
+        persisted: outcome.persisted,
+        suppressed: outcome.suppressed,
         verbose,
-        timings: [...timings, ...report.timings ?? []],
-        usage: reviewResult.usage ?? null
+        timings: outputTimings,
+        usage: outcome.usage
       });
     } else {
-      console.log(colorizeMarkdown(markdown));
-      printFooter(report, reportPath);
-      printTimingSummary([...timings, ...report.timings ?? []]);
+      printFooter(report, outcome.reportPath);
+      printTimingSummary(outputTimings);
     }
     if (options.hook) {
       await writeHookStatus(0, hookCommit);
@@ -7983,7 +8344,7 @@ program.command("chat").description("Open the OpenCode session for a review").ar
   const reportPath = report ? await resolveReviewReportPath(report) : await selectReviewInteractively();
   let content;
   try {
-    content = await readFile10(reportPath, "utf-8");
+    content = await readFile11(reportPath, "utf-8");
   } catch {
     console.error(chalk4.red(`Review report not found: ${reportPath}`));
     process.exit(1);
@@ -8104,8 +8465,8 @@ function resolveReasoningEffort(value, config) {
     process.exit(1);
   }
 }
-function recordCliTiming(timings, phase, label, start) {
-  timings.push({ phase, label, ms: performance.now() - start });
+function createCliTiming(phase, label, start) {
+  return { phase, label, ms: Math.max(0, Math.round(performance.now() - start)) };
 }
 function printTimingSummary(timings) {
   if (timings.length === 0) return;
@@ -8123,47 +8484,58 @@ function formatDuration2(ms) {
   if (ms < 1e3) return `${Math.round(ms)}ms`;
   return `${(ms / 1e3).toFixed(1)}s`;
 }
-async function prepareReviewServer2(config) {
-  if (config.server.auto_start) {
-    await ensureServer(config.server.port);
-    return;
-  }
-  if (await isServerRunning(config.server.port)) {
-    return;
-  }
-  throw new Error(
-    `OpenCode server is not running on port ${config.server.port}. Start it with \`diffowl server start\` or set server.auto_start: true.`
-  );
-}
 program.command("init").description("Set up DiffOwl for this project").action(async () => {
   await runInit();
 });
 async function runInit() {
   console.log(chalk4.bold("DiffOwl Setup\n"));
-  const config = await loadConfigOrExit();
+  const config = await loadProjectConfigOrExit();
   await selectModelInteractively(config, { allowKeepCurrent: false });
+  console.log(chalk4.green(`\u2713 Config saved to ${await saveConfig(config)}`));
 }
-program.command("model").description("View or change the AI model").argument("[model]", "Model to use (e.g., opencode/big-pickle)").action(async (model) => {
-  const config = await loadConfigOrExit();
-  if (!model) {
-    console.log(chalk4.bold("Current model: ") + chalk4.cyan(config.model));
-    await selectModelInteractively(config, { allowKeepCurrent: true });
+program.command("model").description("View or change the AI model").argument("[model]", "Model to use (e.g., opencode/big-pickle)").option("--reset", "Remove the shared local model preference").action(async (model, options) => {
+  if (model && options.reset) {
+    console.error(chalk4.red("Cannot pass a model and --reset together"));
+    process.exit(1);
+  }
+  if (options.reset) {
+    await resetModelPreference();
+    console.log(chalk4.green("\u2713 Local model preference reset"));
+    console.log(chalk4.dim("Run `diffowl model <provider/model>` to choose another."));
     return;
   }
-  let parsedModel;
+  if (model !== void 0) {
+    let parsedModel;
+    try {
+      parsedModel = parseModel(model);
+    } catch {
+      console.error(chalk4.red(`Invalid model: ${model}`));
+      console.error(chalk4.dim("Expected provider/model format, for example opencode/big-pickle"));
+      process.exit(1);
+    }
+    const configPath = await saveModelPreference(parsedModel);
+    console.log(chalk4.green(`\u2713 Model set to ${chalk4.cyan(parsedModel)}`));
+    console.log(chalk4.dim(`Local preference: ${configPath}`));
+    return;
+  }
+  let effective;
   try {
-    parsedModel = parseModel(model);
-  } catch {
-    console.error(chalk4.red(`Invalid model: ${model}`));
-    console.error(
-      chalk4.dim("Expected provider/model format, for example opencode/big-pickle")
-    );
-    process.exit(1);
+    effective = await loadEffectiveConfig();
+  } catch (err) {
+    if (!(err instanceof MissingModelError)) {
+      console.error(
+        chalk4.red(`Config error: ${err instanceof Error ? err.message : String(err)}`)
+      );
+      process.exit(1);
+    }
+    const config2 = await loadProjectConfigOrExit();
+    console.log(chalk4.yellow("No model selected."));
+    await selectModelInteractively(config2, { allowKeepCurrent: false });
+    return;
   }
-  config.model = parsedModel;
-  const configPath = await saveConfig(config);
-  console.log(chalk4.green(`\u2713 Model set to ${chalk4.cyan(parsedModel)}`));
-  console.log(chalk4.dim(`Config: ${configPath}`));
+  const config = effective.config;
+  console.log(formatEffectiveModel(config.model, effective.modelSource));
+  await selectModelInteractively(config, { allowKeepCurrent: true });
 });
 async function selectModelInteractively(config, options) {
   const spinner = ora2("Querying available models from OpenCode...").start();
@@ -8224,22 +8596,14 @@ async function selectModelInteractively(config, options) {
       rl.close();
     }
   } else {
-    console.log(chalk4.yellow("\nNo active/connected providers found in OpenCode."));
-    console.log(
-      chalk4.dim("Make sure you run ") + chalk4.cyan("opencode") + chalk4.dim(" to authenticate and set up your providers/keys first.")
-    );
-    console.log(chalk4.dim("Using fallback default model: ") + chalk4.cyan(config.model));
-    console.log();
+    console.error(chalk4.red("\nNo active/connected providers found in OpenCode."));
+    console.error(chalk4.dim("Run opencode to configure a provider, then retry."));
+    process.exit(1);
   }
   if (selectedModel !== config.model || !options.allowKeepCurrent) {
     config.model = selectedModel;
-    const configPath = await saveConfig(config);
-    if (options.allowKeepCurrent) {
-      console.log(chalk4.green(`\u2713 Model set to ${chalk4.cyan(selectedModel)}`));
-    } else {
-      console.log(chalk4.green(`\u2713 Config saved to ${configPath}`));
-      console.log(chalk4.dim(`Model set to: `) + chalk4.cyan(selectedModel));
-    }
+    await saveModelPreference(selectedModel);
+    console.log(chalk4.green(`\u2713 Model set to ${chalk4.cyan(selectedModel)}`));
     console.log();
   }
 }
@@ -8342,9 +8706,14 @@ serverCmd.command("status").description("Check if the OpenCode server is running
   }
 });
 var findingsCmd = program.command("findings").description("Inspect and manage durable findings");
-findingsCmd.command("list", { isDefault: true }).description("List unresolved findings").action(async () => {
+findingsCmd.command("list", { isDefault: true }).description("List unresolved findings").option("--format <format>", "Output format: text or json", "text").action(async (options) => {
   await loadConfigOrExit();
+  const format = resolveReviewOutputFormat(options.format);
   const items = await withFindingDatabase(await getSharedDiffOwlDir(), listUnresolvedFindings);
+  if (format === "json") {
+    process.stdout.write(renderFindingListJson(items));
+    return;
+  }
   if (items.length === 0) {
     console.log(chalk4.green("No unresolved findings."));
     return;
@@ -8456,34 +8825,29 @@ function collectValues(value, previous) {
   return [...previous, value];
 }
 async function loadConfigOrExit() {
+  return await loadProjectConfigOrExit();
+}
+async function loadEffectiveConfigOrExit(commandModel) {
   try {
-    return await loadConfig();
+    return await loadEffectiveConfig(commandModel);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(chalk4.red(`Config error: ${message}`));
     process.exit(1);
   }
 }
-function buildDocOnlySkipMarkdown(diff) {
-  const lines = [];
-  lines.push("### Summary");
-  lines.push("Documentation-only changes detected. No code review performed.");
-  lines.push("");
-  lines.push("### Changed Files");
-  for (const file of diff.files) {
-    lines.push(`- ${file.path} (+${file.additions}/-${file.deletions})`);
+async function loadProjectConfigOrExit() {
+  try {
+    return await loadConfig();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk4.red(`Config error: ${message}`));
+    process.exit(1);
   }
-  return lines.join("\n");
 }
-async function resolveTargetCommit(target) {
-  switch (target.kind) {
-    case "staged":
-      return null;
-    case "last-commit":
-      return resolveCommitRef("HEAD");
-    case "commit":
-      return resolveCommitRef(target.ref);
-  }
+function formatEffectiveModel(model, source) {
+  const label = source === "local" ? "local preference" : source;
+  return `${chalk4.bold("Current model: ")} ${chalk4.cyan(model)} ${chalk4.dim(`(${label})`)}`;
 }
 function handleReviewInterrupt(input) {
   input.cancelController.abort();