agent-review-cli 0.2.0

package/dist/index.js

@@ -0,0 +1,2596 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { useEffect as useEffect2, useState as useState2 } from "react";
+import { Command } from "commander";
+import { render } from "ink";
+import readline from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+
+// src/dashboard.tsx
+import React, { useState, useEffect } from "react";
+import { Box, Static, Text, useStdout } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var T = {
+  primary: "cyan",
+  success: "green",
+  warning: "yellow",
+  error: "red",
+  muted: "gray",
+  border: "gray"
+};
+function fmt(n) {
+  if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+  if (n >= 1e4) return `${(n / 1e3).toFixed(1)}K`;
+  if (n >= 1e3) return `${(n / 1e3).toFixed(1)}K`;
+  return String(n);
+}
+function elapsed(iso) {
+  const ms = Math.max(0, Date.now() - new Date(iso).getTime());
+  const s = Math.floor(ms / 1e3);
+  const m = Math.floor(s / 60);
+  const h = Math.floor(m / 60);
+  if (h > 0) return `${h}h ${m % 60}m ${s % 60}s`;
+  if (m > 0) return `${m}m ${s % 60}s`;
+  return `${s}s`;
+}
+var BACKEND_LABEL = {
+  codex: "Codex",
+  "claude-code": "Claude Code",
+  opencode: "OpenCode",
+  mixed: "Mixed"
+};
+var PHASE_ORDER = [
+  "initializing",
+  "planning",
+  "discovery",
+  "fixing",
+  "integrating",
+  "verifying",
+  "publishing",
+  "complete"
+];
+var PHASE_LABEL = {
+  initializing: "INIT",
+  planning: "PLAN",
+  discovery: "DISCOVER",
+  fixing: "FIX",
+  integrating: "INTEGRATE",
+  verifying: "VERIFY",
+  publishing: "PUBLISH",
+  complete: "DONE",
+  failed: "FAILED"
+};
+var SPIN = ["\u2807", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function useTimer(intervalMs) {
+  const [tick, setTick] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => setTick((t) => t + 1), intervalMs);
+    return () => clearInterval(id);
+  }, [intervalMs]);
+  return tick;
+}
+function humanizeMessage(raw, maxLen) {
+  if (!raw) return "";
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (typeof parsed.summary === "string" && parsed.summary.trim()) {
+        return parsed.summary.trim().slice(0, maxLen);
+      }
+      for (const key of ["message", "text", "description", "status"]) {
+        if (typeof parsed[key] === "string" && parsed[key].trim()) {
+          return parsed[key].trim().slice(0, maxLen);
+        }
+      }
+    } catch {
+      const match = trimmed.match(/"summary"\s*:\s*"([^"]+)/);
+      if (match?.[1]) {
+        return match[1].slice(0, maxLen);
+      }
+    }
+  }
+  return trimmed.slice(0, maxLen);
+}
+function useTerminalWidth() {
+  const { stdout } = useStdout();
+  const [width, setWidth] = useState(stdout?.columns ?? 120);
+  useEffect(() => {
+    if (!stdout) return;
+    const onResize = () => setWidth(stdout.columns);
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return width;
+}
+function Header({ snapshot, termWidth }) {
+  useTimer(1e3);
+  const el = elapsed(snapshot.startedAt);
+  const phaseColor = snapshot.phase === "complete" ? T.success : snapshot.phase === "failed" ? T.error : T.primary;
+  const backendLabel = BACKEND_LABEL[snapshot.backend] ?? snapshot.backend;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "round",
+      borderColor: T.primary,
+      paddingX: 2,
+      flexDirection: "column",
+      width: termWidth,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs(Text, { bold: true, color: T.primary, children: [
+            "  ",
+            "AGENT REVIEW",
+            "  ",
+            /* @__PURE__ */ jsxs(Text, { color: T.muted, bold: false, children: [
+              "via ",
+              backendLabel
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: T.muted, children: [
+            "elapsed ",
+            /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: el })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: T.muted, children: "run " }),
+            /* @__PURE__ */ jsx(Text, { bold: true, children: snapshot.runId })
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            /* @__PURE__ */ jsx(Text, { color: T.muted, children: "phase " }),
+            /* @__PURE__ */ jsx(Text, { bold: true, color: phaseColor, children: snapshot.phase.toUpperCase() })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: T.muted, wrap: "truncate", children: [
+          snapshot.currentBranch ?? "",
+          snapshot.targetPaths.length > 0 ? ` \u2192 ${snapshot.targetPaths.join(", ")}` : ""
+        ] }) })
+      ]
+    }
+  );
+}
+function PhaseBar({ phase }) {
+  const currentIdx = PHASE_ORDER.indexOf(phase);
+  const failed = phase === "failed";
+  return /* @__PURE__ */ jsxs(Box, { paddingX: 2, marginY: 0, children: [
+    PHASE_ORDER.map((p, i) => {
+      const done = !failed && i < currentIdx;
+      const active = !failed && i === currentIdx;
+      let color = T.muted;
+      let sym = "\u25CB";
+      if (done) {
+        color = T.success;
+        sym = "\u25CF";
+      } else if (active) {
+        color = T.primary;
+        sym = "\u25C9";
+      }
+      const sepColor = !failed && i <= currentIdx ? T.success : T.muted;
+      return /* @__PURE__ */ jsxs(React.Fragment, { children: [
+        i > 0 && /* @__PURE__ */ jsx(Text, { color: sepColor, children: " \u2501\u2501 " }),
+        /* @__PURE__ */ jsxs(Text, { color, bold: active, children: [
+          sym,
+          " ",
+          PHASE_LABEL[p]
+        ] })
+      ] }, p);
+    }),
+    failed && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { color: T.muted, children: " \u2501\u2501 " }),
+      /* @__PURE__ */ jsx(Text, { color: T.error, bold: true, children: "\\u2717 FAILED" })
+    ] })
+  ] });
+}
+function StatCard({
+  title,
+  items,
+  borderColor
+}) {
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "round",
+      borderColor: borderColor ?? T.border,
+      flexGrow: 1,
+      flexBasis: 0,
+      paddingX: 1,
+      flexDirection: "column",
+      marginRight: 1,
+      children: [
+        /* @__PURE__ */ jsx(Text, { bold: true, color: T.primary, children: title }),
+        items.map((item) => /* @__PURE__ */ jsxs(Box, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: item.label }),
+          /* @__PURE__ */ jsx(Text, { bold: true, color: item.color ?? "white", children: typeof item.value === "number" ? fmt(item.value) : item.value })
+        ] }, item.label))
+      ]
+    }
+  );
+}
+function StatsRow({ snapshot }) {
+  const { issueMetrics: im, tokenUsage: tu, agents } = snapshot;
+  const running = agents.filter((a) => a.status === "running").length;
+  const done = agents.filter((a) => a.status === "completed").length;
+  const failed = agents.filter((a) => a.status === "failed").length;
+  const pending = agents.filter((a) => a.status === "pending").length;
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(
+      StatCard,
+      {
+        title: "Issues",
+        borderColor: im.found > 0 ? T.warning : T.border,
+        items: [
+          { label: "Found", value: im.found },
+          { label: "Fixed", value: im.fixed, color: im.fixed > 0 ? T.success : void 0 },
+          { label: "Open", value: im.open, color: im.open > 0 ? T.warning : void 0 },
+          {
+            label: "Failed",
+            value: im.failed,
+            color: im.failed > 0 ? T.error : void 0
+          }
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      StatCard,
+      {
+        title: "Agents",
+        borderColor: running > 0 ? T.warning : T.border,
+        items: [
+          { label: "Running", value: running, color: running > 0 ? T.warning : void 0 },
+          { label: "Done", value: done, color: done > 0 ? T.success : void 0 },
+          { label: "Failed", value: failed, color: failed > 0 ? T.error : void 0 },
+          { label: "Pending", value: pending }
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      StatCard,
+      {
+        title: "Tokens",
+        items: [
+          { label: "Input", value: tu.input },
+          { label: "Cached", value: tu.cachedInput, color: T.primary },
+          { label: "Output", value: tu.output }
+        ]
+      }
+    )
+  ] });
+}
+function statusIndicator(status) {
+  switch (status) {
+    case "running":
+      return { sym: "\u25CF", color: T.warning };
+    case "completed":
+      return { sym: "\u2713", color: T.success };
+    case "failed":
+      return { sym: "\u2717", color: T.error };
+    case "skipped":
+      return { sym: "\u2212", color: T.muted };
+    default:
+      return { sym: "\u25CB", color: T.muted };
+  }
+}
+function AgentRow({
+  agent,
+  spinner,
+  infoWidth
+}) {
+  const { sym, color } = statusIndicator(agent.status);
+  const icon = agent.status === "running" ? spinner : sym;
+  const assignedLabel = agent.kind === "discovery" ? `${agent.issuesAssigned} files` : `${agent.issuesAssigned} issues`;
+  const infoMaxLen = Math.max(20, infoWidth - 2);
+  return /* @__PURE__ */ jsxs(Box, { children: [
+    /* @__PURE__ */ jsx(Box, { width: 16, children: /* @__PURE__ */ jsxs(Text, { color, children: [
+      icon,
+      " ",
+      agent.id
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsx(Text, { color, children: agent.status }) }),
+    /* @__PURE__ */ jsx(Box, { width: 14, children: /* @__PURE__ */ jsx(Text, { color: T.muted, children: assignedLabel }) }),
+    /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsxs(Text, { color: agent.issuesFound > 0 ? T.warning : T.muted, children: [
+      agent.issuesFound,
+      " found"
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsxs(Text, { color: agent.issuesFixed > 0 ? T.success : T.muted, children: [
+      agent.issuesFixed,
+      " fixed"
+    ] }) }),
+    /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsxs(Text, { color: T.muted, children: [
+      fmt(agent.tokenUsage.input + agent.tokenUsage.output),
+      " tok"
+    ] }) }),
+    agent.error ? /* @__PURE__ */ jsx(Box, { flexGrow: 1, children: /* @__PURE__ */ jsx(Text, { color: T.error, wrap: "truncate", children: humanizeMessage(agent.error, infoMaxLen) }) }) : agent.lastMessage ? /* @__PURE__ */ jsx(Box, { flexGrow: 1, children: /* @__PURE__ */ jsx(Text, { color: T.muted, wrap: "truncate", children: humanizeMessage(agent.lastMessage, infoMaxLen) }) }) : null
+  ] });
+}
+function AgentTable({ agents, termWidth }) {
+  const hasRunning = agents.some((a) => a.status === "running");
+  const tick = useTimer(hasRunning ? 250 : 6e4);
+  const spinner = SPIN[tick % SPIN.length];
+  const fixedColumnsWidth = 16 + 12 + 14 + 12 + 12 + 12 + 4;
+  const infoWidth = Math.max(20, termWidth - fixedColumnsWidth);
+  if (agents.length === 0) {
+    return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: T.border, paddingX: 1, flexDirection: "column", width: termWidth, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: T.primary, children: "Agents" }),
+      /* @__PURE__ */ jsx(Text, { color: T.muted, children: "Waiting for agents to start..." })
+    ] });
+  }
+  const planner = agents.filter((a) => a.kind === "planner");
+  const discovery = agents.filter((a) => a.kind === "discovery");
+  const fix = agents.filter((a) => a.kind === "fix");
+  const final = agents.filter((a) => a.kind === "final");
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: T.border, paddingX: 1, flexDirection: "column", width: termWidth, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Box, { width: 16, children: /* @__PURE__ */ jsx(Text, { color: T.muted, dimColor: true, children: "NAME" }) }),
+      /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsx(Text, { color: T.muted, dimColor: true, children: "STATUS" }) }),
+      /* @__PURE__ */ jsx(Box, { width: 14, children: /* @__PURE__ */ jsx(Text, { color: T.muted, dimColor: true, children: "ASSIGNED" }) }),
+      /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsx(Text, { color: T.muted, dimColor: true, children: "FOUND" }) }),
+      /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsx(Text, { color: T.muted, dimColor: true, children: "FIXED" }) }),
+      /* @__PURE__ */ jsx(Box, { width: 12, children: /* @__PURE__ */ jsx(Text, { color: T.muted, dimColor: true, children: "TOKENS" }) }),
+      /* @__PURE__ */ jsx(Box, { flexGrow: 1, children: /* @__PURE__ */ jsx(Text, { color: T.muted, dimColor: true, children: "INFO" }) })
+    ] }),
+    planner.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: T.primary, children: "Planning" }),
+      planner.map((a) => /* @__PURE__ */ jsx(AgentRow, { agent: a, spinner, infoWidth }, a.id))
+    ] }),
+    discovery.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: T.primary, children: "Discovery" }),
+      discovery.map((a) => /* @__PURE__ */ jsx(AgentRow, { agent: a, spinner, infoWidth }, a.id))
+    ] }),
+    fix.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: T.primary, children: "Fix" }),
+      fix.map((a) => /* @__PURE__ */ jsx(AgentRow, { agent: a, spinner, infoWidth }, a.id))
+    ] }),
+    final.length > 0 && /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: T.primary, children: "Verification" }),
+      final.map((a) => /* @__PURE__ */ jsx(AgentRow, { agent: a, spinner, infoWidth }, a.id))
+    ] })
+  ] });
+}
+function CompletionPanel({ snapshot }) {
+  useTimer(snapshot.done ? 1e3 : 6e4);
+  const el = elapsed(snapshot.startedAt);
+  if (!snapshot.done) return null;
+  const ok = !snapshot.failed;
+  const borderColor = ok ? T.success : T.error;
+  const title = ok ? "RUN COMPLETE" : "RUN FAILED";
+  const { issueMetrics: im, tokenUsage: tu } = snapshot;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "double",
+      borderColor,
+      paddingX: 2,
+      paddingY: 0,
+      flexDirection: "column",
+      children: [
+        /* @__PURE__ */ jsxs(Text, { bold: true, color: borderColor, children: [
+          ok ? "\u25CF" : "\u2717",
+          " ",
+          title
+        ] }),
+        /* @__PURE__ */ jsx(Text, {}),
+        snapshot.error && /* @__PURE__ */ jsx(Text, { color: T.error, children: snapshot.error }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: "Issues: " }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            im.found,
+            " found"
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: T.success, children: [
+            ", ",
+            im.fixed,
+            " fixed"
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: T.warning, children: [
+            ", ",
+            im.open,
+            " open"
+          ] }),
+          /* @__PURE__ */ jsxs(Text, { color: T.error, children: [
+            ", ",
+            im.failed,
+            " failed"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: "Tokens: " }),
+          /* @__PURE__ */ jsxs(Text, { children: [
+            fmt(tu.input),
+            " in, ",
+            fmt(tu.cachedInput),
+            " cached, ",
+            fmt(tu.output),
+            " out"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: "Duration: " }),
+          /* @__PURE__ */ jsx(Text, { bold: true, children: el })
+        ] }),
+        /* @__PURE__ */ jsx(Text, {}),
+        snapshot.prUrl && /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: "PR:       " }),
+          /* @__PURE__ */ jsx(Text, { bold: true, color: T.primary, children: snapshot.prUrl })
+        ] }),
+        snapshot.integrationBranch && /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: "Branch:   " }),
+          /* @__PURE__ */ jsx(Text, { bold: true, color: T.success, children: snapshot.integrationBranch })
+        ] }),
+        snapshot.reportFile && /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: "Report:   " }),
+          /* @__PURE__ */ jsx(Text, { children: snapshot.reportFile })
+        ] }),
+        snapshot.issueFile && /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: "Issues:   " }),
+          /* @__PURE__ */ jsx(Text, { children: snapshot.issueFile })
+        ] }),
+        snapshot.integrationWorktree && /* @__PURE__ */ jsxs(Text, { children: [
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: "Worktree: " }),
+          /* @__PURE__ */ jsx(Text, { color: T.muted, children: snapshot.integrationWorktree })
+        ] })
+      ]
+    }
+  );
+}
+function LogLine({ log }) {
+  const m = log.match(/^\[(\d{2}:\d{2}:\d{2})]\s(.*)$/);
+  if (m) {
+    const isError = m[2].includes("failed") || m[2].includes("errored") || m[2].includes("timed out");
+    const isDone = m[2].includes("completed") || m[2].includes("complete");
+    let textColor;
+    if (isError) textColor = T.error;
+    else if (isDone) textColor = T.success;
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      /* @__PURE__ */ jsxs(Text, { color: T.muted, children: [
+        m[1],
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: textColor, children: m[2] })
+    ] });
+  }
+  return /* @__PURE__ */ jsx(Text, { children: log });
+}
+function Dashboard({ snapshot }) {
+  const termWidth = useTerminalWidth();
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: termWidth, children: [
+    /* @__PURE__ */ jsx(Static, { items: snapshot.logs, children: (log, i) => /* @__PURE__ */ jsx(LogLine, { log }, i) }),
+    /* @__PURE__ */ jsx(Header, { snapshot, termWidth }),
+    /* @__PURE__ */ jsx(PhaseBar, { phase: snapshot.phase }),
+    /* @__PURE__ */ jsx(StatsRow, { snapshot }),
+    /* @__PURE__ */ jsx(AgentTable, { agents: snapshot.agents, termWidth }),
+    /* @__PURE__ */ jsx(CompletionPanel, { snapshot })
+  ] });
+}
+
+// src/orchestrator.ts
+import { randomUUID } from "crypto";
+import { spawn } from "child_process";
+import path from "path";
+import os from "os";
+import fs from "fs/promises";
+import { constants as fsConstants } from "fs";
+var REVIEWABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".md",
+  ".mdx",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".swift",
+  ".dart",
+  ".php",
+  ".cs",
+  ".scala",
+  ".c",
+  ".h",
+  ".cpp",
+  ".cc",
+  ".hpp",
+  ".sql",
+  ".yml",
+  ".yaml",
+  ".toml",
+  ".sh",
+  ".zsh"
+]);
+var BINARY_FILE_PATTERN = /\.(png|jpe?g|gif|webp|ico|bmp|svgz?|pdf|woff2?|ttf|eot|zip|gz|tgz|7z|mp3|mp4|mov|avi|wasm|jar|class|dll|so|dylib|exe)$/i;
+var IGNORED_PATH_SEGMENTS = [
+  "/node_modules/",
+  "/dist/",
+  "/build/",
+  "/coverage/",
+  "/.next/",
+  "/.turbo/",
+  "/.git/",
+  "/vendor/"
+];
+var EMPTY_USAGE = { input: 0, cachedInput: 0, output: 0 };
+var RETRYABLE_CODEX_FAILURES = [
+  "failed to install system skills",
+  "no last agent message",
+  "wrote empty content",
+  "stream disconnected before completion"
+];
+var VerificationFailure = class extends Error {
+};
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function normalizeSlashes(input2) {
+  return input2.replaceAll(path.sep, "/");
+}
+function isInsidePath(child, parent) {
+  const rel = path.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function parseJson(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) throw new Error("Expected JSON content but got empty string");
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start === -1 || end === -1 || end <= start) {
+      throw new Error("Unable to parse JSON payload");
+    }
+    return JSON.parse(trimmed.slice(start, end + 1));
+  }
+}
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runCommand(command, args, options = {}) {
+  const child = spawn(command, args, {
+    cwd: options.cwd,
+    env: process.env,
+    stdio: "pipe"
+  });
+  let stdout = "";
+  let stderr = "";
+  child.stdout.setEncoding("utf8");
+  child.stderr.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    stdout += chunk;
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr += chunk;
+  });
+  if (options.stdin !== void 0) {
+    child.stdin.end(options.stdin);
+  } else {
+    child.stdin.end();
+  }
+  const code = await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (exitCode) => resolve(exitCode ?? 1));
+  });
+  if (code !== 0 && !options.allowFailure) {
+    throw new Error(`Command failed (${command} ${args.join(" ")}): ${stderr.trim() || stdout.trim()}`);
+  }
+  return { code, stdout, stderr };
+}
+function createCodexDriver() {
+  return {
+    async checkVersion() {
+      await runCommand("codex", ["--version"]);
+    },
+    buildArgs(input2) {
+      const args = [];
+      if (input2.yolo) {
+        args.push("--dangerously-bypass-approvals-and-sandbox");
+      } else {
+        args.push("-s", "read-only");
+      }
+      if (input2.model) args.push("-m", input2.model);
+      args.push("exec", "--json", "--output-schema", input2.schemaPath, "-o", input2.outputPath, input2.prompt);
+      return { command: "codex", args };
+    },
+    parseStdoutLine(parsed) {
+      const result = {};
+      const type = parsed.type;
+      if (type === "turn.completed") {
+        const usage = parsed.usage;
+        if (usage) {
+          result.tokenIncrement = {
+            input: usage.input_tokens ?? 0,
+            cachedInput: usage.cached_input_tokens ?? 0,
+            output: usage.output_tokens ?? 0
+          };
+        }
+      } else if (type === "item.completed") {
+        const item = parsed.item;
+        if (item?.type === "agent_message" && typeof item.text === "string") {
+          result.message = item.text.slice(0, 600);
+        }
+      } else if (type === "error" || type === "turn.failed") {
+        const errMsg = parsed.message ?? parsed.error?.message;
+        if (typeof errMsg === "string") {
+          result.message = `Error: ${errMsg.slice(0, 500)}`;
+        }
+      }
+      return result;
+    }
+  };
+}
+function createClaudeCodeDriver() {
+  return {
+    async checkVersion() {
+      await runCommand("claude", ["--version"]);
+    },
+    buildArgs(input2) {
+      const args = ["-p", input2.prompt, "--output-format", "stream-json", "--verbose"];
+      if (input2.model) args.push("--model", input2.model);
+      if (!input2.yolo) {
+        args.push("--allowedTools", "Read,Glob,Grep,Bash(git status),Bash(git diff),Bash(git log)");
+      }
+      return { command: "claude", args };
+    },
+    parseStdoutLine(parsed) {
+      const result = {};
+      const type = parsed.type;
+      if (type === "result" || type === "turn_result") {
+        const usage = parsed.usage ?? parsed.token_usage;
+        if (usage) {
+          result.tokenIncrement = {
+            input: usage.input_tokens ?? 0,
+            cachedInput: usage.cache_read_input_tokens ?? usage.cached_input_tokens ?? 0,
+            output: usage.output_tokens ?? 0
+          };
+        }
+      }
+      if (type === "assistant" || type === "message") {
+        const content = parsed.content ?? parsed.message ?? parsed.text;
+        if (typeof content === "string") {
+          result.message = content.slice(0, 600);
+        } else if (Array.isArray(content)) {
+          const textBlock = content.find(
+            (b) => b.type === "text" && typeof b.text === "string"
+          );
+          if (textBlock) {
+            result.message = textBlock.text.slice(0, 600);
+          }
+        }
+      }
+      if (type === "error") {
+        const errMsg = parsed.message ?? parsed.error;
+        if (typeof errMsg === "string") {
+          result.message = `Error: ${errMsg.slice(0, 500)}`;
+        }
+      }
+      return result;
+    }
+  };
+}
+function createOpenCodeDriver() {
+  return {
+    async checkVersion() {
+      await runCommand("opencode", ["--version"]);
+    },
+    buildArgs(input2) {
+      const args = [];
+      if (input2.model) args.push("--model", input2.model);
+      if (input2.yolo) {
+        args.push("--dangerously-skip-permissions");
+      }
+      args.push("run", "--json", "-o", input2.outputPath, input2.prompt);
+      return { command: "opencode", args };
+    },
+    parseStdoutLine(parsed) {
+      const result = {};
+      const type = parsed.type;
+      if (type === "usage" || type === "turn.completed") {
+        const usage = parsed.usage ?? parsed;
+        if (usage.input_tokens !== void 0 || usage.output_tokens !== void 0) {
+          result.tokenIncrement = {
+            input: usage.input_tokens ?? 0,
+            cachedInput: usage.cached_input_tokens ?? 0,
+            output: usage.output_tokens ?? 0
+          };
+        }
+      }
+      if (type === "message" || type === "assistant") {
+        const text = parsed.text ?? parsed.content ?? parsed.message;
+        if (typeof text === "string") {
+          result.message = text.slice(0, 600);
+        }
+      }
+      return result;
+    }
+  };
+}
+function getDriver(backend) {
+  switch (backend) {
+    case "codex":
+      return createCodexDriver();
+    case "claude-code":
+      return createClaudeCodeDriver();
+    case "opencode":
+      return createOpenCodeDriver();
+  }
+}
+var ALL_SINGLE_BACKENDS = ["codex", "claude-code", "opencode"];
+async function detectAvailableBackends() {
+  const available = [];
+  for (const backend of ALL_SINGLE_BACKENDS) {
+    try {
+      await getDriver(backend).checkVersion();
+      available.push(backend);
+    } catch {
+    }
+  }
+  return available;
+}
+var AgentReviewOrchestrator = class _AgentReviewOrchestrator {
+  constructor(config) {
+    this.config = config;
+    this.codexTimeoutMs = config.codexTimeoutMs ?? 6e5;
+    this.codexInactivityTimeoutMs = config.codexInactivityTimeoutMs ?? 18e4;
+    this.driver = config.backend === "mixed" ? getDriver("claude-code") : getDriver(config.backend);
+    const startedAt = nowIso();
+    this.snapshot = {
+      runId: "pending",
+      phase: "initializing",
+      statusMessage: "Bootstrapping run",
+      startedAt,
+      lastUpdatedAt: startedAt,
+      done: false,
+      failed: false,
+      backend: config.backend,
+      targetPaths: [],
+      agents: [],
+      issueMetrics: { found: 0, open: 0, assigned: 0, fixed: 0, failed: 0 },
+      tokenUsage: { ...EMPTY_USAGE },
+      logs: []
+    };
+  }
+  listeners = /* @__PURE__ */ new Set();
+  snapshot;
+  createdWorktrees = /* @__PURE__ */ new Set();
+  codexTimeoutMs;
+  codexInactivityTimeoutMs;
+  driver;
+  drivers = /* @__PURE__ */ new Map();
+  agentBackends = /* @__PURE__ */ new Map();
+  preparedCodexHomes = /* @__PURE__ */ new Map();
+  availableBackends = [];
+  lastEmitTime = 0;
+  emitTimer = null;
+  persistQueue = Promise.resolve();
+  issueStore;
+  issueCounter = 1;
+  runId = "";
+  repoRoot = "";
+  currentBranch = "";
+  baseCommit = "";
+  runDir = "";
+  worktreesDir = "";
+  codexHomesDir = "";
+  issueFile = "";
+  reportFile = "";
+  targetPathsAbs = [];
+  targetFiles = [];
+  sharedWorktree;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.cloneSnapshot());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getSnapshot() {
+    return this.cloneSnapshot();
+  }
+  async run() {
+    try {
+      await this.initialize();
+      await this.runPlanningPhase();
+      await this.runDiscoveryPhase();
+      await this.runFixPhase();
+      await this.runVerificationPhase();
+      try {
+        await this.publishIntegrationBranch();
+      } catch (error) {
+        this.addLog(`Publishing failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      this.setPhase("complete", "Run complete");
+      this.snapshot.done = true;
+      this.emitSnapshotNow();
+      return {
+        success: true,
+        runDir: this.runDir,
+        issueFile: this.issueFile,
+        reportFile: this.reportFile,
+        integrationWorktree: this.snapshot.integrationWorktree,
+        integrationBranch: this.snapshot.integrationBranch,
+        prUrl: this.snapshot.prUrl
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.snapshot.failed = true;
+      this.snapshot.error = message;
+      this.snapshot.done = true;
+      this.setPhase("failed", "Run failed");
+      this.addLog(`Run failed: ${message}`);
+      this.emitSnapshotNow();
+      return {
+        success: false,
+        runDir: this.runDir || void 0,
+        issueFile: this.issueFile || void 0,
+        reportFile: this.reportFile || void 0,
+        integrationWorktree: this.snapshot.integrationWorktree,
+        integrationBranch: this.snapshot.integrationBranch,
+        prUrl: this.snapshot.prUrl,
+        error: message
+      };
+    } finally {
+      if (this.config.cleanup) {
+        await this.cleanupWorktrees();
+      } else {
+        await this.cleanupCodexHomes();
+      }
+    }
+  }
+  /* -- State management ------------------------------------------- */
+  cloneSnapshot() {
+    return {
+      ...this.snapshot,
+      targetPaths: [...this.snapshot.targetPaths],
+      agents: this.snapshot.agents.map((agent) => ({
+        ...agent,
+        tokenUsage: { ...agent.tokenUsage }
+      })),
+      issueMetrics: { ...this.snapshot.issueMetrics },
+      tokenUsage: { ...this.snapshot.tokenUsage },
+      logs: [...this.snapshot.logs]
+    };
+  }
+  /** Throttled emit — batches rapid updates to ~4 renders/sec */
+  emitSnapshot() {
+    this.snapshot.lastUpdatedAt = nowIso();
+    this.recomputeDerivedMetrics();
+    const now = Date.now();
+    const sinceLast = now - this.lastEmitTime;
+    if (sinceLast >= 250) {
+      this.lastEmitTime = now;
+      if (this.emitTimer) {
+        clearTimeout(this.emitTimer);
+        this.emitTimer = null;
+      }
+      this.flushSnapshot();
+      return;
+    }
+    if (!this.emitTimer) {
+      this.emitTimer = setTimeout(() => {
+        this.emitTimer = null;
+        this.lastEmitTime = Date.now();
+        this.snapshot.lastUpdatedAt = nowIso();
+        this.recomputeDerivedMetrics();
+        this.flushSnapshot();
+      }, 250 - sinceLast);
+    }
+  }
+  /** Immediate emit — used for phase transitions and run completion */
+  emitSnapshotNow() {
+    if (this.emitTimer) {
+      clearTimeout(this.emitTimer);
+      this.emitTimer = null;
+    }
+    this.snapshot.lastUpdatedAt = nowIso();
+    this.recomputeDerivedMetrics();
+    this.lastEmitTime = Date.now();
+    this.flushSnapshot();
+  }
+  flushSnapshot() {
+    const clone = this.cloneSnapshot();
+    for (const listener of this.listeners) {
+      listener(clone);
+    }
+  }
+  addLog(message) {
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+    this.snapshot.logs.push(`[${stamp}] ${message}`);
+    this.emitSnapshot();
+  }
+  recomputeDerivedMetrics() {
+    let input2 = 0;
+    let cachedInput = 0;
+    let output2 = 0;
+    for (const agent of this.snapshot.agents) {
+      input2 += agent.tokenUsage.input;
+      cachedInput += agent.tokenUsage.cachedInput;
+      output2 += agent.tokenUsage.output;
+    }
+    this.snapshot.tokenUsage = { input: input2, cachedInput, output: output2 };
+    if (!this.issueStore) {
+      this.snapshot.issueMetrics = { found: 0, open: 0, assigned: 0, fixed: 0, failed: 0 };
+      return;
+    }
+    let open = 0;
+    let assigned = 0;
+    let fixed = 0;
+    let failed = 0;
+    for (const issue of this.issueStore.issues) {
+      if (issue.status === "open") open += 1;
+      if (issue.status === "assigned") assigned += 1;
+      if (issue.status === "fixed") fixed += 1;
+      if (issue.status === "failed") failed += 1;
+    }
+    this.snapshot.issueMetrics = { found: this.issueStore.issues.length, open, assigned, fixed, failed };
+  }
+  setPhase(phase, statusMessage) {
+    this.snapshot.phase = phase;
+    this.snapshot.statusMessage = statusMessage;
+    this.emitSnapshotNow();
+  }
+  getAgent(agentId) {
+    const agent = this.snapshot.agents.find((entry) => entry.id === agentId);
+    if (!agent) throw new Error(`Agent not found: ${agentId}`);
+    return agent;
+  }
+  createAgent(input2) {
+    const agent = {
+      id: input2.id,
+      index: input2.index,
+      kind: input2.kind,
+      status: "pending",
+      branch: input2.branch,
+      worktreePath: input2.worktreePath,
+      issuesAssigned: input2.issuesAssigned,
+      issuesFound: 0,
+      issuesFixed: 0,
+      tokenUsage: { ...EMPTY_USAGE },
+      stepsCompleted: 0,
+      stepsTotal: 0
+    };
+    this.snapshot.agents.push(agent);
+    this.emitSnapshot();
+    return agent;
+  }
+  updateAgent(agentId, patch) {
+    const agent = this.getAgent(agentId);
+    Object.assign(agent, patch);
+    this.emitSnapshot();
+  }
+  addAgentUsage(agentId, usage) {
+    const agent = this.getAgent(agentId);
+    agent.tokenUsage = {
+      input: agent.tokenUsage.input + usage.input,
+      cachedInput: agent.tokenUsage.cachedInput + usage.cachedInput,
+      output: agent.tokenUsage.output + usage.output
+    };
+    this.emitSnapshot();
+  }
+  /* -- Initialize ------------------------------------------------- */
+  async initialize() {
+    this.setPhase("initializing", "Resolving repository context");
+    const gitRoot = (await runCommand("git", ["rev-parse", "--show-toplevel"], { cwd: this.config.startCwd })).stdout.trim();
+    if (!gitRoot) throw new Error("Unable to resolve git repository root");
+    this.repoRoot = gitRoot;
+    const branch = (await runCommand("git", ["-C", this.repoRoot, "branch", "--show-current"])).stdout.trim();
+    this.currentBranch = branch || (await runCommand("git", ["-C", this.repoRoot, "rev-parse", "--short", "HEAD"])).stdout.trim();
+    this.baseCommit = (await runCommand("git", ["-C", this.repoRoot, "rev-parse", "HEAD"])).stdout.trim();
+    if (this.config.backend === "mixed") {
+      this.availableBackends = await detectAvailableBackends();
+      if (this.availableBackends.length === 0) {
+        throw new Error("No backends available. Install at least one of: codex, claude, opencode");
+      }
+      for (const b of this.availableBackends) {
+        this.drivers.set(b, getDriver(b));
+      }
+      this.addLog(`Mixed mode: available backends: ${this.availableBackends.join(", ")}`);
+    } else {
+      await this.driver.checkVersion();
+      const singleBackend = this.config.backend;
+      this.availableBackends = [singleBackend];
+      this.drivers.set(singleBackend, this.driver);
+    }
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replaceAll(/[-:TZ.]/g, "").slice(0, 14);
+    this.runId = `${stamp}-${randomUUID().slice(0, 8)}`;
+    this.runDir = path.join(this.repoRoot, ".agent-review", "runs", this.runId);
+    this.worktreesDir = path.join(this.repoRoot, ".agent-review", "worktrees", this.runId);
+    this.codexHomesDir = path.join(os.tmpdir(), "agent-review-codex-homes", this.runId);
+    this.issueFile = path.join(this.runDir, "issues.json");
+    this.reportFile = path.join(this.runDir, "final-report.md");
+    await fs.mkdir(this.runDir, { recursive: true });
+    await fs.mkdir(this.worktreesDir, { recursive: true });
+    await fs.mkdir(this.codexHomesDir, { recursive: true });
+    const sharedBranch = `agent-review/${this.runId}`;
+    this.sharedWorktree = await this.createWorktree({ label: "shared", branch: sharedBranch });
+    const codexDir = path.join(this.sharedWorktree.path, ".agent-review");
+    const resultDir = path.join(codexDir, "results");
+    await fs.mkdir(resultDir, { recursive: true });
+    this.snapshot.runId = this.runId;
+    this.snapshot.repoRoot = this.repoRoot;
+    this.snapshot.currentBranch = this.currentBranch;
+    this.snapshot.targetPrompt = this.config.targetPrompt;
+    this.snapshot.runDir = this.runDir;
+    this.snapshot.issueFile = this.issueFile;
+    this.snapshot.integrationBranch = sharedBranch;
+    this.snapshot.integrationWorktree = this.sharedWorktree.path;
+    this.addLog(`Run ID: ${this.runId}`);
+    this.addLog(`Repository: ${this.repoRoot}`);
+    this.addLog(`Branch: ${this.currentBranch}`);
+    this.addLog(`Backend: ${this.config.backend}`);
+    this.addLog(`Worktree: ${this.sharedWorktree.path}`);
+  }
+  /* -- Planning phase: use agent to identify the right codebase --- */
+  async runPlanningPhase() {
+    this.setPhase("planning", "Identifying target codebase");
+    const directPaths = await this.resolveDirectPaths();
+    if (directPaths.length > 0) {
+      this.targetPathsAbs = directPaths;
+      this.targetFiles = await this.collectTargetFiles(this.targetPathsAbs);
+      await this.finalizePlanningResults();
+      this.addLog("Target resolved via direct path match");
+      return;
+    }
+    const dirTree = await this.buildDirectoryOverview();
+    const plannerAgentId = "planner-1";
+    this.assignBackend(plannerAgentId, 1);
+    this.createAgent({
+      id: plannerAgentId,
+      index: 1,
+      kind: "planner",
+      issuesAssigned: 0
+    });
+    this.updateAgent(plannerAgentId, { status: "running", startedAt: nowIso(), lastMessage: "Analyzing repository structure" });
+    const plannerPrompt = [
+      "You are a codebase navigation agent. Your ONLY job is to identify which directories/paths in this repository match the user's request.",
+      "",
+      `User request: "${this.config.targetPrompt}"`,
+      "",
+      "Repository structure (top-level directories and their immediate children):",
+      dirTree,
+      "",
+      "Instructions:",
+      "1. Based on the user's request, identify the most relevant directory paths to focus a code review on.",
+      '2. Return ONLY a JSON object with this exact structure: {"paths": ["path/to/dir1", "path/to/dir2"], "reasoning": "brief explanation"}',
+      "3. Paths should be relative to the repository root.",
+      `4. Be specific - prefer deeper paths (e.g. "papertrail/web/app") over broad ones (e.g. "papertrail") when the user's request is specific.`,
+      "5. If the request mentions a specific project, app, or feature, narrow to that area.",
+      '6. If the request is general (e.g. "everything", "the whole repo"), return ["."].',
+      "7. Return ONLY the JSON, nothing else."
+    ].join("\n");
+    try {
+      const planWorktree = this.sharedWorktree;
+      const codexDir = path.join(planWorktree.path, ".agent-review");
+      const resultDir = path.join(codexDir, "results");
+      const schemaPath = path.join(codexDir, "planner-schema.json");
+      const outputPath = path.join(resultDir, "planner-output.json");
+      await fs.writeFile(schemaPath, JSON.stringify({
+        type: "object",
+        required: ["paths", "reasoning"],
+        properties: {
+          paths: { type: "array", items: { type: "string" } },
+          reasoning: { type: "string" }
+        }
+      }, null, 2), "utf8");
+      const result = await this.runBackendExec({
+        agentId: plannerAgentId,
+        cwd: planWorktree.path,
+        prompt: plannerPrompt,
+        schemaPath,
+        outputPath,
+        yolo: false
+      });
+      if (result.exitCode === 0) {
+        try {
+          const planOutput = await this.readJsonFile(outputPath);
+          if (planOutput.paths && planOutput.paths.length > 0) {
+            const resolvedPaths = [];
+            for (const p of planOutput.paths) {
+              const abs = path.resolve(this.repoRoot, p);
+              if (await pathExists(abs) && isInsidePath(abs, this.repoRoot)) {
+                resolvedPaths.push(abs);
+              }
+            }
+            if (resolvedPaths.length > 0) {
+              this.targetPathsAbs = resolvedPaths;
+              this.updateAgent(plannerAgentId, {
+                status: "completed",
+                endedAt: nowIso(),
+                lastMessage: planOutput.reasoning
+              });
+              this.addLog(`Planner identified ${resolvedPaths.length} target paths: ${planOutput.reasoning}`);
+            }
+          }
+        } catch {
+        }
+      }
+    } catch (error) {
+      this.updateAgent(plannerAgentId, {
+        status: "failed",
+        endedAt: nowIso(),
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.addLog("Planner failed, falling back to heuristic matching");
+    }
+    if (this.targetPathsAbs.length === 0) {
+      this.targetPathsAbs = await this.resolveHeuristicTargets();
+      if (this.targetPathsAbs.length === 0) {
+        const fallback = isInsidePath(this.config.startCwd, this.repoRoot) ? this.config.startCwd : this.repoRoot;
+        this.targetPathsAbs = [fallback];
+      }
+      const plannerAgent = this.snapshot.agents.find((a) => a.id === plannerAgentId);
+      if (plannerAgent && plannerAgent.status !== "completed") {
+        this.updateAgent(plannerAgentId, {
+          status: "completed",
+          endedAt: nowIso(),
+          lastMessage: "Resolved via heuristic fallback"
+        });
+      }
+    }
+    this.targetFiles = await this.collectTargetFiles(this.targetPathsAbs);
+    await this.finalizePlanningResults();
+  }
+  async finalizePlanningResults() {
+    this.issueStore = {
+      metadata: {
+        runId: this.runId,
+        createdAt: nowIso(),
+        updatedAt: nowIso(),
+        repoRoot: this.repoRoot,
+        currentBranch: this.currentBranch,
+        targetPrompt: this.config.targetPrompt,
+        targetPaths: this.targetPathsAbs.map((p) => normalizeSlashes(path.relative(this.repoRoot, p) || ".")),
+        instances: this.config.instances,
+        backend: this.config.backend
+      },
+      issues: []
+    };
+    this.snapshot.targetPaths = [...this.issueStore.metadata.targetPaths];
+    await this.persistIssueStore();
+    this.addLog(`Targets: ${this.snapshot.targetPaths.join(", ")}`);
+    this.addLog(`Review file count: ${this.targetFiles.length}`);
+  }
+  async buildDirectoryOverview() {
+    const lines = [];
+    try {
+      const entries = await fs.readdir(this.repoRoot, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        lines.push(`${entry.name}/`);
+        try {
+          const subEntries = await fs.readdir(path.join(this.repoRoot, entry.name), { withFileTypes: true });
+          const dirs = subEntries.filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules");
+          const files = subEntries.filter((e) => e.isFile());
+          for (const d of dirs.slice(0, 15)) {
+            lines.push(`  ${entry.name}/${d.name}/`);
+          }
+          if (dirs.length > 15) lines.push(`  ... ${dirs.length - 15} more directories`);
+          const keyFiles = files.filter(
+            (f) => ["package.json", "Cargo.toml", "go.mod", "pyproject.toml", "README.md", "Makefile"].includes(f.name)
+          );
+          for (const f of keyFiles) {
+            lines.push(`  ${entry.name}/${f.name}`);
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return lines.join("\n");
+  }
+  async resolveDirectPaths() {
+    const prompt = this.config.targetPrompt.trim();
+    if (!prompt || /^(current(\s+directory)?|here|\.|cwd)$/i.test(prompt)) {
+      const fallback = isInsidePath(this.config.startCwd, this.repoRoot) ? this.config.startCwd : this.repoRoot;
+      return [fallback];
+    }
+    const candidates = prompt.split(/,| and /gi).map((p) => p.trim()).filter(Boolean);
+    const found = /* @__PURE__ */ new Set();
+    for (const candidate of candidates) {
+      const abs = path.isAbsolute(candidate) ? candidate : path.resolve(this.config.startCwd, candidate);
+      if (await pathExists(abs) && isInsidePath(path.resolve(abs), this.repoRoot)) {
+        found.add(path.resolve(abs));
+      }
+      const repoRel = path.resolve(this.repoRoot, candidate);
+      if (await pathExists(repoRel) && isInsidePath(path.resolve(repoRel), this.repoRoot)) {
+        found.add(path.resolve(repoRel));
+      }
+    }
+    return [...found];
+  }
+  async resolveHeuristicTargets() {
+    const prompt = this.config.targetPrompt.trim().toLowerCase();
+    const entries = await fs.readdir(this.repoRoot, { withFileTypes: true });
+    const scored = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      const name = entry.name.toLowerCase();
+      let score = 0;
+      if (name === prompt) score = 100;
+      else if (name.startsWith(prompt)) score = 80;
+      else if (name.includes(prompt)) score = 65;
+      else {
+        const promptTokens = prompt.split(/\s+/g).filter(Boolean);
+        const nameTokens = name.split(/[-_/.\s]+/g);
+        const overlap = promptTokens.filter((t) => nameTokens.includes(t)).length;
+        if (overlap > 0) score = 40 + overlap * 10;
+      }
+      if (score > 0) scored.push({ score, fullPath: path.join(this.repoRoot, entry.name) });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    if (scored.length > 0) {
+      const best = scored[0].score;
+      return scored.filter((s) => s.score >= Math.max(60, best - 10)).slice(0, 3).map((s) => s.fullPath);
+    }
+    return [];
+  }
+  /* -- File collection -------------------------------------------- */
+  async collectTargetFiles(targetPaths) {
+    const relTargets = targetPaths.map((p) => normalizeSlashes(path.relative(this.repoRoot, p) || "."));
+    let files = [];
+    try {
+      const { stdout } = await runCommand("git", ["-C", this.repoRoot, "ls-files", "-z", "--", ...relTargets]);
+      files = stdout.split("\0").map((e) => e.trim()).filter(Boolean).filter((e) => this.shouldReviewFile(e));
+    } catch {
+      files = [];
+    }
+    if (files.length > 0) return files;
+    const discovered = /* @__PURE__ */ new Set();
+    for (const targetPath of targetPaths) {
+      const stats = await fs.stat(targetPath);
+      if (stats.isFile()) {
+        const rel = normalizeSlashes(path.relative(this.repoRoot, targetPath));
+        if (this.shouldReviewFile(rel)) discovered.add(rel);
+        continue;
+      }
+      const stack = [targetPath];
+      while (stack.length > 0) {
+        const current = stack.pop();
+        const dirEntries = await fs.readdir(current, { withFileTypes: true });
+        for (const dirEntry of dirEntries) {
+          const absolute = path.join(current, dirEntry.name);
+          if (dirEntry.isDirectory()) {
+            const relDir = normalizeSlashes(path.relative(this.repoRoot, absolute));
+            if (IGNORED_PATH_SEGMENTS.some((seg) => `/${relDir}/`.includes(seg) || relDir.startsWith(seg.slice(1)))) continue;
+            stack.push(absolute);
+            continue;
+          }
+          if (!dirEntry.isFile()) continue;
+          const relFile = normalizeSlashes(path.relative(this.repoRoot, absolute));
+          if (this.shouldReviewFile(relFile)) discovered.add(relFile);
+        }
+      }
+    }
+    return [...discovered].sort();
+  }
+  shouldReviewFile(relPath) {
+    const normalized = `/${normalizeSlashes(relPath)}`;
+    if (IGNORED_PATH_SEGMENTS.some((seg) => normalized.includes(seg))) return false;
+    const fileName = path.basename(relPath).toLowerCase();
+    if (fileName === "pnpm-lock.yaml" || fileName.endsWith(".lock")) return false;
+    if (BINARY_FILE_PATTERN.test(fileName)) return false;
+    if (/\.min\.(js|css)$/.test(fileName)) return false;
+    const ext = path.extname(fileName);
+    if (!ext) return true;
+    return REVIEWABLE_EXTENSIONS.has(ext);
+  }
+  splitIntoSegments(items) {
+    const count = Math.max(1, this.config.instances);
+    const segments = Array.from({ length: count }, () => []);
+    for (let i = 0; i < items.length; i += 1) {
+      segments[i % count].push(items[i]);
+    }
+    return segments;
+  }
+  /**
+   * Split files into segments grouped by directory so each agent gets
+   * coherent directory-level ownership rather than scattered files.
+   * Large directory groups are sub-divided at deeper path levels to
+   * ensure even distribution across agents.
+   */
+  splitFilesIntoDirectorySegments(files) {
+    const count = Math.max(1, this.config.instances);
+    if (files.length === 0) return Array.from({ length: count }, () => []);
+    const maxPerSegment = Math.ceil(files.length / count);
+    const buildGroups = (items, depth) => {
+      const groups = /* @__PURE__ */ new Map();
+      for (const file of items) {
+        const parts = file.split("/");
+        const key = parts.slice(0, Math.min(depth, parts.length - 1)).join("/") || ".";
+        const group = groups.get(key) ?? [];
+        group.push(file);
+        groups.set(key, group);
+      }
+      return groups;
+    };
+    const chunks = [];
+    const pending = /* @__PURE__ */ new Map();
+    const initial = buildGroups(files, 2);
+    for (const [k, gf] of initial) {
+      pending.set(k, gf);
+    }
+    for (let depth = 3; depth <= 5; depth += 1) {
+      const next = /* @__PURE__ */ new Map();
+      for (const [, groupFiles] of pending) {
+        if (groupFiles.length <= maxPerSegment) {
+          chunks.push(groupFiles);
+        } else {
+          const sub = buildGroups(groupFiles, depth);
+          for (const [sk, sf] of sub) {
+            next.set(sk, sf);
+          }
+        }
+      }
+      pending.clear();
+      for (const [k, gf] of next) {
+        pending.set(k, gf);
+      }
+    }
+    for (const [, groupFiles] of pending) {
+      chunks.push(groupFiles);
+    }
+    chunks.sort((a, b) => b.length - a.length);
+    const segments = Array.from({ length: count }, () => []);
+    for (const chunk of chunks) {
+      let minIdx = 0;
+      for (let i = 1; i < count; i += 1) {
+        if (segments[i].length < segments[minIdx].length) minIdx = i;
+      }
+      segments[minIdx].push(...chunk);
+    }
+    return segments;
+  }
+  /* -- Discovery phase -------------------------------------------- */
+  async runDiscoveryPhase() {
+    this.setPhase("discovery", "Running discovery agents");
+    const segments = this.splitFilesIntoDirectorySegments(this.targetFiles);
+    if (this.targetFiles.length === 0) {
+      this.addLog("No files matched the selected target. Skipping discovery.");
+      return;
+    }
+    const worktree = this.sharedWorktree;
+    for (let i = 1; i <= this.config.instances; i += 1) {
+      const agentId = `discovery-${i}`;
+      const backend = this.assignBackend(agentId, i);
+      this.createAgent({
+        id: agentId,
+        index: i,
+        kind: "discovery",
+        branch: worktree.branch,
+        worktreePath: worktree.path,
+        issuesAssigned: segments[i - 1]?.length ?? 0
+      });
+      this.addLog(`${agentId} assigned to ${backend}`);
+    }
+    await Promise.all(
+      Array.from({ length: this.config.instances }, (_, index) => {
+        const agentId = `discovery-${index + 1}`;
+        const segment = segments[index] ?? [];
+        return this.runDiscoveryAgent(agentId, worktree, segment);
+      })
+    );
+    const actionableAgents = segments.filter((segment) => segment.length > 0).length;
+    const failedAgents = this.snapshot.agents.filter((agent) => agent.kind === "discovery" && agent.status === "failed").length;
+    if (actionableAgents > 0 && failedAgents >= actionableAgents) {
+      throw new Error(`All discovery agents failed (${failedAgents}/${actionableAgents}).`);
+    }
+    this.addLog(`Discovery complete. Findings: ${this.issueStore?.issues.length ?? 0}`);
+  }
+  async runDiscoveryAgent(agentId, worktree, segment) {
+    if (segment.length === 0) {
+      this.updateAgent(agentId, { status: "skipped", startedAt: nowIso(), endedAt: nowIso(), lastMessage: "No files assigned" });
+      return;
+    }
+    this.updateAgent(agentId, { status: "running", startedAt: nowIso(), lastMessage: `Reviewing ${segment.length} files` });
+    this.addLog(`${agentId} started (${segment.length} files)`);
+    const codexDir = path.join(worktree.path, ".agent-review");
+    const resultDir = path.join(codexDir, "results");
+    const manifestPath = path.join(codexDir, `${agentId}-manifest.txt`);
+    const schemaPath = path.join(codexDir, `${agentId}-schema.json`);
+    const outputPath = path.join(resultDir, `${agentId}-output.json`);
+    const schema = this.discoverySchema();
+    await fs.writeFile(manifestPath, `${segment.join("\n")}
+`, "utf8");
+    await fs.writeFile(schemaPath, JSON.stringify(schema, null, 2), "utf8");
+    let prompt = this.discoveryPrompt(agentId, segment, manifestPath);
+    if (this.isClaudeCode(agentId)) {
+      prompt += `
+
+CRITICAL OUTPUT REQUIREMENT:`;
+      prompt += `
+You MUST write your results as valid JSON to this exact file path: ${outputPath}`;
+      prompt += `
+Use the Write tool to create this file. The JSON must match this schema:
+${JSON.stringify(schema, null, 2)}`;
+      prompt += `
+If you find no issues, still write the file with an empty issues array: {"summary": "No issues found.", "issues": []}`;
+      prompt += `
+Write the JSON file BEFORE your final response. Your final text response should just be the summary.`;
+      prompt += `
+Failing to write this file will cause the entire review run to fail.`;
+    }
+    try {
+      const result = await this.runBackendExec({ agentId, cwd: worktree.path, prompt, schemaPath, outputPath, yolo: false });
+      if (result.exitCode !== 0) {
+        const errMsg = result.stderr || result.lastMessage || `exited with code ${result.exitCode}`;
+        this.updateAgent(agentId, { status: "failed", endedAt: nowIso(), error: errMsg, lastMessage: errMsg.slice(0, 600) });
+        this.addLog(`${agentId} failed (exit ${result.exitCode}): ${errMsg.slice(0, 300)}`);
+        return;
+      }
+      let payload;
+      try {
+        payload = await this.readJsonFile(outputPath);
+      } catch (readError) {
+        const msg = readError instanceof Error ? readError.message : String(readError);
+        this.updateAgent(agentId, { status: "failed", endedAt: nowIso(), error: `Failed to read output: ${msg}` });
+        this.addLog(`${agentId} failed: could not read output file`);
+        return;
+      }
+      const createdIssues = payload.issues.map((item) => {
+        const issueId = `ISS-${String(this.issueCounter++).padStart(4, "0")}`;
+        const normalizedFile = this.normalizeIssueFile(item.location.file, worktree.path);
+        const line = typeof item.location.line === "number" ? item.location.line : void 0;
+        return {
+          id: issueId,
+          title: item.title.trim(),
+          description: item.description.trim(),
+          suggestedFix: item.suggested_fix.trim(),
+          severity: this.normalizeSeverity(item.severity),
+          location: { file: normalizedFile, line },
+          status: "open",
+          discoveredBy: agentId,
+          confidence: typeof item.confidence === "number" ? item.confidence : void 0
+        };
+      });
+      if (this.issueStore) {
+        this.issueStore.issues.push(...createdIssues);
+      }
+      await this.persistIssueStore();
+      this.updateAgent(agentId, {
+        status: "completed",
+        endedAt: nowIso(),
+        issuesFound: createdIssues.length,
+        lastMessage: payload.summary
+      });
+      this.addLog(`${agentId} completed with ${createdIssues.length} findings`);
+    } catch (error) {
+      this.updateAgent(agentId, { status: "failed", endedAt: nowIso(), error: error instanceof Error ? error.message : String(error) });
+      this.addLog(`${agentId} errored`);
+    }
+  }
+  /* -- Fix phase -------------------------------------------------- */
+  async runFixPhase() {
+    this.setPhase("fixing", "Running fix agents");
+    if (!this.issueStore) return;
+    const openIssues = this.issueStore.issues.filter((issue) => issue.status === "open");
+    if (openIssues.length === 0) {
+      this.addLog("No open issues discovered. Skipping fix phase.");
+      return;
+    }
+    const integrationWorktree = this.sharedWorktree;
+    const chunks = this.splitIntoSegments(openIssues);
+    const agentWork = [];
+    for (let i = 1; i <= this.config.instances; i += 1) {
+      const agentId = `fix-${i}`;
+      const chunk = chunks[i - 1] ?? [];
+      this.assignBackend(agentId, i);
+      if (chunk.length === 0) {
+        this.createAgent({
+          id: agentId,
+          index: i,
+          kind: "fix",
+          branch: integrationWorktree.branch,
+          worktreePath: integrationWorktree.path,
+          issuesAssigned: 0
+        });
+        this.updateAgent(agentId, { status: "skipped", startedAt: nowIso(), endedAt: nowIso(), lastMessage: "No issues assigned" });
+        continue;
+      }
+      const fixBranch = `${integrationWorktree.branch}-fix-${i}`;
+      const worktree = await this.createWorktree({ label: `fix-${i}`, branch: fixBranch, startPoint: integrationWorktree.branch });
+      const resultDir = path.join(worktree.path, ".agent-review", "results");
+      await fs.mkdir(resultDir, { recursive: true });
+      this.createAgent({
+        id: agentId,
+        index: i,
+        kind: "fix",
+        branch: fixBranch,
+        worktreePath: worktree.path,
+        issuesAssigned: chunk.length
+      });
+      for (const issue of chunk) {
+        issue.status = "assigned";
+        issue.assignedTo = agentId;
+      }
+      agentWork.push({ agentId, worktree, issues: chunk });
+    }
+    await this.persistIssueStore();
+    await Promise.all(
+      agentWork.map(
+        ({ agentId, worktree, issues }) => this.runFixAgent(agentId, worktree, issues)
+      )
+    );
+    if (agentWork.some(({ agentId }) => {
+      const a = this.getAgent(agentId);
+      return a.status === "completed" && a.issuesFixed > 0;
+    })) {
+      this.setPhase("integrating", "Merging fix branches");
+      for (const { agentId, worktree } of agentWork) {
+        const agent = this.getAgent(agentId);
+        if (agent.status !== "completed" || agent.issuesFixed === 0) continue;
+        const merge = await runCommand("git", [
+          "-C",
+          integrationWorktree.path,
+          "merge",
+          worktree.branch,
+          "-m",
+          `merge: integrate fixes from ${agentId}`
+        ], { allowFailure: true });
+        if (merge.code === 0) {
+          this.addLog(`Merged ${agentId} fixes into integration branch`);
+        } else {
+          await runCommand("git", ["-C", integrationWorktree.path, "merge", "--abort"], { allowFailure: true });
+          const retry = await runCommand("git", [
+            "-C",
+            integrationWorktree.path,
+            "merge",
+            "-X",
+            "theirs",
+            worktree.branch,
+            "-m",
+            `merge: integrate fixes from ${agentId} (auto-resolved)`
+          ], { allowFailure: true });
+          if (retry.code === 0) {
+            this.addLog(`Merged ${agentId} fixes (auto-resolved conflicts)`);
+          } else {
+            await runCommand("git", ["-C", integrationWorktree.path, "merge", "--abort"], { allowFailure: true });
+            this.addLog(`Could not merge ${agentId} fixes \u2014 skipped`);
+          }
+        }
+      }
+    }
+    this.addLog(`Fix phase complete. Fixed: ${this.snapshot.issueMetrics.fixed}`);
+  }
+  async runFixAgent(agentId, worktree, assignedIssues) {
+    this.updateAgent(agentId, { status: "running", startedAt: nowIso(), lastMessage: `Fixing ${assignedIssues.length} issues` });
+    this.addLog(`${agentId} started (${assignedIssues.length} issues)`);
+    const codexDir = path.join(worktree.path, ".agent-review");
+    const resultDir = path.join(codexDir, "results");
+    const assignmentPath = path.join(codexDir, `${agentId}-issues.json`);
+    const schemaPath = path.join(codexDir, `${agentId}-schema.json`);
+    const outputPath = path.join(resultDir, `${agentId}-output.json`);
+    const schema = this.fixSchema();
+    await fs.writeFile(assignmentPath, JSON.stringify({ assigned_issue_ids: assignedIssues.map((i) => i.id), issues: assignedIssues }, null, 2), "utf8");
+    await fs.writeFile(schemaPath, JSON.stringify(schema, null, 2), "utf8");
+    let prompt = this.fixPrompt(agentId, assignedIssues, assignmentPath);
+    if (this.isClaudeCode(agentId)) {
+      prompt += `
+
+CRITICAL OUTPUT REQUIREMENT:`;
+      prompt += `
+After making fixes, you MUST write your results as valid JSON to this exact file path: ${outputPath}`;
+      prompt += `
+Use the Write tool to create this file. The JSON must match this schema:
+${JSON.stringify(schema, null, 2)}`;
+      prompt += `
+Each assigned issue ID must appear exactly once in the results array.`;
+      prompt += `
+Write the JSON file BEFORE your final response. Your final text response should just be the summary.`;
+      prompt += `
+Failing to write this file will cause the entire fix run to fail.`;
+    }
+    try {
+      const result = await this.runBackendExec({ agentId, cwd: worktree.path, prompt, schemaPath, outputPath, yolo: true });
+      if (result.exitCode !== 0) {
+        const errMsg = result.stderr || `exited with ${result.exitCode}`;
+        for (const issue of assignedIssues) {
+          issue.status = "failed";
+          issue.failureReason = `fix agent failed: ${errMsg}`;
+        }
+        await this.persistIssueStore();
+        this.updateAgent(agentId, { status: "failed", endedAt: nowIso(), error: errMsg, lastMessage: errMsg.slice(0, 600) });
+        this.addLog(`${agentId} failed: ${errMsg.slice(0, 200)}`);
+        return;
+      }
+      const commitCreated = await this.commitIfDirty(worktree.path, `fix(agent-review): resolve assigned issues (${agentId})`);
+      let payload;
+      try {
+        payload = await this.readJsonFile(outputPath);
+      } catch {
+        if (commitCreated) {
+          this.addLog(`${agentId}: no output file but commit created \u2014 assuming fixes applied`);
+          payload = {
+            summary: result.lastMessage ?? "Fixes applied (output file not written)",
+            results: assignedIssues.map((i) => ({
+              issue_id: i.id,
+              status: "fixed",
+              fix_summary: result.lastMessage ?? "Fixed (inferred from commit)",
+              files_touched: []
+            }))
+          };
+        } else {
+          for (const issue of assignedIssues) {
+            issue.status = "failed";
+            issue.failureReason = "Agent completed but wrote no output and made no code changes";
+          }
+          await this.persistIssueStore();
+          this.updateAgent(agentId, { status: "failed", endedAt: nowIso(), error: "No output file and no code changes" });
+          this.addLog(`${agentId} failed: no output file and no code changes`);
+          return;
+        }
+      }
+      const byIssueId = new Map(payload.results.map((item) => [item.issue_id, item]));
+      const fixedIssueIds = [];
+      for (const issue of assignedIssues) {
+        const entry = byIssueId.get(issue.id);
+        if (entry?.status === "fixed" && commitCreated) {
+          issue.status = "fixed";
+          issue.fixedBy = agentId;
+          issue.fixSummary = entry.fix_summary;
+          issue.failureReason = void 0;
+          fixedIssueIds.push(issue.id);
+          continue;
+        }
+        issue.status = "failed";
+        issue.failureReason = entry?.fix_summary || "Issue not fixed or no code changes were committed";
+      }
+      await this.persistIssueStore();
+      this.updateAgent(agentId, { status: "completed", endedAt: nowIso(), issuesFixed: fixedIssueIds.length, lastMessage: payload.summary });
+      this.addLog(`${agentId} completed with ${fixedIssueIds.length} fixes`);
+    } catch (error) {
+      for (const issue of assignedIssues) {
+        issue.status = "failed";
+        issue.failureReason = `fix agent exception: ${error instanceof Error ? error.message : String(error)}`;
+      }
+      await this.persistIssueStore();
+      this.updateAgent(agentId, { status: "failed", endedAt: nowIso(), error: error instanceof Error ? error.message : String(error) });
+      this.addLog(`${agentId} errored`);
+    }
+  }
+  /* -- Verification ------------------------------------------------ */
+  async runVerificationPhase() {
+    this.setPhase("verifying", "Running final verification agent");
+    const worktree = this.sharedWorktree;
+    const finalAgentId = "final-1";
+    this.assignBackend(finalAgentId, 1);
+    this.createAgent({ id: finalAgentId, index: 1, kind: "final", branch: worktree.branch, worktreePath: worktree.path, issuesAssigned: 0 });
+    this.updateAgent(finalAgentId, { status: "running", startedAt: nowIso(), lastMessage: "Running validation checks" });
+    const codexDir = path.join(worktree.path, ".agent-review");
+    const resultDir = path.join(codexDir, "results");
+    const schema = this.verificationSchema();
+    const schemaPath = path.join(codexDir, "verify-schema.json");
+    const outputPath = path.join(resultDir, "verify-output.json");
+    await fs.writeFile(schemaPath, JSON.stringify(schema, null, 2), "utf8");
+    let prompt = this.verificationPrompt();
+    if (this.isClaudeCode(finalAgentId)) {
+      prompt += `
+
+CRITICAL OUTPUT REQUIREMENT:`;
+      prompt += `
+After verification, you MUST write your results as valid JSON to this exact file path: ${outputPath}`;
+      prompt += `
+Use the Write tool to create this file. The JSON must match this schema:
+${JSON.stringify(schema, null, 2)}`;
+      prompt += `
+Write the JSON file BEFORE your final response. Your final text response should just be the summary.`;
+      prompt += `
+Failing to write this file will cause the entire verification to fail.`;
+    }
+    try {
+      const result = await this.runBackendExec({ agentId: finalAgentId, cwd: worktree.path, prompt, schemaPath, outputPath, yolo: true });
+      if (result.exitCode !== 0) {
+        const errMsg = result.stderr || `exited with ${result.exitCode}`;
+        this.updateAgent(finalAgentId, { status: "failed", endedAt: nowIso(), error: errMsg, lastMessage: errMsg.slice(0, 600) });
+        this.addLog(`Final verification agent failed: ${errMsg.slice(0, 200)}`);
+        await this.writeFinalReport(void 0, `Final verification agent failed: ${errMsg}`);
+        throw new VerificationFailure(`Final verification agent failed: ${errMsg}`);
+      }
+      let payload;
+      try {
+        payload = await this.readJsonFile(outputPath);
+      } catch (readError) {
+        const msg = readError instanceof Error ? readError.message : String(readError);
+        this.updateAgent(finalAgentId, { status: "failed", endedAt: nowIso(), error: `Failed to read output: ${msg}` });
+        this.addLog("Final verification failed: could not read output file");
+        await this.writeFinalReport(void 0, `Could not read verification output: ${msg}`);
+        throw new VerificationFailure(`Could not read verification output: ${msg}`);
+      }
+      await this.commitIfDirty(worktree.path, "chore(agent-review): final verification follow-ups");
+      this.updateAgent(finalAgentId, { status: "completed", endedAt: nowIso(), lastMessage: payload.summary });
+      this.addLog("Final verification completed");
+      await this.writeFinalReport(payload);
+    } catch (error) {
+      if (error instanceof VerificationFailure) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      this.updateAgent(finalAgentId, { status: "failed", endedAt: nowIso(), error: message });
+      this.addLog("Final verification errored");
+      await this.writeFinalReport(void 0, message);
+      throw new VerificationFailure(message);
+    }
+  }
+  /* -- Publish: rebase, push, and create PR ------------------------ */
+  async getDefaultBranch() {
+    try {
+      const result = await runCommand("gh", ["repo", "view", "--json", "defaultBranchRef", "--jq", ".defaultBranchRef.name"], { cwd: this.repoRoot });
+      const branch = result.stdout.trim();
+      if (branch) return branch;
+    } catch {
+    }
+    try {
+      const result = await runCommand("git", ["-C", this.repoRoot, "symbolic-ref", "refs/remotes/origin/HEAD"], { allowFailure: true });
+      const match = result.stdout.trim().match(/refs\/remotes\/origin\/(.+)/);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+    return "main";
+  }
+  async publishIntegrationBranch() {
+    const worktree = this.sharedWorktree;
+    const branch = this.snapshot.integrationBranch;
+    if (!worktree || !branch) {
+      this.addLog("Skipping publish: no integration branch");
+      return;
+    }
+    const currentHead = (await runCommand("git", ["-C", worktree.path, "rev-parse", "HEAD"])).stdout.trim();
+    if (currentHead === this.baseCommit) {
+      this.addLog("No changes to publish");
+      return;
+    }
+    this.setPhase("publishing", "Rebasing and publishing PR");
+    try {
+      const defaultBranch = await this.getDefaultBranch();
+      this.addLog(`Default branch: ${defaultBranch}`);
+      await runCommand("git", ["-C", worktree.path, "fetch", "origin", defaultBranch]);
+      const rebase = await runCommand("git", [
+        "-C",
+        worktree.path,
+        "rebase",
+        "-X",
+        "theirs",
+        `origin/${defaultBranch}`
+      ], { allowFailure: true });
+      if (rebase.code !== 0) {
+        this.addLog("Rebase had conflicts, attempting merge fallback");
+        await runCommand("git", ["-C", worktree.path, "rebase", "--abort"], { allowFailure: true });
+        const merge = await runCommand("git", [
+          "-C",
+          worktree.path,
+          "merge",
+          "-X",
+          "ours",
+          `origin/${defaultBranch}`,
+          "-m",
+          `merge: integrate with latest ${defaultBranch}`
+        ], { allowFailure: true });
+        if (merge.code !== 0) {
+          await runCommand("git", ["-C", worktree.path, "merge", "--abort"], { allowFailure: true });
+          this.addLog("Could not resolve merge conflicts automatically, pushing as-is");
+        }
+      } else {
+        this.addLog("Rebased onto latest " + defaultBranch);
+      }
+      const push = await runCommand("git", [
+        "-C",
+        worktree.path,
+        "push",
+        "-u",
+        "origin",
+        `HEAD:refs/heads/${branch}`
+      ], { allowFailure: true });
+      if (push.code !== 0) {
+        this.addLog(`Push failed: ${push.stderr.trim()}`);
+        return;
+      }
+      this.addLog(`Pushed branch: ${branch}`);
+      const im = this.snapshot.issueMetrics;
+      const prTitle = `[agent-review] ${this.config.targetPrompt.slice(0, 70)}`;
+      const prBody = [
+        "## Agent Review",
+        "",
+        `Automated code review and fix by \`agent-review\` using **${this.config.backend}**.`,
+        "",
+        `**Target:** ${this.config.targetPrompt}`,
+        "",
+        "### Results",
+        "",
+        `| Metric | Count |`,
+        `|--------|-------|`,
+        `| Issues found | ${im.found} |`,
+        `| Issues fixed | ${im.fixed} |`,
+        `| Issues failed | ${im.failed} |`,
+        `| Issues open | ${im.open} |`,
+        "",
+        `Run ID: \`${this.runId}\``
+      ].join("\n");
+      const pr = await runCommand("gh", [
+        "pr",
+        "create",
+        "--base",
+        defaultBranch,
+        "--head",
+        branch,
+        "--title",
+        prTitle,
+        "--body",
+        prBody
+      ], { cwd: this.repoRoot, allowFailure: true });
+      if (pr.code === 0) {
+        const prUrl = pr.stdout.trim();
+        this.snapshot.prUrl = prUrl;
+        this.addLog(`PR created: ${prUrl}`);
+      } else {
+        this.addLog(`PR creation failed: ${pr.stderr.trim()}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.addLog(`Publish failed: ${message}`);
+    }
+  }
+  /* -- Report ----------------------------------------------------- */
+  async writeFinalReport(verificationOutput, verificationError) {
+    const im = this.snapshot.issueMetrics;
+    const tu = this.snapshot.tokenUsage;
+    const unresolved = this.issueStore?.issues.filter((issue) => issue.status !== "fixed") ?? [];
+    const preview = unresolved.slice(0, 20);
+    const lines = [];
+    lines.push("# Agent Review Report");
+    lines.push("");
+    lines.push(`- Run ID: ${this.runId}`);
+    lines.push(`- Backend: ${this.config.backend}`);
+    lines.push(`- Repo: ${this.repoRoot}`);
+    lines.push(`- Base Branch: ${this.currentBranch}`);
+    lines.push(`- Base Commit: ${this.baseCommit}`);
+    lines.push(`- Target Prompt: ${this.config.targetPrompt}`);
+    lines.push(`- Target Paths: ${this.snapshot.targetPaths.join(", ")}`);
+    lines.push(`- Instances: ${this.config.instances}`);
+    lines.push("");
+    lines.push("## Issue Summary");
+    lines.push("");
+    lines.push(`- Found: ${im.found}`);
+    lines.push(`- Fixed: ${im.fixed}`);
+    lines.push(`- Open: ${im.open}`);
+    lines.push(`- Failed: ${im.failed}`);
+    lines.push("");
+    lines.push("## Token Usage");
+    lines.push("");
+    lines.push(`- Input: ${tu.input}`);
+    lines.push(`- Cached Input: ${tu.cachedInput}`);
+    lines.push(`- Output: ${tu.output}`);
+    lines.push("");
+    lines.push("## Verification");
+    lines.push("");
+    if (verificationError) {
+      lines.push(`- Status: failed`);
+      lines.push(`- Error: ${verificationError}`);
+    } else if (verificationOutput) {
+      lines.push(`- Status: completed`);
+      lines.push(`- Summary: ${verificationOutput.summary}`);
+      lines.push("");
+      lines.push("### Checks");
+      lines.push("");
+      for (const check of verificationOutput.checks_run) {
+        lines.push(`- ${check.command} -> ${check.result}: ${check.details}`);
+      }
+      if (verificationOutput.unresolved_risks.length > 0) {
+        lines.push("");
+        lines.push("### Unresolved Risks");
+        lines.push("");
+        for (const risk of verificationOutput.unresolved_risks) {
+          lines.push(`- ${risk}`);
+        }
+      }
+    } else {
+      lines.push("- Status: skipped");
+    }
+    lines.push("");
+    if (preview.length > 0) {
+      lines.push("## Remaining Issues");
+      lines.push("");
+      for (const issue of preview) {
+        const loc = issue.location.line !== void 0 ? `${issue.location.file}:${issue.location.line}` : issue.location.file;
+        lines.push(`- ${issue.id} [${issue.status}] ${issue.title} (${loc})`);
+      }
+      if (unresolved.length > preview.length) {
+        lines.push(`- ... ${unresolved.length - preview.length} additional issues`);
+      }
+      lines.push("");
+    }
+    await fs.writeFile(this.reportFile, `${lines.join("\n")}
+`, "utf8");
+    this.snapshot.reportFile = this.reportFile;
+    this.emitSnapshot();
+  }
+  /* -- Helpers ---------------------------------------------------- */
+  normalizeIssueFile(rawFile, worktreePath) {
+    const trimmed = rawFile.trim();
+    if (!trimmed) return ".";
+    if (path.isAbsolute(trimmed)) {
+      if (isInsidePath(trimmed, worktreePath)) return normalizeSlashes(path.relative(worktreePath, trimmed));
+      if (isInsidePath(trimmed, this.repoRoot)) return normalizeSlashes(path.relative(this.repoRoot, trimmed));
+      return normalizeSlashes(trimmed);
+    }
+    return normalizeSlashes(trimmed);
+  }
+  normalizeSeverity(raw) {
+    if (["critical", "high", "medium", "low", "info"].includes(raw)) return raw;
+    return "medium";
+  }
+  async persistIssueStore() {
+    if (!this.issueStore || !this.issueFile) return;
+    this.persistQueue = this.persistQueue.then(async () => {
+      this.issueStore.metadata.updatedAt = nowIso();
+      const tmpPath = `${this.issueFile}.tmp`;
+      await fs.writeFile(tmpPath, JSON.stringify(this.issueStore, null, 2), "utf8");
+      await fs.rename(tmpPath, this.issueFile);
+    });
+    await this.persistQueue;
+    this.emitSnapshot();
+  }
+  async readJsonFile(filePath) {
+    const raw = await fs.readFile(filePath, "utf8");
+    return parseJson(raw);
+  }
+  /* -- Schemas ---------------------------------------------------- */
+  discoverySchema() {
+    return {
+      type: "object",
+      additionalProperties: false,
+      required: ["summary", "issues"],
+      properties: {
+        summary: { type: "string" },
+        issues: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["title", "description", "suggested_fix", "severity", "confidence", "location"],
+            properties: {
+              title: { type: "string" },
+              description: { type: "string" },
+              suggested_fix: { type: "string" },
+              severity: { type: "string", enum: ["critical", "high", "medium", "low", "info"] },
+              confidence: { type: ["number", "null"] },
+              location: {
+                type: "object",
+                additionalProperties: false,
+                required: ["file", "line"],
+                properties: { file: { type: "string" }, line: { type: ["number", "null"] } }
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+  fixSchema() {
+    return {
+      type: "object",
+      additionalProperties: false,
+      required: ["summary", "results"],
+      properties: {
+        summary: { type: "string" },
+        results: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["issue_id", "status", "fix_summary", "files_touched"],
+            properties: {
+              issue_id: { type: "string" },
+              status: { type: "string", enum: ["fixed", "not_fixed"] },
+              fix_summary: { type: "string" },
+              files_touched: { type: "array", items: { type: "string" } }
+            }
+          }
+        }
+      }
+    };
+  }
+  verificationSchema() {
+    return {
+      type: "object",
+      additionalProperties: false,
+      required: ["summary", "checks_run", "changes_made", "unresolved_risks"],
+      properties: {
+        summary: { type: "string" },
+        checks_run: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["command", "result", "details"],
+            properties: {
+              command: { type: "string" },
+              result: { type: "string", enum: ["passed", "failed", "skipped"] },
+              details: { type: "string" }
+            }
+          }
+        },
+        changes_made: { type: "boolean" },
+        unresolved_risks: { type: "array", items: { type: "string" } }
+      }
+    };
+  }
+  /* -- Prompts ---------------------------------------------------- */
+  /**
+   * Try to extract valid JSON from text that may contain markdown code blocks or extra prose.
+   */
+  static extractJson(text) {
+    try {
+      JSON.parse(text.trim());
+      return text.trim();
+    } catch {
+    }
+    const codeBlockMatch = text.match(/```(?:json)?\s*\n([\s\S]*?)```/);
+    if (codeBlockMatch) {
+      try {
+        JSON.parse(codeBlockMatch[1].trim());
+        return codeBlockMatch[1].trim();
+      } catch {
+      }
+    }
+    try {
+      const result = parseJson(text);
+      return JSON.stringify(result);
+    } catch {
+    }
+    return void 0;
+  }
+  /**
+   * Extract unique directory paths from a file list, sorted, for prompt context.
+   */
+  static summarizeDirectories(files) {
+    const dirs = /* @__PURE__ */ new Set();
+    for (const f of files) {
+      const dir = f.includes("/") ? f.slice(0, f.lastIndexOf("/")) : ".";
+      dirs.add(dir);
+    }
+    return [...dirs].sort();
+  }
+  /**
+   * Build a compact tree-like overview of a file segment, grouped by top-level directory,
+   * with file counts and extension breakdown per directory.
+   */
+  static buildSegmentOverview(files) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const f of files) {
+      const parts = f.split("/");
+      const key = parts.length > 2 ? `${parts[0]}/${parts[1]}` : parts[0];
+      const group = groups.get(key) ?? [];
+      group.push(f);
+      groups.set(key, group);
+    }
+    const lines = [];
+    for (const [dir, dirFiles] of [...groups.entries()].sort()) {
+      const extCounts = /* @__PURE__ */ new Map();
+      for (const f of dirFiles) {
+        const ext = path.extname(f) || "(no ext)";
+        extCounts.set(ext, (extCounts.get(ext) ?? 0) + 1);
+      }
+      const extSummary = [...extCounts.entries()].sort((a, b) => b[1] - a[1]).map(([ext, count]) => `${count}${ext}`).join(", ");
+      lines.push(`  ${dir}/ (${dirFiles.length} files: ${extSummary})`);
+      const subDirs = /* @__PURE__ */ new Set();
+      for (const f of dirFiles) {
+        const rel = f.slice(dir.length + 1);
+        const subDir = rel.includes("/") ? rel.slice(0, rel.indexOf("/")) : null;
+        if (subDir) subDirs.add(subDir);
+      }
+      if (subDirs.size > 0 && subDirs.size <= 15) {
+        lines.push(`    subdirs: ${[...subDirs].sort().join(", ")}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  discoveryPrompt(agentId, segment, manifestPath) {
+    const overview = _AgentReviewOrchestrator.buildSegmentOverview(segment);
+    const topDirs = [...new Set(segment.map((f) => {
+      const parts = f.split("/");
+      return parts.length > 2 ? `${parts[0]}/${parts[1]}` : parts[0];
+    }))].sort();
+    return [
+      `You are ${agentId}, a discovery-only code review agent.`,
+      `Task: perform a deep review focused on logic bugs, type/runtime errors, state handling bugs, edge case failures, and security defects.`,
+      "",
+      "== CONTEXT ==",
+      `Repo root: ${this.repoRoot}`,
+      `Current branch: ${this.currentBranch}`,
+      `User review target: "${this.config.targetPrompt}"`,
+      `Total agents: ${this.config.instances} (running in parallel, each reviewing different sections)`,
+      "",
+      "== YOUR ASSIGNED SECTION ==",
+      `You are responsible for reviewing ${segment.length} files in these areas:`,
+      "",
+      overview,
+      "",
+      `Full file list is in the manifest: ${manifestPath}`,
+      "",
+      "== SCOPE RULES ==",
+      `- ONLY review files within YOUR assigned directories: ${topDirs.join(", ")}`,
+      "- Do NOT review files outside your section. Other agents handle those.",
+      "- You MAY read files outside your section for context (e.g. shared types, imports, config).",
+      "",
+      "== REVIEW GUIDELINES ==",
+      "1. Do NOT modify any files. This is discovery only.",
+      "2. Read files from the manifest and review them in depth.",
+      "3. Report only concrete, actionable defects. Skip style, formatting, or naming nits.",
+      "4. Include precise file paths and line numbers for each issue.",
+      "5. For each issue explain WHY it is a bug and provide a specific fix suggestion.",
+      "6. If unsure whether something is a real bug, do not report it.",
+      "",
+      "== WORKFLOW ==",
+      "1. Read the manifest file to see your complete file list.",
+      "2. Work through each directory in your assigned section systematically.",
+      "3. For each file, look for logic bugs, type errors, race conditions, missing error handling, data loss risks, and security issues.",
+      "4. Return your findings as JSON matching the output schema exactly."
+    ].join("\n");
+  }
+  fixPrompt(agentId, assignedIssues, assignedIssuesPath) {
+    const issueFiles = [...new Set(assignedIssues.map((i) => i.location.file))].sort();
+    const issueDirs = _AgentReviewOrchestrator.summarizeDirectories(issueFiles);
+    const fileListing = issueFiles.map((f) => `  - ${f}`).join("\n");
+    const dirListing = issueDirs.map((d) => `  - ${d}/`).join("\n");
+    return [
+      `You are ${agentId}, a fix agent.`,
+      "Task: resolve ONLY the assigned issues and nothing else.",
+      "",
+      "Context:",
+      `- Repo root: ${this.repoRoot}`,
+      `- Branch: ${this.currentBranch}`,
+      `- Number of assigned issues: ${assignedIssues.length}`,
+      `- Assigned issues file (full details): ${assignedIssuesPath}`,
+      "",
+      "YOUR ASSIGNED SCOPE (only work within these areas):",
+      "Directories:",
+      dirListing,
+      "Files containing issues:",
+      fileListing,
+      "",
+      `There are ${this.config.instances} fix agents, each responsible for different issues. Only fix YOUR assigned issues.`,
+      "",
+      "Hard rules:",
+      "1. Fix only issue IDs listed in the assigned issues file.",
+      "2. No broad refactors or unrelated cleanup.",
+      "3. Keep behavior stable except for the necessary bug fixes.",
+      "4. Make edits directly in this worktree.",
+      "5. If an issue cannot be fixed safely, mark it as not_fixed with reason.",
+      "",
+      "Execution guidance:",
+      "- Read the assigned issues file first to understand all issues you need to fix.",
+      "- Validate each fix with minimal relevant checks where practical.",
+      "- Prefer targeted checks over expensive full-suite runs.",
+      "",
+      "Return JSON matching the output schema exactly. Each assigned issue ID must appear once in results."
+    ].join("\n");
+  }
+  verificationPrompt() {
+    return [
+      "You are the final verification agent for this agent-review run.",
+      "Goal: validate integrated fixes and produce a short reliability report.",
+      "",
+      "Steps:",
+      "1. Inspect package scripts and identify practical quality gates.",
+      "2. Run relevant typecheck/build/test commands using judgment.",
+      "3. If tests appear stale or irrelevant, skip with a concise justification.",
+      "4. If checks fail because of real regressions, apply minimal corrective fixes.",
+      "5. Keep changes narrowly scoped to verification failures.",
+      "",
+      "Return JSON matching the output schema exactly."
+    ].join("\n");
+  }
+  /* -- Git worktree management ------------------------------------ */
+  async createWorktree(input2) {
+    const worktreePath = path.join(this.worktreesDir, input2.label);
+    await runCommand("git", [
+      "-C",
+      this.repoRoot,
+      "worktree",
+      "add",
+      "--force",
+      "-b",
+      input2.branch,
+      worktreePath,
+      input2.startPoint ?? this.currentBranch
+    ]);
+    this.createdWorktrees.add(worktreePath);
+    return { label: input2.label, branch: input2.branch, path: worktreePath };
+  }
+  async commitIfDirty(worktreePath, message) {
+    const status = (await runCommand("git", ["-C", worktreePath, "status", "--porcelain"])).stdout.trim();
+    if (!status) return false;
+    await runCommand("git", ["-C", worktreePath, "add", "-A"]);
+    const commit = await runCommand("git", ["-C", worktreePath, "commit", "-m", message], { allowFailure: true });
+    return commit.code === 0;
+  }
+  /** Assign a backend to an agent (round-robin across available backends) */
+  assignBackend(agentId, index) {
+    const backend = this.availableBackends[(index - 1) % this.availableBackends.length];
+    this.agentBackends.set(agentId, backend);
+    return backend;
+  }
+  /** Get the backend assigned to a specific agent */
+  getAgentBackend(agentId) {
+    return this.agentBackends.get(agentId) ?? this.availableBackends[0];
+  }
+  /** Get the driver for a specific agent */
+  getAgentDriver(agentId) {
+    const backend = this.getAgentBackend(agentId);
+    return this.drivers.get(backend) ?? this.driver;
+  }
+  /** Check if a specific agent uses the claude-code backend */
+  isClaudeCode(agentId) {
+    return this.getAgentBackend(agentId) === "claude-code";
+  }
+  async prepareCodexHome(agentId) {
+    if (this.getAgentBackend(agentId) !== "codex") return void 0;
+    const existing = this.preparedCodexHomes.get(agentId);
+    if (existing) return existing;
+    const setup = this.createCodexHome(agentId).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      this.addLog(`${agentId} codex home setup warning: ${message}`);
+      return void 0;
+    });
+    this.preparedCodexHomes.set(agentId, setup);
+    return setup;
+  }
+  async createCodexHome(agentId) {
+    const codexHome = path.join(this.codexHomesDir, agentId);
+    await fs.mkdir(codexHome, { recursive: true });
+    const sourceHome = process.env.CODEX_HOME?.trim() || path.join(os.homedir(), ".codex");
+    if (await pathExists(sourceHome)) {
+      await this.copyFileIfPresent(path.join(sourceHome, "auth.json"), path.join(codexHome, "auth.json"));
+      await this.copyFileIfPresent(path.join(sourceHome, "config.toml"), path.join(codexHome, "config.toml"));
+      await this.copyFileIfPresent(path.join(sourceHome, ".codex-global-state.json"), path.join(codexHome, ".codex-global-state.json"));
+      await this.copyFileIfPresent(path.join(sourceHome, "version.json"), path.join(codexHome, "version.json"));
+      await this.copyFileIfPresent(path.join(sourceHome, "models_cache.json"), path.join(codexHome, "models_cache.json"));
+    }
+    return codexHome;
+  }
+  async copyFileIfPresent(sourcePath, targetPath) {
+    try {
+      if (!await pathExists(sourcePath)) return;
+      await fs.mkdir(path.dirname(targetPath), { recursive: true });
+      await fs.copyFile(sourcePath, targetPath);
+    } catch {
+    }
+  }
+  shouldRetryCodexExec(result, attempt, maxAttempts) {
+    if (attempt >= maxAttempts) return false;
+    if (result.timedOut) return false;
+    if (result.exitCode === 0) return false;
+    const combined = `${result.stderr}
+${result.lastMessage ?? ""}`.toLowerCase();
+    if (!combined.trim()) return true;
+    return RETRYABLE_CODEX_FAILURES.some((pattern) => combined.includes(pattern));
+  }
+  async sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /* -- Backend exec ----------------------------------------------- */
+  async runBackendExec(input2) {
+    const backend = this.getAgentBackend(input2.agentId);
+    const maxAttempts = backend === "codex" ? 2 : 1;
+    let lastResult;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      if (attempt > 1) {
+        this.addLog(`${input2.agentId} retrying ${backend} execution (attempt ${attempt}/${maxAttempts})`);
+      }
+      const result = await this.runBackendExecOnce(input2, attempt);
+      lastResult = result;
+      if (backend !== "codex" || !this.shouldRetryCodexExec(result, attempt, maxAttempts)) {
+        return result;
+      }
+      await this.sleep(750 * attempt);
+    }
+    return lastResult;
+  }
+  async runBackendExecOnce(input2, attempt) {
+    const agentDriver = this.getAgentDriver(input2.agentId);
+    const agentBackend = this.getAgentBackend(input2.agentId);
+    const { command, args } = agentDriver.buildArgs({
+      yolo: input2.yolo,
+      model: this.config.model,
+      schemaPath: input2.schemaPath,
+      outputPath: input2.outputPath,
+      prompt: input2.prompt
+    });
+    const childEnv = { ...process.env };
+    const codexHome = await this.prepareCodexHome(input2.agentId);
+    if (agentBackend === "codex" && codexHome) {
+      childEnv.CODEX_HOME = codexHome;
+    }
+    this.addLog(`${input2.agentId} spawning ${agentBackend}${attempt > 1 ? ` (attempt ${attempt})` : ""}`);
+    const child = spawn(command, args, { cwd: input2.cwd, env: childEnv, stdio: "pipe" });
+    let stderr = "";
+    let buffered = "";
+    let stdoutBytes = 0;
+    let lastMessage;
+    let fullResultText;
+    let lastAssistantFullText;
+    const usage = { ...EMPTY_USAGE };
+    let timedOut = false;
+    const startTime = Date.now();
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdin.end();
+    const killChild = () => {
+      if (timedOut) return;
+      timedOut = true;
+      const el = Math.round((Date.now() - startTime) / 1e3);
+      this.addLog(`${input2.agentId} timed out after ${el}s`);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 5e3);
+    };
+    const overallTimer = setTimeout(killChild, this.codexTimeoutMs);
+    let inactivityTimer = setTimeout(killChild, this.codexInactivityTimeoutMs);
+    const resetInactivity = () => {
+      clearTimeout(inactivityTimer);
+      inactivityTimer = setTimeout(killChild, this.codexInactivityTimeoutMs);
+    };
+    const processJsonLine = (line, emitAgentUpdate) => {
+      if (!line) return;
+      try {
+        const parsed = JSON.parse(line);
+        const result = agentDriver.parseStdoutLine(parsed);
+        if (result.tokenIncrement) {
+          usage.input += result.tokenIncrement.input;
+          usage.cachedInput += result.tokenIncrement.cachedInput;
+          usage.output += result.tokenIncrement.output;
+          this.addAgentUsage(input2.agentId, result.tokenIncrement);
+        }
+        if (result.message) {
+          lastMessage = result.message;
+          if (emitAgentUpdate) this.updateAgent(input2.agentId, { lastMessage });
+        }
+        const pType = parsed.type;
+        if (pType === "result" || pType === "turn_result") {
+          const rc = parsed.result ?? parsed.content ?? parsed.text ?? parsed.message;
+          if (typeof rc === "string") {
+            fullResultText = rc;
+          } else if (Array.isArray(rc)) {
+            const texts = rc.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text);
+            if (texts.length > 0) fullResultText = texts.join("\n");
+          }
+        }
+        if (pType === "assistant" || pType === "message") {
+          const ac = parsed.content ?? parsed.message ?? parsed.text;
+          if (typeof ac === "string") {
+            lastAssistantFullText = ac;
+          } else if (Array.isArray(ac)) {
+            const texts = ac.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text);
+            const combined = texts.join("\n");
+            if (combined) lastAssistantFullText = combined;
+          }
+        }
+      } catch {
+      }
+    };
+    child.stdout.on("data", (chunk) => {
+      resetInactivity();
+      stdoutBytes += Buffer.byteLength(chunk, "utf8");
+      buffered += chunk;
+      while (buffered.includes("\n")) {
+        const idx = buffered.indexOf("\n");
+        const line = buffered.slice(0, idx).trim();
+        buffered = buffered.slice(idx + 1);
+        processJsonLine(line, true);
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      resetInactivity();
+      stderr += chunk;
+    });
+    const exitCode = await new Promise((resolve, reject) => {
+      child.on("error", reject);
+      child.on("close", (code) => resolve(code ?? 1));
+    });
+    clearTimeout(overallTimer);
+    clearTimeout(inactivityTimer);
+    if (buffered.trim()) {
+      const remainingLines = buffered.split("\n").map((l) => l.trim()).filter(Boolean);
+      for (const line of remainingLines) {
+        processJsonLine(line, false);
+      }
+    }
+    const capturedText = fullResultText ?? lastAssistantFullText;
+    if (capturedText) {
+      const outputExists = await pathExists(input2.outputPath);
+      if (!outputExists) {
+        const jsonContent = _AgentReviewOrchestrator.extractJson(capturedText);
+        if (jsonContent) {
+          try {
+            await fs.mkdir(path.dirname(input2.outputPath), { recursive: true });
+            await fs.writeFile(input2.outputPath, jsonContent, "utf8");
+          } catch {
+          }
+        }
+      }
+    }
+    const hasOutput = await pathExists(input2.outputPath);
+    if (!lastMessage || !hasOutput) {
+      const diag = [
+        `exit=${exitCode}`,
+        `stdout=${stdoutBytes}b`,
+        `stderr=${stderr.length}b`,
+        `output_file=${hasOutput ? "yes" : "no"}`
+      ].join(", ");
+      this.addLog(`${input2.agentId} diagnostic: ${diag}`);
+      if (stderr.trim()) {
+        this.addLog(`${input2.agentId} stderr: ${stderr.trim().slice(0, 500)}`);
+      }
+    }
+    const stderrResult = timedOut ? `Process timed out after ${Math.round((Date.now() - startTime) / 1e3)}s${stderr.trim() ? ": " + stderr.trim() : ""}` : stderr.trim();
+    return {
+      exitCode,
+      usage,
+      timedOut,
+      durationMs: Date.now() - startTime,
+      lastMessage,
+      resultText: capturedText,
+      stderr: stderrResult
+    };
+  }
+  async cleanupWorktrees() {
+    if (!this.repoRoot) return;
+    this.addLog("Cleaning up worktrees");
+    for (const worktreePath of this.createdWorktrees) {
+      const result = await runCommand(
+        "git",
+        ["-C", this.repoRoot, "worktree", "remove", "--force", worktreePath],
+        { allowFailure: true }
+      );
+      if (result.code !== 0 && await pathExists(worktreePath)) {
+        try {
+          await fs.rm(worktreePath, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+    await runCommand("git", ["-C", this.repoRoot, "worktree", "prune"], { allowFailure: true });
+    if (this.sharedWorktree?.branch) {
+      await runCommand(
+        "git",
+        ["-C", this.repoRoot, "branch", "-D", this.sharedWorktree.branch],
+        { allowFailure: true }
+      );
+    }
+    if (this.worktreesDir && await pathExists(this.worktreesDir)) {
+      try {
+        await fs.rm(this.worktreesDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    if (this.codexHomesDir && await pathExists(this.codexHomesDir)) {
+      try {
+        await fs.rm(this.codexHomesDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+    this.addLog("Worktree cleanup complete");
+  }
+  async cleanupCodexHomes() {
+    if (!this.codexHomesDir) return;
+    if (!await pathExists(this.codexHomesDir)) return;
+    try {
+      await fs.rm(this.codexHomesDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+};
+
+// src/index.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function parsePositiveInt(raw, label) {
+  const value = Number.parseInt(raw, 10);
+  if (!Number.isFinite(value) || value < 1) {
+    throw new Error(`${label} must be a positive integer`);
+  }
+  return value;
+}
+function parseBackend(raw) {
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "codex") return "codex";
+  if (normalized === "claude-code" || normalized === "claude" || normalized === "cc") return "claude-code";
+  if (normalized === "opencode" || normalized === "oc") return "opencode";
+  if (normalized === "mixed" || normalized === "all") return "mixed";
+  throw new Error(`Unknown backend "${raw}". Supported: codex, claude-code, opencode, mixed`);
+}
+async function askForTargetPrompt() {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const answer = await rl.question("What should be reviewed? (describe the codebase area in natural language) ");
+    return answer.trim() || "current directory";
+  } finally {
+    rl.close();
+  }
+}
+function DashboardApp({ orchestrator }) {
+  const [snapshot, setSnapshot] = useState2(orchestrator.getSnapshot());
+  useEffect2(() => {
+    return orchestrator.subscribe(setSnapshot);
+  }, [orchestrator]);
+  return /* @__PURE__ */ jsx2(Dashboard, { snapshot });
+}
+async function main() {
+  const program = new Command();
+  program.name("agent-review").description("Parallel agent-powered code review and fix orchestrator (supports Codex, Claude Code, OpenCode)").argument("[instances]", "Number of parallel agents").option("-i, --instances <number>", "Number of parallel agents").option("-t, --target <prompt>", "What to review (natural language or path)").option("-b, --backend <name>", "Agent backend: codex, claude-code, opencode, mixed (default: codex)").option("-m, --model <name>", "Model override for the backend").option("--no-cleanup", "Keep generated worktrees after run finishes").option("--timeout <ms>", "Overall timeout per agent in ms (default: 300000)").option("--inactivity-timeout <ms>", "Inactivity timeout per agent in ms (default: 120000)").parse(process.argv);
+  const opts = program.opts();
+  const argInstances = program.args[0];
+  const rawInstances = opts.instances ?? argInstances ?? "2";
+  const instances = parsePositiveInt(rawInstances, "instances");
+  const targetPrompt = opts.target?.trim() || await askForTargetPrompt();
+  const backend = parseBackend(opts.backend ?? "codex");
+  const config = {
+    instances,
+    targetPrompt,
+    startCwd: process.cwd(),
+    backend,
+    model: opts.model?.trim() || void 0,
+    cleanup: opts.cleanup,
+    codexTimeoutMs: opts.timeout ? parsePositiveInt(opts.timeout, "timeout") : void 0,
+    codexInactivityTimeoutMs: opts.inactivityTimeout ? parsePositiveInt(opts.inactivityTimeout, "inactivity-timeout") : void 0
+  };
+  const orchestrator = new AgentReviewOrchestrator(config);
+  const app = render(/* @__PURE__ */ jsx2(DashboardApp, { orchestrator }));
+  const result = await orchestrator.run();
+  await new Promise((resolve) => setTimeout(resolve, 250));
+  app.unmount();
+  if (result.success) {
+    if (result.prUrl) {
+      process.stdout.write(`
+Pull request: ${result.prUrl}
+`);
+    }
+    if (result.integrationBranch) {
+      process.stdout.write(`Branch: ${result.integrationBranch}
+`);
+    }
+    if (result.issueFile) {
+      process.stdout.write(`Issue tracker: ${result.issueFile}
+`);
+    }
+    if (result.reportFile) {
+      process.stdout.write(`Final report: ${result.reportFile}
+`);
+    }
+    if (result.integrationWorktree) {
+      process.stdout.write(`Worktree: ${result.integrationWorktree}
+`);
+    }
+    return;
+  }
+  if (result.error) {
+    process.stderr.write(`agent-review failed: ${result.error}
+`);
+  }
+  process.exitCode = 1;
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`agent-review failed: ${message}
+`);
+  process.exitCode = 1;
+});