diffowl 0.2.1 → 0.3.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { Command } from "commander";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import ora from "ora";
 import { createInterface } from "readline/promises";
 
@@ -160,7 +160,9 @@ import { join as join2 } from "path";
 var HEALTH_TIMEOUT_MS = 2e3;
 var STARTUP_WAIT_MS = 3e3;
 var MAX_RETRIES = 10;
-async function isServerRunning(port) {
+var PORT_RELEASE_WAIT_MS = 5e3;
+var PORT_RELEASE_POLL_MS = 200;
+async function getServerHealth(port) {
   try {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
@@ -168,15 +170,48 @@ async function isServerRunning(port) {
       signal: controller.signal
     });
     clearTimeout(timeout);
-    return res.ok;
+    if (!res.ok) {
+      return null;
+    }
+    const body = await res.json();
+    const health = { healthy: body.healthy === true };
+    if (typeof body.version === "string") {
+      health.version = body.version;
+    }
+    return health;
   } catch {
-    return false;
+    return null;
+  }
+}
+async function getInstalledOpencodeVersion() {
+  try {
+    const { stdout } = await execa("opencode", ["--version"], { timeout: 5e3 });
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+      return null;
+    }
+    const match = trimmed.match(/(\d+\.\d+\.\d+(?:[-+][\w.-]+)?)/);
+    return match?.[1] ?? trimmed;
+  } catch {
+    return null;
   }
 }
+async function isServerRunning(port) {
+  const health = await getServerHealth(port);
+  return health?.healthy === true;
+}
 async function ensureServer(port) {
   const baseUrl = `http://127.0.0.1:${port}`;
-  if (await isServerRunning(port)) {
-    return baseUrl;
+  const health = await getServerHealth(port);
+  if (health?.healthy) {
+    const cliVersion = await getInstalledOpencodeVersion();
+    if (health.version && cliVersion && health.version !== cliVersion) {
+      if (!await stopServer(port)) {
+        throw new Error(`Could not locate or stop stale OpenCode server on port ${port}.`);
+      }
+    } else {
+      return baseUrl;
+    }
   }
   await spawnServer(port);
   for (let i = 0; i < MAX_RETRIES; i++) {
@@ -224,10 +259,33 @@ async function spawnServer(port) {
   }
   subprocess.unref();
 }
-async function stopServer() {
+async function stopServer(port) {
+  if (await stopManagedServer()) {
+    await waitUntilPortFree(port);
+    return true;
+  }
+  const listenerPid = await findOpencodeListenerPid(port);
+  if (listenerPid === null) {
+    return false;
+  }
+  if (!await isOpencodeProcess(listenerPid)) {
+    return false;
+  }
+  try {
+    process.kill(listenerPid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  await cleanupPidFile();
+  await waitUntilPortFree(port);
+  return true;
+}
+async function stopManagedServer() {
   const dir = getDiffOwlDir();
   const pidFile = join2(dir, "server.pid");
-  if (!existsSync2(pidFile)) return false;
+  if (!existsSync2(pidFile)) {
+    return false;
+  }
   let pid;
   try {
     pid = parseInt(await readFile2(pidFile, "utf-8"), 10);
@@ -256,46 +314,112 @@ async function stopServer() {
   }
   try {
     process.kill(pid, "SIGTERM");
-    await unlink(pidFile);
-    return true;
   } catch {
     return false;
   }
+  try {
+    await unlink(pidFile);
+  } catch {
+  }
+  return true;
+}
+async function cleanupPidFile() {
+  const pidFile = join2(getDiffOwlDir(), "server.pid");
+  if (!existsSync2(pidFile)) {
+    return;
+  }
+  try {
+    await unlink(pidFile);
+  } catch {
+  }
+}
+async function findOpencodeListenerPid(port) {
+  if (process.platform === "win32") {
+    return findOpencodeListenerPidWindows(port);
+  }
+  try {
+    const { stdout } = await execa("lsof", ["-tiTCP:" + String(port), "-sTCP:LISTEN"], {
+      timeout: 5e3
+    });
+    const pids = stdout.trim().split(/\s+/).map((value) => parseInt(value, 10)).filter((value) => Number.isInteger(value) && value > 0);
+    for (const pid of pids) {
+      if (await isOpencodeProcess(pid)) {
+        return pid;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function findOpencodeListenerPidWindows(port) {
+  try {
+    const { stdout } = await execa("netstat", ["-ano"], { timeout: 5e3 });
+    const portToken = `:${port}`;
+    const lines = stdout.split(/\r?\n/);
+    for (const line of lines) {
+      if (!line.includes("LISTENING") || !line.includes(portToken)) {
+        continue;
+      }
+      const parts = line.trim().split(/\s+/);
+      const pid = parseInt(parts[parts.length - 1] ?? "", 10);
+      if (!Number.isInteger(pid) || pid <= 0) {
+        continue;
+      }
+      if (await isOpencodeProcess(pid)) {
+        return pid;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function waitUntilPortFree(port) {
+  const deadline = Date.now() + PORT_RELEASE_WAIT_MS;
+  while (Date.now() < deadline) {
+    if (!await isServerRunning(port)) {
+      return;
+    }
+    await sleep(PORT_RELEASE_POLL_MS);
+  }
+  if (await isServerRunning(port)) {
+    throw new Error(
+      `OpenCode server on port ${port} did not stop within ${PORT_RELEASE_WAIT_MS}ms. Retry: diffowl server stop && diffowl server start`
+    );
+  }
 }
 async function isOpencodeProcess(pid) {
   const isWin = process.platform === "win32";
   try {
     if (isWin) {
       try {
-        const { stdout: stdout2 } = await execa("powershell", [
+        const { stdout: stdout3 } = await execa("powershell", [
           "-NoProfile",
           "-Command",
           `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' | Select-Object -ExpandProperty CommandLine`
         ]);
-        if (stdout2.toLowerCase().includes("opencode")) {
+        if (stdout3.toLowerCase().includes("opencode")) {
           return true;
         }
       } catch {
       }
       try {
-        const { stdout: stdout2 } = await execa("wmic", [
+        const { stdout: stdout3 } = await execa("wmic", [
           "process",
           "where",
           `ProcessId=${pid}`,
           "get",
           "CommandLine"
         ]);
-        if (stdout2.toLowerCase().includes("opencode")) {
+        if (stdout3.toLowerCase().includes("opencode")) {
           return true;
         }
       } catch {
       }
-      const { stdout } = await execa("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"]);
-      return stdout.toLowerCase().includes("opencode");
-    } else {
-      const { stdout } = await execa("ps", ["-p", String(pid), "-o", "command="]);
-      return stdout.toLowerCase().includes("opencode");
+      const { stdout: stdout2 } = await execa("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"]);
+      return stdout2.toLowerCase().includes("opencode");
     }
+    const { stdout } = await execa("ps", ["-p", String(pid), "-o", "command="]);
+    return stdout.toLowerCase().includes("opencode");
   } catch {
     return false;
   }
@@ -838,6 +962,27 @@ function parseProviderPayload(response) {
   return ProviderPayloadSchema.safeParse(response.data).data;
 }
 
+// src/opencode/quota.ts
+var QUOTA_PATTERNS = [
+  /\b429\b/,
+  /rate.?limit/,
+  /usage limit/,
+  /insufficient[_ -]?quota/,
+  /quota (exceeded|reached)/,
+  /(exceeded|reached) (your )?(current )?quota/,
+  /resource.?exhausted/,
+  /too many requests/,
+  /overloaded/,
+  /insufficient capacity/,
+  /billing[_ -]?(hard[_ -]?)?limit/,
+  /tokens per (min|day)/,
+  /requests per (min|day)/
+];
+function isQuotaOrRateLimitError(message) {
+  const normalized = message.toLowerCase();
+  return QUOTA_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+
 // src/opencode/models.ts
 import { createOpencodeClient } from "@opencode-ai/sdk";
 async function getAvailableModels(port, options = {}) {
@@ -861,6 +1006,12 @@ function listAvailableModels(payload) {
 }
 
 // src/opencode/client.ts
+var ReviewCancelledError = class extends Error {
+  name = "ReviewCancelledError";
+};
+function isReviewCancellation(error) {
+  return error instanceof ReviewCancelledError;
+}
 function normalizeOpenCodeEvent(event, expectedSessionId) {
   if (!event || typeof event !== "object") return void 0;
   const payload = event.payload;
@@ -950,7 +1101,10 @@ function normalizeAssistantMessage(info, expectedSessionId) {
   };
 }
 async function runReview(options) {
-  const { target, directory, config, localContext, depth, onProgress } = options;
+  const { target, directory, config, localContext, depth, onProgress, signal } = options;
+  if (signal?.aborted) {
+    throw new ReviewCancelledError("Review cancelled by user.");
+  }
   const port = config.server.port;
   const directoryOptions = opencodeDirectoryOptions(directory);
   const timings = [];
@@ -999,6 +1153,10 @@ async function runReview(options) {
   );
   let fullResponse = "";
   const eventsController = new AbortController();
+  const cancelReview = () => {
+    eventsController.abort();
+  };
+  signal?.addEventListener("abort", cancelReview, { once: true });
   const eventStart = performance.now();
   const sseResult = await withOpenCodeDiagnostics(
     "event-stream-connect",
@@ -1068,10 +1226,28 @@ async function runReview(options) {
                 settlement.acceptAssistantMessage({ text, error: normalized.error });
                 break;
               }
-              case "session-status":
-                const message = normalized.status === "retry" ? `OpenCode retrying: ${normalized.message ?? "unknown error"}` : `OpenCode session ${normalized.status}.`;
-                onProgress?.({ type: "session", message, sessionId });
+              case "session-status": {
+                if (normalized.status === "retry") {
+                  const retryMessage = normalized.message ?? "unknown error";
+                  onProgress?.({
+                    type: "session",
+                    message: `OpenCode retrying: ${retryMessage}`,
+                    sessionId
+                  });
+                  if (isQuotaOrRateLimitError(retryMessage)) {
+                    settlement.reject(
+                      new Error(`Provider quota or rate limit reached: ${retryMessage}`)
+                    );
+                  }
+                } else {
+                  onProgress?.({
+                    type: "session",
+                    message: `OpenCode session ${normalized.status}.`,
+                    sessionId
+                  });
+                }
                 break;
+              }
               case "session-idle":
                 if (fullResponse.length === 0) break;
                 onProgress?.({ type: "idle", message: "OpenCode session is idle." });
@@ -1084,48 +1260,57 @@ async function runReview(options) {
             settlement.finish();
           }
         } catch (streamErr) {
-          if (!settlement.isSettled() && !eventsController.signal.aborted) {
-            settlement.reject(
-              describeOpenCodeError(streamErr, "event-stream-read", { port, sessionId })
-            );
+          if (settlement.isSettled()) {
+            return;
+          }
+          if (eventsController.signal.aborted) {
+            settlement.reject(new ReviewCancelledError("Review cancelled by user."));
+            return;
           }
+          settlement.reject(
+            describeOpenCodeError(streamErr, "event-stream-read", { port, sessionId })
+          );
         }
       })();
     })
   );
-  onProgress?.({ type: "session", message: "Sending review prompt.", sessionId });
-  const promptSendStart = performance.now();
-  await withOpenCodeDiagnostics(
-    "prompt-send",
-    { port, sessionId },
-    () => client.session.promptAsync({
-      path: { id: sessionId },
-      ...directoryOptions,
-      body: {
-        system: REVIEW_AGENT_PROMPT,
-        model: { providerID, modelID },
-        tools,
-        ...reasoning.variant ? { variant: reasoning.variant } : {},
-        parts: [{ type: "text", text: prompt }]
-      }
-    })
-  );
-  recordTiming(timings, onProgress, "prompt-send", "OpenCode prompt request", promptSendStart);
-  const agentWaitStart = performance.now();
-  const raw = await withOpenCodeDiagnostics(
-    "agent-wait",
-    { port, sessionId },
-    () => responsePromise
-  );
-  recordTiming(timings, onProgress, "agent-wait", "OpenCode review generation", agentWaitStart);
-  const parseStart = performance.now();
-  const report = parseStructuredReview(raw);
-  recordTiming(timings, onProgress, "parse-review", "Review JSON parsing", parseStart);
-  const diagnostics = [...report.diagnostics ?? [], ...reasoning.diagnostics];
-  return {
-    report: { ...report, ...diagnostics.length > 0 ? { diagnostics } : {}, timings },
-    sessionId
-  };
+  try {
+    onProgress?.({ type: "session", message: "Sending review prompt.", sessionId });
+    const promptSendStart = performance.now();
+    await withOpenCodeDiagnostics(
+      "prompt-send",
+      { port, sessionId },
+      () => client.session.promptAsync({
+        path: { id: sessionId },
+        ...directoryOptions,
+        body: {
+          system: REVIEW_AGENT_PROMPT,
+          model: { providerID, modelID },
+          tools,
+          ...reasoning.variant ? { variant: reasoning.variant } : {},
+          parts: [{ type: "text", text: prompt }]
+        }
+      })
+    );
+    recordTiming(timings, onProgress, "prompt-send", "OpenCode prompt request", promptSendStart);
+    const agentWaitStart = performance.now();
+    const raw = await withOpenCodeDiagnostics(
+      "agent-wait",
+      { port, sessionId },
+      () => responsePromise
+    );
+    recordTiming(timings, onProgress, "agent-wait", "OpenCode review generation", agentWaitStart);
+    const parseStart = performance.now();
+    const report = parseStructuredReview(raw);
+    recordTiming(timings, onProgress, "parse-review", "Review JSON parsing", parseStart);
+    const diagnostics = [...report.diagnostics ?? [], ...reasoning.diagnostics];
+    return {
+      report: { ...report, ...diagnostics.length > 0 ? { diagnostics } : {}, timings },
+      sessionId
+    };
+  } finally {
+    signal?.removeEventListener("abort", cancelReview);
+  }
 }
 function extractSessionMessageResult(response) {
   if (!response || typeof response !== "object") return { kind: "empty" };
@@ -1320,9 +1505,30 @@ function getOpenCodeFailureGuidance(message) {
   if (normalized.includes("server is not running") || normalized.includes("failed to start opencode server") || normalized.includes("econnrefused") || normalized.includes("connection refused")) {
     return ["Start the managed server: diffowl server start", "Then retry the DiffOwl command."];
   }
+  if (isQuotaOrRateLimitError(normalized)) {
+    return [
+      "Provider quota or rate limit reached. Wait a few minutes and retry.",
+      "If persistent, check your provider dashboard for usage limits and billing.",
+      "You can also try a different model: diffowl review --model <model>"
+    ];
+  }
   if (normalized.includes("timed out") || normalized.includes("timeout")) {
     return ["Retry with less context: diffowl review --depth shallow"];
   }
+  if (normalized.includes("node_module_version") || normalized.includes("better-sqlite3") && normalized.includes("compiled against a different node.js version")) {
+    return [
+      "Native module ABI mismatch. Rebuild for your active Node: pnpm rebuild better-sqlite3",
+      "Reinstall the hook so it uses the same Node as the CLI: diffowl hook install",
+      "Compare the required NODE_MODULE_VERSION with the Hook Node ABI from `diffowl hook install`."
+    ];
+  }
+  if (normalized.includes("session_message.seq") || normalized.includes("not null constraint failed") && normalized.includes("seq")) {
+    return [
+      "OpenCode server version may be stale. Check: diffowl server status",
+      "Restart the server: diffowl server stop && diffowl server start",
+      "Confirm server and CLI versions match: opencode --version"
+    ];
+  }
   return [];
 }
 
@@ -1512,6 +1718,28 @@ Retry:
   diffowl review --commit ${failure.commit}
   diffowl review --commit ${failure.commit} --depth shallow`;
 }
+function isHookQueueStopFailure(message) {
+  if (!message || message === "Review started.") {
+    return false;
+  }
+  const normalized = message.toLowerCase();
+  if (isQuotaOrRateLimitError(normalized)) {
+    return true;
+  }
+  if (normalized.includes("unauthorized") || normalized.includes("authentication") || normalized.includes("invalid api key") || normalized.includes("missing api key") || /\b(401|403)\b/.test(normalized) || normalized.includes("no active provider") || normalized.includes("no connected provider") || normalized.includes("model not found") || normalized.includes("unknown model")) {
+    return true;
+  }
+  if (normalized.includes("server is not running") || normalized.includes("failed to start opencode server") || normalized.includes("econnrefused") || normalized.includes("connection refused")) {
+    return true;
+  }
+  if (normalized.includes("node_module_version") || normalized.includes("better-sqlite3") && normalized.includes("compiled against a different node.js version")) {
+    return true;
+  }
+  if (normalized.includes("opencode not found") || normalized.includes("opencode: command not found") || normalized.includes("enoent") && normalized.includes("opencode")) {
+    return true;
+  }
+  return false;
+}
 async function runHookReview() {
   const dir = await ensureDiffOwlDir();
   const logFile = join3(dir, "hook.log");
@@ -1536,7 +1764,7 @@ async function runHookReview() {
     const prefix = command.pathDirs?.join(":");
     const existingPath = process.env["PATH"] ?? "";
     const envPath = prefix ? `${prefix}:${existingPath}` : existingPath;
-    const subprocess = execa2(process.execPath, [fileURLToPath(import.meta.url), "hook-worker"], {
+    const subprocess = execa2(command.node, [fileURLToPath(import.meta.url), "hook-worker"], {
       detached: true,
       cleanup: false,
       cwd: process.cwd(),
@@ -1604,6 +1832,18 @@ async function runPendingHookReviews() {
     if (status?.exitCode !== 0 || status.message) {
       if (status && status.exitCode !== 0) {
         await writeHookStatus(status.exitCode, status.commit, status.message, null, dir);
+        if (isHookQueueStopFailure(status.message)) {
+          const remaining = (await listPendingReviews(dir)).filter((item) => item.sha !== next.sha);
+          if (remaining.length > 0) {
+            await appendFile(
+              logFile,
+              `diffowl: stopping hook queue after ${next.sha}; ${remaining.length} pending review(s) left for later (${status.message})
+`,
+              "utf-8"
+            );
+          }
+          return;
+        }
       }
       continue;
     }
@@ -1781,6 +2021,9 @@ function extractManagedSection(content) {
   if (ourEnd === -1) return void 0;
   return lines.slice(ourStart, ourEnd + 1).join("\n");
 }
+async function getHookCommand() {
+  return resolveHookCommand();
+}
 async function resolveHookCommand() {
   const diffowl = await resolveCommand("diffowl");
   const opencode = await resolveCommand("opencode");
@@ -1845,11 +2088,13 @@ function generateManagedSection(command) {
   const diffowlPathFallback = isPath ? `elif [ -x ${quotedDiffOwl} ]; then
   ${quotedDiffOwl} hook-run
 ` : "";
-  const runBlock = `if [ -x ${quotedNode} ] && [ -f ${quotedCli} ]; then
+  const nodeCliRun = `if [ -x ${quotedNode} ] && [ -f ${quotedCli} ]; then
   ${quotedNode} ${quotedCli} hook-run
-${diffowlPathFallback}elif command -v diffowl >/dev/null 2>&1; then
+`;
+  const commandRun = `elif command -v diffowl >/dev/null 2>&1; then
   diffowl hook-run
-else
+`;
+  const runBlock = `${nodeCliRun}${diffowlPathFallback}${commandRun}else
   echo "diffowl: review not started; diffowl command not found or not executable; log: $DIFFOWL_LOG_FILE"
   echo "diffowl: review not started at $(date); diffowl command not found or not executable" >>"$DIFFOWL_LOG_FILE"
 fi`;
@@ -3095,6 +3340,21 @@ import { writeFile as writeFile5, mkdir as mkdir3 } from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
 import { join as join7 } from "path";
 import { parse as parse2, stringify as stringify2 } from "yaml";
+var REPORT_SCHEMA_VERSION = 1;
+function formatFindingHeading(index, finding) {
+  const ordinal = `Finding ${index + 1}`;
+  if (!finding.durable) {
+    return `#### ${ordinal}`;
+  }
+  const classification = formatFindingClassification(finding.durable);
+  return `#### ${ordinal} (\`${finding.durable.id}\`) \u2014 ${classification}`;
+}
+function formatFindingClassification(durable) {
+  if (durable.lifecycleSuppressed) {
+    return `**suppressed (${durable.status})**`;
+  }
+  return `**${durable.classification}**`;
+}
 function renderMarkdown(report) {
   const lines = [];
   lines.push("### Summary");
@@ -3105,7 +3365,7 @@ function renderMarkdown(report) {
     lines.push("No issues were reported.");
   } else {
     for (const [index, finding] of report.findings.entries()) {
-      lines.push(`#### Finding ${index + 1}`);
+      lines.push(formatFindingHeading(index, finding));
       lines.push(`**[${finding.severity.toUpperCase()}] ${finding.file}:${finding.line}**`);
       lines.push(finding.title.trim());
       lines.push("");
@@ -3120,10 +3380,10 @@ function renderMarkdown(report) {
   if (report.suppressedFindings && report.suppressedFindings.length > 0) {
     lines.push("");
     lines.push("### Suppressed Findings");
-    lines.push("These findings are outside files changed in this diff.");
+    lines.push("These findings were excluded from the actionable review set.");
     lines.push("");
     for (const [index, finding] of report.suppressedFindings.entries()) {
-      lines.push(`#### Finding ${report.findings.length + index + 1}`);
+      lines.push(formatFindingHeading(report.findings.length + index, finding));
       lines.push(
         `**[${finding.severity.toUpperCase()}] ${finding.file}:${finding.line}** (${finding.confidence} confidence)`
       );
@@ -3177,10 +3437,22 @@ function parseReviewMetadata(content) {
   if (!diffowl || typeof diffowl !== "object") return void 0;
   const sessionId = diffowl.session_id;
   const projectRoot = diffowl.project_root;
+  const schemaVersion = diffowl.schema_version;
+  const reviewId = diffowl.review_id;
   if (typeof sessionId !== "string" || sessionId.trim() === "" || typeof projectRoot !== "string" || projectRoot.trim() === "") {
     return void 0;
   }
-  return { session_id: sessionId, project_root: projectRoot };
+  const metadata = {
+    session_id: sessionId,
+    project_root: projectRoot
+  };
+  if (typeof schemaVersion === "number" && Number.isInteger(schemaVersion) && schemaVersion > 0) {
+    metadata.schema_version = schemaVersion;
+  }
+  if (typeof reviewId === "string" && reviewId.trim() !== "") {
+    metadata.review_id = reviewId;
+  }
+  return metadata;
 }
 function renderReviewFrontmatter(metadata) {
   return `---
@@ -3331,107 +3603,1628 @@ async function listMarkdownFiles(dir) {
   return reports.filter((path) => path !== void 0);
 }
 
-// src/cli.ts
-import { readFile as readFile7 } from "fs/promises";
-import { basename as basename5, dirname as dirname4 } from "path";
-import { execa as execa5 } from "execa";
+// src/state/persist.ts
+import { createHash as createHash2 } from "crypto";
 
-// package.json
-var package_default = {
-  name: "diffowl",
-  version: "0.2.1",
-  description: "Local AI code review agent powered by OpenCode",
-  keywords: [
-    "ai",
-    "code-review",
-    "git",
-    "opencode",
-    "pre-commit"
-  ],
-  homepage: "https://github.com/gutierrezje/diffowl#readme",
-  bugs: {
-    url: "https://github.com/gutierrezje/diffowl/issues"
-  },
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/gutierrezje/diffowl.git"
-  },
-  bin: {
-    diffowl: "dist/cli.js"
-  },
-  files: [
-    "dist"
-  ],
-  type: "module",
-  scripts: {
-    build: "tsup",
-    dev: "tsup --watch",
-    test: "vitest run",
-    typecheck: "tsc --noEmit",
-    lint: "oxlint . && pnpm run typecheck",
-    format: "oxfmt --write .",
-    "format:check": "oxfmt --check .",
-    prepack: "npm run build"
-  },
-  dependencies: {
-    "@opencode-ai/sdk": "^1.15.11",
-    chalk: "^5.6.2",
-    commander: "^14.0.3",
-    execa: "^9.6.1",
-    ora: "^9.4.0",
-    picomatch: "^4.0.4",
-    yaml: "^2.9.0",
-    zod: "^4.4.3"
-  },
-  devDependencies: {
-    "@types/node": "^25.9.1",
-    "@types/picomatch": "^4.0.3",
-    oxfmt: "^0.52.0",
-    oxlint: "^1.67.0",
-    tsup: "^8.5.1",
-    typescript: "^6.0.3",
-    vitest: "^4.1.7"
-  },
-  engines: {
-    node: ">=20"
-  },
-  packageManager: "pnpm@10.15.1"
-};
+// src/state/db.ts
+import { mkdir as mkdir4 } from "fs/promises";
+import { join as join9 } from "path";
+import Database from "better-sqlite3";
 
-// 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(
-  "--reasoning <effort>",
-  "Reasoning variant: auto, none, minimal, low, medium, high, max, or xhigh"
-).option("--verbose", "Include suppressed findings and extra review details").action(async (options) => {
-  const hookCommit = options.hook && options.commit ? String(options.commit) : void 0;
-  const hookLock = options.hook ? process.env["DIFFOWL_HOOK_LOCK"] : void 0;
-  if (hookLock) {
-    process.once("exit", () => releaseHookReviewLock(hookLock));
+// src/state/migrations/001-initial-schema.ts
+var MIGRATION_001_INITIAL_SCHEMA = `
+CREATE TABLE schema_migrations (
+  version INTEGER PRIMARY KEY,
+  applied_at TEXT NOT NULL
+);
+
+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')),
+  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
+);
+
+CREATE TABLE findings (
+  id TEXT PRIMARY KEY,
+  fingerprint TEXT NOT NULL UNIQUE,
+  status TEXT NOT NULL CHECK (status IN ('open', 'deferred', 'dismissed', 'fixed', 'regressed')),
+  first_review_id TEXT NOT NULL REFERENCES reviews(id),
+  last_review_id TEXT NOT NULL REFERENCES reviews(id),
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_findings_status ON findings(status);
+
+CREATE TABLE finding_observations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  review_id TEXT NOT NULL REFERENCES reviews(id),
+  finding_id TEXT NOT NULL REFERENCES findings(id),
+  file TEXT NOT NULL,
+  line INTEGER NOT NULL,
+  severity TEXT NOT NULL CHECK (severity IN ('error', 'warning', 'info')),
+  confidence TEXT NOT NULL CHECK (confidence IN ('low', 'medium', 'high')),
+  title TEXT NOT NULL,
+  body TEXT NOT NULL,
+  evidence TEXT,
+  ordinal INTEGER NOT NULL,
+  classification TEXT NOT NULL CHECK (classification IN ('new', 'existing', 'regressed')),
+  UNIQUE (review_id, finding_id)
+);
+
+CREATE TABLE finding_events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  finding_id TEXT NOT NULL REFERENCES findings(id),
+  review_id TEXT REFERENCES reviews(id),
+  event_type TEXT NOT NULL CHECK (
+    event_type IN ('observed', 'dismissed', 'deferred', 'fixed', 'reopened', 'regressed')
+  ),
+  actor TEXT NOT NULL CHECK (actor IN ('user', 'agent')),
+  reason TEXT,
+  commit_ref TEXT,
+  verification_json TEXT,
+  created_at TEXT NOT NULL
+);
+
+CREATE INDEX idx_finding_events_finding_id ON finding_events(finding_id);
+`;
+
+// src/state/types.ts
+import { randomUUID } from "crypto";
+var CURRENT_SCHEMA_VERSION = 1;
+function createReviewId() {
+  return `rev_${randomUUID()}`;
+}
+function createFindingId() {
+  return `fnd_${randomUUID()}`;
+}
+
+// src/state/db.ts
+var BUSY_TIMEOUT_MS = 5e3;
+var MIGRATIONS = {
+  1: MIGRATION_001_INITIAL_SCHEMA
+};
+var StateDatabaseError = class extends Error {
+  name = "StateDatabaseError";
+};
+var InvalidFindingTransitionError = class extends StateDatabaseError {
+  name = "InvalidFindingTransitionError";
+};
+function getStateDbPath(diffOwlDir) {
+  return join9(diffOwlDir, "state.db");
+}
+async function openStateDatabase(diffOwlDir) {
+  await mkdir4(diffOwlDir, { recursive: true });
+  const path = getStateDbPath(diffOwlDir);
+  const db = new Database(path);
+  try {
+    configureDatabase(db);
+    assertCompatibleSchema(db);
+    applyMigrations(db, CURRENT_SCHEMA_VERSION);
+    return { db, path };
+  } catch (error) {
+    try {
+      closeDatabaseConnection(db);
+    } catch {
+    }
+    throw error;
   }
-  if (options.hook) {
-    await writeHookStatus(0, hookCommit, "Review started.");
+}
+function closeDatabaseConnection(db) {
+  if (!db.open) {
+    return;
   }
-  const totalStart = performance.now();
-  const timings = [];
+  try {
+    db.pragma("wal_checkpoint(TRUNCATE)");
+  } finally {
+    db.close();
+  }
+}
+function closeStateDatabase(state) {
+  closeDatabaseConnection(state.db);
+}
+function configureDatabase(db) {
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.pragma(`busy_timeout = ${BUSY_TIMEOUT_MS}`);
+}
+function assertCompatibleSchema(db) {
+  const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'schema_migrations'").get();
+  if (!table) {
+    return;
+  }
+  const row = db.prepare("SELECT MAX(version) AS maxVersion FROM schema_migrations").get();
+  const maxVersion = row?.maxVersion ?? 0;
+  if (maxVersion > CURRENT_SCHEMA_VERSION) {
+    throw new StateDatabaseError(
+      `Database schema version ${maxVersion} is newer than supported version ${CURRENT_SCHEMA_VERSION}`
+    );
+  }
+}
+function applyMigrations(db, targetVersion, migrations = MIGRATIONS) {
+  assertCompatibleSchema(db);
+  const appliedVersions = listAppliedMigrationVersions(db);
+  for (let version = 1; version <= targetVersion; version++) {
+    if (appliedVersions.includes(version)) {
+      continue;
+    }
+    const sql = migrations[version];
+    if (!sql) {
+      throw new StateDatabaseError(`Missing migration for schema version ${version}`);
+    }
+    const migrate = db.transaction(() => {
+      db.exec(sql);
+      db.prepare("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)").run(
+        version,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    });
+    migrate();
+  }
+}
+function listAppliedMigrationVersions(db) {
+  const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'schema_migrations'").get();
+  if (!table) {
+    return [];
+  }
+  const rows = db.prepare("SELECT version FROM schema_migrations ORDER BY version ASC").all();
+  return rows.map((row) => row.version);
+}
+function runInTransaction(db, fn) {
+  const transaction = db.transaction(fn);
+  return transaction();
+}
+
+// src/state/fingerprint.ts
+import { createHash } from "crypto";
+var FINGERPRINT_VERSION = 1;
+function normalizeFingerprintText(text) {
+  return text.normalize("NFKC").toLowerCase().trim().replace(/\s+/g, " ");
+}
+function computeFindingFingerprint(input) {
+  const file = normalizeFingerprintText(input.file);
+  const title = normalizeFingerprintText(input.title);
+  const identitySource = input.evidence?.trim() ? input.evidence : input.body;
+  const identity = normalizeFingerprintText(identitySource);
+  const payload = `v${FINGERPRINT_VERSION}|${file}|${title}|${identity}`;
+  const digest = createHash("sha256").update(payload, "utf8").digest("hex");
+  return `v${FINGERPRINT_VERSION}:${digest}`;
+}
+function deduplicateFindingCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const candidate of candidates) {
+    const fingerprint = computeFindingFingerprint(candidate);
+    if (seen.has(fingerprint)) {
+      continue;
+    }
+    seen.add(fingerprint);
+    deduped.push(candidate);
+  }
+  return deduped;
+}
+
+// src/state/repositories/events.ts
+var insertEventStatement = (db) => db.prepare(`
+    INSERT INTO finding_events (
+      finding_id,
+      review_id,
+      event_type,
+      actor,
+      reason,
+      commit_ref,
+      verification_json,
+      created_at
+    ) VALUES (
+      @findingId,
+      @reviewId,
+      @eventType,
+      @actor,
+      @reason,
+      @commitRef,
+      @verificationJson,
+      @createdAt
+    )
+  `);
+var getEventStatement = (db) => db.prepare(`
+    SELECT
+      id,
+      finding_id AS findingId,
+      review_id AS reviewId,
+      event_type AS eventType,
+      actor,
+      reason,
+      commit_ref AS commitRef,
+      verification_json AS verificationJson,
+      created_at AS createdAt
+    FROM finding_events
+    WHERE id = ?
+  `);
+function insertFindingEvent(db, input) {
+  const createdAt = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const result = insertEventStatement(db).run({
+    findingId: input.findingId,
+    reviewId: input.reviewId ?? null,
+    eventType: input.eventType,
+    actor: input.actor,
+    reason: input.reason ?? null,
+    commitRef: input.commitRef ?? null,
+    verificationJson: JSON.stringify(input.verification ?? []),
+    createdAt
+  });
+  const row = getEventStatement(db).get(Number(result.lastInsertRowid));
+  if (!row) {
+    throw new Error(`Failed to load finding event ${String(result.lastInsertRowid)}.`);
+  }
+  return mapEventRow(row);
+}
+function listFindingEvents(db, findingId) {
+  const rows = db.prepare(`
+      SELECT
+        id,
+        finding_id AS findingId,
+        review_id AS reviewId,
+        event_type AS eventType,
+        actor,
+        reason,
+        commit_ref AS commitRef,
+        verification_json AS verificationJson,
+        created_at AS createdAt
+      FROM finding_events
+      WHERE finding_id = ?
+      ORDER BY id ASC
+    `).all(findingId);
+  return rows.map(mapEventRow);
+}
+function mapEventRow(row) {
+  return {
+    id: row.id,
+    findingId: row.findingId,
+    reviewId: row.reviewId,
+    eventType: row.eventType,
+    actor: row.actor,
+    reason: row.reason,
+    commitRef: row.commitRef,
+    verification: JSON.parse(row.verificationJson),
+    createdAt: row.createdAt
+  };
+}
+
+// src/state/repositories/findings.ts
+var insertFindingStatement = (db) => db.prepare(`
+    INSERT INTO findings (
+      id,
+      fingerprint,
+      status,
+      first_review_id,
+      last_review_id,
+      created_at,
+      updated_at
+    ) VALUES (
+      @id,
+      @fingerprint,
+      @status,
+      @firstReviewId,
+      @lastReviewId,
+      @createdAt,
+      @updatedAt
+    )
+  `);
+var getFindingByIdStatement = (db) => db.prepare(`
+    SELECT
+      id,
+      fingerprint,
+      status,
+      first_review_id AS firstReviewId,
+      last_review_id AS lastReviewId,
+      created_at AS createdAt,
+      updated_at AS updatedAt
+    FROM findings
+    WHERE id = ?
+  `);
+var getFindingByFingerprintStatement = (db) => db.prepare(`
+    SELECT
+      id,
+      fingerprint,
+      status,
+      first_review_id AS firstReviewId,
+      last_review_id AS lastReviewId,
+      created_at AS createdAt,
+      updated_at AS updatedAt
+    FROM findings
+    WHERE fingerprint = ?
+  `);
+function insertFinding(db, input) {
+  const timestamp = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const record = {
+    id: input.id ?? createFindingId(),
+    fingerprint: input.fingerprint,
+    status: input.status,
+    firstReviewId: input.firstReviewId,
+    lastReviewId: input.lastReviewId,
+    createdAt: timestamp,
+    updatedAt: input.updatedAt ?? timestamp
+  };
+  insertFindingStatement(db).run({
+    id: record.id,
+    fingerprint: record.fingerprint,
+    status: record.status,
+    firstReviewId: record.firstReviewId,
+    lastReviewId: record.lastReviewId,
+    createdAt: record.createdAt,
+    updatedAt: record.updatedAt
+  });
+  return record;
+}
+function getFindingById(db, id) {
+  const row = getFindingByIdStatement(db).get(id);
+  return row;
+}
+function getFindingByFingerprint(db, fingerprint) {
+  const row = getFindingByFingerprintStatement(db).get(fingerprint);
+  return row;
+}
+function listFindingsByStatuses(db, statuses) {
+  if (statuses.length === 0) {
+    return [];
+  }
+  const placeholders = statuses.map(() => "?").join(", ");
+  return db.prepare(`
+      SELECT
+        id,
+        fingerprint,
+        status,
+        first_review_id AS firstReviewId,
+        last_review_id AS lastReviewId,
+        created_at AS createdAt,
+        updated_at AS updatedAt
+      FROM findings
+      WHERE status IN (${placeholders})
+      ORDER BY updated_at DESC, id ASC
+    `).all(...statuses);
+}
+function listAllFindings(db) {
+  return db.prepare(`
+      SELECT
+        id,
+        fingerprint,
+        status,
+        first_review_id AS firstReviewId,
+        last_review_id AS lastReviewId,
+        created_at AS createdAt,
+        updated_at AS updatedAt
+      FROM findings
+      ORDER BY updated_at DESC, id ASC
+    `).all();
+}
+var updateFindingStatement = (db) => db.prepare(`
+    UPDATE findings
+    SET
+      status = @status,
+      last_review_id = @lastReviewId,
+      updated_at = @updatedAt
+    WHERE id = @id
+  `);
+function updateFinding(db, id, updates) {
+  const existing = getFindingById(db, id);
+  if (!existing) {
+    throw new StateDatabaseError(`Finding ${id} was not found.`);
+  }
+  const updatedAt = updates.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  updateFindingStatement(db).run({
+    id,
+    status: updates.status,
+    lastReviewId: updates.lastReviewId,
+    updatedAt
+  });
+  return {
+    ...existing,
+    status: updates.status,
+    lastReviewId: updates.lastReviewId,
+    updatedAt
+  };
+}
+
+// src/state/repositories/observations.ts
+var insertObservationStatement = (db) => db.prepare(`
+    INSERT INTO finding_observations (
+      review_id,
+      finding_id,
+      file,
+      line,
+      severity,
+      confidence,
+      title,
+      body,
+      evidence,
+      ordinal,
+      classification
+    ) VALUES (
+      @reviewId,
+      @findingId,
+      @file,
+      @line,
+      @severity,
+      @confidence,
+      @title,
+      @body,
+      @evidence,
+      @ordinal,
+      @classification
+    )
+  `);
+var getObservationStatement = (db) => db.prepare(`
+    SELECT
+      id,
+      review_id AS reviewId,
+      finding_id AS findingId,
+      file,
+      line,
+      severity,
+      confidence,
+      title,
+      body,
+      evidence,
+      ordinal,
+      classification
+    FROM finding_observations
+    WHERE review_id = ? AND finding_id = ?
+  `);
+function insertObservation(db, input) {
+  insertObservationStatement(db).run({
+    reviewId: input.reviewId,
+    findingId: input.findingId,
+    file: input.file,
+    line: input.line,
+    severity: input.severity,
+    confidence: input.confidence,
+    title: input.title,
+    body: input.body,
+    evidence: input.evidence ?? null,
+    ordinal: input.ordinal,
+    classification: input.classification
+  });
+  const observation = getObservationStatement(db).get(input.reviewId, input.findingId);
+  if (!observation) {
+    throw new Error(`Failed to load observation for review ${input.reviewId}.`);
+  }
+  return observation;
+}
+function listObservationsForReview(db, reviewId) {
+  return db.prepare(`
+      SELECT
+        id,
+        review_id AS reviewId,
+        finding_id AS findingId,
+        file,
+        line,
+        severity,
+        confidence,
+        title,
+        body,
+        evidence,
+        ordinal,
+        classification
+      FROM finding_observations
+      WHERE review_id = ?
+      ORDER BY ordinal ASC
+    `).all(reviewId);
+}
+function countObservationsByFindingIds(db, findingIds) {
+  const counts = /* @__PURE__ */ new Map();
+  if (findingIds.length === 0) {
+    return counts;
+  }
+  const placeholders = findingIds.map(() => "?").join(", ");
+  const rows = db.prepare(`
+      SELECT finding_id AS findingId, COUNT(*) AS count
+      FROM finding_observations
+      WHERE finding_id IN (${placeholders})
+      GROUP BY finding_id
+    `).all(...findingIds);
+  for (const row of rows) {
+    counts.set(row.findingId, row.count);
+  }
+  return counts;
+}
+function getLatestObservationForFinding(db, findingId) {
+  return db.prepare(`
+      SELECT
+        id,
+        review_id AS reviewId,
+        finding_id AS findingId,
+        file,
+        line,
+        severity,
+        confidence,
+        title,
+        body,
+        evidence,
+        ordinal,
+        classification
+      FROM finding_observations
+      WHERE finding_id = ?
+      ORDER BY id DESC
+      LIMIT 1
+    `).get(findingId);
+}
+
+// src/state/reconcile.ts
+function reconcileReviewFindings(db, reviewId, candidates) {
+  const observations = [];
+  const suppressedCounts = { dismissed: 0, deferred: 0 };
+  const uniqueCandidates = deduplicateFindingCandidates(candidates);
+  for (const [index, candidate] of uniqueCandidates.entries()) {
+    const fingerprint = computeFindingFingerprint(candidate);
+    const existing = getFindingByFingerprint(db, fingerprint);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    let finding = existing;
+    let classification;
+    let suppressed = false;
+    if (!finding) {
+      finding = insertFinding(db, {
+        fingerprint,
+        status: "open",
+        firstReviewId: reviewId,
+        lastReviewId: reviewId,
+        createdAt: timestamp,
+        updatedAt: timestamp
+      });
+      classification = "new";
+    } else if (finding.status === "open" || finding.status === "regressed") {
+      finding = updateFinding(db, finding.id, {
+        status: finding.status,
+        lastReviewId: reviewId,
+        updatedAt: timestamp
+      });
+      classification = "existing";
+    } else if (finding.status === "deferred" || finding.status === "dismissed") {
+      finding = updateFinding(db, finding.id, {
+        status: finding.status,
+        lastReviewId: reviewId,
+        updatedAt: timestamp
+      });
+      classification = "existing";
+      suppressed = true;
+      if (finding.status === "dismissed") {
+        suppressedCounts.dismissed++;
+      } else {
+        suppressedCounts.deferred++;
+      }
+    } else {
+      finding = updateFinding(db, finding.id, {
+        status: "regressed",
+        lastReviewId: reviewId,
+        updatedAt: timestamp
+      });
+      classification = "regressed";
+      insertFindingEvent(db, {
+        findingId: finding.id,
+        reviewId,
+        eventType: "regressed",
+        actor: "agent",
+        reason: "Finding reappeared after being marked fixed."
+      });
+    }
+    insertFindingEvent(db, {
+      findingId: finding.id,
+      reviewId,
+      eventType: "observed",
+      actor: "agent"
+    });
+    const observation = insertObservation(db, {
+      reviewId,
+      findingId: finding.id,
+      file: candidate.file,
+      line: candidate.line,
+      severity: candidate.severity,
+      confidence: candidate.confidence,
+      title: candidate.title,
+      body: candidate.body,
+      evidence: candidate.evidence ?? null,
+      ordinal: index + 1,
+      classification
+    });
+    observations.push({
+      observation,
+      finding,
+      fingerprint,
+      suppressed
+    });
+  }
+  return { observations, suppressedCounts };
+}
+
+// src/state/repositories/reviews.ts
+var insertReviewStatement = (db) => db.prepare(`
+    INSERT INTO reviews (
+      id,
+      created_at,
+      target_kind,
+      target_ref,
+      target_commit,
+      diff_hash,
+      model,
+      reasoning,
+      depth,
+      session_id,
+      summary,
+      report_path,
+      diagnostics_json,
+      timings_json,
+      skipped_reason
+    ) VALUES (
+      @id,
+      @createdAt,
+      @targetKind,
+      @targetRef,
+      @targetCommit,
+      @diffHash,
+      @model,
+      @reasoning,
+      @depth,
+      @sessionId,
+      @summary,
+      @reportPath,
+      @diagnosticsJson,
+      @timingsJson,
+      @skippedReason
+    )
+  `);
+var getReviewByIdStatement = (db) => db.prepare(`
+    SELECT
+      id,
+      created_at AS createdAt,
+      target_kind AS targetKind,
+      target_ref AS targetRef,
+      target_commit AS targetCommit,
+      diff_hash AS diffHash,
+      model,
+      reasoning,
+      depth,
+      session_id AS sessionId,
+      summary,
+      report_path AS reportPath,
+      diagnostics_json AS diagnosticsJson,
+      timings_json AS timingsJson,
+      skipped_reason AS skippedReason
+    FROM reviews
+    WHERE id = ?
+  `);
+function insertReview(db, input) {
+  const record = {
+    id: input.id ?? createReviewId(),
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    targetKind: input.targetKind,
+    targetRef: input.targetRef ?? null,
+    targetCommit: input.targetCommit ?? null,
+    diffHash: input.diffHash,
+    model: input.model,
+    reasoning: input.reasoning,
+    depth: input.depth,
+    sessionId: input.sessionId,
+    summary: input.summary,
+    reportPath: input.reportPath ?? null,
+    diagnostics: input.diagnostics ?? [],
+    timings: input.timings ?? [],
+    skippedReason: input.skippedReason ?? null
+  };
+  insertReviewStatement(db).run({
+    id: record.id,
+    createdAt: record.createdAt,
+    targetKind: record.targetKind,
+    targetRef: record.targetRef,
+    targetCommit: record.targetCommit,
+    diffHash: record.diffHash,
+    model: record.model,
+    reasoning: record.reasoning,
+    depth: record.depth,
+    sessionId: record.sessionId,
+    summary: record.summary,
+    reportPath: record.reportPath,
+    diagnosticsJson: JSON.stringify(record.diagnostics),
+    timingsJson: JSON.stringify(record.timings),
+    skippedReason: record.skippedReason
+  });
+  return record;
+}
+function getReviewById(db, id) {
+  const row = getReviewByIdStatement(db).get(id);
+  if (!row) {
+    return void 0;
+  }
+  return mapReviewRow(row);
+}
+function getLatestReview(db) {
+  const row = db.prepare(`
+      SELECT
+        id,
+        created_at AS createdAt,
+        target_kind AS targetKind,
+        target_ref AS targetRef,
+        target_commit AS targetCommit,
+        diff_hash AS diffHash,
+        model,
+        reasoning,
+        depth,
+        session_id AS sessionId,
+        summary,
+        report_path AS reportPath,
+        diagnostics_json AS diagnosticsJson,
+        timings_json AS timingsJson,
+        skipped_reason AS skippedReason
+      FROM reviews
+      ORDER BY created_at DESC, id DESC
+      LIMIT 1
+    `).get();
+  if (!row) {
+    return void 0;
+  }
+  return mapReviewRow(row);
+}
+function updateReview(db, id, input) {
+  const existing = getReviewById(db, id);
+  if (!existing) {
+    throw new StateDatabaseError(`Review ${id} was not found.`);
+  }
+  const record = {
+    ...existing,
+    reportPath: input.reportPath === void 0 ? existing.reportPath : input.reportPath,
+    diagnostics: input.diagnostics ?? existing.diagnostics
+  };
+  db.prepare(`
+    UPDATE reviews
+    SET report_path = @reportPath,
+        diagnostics_json = @diagnosticsJson
+    WHERE id = @id
+  `).run({
+    id: record.id,
+    reportPath: record.reportPath,
+    diagnosticsJson: JSON.stringify(record.diagnostics)
+  });
+  return record;
+}
+function mapReviewRow(row) {
+  return {
+    id: row.id,
+    createdAt: row.createdAt,
+    targetKind: row.targetKind,
+    targetRef: row.targetRef,
+    targetCommit: row.targetCommit,
+    diffHash: row.diffHash,
+    model: row.model,
+    reasoning: row.reasoning,
+    depth: row.depth,
+    sessionId: row.sessionId,
+    summary: row.summary,
+    reportPath: row.reportPath,
+    diagnostics: parseReviewJsonField(row.diagnosticsJson, "diagnostics_json", row.id),
+    timings: parseReviewJsonField(row.timingsJson, "timings_json", row.id),
+    skippedReason: row.skippedReason
+  };
+}
+function parseReviewJsonField(raw, field, reviewId) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new StateDatabaseError(`Review ${reviewId} contains invalid JSON in ${field}.`);
+  }
+}
+
+// src/state/persist.ts
+function computeDiffHash(raw) {
+  return createHash2("sha256").update(raw, "utf8").digest("hex");
+}
+function deduplicateReviewFindings(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const finding of findings) {
+    const fingerprint = computeFindingFingerprint(toFindingCandidate(finding));
+    if (seen.has(fingerprint)) {
+      continue;
+    }
+    seen.add(fingerprint);
+    deduped.push(finding);
+  }
+  return deduped;
+}
+function toFindingCandidate(finding) {
+  const candidate = {
+    file: finding.file,
+    line: finding.line,
+    severity: finding.severity,
+    confidence: finding.confidence,
+    title: finding.title,
+    body: finding.body
+  };
+  if (finding.evidence !== void 0) {
+    candidate.evidence = finding.evidence;
+  }
+  return candidate;
+}
+function formatLifecycleSuppressedSummary(counts) {
+  const parts = [];
+  if (counts.dismissed > 0) {
+    parts.push(`${counts.dismissed} dismissed`);
+  }
+  if (counts.deferred > 0) {
+    parts.push(`${counts.deferred} deferred`);
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return `Suppressed ${parts.join(" and ")} previously resolved finding(s).`;
+}
+function splitFindingsByLifecycleSuppression(findings, reconcile) {
+  const fingerprintedFindings = fingerprintUniqueReviewFindings(findings);
+  const findingsByFingerprint = /* @__PURE__ */ new Map();
+  for (const { finding, fingerprint } of fingerprintedFindings) {
+    findingsByFingerprint.set(fingerprint, finding);
+  }
+  const actionableFindings = [];
+  const lifecycleSuppressedFindings = [];
+  const matchedFingerprints = /* @__PURE__ */ new Set();
+  for (const observation of reconcile.observations) {
+    const finding = findingsByFingerprint.get(observation.fingerprint);
+    if (!finding) {
+      continue;
+    }
+    matchedFingerprints.add(observation.fingerprint);
+    if (observation.suppressed) {
+      lifecycleSuppressedFindings.push(finding);
+    } else {
+      actionableFindings.push(finding);
+    }
+  }
+  for (const { finding, fingerprint } of fingerprintedFindings) {
+    if (!matchedFingerprints.has(fingerprint)) {
+      actionableFindings.push(finding);
+    }
+  }
+  return { actionableFindings, lifecycleSuppressedFindings };
+}
+function fingerprintUniqueReviewFindings(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  const fingerprinted = [];
+  for (const finding of findings) {
+    const fingerprint = computeFindingFingerprint(toFindingCandidate(finding));
+    if (seen.has(fingerprint)) {
+      continue;
+    }
+    seen.add(fingerprint);
+    fingerprinted.push({ finding, fingerprint });
+  }
+  return fingerprinted;
+}
+function enrichReviewFindingsWithDurableMetadata(findings, reconcile) {
+  const observationsByFingerprint = new Map(
+    reconcile.observations.map((item) => [item.fingerprint, item])
+  );
+  return findings.map((finding) => {
+    const fingerprint = computeFindingFingerprint(toFindingCandidate(finding));
+    const observation = observationsByFingerprint.get(fingerprint);
+    if (!observation) {
+      return finding;
+    }
+    return {
+      ...finding,
+      durable: {
+        id: observation.finding.id,
+        classification: observation.observation.classification,
+        status: observation.finding.status,
+        lifecycleSuppressed: observation.suppressed
+      }
+    };
+  });
+}
+async function persistReviewRun(diffOwlDir, input) {
+  const state = await openStateDatabase(diffOwlDir);
+  try {
+    return runInTransaction(state.db, () => {
+      const review = insertReview(state.db, {
+        targetKind: input.targetKind,
+        targetRef: input.targetRef,
+        targetCommit: input.targetCommit,
+        diffHash: input.diffHash,
+        model: input.model,
+        reasoning: input.reasoning,
+        depth: input.depth,
+        sessionId: input.sessionId,
+        summary: input.summary,
+        diagnostics: input.diagnostics,
+        timings: input.timings,
+        skippedReason: input.skippedReason ?? null
+      });
+      const findings = deduplicateReviewFindings(input.findings);
+      const candidates = findings.map(toFindingCandidate);
+      const reconcile = reconcileReviewFindings(state.db, review.id, candidates);
+      const { actionableFindings, lifecycleSuppressedFindings } = splitFindingsByLifecycleSuppression(findings, reconcile);
+      return {
+        reviewId: review.id,
+        reconcile,
+        actionableFindings,
+        lifecycleSuppressedFindings
+      };
+    });
+  } finally {
+    closeStateDatabase(state);
+  }
+}
+async function updatePersistedReview(diffOwlDir, reviewId, input) {
+  const state = await openStateDatabase(diffOwlDir);
+  try {
+    runInTransaction(state.db, () => {
+      updateReview(state.db, reviewId, {
+        ...input.reportPath !== void 0 ? { reportPath: input.reportPath } : {},
+        ...input.diagnostics !== void 0 ? { diagnostics: input.diagnostics } : {}
+      });
+    });
+  } finally {
+    closeStateDatabase(state);
+  }
+}
+async function getPersistedReview(diffOwlDir, reviewId) {
+  const state = await openStateDatabase(diffOwlDir);
+  try {
+    return getReviewById(state.db, reviewId);
+  } finally {
+    closeStateDatabase(state);
+  }
+}
+async function loadFindingOccurrenceCounts(diffOwlDir, findingIds) {
+  const state = await openStateDatabase(diffOwlDir);
+  try {
+    return countObservationsByFindingIds(state.db, findingIds);
+  } finally {
+    closeStateDatabase(state);
+  }
+}
+function mapReviewTarget(target) {
+  switch (target.kind) {
+    case "staged":
+      return { targetKind: "staged", targetRef: null };
+    case "last-commit":
+      return { targetKind: "last-commit", targetRef: null };
+    case "commit":
+      return { targetKind: "commit", targetRef: target.ref ?? null };
+  }
+}
+
+// src/output/json.ts
+var JSON_OUTPUT_SCHEMA_VERSION = 1;
+function parseReviewOutputFormat(value) {
+  if (value === void 0 || value === "text") {
+    return "text";
+  }
+  if (value === "json") {
+    return "json";
+  }
+  throw new Error(`Invalid output format: ${String(value)}. Expected text or json.`);
+}
+function buildReviewJsonDocument(input) {
+  const observations = selectJsonObservations(
+    input.persisted.reconcile.observations,
+    input.verbose
+  );
+  const actionableCount = input.persisted.reconcile.observations.filter(
+    (item) => !item.suppressed
+  ).length;
+  return {
+    schema_version: JSON_OUTPUT_SCHEMA_VERSION,
+    review: {
+      id: input.review.id,
+      created_at: input.review.createdAt,
+      target: {
+        kind: input.review.targetKind,
+        ref: input.review.targetRef,
+        commit: input.review.targetCommit
+      },
+      model: input.review.model,
+      reasoning: input.review.reasoning,
+      depth: input.review.depth,
+      session_id: input.review.sessionId,
+      summary: input.review.summary,
+      status: resolveReviewJsonStatus(input.review, actionableCount),
+      report_path: input.review.reportPath,
+      skipped_reason: input.review.skippedReason
+    },
+    findings: observations.map((item) => mapJsonFinding(item, input.occurrenceCounts)),
+    suppressed: {
+      lifecycle: input.persisted.reconcile.suppressedCounts,
+      outside_changed_files: input.suppressed.outsideChangedFiles,
+      below_confidence: input.suppressed.belowConfidence
+    },
+    diagnostics: input.review.diagnostics,
+    timings: input.timings ?? input.review.timings
+  };
+}
+function renderReviewJsonDocument(document) {
+  return `${JSON.stringify(document)}
+`;
+}
+function renderJsonErrorDocument(message) {
+  const document = {
+    schema_version: JSON_OUTPUT_SCHEMA_VERSION,
+    error: { message }
+  };
+  return `${JSON.stringify(document)}
+`;
+}
+function writeReviewJsonSuccess(document) {
+  process.stdout.write(renderReviewJsonDocument(document));
+}
+function writeJsonError(message) {
+  process.stderr.write(renderJsonErrorDocument(message));
+}
+function selectJsonObservations(observations, verbose = false) {
+  if (verbose) {
+    return observations;
+  }
+  return observations.filter((item) => !item.suppressed);
+}
+function resolveReviewJsonStatus(review, actionableCount) {
+  if (review.skippedReason) {
+    return "skipped";
+  }
+  return actionableCount > 0 ? "open" : "resolved";
+}
+function mapJsonFinding(item, occurrenceCounts) {
+  const { observation, finding, fingerprint, suppressed } = item;
+  return {
+    id: finding.id,
+    fingerprint,
+    status: finding.status,
+    classification: observation.classification,
+    suppressed,
+    location: {
+      file: observation.file,
+      line: observation.line
+    },
+    content: {
+      title: observation.title,
+      body: observation.body,
+      evidence: observation.evidence
+    },
+    severity: observation.severity,
+    confidence: observation.confidence,
+    created_at: finding.createdAt,
+    updated_at: finding.updatedAt,
+    occurrence_count: occurrenceCounts.get(finding.id) ?? 1
+  };
+}
+
+// src/output/findings.ts
+import chalk2 from "chalk";
+var ID_WIDTH = 12;
+var STATUS_WIDTH = 10;
+var SEVERITY_WIDTH = 8;
+var SEEN_WIDTH = 4;
+var COLUMN_GAP = 2;
+var MIN_LOCATION_WIDTH = 10;
+var MIN_TITLE_WIDTH = 12;
+var MAX_LOCATION_SHARE = 0.4;
+function shortenFindingId(id) {
+  if (id.length <= 16) {
+    return id;
+  }
+  return id.slice(0, 12);
+}
+function formatFindingList(items, options = {}) {
+  if (items.length === 0) {
+    return "";
+  }
+  const columns = options.columns ?? process.stdout.columns ?? 100;
+  const color = options.color ?? chalk2.level > 0;
+  const layout = computeListLayout(columns);
+  const lines = [];
+  lines.push(
+    color ? chalk2.bold(`Open findings: ${items.length}`) : `Open findings: ${items.length}`
+  );
+  lines.push(
+    color ? chalk2.dim("Durable backlog; absence from later reviews does not auto-fix findings.") : "Durable backlog; absence from later reviews does not auto-fix findings."
+  );
+  lines.push("");
+  lines.push(
+    color ? chalk2.bold(
+      [
+        padEnd("ID", ID_WIDTH),
+        padEnd("Status", STATUS_WIDTH),
+        padEnd("Severity", SEVERITY_WIDTH),
+        padEnd("Seen", SEEN_WIDTH),
+        padEnd("Location", layout.locationWidth),
+        "Title"
+      ].join(" ".repeat(COLUMN_GAP))
+    ) : [
+      padEnd("ID", ID_WIDTH),
+      padEnd("Status", STATUS_WIDTH),
+      padEnd("Severity", SEVERITY_WIDTH),
+      padEnd("Seen", SEEN_WIDTH),
+      padEnd("Location", layout.locationWidth),
+      "Title"
+    ].join(" ".repeat(COLUMN_GAP))
+  );
+  for (const item of items) {
+    lines.push(...formatFindingListRow(item, layout));
+  }
+  lines.push("");
+  lines.push(
+    color ? chalk2.dim("Mark resolved: diffowl findings fix <id> --note <text> --verified-by <command>") : "Mark resolved: diffowl findings fix <id> --note <text> --verified-by <command>"
+  );
+  return lines.join("\n");
+}
+function formatFindingDetail(detail) {
+  const lines = [
+    `ID: ${detail.finding.id}`,
+    `Status: ${detail.finding.status}`,
+    `Fingerprint: ${detail.finding.fingerprint}`,
+    `Occurrences: ${detail.occurrence_count}`,
+    `Created: ${detail.finding.createdAt}`,
+    `Updated: ${detail.finding.updatedAt}`
+  ];
+  if (detail.observation) {
+    lines.push(
+      "",
+      `Location: ${detail.observation.file}:${detail.observation.line}`,
+      `Severity: ${detail.observation.severity}`,
+      `Confidence: ${detail.observation.confidence}`,
+      `Classification: ${detail.observation.classification}`,
+      "",
+      detail.observation.title,
+      detail.observation.body
+    );
+    if (detail.observation.evidence) {
+      lines.push("", `Evidence: ${detail.observation.evidence}`);
+    }
+  }
+  if (detail.events.length > 0) {
+    lines.push("", "Events:");
+    for (const event of detail.events) {
+      const reason = event.reason ? ` \u2014 ${event.reason}` : "";
+      lines.push(`  - ${event.createdAt} ${event.eventType} (${event.actor})${reason}`);
+    }
+  }
+  return lines.join("\n");
+}
+function renderFindingDetailJson(detail) {
+  return `${JSON.stringify(detail, null, 2)}
+`;
+}
+function computeListLayout(columns) {
+  const fixedWidth = fixedPrefixWidth();
+  const flexibleWidth = Math.max(
+    columns - fixedWidth,
+    MIN_LOCATION_WIDTH + COLUMN_GAP + MIN_TITLE_WIDTH
+  );
+  let locationWidth = Math.max(
+    MIN_LOCATION_WIDTH,
+    Math.min(
+      Math.floor(flexibleWidth * MAX_LOCATION_SHARE),
+      flexibleWidth - COLUMN_GAP - MIN_TITLE_WIDTH
+    )
+  );
+  let titleWidth = flexibleWidth - locationWidth - COLUMN_GAP;
+  if (titleWidth < MIN_TITLE_WIDTH) {
+    titleWidth = MIN_TITLE_WIDTH;
+    locationWidth = Math.max(MIN_LOCATION_WIDTH, flexibleWidth - COLUMN_GAP - titleWidth);
+  }
+  return {
+    locationWidth,
+    titleWidth,
+    titleIndent: fixedWidth + locationWidth + COLUMN_GAP
+  };
+}
+function formatFindingListRow(item, layout) {
+  const id = shortenFindingId(item.finding.id);
+  const status = item.finding.status;
+  const severity = item.observation?.severity ?? "unknown";
+  const seen = `${item.occurrence_count}x`;
+  const location = formatLocation(item);
+  const title = normalizeDisplayWhitespace(item.observation?.title ?? "(no observation)");
+  const titleLines = wrapText(title, layout.titleWidth);
+  const locationCell = truncateEnd(location, layout.locationWidth);
+  const prefix = [
+    padEnd(id, ID_WIDTH),
+    padEnd(status, STATUS_WIDTH),
+    padEnd(severity, SEVERITY_WIDTH),
+    padEnd(seen, SEEN_WIDTH),
+    padEnd(locationCell, layout.locationWidth)
+  ].join(" ".repeat(COLUMN_GAP));
+  const lines = [`${prefix}${" ".repeat(COLUMN_GAP)}${titleLines[0] ?? ""}`];
+  for (let index = 1; index < titleLines.length; index += 1) {
+    lines.push(`${" ".repeat(layout.titleIndent)}${titleLines[index]}`);
+  }
+  return lines;
+}
+function formatLocation(item) {
+  if (!item.observation) {
+    return "unknown";
+  }
+  if (!item.observation.file) {
+    return "unknown";
+  }
+  return `${item.observation.file}:${item.observation.line}`;
+}
+function normalizeDisplayWhitespace(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+function wrapText(text, width) {
+  if (width <= 0) {
+    return [text];
+  }
+  if (text.length <= width) {
+    return [text];
+  }
+  const lines = [];
+  let remaining = text;
+  while (remaining.length > width) {
+    let breakAt = remaining.lastIndexOf(" ", width);
+    if (breakAt <= 0) {
+      breakAt = width;
+    }
+    lines.push(remaining.slice(0, breakAt).trimEnd());
+    remaining = remaining.slice(breakAt).trimStart();
+  }
+  if (remaining.length > 0) {
+    lines.push(remaining);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+function truncateEnd(text, width) {
+  if (text.length <= width) {
+    return text;
+  }
+  if (width <= 3) {
+    return text.slice(0, width);
+  }
+  return `${text.slice(0, width - 3)}...`;
+}
+function padEnd(text, width) {
+  if (text.length >= width) {
+    return text.slice(0, width);
+  }
+  return `${text}${" ".repeat(width - text.length)}`;
+}
+function fixedPrefixWidth() {
+  return ID_WIDTH + COLUMN_GAP + STATUS_WIDTH + COLUMN_GAP + SEVERITY_WIDTH + COLUMN_GAP + SEEN_WIDTH + COLUMN_GAP;
+}
+
+// src/output/locator.ts
+var LocatorNotFoundError = class extends Error {
+  name = "LocatorNotFoundError";
+};
+var LocatorAmbiguousError = class extends Error {
+  constructor(locator, matches) {
+    super(`Locator ${locator} is ambiguous (${matches.length} matches).`);
+    this.locator = locator;
+    this.matches = matches;
+  }
+  locator;
+  matches;
+  name = "LocatorAmbiguousError";
+};
+function parseLatestOrdinalLocator(locator) {
+  const match = /^latest:(\d+)$/i.exec(locator.trim());
+  if (!match) {
+    return null;
+  }
+  const ordinal = Number.parseInt(match[1] ?? "", 10);
+  if (!Number.isInteger(ordinal) || ordinal < 1) {
+    throw new LocatorNotFoundError(`Invalid latest locator: ${locator}`);
+  }
+  return ordinal;
+}
+function resolveFindingIdFromCandidates(locator, candidates) {
+  const trimmed = locator.trim();
+  const exact = candidates.find((finding) => finding.id === trimmed);
+  if (exact) {
+    return exact.id;
+  }
+  const prefixMatches = candidates.filter((finding) => finding.id.startsWith(trimmed));
+  if (prefixMatches.length === 1) {
+    return prefixMatches[0].id;
+  }
+  if (prefixMatches.length > 1) {
+    throw new LocatorAmbiguousError(
+      trimmed,
+      prefixMatches.map((finding) => finding.id)
+    );
+  }
+  throw new LocatorNotFoundError(`Finding locator not found: ${trimmed}`);
+}
+function resolveLatestOrdinalFindingId(ordinal, observations) {
+  const match = observations.find((observation) => observation.ordinal === ordinal);
+  if (!match) {
+    throw new LocatorNotFoundError(`Finding ${ordinal} was not found in the latest review.`);
+  }
+  return match.findingId;
+}
+
+// src/state/lifecycle.ts
+function dismissFinding(db, findingId, input) {
+  return transitionFinding(db, findingId, {
+    allowedFrom: ["open", "regressed"],
+    to: "dismissed",
+    eventType: "dismissed",
+    actor: input.actor,
+    reason: input.reason
+  });
+}
+function deferFinding(db, findingId, input) {
+  return transitionFinding(db, findingId, {
+    allowedFrom: ["open", "regressed"],
+    to: "deferred",
+    eventType: "deferred",
+    actor: input.actor,
+    reason: input.reason
+  });
+}
+function fixFinding(db, findingId, input) {
+  const finding = requireFinding(db, findingId);
+  assertTransition(finding.status, ["open", "regressed"], "fixed");
+  const updated = updateFinding(db, findingId, {
+    status: "fixed",
+    lastReviewId: finding.lastReviewId
+  });
+  insertFindingEvent(db, {
+    findingId,
+    eventType: "fixed",
+    actor: input.actor,
+    reason: input.note,
+    commitRef: input.commitRef ?? null,
+    verification: input.verifiedBy
+  });
+  return updated;
+}
+function reopenFinding(db, findingId, input) {
+  return transitionFinding(db, findingId, {
+    allowedFrom: ["fixed"],
+    to: "open",
+    eventType: "reopened",
+    actor: input.actor,
+    reason: input.reason
+  });
+}
+function transitionFinding(db, findingId, options) {
+  const finding = requireFinding(db, findingId);
+  assertTransition(finding.status, options.allowedFrom, options.to);
+  const updated = updateFinding(db, findingId, {
+    status: options.to,
+    lastReviewId: finding.lastReviewId
+  });
+  insertFindingEvent(db, {
+    findingId,
+    eventType: options.eventType,
+    actor: options.actor,
+    reason: options.reason
+  });
+  return updated;
+}
+function requireFinding(db, findingId) {
+  const finding = getFindingById(db, findingId);
+  if (!finding) {
+    throw new InvalidFindingTransitionError(`Finding ${findingId} was not found.`);
+  }
+  return finding;
+}
+function assertTransition(current, allowedFrom, target) {
+  if (!allowedFrom.includes(current)) {
+    throw new InvalidFindingTransitionError(
+      `Cannot transition finding from ${current} to ${target}.`
+    );
+  }
+}
+
+// src/state/findings-query.ts
+async function withFindingDatabase(diffOwlDir, fn) {
+  const state = await openStateDatabase(diffOwlDir);
+  try {
+    return fn(state.db);
+  } finally {
+    closeStateDatabase(state);
+  }
+}
+function listUnresolvedFindings(db) {
+  return listFindingsByStatuses(db, ["open", "regressed"]).map(
+    (finding) => toFindingListItem(db, finding)
+  );
+}
+function getFindingDetail(db, findingId) {
+  const finding = getFindingById(db, findingId);
+  if (!finding) {
+    return void 0;
+  }
+  return toFindingDetail(db, finding);
+}
+function resolveFindingLocator(db, locator) {
+  const latestOrdinal = parseLatestOrdinalLocator(locator);
+  if (latestOrdinal !== null) {
+    const latestReview = getLatestReview(db);
+    if (!latestReview) {
+      throw new LocatorNotFoundError("No reviews found for latest locator resolution.");
+    }
+    const observations = listObservationsForReview(db, latestReview.id);
+    return resolveLatestOrdinalFindingId(latestOrdinal, observations);
+  }
+  return resolveFindingIdFromCandidates(locator, listAllFindings(db));
+}
+function requireFindingDetail(db, locator) {
+  const findingId = resolveFindingLocator(db, locator);
+  const detail = getFindingDetail(db, findingId);
+  if (!detail) {
+    throw new LocatorNotFoundError(`Finding ${findingId} was not found.`);
+  }
+  return detail;
+}
+function mutateFinding(db, locator, mutation) {
+  return runInTransaction(db, () => {
+    const findingId = resolveFindingLocator(db, locator);
+    const updated = mutation(findingId);
+    const detail = getFindingDetail(db, updated.id);
+    if (!detail) {
+      throw new LocatorNotFoundError(`Finding ${updated.id} was not found after mutation.`);
+    }
+    return detail;
+  });
+}
+function dismissFindingByLocator(db, locator, input) {
+  return mutateFinding(db, locator, (findingId) => dismissFinding(db, findingId, input));
+}
+function deferFindingByLocator(db, locator, input) {
+  return mutateFinding(db, locator, (findingId) => deferFinding(db, findingId, input));
+}
+function fixFindingByLocator(db, locator, input) {
+  return mutateFinding(db, locator, (findingId) => fixFinding(db, findingId, input));
+}
+function reopenFindingByLocator(db, locator, input) {
+  return mutateFinding(db, locator, (findingId) => reopenFinding(db, findingId, input));
+}
+function toFindingListItem(db, finding) {
+  const counts = countObservationsByFindingIds(db, [finding.id]);
+  return {
+    finding,
+    observation: getLatestObservationForFinding(db, finding.id) ?? null,
+    occurrence_count: counts.get(finding.id) ?? 0
+  };
+}
+function toFindingDetail(db, finding) {
+  const counts = countObservationsByFindingIds(db, [finding.id]);
+  return {
+    finding,
+    observation: getLatestObservationForFinding(db, finding.id) ?? null,
+    events: listFindingEvents(db, finding.id),
+    occurrence_count: counts.get(finding.id) ?? 0
+  };
+}
+
+// src/cli.ts
+import { readFile as readFile7 } from "fs/promises";
+import { basename as basename5, dirname as dirname4 } from "path";
+import { execa as execa5 } from "execa";
+
+// package.json
+var package_default = {
+  name: "diffowl",
+  version: "0.3.0",
+  description: "Local AI code review agent powered by OpenCode",
+  keywords: [
+    "ai",
+    "code-review",
+    "git",
+    "opencode",
+    "pre-commit"
+  ],
+  homepage: "https://github.com/gutierrezje/diffowl#readme",
+  bugs: {
+    url: "https://github.com/gutierrezje/diffowl/issues"
+  },
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/gutierrezje/diffowl.git"
+  },
+  bin: {
+    diffowl: "dist/cli.js"
+  },
+  files: [
+    "dist"
+  ],
+  type: "module",
+  scripts: {
+    "check:native-runtime": "node scripts/check-native-runtime.mjs",
+    prebuild: "pnpm run check:native-runtime",
+    build: "tsup",
+    predev: "pnpm run check:native-runtime",
+    dev: "tsup --watch",
+    pretest: "pnpm run check:native-runtime",
+    test: "vitest run",
+    pretypecheck: "pnpm run check:native-runtime",
+    typecheck: "tsc --noEmit",
+    lint: "oxlint . && pnpm run typecheck",
+    format: "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "dogfood:0.3": "pnpm run build && node scripts/dogfood-0.3.mjs",
+    prepack: "npm run build"
+  },
+  dependencies: {
+    "@opencode-ai/sdk": "^1.15.11",
+    "better-sqlite3": "^12.10.0",
+    chalk: "^5.6.2",
+    commander: "^14.0.3",
+    execa: "^9.6.1",
+    ora: "^9.4.0",
+    picomatch: "^4.0.4",
+    yaml: "^2.9.0",
+    zod: "^4.4.3"
+  },
+  devDependencies: {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.9.1",
+    "@types/picomatch": "^4.0.3",
+    oxfmt: "^0.52.0",
+    oxlint: "^1.67.0",
+    tsup: "^8.5.1",
+    typescript: "^6.0.3",
+    vitest: "^4.1.7"
+  },
+  engines: {
+    node: ">=22.14.0 <23"
+  },
+  packageManager: "pnpm@10.15.1",
+  pnpm: {
+    onlyBuiltDependencies: [
+      "better-sqlite3"
+    ]
+  }
+};
+
+// 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(
+  "--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) => {
+  const format = resolveReviewOutputFormat(options.format);
+  const jsonMode = format === "json";
+  const hookCommit = options.hook && options.commit ? String(options.commit) : void 0;
+  const hookLock = options.hook ? process.env["DIFFOWL_HOOK_LOCK"] : void 0;
+  if (hookLock) {
+    process.once("exit", () => releaseHookReviewLock(hookLock));
+  }
+  if (options.hook) {
+    await writeHookStatus(0, hookCommit, "Review started.");
+  }
+  const totalStart = performance.now();
+  const timings = [];
   const gitRepoStart = performance.now();
   const isRepo = await isGitRepo();
   recordCliTiming(timings, "git-repo-check", "Git repository check", gitRepoStart);
   if (!isRepo) {
-    console.error(chalk2.red("Not a git repository"));
-    process.exit(1);
+    await failReview(format, "Not a git repository", { hook: options.hook, hookCommit });
   }
   if (!configExists()) {
-    console.log(chalk2.yellow("No .diffowl.yml found. Running first-time setup...\n"));
+    console.log(chalk3.yellow("No .diffowl.yml found. Running first-time setup...\n"));
     await runInit();
   }
   const config = await loadConfigOrExit();
   const projectRoot = getProjectRoot();
   if (options.staged && options.commit) {
-    console.error(chalk2.red("Cannot use --staged and --commit together"));
-    process.exit(1);
+    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" };
   const depth = resolveReviewDepth(options.depth, config);
@@ -3442,51 +5235,130 @@ program.command("review", { isDefault: true }).description("Review the last comm
     const commitsExist = await hasCommits();
     recordCliTiming(timings, "git-commit-check", "Git commit check", hasCommitsStart);
     if (!commitsExist) {
-      console.error(chalk2.red("No commits found in this repository"));
-      process.exit(1);
+      await failReview(format, "No commits found in this repository", {
+        hook: options.hook,
+        hookCommit
+      });
     }
   }
-  printHeader();
+  if (!jsonMode) {
+    printHeader();
+  }
   const hookFailure = await checkRecentHookFailure();
-  if (hookFailure) {
-    console.log(chalk2.yellow(`\u26A0 ${formatHookFailure(hookFailure)}`));
+  if (hookFailure && !jsonMode) {
+    console.log(chalk3.yellow(`\u26A0 ${formatHookFailure(hookFailure)}`));
     console.log();
   }
-  const spinner = ora({
+  const spinner = jsonMode ? null : ora({
     text: "Building local review context...",
     color: "cyan",
     discardStdin: false
   }).start();
+  const cancelController = new AbortController();
   process.once("SIGINT", () => {
-    try {
-      spinner.stop();
-    } catch {
-    }
-    console.log(chalk2.yellow("\nReview cancelled by user (Ctrl+C)."));
-    process.exit(130);
+    handleReviewInterrupt({
+      cancelController,
+      spinner,
+      jsonMode,
+      message: "Review cancelled by user (Ctrl+C).",
+      exitCode: 130,
+      hook: options.hook,
+      hookCommit
+    });
   });
   process.once("SIGTSTP", () => {
-    try {
-      spinner.stop();
-    } catch {
-    }
-    console.log(chalk2.yellow("\nReview cancelled by user (Ctrl+Z)."));
-    process.exit(146);
+    handleReviewInterrupt({
+      cancelController,
+      spinner,
+      jsonMode,
+      message: "Review cancelled by user (Ctrl+Z).",
+      exitCode: 146,
+      hook: options.hook,
+      hookCommit
+    });
   });
   try {
     const snapshot = await loadReviewSnapshot(projectRoot, target);
     const { diff } = snapshot;
     if (target.kind === "staged" && diff.files.length === 0) {
-      spinner.stop();
-      console.log(chalk2.yellow("No staged changes to review"));
+      spinner?.stop();
+      if (jsonMode) {
+        const persisted2 = await persistReviewRun(getDiffOwlDir(), {
+          ...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: getDiffOwlDir(),
+          reviewId: persisted2.reviewId,
+          persisted: persisted2,
+          suppressed: { outsideChangedFiles: 0, belowConfidence: 0 },
+          verbose,
+          timings
+        });
+        process.exit(0);
+      }
+      console.log(chalk3.yellow("No staged changes to review"));
       process.exit(0);
     }
     if (config.skip_doc_only && isDocOnlyDiff(diff)) {
-      spinner.stop();
-      console.warn(chalk2.yellow("Documentation-only changes detected. Skipping review."));
+      spinner?.stop();
+      if (!jsonMode) {
+        console.warn(chalk3.yellow("Documentation-only changes detected. Skipping review."));
+      }
       const skipContent = buildDocOnlySkipMarkdown(diff);
-      const reportPath2 = await writeMarkdownReport(skipContent);
-      console.log(chalk2.dim(`Report saved: ${reportPath2}`));
+      const diffHash2 = computeDiffHash(diff.raw);
+      const targetFields2 = mapReviewTarget(target);
+      const targetCommit2 = await resolveTargetCommit(target);
+      const persisted2 = await persistReviewRun(getDiffOwlDir(), {
+        ...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(getDiffOwlDir(), persisted2.reviewId, {
+          reportPath: reportPath2
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        await updatePersistedReview(getDiffOwlDir(), persisted2.reviewId, {
+          reportPath: null,
+          diagnostics: [`Report write failed: ${message}`]
+        });
+        throw err;
+      }
+      if (jsonMode) {
+        await emitReviewJsonSuccess({
+          diffOwlDir: getDiffOwlDir(),
+          reviewId: persisted2.reviewId,
+          persisted: persisted2,
+          suppressed: { outsideChangedFiles: 0, belowConfidence: 0 },
+          verbose,
+          timings
+        });
+      } else {
+        console.log(chalk3.dim(`Report saved: ${reportPath2}`));
+      }
       if (options.hook) {
         await writeHookStatus(0, hookCommit);
       }
@@ -3498,19 +5370,23 @@ program.command("review", { isDefault: true }).description("Review the last comm
     const contextRenderStart = performance.now();
     const localContext = renderReviewContext(reviewContext, { depth });
     recordCliTiming(timings, "context-render", "Local review context render", contextRenderStart);
-    if (reviewContext.diagnostics.length > 0) {
+    if (reviewContext.diagnostics.length > 0 && spinner) {
       spinner.warn("Local review context built with warnings.");
       for (const diagnostic of reviewContext.diagnostics) {
-        console.log(chalk2.yellow(`  - ${diagnostic}`));
+        console.log(chalk3.yellow(`  - ${diagnostic}`));
       }
       console.log();
       spinner.start("Connecting to OpenCode...");
     }
-    spinner.text = "Connecting to OpenCode...";
+    if (spinner) {
+      spinner.text = "Connecting to OpenCode...";
+    }
     const serverStart = performance.now();
     await prepareReviewServer(config);
     recordCliTiming(timings, "server-ensure", "OpenCode server ensure", serverStart);
-    spinner.text = "Reviewing changes...";
+    if (spinner) {
+      spinner.text = "Reviewing changes...";
+    }
     const reviewStart = performance.now();
     const reviewResult = await runReview({
       target,
@@ -3518,14 +5394,19 @@ program.command("review", { isDefault: true }).description("Review the last comm
       config,
       localContext,
       depth,
+      signal: cancelController.signal,
       onProgress: (event) => {
-        spinner.text = formatReviewProgress(event);
+        if (spinner) {
+          spinner.text = formatReviewProgress(event);
+        }
       }
     });
     const report = reviewResult.report;
     recordCliTiming(timings, "review-run", "OpenCode review run", reviewStart);
-    spinner.succeed("Review complete.");
-    console.log();
+    spinner?.succeed("Review complete.");
+    if (!jsonMode) {
+      console.log();
+    }
     const diagnostics = report.diagnostics ?? [];
     const confidenceFilter = filterFindingsByConfidence(report.findings, config.min_confidence);
     report.findings = confidenceFilter.findings;
@@ -3551,30 +5432,118 @@ program.command("review", { isDefault: true }).description("Review the last comm
     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(getDiffOwlDir(), {
+      ...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();
-    const reportPath = await writeMarkdownReport(markdown, {
-      session_id: reviewResult.sessionId,
-      project_root: projectRoot
-    });
+    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(getDiffOwlDir(), 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(getDiffOwlDir(), persisted.reviewId, {
+        reportPath: null,
+        diagnostics
+      });
+      throw err;
+    }
     recordCliTiming(timings, "write-report", "Report write", writeStart);
     recordCliTiming(timings, "total", "Total review command", totalStart);
-    console.log(colorizeMarkdown(markdown));
-    printFooter(report, reportPath);
-    printTimingSummary([...timings, ...report.timings ?? []]);
+    if (jsonMode) {
+      await emitReviewJsonSuccess({
+        diffOwlDir: getDiffOwlDir(),
+        reviewId: persisted.reviewId,
+        persisted,
+        suppressed: {
+          outsideChangedFiles: changedFileFilter.suppressed.length,
+          belowConfidence: confidenceFilter.dropped
+        },
+        verbose,
+        timings: [...timings, ...report.timings ?? []]
+      });
+    } else {
+      console.log(colorizeMarkdown(markdown));
+      printFooter(report, reportPath);
+      printTimingSummary([...timings, ...report.timings ?? []]);
+    }
     if (options.hook) {
       await writeHookStatus(0, hookCommit);
       process.exit(0);
     }
   } catch (err) {
-    spinner.stop();
+    spinner?.stop();
+    if (cancelController.signal.aborted || isReviewCancellation(err)) {
+      if (options.hook) {
+        await writeHookStatus(1, hookCommit, "Review cancelled by user.");
+        process.exit(0);
+      }
+      if (!cancelController.signal.aborted) {
+        process.exit(130);
+      }
+      return;
+    }
     const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk2.red(`
+    if (jsonMode) {
+      writeJsonError(message);
+    } else {
+      console.error(chalk3.red(`
 Review failed: ${message}`));
-    for (const line of getOpenCodeFailureGuidance(message)) {
-      console.log(chalk2.dim(line));
+      for (const line of getOpenCodeFailureGuidance(message)) {
+        console.log(chalk3.dim(line));
+      }
     }
     if (options.hook) {
       await writeHookStatus(1, hookCommit, message);
@@ -3589,19 +5558,19 @@ program.command("chat").description("Open the OpenCode session for a review").ar
   try {
     content = await readFile7(reportPath, "utf-8");
   } catch {
-    console.error(chalk2.red(`Review report not found: ${reportPath}`));
+    console.error(chalk3.red(`Review report not found: ${reportPath}`));
     process.exit(1);
   }
   let metadata;
   try {
     metadata = parseReviewMetadata(content);
   } catch {
-    console.error(chalk2.red(`Invalid review metadata: ${reportPath}`));
+    console.error(chalk3.red(`Invalid review metadata: ${reportPath}`));
     process.exit(1);
   }
   if (!metadata) {
     console.error(
-      chalk2.red(`Review report does not contain chat session metadata: ${reportPath}`)
+      chalk3.red(`Review report does not contain chat session metadata: ${reportPath}`)
     );
     process.exit(1);
   }
@@ -3611,9 +5580,9 @@ program.command("chat").description("Open the OpenCode session for a review").ar
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk2.red(`Failed to open review session: ${message}`));
+    console.error(chalk3.red(`Failed to open review session: ${message}`));
     for (const line of getOpenCodeFailureGuidance(message)) {
-      console.log(chalk2.dim(line));
+      console.log(chalk3.dim(line));
     }
     process.exit(1);
   }
@@ -3621,7 +5590,7 @@ program.command("chat").description("Open the OpenCode session for a review").ar
 async function selectReviewInteractively() {
   if (!canSelectReviewInteractively(process.stdin.isTTY, process.stdout.isTTY)) {
     console.error(
-      chalk2.red(
+      chalk3.red(
         "Interactive review selection requires a terminal. Pass a report filename or path instead."
       )
     );
@@ -3629,14 +5598,14 @@ async function selectReviewInteractively() {
   }
   const reports = await listReviewReportPaths();
   if (reports.length === 0) {
-    console.error(chalk2.red("No review reports available. Run `diffowl review` first."));
+    console.error(chalk3.red("No review reports available. Run `diffowl review` first."));
     process.exit(1);
   }
-  console.log(chalk2.bold("\nSelect a review:\n"));
+  console.log(chalk3.bold("\nSelect a review:\n"));
   for (const [index, report] of reports.entries()) {
     const resolved = basename5(dirname4(report)) === "resolved";
     console.log(
-      `  ${chalk2.cyan(`${index + 1}.`)} ${basename5(report)}${resolved ? chalk2.dim(" (resolved)") : ""}`
+      `  ${chalk3.cyan(`${index + 1}.`)} ${basename5(report)}${resolved ? chalk3.dim(" (resolved)") : ""}`
     );
   }
   const rl = createInterface({
@@ -3647,10 +5616,10 @@ async function selectReviewInteractively() {
     while (true) {
       const selected = selectReviewReportPath(
         reports,
-        await rl.question(chalk2.yellow("\nReview number: "))
+        await rl.question(chalk3.yellow("\nReview number: "))
       );
       if (selected) return selected;
-      console.log(chalk2.red(`Enter a number between 1 and ${reports.length}.`));
+      console.log(chalk3.red(`Enter a number between 1 and ${reports.length}.`));
     }
   } finally {
     rl.close();
@@ -3670,6 +5639,20 @@ function formatReviewProgress(event) {
       return event.message;
   }
 }
+async function describeNodeRuntime(node) {
+  try {
+    const { stdout } = await execa5(node, [
+      "-p",
+      "JSON.stringify({ version: process.version, modules: process.versions.modules })"
+    ]);
+    const parsed = JSON.parse(stdout);
+    if (typeof parsed.version === "string" && typeof parsed.modules === "string") {
+      return `${node} (${parsed.version}, ABI ${parsed.modules})`;
+    }
+  } catch {
+  }
+  return node;
+}
 function resolveReviewDepth(value, config) {
   if (value === void 0) {
     return config.context.depth;
@@ -3677,8 +5660,8 @@ function resolveReviewDepth(value, config) {
   try {
     return parseReviewContextDepth(value);
   } catch {
-    console.error(chalk2.red(`Invalid review depth: ${String(value)}`));
-    console.error(chalk2.dim("Expected one of: shallow, default"));
+    console.error(chalk3.red(`Invalid review depth: ${String(value)}`));
+    console.error(chalk3.dim("Expected one of: shallow, default"));
     process.exit(1);
   }
 }
@@ -3689,8 +5672,8 @@ function resolveReasoningEffort(value, config) {
   try {
     return parseReasoningEffort(value);
   } catch {
-    console.error(chalk2.red(`Invalid reasoning effort: ${String(value)}`));
-    console.error(chalk2.dim("Expected one of: auto, none, minimal, low, medium, high, max, xhigh"));
+    console.error(chalk3.red(`Invalid reasoning effort: ${String(value)}`));
+    console.error(chalk3.dim("Expected one of: auto, none, minimal, low, medium, high, max, xhigh"));
     process.exit(1);
   }
 }
@@ -3703,9 +5686,9 @@ function printTimingSummary(timings) {
     ...timings.filter((timing) => timing.phase !== "total"),
     ...timings.filter((timing) => timing.phase === "total")
   ];
-  console.log(chalk2.dim("Timing:"));
+  console.log(chalk3.dim("Timing:"));
   for (const timing of ordered) {
-    console.log(chalk2.dim(`  ${timing.label}: ${formatDuration2(timing.ms)}`));
+    console.log(chalk3.dim(`  ${timing.label}: ${formatDuration2(timing.ms)}`));
   }
   console.log();
 }
@@ -3729,14 +5712,14 @@ program.command("init").description("Set up DiffOwl for this project").action(as
   await runInit();
 });
 async function runInit() {
-  console.log(chalk2.bold("DiffOwl Setup\n"));
+  console.log(chalk3.bold("DiffOwl Setup\n"));
   const config = await loadConfigOrExit();
   await selectModelInteractively(config, { allowKeepCurrent: false });
 }
 program.command("model").description("View or change the AI model").argument("[model]", "Model to use (e.g., opencode-go/big-pickle)").action(async (model) => {
   const config = await loadConfigOrExit();
   if (!model) {
-    console.log(chalk2.bold("Current model: ") + chalk2.cyan(config.model));
+    console.log(chalk3.bold("Current model: ") + chalk3.cyan(config.model));
     await selectModelInteractively(config, { allowKeepCurrent: true });
     return;
   }
@@ -3744,16 +5727,16 @@ program.command("model").description("View or change the AI model").argument("[m
   try {
     parsedModel = parseModel(model);
   } catch {
-    console.error(chalk2.red(`Invalid model: ${model}`));
+    console.error(chalk3.red(`Invalid model: ${model}`));
     console.error(
-      chalk2.dim("Expected provider/model format, for example opencode-go/big-pickle")
+      chalk3.dim("Expected provider/model format, for example opencode-go/big-pickle")
     );
     process.exit(1);
   }
   config.model = parsedModel;
   const configPath = await saveConfig(config);
-  console.log(chalk2.green(`\u2713 Model set to ${chalk2.cyan(parsedModel)}`));
-  console.log(chalk2.dim(`Config: ${configPath}`));
+  console.log(chalk3.green(`\u2713 Model set to ${chalk3.cyan(parsedModel)}`));
+  console.log(chalk3.dim(`Config: ${configPath}`));
 });
 async function selectModelInteractively(config, options) {
   const spinner = ora("Querying available models from OpenCode...").start();
@@ -3767,7 +5750,7 @@ async function selectModelInteractively(config, options) {
     const message = err instanceof Error ? err.message : String(err);
     spinner.fail(`Failed to query models: ${message}`);
     for (const line of getOpenCodeFailureGuidance(message)) {
-      console.error(chalk2.dim(line));
+      console.error(chalk3.dim(line));
     }
     process.exit(1);
   }
@@ -3775,19 +5758,19 @@ async function selectModelInteractively(config, options) {
   if (models.length > 0) {
     if (!canSelectModelInteractively(process.stdin.isTTY, process.stdout.isTTY)) {
       console.error(
-        chalk2.red(
+        chalk3.red(
           "Interactive model selection requires a terminal. Pass a model explicitly, for example `diffowl model provider/model`."
         )
       );
       process.exit(1);
     }
     console.log(
-      chalk2.bold(
+      chalk3.bold(
         options.allowKeepCurrent ? "\nAvailable models configured in OpenCode:" : "Available models configured in OpenCode:"
       )
     );
     models.forEach((m, idx) => {
-      console.log(`  ${chalk2.cyan(idx + 1)}. ${m}`);
+      console.log(`  ${chalk3.cyan(idx + 1)}. ${m}`);
     });
     console.log();
     const rl = createInterface({
@@ -3800,7 +5783,7 @@ async function selectModelInteractively(config, options) {
         const selection = selectModel(
           models,
           config.model,
-          await rl.question(chalk2.yellow(promptText)),
+          await rl.question(chalk3.yellow(promptText)),
           options.allowKeepCurrent
         );
         if (selection.type === "kept") break;
@@ -3808,27 +5791,27 @@ async function selectModelInteractively(config, options) {
           selectedModel = selection.model;
           break;
         }
-        console.log(chalk2.red("Invalid selection. Please enter a valid number."));
+        console.log(chalk3.red("Invalid selection. Please enter a valid number."));
       }
     } finally {
       rl.close();
     }
   } else {
-    console.log(chalk2.yellow("\nNo active/connected providers found in OpenCode."));
+    console.log(chalk3.yellow("\nNo active/connected providers found in OpenCode."));
     console.log(
-      chalk2.dim("Make sure you run ") + chalk2.cyan("opencode") + chalk2.dim(" to authenticate and set up your providers/keys first.")
+      chalk3.dim("Make sure you run ") + chalk3.cyan("opencode") + chalk3.dim(" to authenticate and set up your providers/keys first.")
     );
-    console.log(chalk2.dim("Using fallback default model: ") + chalk2.cyan(config.model));
+    console.log(chalk3.dim("Using fallback default model: ") + chalk3.cyan(config.model));
     console.log();
   }
   if (selectedModel !== config.model || !options.allowKeepCurrent) {
     config.model = selectedModel;
     const configPath = await saveConfig(config);
     if (options.allowKeepCurrent) {
-      console.log(chalk2.green(`\u2713 Model set to ${chalk2.cyan(selectedModel)}`));
+      console.log(chalk3.green(`\u2713 Model set to ${chalk3.cyan(selectedModel)}`));
     } else {
-      console.log(chalk2.green(`\u2713 Config saved to ${configPath}`));
-      console.log(chalk2.dim(`Model set to: `) + chalk2.cyan(selectedModel));
+      console.log(chalk3.green(`\u2713 Config saved to ${configPath}`));
+      console.log(chalk3.dim(`Model set to: `) + chalk3.cyan(selectedModel));
     }
     console.log();
   }
@@ -3836,37 +5819,40 @@ async function selectModelInteractively(config, options) {
 var hookCmd = program.command("hook").description("Manage git hooks");
 hookCmd.command("install").description("Install post-commit hook (non-blocking review)").action(async () => {
   if (!await isGitRepo()) {
-    console.error(chalk2.red("Not a git repository"));
+    console.error(chalk3.red("Not a git repository"));
     process.exit(1);
   }
   const alreadyInstalled = await isHookInstalled();
   const hookPath = await installHook();
+  const command = await getHookCommand();
   const action = alreadyInstalled ? "updated" : "installed";
-  console.log(chalk2.green(`\u2713 Post-commit hook ${action}: ${hookPath}`));
-  console.log(chalk2.dim("Reviews will run automatically after each commit (non-blocking)"));
+  console.log(chalk3.green(`\u2713 Post-commit hook ${action}: ${hookPath}`));
+  console.log(chalk3.dim(`Hook Node: ${await describeNodeRuntime(command.node)}`));
+  console.log(chalk3.dim(`Hook Entrypoint: ${command.cli}`));
+  console.log(chalk3.dim("Reviews will run automatically after each commit (non-blocking)"));
   console.log(
-    chalk2.dim("Hook output: .diffowl/hook.log; latest report: .diffowl/reviews/latest.md")
+    chalk3.dim("Hook output: .diffowl/hook.log; latest report: .diffowl/reviews/latest.md")
   );
 });
 hookCmd.command("status").description("Check if the post-commit hook is installed and up to date").action(async () => {
   const status = await checkHookStale();
   if (!status.installed) {
-    console.log(chalk2.yellow(`\u2717 ${status.reason ?? "Hook not installed"}`));
+    console.log(chalk3.yellow(`\u2717 ${status.reason ?? "Hook not installed"}`));
     return;
   }
   if (status.stale) {
-    console.log(chalk2.yellow("\u26A0 Hook is installed but stale"));
-    console.log(chalk2.dim(`Reason: ${status.reason}`));
-    console.log(chalk2.dim("Run `diffowl hook install` to update it."));
+    console.log(chalk3.yellow("\u26A0 Hook is installed but stale"));
+    console.log(chalk3.dim(`Reason: ${status.reason}`));
+    console.log(chalk3.dim("Run `diffowl hook install` to update it."));
     return;
   }
-  console.log(chalk2.green("\u2713 Hook is installed and up to date"));
+  console.log(chalk3.green("\u2713 Hook is installed and up to date"));
 });
 hookCmd.command("uninstall").description("Remove the post-commit hook").action(async () => {
   if (await uninstallHook()) {
-    console.log(chalk2.green("\u2713 Hook removed"));
+    console.log(chalk3.green("\u2713 Hook removed"));
   } else {
-    console.log(chalk2.yellow("No diffowl hook found"));
+    console.log(chalk3.yellow("No diffowl hook found"));
   }
 });
 program.command("hook-run", { hidden: true }).description("Spawn a non-blocking hook review").action(async () => {
@@ -3892,28 +5878,156 @@ serverCmd.command("start").description("Start the OpenCode server").action(async
   }
 });
 serverCmd.command("stop").description("Stop the OpenCode server").action(async () => {
-  if (await stopServer()) {
-    console.log(chalk2.green("\u2713 Server stopped"));
+  const config = await loadConfigOrExit();
+  if (await stopServer(config.server.port)) {
+    console.log(chalk3.green("\u2713 Server stopped"));
   } else {
-    console.log(chalk2.yellow("No managed server found"));
+    console.log(chalk3.yellow(`No OpenCode server found on port ${config.server.port}`));
   }
 });
 serverCmd.command("status").description("Check if the OpenCode server is running").action(async () => {
   const config = await loadConfigOrExit();
-  const running = await isServerRunning(config.server.port);
-  if (running) {
-    console.log(chalk2.green(`\u2713 Server running on port ${config.server.port}`));
-  } else {
-    console.log(chalk2.yellow(`\u2717 No server on port ${config.server.port}`));
+  const health = await getServerHealth(config.server.port);
+  if (!health?.healthy) {
+    console.log(chalk3.yellow(`\u2717 No server on port ${config.server.port}`));
+    return;
+  }
+  console.log(chalk3.green(`\u2713 Server running on port ${config.server.port}`));
+  const cliVersion = await getInstalledOpencodeVersion();
+  if (health.version) {
+    console.log(`  Server version: ${health.version}`);
+  }
+  if (cliVersion) {
+    console.log(`  CLI version: ${cliVersion}`);
+  }
+  if (health.version && cliVersion && health.version !== cliVersion) {
+    console.log(
+      chalk3.yellow(
+        "\u26A0 Version mismatch. Restart with: diffowl server stop && diffowl server start"
+      )
+    );
   }
 });
+var findingsCmd = program.command("findings").description("Inspect and manage durable findings");
+findingsCmd.command("list", { isDefault: true }).description("List unresolved findings").action(async () => {
+  await loadConfigOrExit();
+  const items = await withFindingDatabase(getDiffOwlDir(), listUnresolvedFindings);
+  if (items.length === 0) {
+    console.log(chalk3.green("No unresolved findings."));
+    return;
+  }
+  console.log(formatFindingList(items));
+});
+findingsCmd.command("show").description("Show one finding by locator").argument("<locator>", "Finding id, id prefix, or latest:N").option("--format <format>", "Output format: text or json", "text").action(async (locator, options) => {
+  await loadConfigOrExit();
+  const format = resolveReviewOutputFormat(options.format);
+  try {
+    const detail = await withFindingDatabase(
+      getDiffOwlDir(),
+      (db) => requireFindingDetail(db, locator)
+    );
+    if (format === "json") {
+      process.stdout.write(renderFindingDetailJson(detail));
+      return;
+    }
+    console.log(formatFindingDetail(detail));
+  } catch (err) {
+    failFindingsCommand(format, err);
+  }
+});
+findingsCmd.command("dismiss").description("Dismiss a finding").argument("<locator>", "Finding id, id prefix, or latest:N").requiredOption("--reason <text>", "Dismissal reason").option("--actor <actor>", "Actor: user or agent", "user").option("--format <format>", "Output format: text or json", "json").action(async (locator, options) => {
+  await runFindingMutation(
+    locator,
+    options.format,
+    (db) => dismissFindingByLocator(db, locator, {
+      actor: parseFindingActor(options.actor),
+      reason: options.reason
+    })
+  );
+});
+findingsCmd.command("defer").description("Defer a finding").argument("<locator>", "Finding id, id prefix, or latest:N").requiredOption("--reason <text>", "Deferral reason").option("--actor <actor>", "Actor: user or agent", "user").option("--format <format>", "Output format: text or json", "json").action(async (locator, options) => {
+  await runFindingMutation(
+    locator,
+    options.format,
+    (db) => deferFindingByLocator(db, locator, {
+      actor: parseFindingActor(options.actor),
+      reason: options.reason
+    })
+  );
+});
+findingsCmd.command("fix").description("Mark a finding fixed").argument("<locator>", "Finding id, id prefix, or latest:N").requiredOption("--note <text>", "Fix note").option("--verified-by <command>", "Verification command (repeatable)", collectValues, []).option("--commit <ref>", "Commit reference").option("--actor <actor>", "Actor: user or agent", "user").option("--format <format>", "Output format: text or json", "json").action(
+  async (locator, options) => {
+    const verifiedBy = options.verifiedBy ?? [];
+    if (verifiedBy.length === 0) {
+      failFindingsCommand(
+        resolveReviewOutputFormat(options.format),
+        new Error("At least one --verified-by command is required.")
+      );
+    }
+    await runFindingMutation(
+      locator,
+      options.format,
+      (db) => fixFindingByLocator(db, locator, {
+        actor: parseFindingActor(options.actor),
+        note: options.note,
+        verifiedBy,
+        ...options.commit ? { commitRef: options.commit } : {}
+      })
+    );
+  }
+);
+findingsCmd.command("reopen").description("Reopen a fixed finding").argument("<locator>", "Finding id, id prefix, or latest:N").requiredOption("--reason <text>", "Reopen reason").option("--actor <actor>", "Actor: user or agent", "user").option("--format <format>", "Output format: text or json", "json").action(async (locator, options) => {
+  await runFindingMutation(
+    locator,
+    options.format,
+    (db) => reopenFindingByLocator(db, locator, {
+      actor: parseFindingActor(options.actor),
+      reason: options.reason
+    })
+  );
+});
 program.parse();
+async function runFindingMutation(_locator, formatValue, mutate) {
+  await loadConfigOrExit();
+  const format = resolveReviewOutputFormat(formatValue);
+  try {
+    const detail = await withFindingDatabase(getDiffOwlDir(), mutate);
+    if (format === "json") {
+      process.stdout.write(renderFindingDetailJson(detail));
+      return;
+    }
+    console.log(formatFindingDetail(detail));
+  } catch (err) {
+    failFindingsCommand(format, err);
+  }
+}
+function failFindingsCommand(format, err) {
+  const message = err instanceof LocatorNotFoundError || err instanceof LocatorAmbiguousError || err instanceof InvalidFindingTransitionError ? err.message : err instanceof Error ? err.message : String(err);
+  if (format === "json") {
+    writeJsonError(message);
+  } else {
+    console.error(chalk3.red(message));
+  }
+  process.exit(1);
+}
+function parseFindingActor(value) {
+  if (value === void 0 || value === "user") {
+    return "user";
+  }
+  if (value === "agent") {
+    return "agent";
+  }
+  throw new Error(`Invalid actor: ${value}. Expected user or agent.`);
+}
+function collectValues(value, previous) {
+  return [...previous, value];
+}
 async function loadConfigOrExit() {
   try {
     return await loadConfig();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    console.error(chalk2.red(`Config error: ${message}`));
+    console.error(chalk3.red(`Config error: ${message}`));
     process.exit(1);
   }
 }
@@ -3949,4 +6063,78 @@ function buildDocOnlySkipMarkdown(diff) {
   }
   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 handleReviewInterrupt(input) {
+  input.cancelController.abort();
+  try {
+    input.spinner?.stop();
+  } catch {
+  }
+  if (input.jsonMode) {
+    writeJsonError(input.message);
+  } else {
+    console.log(chalk3.yellow(`
+${input.message}`));
+  }
+  if (input.hook) {
+    const forceExit = setTimeout(() => process.exit(0), 2e3);
+    void writeHookStatus(1, input.hookCommit, input.message).finally(() => {
+      clearTimeout(forceExit);
+      process.exit(0);
+    });
+    return;
+  }
+  setTimeout(() => process.exit(input.exitCode), 750).unref();
+}
+function resolveReviewOutputFormat(value) {
+  try {
+    return parseReviewOutputFormat(value);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk3.red(message));
+    process.exit(1);
+  }
+}
+async function failReview(format, message, options = {}) {
+  const exitCode = options.exitCode ?? 1;
+  if (format === "json") {
+    writeJsonError(message);
+  } else {
+    console.error(chalk3.red(message));
+  }
+  if (options.hook) {
+    await writeHookStatus(1, options.hookCommit, message);
+    process.exit(0);
+  }
+  process.exit(exitCode);
+}
+async function emitReviewJsonSuccess(input) {
+  const review = await getPersistedReview(input.diffOwlDir, input.reviewId);
+  if (!review) {
+    throw new Error(`Review ${input.reviewId} was not found in state database.`);
+  }
+  const findingIds = input.persisted.reconcile.observations.map((item) => item.finding.id);
+  const occurrenceCounts = await loadFindingOccurrenceCounts(input.diffOwlDir, findingIds);
+  const document = buildReviewJsonDocument({
+    review,
+    persisted: input.persisted,
+    occurrenceCounts,
+    suppressed: {
+      outsideChangedFiles: input.suppressed.outsideChangedFiles,
+      belowConfidence: input.suppressed.belowConfidence
+    },
+    verbose: input.verbose,
+    ...input.timings ? { timings: input.timings } : {}
+  });
+  writeReviewJsonSuccess(document);
+}
 //# sourceMappingURL=cli.js.map