diffowl 0.1.0

package/dist/cli.js

@@ -0,0 +1,3658 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import ora from "ora";
+import { createInterface } from "readline/promises";
+
+// src/config.ts
+import { access, readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { parse, stringify } from "yaml";
+import { z, ZodError } from "zod";
+var DEFAULT_CONFIG = {
+  model: "opencode-go/big-pickle",
+  server: {
+    port: 4096,
+    auto_start: true
+  },
+  context: {
+    depth: "default"
+  },
+  reasoning: {
+    effort: "auto"
+  },
+  retention: {
+    hook_log_kb: 1024
+  },
+  timeout: 300,
+  // 5 minutes
+  min_confidence: "medium",
+  include: ["**/*"],
+  exclude: [
+    "**/*.test.*",
+    "**/*.spec.*",
+    "**/*.lock",
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.git/**"
+  ],
+  rules: [],
+  skip_doc_only: false,
+  verbose: false
+};
+var CONFIG_FILENAME = ".diffowl.yml";
+var ReviewConfidenceSchema = z.enum(["low", "medium", "high"]);
+var ReviewContextDepthSchema = z.enum(["shallow", "default"]);
+var ReasoningEffortSchema = z.enum([
+  "auto",
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "max",
+  "xhigh"
+]);
+var ModelSchema = z.string().trim().min(1, "model must not be empty").regex(/^[^/\s]+\/\S+$/, "model must use provider/model format");
+var stringArraySchema = z.array(z.string().trim().min(1));
+var DiffOwlConfigSchema = z.object({
+  model: ModelSchema.default(DEFAULT_CONFIG.model),
+  server: z.object({
+    port: z.number().int().min(1).max(65535).default(DEFAULT_CONFIG.server.port),
+    auto_start: z.boolean().default(DEFAULT_CONFIG.server.auto_start)
+  }).strict().default(DEFAULT_CONFIG.server),
+  context: z.object({
+    depth: ReviewContextDepthSchema.default(DEFAULT_CONFIG.context.depth)
+  }).strict().default(DEFAULT_CONFIG.context),
+  reasoning: z.object({
+    effort: ReasoningEffortSchema.default(DEFAULT_CONFIG.reasoning.effort)
+  }).strict().default(DEFAULT_CONFIG.reasoning),
+  retention: z.object({
+    hook_log_kb: z.number().int().nonnegative().default(DEFAULT_CONFIG.retention.hook_log_kb)
+  }).strict().default(DEFAULT_CONFIG.retention),
+  timeout: z.number().int().positive().default(DEFAULT_CONFIG.timeout),
+  min_confidence: ReviewConfidenceSchema.default(DEFAULT_CONFIG.min_confidence),
+  include: stringArraySchema.default(DEFAULT_CONFIG.include),
+  exclude: stringArraySchema.default(DEFAULT_CONFIG.exclude),
+  rules: stringArraySchema.default(DEFAULT_CONFIG.rules),
+  skip_doc_only: z.boolean().default(DEFAULT_CONFIG.skip_doc_only),
+  verbose: z.boolean().default(DEFAULT_CONFIG.verbose)
+}).strict();
+function parseModel(value) {
+  return ModelSchema.parse(value);
+}
+function parseReviewContextDepth(value) {
+  return ReviewContextDepthSchema.parse(value);
+}
+function parseReasoningEffort(value) {
+  return ReasoningEffortSchema.parse(value);
+}
+function parseConfigInput(value) {
+  return DiffOwlConfigSchema.parse(value ?? {});
+}
+function formatZodError(err) {
+  return err.issues.map((issue) => {
+    const path = issue.path.length > 0 ? issue.path.join(".") : "config";
+    return `${path}: ${issue.message}`;
+  }).join("; ");
+}
+function findConfigPath() {
+  let dir = process.cwd();
+  while (true) {
+    const candidate = join(dir, CONFIG_FILENAME);
+    if (existsSync(candidate)) return candidate;
+    const parent = join(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return join(process.cwd(), CONFIG_FILENAME);
+}
+async function loadConfig() {
+  const configPath = findConfigPath();
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const raw = await readFile(configPath, "utf-8");
+    return parseConfigInput(parse(raw));
+  } catch (err) {
+    const message = err instanceof ZodError ? formatZodError(err) : err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load ${configPath}: ${message}`);
+  }
+}
+async function saveConfig(config) {
+  const configPath = findConfigPath();
+  const content = stringify(DiffOwlConfigSchema.parse(config), { lineWidth: 0 });
+  await writeFile(configPath, content, "utf-8");
+  return configPath;
+}
+function getDiffOwlDir() {
+  return join(getProjectRoot(), ".diffowl");
+}
+function getProjectRoot() {
+  return dirname(findConfigPath());
+}
+async function ensureDiffOwlDir() {
+  const dir = getDiffOwlDir();
+  try {
+    await access(dir);
+  } catch {
+    await mkdir(dir, { recursive: true });
+  }
+  return dir;
+}
+function configExists() {
+  return existsSync(findConfigPath());
+}
+
+// src/opencode/client.ts
+import { createOpencodeClient as createOpencodeClient2 } from "@opencode-ai/sdk";
+
+// src/opencode/server.ts
+import { execa } from "execa";
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2, writeFile as writeFile2, unlink } from "fs/promises";
+import { join as join2 } from "path";
+var HEALTH_TIMEOUT_MS = 2e3;
+var STARTUP_WAIT_MS = 3e3;
+var MAX_RETRIES = 10;
+async function isServerRunning(port) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), HEALTH_TIMEOUT_MS);
+    const res = await fetch(`http://127.0.0.1:${port}/global/health`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function ensureServer(port) {
+  const baseUrl = `http://127.0.0.1:${port}`;
+  if (await isServerRunning(port)) {
+    return baseUrl;
+  }
+  await spawnServer(port);
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    await sleep(STARTUP_WAIT_MS / MAX_RETRIES);
+    if (await isServerRunning(port)) {
+      return baseUrl;
+    }
+  }
+  await sleep(STARTUP_WAIT_MS);
+  if (await isServerRunning(port)) {
+    return baseUrl;
+  }
+  throw new Error(
+    `Failed to start OpenCode server on port ${port}. Is opencode installed? (npm i -g opencode-ai)`
+  );
+}
+async function checkOpencodeInstalled() {
+  const isWin = process.platform === "win32";
+  const checkCmd = isWin ? "where" : "which";
+  try {
+    await execa(checkCmd, ["opencode"]);
+  } catch {
+    try {
+      await execa("opencode", ["--version"], { timeout: 5e3 });
+    } catch {
+      throw new Error(
+        "opencode not found. Install it: npm i -g opencode-ai\nSee: https://opencode.ai/docs/"
+      );
+    }
+  }
+}
+async function spawnServer(port) {
+  const dir = await ensureDiffOwlDir();
+  const pidFile = join2(dir, "server.pid");
+  await checkOpencodeInstalled();
+  const subprocess = execa("opencode", ["serve", "--port", String(port)], {
+    detached: true,
+    stdio: "ignore",
+    cleanup: false
+  });
+  void subprocess.catch(() => {
+  });
+  if (subprocess.pid) {
+    await writeFile2(pidFile, String(subprocess.pid), "utf-8");
+  }
+  subprocess.unref();
+}
+async function stopServer() {
+  const dir = getDiffOwlDir();
+  const pidFile = join2(dir, "server.pid");
+  if (!existsSync2(pidFile)) return false;
+  let pid;
+  try {
+    pid = parseInt(await readFile2(pidFile, "utf-8"), 10);
+  } catch {
+    try {
+      await unlink(pidFile);
+    } catch {
+    }
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+  } catch {
+    try {
+      await unlink(pidFile);
+    } catch {
+    }
+    return false;
+  }
+  if (!await isOpencodeProcess(pid)) {
+    try {
+      await unlink(pidFile);
+    } catch {
+    }
+    return false;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    await unlink(pidFile);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isOpencodeProcess(pid) {
+  const isWin = process.platform === "win32";
+  try {
+    if (isWin) {
+      try {
+        const { stdout: stdout2 } = await execa("powershell", [
+          "-NoProfile",
+          "-Command",
+          `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' | Select-Object -ExpandProperty CommandLine`
+        ]);
+        if (stdout2.toLowerCase().includes("opencode")) {
+          return true;
+        }
+      } catch {
+      }
+      try {
+        const { stdout: stdout2 } = await execa("wmic", [
+          "process",
+          "where",
+          `ProcessId=${pid}`,
+          "get",
+          "CommandLine"
+        ]);
+        if (stdout2.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");
+    }
+  } catch {
+    return false;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// src/opencode/agent.ts
+var REVIEW_AGENT_PROMPT = `You are DiffOwl, a meticulous senior code reviewer. Your job is to review git changes and provide actionable feedback as structured JSON.
+
+You MAY think step-by-step internally, but your VISIBLE output must follow this contract exactly:
+
+1. Output a single line with the text: FINAL_REVIEW_JSON
+2. On the next line, output a single JSON object with this exact shape (no markdown fences, no comments, no trailing commas):
+
+{
+  "summary": "1-3 sentences describing what the changes do and the overall risk profile.",
+  "findings": [
+    {
+      "severity": "error" | "warning" | "info",
+      "file": "relative/path/from/repo/root.ts",
+      "line": 123,
+      "evidence": "Quote the exact 1-2 lines of code showing the concern",
+      "title": "Short, specific issue title",
+      "body": "Concrete description of the problem, its impact, and a focused suggestion for how to fix it.",
+      "confidence": "high" | "medium" | "low"
+    }
+  ]
+}
+
+3. Do not wrap the JSON in backticks or markdown code fences.
+4. Do not print any other text before or after the JSON line. No greetings, no explanations, no scratchpad, no commentary.
+
+Semantics and constraints:
+- "severity":
+  - "error" \u2014 Bugs, security vulnerabilities, crashes, data loss, or behavior that is very likely wrong and should block merge.
+  - "warning" \u2014 Error-handling gaps, race conditions, performance issues, surprising behavior that is likely problematic but not an immediate blocker.
+  - "info" \u2014 Non-blocking suggestions that are clearly improvements but may be subjective or low risk.
+- "file": must be a path that exists in the repository and that is relevant to the diff you inspected.
+- "line": the 1-based line number in that file that best anchors the issue (usually the first changed line or the line where the problem manifests).
+- "evidence": Quote the exact 1-2 lines of code showing the concern. If you cannot quote exact code lines supporting your finding, you MUST downgrade the confidence to "low".
+- "title": one short sentence fragment that could be used as a PR comment subject line.
+- "body": 2-6 sentences that describe:
+  1) what is wrong,
+  2) why it matters (risk/impact),
+  3) how to fix or improve it in concrete terms.
+- "confidence":
+  - "high" \u2014 You are very confident this is a real issue based on the code you can see.
+  - "medium" \u2014 You are reasonably confident but missing some surrounding context.
+  - "low" \u2014 You are speculating or extrapolating beyond the visible code.
+
+Review rules:
+- Focus on substantive issues: bugs, security, logic errors, edge cases, error handling, performance.
+- Prefer high-confidence findings. If you are speculating, label it "low" confidence. If you are uncertain but see a real risk, label it "medium". Only use "high" when the issue is clearly present in the visible code.
+- Do NOT nitpick formatting, naming style, or cosmetic preferences.
+- Do NOT suggest changes that would alter behavior without a clear, justified benefit.
+- It is OK for "findings" to be an empty array if you see no meaningful issues.
+
+Required review passes:
+- Behavior and compatibility: Look for changed defaults, contracts, edge cases, and user-visible behavior regressions.
+- Failure modes and error handling: Look for hangs, swallowed errors, misleading success, unbounded retries, unsafe fallbacks, and timeout behavior.
+- State, lifecycle, and concurrency: Look at process/session ownership, file writes, hooks, ports, signals, async settle logic, and cleanup paths.
+- Paths, environment, and portability: Check cwd vs project root, monorepos, Windows/POSIX behavior, PATH assumptions, symlinks, and shell quoting.
+- Security and permissions: Check command execution, path injection, unintended reads/writes, log leakage, and permission-boundary changes.
+- Output, config, and observability consistency: Check CLI output, markdown reports, hook logs, config semantics, diagnostics, truncation, and timing labels agree.
+- Tests for changed behavior: Report specific missing tests for new branches, config modes, output sections, or failure paths when the gap creates regression risk.
+- Performance and boundedness: Look for unbounded scans, large-file/diff cliffs, slow hook behavior, and expensive operations in common paths.
+- Data filtering/loss: Look for data silently dropped, hidden, duplicated, parsed with a fallback, or reported inconsistently.
+`;
+function buildReviewPrompt(mode, customRules, include, exclude, localContext, depth = "default") {
+  const modeInstruction = mode === "staged" ? "Review the currently staged changes." : mode === "commit" ? "Review the selected commit." : "Review the last commit.";
+  let prompt = `${modeInstruction}
+
+DiffOwl has already collected the diff and likely-relevant local context below. Use this context first.
+
+${reviewDepthInstruction(depth)}
+
+Then provide your review following the format in your instructions.`;
+  if (localContext) {
+    prompt += `
+
+${localContext}`;
+  }
+  if (include && include.length > 0 && !(include.length === 1 && include[0] === "**/*")) {
+    prompt += `
+
+Only review files that match these patterns: ${include.join(", ")}`;
+  }
+  if (exclude && exclude.length > 0) {
+    prompt += `
+
+Ignore and do NOT review files that match these patterns: ${exclude.join(", ")}`;
+  }
+  if (customRules.length > 0) {
+    prompt += `
+
+Additional review rules for this project:
+${customRules.map((r) => `- ${r}`).join("\n")}`;
+  }
+  return prompt;
+}
+function reviewDepthInstruction(depth) {
+  switch (depth) {
+    case "shallow":
+      return [
+        "Review depth: shallow.",
+        "This is a cheap, surface-level review from the provided context only.",
+        "Look for obvious local bugs such as off-by-one errors, inverted conditions, unsafe null handling, missing awaits, and implementation anti-patterns visible in the diff.",
+        "Do not claim a field, branch, call path, or validation is missing or ignored unless the provided context directly proves it. If relevant snippets are truncated, either skip the finding or mark it low confidence."
+      ].join("\n");
+    case "default":
+      return [
+        "Review depth: default.",
+        "Use tools for targeted exploration when the provided context is not enough.",
+        "This mode should catch more than surface-level diff bugs, including ignored fields, missed wiring, incorrect assumptions about adjacent code, and behavior mismatches around changed symbols.",
+        "Before reporting that a field, branch, validation, call, or config value is missing or ignored, inspect the relevant nearby definitions or call sites with tools when they are not fully present in the context."
+      ].join("\n");
+  }
+}
+
+// src/opencode/review-parser.ts
+import { z as z2 } from "zod";
+var ReviewSeveritySchema = z2.preprocess(
+  (value) => typeof value === "string" ? value.toLowerCase() : value,
+  z2.enum(["error", "warning", "info"])
+);
+var ReviewConfidenceSchema2 = z2.preprocess(
+  (value) => typeof value === "string" ? value.toLowerCase() : value,
+  z2.enum(["low", "medium", "high"])
+).catch("low");
+var ReviewFindingLineSchema = z2.preprocess(
+  (value) => typeof value === "string" ? Number(value) : value,
+  z2.number().int().positive()
+);
+var ReviewFindingSchema = z2.object({
+  severity: ReviewSeveritySchema,
+  file: z2.string().trim().min(1),
+  line: ReviewFindingLineSchema,
+  evidence: z2.string().nullish(),
+  title: z2.string().trim().min(1),
+  body: z2.string().trim().min(1),
+  confidence: ReviewConfidenceSchema2
+});
+var ReviewJsonSchema = z2.object({
+  summary: z2.string(),
+  findings: z2.array(z2.unknown())
+});
+function parseStructuredReview(raw) {
+  const marker = "FINAL_REVIEW_JSON";
+  const markerIndex = raw.indexOf(marker);
+  const usedFallbackJson = markerIndex === -1;
+  const afterMarker = markerIndex === -1 ? raw : raw.slice(markerIndex + marker.length);
+  const firstBrace = afterMarker.indexOf("{");
+  const lastBrace = afterMarker.lastIndexOf("}");
+  if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace) {
+    throw new Error(
+      markerIndex === -1 ? `Review did not contain a valid JSON object. Raw response preview: ${previewRawResponse(raw)}` : `Review did not include a valid JSON object after FINAL_REVIEW_JSON. Raw response preview: ${previewRawResponse(raw)}`
+    );
+  }
+  const jsonText = afterMarker.slice(firstBrace, lastBrace + 1);
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonText);
+  } catch (err) {
+    throw new Error(
+      `Failed to parse review JSON: ${err.message}. Raw response preview: ${previewRawResponse(raw)}`
+    );
+  }
+  const root = ReviewJsonSchema.safeParse(parsed);
+  if (!root.success) {
+    throw new Error(
+      `Review JSON is missing required fields: summary or findings. Raw response preview: ${previewRawResponse(raw)}`
+    );
+  }
+  const findings = [];
+  const diagnostics = usedFallbackJson ? ["Review JSON did not include FINAL_REVIEW_JSON marker; parsed fallback JSON object."] : [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, item] of root.data.findings.entries()) {
+    const finding = ReviewFindingSchema.safeParse(item);
+    if (!finding.success) {
+      diagnostics.push(`Dropped malformed finding at index ${index}.`);
+      continue;
+    }
+    const key = `${finding.data.severity}:${finding.data.file}:${finding.data.line}:${finding.data.title}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    findings.push({
+      severity: finding.data.severity,
+      file: finding.data.file,
+      line: finding.data.line,
+      ...finding.data.evidence != null ? { evidence: finding.data.evidence } : {},
+      title: finding.data.title,
+      body: finding.data.body,
+      confidence: finding.data.confidence
+    });
+  }
+  return {
+    summary: root.data.summary,
+    findings,
+    ...diagnostics.length > 0 ? { diagnostics } : {}
+  };
+}
+function previewRawResponse(raw) {
+  const compact = raw.replace(/\s+/g, " ").trim();
+  return compact.length > 500 ? `${compact.slice(0, 500)}...` : compact || "<empty>";
+}
+function looksLikeCompleteStructuredReview(text) {
+  const markerIndex = text.indexOf("FINAL_REVIEW_JSON");
+  if (markerIndex === -1) return false;
+  const afterMarker = text.slice(markerIndex + "FINAL_REVIEW_JSON".length);
+  const firstBrace = afterMarker.indexOf("{");
+  const lastBrace = afterMarker.lastIndexOf("}");
+  if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace) return false;
+  const jsonText = afterMarker.slice(firstBrace, lastBrace + 1);
+  if (!jsonText.endsWith("}")) return false;
+  let openCount = 0;
+  let closeCount = 0;
+  let inString = false;
+  let escapeNext = false;
+  for (let i = 0; i < jsonText.length; i++) {
+    const char = jsonText[i];
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+    if (char === "\\") {
+      escapeNext = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (!inString) {
+      if (char === "{") openCount++;
+      else if (char === "}") closeCount++;
+    }
+  }
+  if (openCount === 0 || openCount !== closeCount) return false;
+  try {
+    return ReviewJsonSchema.safeParse(JSON.parse(jsonText)).success;
+  } catch {
+    return false;
+  }
+}
+
+// src/opencode/settlement.ts
+function createReviewSettlementCoordinator(options) {
+  let settled = false;
+  let fullResponse = "";
+  let lastCheckedLength = 0;
+  let reconciliationRunning = false;
+  let timeoutRequested = false;
+  let lastReconciliationError;
+  const settle = (outcome, value) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(safetyTimeout);
+    clearInterval(reconciliationInterval);
+    options.onAbort();
+    if (outcome === "resolve") {
+      options.resolve(value);
+    } else {
+      options.reject(value);
+    }
+  };
+  const acceptText = (text) => {
+    if (text.length > fullResponse.length) {
+      fullResponse = text;
+      options.onText?.(fullResponse);
+    }
+    const trimmed = fullResponse.trim();
+    const endsWithBrace = trimmed.endsWith("}");
+    const lengthDelta = fullResponse.length - lastCheckedLength;
+    if (lengthDelta > 500 || endsWithBrace) {
+      lastCheckedLength = fullResponse.length;
+      if (looksLikeCompleteStructuredReview(fullResponse)) {
+        settle("resolve", fullResponse);
+        return true;
+      }
+    }
+    return false;
+  };
+  const reconcile = async (isTimeout) => {
+    if (settled || reconciliationRunning) return;
+    reconciliationRunning = true;
+    try {
+      const result = await options.reconcile();
+      if (result?.error) {
+        settle("reject", result.error);
+        return;
+      }
+      if (result?.reconciliationError) {
+        lastReconciliationError = result.reconciliationError;
+      } else if (result) {
+        lastReconciliationError = void 0;
+      }
+      if (result?.text && acceptText(result.text)) {
+        return;
+      }
+      if (isTimeout || timeoutRequested) {
+        const suffix = lastReconciliationError ? ` Last session reconciliation error: ${lastReconciliationError.message}` : "";
+        settle(
+          "reject",
+          new Error(
+            `Review timed out.${suffix}`,
+            lastReconciliationError ? { cause: lastReconciliationError } : void 0
+          )
+        );
+      }
+    } finally {
+      reconciliationRunning = false;
+    }
+  };
+  const safetyTimeout = setTimeout(() => {
+    timeoutRequested = true;
+    void reconcile(true);
+  }, options.timeoutMs);
+  const reconciliationInterval = setInterval(
+    () => void reconcile(false),
+    options.reconciliationIntervalMs ?? 1e3
+  );
+  return {
+    acceptText,
+    finish: () => {
+      if (settled || acceptText(fullResponse)) return;
+      settle(
+        "reject",
+        new Error("OpenCode event stream ended before a complete review was received.")
+      );
+    },
+    isSettled: () => settled,
+    reject: (error) => settle("reject", error),
+    resolve: (text) => settle("resolve", text)
+  };
+}
+
+// src/opencode/tools.ts
+var FALLBACK_TOOL_IDS = [
+  "apply_patch",
+  "bash",
+  "edit",
+  "glob",
+  "grep",
+  "question",
+  "read",
+  "skill",
+  "task",
+  "todowrite",
+  "webfetch",
+  "write"
+];
+var READ_SEARCH_TOOLS = /* @__PURE__ */ new Set(["glob", "grep", "read"]);
+var PERMISSION_REPLY_TIMEOUT_MS = 5e3;
+async function buildToolPolicy(client, depth) {
+  const available = new Set(FALLBACK_TOOL_IDS);
+  try {
+    const result = await client.tool?.ids?.();
+    if (Array.isArray(result?.data)) {
+      for (const id of result.data) {
+        if (typeof id === "string") {
+          available.add(id);
+        }
+      }
+    }
+  } catch {
+  }
+  const allowed = allowedToolsForDepth(depth);
+  const policy = {};
+  for (const id of available) {
+    policy[id] = allowed.has(id);
+  }
+  return policy;
+}
+function allowedToolsForDepth(depth) {
+  if (depth === "shallow") {
+    return /* @__PURE__ */ new Set();
+  }
+  return READ_SEARCH_TOOLS;
+}
+async function replyToPermissionRequest(client, permission, onProgress) {
+  const response = "reject";
+  onProgress?.({
+    type: "session",
+    message: `OpenCode permission ${response}: ${permission.title ?? permission.type}`,
+    sessionId: permission.sessionID
+  });
+  await withTimeout(
+    replyWithAvailableEndpoint(client, permission, response),
+    PERMISSION_REPLY_TIMEOUT_MS
+  );
+}
+async function replyWithAvailableEndpoint(client, permission, response) {
+  if (client.permission?.reply) {
+    await client.permission.reply(
+      { requestID: permission.id },
+      { body: { reply: response, message: "DiffOwl review depth policy" } }
+    );
+    return;
+  }
+  if (client.postSessionIdPermissionsPermissionId) {
+    await client.postSessionIdPermissionsPermissionId({
+      path: { id: permission.sessionID, permissionID: permission.id },
+      body: { response }
+    });
+  }
+}
+function extractPermissionRequest(payload, sessionId) {
+  if (!payload || typeof payload !== "object") {
+    return void 0;
+  }
+  const event = payload;
+  if (typeof event.type !== "string" || !event.properties || typeof event.properties !== "object") {
+    return void 0;
+  }
+  const properties = event.properties;
+  if (properties["sessionID"] !== sessionId) {
+    return void 0;
+  }
+  if (event.type === "permission.updated") {
+    const id = properties["id"];
+    const type = properties["type"];
+    if (typeof id !== "string" || id.trim() === "" || typeof type !== "string" || type.trim() === "") {
+      return void 0;
+    }
+    const title = properties["title"];
+    return {
+      id,
+      sessionID: sessionId,
+      type,
+      ...typeof title === "string" ? { title } : {}
+    };
+  }
+  if (event.type === "permission.asked") {
+    const id = properties["id"];
+    const permission = properties["permission"];
+    if (typeof id !== "string" || id.trim() === "" || typeof permission !== "string" || permission.trim() === "") {
+      return void 0;
+    }
+    const patterns = properties["patterns"];
+    return {
+      id,
+      sessionID: sessionId,
+      type: permission,
+      ...Array.isArray(patterns) && patterns.every((pattern) => typeof pattern === "string") ? { title: patterns.join(", ") } : {}
+    };
+  }
+  return void 0;
+}
+async function withTimeout(promise, ms) {
+  let timeout;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error("permission reply timed out")), ms);
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+// src/opencode/provider-payload.ts
+import { z as z3 } from "zod";
+var ProviderModelSchema = z3.object({
+  id: z3.string(),
+  status: z3.string().nullish().transform((value) => value ?? void 0),
+  reasoning: z3.boolean().nullish().transform((value) => value ?? void 0),
+  capabilities: z3.object({
+    reasoning: z3.boolean().nullish().transform((value) => value ?? void 0)
+  }).nullish().transform((value) => value ?? void 0),
+  variants: z3.record(z3.string(), z3.unknown()).nullish().transform((value) => value ?? void 0)
+}).passthrough();
+var ProviderSchema = z3.object({
+  id: z3.string(),
+  models: z3.record(z3.string(), z3.unknown()).nullish().transform((models) => {
+    if (!models) return void 0;
+    return Object.fromEntries(
+      Object.entries(models).flatMap(([key, model]) => {
+        const parsed = ProviderModelSchema.safeParse(model);
+        return parsed.success ? [[key, parsed.data]] : [];
+      })
+    );
+  })
+}).passthrough();
+var ProviderPayloadSchema = z3.object({
+  connected: z3.array(z3.string()).nullish().transform((value) => value ?? []),
+  all: z3.array(z3.unknown()).nullish().transform(
+    (providers) => (providers ?? []).flatMap((provider) => {
+      const parsed = ProviderSchema.safeParse(provider);
+      return parsed.success ? [parsed.data] : [];
+    })
+  )
+}).passthrough();
+function parseProviderPayload(response) {
+  if (!response || typeof response !== "object") return void 0;
+  return ProviderPayloadSchema.safeParse(response.data).data;
+}
+
+// src/opencode/models.ts
+import { createOpencodeClient } from "@opencode-ai/sdk";
+async function getAvailableModels(port, options = {}) {
+  if (!await isServerRunning(port)) {
+    if (options.autoStart === false) {
+      return [];
+    }
+    try {
+      await ensureServer(port);
+    } catch {
+      return [];
+    }
+  }
+  const client = createOpencodeClient({
+    baseUrl: `http://127.0.0.1:${port}`
+  });
+  try {
+    const payload = parseProviderPayload(await client.provider.list());
+    return listAvailableModels(payload);
+  } catch {
+    return [];
+  }
+}
+function listAvailableModels(payload) {
+  if (!payload) return [];
+  return payload.all.filter((provider) => payload.connected.includes(provider.id)).flatMap(
+    (provider) => Object.values(provider.models ?? {}).filter((model) => model.status === "active" || !model.status).map((model) => `${provider.id}/${model.id}`)
+  ).sort();
+}
+
+// src/opencode/client.ts
+function extractEventPayload(event) {
+  if (!event || typeof event !== "object") return void 0;
+  const payload = event.payload;
+  if (!payload || typeof payload !== "object") return void 0;
+  return payload;
+}
+async function runReview(options) {
+  const { mode, config, localContext, depth, onProgress } = options;
+  const port = config.server.port;
+  const directoryOptions = opencodeDirectoryOptions();
+  const timings = [];
+  const connectStart = performance.now();
+  if (!await isServerRunning(port)) {
+    throw new Error(`OpenCode server is not running on port ${port}.`);
+  }
+  onProgress?.({ type: "server", message: `Connected to OpenCode on port ${port}.` });
+  const client = createOpencodeClient2({
+    baseUrl: `http://127.0.0.1:${port}`
+  });
+  recordTiming(timings, onProgress, "opencode-connect", "OpenCode client connection", connectStart);
+  const sessionStart = performance.now();
+  const session = await withOpenCodeDiagnostics(
+    "session-create",
+    { port },
+    () => client.session.create({
+      ...directoryOptions,
+      body: {}
+    })
+  );
+  const sessionId = extractSessionId(session);
+  recordTiming(timings, onProgress, "session-create", "OpenCode session creation", sessionStart);
+  onProgress?.({ type: "session", message: "Created review session.", sessionId });
+  const toolPolicyStart = performance.now();
+  const tools = await buildToolPolicy(client, depth);
+  recordTiming(timings, onProgress, "tool-policy", "OpenCode tool policy", toolPolicyStart);
+  const promptStart = performance.now();
+  const prompt = buildReviewPrompt(
+    mode,
+    config.rules,
+    config.include,
+    config.exclude,
+    localContext,
+    depth
+  );
+  recordTiming(timings, onProgress, "prompt-build", "Review prompt build", promptStart);
+  const parts = config.model.split("/");
+  const providerID = parts[0];
+  const modelID = parts.slice(1).join("/");
+  const reasoning = await resolveReasoningVariant(
+    client,
+    providerID,
+    modelID,
+    config.reasoning.effort
+  );
+  let fullResponse = "";
+  const eventsController = new AbortController();
+  const eventStart = performance.now();
+  const sseResult = await withOpenCodeDiagnostics(
+    "event-stream-connect",
+    { port, sessionId },
+    () => client.global.event({
+      signal: eventsController.signal
+    })
+  );
+  recordTiming(timings, onProgress, "event-stream", "OpenCode event stream connection", eventStart);
+  const responsePromise = handledAwaitable(
+    new Promise((resolve2, reject) => {
+      const assistantMessageIds = /* @__PURE__ */ new Set();
+      const textPartsByMessageId = /* @__PURE__ */ new Map();
+      const settlement = createReviewSettlementCoordinator({
+        timeoutMs: config.timeout * 1e3,
+        reconcile: () => reconcileSessionMessages(client, directoryOptions, sessionId),
+        onAbort: () => eventsController.abort(),
+        onText: (text) => {
+          fullResponse = text;
+          onProgress?.({
+            type: "output",
+            message: `Review response received (${fullResponse.length} chars).`,
+            characters: fullResponse.length
+          });
+        },
+        resolve: resolve2,
+        reject
+      });
+      (async () => {
+        try {
+          for await (const event of sseResult.stream) {
+            if (settlement.isSettled()) break;
+            const payload = extractEventPayload(event);
+            if (!payload) continue;
+            const permission = extractPermissionRequest(payload, sessionId);
+            if (permission) {
+              void replyToPermissionRequest(client, permission, onProgress).catch((err) => {
+                onProgress?.({
+                  type: "session",
+                  message: `OpenCode permission reply failed: ${err instanceof Error ? err.message : String(err)}`,
+                  sessionId
+                });
+              });
+              continue;
+            }
+            const sessionError = extractSessionError(payload, sessionId);
+            if (sessionError) {
+              settlement.reject(sessionError);
+              break;
+            }
+            if (payload.type === "message.part.updated" && payload.properties?.part?.sessionID === sessionId) {
+              const part = payload.properties.part;
+              if (part.type === "tool" && typeof part.tool === "string") {
+                const state = typeof part.state?.status === "string" ? part.state.status : "unknown";
+                const title = typeof part.state?.title === "string" ? part.state.title : part.tool;
+                onProgress?.({
+                  type: "tool",
+                  message: `${title} (${state})`,
+                  tool: part.tool,
+                  status: state
+                });
+              }
+              if (part.type === "text" && typeof part.messageID === "string" && typeof part.text === "string" && part.text) {
+                textPartsByMessageId.set(part.messageID, part.text);
+                if (assistantMessageIds.has(part.messageID) && settlement.acceptText(part.text)) {
+                  break;
+                }
+              }
+            }
+            if (payload.type === "message.updated" && payload.properties?.info?.sessionID === sessionId) {
+              const msg = payload.properties?.info;
+              if (msg?.role === "assistant" && typeof msg.id === "string") {
+                assistantMessageIds.add(msg.id);
+                const text = textPartsByMessageId.get(msg.id);
+                if (text && settlement.acceptText(text)) {
+                  break;
+                }
+                if (msg.error) {
+                  const message = typeof msg.error.data?.message === "string" ? msg.error.data.message : "Review failed";
+                  settlement.reject(new Error(message));
+                  break;
+                }
+              }
+            }
+            if (payload.type === "session.status" && payload.properties?.sessionID === sessionId) {
+              const status = payload.properties.status;
+              if (!status || typeof status.type !== "string") continue;
+              const message = status.type === "retry" ? `OpenCode retrying: ${typeof status.message === "string" ? status.message : "unknown error"}` : `OpenCode session ${status.type}.`;
+              onProgress?.({ type: "session", message, sessionId });
+            }
+            if (payload.type === "session.idle" && payload.properties?.sessionID === sessionId && fullResponse.length > 0) {
+              onProgress?.({ type: "idle", message: "OpenCode session is idle." });
+              settlement.finish();
+              break;
+            }
+          }
+          if (!settlement.isSettled()) {
+            settlement.finish();
+          }
+        } catch (streamErr) {
+          if (!settlement.isSettled() && !eventsController.signal.aborted) {
+            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
+  };
+}
+function extractSessionError(payload, sessionId) {
+  if (!payload || typeof payload !== "object") return void 0;
+  const event = payload;
+  if (event.type !== "session.error" || event.properties?.sessionID !== sessionId) {
+    return void 0;
+  }
+  return new Error(`OpenCode session failed: ${describeSessionError(event.properties.error)}`);
+}
+function extractSessionMessageResult(response) {
+  if (!response || typeof response !== "object") return void 0;
+  const data = response.data;
+  if (!Array.isArray(data)) return void 0;
+  for (let index = data.length - 1; index >= 0; index--) {
+    const message = data[index];
+    if (!message || typeof message !== "object") continue;
+    const info = message.info;
+    if (!info || typeof info !== "object" || info.role !== "assistant") {
+      continue;
+    }
+    const error = info.error;
+    if (error) {
+      return { error: new Error(`OpenCode session failed: ${describeSessionError(error)}`) };
+    }
+    const parts = message.parts;
+    if (!Array.isArray(parts)) continue;
+    const text = parts.filter(
+      (part) => Boolean(
+        part && typeof part === "object" && part.type === "text" && typeof part.text === "string"
+      )
+    ).map((part) => part.text).join("");
+    if (text) return { text };
+  }
+  return void 0;
+}
+async function reconcileSessionMessages(client, directoryOptions, sessionId) {
+  try {
+    const response = await Promise.race([
+      client.session.messages({
+        path: { id: sessionId },
+        ...directoryOptions,
+        query: { ...directoryOptions.query, limit: 10 }
+      }),
+      new Promise((_, reject) => {
+        setTimeout(() => reject(new Error("Session reconciliation timed out.")), 2e3);
+      })
+    ]);
+    return extractSessionMessageResult(response);
+  } catch (error) {
+    return {
+      reconciliationError: error instanceof Error ? error : new Error(`Session reconciliation failed: ${String(error)}`)
+    };
+  }
+}
+function describeSessionError(error) {
+  if (typeof error === "string" && error.trim() !== "") return error;
+  if (!error || typeof error !== "object") return "unknown session error";
+  const value = error;
+  if (typeof value.data?.message === "string" && value.data.message.trim() !== "") {
+    return value.data.message;
+  }
+  if (typeof value.message === "string" && value.message.trim() !== "") {
+    return value.message;
+  }
+  if (typeof value.name === "string" && value.name.trim() !== "") {
+    return value.name;
+  }
+  return "unknown session error";
+}
+async function resolveReasoningVariant(client, providerID, modelID, effort) {
+  if (effort === "auto") {
+    return { diagnostics: [] };
+  }
+  const variant = effort;
+  const model = await getProviderModelMetadata(client, providerID, modelID);
+  if (!model) {
+    return { variant, diagnostics: [] };
+  }
+  if (model.reasoning === false) {
+    return {
+      diagnostics: [
+        `Reasoning variant "${variant}" was requested, but ${providerID}/${modelID} does not advertise reasoning support; continuing with provider default.`
+      ]
+    };
+  }
+  if (model.variants && !model.variants.has(variant)) {
+    return {
+      diagnostics: [
+        `Reasoning variant "${variant}" was requested, but ${providerID}/${modelID} does not advertise that variant; continuing with provider default.`
+      ]
+    };
+  }
+  return { variant, diagnostics: [] };
+}
+async function getProviderModelMetadata(client, providerID, modelID) {
+  try {
+    const providerList = client.provider?.list;
+    if (!providerList) {
+      return void 0;
+    }
+    const payload = parseProviderPayload(await providerList());
+    if (!payload) return void 0;
+    const provider = payload.all.find((item) => item.id === providerID);
+    const models = provider?.models;
+    if (!models) return void 0;
+    for (const model of Object.values(models)) {
+      if (model.id !== modelID) continue;
+      const reasoning = model.capabilities?.reasoning ?? model.reasoning;
+      const variants = model.variants ? new Set(Object.keys(model.variants)) : void 0;
+      return {
+        ...reasoning !== void 0 ? { reasoning } : {},
+        ...variants ? { variants } : {}
+      };
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function withOpenCodeDiagnostics(phase, context, run) {
+  try {
+    return await run();
+  } catch (err) {
+    throw describeOpenCodeError(err, phase, context);
+  }
+}
+function describeOpenCodeError(err, phase, context) {
+  const original = err instanceof Error ? err : new Error(String(err));
+  const cause = describeErrorCause(original);
+  const details = [
+    `phase=${phase}`,
+    `server=http://127.0.0.1:${context.port}`,
+    ...context.sessionId ? [`session=${context.sessionId}`] : [],
+    `cause=${cause}`
+  ];
+  const message = `OpenCode request failed (${details.join(", ")}).`;
+  return new Error(message, { cause: original });
+}
+function describeErrorCause(err) {
+  const parts = [err.name, err.message].filter(Boolean);
+  const cause = err.cause;
+  if (cause instanceof Error) {
+    parts.push(`cause=${cause.name}: ${cause.message}`);
+  } else if (cause) {
+    parts.push(`cause=${String(cause)}`);
+  }
+  return parts.join(": ") || "unknown error";
+}
+function opencodeDirectoryOptions() {
+  return { query: { directory: process.cwd() } };
+}
+function handledAwaitable(promise) {
+  promise.catch(() => {
+  });
+  return promise;
+}
+function extractSessionId(response) {
+  if (!response || typeof response !== "object") {
+    throw new Error("OpenCode session response missing id.");
+  }
+  const data = response.data;
+  if (!data || typeof data !== "object") {
+    throw new Error("OpenCode session response missing id.");
+  }
+  const id = data.id;
+  if (typeof id !== "string" || id.trim() === "") {
+    throw new Error("OpenCode session response missing id.");
+  }
+  return id;
+}
+function recordTiming(timings, onProgress, phase, label, start) {
+  const ms = performance.now() - start;
+  timings.push({ phase, label, ms });
+  onProgress?.({ type: "timing", message: `${label}: ${formatDuration(ms)}`, phase, ms });
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+
+// src/opencode/guidance.ts
+function getOpenCodeFailureGuidance(message) {
+  const normalized = message.toLowerCase();
+  if (normalized.includes("opencode not found") || normalized.includes("opencode: command not found") || normalized.includes("enoent") && normalized.includes("opencode")) {
+    return [
+      "Install OpenCode: npm install --global opencode-ai",
+      "Run `opencode`, connect a provider, then retry the DiffOwl command.",
+      "Docs: https://opencode.ai/docs/"
+    ];
+  }
+  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 [
+      "Run `opencode` and connect or re-authenticate a provider.",
+      "Confirm a model is available, then retry the DiffOwl command."
+    ];
+  }
+  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 (normalized.includes("timed out") || normalized.includes("timeout")) {
+    return ["Retry with less context: diffowl review --depth shallow"];
+  }
+  return [];
+}
+
+// src/opencode/model-selection.ts
+function canSelectModelInteractively(inputIsTTY, outputIsTTY) {
+  return inputIsTTY === true && outputIsTTY === true;
+}
+function selectModel(models, currentModel, answer, allowKeepCurrent) {
+  const trimmed = answer.trim();
+  if (trimmed === "") {
+    if (allowKeepCurrent) return { type: "kept", model: currentModel };
+    if (models.length === 0) return { type: "invalid" };
+    return { type: "selected", model: models[0] };
+  }
+  if (!/^\d+$/.test(trimmed)) return { type: "invalid" };
+  const selection = Number.parseInt(trimmed, 10);
+  if (!Number.isInteger(selection) || selection < 1 || selection > models.length) {
+    return { type: "invalid" };
+  }
+  return { type: "selected", model: models[selection - 1] };
+}
+
+// src/git/hooks.ts
+import { appendFile, chmod, mkdir as mkdir2, readFile as readFile4, readdir, unlink as unlink2, writeFile as writeFile4 } from "fs/promises";
+import {
+  closeSync,
+  existsSync as existsSync3,
+  openSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+  writeSync
+} from "fs";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath } from "url";
+import { execa as execa2 } from "execa";
+import { z as z4 } from "zod";
+
+// src/review/retention.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+async function trimHookLog(logFile, maxBytes) {
+  if (maxBytes === 0) return;
+  try {
+    const content = await readFile3(logFile);
+    if (content.length <= maxBytes) return;
+    await writeFile3(logFile, content.subarray(content.length - maxBytes));
+  } catch {
+  }
+}
+
+// src/git/hooks.ts
+var HOOK_MARKER = "# diffowl-managed";
+var HOOK_END_MARKER = "# end-diffowl";
+var HOOK_SHEBANG = "#!/bin/sh";
+function loggedStdio(outFd) {
+  return ["ignore", outFd, outFd];
+}
+async function getHooksDir() {
+  const { stdout } = await execa2("git", ["rev-parse", "--git-dir"]);
+  return join3(stdout.trim(), "hooks");
+}
+async function installHook() {
+  const hooksDir = await getHooksDir();
+  const hookPath = join3(hooksDir, "post-commit");
+  const command = await resolveHookCommand();
+  if (existsSync3(hookPath)) {
+    const existing = await readFile4(hookPath, "utf-8");
+    const base = existing.includes(HOOK_MARKER) || existing.includes("# commitdog-managed") ? removeManagedSection(existing) : existing.trimEnd();
+    const hookSection = generateManagedSection(command);
+    const updated = base && !isOnlyShebangs(base) ? `${base}
+
+${hookSection}` : generateHookScript(command);
+    await writeFile4(hookPath, updated, "utf-8");
+  } else {
+    await writeFile4(hookPath, generateHookScript(command), "utf-8");
+  }
+  await chmod(hookPath, 493);
+  return hookPath;
+}
+async function uninstallHook() {
+  const hooksDir = await getHooksDir();
+  const hookPath = join3(hooksDir, "post-commit");
+  if (!existsSync3(hookPath)) return false;
+  const content = await readFile4(hookPath, "utf-8");
+  if (!content.includes(HOOK_MARKER) && !content.includes("# commitdog-managed")) return false;
+  const cleaned = removeManagedSection(content);
+  if (isOnlyShebangs(cleaned) || cleaned === "") {
+    await unlink2(hookPath);
+  } else {
+    await writeFile4(hookPath, cleaned + "\n", "utf-8");
+  }
+  return true;
+}
+async function isHookInstalled() {
+  const hooksDir = await getHooksDir();
+  const hookPath = join3(hooksDir, "post-commit");
+  if (!existsSync3(hookPath)) return false;
+  const content = await readFile4(hookPath, "utf-8");
+  return content.includes(HOOK_MARKER);
+}
+var HookFailureSchema = z4.object({
+  commit: z4.string().min(1).optional(),
+  exitCode: z4.number().int(),
+  timestamp: z4.string(),
+  message: z4.string().optional()
+});
+async function checkRecentHookFailure() {
+  const statusPath = join3(getDiffOwlDir(), "last-hook-status.json");
+  if (!existsSync3(statusPath)) {
+    return void 0;
+  }
+  try {
+    const raw = await readFile4(statusPath, "utf-8");
+    const parsed = HookFailureSchema.safeParse(JSON.parse(raw));
+    if (!parsed.success) return void 0;
+    const { commit, exitCode, timestamp, message } = parsed.data;
+    if (exitCode === 0) {
+      return void 0;
+    }
+    const failureTime = new Date(timestamp).getTime();
+    const oneHourAgo = Date.now() - 60 * 60 * 1e3;
+    if (Number.isNaN(failureTime) || failureTime < oneHourAgo) {
+      return void 0;
+    }
+    return {
+      ...commit ? { commit } : {},
+      exitCode,
+      timestamp,
+      ...message ? { message } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function formatHookFailure(failure) {
+  const detail = failure.message ? `: ${failure.message}` : "";
+  const header = `Post-commit hook failed at ${new Date(failure.timestamp).toLocaleString()}${detail}. Check .diffowl/hook.log`;
+  if (!failure.commit) return header;
+  return `${header}
+Retry:
+  diffowl review --commit ${failure.commit}
+  diffowl review --commit ${failure.commit} --depth shallow`;
+}
+async function runHookReview() {
+  const dir = await ensureDiffOwlDir();
+  const logFile = join3(dir, "hook.log");
+  const latestReport = join3(dir, "reviews", "latest.md");
+  const lockFile = join3(dir, "hook-review.lock");
+  const commit = await getHeadCommit();
+  await enqueuePendingReview(dir, commit);
+  if (!acquireHookReviewLock(lockFile)) {
+    console.log(`diffowl: review queued for ${commit}; another hook review is already running`);
+    return;
+  }
+  const config = await loadConfig();
+  await trimHookLog(logFile, config.retention.hook_log_kb * 1024);
+  const outFd = openSync(logFile, "a");
+  try {
+    writeSync(
+      outFd,
+      `diffowl: review worker started at ${(/* @__PURE__ */ new Date()).toString()}; latest report: ${latestReport}
+`
+    );
+    const command = await resolveHookCommand();
+    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"], {
+      detached: true,
+      cleanup: false,
+      cwd: process.cwd(),
+      stdio: loggedStdio(outFd),
+      env: {
+        ...process.env,
+        PATH: envPath,
+        DIFFOWL_HOOK_LOCK: lockFile
+      }
+    });
+    void subprocess.catch(() => {
+    });
+    if (subprocess.pid) {
+      writeFileSync(lockFile, String(subprocess.pid), "utf-8");
+    }
+    subprocess.unref();
+    console.log(
+      `diffowl: review queued for ${commit}; worker started in background; log: ${logFile}; latest report: ${latestReport}`
+    );
+  } catch (err) {
+    releaseHookReviewLock(lockFile);
+    throw err;
+  } finally {
+    closeSync(outFd);
+  }
+}
+async function runPendingHookReviews() {
+  const dir = await ensureDiffOwlDir();
+  const logFile = join3(dir, "hook.log");
+  const cli = fileURLToPath(import.meta.url);
+  const attempted = /* @__PURE__ */ new Set();
+  while (true) {
+    const pending = await listPendingReviews(dir);
+    const next = pending.find((item) => !attempted.has(item.sha));
+    if (!next) return;
+    attempted.add(next.sha);
+    const outFd = openSync(logFile, "a");
+    const resultPath = join3(dir, "pending-reviews", `${next.sha}.result.json`);
+    try {
+      writeSync(outFd, `diffowl: reviewing queued commit ${next.sha}
+`);
+      try {
+        await unlink2(resultPath);
+      } catch {
+      }
+      const env = { ...process.env };
+      delete env["DIFFOWL_HOOK_LOCK"];
+      env["DIFFOWL_HOOK_RESULT"] = resultPath;
+      try {
+        await execa2(process.execPath, [cli, "review", "--hook", "--commit", next.sha], {
+          cwd: process.cwd(),
+          stdio: loggedStdio(outFd),
+          env
+        });
+      } catch (error) {
+        writeSync(
+          outFd,
+          `diffowl: queued review ${next.sha} failed to run: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+        continue;
+      }
+    } finally {
+      closeSync(outFd);
+    }
+    const status = await readHookResult(resultPath);
+    if (status?.exitCode !== 0 || status.message) {
+      continue;
+    }
+    try {
+      await unlink2(next.path);
+    } catch (error) {
+      await appendFile(
+        logFile,
+        `diffowl: failed to remove pending marker for ${next.sha}: ${error instanceof Error ? error.message : String(error)}
+`,
+        "utf-8"
+      ).catch(() => {
+      });
+      continue;
+    }
+    try {
+      await unlink2(resultPath);
+    } catch {
+    }
+  }
+}
+async function enqueuePendingReview(dir, sha) {
+  const pendingDir = join3(dir, "pending-reviews");
+  await mkdir2(pendingDir, { recursive: true });
+  const marker = join3(pendingDir, sha);
+  if (existsSync3(marker)) return;
+  await writeFile4(
+    marker,
+    JSON.stringify({ sha, queuedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    "utf-8"
+  );
+}
+async function listPendingReviews(dir) {
+  const pendingDir = join3(dir, "pending-reviews");
+  let files;
+  try {
+    files = await readdir(pendingDir);
+  } catch {
+    return [];
+  }
+  const markerFiles = new Set(files.filter((file) => !file.endsWith(".result.json")));
+  await Promise.all(
+    files.filter((file) => file.endsWith(".result.json")).filter((file) => !markerFiles.has(file.slice(0, -".result.json".length))).map((file) => unlink2(join3(pendingDir, file)).catch(() => {
+    }))
+  );
+  const pending = await Promise.all(
+    [...markerFiles].map(async (file) => {
+      const path = join3(pendingDir, file);
+      try {
+        const parsed = JSON.parse(await readFile4(path, "utf-8"));
+        if (typeof parsed.sha !== "string" || typeof parsed.queuedAt !== "string") {
+          return void 0;
+        }
+        return { sha: parsed.sha, queuedAt: parsed.queuedAt, path };
+      } catch {
+        return void 0;
+      }
+    })
+  );
+  return pending.filter((item) => item !== void 0).sort((a, b) => a.queuedAt.localeCompare(b.queuedAt));
+}
+async function getHeadCommit() {
+  const { stdout } = await execa2("git", ["rev-parse", "--verify", "HEAD"]);
+  return stdout.trim();
+}
+async function readHookResult(path) {
+  try {
+    const parsed = HookFailureSchema.safeParse(JSON.parse(await readFile4(path, "utf-8")));
+    if (!parsed.success) return void 0;
+    return {
+      ...parsed.data.commit ? { commit: parsed.data.commit } : {},
+      exitCode: parsed.data.exitCode,
+      timestamp: parsed.data.timestamp,
+      ...parsed.data.message ? { message: parsed.data.message } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function acquireHookReviewLock(lockFile) {
+  try {
+    const fd = openSync(lockFile, "wx");
+    try {
+      writeSync(fd, String(process.pid));
+    } finally {
+      closeSync(fd);
+    }
+    return true;
+  } catch {
+    if (isHookReviewLockActive(lockFile)) return false;
+    releaseHookReviewLock(lockFile);
+    try {
+      const fd = openSync(lockFile, "wx");
+      try {
+        writeSync(fd, String(process.pid));
+      } finally {
+        closeSync(fd);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function releaseHookReviewLock(lockFile) {
+  try {
+    unlinkSync(lockFile);
+  } catch {
+  }
+}
+function isHookReviewLockActive(lockFile) {
+  try {
+    const pid = Number.parseInt(readFileSync(lockFile, "utf-8"), 10);
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkHookStale() {
+  let hooksDir;
+  try {
+    hooksDir = await getHooksDir();
+  } catch {
+    return { installed: false, stale: false, reason: "Not a git repository" };
+  }
+  const hookPath = join3(hooksDir, "post-commit");
+  if (!existsSync3(hookPath)) {
+    return { installed: false, stale: false, reason: "No post-commit hook found" };
+  }
+  let content;
+  try {
+    content = await readFile4(hookPath, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { installed: true, stale: false, reason: `Cannot read hook file: ${message}` };
+  }
+  if (!content.includes(HOOK_MARKER)) {
+    return { installed: false, stale: false, reason: "Hook exists but is not diffowl-managed" };
+  }
+  let command;
+  try {
+    command = await resolveHookCommand();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { installed: true, stale: false, reason: `Cannot resolve diffowl command: ${message}` };
+  }
+  const expected = generateManagedSection(command);
+  const actual = extractManagedSection(content);
+  if (!actual) {
+    return { installed: true, stale: true, reason: "Could not extract managed section" };
+  }
+  if (actual.trim() !== expected.trim()) {
+    return {
+      installed: true,
+      stale: true,
+      reason: "Managed section differs from current generator"
+    };
+  }
+  return { installed: true, stale: false };
+}
+function extractManagedSection(content) {
+  const lines = content.split("\n");
+  const ourStart = lines.findIndex((line) => line.includes(HOOK_MARKER));
+  if (ourStart === -1) return void 0;
+  const ourEnd = lines.findIndex(
+    (line, index) => index > ourStart && line.includes(HOOK_END_MARKER)
+  );
+  if (ourEnd === -1) return void 0;
+  return lines.slice(ourStart, ourEnd + 1).join("\n");
+}
+async function resolveHookCommand() {
+  const diffowl = await resolveCommand("diffowl");
+  const opencode = await resolveCommand("opencode");
+  const node = process.execPath;
+  return {
+    diffowl,
+    node,
+    cli: fileURLToPath(import.meta.url),
+    pathDirs: uniqueDirs([node, diffowl, opencode])
+  };
+}
+function uniqueDirs(paths) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    if (path.includes("/") || path.includes("\\")) {
+      dirs.add(dirname2(path));
+    }
+  }
+  return [...dirs];
+}
+async function resolveCommand(command) {
+  const isWin = process.platform === "win32";
+  try {
+    if (isWin) {
+      const { stdout } = await execa2("where", [command]);
+      const lines = stdout.trim().split("\r\n").map((l) => l.trim()).filter(Boolean);
+      return lines[0] || command;
+    } else {
+      const { stdout } = await execa2("which", [command]);
+      return stdout.trim() || command;
+    }
+  } catch {
+    return command;
+  }
+}
+function removeManagedSection(content) {
+  let lines = content.split("\n");
+  lines = removeSectionByMarkers(lines, "# diffowl-managed", "# end-diffowl");
+  lines = removeSectionByMarkers(lines, "# commitdog-managed", "# end-commitdog");
+  return lines.join("\n").trim();
+}
+function removeSectionByMarkers(lines, startMarker, endMarker) {
+  const start = lines.findIndex((line) => line.includes(startMarker));
+  if (start === -1) return lines;
+  const end = lines.findIndex((line, index) => index > start && line.includes(endMarker));
+  const endIndex = end === -1 ? start : end;
+  return [...lines.slice(0, start), ...lines.slice(endIndex + 1)];
+}
+function isOnlyShebangs(content) {
+  const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
+  return lines.length > 0 && lines.every((line) => line === HOOK_SHEBANG);
+}
+function generateHookScript(command) {
+  return `${HOOK_SHEBANG}
+${generateManagedSection(command)}`;
+}
+function generateManagedSection(command) {
+  const isPath = command.diffowl.includes("/") || command.diffowl.includes("\\");
+  const quotedDiffOwl = shellQuote(command.diffowl);
+  const quotedNode = shellQuote(command.node);
+  const quotedCli = shellQuote(command.cli);
+  const pathPrefix = command.pathDirs.length ? command.pathDirs.join(":") : void 0;
+  const diffowlPathFallback = isPath ? `elif [ -x ${quotedDiffOwl} ]; then
+  ${quotedDiffOwl} hook-run
+` : "";
+  const runBlock = `if [ -x ${quotedNode} ] && [ -f ${quotedCli} ]; then
+  ${quotedNode} ${quotedCli} hook-run
+${diffowlPathFallback}elif command -v diffowl >/dev/null 2>&1; then
+  diffowl hook-run
+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`;
+  return `${HOOK_MARKER}
+# Run diffowl review in the background (non-blocking)
+DIFFOWL_SEARCH_DIR="$PWD"
+while [ "$DIFFOWL_SEARCH_DIR" != "/" ] && [ ! -f "$DIFFOWL_SEARCH_DIR/.diffowl.yml" ]; do
+  DIFFOWL_SEARCH_DIR=$(dirname "$DIFFOWL_SEARCH_DIR")
+done
+if [ -f "$DIFFOWL_SEARCH_DIR/.diffowl.yml" ]; then
+  DIFFOWL_LOG_DIR="$DIFFOWL_SEARCH_DIR/.diffowl"
+else
+  DIFFOWL_LOG_DIR=".diffowl"
+fi
+DIFFOWL_LOG_FILE="$DIFFOWL_LOG_DIR/hook.log"
+mkdir -p "$DIFFOWL_LOG_DIR"
+${pathPrefix ? `PATH=${shellQuote(pathPrefix)}":$PATH"
+export PATH
+` : ""}
+
+${runBlock}
+${HOOK_END_MARKER}
+`;
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// src/git/diff.ts
+import { execa as execa3 } from "execa";
+import { basename } from "path";
+var MAX_DIFF_OUTPUT_BYTES = 2 * 1024 * 1024;
+async function getLastCommitDiff() {
+  return getCommitDiff("HEAD");
+}
+async function getCommitDiff(ref) {
+  const commit = await resolveCommitRef(ref);
+  const raw = await collectGitDiff([
+    "-c",
+    "diff.noprefix=false",
+    "-c",
+    "diff.mnemonicprefix=false",
+    "show",
+    "--format=",
+    "--stat",
+    "--patch",
+    commit
+  ]);
+  return parseDiff(raw.stdout, raw.diagnostics);
+}
+async function resolveCommitRef(ref) {
+  const trimmed = ref.trim();
+  if (trimmed === "") {
+    throw new Error("Commit ref must not be empty.");
+  }
+  try {
+    const { stdout } = await execa3("git", [
+      "rev-parse",
+      "--verify",
+      "--quiet",
+      "--end-of-options",
+      `${trimmed}^{commit}`
+    ]);
+    return stdout.trim();
+  } catch {
+    throw new Error(`Invalid commit ref: ${ref}`);
+  }
+}
+async function getStagedDiff() {
+  const raw = await collectGitDiff([
+    "-c",
+    "diff.noprefix=false",
+    "-c",
+    "diff.mnemonicprefix=false",
+    "diff",
+    "--staged",
+    "--stat",
+    "--patch"
+  ]);
+  return parseDiff(raw.stdout, raw.diagnostics);
+}
+async function collectGitDiff(args) {
+  try {
+    const { stdout } = await execa3("git", args, { maxBuffer: MAX_DIFF_OUTPUT_BYTES });
+    return { stdout, diagnostics: [] };
+  } catch (err) {
+    if (isMaxBufferError(err)) {
+      return {
+        stdout: err.stdout,
+        diagnostics: [
+          `Git diff output exceeded ${formatBytes(MAX_DIFF_OUTPUT_BYTES)}; review context includes the truncated output captured before the limit.`
+        ]
+      };
+    }
+    throw err;
+  }
+}
+async function isGitRepo() {
+  try {
+    await execa3("git", ["rev-parse", "--is-inside-work-tree"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasCommits() {
+  try {
+    await execa3("git", ["rev-parse", "HEAD"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseDiff(raw, diagnostics = []) {
+  const files = [];
+  const lines = raw.split(/\r?\n/).map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+  for (const line of lines) {
+    const gitDiffPaths = parseGitDiffLine(line);
+    if (gitDiffPaths) {
+      files.push({
+        path: gitDiffPaths.pathB,
+        status: "modified",
+        additions: 0,
+        deletions: 0
+      });
+      continue;
+    }
+    const combinedPath = parseCombinedDiffLine(line);
+    if (combinedPath) {
+      files.push({
+        path: combinedPath,
+        status: "modified",
+        additions: 0,
+        deletions: 0
+      });
+      continue;
+    }
+    const lastFile = files[files.length - 1];
+    if (lastFile) {
+      if (line.startsWith("rename to ")) {
+        const target = unescapePath(line.slice("rename to ".length));
+        lastFile.path = target;
+        lastFile.status = "renamed";
+        continue;
+      }
+      if (line === "--- /dev/null") {
+        lastFile.status = "added";
+        continue;
+      }
+      if (line === "+++ /dev/null") {
+        lastFile.status = "deleted";
+        continue;
+      }
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        lastFile.additions++;
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        lastFile.deletions++;
+      }
+    }
+  }
+  const summary = files.map((f) => `${statusSymbol(f.status)} ${f.path} (+${f.additions}/-${f.deletions})`).join("\n");
+  return { files, raw, summary, ...diagnostics.length > 0 ? { diagnostics } : {} };
+}
+function isMaxBufferError(err) {
+  return err !== null && typeof err === "object" && err.isMaxBuffer === true && "stdout" in err && typeof err.stdout === "string";
+}
+function formatBytes(bytes) {
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${Math.round(bytes / (1024 * 1024) * 10) / 10} MB`;
+}
+function parseGitDiffLine(line) {
+  const cleanLine = line.endsWith("\r") ? line.slice(0, -1) : line;
+  if (!cleanLine.startsWith("diff --git ")) return null;
+  const content = cleanLine.slice("diff --git ".length);
+  const paths = [];
+  let i = 0;
+  while (i < content.length && paths.length < 2) {
+    while (i < content.length && content[i] === " ") {
+      i++;
+    }
+    if (i >= content.length) break;
+    if (content[i] === '"') {
+      i++;
+      let path = "";
+      while (i < content.length) {
+        if (content[i] === '"') {
+          i++;
+          break;
+        }
+        if (content[i] === "\\" && i + 1 < content.length) {
+          path += content[i + 1] ?? "";
+          i += 2;
+        } else {
+          path += content[i] ?? "";
+          i++;
+        }
+      }
+      paths.push(path);
+    } else {
+      let start = i;
+      while (i < content.length && content[i] !== " ") {
+        i++;
+      }
+      paths.push(content.slice(start, i));
+    }
+  }
+  if (paths.length !== 2) return null;
+  let pathA = paths[0] ?? "";
+  let pathB = paths[1] ?? "";
+  const matchA = pathA.match(/^([abciow])\//);
+  const matchB = pathB.match(/^([abciow])\//);
+  if (matchA && matchB && matchA[1] !== matchB[1]) {
+    pathA = pathA.slice(2);
+    pathB = pathB.slice(2);
+  } else if (pathA.startsWith("a/") && pathB.startsWith("b/")) {
+    pathA = pathA.slice(2);
+    pathB = pathB.slice(2);
+  }
+  return { pathA, pathB };
+}
+function parseCombinedDiffLine(line) {
+  const cleanLine = line.endsWith("\r") ? line.slice(0, -1) : line;
+  let content = "";
+  if (cleanLine.startsWith("diff --cc ")) {
+    content = cleanLine.slice("diff --cc ".length);
+  } else if (cleanLine.startsWith("diff --combined ")) {
+    content = cleanLine.slice("diff --combined ".length);
+  } else {
+    return null;
+  }
+  return unescapePath(content);
+}
+function unescapePath(content) {
+  if (content.startsWith('"') && content.endsWith('"')) {
+    let path = "";
+    let i = 1;
+    while (i < content.length - 1) {
+      if (content[i] === "\\" && i + 1 < content.length - 1) {
+        path += content[i + 1] ?? "";
+        i += 2;
+      } else {
+        path += content[i] ?? "";
+        i++;
+      }
+    }
+    return path;
+  }
+  return content;
+}
+function statusSymbol(status) {
+  switch (status) {
+    case "added":
+      return "+";
+    case "deleted":
+      return "-";
+    case "renamed":
+      return ">";
+    default:
+      return "~";
+  }
+}
+var DOC_FILE_PATTERNS = [
+  /\.md$/i,
+  /\.txt$/i,
+  /\.rst$/i,
+  /\.adoc$/i,
+  /^LICENSE/i,
+  /^CHANGELOG/i,
+  /^CONTRIBUTING/i,
+  /^README/i,
+  /^CODE_OF_CONDUCT/i,
+  /^AUTHORS/i,
+  /^COPYING/i,
+  /^PATENTS/i,
+  /^SECURITY/i,
+  /^PRIVACY/i,
+  /^FAQ/i,
+  /^TODO/i
+];
+function isDocFile(path) {
+  const base = basename(path);
+  return DOC_FILE_PATTERNS.some((pattern) => pattern.test(base));
+}
+function isDocOnlyDiff(diff) {
+  return diff.files.length > 0 && diff.files.every((file) => isDocFile(file.path));
+}
+
+// src/review/context.ts
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile6, stat as stat2 } from "fs/promises";
+import { basename as basename3, dirname as dirname3, extname as extname4, join as join5 } from "path";
+import picomatch from "picomatch";
+
+// src/review/ast/index.ts
+import { extname } from "path";
+
+// src/review/ast/typescript.ts
+import { createRequire } from "module";
+import { join as join4 } from "path";
+import { pathToFileURL } from "url";
+var MAX_AST_SYMBOL_CHARS = 8e3;
+var cachedTs = null;
+var typescriptAstParser = {
+  id: "typescript",
+  label: "TypeScript",
+  matchesPath(path) {
+    return path.endsWith(".ts") || path.endsWith(".tsx") || path.endsWith(".mts") || path.endsWith(".cts");
+  },
+  extract(input) {
+    return extractTypeScriptAstSymbols(input);
+  }
+};
+function tryLoadUserTypescript() {
+  if (cachedTs !== null) return cachedTs;
+  try {
+    const require2 = createRequire(pathToFileURL(join4(process.cwd(), "package.json")));
+    cachedTs = require2("typescript");
+  } catch {
+    try {
+      const fallbackRequire = createRequire(import.meta.url);
+      cachedTs = fallbackRequire("typescript");
+    } catch {
+      cachedTs = void 0;
+    }
+  }
+  return cachedTs;
+}
+function extractTypeScriptAstSymbols(input) {
+  if (input.changedLines.length === 0) {
+    return { symbols: [] };
+  }
+  const activeTs = tryLoadUserTypescript();
+  if (!activeTs) {
+    return {
+      symbols: [],
+      diagnostics: ["TypeScript AST unavailable; reviewing from diff and file context only."]
+    };
+  }
+  const sourceFile = activeTs.createSourceFile(
+    input.path,
+    input.content,
+    activeTs.ScriptTarget.Latest,
+    true
+  );
+  const changed = new Set(input.changedLines);
+  const symbols = [];
+  const visit = (node) => {
+    const namedNode = getNamedDeclarationNode(activeTs, node);
+    if (namedNode) {
+      const startLine = sourceFile.getLineAndCharacterOfPosition(namedNode.getStart(sourceFile)).line + 1;
+      const endLine = sourceFile.getLineAndCharacterOfPosition(namedNode.getEnd()).line + 1;
+      if (containsChangedLine(changed, startLine, endLine)) {
+        const text = truncateText(namedNode.getText(sourceFile), MAX_AST_SYMBOL_CHARS);
+        symbols.push({
+          name: getDeclarationName(activeTs, namedNode),
+          kind: getDeclarationKind(activeTs, namedNode),
+          startLine,
+          endLine,
+          text: text.text,
+          truncated: text.truncated
+        });
+      }
+    }
+    activeTs.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return { symbols: dedupeAstSymbols(symbols) };
+}
+function getNamedDeclarationNode(ts, node) {
+  if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isMethodDeclaration(node) || ts.isPropertyDeclaration(node)) {
+    return hasIdentifierName(ts, node) ? node : void 0;
+  }
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+    const statement = findAncestor(node, ts.isVariableStatement);
+    return statement && ts.isSourceFile(statement.parent) ? statement : void 0;
+  }
+  return void 0;
+}
+function hasIdentifierName(ts, node) {
+  const name = node.name;
+  return Boolean(name && ts.isIdentifier(name));
+}
+function findAncestor(node, predicate) {
+  let current = node.parent;
+  while (current) {
+    if (predicate(current)) return current;
+    current = current.parent;
+  }
+  return void 0;
+}
+function getDeclarationName(ts, node) {
+  if (ts.isVariableStatement(node)) {
+    return node.declarationList.declarations.map((declaration) => declaration.name.getText()).join(", ");
+  }
+  if (hasIdentifierName(ts, node)) {
+    return node.name.text;
+  }
+  return "<anonymous>";
+}
+function getDeclarationKind(ts, node) {
+  if (ts.isFunctionDeclaration(node)) return "function";
+  if (ts.isClassDeclaration(node)) return "class";
+  if (ts.isInterfaceDeclaration(node)) return "interface";
+  if (ts.isTypeAliasDeclaration(node)) return "type";
+  if (ts.isEnumDeclaration(node)) return "enum";
+  if (ts.isMethodDeclaration(node)) return "method";
+  if (ts.isPropertyDeclaration(node)) return "property";
+  if (ts.isVariableStatement(node)) {
+    const flags = node.declarationList.flags;
+    if (flags & ts.NodeFlags.Const) return "const";
+    if (flags & ts.NodeFlags.Let) return "let";
+    return "var";
+  }
+  return ts.SyntaxKind[node.kind] ?? "symbol";
+}
+function dedupeAstSymbols(symbols) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const symbol of symbols.sort((a, b) => a.startLine - b.startLine)) {
+    const key = `${symbol.kind}:${symbol.name}:${symbol.startLine}:${symbol.endLine}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(symbol);
+  }
+  return unique.slice(0, 20);
+}
+function containsChangedLine(changedLines, startLine, endLine) {
+  for (let line = startLine; line <= endLine; line++) {
+    if (changedLines.has(line)) return true;
+  }
+  return false;
+}
+function truncateText(text, maxChars) {
+  if (text.length <= maxChars) {
+    return { text, truncated: false };
+  }
+  return {
+    text: `${text.slice(0, maxChars)}
+... [truncated ${text.length - maxChars} chars]`,
+    truncated: true
+  };
+}
+
+// src/review/ast/index.ts
+var AST_PARSERS = [typescriptAstParser];
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".c",
+  ".cjs",
+  ".cc",
+  ".cpp",
+  ".cts",
+  ".cs",
+  ".go",
+  ".h",
+  ".hpp",
+  ".java",
+  ".js",
+  ".jsx",
+  ".kt",
+  ".mjs",
+  ".mts",
+  ".php",
+  ".py",
+  ".rb",
+  ".rs",
+  ".swift",
+  ".ts",
+  ".tsx"
+]);
+function extractAstSymbols(path, content, changedLines) {
+  if (changedLines.length === 0) {
+    return { symbols: [] };
+  }
+  const parser = AST_PARSERS.find((candidate) => candidate.matchesPath(path));
+  if (parser) {
+    return parser.extract({ path, content, changedLines });
+  }
+  if (isCodePath(path)) {
+    return {
+      symbols: [],
+      diagnostics: ["Reviewing from diff and file context only."]
+    };
+  }
+  return { symbols: [] };
+}
+function isCodePath(path) {
+  return CODE_EXTENSIONS.has(extname(path).toLowerCase());
+}
+
+// src/review/context-references.ts
+import { basename as basename2, extname as extname2 } from "path";
+import { readFile as readFile5, stat } from "fs/promises";
+import { execa as execa4 } from "execa";
+var MAX_REFERENCES_PER_TERM = 8;
+var MAX_REFERENCE_TERMS = 8;
+var MAX_REFERENCE_LINE_CHARS = 220;
+var MAX_BATCH_REFERENCE_MATCHES = 200;
+var REFERENCE_SEARCH_TIMEOUT_MS = 5e3;
+var REFERENCE_SNIPPET_RADIUS = 2;
+var MAX_REFERENCE_SNIPPET_CHARS = 1200;
+var MAX_REFERENCE_SNIPPET_FILE_BYTES = 256 * 1024;
+async function buildReferenceContexts(changedFiles, skippedFiles, diagnostics) {
+  const terms = /* @__PURE__ */ new Set();
+  const ignoredPaths = /* @__PURE__ */ new Set([
+    ...changedFiles.map((file) => file.file.path),
+    ...skippedFiles.map((file) => file.path)
+  ]);
+  for (const file of changedFiles) {
+    terms.add(basename2(file.file.path, extname2(file.file.path)));
+    for (const symbol of file.symbols.slice(0, 4)) {
+      terms.add(symbol);
+    }
+  }
+  const validTerms = [...terms].filter((value) => value.length >= 3).slice(0, MAX_REFERENCE_TERMS);
+  if (validTerms.length === 0) {
+    return [];
+  }
+  const allMatches = await findBatchReferences(validTerms, ignoredPaths, diagnostics);
+  const references = [];
+  for (const term of validTerms) {
+    const matches = await addReferenceSnippets(
+      allMatches.filter((match) => (match.fullText ?? match.text).includes(term)).slice(0, MAX_REFERENCES_PER_TERM)
+    );
+    if (matches.length > 0) {
+      references.push({ term, matches });
+    }
+  }
+  return references;
+}
+async function findBatchReferences(terms, ignoredPaths, diagnostics) {
+  let matches;
+  try {
+    matches = await findBatchReferencesWithGitGrep(terms, ignoredPaths);
+  } catch (err) {
+    diagnostics.push(`Reference search failed: ${formatReferenceSearchError(err)}.`);
+    return [];
+  }
+  if (matches.length > MAX_BATCH_REFERENCE_MATCHES) {
+    diagnostics.push(
+      `Reference search found ${matches.length} matches; only the first ${MAX_BATCH_REFERENCE_MATCHES} are included.`
+    );
+  }
+  return matches.slice(0, MAX_BATCH_REFERENCE_MATCHES);
+}
+function formatReferenceSearchError(err) {
+  if (err && typeof err === "object") {
+    const timedOut = "timedOut" in err && err.timedOut === true;
+    const duration = "durationMs" in err && typeof err.durationMs === "number" ? err.durationMs : 0;
+    if (timedOut) {
+      return duration > 0 ? `timed out after ${duration}ms` : "timed out";
+    }
+    if ("exitCode" in err && typeof err.exitCode === "number") {
+      return `exited with code ${err.exitCode}`;
+    }
+  }
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+async function findBatchReferencesWithGitGrep(terms, ignoredPaths) {
+  try {
+    const args = ["grep", "-n", "--fixed-strings"];
+    for (const term of terms) {
+      args.push("-e", term);
+    }
+    args.push("--");
+    const { stdout } = await execa4("git", args, { timeout: REFERENCE_SEARCH_TIMEOUT_MS });
+    return parseBatchReferenceLines(stdout, ignoredPaths);
+  } catch (err) {
+    if (isNoMatchesExit(err)) return [];
+    throw err;
+  }
+}
+function isNoMatchesExit(err) {
+  return typeof err === "object" && err !== null && "exitCode" in err && err.exitCode === 1;
+}
+function parseBatchReferenceLines(stdout, ignoredPaths) {
+  return stdout.split("\n").filter(Boolean).map(parseReferenceLine).filter((match) => Boolean(match)).filter((match) => !ignoredPaths.has(match.path));
+}
+function parseReferenceLine(line) {
+  const match = line.match(/^(.+?):(\d+):(.*)$/);
+  if (!match) return void 0;
+  return {
+    path: match[1],
+    line: Number(match[2]),
+    text: match[3].trim().slice(0, MAX_REFERENCE_LINE_CHARS),
+    fullText: match[3].trim()
+  };
+}
+async function addReferenceSnippets(matches) {
+  const files = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...new Set(matches.map((match) => match.path))].map(async (path) => {
+      try {
+        const info = await stat(path);
+        if (!info.isFile() || info.size > MAX_REFERENCE_SNIPPET_FILE_BYTES) {
+          return;
+        }
+        const content = await readFile5(path, "utf-8");
+        if (!content.includes("\0")) {
+          files.set(path, content.split("\n"));
+        }
+      } catch {
+      }
+    })
+  );
+  return matches.map((match) => {
+    const lines = files.get(match.path);
+    if (!lines) return match;
+    const start = Math.max(1, match.line - REFERENCE_SNIPPET_RADIUS);
+    const end = Math.min(lines.length, match.line + REFERENCE_SNIPPET_RADIUS);
+    const snippet = lines.slice(start - 1, end).map((line, index) => `${start + index}: ${line}`).join("\n");
+    return {
+      ...match,
+      snippet: truncateSnippet(snippet),
+      snippetStartLine: start,
+      snippetEndLine: end
+    };
+  });
+}
+function truncateSnippet(snippet) {
+  if (snippet.length <= MAX_REFERENCE_SNIPPET_CHARS) {
+    return snippet;
+  }
+  return `${snippet.slice(0, MAX_REFERENCE_SNIPPET_CHARS)}
+... [truncated]`;
+}
+
+// src/review/context-render.ts
+import { extname as extname3 } from "path";
+var MAX_DIFF_CHARS = 4e4;
+var MAX_AST_SYMBOL_CHARS2 = 8e3;
+var MAX_QUICK_DIFF_CHARS = 12e3;
+var MAX_QUICK_SYMBOL_CHARS = 4e3;
+var MAX_QUICK_FILE_CHARS = 4e3;
+function renderReviewContext(context, options = {}) {
+  const depth = options.depth ?? context.depth;
+  const shallow = depth === "shallow";
+  const lines = [];
+  lines.push("## Local Review Context");
+  lines.push("");
+  lines.push(`Mode: ${context.mode}`);
+  lines.push(`Review depth: ${depth}`);
+  lines.push("");
+  lines.push("### Changed Files");
+  lines.push(context.diff.summary || "No changed files detected.");
+  if (context.skippedFiles.length > 0) {
+    lines.push("");
+    lines.push("Skipped by include/exclude rules:");
+    lines.push(context.skippedFiles.map((file) => `- ${file.path}`).join("\n"));
+  }
+  if (context.diagnostics.length > 0) {
+    lines.push("");
+    lines.push("Context diagnostics:");
+    lines.push(context.diagnostics.map((diagnostic) => `- ${diagnostic}`).join("\n"));
+  }
+  lines.push("");
+  lines.push("### Diff");
+  lines.push(
+    fence(
+      truncateText2(
+        filterDiffRaw(
+          context.diff.raw,
+          new Set(context.changedFiles.map((fileContext) => fileContext.file.path))
+        ),
+        shallow ? MAX_QUICK_DIFF_CHARS : MAX_DIFF_CHARS
+      ).text,
+      "diff"
+    )
+  );
+  lines.push("");
+  for (const fileContext of context.changedFiles) {
+    lines.push(`### File Context: ${fileContext.file.path}`);
+    lines.push(
+      `Status: ${fileContext.file.status}; additions: ${fileContext.file.additions}; deletions: ${fileContext.file.deletions}`
+    );
+    if (fileContext.imports.length > 0) {
+      lines.push("");
+      lines.push("Imports:");
+      lines.push(fileContext.imports.map((line) => `- ${line}`).join("\n"));
+    }
+    if (fileContext.symbols.length > 0) {
+      lines.push("");
+      lines.push("Symbols:");
+      lines.push(fileContext.symbols.map((symbol) => `- ${symbol}`).join("\n"));
+    }
+    lines.push("");
+    if (fileContext.changedLines.length > 0) {
+      lines.push(`Changed lines: ${summarizeLines(fileContext.changedLines)}`);
+      lines.push("");
+    }
+    if (fileContext.astSymbols.length > 0) {
+      lines.push("Changed AST symbols:");
+      for (const symbol of shallow ? fileContext.astSymbols.slice(0, 5) : fileContext.astSymbols) {
+        lines.push(`#### ${symbol.kind} ${symbol.name} (${symbol.startLine}-${symbol.endLine})`);
+        lines.push(
+          fence(
+            truncateText2(symbol.text, shallow ? MAX_QUICK_SYMBOL_CHARS : MAX_AST_SYMBOL_CHARS2).text,
+            languageForPath(fileContext.file.path)
+          )
+        );
+        if (symbol.truncated) {
+          lines.push("_Symbol content truncated._");
+        }
+        lines.push("");
+      }
+    }
+    if (fileContext.content && fileContext.astSymbols.length === 0 && fileContext.shouldRenderContent) {
+      lines.push(
+        fence(
+          shallow ? truncateText2(fileContext.content, MAX_QUICK_FILE_CHARS).text : fileContext.content,
+          languageForPath(fileContext.file.path)
+        )
+      );
+      if (fileContext.truncated) {
+        lines.push("_File content truncated._");
+      }
+    } else if (fileContext.content && fileContext.astSymbols.length === 0) {
+      lines.push("_Full file content omitted because the diff already shows the changed hunks._");
+    } else if (fileContext.content) {
+      lines.push("_Full file content omitted because changed AST symbols are shown._");
+    } else {
+      lines.push(`_File content skipped: ${fileContext.skippedReason ?? "unavailable"}._`);
+    }
+    lines.push("");
+  }
+  if (!shallow && context.relatedFiles.length > 0) {
+    lines.push("### Related Test Files");
+    for (const related of context.relatedFiles) {
+      lines.push(`#### ${related.path}`);
+      lines.push(`Reason: ${related.reason}`);
+      lines.push(fence(related.content, languageForPath(related.path)));
+      if (related.truncated) {
+        lines.push("_File content truncated._");
+      }
+      lines.push("");
+    }
+  }
+  if (!shallow && context.references.length > 0) {
+    lines.push("### Potential Call Flow");
+    lines.push(
+      "These bounded snippets show where changed filenames or symbols are referenced. Use them to reason about callers, output paths, config wiring, tests, and user-visible behavior."
+    );
+    for (const reference of context.references) {
+      lines.push(`#### Term: ${reference.term}`);
+      for (const match of reference.matches) {
+        lines.push(`- ${match.path}:${match.line}: ${match.text}`);
+        if (match.snippet) {
+          lines.push(fence(match.snippet, languageForPath(match.path)));
+        }
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trim();
+}
+function filterDiffRaw(rawDiff, includedPaths) {
+  if (includedPaths.size === 0) {
+    return "No included file diffs.";
+  }
+  const lines = [];
+  let includeCurrentFile = false;
+  for (const line of rawDiff.split(/\r?\n/).map((l) => l.endsWith("\r") ? l.slice(0, -1) : l)) {
+    const gitDiffPaths = parseGitDiffLine(line);
+    if (gitDiffPaths) {
+      includeCurrentFile = includedPaths.has(gitDiffPaths.pathB);
+    }
+    if (includeCurrentFile) {
+      lines.push(line);
+    }
+  }
+  return lines.join("\n");
+}
+function summarizeLines(lines) {
+  const sortedLines = [...new Set(lines)].sort((a, b) => a - b);
+  const firstLine = sortedLines[0];
+  if (firstLine === void 0) {
+    return "";
+  }
+  const ranges = [];
+  let start = firstLine;
+  let previous = firstLine;
+  for (const line of sortedLines.slice(1)) {
+    if (line === previous + 1) {
+      previous = line;
+      continue;
+    }
+    ranges.push(formatLineRange(start, previous));
+    start = line;
+    previous = line;
+  }
+  ranges.push(formatLineRange(start, previous));
+  return ranges.join(", ");
+}
+function formatLineRange(start, end) {
+  return start === end ? String(start) : `${start}-${end}`;
+}
+function truncateText2(text, maxChars) {
+  if (text.length <= maxChars) {
+    return { text, truncated: false };
+  }
+  return {
+    text: `${text.slice(0, maxChars)}
+... [truncated ${text.length - maxChars} chars]`,
+    truncated: true
+  };
+}
+function fence(content, language = "") {
+  return `\`\`\`${language}
+${content.replaceAll("```", "'''")}
+\`\`\``;
+}
+function languageForPath(path) {
+  const ext = extname3(path).slice(1);
+  if (ext === "ts" || ext === "tsx") return "ts";
+  if (ext === "js" || ext === "jsx") return "js";
+  if (ext === "json") return "json";
+  if (ext === "md") return "md";
+  if (ext === "yml" || ext === "yaml") return "yaml";
+  return "";
+}
+
+// src/review/context.ts
+var MAX_FILE_CHARS = 12e3;
+var MAX_RELATED_FILE_CHARS = 6e3;
+var MAX_INLINE_FILE_CHARS = 2e3;
+var MAX_INLINE_FILE_LINES = 80;
+var MAX_CONTEXT_FILE_BYTES = 512 * 1024;
+var MIN_CHANGED_RATIO_FOR_INLINE_CONTENT = 0.4;
+var LOCKFILE_EXCLUDES = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"];
+async function buildReviewContext(mode, config, depth = config.context.depth, diff) {
+  const diffResult = diff ?? await loadDiffForMode(mode);
+  const reviewableFiles = diffResult.files.filter((file) => shouldReviewFile(file.path, config));
+  const skippedFiles = diffResult.files.filter((file) => !shouldReviewFile(file.path, config));
+  const changedLines = getChangedLinesByFile(diffResult.raw);
+  const changedFileResults = await Promise.all(
+    reviewableFiles.map((file) => buildChangedFileContext(file, changedLines.get(file.path) ?? []))
+  );
+  const changedFiles = changedFileResults.map((result) => result.fileContext);
+  const diagnostics = [...diffResult.diagnostics ?? []];
+  addUniqueDiagnostics(
+    diagnostics,
+    changedFileResults.flatMap((result) => result.diagnostics)
+  );
+  const relatedFiles = depth === "shallow" ? [] : await buildRelatedFileContexts(reviewableFiles);
+  const references = depth === "shallow" ? [] : await buildReferenceContexts(changedFiles, skippedFiles, diagnostics);
+  return {
+    mode,
+    depth,
+    diff: diffResult,
+    changedFiles,
+    skippedFiles,
+    relatedFiles,
+    references,
+    diagnostics
+  };
+}
+async function loadDiffForMode(mode) {
+  if (mode === "staged") {
+    return getStagedDiff();
+  }
+  if (mode === "commit") {
+    throw new Error("Commit review context requires an explicit diff.");
+  }
+  return getLastCommitDiff();
+}
+async function buildChangedFileContext(file, changedLines) {
+  if (file.status === "deleted") {
+    return {
+      fileContext: {
+        file,
+        imports: [],
+        symbols: [],
+        changedLines,
+        astSymbols: [],
+        truncated: false,
+        shouldRenderContent: false,
+        skippedReason: "deleted file"
+      },
+      diagnostics: []
+    };
+  }
+  const contentResult = await readTextFile(file.path, MAX_FILE_CHARS);
+  if (!contentResult.content) {
+    return {
+      fileContext: {
+        file,
+        imports: [],
+        symbols: [],
+        changedLines,
+        astSymbols: [],
+        truncated: false,
+        shouldRenderContent: false,
+        skippedReason: contentResult.reason
+      },
+      diagnostics: []
+    };
+  }
+  const astResult = extractAstSymbols(file.path, contentResult.content, changedLines);
+  return {
+    fileContext: {
+      file,
+      imports: extractImports(contentResult.content),
+      symbols: mergeSymbols(
+        extractSymbols(contentResult.content),
+        astResult.symbols.map((symbol) => symbol.name)
+      ),
+      changedLines,
+      astSymbols: astResult.symbols,
+      content: contentResult.content,
+      truncated: contentResult.truncated,
+      shouldRenderContent: shouldRenderFullFileContent(file, contentResult.content)
+    },
+    diagnostics: astResult.diagnostics ?? []
+  };
+}
+async function buildRelatedFileContexts(files) {
+  const seen = /* @__PURE__ */ new Set();
+  const related = [];
+  for (const file of files) {
+    if (file.status === "deleted") continue;
+    for (const candidate of testCandidates(file.path)) {
+      if (seen.has(candidate) || !existsSync4(candidate)) continue;
+      seen.add(candidate);
+      const result = await readTextFile(candidate, MAX_RELATED_FILE_CHARS);
+      if (!result.content) continue;
+      related.push({
+        path: candidate,
+        reason: `Likely test file for ${file.path}`,
+        content: result.content,
+        truncated: result.truncated
+      });
+    }
+  }
+  return related;
+}
+function shouldReviewFile(path, config) {
+  if (LOCKFILE_EXCLUDES.includes(path)) return false;
+  const include = config.include.length > 0 ? config.include : ["**/*"];
+  if (!include.some((pattern) => picomatch.isMatch(path, pattern))) {
+    return false;
+  }
+  return !config.exclude.some((pattern) => picomatch.isMatch(path, pattern));
+}
+async function readTextFile(path, maxChars) {
+  try {
+    const info = await stat2(path);
+    if (!info.isFile()) {
+      return { truncated: false, reason: "not a regular file" };
+    }
+    if (info.size > MAX_CONTEXT_FILE_BYTES) {
+      return {
+        truncated: false,
+        reason: `file too large for context (${formatBytes2(info.size)} > ${formatBytes2(MAX_CONTEXT_FILE_BYTES)})`
+      };
+    }
+    const raw = await readFile6(path, "utf-8");
+    if (raw.includes("\0")) {
+      return { truncated: false, reason: "binary file" };
+    }
+    const result = truncateText3(raw, maxChars);
+    return { content: result.text, truncated: result.truncated };
+  } catch (err) {
+    return {
+      truncated: false,
+      reason: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function extractImports(content) {
+  return content.split("\n").map((line) => line.trim()).filter((line) => line.startsWith("import ") || /^export\s+.*\sfrom\s+/.test(line)).slice(0, 30);
+}
+function extractSymbols(content) {
+  const symbols = /* @__PURE__ */ new Set();
+  const patterns = [
+    /^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/gm,
+    /^(?:export\s+)?(?:class|interface|type|enum)\s+([A-Za-z_$][\w$]*)/gm,
+    /^(?:export\s+)?const\s+([A-Za-z_$][\w$]*)\s*=/gm
+  ];
+  for (const pattern of patterns) {
+    for (const match of content.matchAll(pattern)) {
+      symbols.add(match[1]);
+    }
+  }
+  return [...symbols].slice(0, 30);
+}
+function shouldRenderFullFileContent(file, content) {
+  const totalLines = content.split("\n").length;
+  if (content.length <= MAX_INLINE_FILE_CHARS && totalLines <= MAX_INLINE_FILE_LINES) {
+    return true;
+  }
+  if (file.status === "added") {
+    return false;
+  }
+  const changedLineCount = file.additions + file.deletions;
+  return changedLineCount / totalLines >= MIN_CHANGED_RATIO_FOR_INLINE_CONTENT;
+}
+function mergeSymbols(...groups) {
+  const symbols = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    for (const symbol of group) {
+      symbols.add(symbol);
+    }
+  }
+  return [...symbols].slice(0, 30);
+}
+function getChangedLinesByFile(rawDiff) {
+  const changed = /* @__PURE__ */ new Map();
+  let currentPath;
+  let newLine;
+  for (const line of rawDiff.split(/\r?\n/).map((l) => l.endsWith("\r") ? l.slice(0, -1) : l)) {
+    const gitDiffPaths = parseGitDiffLine(line);
+    if (gitDiffPaths) {
+      currentPath = gitDiffPaths.pathB;
+      continue;
+    }
+    if (line.startsWith("rename to ")) {
+      currentPath = unescapePath(line.slice("rename to ".length));
+      continue;
+    }
+    const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (hunkMatch) {
+      newLine = Number(hunkMatch[1]);
+      continue;
+    }
+    if (!currentPath || newLine === void 0) continue;
+    if (line.startsWith("+++")) {
+      continue;
+    }
+    if (line.startsWith("+")) {
+      const lines = changed.get(currentPath) ?? [];
+      lines.push(newLine);
+      changed.set(currentPath, lines);
+      newLine++;
+      continue;
+    }
+    if (line.startsWith("-")) {
+      continue;
+    }
+    newLine++;
+  }
+  return changed;
+}
+function testCandidates(path) {
+  const dir = dirname3(path);
+  const ext = extname4(path);
+  const base = basename3(path, ext);
+  return [
+    join5(dir, `${base}.test${ext}`),
+    join5(dir, `${base}.spec${ext}`),
+    join5(dir, "__tests__", `${base}.test${ext}`),
+    join5(dir, "__tests__", `${base}.spec${ext}`)
+  ];
+}
+function truncateText3(text, maxChars) {
+  if (text.length <= maxChars) {
+    return { text, truncated: false };
+  }
+  return {
+    text: `${text.slice(0, maxChars)}
+... [truncated ${text.length - maxChars} chars]`,
+    truncated: true
+  };
+}
+function formatBytes2(bytes) {
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${Math.round(bytes / (1024 * 1024) * 10) / 10} MB`;
+}
+function addUniqueDiagnostics(target, diagnostics) {
+  const seen = new Set(target);
+  for (const diagnostic of diagnostics) {
+    if (seen.has(diagnostic)) continue;
+    seen.add(diagnostic);
+    target.push(diagnostic);
+  }
+}
+
+// src/review/formatter.ts
+import chalk from "chalk";
+import { writeFile as writeFile5, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+import { parse as parse2, stringify as stringify2 } from "yaml";
+function renderMarkdown(report) {
+  const lines = [];
+  lines.push("### Summary");
+  lines.push(report.summary.trim() || "No summary provided.");
+  lines.push("");
+  lines.push("### Issues Found");
+  if (report.findings.length === 0) {
+    lines.push("No issues were reported.");
+  } else {
+    for (const [index, finding] of report.findings.entries()) {
+      lines.push(`#### Finding ${index + 1}`);
+      lines.push(`**[${finding.severity.toUpperCase()}] ${finding.file}:${finding.line}**`);
+      lines.push(finding.title.trim());
+      lines.push("");
+      if (finding.evidence) {
+        lines.push(`> **Evidence:** ${formatMarkdownCodeSpan(finding.evidence)}`);
+        lines.push("");
+      }
+      lines.push(finding.body.trim());
+      lines.push("");
+    }
+  }
+  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("");
+    for (const [index, finding] of report.suppressedFindings.entries()) {
+      lines.push(`#### Finding ${report.findings.length + index + 1}`);
+      lines.push(
+        `**[${finding.severity.toUpperCase()}] ${finding.file}:${finding.line}** (${finding.confidence} confidence)`
+      );
+      lines.push(finding.title.trim());
+      lines.push("");
+      if (finding.evidence) {
+        lines.push(`> **Evidence:** ${formatMarkdownCodeSpan(finding.evidence)}`);
+        lines.push("");
+      }
+      lines.push(finding.body.trim());
+      lines.push("");
+    }
+  }
+  if (report.diagnostics && report.diagnostics.length > 0) {
+    lines.push("");
+    lines.push("### Diagnostics");
+    for (const diagnostic of report.diagnostics) {
+      lines.push(`- ${diagnostic}`);
+    }
+  }
+  lines.push("");
+  lines.push("### Status");
+  lines.push(report.findings.length > 0 ? "Open" : "Resolved");
+  return lines.join("\n");
+}
+async function writeMarkdownReport(review, metadata) {
+  const dir = join6(getDiffOwlDir(), "reviews");
+  if (!existsSync5(dir)) {
+    await mkdir3(dir, { recursive: true });
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filename = `review-${timestamp}.md`;
+  const filepath = join6(dir, filename);
+  const content = `${metadata ? renderReviewFrontmatter(metadata) : ""}# DiffOwl Review
+_${(/* @__PURE__ */ new Date()).toLocaleString()}_
+
+${review}
+`;
+  await writeFile5(filepath, content, "utf-8");
+  const latestPath = join6(dir, "latest.md");
+  await writeFile5(latestPath, content, "utf-8");
+  return filepath;
+}
+function parseReviewMetadata(content) {
+  if (!content.startsWith("---\n")) return void 0;
+  const end = content.indexOf("\n---\n", 4);
+  if (end === -1) return void 0;
+  const parsed = parse2(content.slice(4, end));
+  if (!parsed || typeof parsed !== "object") return void 0;
+  const diffowl = parsed.diffowl;
+  if (!diffowl || typeof diffowl !== "object") return void 0;
+  const sessionId = diffowl.session_id;
+  const projectRoot = diffowl.project_root;
+  if (typeof sessionId !== "string" || sessionId.trim() === "" || typeof projectRoot !== "string" || projectRoot.trim() === "") {
+    return void 0;
+  }
+  return { session_id: sessionId, project_root: projectRoot };
+}
+function renderReviewFrontmatter(metadata) {
+  return `---
+${stringify2({ diffowl: metadata }, { lineWidth: 0 })}---
+
+`;
+}
+function printHeader() {
+  console.log();
+  console.log(chalk.bold("diffowl") + chalk.dim(" reviewing..."));
+  console.log(chalk.dim("\u2500".repeat(50)));
+  console.log();
+}
+function printFooter(report, reportPath) {
+  console.log();
+  console.log(chalk.dim("\u2500".repeat(50)));
+  let errors = 0;
+  let warnings = 0;
+  let infos = 0;
+  for (const finding of report.findings) {
+    switch (finding.severity) {
+      case "error":
+        errors++;
+        break;
+      case "warning":
+        warnings++;
+        break;
+      case "info":
+        infos++;
+        break;
+    }
+  }
+  const parts = [];
+  if (errors > 0) parts.push(chalk.red(`${errors} error${errors > 1 ? "s" : ""}`));
+  if (warnings > 0) parts.push(chalk.yellow(`${warnings} warning${warnings > 1 ? "s" : ""}`));
+  if (infos > 0) parts.push(chalk.blue(`${infos} suggestion${infos > 1 ? "s" : ""}`));
+  if (parts.length === 0) {
+    console.log(chalk.green("\u2713 No issues found. Clean commit!"));
+  } else {
+    console.log(`Found ${parts.join(", ")}`);
+  }
+  if (reportPath) {
+    console.log(chalk.dim(`Report saved: ${reportPath}`));
+  }
+  console.log();
+}
+function colorizeMarkdown(text) {
+  const lines = text.split("\n");
+  const colorizedLines = [];
+  let inCodeBlock = false;
+  for (const line of lines) {
+    if (line.trim().startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      colorizedLines.push(chalk.dim(line));
+      continue;
+    }
+    if (inCodeBlock) {
+      colorizedLines.push(line);
+    } else {
+      const colorized = line.replace(
+        /\*\*\[(ERROR|WARNING|INFO)\]([^*]*)\*\*/g,
+        (_match, label, rest) => `${colorizeSeverity(label)}${chalk.bold(rest)}`
+      ).replace(/^### (.*)/g, (_match, title) => chalk.bold.underline(title)).replace(/\*\*([^*]+)\*\*/g, (_match, content) => chalk.bold(content));
+      colorizedLines.push(colorized);
+    }
+  }
+  return colorizedLines.join("\n");
+}
+function colorizeSeverity(label) {
+  switch (label) {
+    case "ERROR":
+      return chalk.red.bold(`[${label}]`);
+    case "WARNING":
+      return chalk.yellow.bold(`[${label}]`);
+    default:
+      return chalk.blue.bold(`[${label}]`);
+  }
+}
+function formatMarkdownCodeSpan(text) {
+  const trimmed = text.trim();
+  let maxRun = 0;
+  let currentRun = 0;
+  for (const char of trimmed) {
+    if (char === "`") {
+      currentRun++;
+      if (currentRun > maxRun) {
+        maxRun = currentRun;
+      }
+    } else {
+      currentRun = 0;
+    }
+  }
+  const delimiter = "`".repeat(maxRun + 1);
+  const pad = trimmed.startsWith("`") || trimmed.endsWith("`") ? " " : "";
+  return `${delimiter}${pad}${trimmed}${pad}${delimiter}`;
+}
+function formatExcludedCandidateSummary(belowConfidence, outsideChangedFiles) {
+  const total = belowConfidence + outsideChangedFiles;
+  const reasons = [
+    belowConfidence > 0 ? `${belowConfidence} below the confidence threshold` : void 0,
+    outsideChangedFiles > 0 ? `${outsideChangedFiles} outside changed files` : void 0
+  ].filter((reason) => reason !== void 0);
+  return `${total} candidate${total === 1 ? "" : "s"} excluded from findings: ${reasons.join(" and ")}. Run \`diffowl chat\` to investigate.`;
+}
+
+// src/review/report-path.ts
+import { readFile as readFile7, readdir as readdir2 } from "fs/promises";
+import { basename as basename4, isAbsolute, join as join7, resolve } from "path";
+function resolveReviewReportPath(report) {
+  if (isAbsolute(report)) return report;
+  if (report.includes("/") || report.includes("\\")) {
+    return resolve(report);
+  }
+  return join7(getDiffOwlDir(), "reviews", report);
+}
+async function listReviewReportPaths() {
+  const reviews = join7(getDiffOwlDir(), "reviews");
+  const entries = await Promise.all([
+    listMarkdownFiles(reviews),
+    listMarkdownFiles(join7(reviews, "resolved"))
+  ]);
+  return entries.flat().filter((path) => basename4(path) !== "latest.md").sort((a, b) => basename4(b).localeCompare(basename4(a)));
+}
+function canSelectReviewInteractively(inputIsTTY, outputIsTTY) {
+  return inputIsTTY === true && outputIsTTY === true;
+}
+function selectReviewReportPath(paths, answer) {
+  const selection = Number.parseInt(answer.trim(), 10);
+  if (!Number.isInteger(selection) || selection < 1 || selection > paths.length) return void 0;
+  return paths[selection - 1];
+}
+async function listMarkdownFiles(dir) {
+  let paths;
+  try {
+    paths = (await readdir2(dir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => join7(dir, entry.name));
+  } catch {
+    return [];
+  }
+  const reports = await Promise.all(
+    paths.map(async (path) => {
+      try {
+        return parseReviewMetadata(await readFile7(path, "utf-8")) ? path : void 0;
+      } catch {
+        return void 0;
+      }
+    })
+  );
+  return reports.filter((path) => path !== void 0);
+}
+
+// src/cli.ts
+import { readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { basename as basename5, dirname as dirname4, join as join8 } from "path";
+import { execa as execa5 } from "execa";
+
+// package.json
+var package_default = {
+  name: "diffowl",
+  version: "0.1.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: {
+    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/cli.ts
+async function writeHookStatus(exitCode, commit, message) {
+  try {
+    const dir = await ensureDiffOwlDir();
+    const content = JSON.stringify(
+      {
+        ...commit ? { commit } : {},
+        exitCode,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...message ? { message } : {}
+      },
+      null,
+      2
+    );
+    await writeFile6(join8(dir, "last-hook-status.json"), content, "utf-8");
+    const resultPath = process.env["DIFFOWL_HOOK_RESULT"];
+    if (resultPath) {
+      await writeFile6(resultPath, content, "utf-8");
+    }
+  } catch {
+  }
+}
+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));
+  }
+  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);
+  }
+  if (!configExists()) {
+    console.log(chalk2.yellow("No .diffowl.yml found. Running first-time setup...\n"));
+    await runInit();
+  }
+  const config = await loadConfigOrExit();
+  if (options.staged && options.commit) {
+    console.error(chalk2.red("Cannot use --staged and --commit together"));
+    process.exit(1);
+  }
+  const mode = options.staged ? "staged" : options.commit ? "commit" : "last-commit";
+  const depth = resolveReviewDepth(options.depth, config);
+  config.reasoning.effort = resolveReasoningEffort(options.reasoning, config);
+  const verbose = Boolean(config.verbose || options.verbose);
+  if (mode !== "staged") {
+    const hasCommitsStart = performance.now();
+    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);
+    }
+  }
+  printHeader();
+  const hookFailure = await checkRecentHookFailure();
+  if (hookFailure) {
+    console.log(chalk2.yellow(`\u26A0 ${formatHookFailure(hookFailure)}`));
+    console.log();
+  }
+  const diff = mode === "staged" ? await getStagedDiff() : mode === "commit" ? await getCommitDiff(String(options.commit)) : await getLastCommitDiff();
+  if (config.skip_doc_only && isDocOnlyDiff(diff)) {
+    console.warn(chalk2.yellow("Documentation-only changes detected. Skipping review."));
+    const skipContent = buildDocOnlySkipMarkdown(diff);
+    const reportPath = await writeMarkdownReport(skipContent);
+    console.log(chalk2.dim(`Report saved: ${reportPath}`));
+    if (options.hook) {
+      await writeHookStatus(0, hookCommit);
+    }
+    process.exit(0);
+  }
+  const spinner = ora({
+    text: "Building local review context...",
+    color: "cyan",
+    discardStdin: false
+  }).start();
+  process.once("SIGINT", () => {
+    try {
+      spinner.stop();
+    } catch {
+    }
+    console.log(chalk2.yellow("\nReview cancelled by user (Ctrl+C)."));
+    process.exit(130);
+  });
+  process.once("SIGTSTP", () => {
+    try {
+      spinner.stop();
+    } catch {
+    }
+    console.log(chalk2.yellow("\nReview cancelled by user (Ctrl+Z)."));
+    process.exit(146);
+  });
+  try {
+    const contextStart = performance.now();
+    const reviewContext = await buildReviewContext(mode, config, depth, diff);
+    recordCliTiming(timings, "context-build", "Local review context build", contextStart);
+    if (mode === "staged" && reviewContext.diff.files.length === 0) {
+      spinner.stop();
+      console.log(chalk2.yellow("No staged changes to review"));
+      process.exit(0);
+    }
+    const contextRenderStart = performance.now();
+    const localContext = renderReviewContext(reviewContext, { depth });
+    recordCliTiming(timings, "context-render", "Local review context render", contextRenderStart);
+    if (reviewContext.diagnostics.length > 0) {
+      spinner.warn("Local review context built with warnings.");
+      for (const diagnostic of reviewContext.diagnostics) {
+        console.log(chalk2.yellow(`  - ${diagnostic}`));
+      }
+      console.log();
+      spinner.start("Connecting to OpenCode...");
+    }
+    spinner.text = "Connecting to OpenCode...";
+    const serverStart = performance.now();
+    await prepareReviewServer(config);
+    recordCliTiming(timings, "server-ensure", "OpenCode server ensure", serverStart);
+    spinner.text = "Reviewing changes...";
+    const reviewStart = performance.now();
+    const reviewResult = await runReview({
+      mode,
+      config,
+      localContext,
+      depth,
+      onProgress: (event) => {
+        spinner.text = formatReviewProgress(event);
+      }
+    });
+    const report = reviewResult.report;
+    recordCliTiming(timings, "review-run", "OpenCode review run", reviewStart);
+    spinner.succeed("Review complete.");
+    console.log();
+    const diagnostics = report.diagnostics ?? [];
+    const confidenceFilter = filterFindingsByConfidence(report.findings, config.min_confidence);
+    report.findings = confidenceFilter.findings;
+    const changedFilesSet = /* @__PURE__ */ new Set();
+    for (const file of reviewContext.changedFiles) {
+      changedFilesSet.add(file.file.path);
+    }
+    const changedFileFilter = filterFindingsByChangedFiles(report.findings, changedFilesSet);
+    report.findings = changedFileFilter.findings;
+    if (changedFileFilter.suppressed.length > 0) {
+      if (verbose) {
+        report.suppressedFindings = changedFileFilter.suppressed;
+      }
+    }
+    if (confidenceFilter.dropped > 0 || changedFileFilter.suppressed.length > 0) {
+      diagnostics.push(
+        formatExcludedCandidateSummary(
+          confidenceFilter.dropped,
+          changedFileFilter.suppressed.length
+        )
+      );
+    }
+    if (diagnostics.length > 0) {
+      report.diagnostics = diagnostics;
+    }
+    const 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: getProjectRoot()
+    });
+    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 (options.hook) {
+      await writeHookStatus(0, hookCommit);
+      process.exit(0);
+    }
+  } catch (err) {
+    spinner.stop();
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk2.red(`
+Review failed: ${message}`));
+    for (const line of getOpenCodeFailureGuidance(message)) {
+      console.log(chalk2.dim(line));
+    }
+    if (options.hook) {
+      await writeHookStatus(1, hookCommit, message);
+      process.exit(0);
+    }
+    process.exit(1);
+  }
+});
+program.command("chat").description("Open the OpenCode session for a review").argument("[report]", "Review report path or filename").action(async (report) => {
+  const reportPath = report ? resolveReviewReportPath(report) : await selectReviewInteractively();
+  let content;
+  try {
+    content = await readFile8(reportPath, "utf-8");
+  } catch {
+    console.error(chalk2.red(`Review report not found: ${reportPath}`));
+    process.exit(1);
+  }
+  let metadata;
+  try {
+    metadata = parseReviewMetadata(content);
+  } catch {
+    console.error(chalk2.red(`Invalid review metadata: ${reportPath}`));
+    process.exit(1);
+  }
+  if (!metadata) {
+    console.error(
+      chalk2.red(`Review report does not contain chat session metadata: ${reportPath}`)
+    );
+    process.exit(1);
+  }
+  try {
+    await execa5("opencode", [metadata.project_root, "--session", metadata.session_id], {
+      stdio: "inherit"
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk2.red(`Failed to open review session: ${message}`));
+    for (const line of getOpenCodeFailureGuidance(message)) {
+      console.log(chalk2.dim(line));
+    }
+    process.exit(1);
+  }
+});
+async function selectReviewInteractively() {
+  if (!canSelectReviewInteractively(process.stdin.isTTY, process.stdout.isTTY)) {
+    console.error(
+      chalk2.red(
+        "Interactive review selection requires a terminal. Pass a report filename or path instead."
+      )
+    );
+    process.exit(1);
+  }
+  const reports = await listReviewReportPaths();
+  if (reports.length === 0) {
+    console.error(chalk2.red("No review reports available. Run `diffowl review` first."));
+    process.exit(1);
+  }
+  console.log(chalk2.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)") : ""}`
+    );
+  }
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    while (true) {
+      const selected = selectReviewReportPath(
+        reports,
+        await rl.question(chalk2.yellow("\nReview number: "))
+      );
+      if (selected) return selected;
+      console.log(chalk2.red(`Enter a number between 1 and ${reports.length}.`));
+    }
+  } finally {
+    rl.close();
+  }
+}
+function formatReviewProgress(event) {
+  switch (event.type) {
+    case "server":
+    case "session":
+    case "idle":
+      return event.message;
+    case "tool":
+      return `OpenCode tool: ${event.message}`;
+    case "output":
+      return event.message;
+    case "timing":
+      return event.message;
+  }
+}
+function resolveReviewDepth(value, config) {
+  if (value === void 0) {
+    return config.context.depth;
+  }
+  try {
+    return parseReviewContextDepth(value);
+  } catch {
+    console.error(chalk2.red(`Invalid review depth: ${String(value)}`));
+    console.error(chalk2.dim("Expected one of: shallow, default"));
+    process.exit(1);
+  }
+}
+function resolveReasoningEffort(value, config) {
+  if (value === void 0) {
+    return config.reasoning.effort;
+  }
+  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"));
+    process.exit(1);
+  }
+}
+function recordCliTiming(timings, phase, label, start) {
+  timings.push({ phase, label, ms: performance.now() - start });
+}
+function printTimingSummary(timings) {
+  if (timings.length === 0) return;
+  const ordered = [
+    ...timings.filter((timing) => timing.phase !== "total"),
+    ...timings.filter((timing) => timing.phase === "total")
+  ];
+  console.log(chalk2.dim("Timing:"));
+  for (const timing of ordered) {
+    console.log(chalk2.dim(`  ${timing.label}: ${formatDuration2(timing.ms)}`));
+  }
+  console.log();
+}
+function formatDuration2(ms) {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+async function prepareReviewServer(config) {
+  if (config.server.auto_start) {
+    await ensureServer(config.server.port);
+    return;
+  }
+  if (await isServerRunning(config.server.port)) {
+    return;
+  }
+  throw new Error(
+    `OpenCode server is not running on port ${config.server.port}. Start it with \`diffowl server start\` or set server.auto_start: true.`
+  );
+}
+program.command("init").description("Set up DiffOwl for this project").action(async () => {
+  await runInit();
+});
+async function runInit() {
+  console.log(chalk2.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));
+    await selectModelInteractively(config, { allowKeepCurrent: true });
+    return;
+  }
+  let parsedModel;
+  try {
+    parsedModel = parseModel(model);
+  } catch {
+    console.error(chalk2.red(`Invalid model: ${model}`));
+    console.error(
+      chalk2.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}`));
+});
+async function selectModelInteractively(config, options) {
+  const spinner = ora("Querying available models from OpenCode...").start();
+  let models = [];
+  try {
+    models = await getAvailableModels(config.server.port, {
+      autoStart: config.server.auto_start
+    });
+    spinner.stop();
+  } catch {
+    spinner.fail("Failed to query models from OpenCode server.");
+  }
+  let selectedModel = config.model;
+  if (models.length > 0) {
+    if (!canSelectModelInteractively(process.stdin.isTTY, process.stdout.isTTY)) {
+      console.error(
+        chalk2.red(
+          "Interactive model selection requires a terminal. Pass a model explicitly, for example `diffowl model provider/model`."
+        )
+      );
+      process.exit(1);
+    }
+    console.log(
+      chalk2.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();
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    try {
+      while (true) {
+        const promptText = options.allowKeepCurrent ? `Select a model number (1-${models.length}) or press Enter to keep current: ` : `Select a model number (1-${models.length}) [default: 1]: `;
+        const selection = selectModel(
+          models,
+          config.model,
+          await rl.question(chalk2.yellow(promptText)),
+          options.allowKeepCurrent
+        );
+        if (selection.type === "kept") break;
+        if (selection.type === "selected") {
+          selectedModel = selection.model;
+          break;
+        }
+        console.log(chalk2.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(
+      chalk2.dim("Make sure you run ") + chalk2.cyan("opencode") + chalk2.dim(" to authenticate and set up your providers/keys first.")
+    );
+    console.log(chalk2.dim("Using fallback default model: ") + chalk2.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)}`));
+    } else {
+      console.log(chalk2.green(`\u2713 Config saved to ${configPath}`));
+      console.log(chalk2.dim(`Model set to: `) + chalk2.cyan(selectedModel));
+    }
+    console.log();
+  }
+}
+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"));
+    process.exit(1);
+  }
+  const alreadyInstalled = await isHookInstalled();
+  const hookPath = await installHook();
+  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(
+    chalk2.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"}`));
+    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."));
+    return;
+  }
+  console.log(chalk2.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"));
+  } else {
+    console.log(chalk2.yellow("No diffowl hook found"));
+  }
+});
+program.command("hook-run", { hidden: true }).description("Spawn a non-blocking hook review").action(async () => {
+  await runHookReview();
+});
+program.command("hook-worker", { hidden: true }).description("Process queued hook reviews").action(async () => {
+  const hookLock = process.env["DIFFOWL_HOOK_LOCK"];
+  if (hookLock) {
+    process.once("exit", () => releaseHookReviewLock(hookLock));
+  }
+  await runPendingHookReviews();
+});
+var serverCmd = program.command("server").description("Manage the OpenCode server");
+serverCmd.command("start").description("Start the OpenCode server").action(async () => {
+  const config = await loadConfigOrExit();
+  const spinner = ora("Starting OpenCode server...").start();
+  try {
+    const url = await ensureServer(config.server.port);
+    spinner.succeed(`Server running at ${url}`);
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+});
+serverCmd.command("stop").description("Stop the OpenCode server").action(async () => {
+  if (await stopServer()) {
+    console.log(chalk2.green("\u2713 Server stopped"));
+  } else {
+    console.log(chalk2.yellow("No managed server found"));
+  }
+});
+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}`));
+  }
+});
+program.parse();
+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}`));
+    process.exit(1);
+  }
+}
+function filterFindingsByConfidence(findings, minConfidence) {
+  const levels = ["low", "medium", "high"];
+  const minIndex = levels.indexOf(minConfidence);
+  const kept = findings.filter((f) => {
+    const idx = levels.indexOf(f.confidence.toLowerCase());
+    return idx >= minIndex;
+  });
+  return { findings: kept, dropped: findings.length - kept.length };
+}
+function filterFindingsByChangedFiles(findings, changedFiles) {
+  const kept = [];
+  const suppressed = [];
+  for (const finding of findings) {
+    if (changedFiles.has(finding.file)) {
+      kept.push(finding);
+    } else {
+      suppressed.push(finding);
+    }
+  }
+  return { findings: kept, suppressed };
+}
+function buildDocOnlySkipMarkdown(diff) {
+  const lines = [];
+  lines.push("### Summary");
+  lines.push("Documentation-only changes detected. No code review performed.");
+  lines.push("");
+  lines.push("### Changed Files");
+  for (const file of diff.files) {
+    lines.push(`- ${file.path} (+${file.additions}/-${file.deletions})`);
+  }
+  return lines.join("\n");
+}
+//# sourceMappingURL=cli.js.map