diffprism 0.34.0 → 0.35.0

package/dist/{chunk-NJKYNMAQ.js → chunk-LUUR6LNP.js}

@@ -1,28 +1,17 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+import {
+  getCurrentBranch,
+  getDiff,
+  listBranches,
+  listCommits,
+  parseDiff
+} from "./chunk-QGWYCEJN.js";
+import {
+  analyze
+} from "./chunk-DHCVZGHE.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-JSBRDJBE.js";
 
 // node_modules/.pnpm/fast-content-type-parse@2.0.1/node_modules/fast-content-type-parse/index.js
 var require_fast_content_type_parse = __commonJS({
@@ -120,947 +109,15 @@ var require_fast_content_type_parse = __commonJS({
   }
 });
 
-// packages/git/src/local.ts
-import { execSync } from "child_process";
-import { readFileSync } from "fs";
-import path from "path";
-function getGitDiff(ref, options) {
-  const cwd = options?.cwd ?? process.cwd();
-  try {
-    execSync("git --version", { cwd, stdio: "pipe" });
-  } catch {
-    throw new Error(
-      "git is not available. Please install git and make sure it is on your PATH."
-    );
-  }
-  try {
-    execSync("git rev-parse --is-inside-work-tree", { cwd, stdio: "pipe" });
-  } catch {
-    throw new Error(
-      `The directory "${cwd}" is not inside a git repository.`
-    );
-  }
-  let command;
-  let includeUntracked = false;
-  switch (ref) {
-    case "staged":
-      command = "git diff --staged --no-color";
-      break;
-    case "unstaged":
-      command = "git diff --no-color";
-      includeUntracked = true;
-      break;
-    case "all":
-      command = "git diff HEAD --no-color";
-      includeUntracked = true;
-      break;
-    default:
-      command = `git diff --no-color ${ref}`;
-      break;
-  }
-  let output;
-  try {
-    output = execSync(command, {
-      cwd,
-      encoding: "utf-8",
-      maxBuffer: 50 * 1024 * 1024
-      // 50 MB
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`git diff failed: ${message}`);
-  }
-  if (includeUntracked) {
-    output += getUntrackedDiffs(cwd);
-  }
-  return output;
-}
-function getCurrentBranch(options) {
-  const cwd = options?.cwd ?? process.cwd();
-  try {
-    return execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch {
-    return "unknown";
-  }
-}
-function listBranches(options) {
-  const cwd = options?.cwd ?? process.cwd();
-  try {
-    const output = execSync(
-      "git branch -a --format='%(refname:short)' --sort=-committerdate",
-      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    if (!output) return { local: [], remote: [] };
-    const local = [];
-    const remote = [];
-    for (const line of output.split("\n")) {
-      const name = line.trim();
-      if (!name) continue;
-      if (name.endsWith("/HEAD")) continue;
-      if (name.includes("/")) {
-        remote.push(name);
-      } else {
-        local.push(name);
-      }
-    }
-    return { local, remote };
-  } catch {
-    return { local: [], remote: [] };
-  }
-}
-function listCommits(options) {
-  const cwd = options?.cwd ?? process.cwd();
-  const limit = options?.limit ?? 50;
-  try {
-    const output = execSync(
-      `git log --format='%H<<>>%h<<>>%s<<>>%an<<>>%aI' -n ${limit}`,
-      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-    if (!output) return [];
-    const commits = [];
-    for (const line of output.split("\n")) {
-      const parts = line.split("<<>>");
-      if (parts.length < 5) continue;
-      commits.push({
-        hash: parts[0],
-        shortHash: parts[1],
-        subject: parts[2],
-        author: parts[3],
-        date: parts[4]
-      });
-    }
-    return commits;
-  } catch {
-    return [];
-  }
-}
-function detectWorktree(options) {
-  const cwd = options?.cwd ?? process.cwd();
-  try {
-    const gitDir = execSync("git rev-parse --git-dir", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const gitCommonDir = execSync("git rev-parse --git-common-dir", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const resolvedGitDir = path.resolve(cwd, gitDir);
-    const resolvedCommonDir = path.resolve(cwd, gitCommonDir);
-    const isWorktree = resolvedGitDir !== resolvedCommonDir;
-    if (!isWorktree) {
-      return { isWorktree: false };
-    }
-    const worktreePath = execSync("git rev-parse --show-toplevel", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    const mainWorktreePath = path.dirname(resolvedCommonDir);
-    const branch = execSync("git rev-parse --abbrev-ref HEAD", {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-    return {
-      isWorktree: true,
-      worktreePath,
-      mainWorktreePath,
-      branch: branch === "HEAD" ? void 0 : branch
-    };
-  } catch {
-    return { isWorktree: false };
-  }
-}
-function getUntrackedDiffs(cwd) {
-  let untrackedList;
-  try {
-    untrackedList = execSync(
-      "git ls-files --others --exclude-standard",
-      { cwd, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
-    ).trim();
-  } catch {
-    return "";
-  }
-  if (!untrackedList) return "";
-  const files = untrackedList.split("\n");
-  let result = "";
-  for (const file of files) {
-    const absPath = path.resolve(cwd, file);
-    let content;
-    try {
-      content = readFileSync(absPath, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = content.split("\n");
-    const hasTrailingNewline = content.length > 0 && content[content.length - 1] === "\n";
-    const contentLines = hasTrailingNewline ? lines.slice(0, -1) : lines;
-    result += `diff --git a/${file} b/${file}
-`;
-    result += "new file mode 100644\n";
-    result += "--- /dev/null\n";
-    result += `+++ b/${file}
-`;
-    result += `@@ -0,0 +1,${contentLines.length} @@
-`;
-    for (const line of contentLines) {
-      result += `+${line}
-`;
-    }
-    if (!hasTrailingNewline) {
-      result += "\\n";
-    }
-  }
-  return result;
-}
-
-// packages/git/src/parser.ts
-import path2 from "path";
-var EXTENSION_MAP = {
-  ts: "typescript",
-  tsx: "typescript",
-  js: "javascript",
-  jsx: "javascript",
-  py: "python",
-  rb: "ruby",
-  go: "go",
-  rs: "rust",
-  java: "java",
-  c: "c",
-  h: "c",
-  cpp: "cpp",
-  hpp: "cpp",
-  cc: "cpp",
-  cs: "csharp",
-  md: "markdown",
-  json: "json",
-  yaml: "yaml",
-  yml: "yaml",
-  html: "html",
-  css: "css",
-  scss: "scss",
-  sql: "sql",
-  sh: "shell",
-  bash: "shell",
-  zsh: "shell"
-};
-var FILENAME_MAP = {
-  Dockerfile: "dockerfile",
-  Makefile: "makefile"
-};
-function detectLanguage(filePath) {
-  const basename = path2.basename(filePath);
-  if (FILENAME_MAP[basename]) {
-    return FILENAME_MAP[basename];
-  }
-  const ext = basename.includes(".") ? basename.slice(basename.lastIndexOf(".") + 1) : "";
-  return EXTENSION_MAP[ext] ?? "text";
-}
-function stripPrefix(raw) {
-  if (raw === "/dev/null") return raw;
-  return raw.replace(/^[ab]\//, "");
-}
-function parseDiff(rawDiff, baseRef, headRef) {
-  if (!rawDiff.trim()) {
-    return { baseRef, headRef, files: [] };
-  }
-  const files = [];
-  const lines = rawDiff.split("\n");
-  let i = 0;
-  while (i < lines.length) {
-    if (!lines[i].startsWith("diff --git ")) {
-      i++;
-      continue;
-    }
-    let oldPath;
-    let newPath;
-    let status = "modified";
-    let binary = false;
-    let renameFrom;
-    let renameTo;
-    const diffLine = lines[i];
-    const gitPathMatch = diffLine.match(/^diff --git a\/(.*) b\/(.*)$/);
-    if (gitPathMatch) {
-      oldPath = gitPathMatch[1];
-      newPath = gitPathMatch[2];
-    }
-    i++;
-    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
-      const line = lines[i];
-      if (line.startsWith("--- ")) {
-        const raw = line.slice(4);
-        oldPath = stripPrefix(raw);
-        if (raw === "/dev/null") {
-          status = "added";
-        }
-      } else if (line.startsWith("+++ ")) {
-        const raw = line.slice(4);
-        newPath = stripPrefix(raw);
-        if (raw === "/dev/null") {
-          status = "deleted";
-        }
-      } else if (line.startsWith("rename from ")) {
-        renameFrom = line.slice("rename from ".length);
-        status = "renamed";
-      } else if (line.startsWith("rename to ")) {
-        renameTo = line.slice("rename to ".length);
-        status = "renamed";
-      } else if (line.startsWith("new file mode")) {
-        status = "added";
-      } else if (line.startsWith("deleted file mode")) {
-        status = "deleted";
-      } else if (line.startsWith("Binary files") || line === "GIT binary patch") {
-        binary = true;
-        if (line.includes("/dev/null") && line.includes(" and b/")) {
-          status = "added";
-        } else if (line.includes("a/") && line.includes("/dev/null")) {
-          status = "deleted";
-        }
-      }
-      if (line.startsWith("@@ ")) {
-        break;
-      }
-      i++;
-    }
-    const filePath = status === "deleted" ? oldPath ?? newPath ?? "unknown" : newPath ?? oldPath ?? "unknown";
-    const fileOldPath = status === "renamed" ? renameFrom ?? oldPath : oldPath;
-    const hunks = [];
-    let additions = 0;
-    let deletions = 0;
-    while (i < lines.length && !lines[i].startsWith("diff --git ")) {
-      const line = lines[i];
-      if (line.startsWith("@@ ")) {
-        const hunkMatch = line.match(
-          /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
-        );
-        if (!hunkMatch) {
-          i++;
-          continue;
-        }
-        const oldStart = parseInt(hunkMatch[1], 10);
-        const oldLines = hunkMatch[2] !== void 0 ? parseInt(hunkMatch[2], 10) : 1;
-        const newStart = parseInt(hunkMatch[3], 10);
-        const newLines = hunkMatch[4] !== void 0 ? parseInt(hunkMatch[4], 10) : 1;
-        const changes = [];
-        let oldLineNum = oldStart;
-        let newLineNum = newStart;
-        i++;
-        while (i < lines.length) {
-          const changeLine = lines[i];
-          if (changeLine.startsWith("@@ ") || changeLine.startsWith("diff --git ")) {
-            break;
-          }
-          if (changeLine.startsWith("\")) {
-            i++;
-            continue;
-          }
-          if (changeLine.startsWith("+")) {
-            changes.push({
-              type: "add",
-              lineNumber: newLineNum,
-              content: changeLine.slice(1)
-            });
-            newLineNum++;
-            additions++;
-          } else if (changeLine.startsWith("-")) {
-            changes.push({
-              type: "delete",
-              lineNumber: oldLineNum,
-              content: changeLine.slice(1)
-            });
-            oldLineNum++;
-            deletions++;
-          } else {
-            changes.push({
-              type: "context",
-              lineNumber: newLineNum,
-              content: changeLine.length > 0 ? changeLine.slice(1) : ""
-            });
-            oldLineNum++;
-            newLineNum++;
-          }
-          i++;
-        }
-        hunks.push({ oldStart, oldLines, newStart, newLines, changes });
-      } else {
-        i++;
-      }
-    }
-    const diffFile = {
-      path: filePath,
-      status,
-      hunks,
-      language: detectLanguage(filePath),
-      binary,
-      additions,
-      deletions
-    };
-    if (status === "renamed" && fileOldPath) {
-      diffFile.oldPath = fileOldPath;
-    }
-    files.push(diffFile);
-  }
-  return { baseRef, headRef, files };
-}
-
-// packages/git/src/index.ts
-function getDiff(ref, options) {
-  if (ref === "working-copy") {
-    return getWorkingCopyDiff(options);
-  }
-  const rawDiff = getGitDiff(ref, options);
-  let baseRef;
-  let headRef;
-  if (ref === "staged") {
-    baseRef = "HEAD";
-    headRef = "staged";
-  } else if (ref === "unstaged") {
-    baseRef = "staged";
-    headRef = "working tree";
-  } else if (ref.includes("..")) {
-    const [base, head] = ref.split("..");
-    baseRef = base;
-    headRef = head;
-  } else {
-    baseRef = ref;
-    headRef = "HEAD";
-  }
-  const diffSet = parseDiff(rawDiff, baseRef, headRef);
-  return { diffSet, rawDiff };
-}
-function getWorkingCopyDiff(options) {
-  const stagedRaw = getGitDiff("staged", options);
-  const unstagedRaw = getGitDiff("unstaged", options);
-  const stagedDiffSet = parseDiff(stagedRaw, "HEAD", "staged");
-  const unstagedDiffSet = parseDiff(unstagedRaw, "staged", "working tree");
-  const stagedFiles = stagedDiffSet.files.map((f) => ({
-    ...f,
-    stage: "staged"
-  }));
-  const unstagedFiles = unstagedDiffSet.files.map((f) => ({
-    ...f,
-    stage: "unstaged"
-  }));
-  const rawDiff = [stagedRaw, unstagedRaw].filter(Boolean).join("");
-  return {
-    diffSet: {
-      baseRef: "HEAD",
-      headRef: "working tree",
-      files: [...stagedFiles, ...unstagedFiles]
-    },
-    rawDiff
-  };
-}
-
-// packages/analysis/src/deterministic.ts
-var MECHANICAL_CONFIG_PATTERNS = [
-  /\.config\./,
-  /\.eslintrc/,
-  /\.prettierrc/,
-  /tsconfig.*\.json$/,
-  /\.gitignore$/,
-  /\.lock$/
-];
-var API_SURFACE_PATTERNS = [
-  /\/api\//,
-  /\/routes\//
-];
-function isFormattingOnly(file) {
-  if (file.hunks.length === 0) return false;
-  for (const hunk of file.hunks) {
-    const adds = hunk.changes.filter((c) => c.type === "add").map((c) => c.content.replace(/\s/g, ""));
-    const deletes = hunk.changes.filter((c) => c.type === "delete").map((c) => c.content.replace(/\s/g, ""));
-    if (adds.length === 0 || deletes.length === 0) return false;
-    const deleteBag = [...deletes];
-    for (const add of adds) {
-      const idx = deleteBag.indexOf(add);
-      if (idx === -1) return false;
-      deleteBag.splice(idx, 1);
-    }
-    if (deleteBag.length > 0) return false;
-  }
-  return true;
-}
-function isImportOnly(file) {
-  if (file.hunks.length === 0) return false;
-  const importPattern = /^\s*(import\s|export\s.*from\s|const\s+\w+\s*=\s*require\(|require\()/;
-  for (const hunk of file.hunks) {
-    for (const change of hunk.changes) {
-      if (change.type === "context") continue;
-      const trimmed = change.content.trim();
-      if (trimmed === "") continue;
-      if (!importPattern.test(trimmed)) return false;
-    }
-  }
-  return true;
-}
-function isMechanicalConfigFile(path8) {
-  return MECHANICAL_CONFIG_PATTERNS.some((re) => re.test(path8));
-}
-function isApiSurface(file) {
-  if (API_SURFACE_PATTERNS.some((re) => re.test(file.path))) return true;
-  const basename = file.path.slice(file.path.lastIndexOf("/") + 1);
-  if ((basename === "index.ts" || basename === "index.js") && file.additions >= 10) {
-    return true;
-  }
-  return false;
-}
-function categorizeFiles(files) {
-  const critical = [];
-  const notable = [];
-  const mechanical = [];
-  const securityFlags = detectSecurityPatterns(files);
-  const complexityScores = computeComplexityScores(files);
-  const securityByFile = /* @__PURE__ */ new Map();
-  for (const flag of securityFlags) {
-    const existing = securityByFile.get(flag.file) || [];
-    existing.push(flag);
-    securityByFile.set(flag.file, existing);
-  }
-  const complexityByFile = /* @__PURE__ */ new Map();
-  for (const score of complexityScores) {
-    complexityByFile.set(score.path, score);
-  }
-  for (const file of files) {
-    const description = `${file.status} (${file.language || "unknown"}) +${file.additions} -${file.deletions}`;
-    const fileSecurityFlags = securityByFile.get(file.path);
-    const fileComplexity = complexityByFile.get(file.path);
-    const criticalReasons = [];
-    if (fileSecurityFlags && fileSecurityFlags.length > 0) {
-      const patterns = fileSecurityFlags.map((f) => f.pattern);
-      const unique = [...new Set(patterns)];
-      criticalReasons.push(`security patterns detected: ${unique.join(", ")}`);
-    }
-    if (fileComplexity && fileComplexity.score >= 8) {
-      criticalReasons.push(`high complexity score (${fileComplexity.score}/10)`);
-    }
-    if (isApiSurface(file)) {
-      criticalReasons.push("modifies public API surface");
-    }
-    if (criticalReasons.length > 0) {
-      critical.push({
-        file: file.path,
-        description,
-        reason: `Critical: ${criticalReasons.join("; ")}`
-      });
-      continue;
-    }
-    const isPureRename = file.status === "renamed" && file.additions === 0 && file.deletions === 0;
-    if (isPureRename) {
-      mechanical.push({
-        file: file.path,
-        description,
-        reason: "Mechanical: pure rename with no content changes"
-      });
-      continue;
-    }
-    if (isFormattingOnly(file)) {
-      mechanical.push({
-        file: file.path,
-        description,
-        reason: "Mechanical: formatting/whitespace-only changes"
-      });
-      continue;
-    }
-    if (isMechanicalConfigFile(file.path)) {
-      mechanical.push({
-        file: file.path,
-        description,
-        reason: "Mechanical: config file change"
-      });
-      continue;
-    }
-    if (file.hunks.length > 0 && isImportOnly(file)) {
-      mechanical.push({
-        file: file.path,
-        description,
-        reason: "Mechanical: import/require-only changes"
-      });
-      continue;
-    }
-    notable.push({
-      file: file.path,
-      description,
-      reason: "Notable: requires review"
-    });
-  }
-  return { critical, notable, mechanical };
-}
-function computeFileStats(files) {
-  return files.map((f) => ({
-    path: f.path,
-    language: f.language,
-    status: f.status,
-    additions: f.additions,
-    deletions: f.deletions
-  }));
-}
-function detectAffectedModules(files) {
-  const dirs = /* @__PURE__ */ new Set();
-  for (const f of files) {
-    const lastSlash = f.path.lastIndexOf("/");
-    if (lastSlash > 0) {
-      dirs.add(f.path.slice(0, lastSlash));
-    }
-  }
-  return [...dirs].sort();
-}
-var TEST_PATTERNS = [
-  /\.test\./,
-  /\.spec\./,
-  /\/__tests__\//,
-  /\/test\//
-];
-function detectAffectedTests(files) {
-  return files.filter((f) => TEST_PATTERNS.some((re) => re.test(f.path))).map((f) => f.path);
-}
-var DEPENDENCY_FIELDS = [
-  '"dependencies"',
-  '"devDependencies"',
-  '"peerDependencies"',
-  '"optionalDependencies"'
-];
-function detectNewDependencies(files) {
-  const deps = /* @__PURE__ */ new Set();
-  const packageFiles = files.filter(
-    (f) => f.path.endsWith("package.json") && f.hunks.length > 0
-  );
-  for (const file of packageFiles) {
-    for (const hunk of file.hunks) {
-      let inDependencyBlock = false;
-      for (const change of hunk.changes) {
-        const line = change.content;
-        if (DEPENDENCY_FIELDS.some((field) => line.includes(field))) {
-          inDependencyBlock = true;
-          continue;
-        }
-        if (inDependencyBlock && line.trim().startsWith("}")) {
-          inDependencyBlock = false;
-          continue;
-        }
-        if (change.type === "add" && inDependencyBlock) {
-          const match = line.match(/"([^"]+)"\s*:/);
-          if (match) {
-            deps.add(match[1]);
-          }
-        }
-      }
-    }
-  }
-  return [...deps].sort();
-}
-function generateSummary(files) {
-  const totalFiles = files.length;
-  const counts = {
-    added: 0,
-    modified: 0,
-    deleted: 0,
-    renamed: 0
-  };
-  let totalAdditions = 0;
-  let totalDeletions = 0;
-  for (const f of files) {
-    counts[f.status]++;
-    totalAdditions += f.additions;
-    totalDeletions += f.deletions;
-  }
-  const parts = [];
-  if (counts.modified > 0) parts.push(`${counts.modified} modified`);
-  if (counts.added > 0) parts.push(`${counts.added} added`);
-  if (counts.deleted > 0) parts.push(`${counts.deleted} deleted`);
-  if (counts.renamed > 0) parts.push(`${counts.renamed} renamed`);
-  const breakdown = parts.length > 0 ? `: ${parts.join(", ")}` : "";
-  return `${totalFiles} files changed${breakdown} (+${totalAdditions} -${totalDeletions})`;
-}
-var BRANCH_PATTERN = /\b(if|else|switch|case|catch)\b|\?\s|&&|\|\|/;
-function computeComplexityScores(files) {
-  const results = [];
-  for (const file of files) {
-    let score = 0;
-    const factors = [];
-    const totalChanges = file.additions + file.deletions;
-    if (totalChanges > 100) {
-      score += 3;
-      factors.push(`large diff (+${file.additions} -${file.deletions})`);
-    } else if (totalChanges > 50) {
-      score += 2;
-      factors.push(`medium diff (+${file.additions} -${file.deletions})`);
-    } else if (totalChanges > 20) {
-      score += 1;
-      factors.push(`moderate diff (+${file.additions} -${file.deletions})`);
-    }
-    const hunkCount = file.hunks.length;
-    if (hunkCount > 4) {
-      score += 2;
-      factors.push(`many hunks (${hunkCount})`);
-    } else if (hunkCount > 2) {
-      score += 1;
-      factors.push(`multiple hunks (${hunkCount})`);
-    }
-    let branchCount = 0;
-    let deepNestCount = 0;
-    for (const hunk of file.hunks) {
-      for (const change of hunk.changes) {
-        if (change.type !== "add") continue;
-        const line = change.content;
-        if (BRANCH_PATTERN.test(line)) {
-          branchCount++;
-        }
-        const leadingSpaces = line.match(/^(\s*)/);
-        if (leadingSpaces) {
-          const ws = leadingSpaces[1];
-          const tabCount = (ws.match(/\t/g) || []).length;
-          const spaceCount = ws.replace(/\t/g, "").length;
-          if (tabCount >= 4 || spaceCount >= 16) {
-            deepNestCount++;
-          }
-        }
-      }
-    }
-    const branchScore = Math.floor(branchCount / 5);
-    if (branchScore > 0) {
-      score += branchScore;
-      factors.push(`${branchCount} logic branches`);
-    }
-    const nestScore = Math.floor(deepNestCount / 5);
-    if (nestScore > 0) {
-      score += nestScore;
-      factors.push(`${deepNestCount} deeply nested lines`);
-    }
-    score = Math.max(1, Math.min(10, score));
-    results.push({ path: file.path, score, factors });
-  }
-  results.sort((a, b) => b.score - a.score);
-  return results;
-}
-var NON_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".json",
-  ".md",
-  ".css",
-  ".scss",
-  ".less",
-  ".svg",
-  ".png",
-  ".jpg",
-  ".gif",
-  ".ico",
-  ".yaml",
-  ".yml",
-  ".toml",
-  ".lock",
-  ".html"
-]);
-var CONFIG_PATTERNS = [
-  /\.config\./,
-  /\.rc\./,
-  /eslint/,
-  /prettier/,
-  /tsconfig/,
-  /tailwind/,
-  /vite\.config/,
-  /vitest\.config/
-];
-function isTestFile(path8) {
-  return TEST_PATTERNS.some((re) => re.test(path8));
-}
-function isNonCodeFile(path8) {
-  const ext = path8.slice(path8.lastIndexOf("."));
-  return NON_CODE_EXTENSIONS.has(ext);
-}
-function isConfigFile(path8) {
-  return CONFIG_PATTERNS.some((re) => re.test(path8));
-}
-function detectTestCoverageGaps(files) {
-  const filePaths = new Set(files.map((f) => f.path));
-  const results = [];
-  for (const file of files) {
-    if (file.status !== "added" && file.status !== "modified") continue;
-    if (isTestFile(file.path)) continue;
-    if (isNonCodeFile(file.path)) continue;
-    if (isConfigFile(file.path)) continue;
-    const dir = file.path.slice(0, file.path.lastIndexOf("/") + 1);
-    const basename = file.path.slice(file.path.lastIndexOf("/") + 1);
-    const extDot = basename.lastIndexOf(".");
-    const name = extDot > 0 ? basename.slice(0, extDot) : basename;
-    const ext = extDot > 0 ? basename.slice(extDot) : "";
-    const candidates = [
-      `${dir}${name}.test${ext}`,
-      `${dir}${name}.spec${ext}`,
-      `${dir}__tests__/${name}${ext}`,
-      `${dir}__tests__/${name}.test${ext}`,
-      `${dir}__tests__/${name}.spec${ext}`
-    ];
-    const matchedTest = candidates.find((c) => filePaths.has(c));
-    results.push({
-      sourceFile: file.path,
-      testFile: matchedTest ?? null
-    });
-  }
-  return results;
-}
-var PATTERN_MATCHERS = [
-  { pattern: "todo", test: (l) => /\btodo\b/i.test(l) },
-  { pattern: "fixme", test: (l) => /\bfixme\b/i.test(l) },
-  { pattern: "hack", test: (l) => /\bhack\b/i.test(l) },
-  {
-    pattern: "console",
-    test: (l) => /\bconsole\.(log|debug|warn|error)\b/.test(l)
-  },
-  { pattern: "debug", test: (l) => /\bdebugger\b/.test(l) },
-  {
-    pattern: "disabled_test",
-    test: (l) => /\.(skip)\(|(\bxit|xdescribe|xtest)\(/.test(l)
-  }
-];
-function detectPatterns(files) {
-  const results = [];
-  for (const file of files) {
-    if (file.status === "added" && file.additions > 500) {
-      results.push({
-        file: file.path,
-        line: 0,
-        pattern: "large_file",
-        content: `Large added file: ${file.additions} lines`
-      });
-    }
-    for (const hunk of file.hunks) {
-      for (const change of hunk.changes) {
-        if (change.type !== "add") continue;
-        for (const matcher of PATTERN_MATCHERS) {
-          if (matcher.test(change.content)) {
-            results.push({
-              file: file.path,
-              line: change.lineNumber,
-              pattern: matcher.pattern,
-              content: change.content.trim()
-            });
-          }
-        }
-      }
-    }
-  }
-  results.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line);
-  return results;
-}
-var SECURITY_MATCHERS = [
-  {
-    pattern: "eval",
-    severity: "critical",
-    test: (l) => /\beval\s*\(/.test(l)
-  },
-  {
-    pattern: "inner_html",
-    severity: "warning",
-    test: (l) => /\.innerHTML\b|dangerouslySetInnerHTML/.test(l)
-  },
-  {
-    pattern: "sql_injection",
-    severity: "critical",
-    test: (l) => /`[^`]*\b(SELECT|INSERT|UPDATE|DELETE)\b/i.test(l) || /\b(SELECT|INSERT|UPDATE|DELETE)\b[^`]*\$\{/i.test(l)
-  },
-  {
-    pattern: "exec",
-    severity: "critical",
-    test: (l) => /child_process/.test(l) || /\bexec\s*\(/.test(l) || /\bexecSync\s*\(/.test(l)
-  },
-  {
-    pattern: "hardcoded_secret",
-    severity: "critical",
-    test: (l) => /\b(token|secret|api_key|apikey|password|passwd|credential)\s*=\s*["']/i.test(l)
-  },
-  {
-    pattern: "insecure_url",
-    severity: "warning",
-    test: (l) => /http:\/\/(?!localhost|127\.0\.0\.1|0\.0\.0\.0)/.test(l)
-  }
-];
-function detectSecurityPatterns(files) {
-  const results = [];
-  for (const file of files) {
-    for (const hunk of file.hunks) {
-      for (const change of hunk.changes) {
-        if (change.type !== "add") continue;
-        for (const matcher of SECURITY_MATCHERS) {
-          if (matcher.test(change.content)) {
-            results.push({
-              file: file.path,
-              line: change.lineNumber,
-              pattern: matcher.pattern,
-              content: change.content.trim(),
-              severity: matcher.severity
-            });
-          }
-        }
-      }
-    }
-  }
-  results.sort((a, b) => {
-    const severityOrder = { critical: 0, warning: 1 };
-    const aSev = severityOrder[a.severity];
-    const bSev = severityOrder[b.severity];
-    if (aSev !== bSev) return aSev - bSev;
-    return a.file.localeCompare(b.file) || a.line - b.line;
-  });
-  return results;
-}
-
-// packages/analysis/src/index.ts
-function analyze(diffSet) {
-  const { files } = diffSet;
-  const triage = categorizeFiles(files);
-  const fileStats = computeFileStats(files);
-  const affectedModules = detectAffectedModules(files);
-  const affectedTests = detectAffectedTests(files);
-  const newDependencies = detectNewDependencies(files);
-  const summary = generateSummary(files);
-  const complexity = computeComplexityScores(files);
-  const testCoverage = detectTestCoverageGaps(files);
-  const codePatterns = detectPatterns(files);
-  const securityPatterns = detectSecurityPatterns(files);
-  const patterns = [...securityPatterns, ...codePatterns];
-  return {
-    summary,
-    triage,
-    impact: {
-      affectedModules,
-      affectedTests,
-      publicApiChanges: false,
-      breakingChanges: [],
-      newDependencies
-    },
-    verification: {
-      testsPass: null,
-      typeCheck: null,
-      lintClean: null
-    },
-    fileStats,
-    complexity,
-    testCoverage,
-    patterns
-  };
-}
-
-// packages/core/src/watch-file.ts
+// packages/core/src/server-file.ts
 import fs from "fs";
-import path3 from "path";
-import { execSync as execSync2 } from "child_process";
-function findGitRoot(cwd) {
-  const root = execSync2("git rev-parse --show-toplevel", {
-    cwd: cwd ?? process.cwd(),
-    encoding: "utf-8"
-  }).trim();
-  return root;
+import path from "path";
+import os from "os";
+function serverDir() {
+  return path.join(os.homedir(), ".diffprism");
 }
-function watchFilePath(cwd) {
-  const gitRoot = findGitRoot(cwd);
-  return path3.join(gitRoot, ".diffprism", "watch.json");
+function serverFilePath() {
+  return path.join(serverDir(), "server.json");
 }
 function isPidAlive(pid) {
   try {
@@ -1070,16 +127,15 @@ function isPidAlive(pid) {
     return false;
   }
 }
-function writeWatchFile(cwd, info) {
-  const filePath = watchFilePath(cwd);
-  const dir = path3.dirname(filePath);
+function writeServerFile(info) {
+  const dir = serverDir();
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  fs.writeFileSync(filePath, JSON.stringify(info, null, 2) + "\n");
+  fs.writeFileSync(serverFilePath(), JSON.stringify(info, null, 2) + "\n");
 }
-function readWatchFile(cwd) {
-  const filePath = watchFilePath(cwd);
+function readServerFile() {
+  const filePath = serverFilePath();
   if (!fs.existsSync(filePath)) {
     return null;
   }
@@ -1095,305 +151,202 @@ function readWatchFile(cwd) {
     return null;
   }
 }
-function removeWatchFile(cwd) {
+function removeServerFile() {
   try {
-    const filePath = watchFilePath(cwd);
+    const filePath = serverFilePath();
     if (fs.existsSync(filePath)) {
       fs.unlinkSync(filePath);
     }
   } catch {
   }
 }
-function reviewResultPath(cwd) {
-  const gitRoot = findGitRoot(cwd);
-  return path3.join(gitRoot, ".diffprism", "last-review.json");
-}
-function writeReviewResult(cwd, result) {
-  const filePath = reviewResultPath(cwd);
-  const dir = path3.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  const data = {
-    result,
-    timestamp: Date.now(),
-    consumed: false
-  };
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-}
-function readReviewResult(cwd) {
-  try {
-    const filePath = reviewResultPath(cwd);
-    if (!fs.existsSync(filePath)) {
-      return null;
-    }
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(raw);
-    if (data.consumed) {
-      return null;
-    }
-    return data;
-  } catch {
+async function isServerAlive() {
+  const info = readServerFile();
+  if (!info) {
     return null;
   }
-}
-function consumeReviewResult(cwd) {
   try {
-    const filePath = reviewResultPath(cwd);
-    if (!fs.existsSync(filePath)) {
-      return;
+    const response = await fetch(`http://localhost:${info.httpPort}/api/status`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (response.ok) {
+      return info;
     }
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(raw);
-    data.consumed = true;
-    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+    return null;
   } catch {
+    removeServerFile();
+    return null;
   }
 }
 
-// packages/core/src/pipeline.ts
-import getPort from "get-port";
-import open from "open";
-
-// packages/core/src/review-history.ts
+// packages/core/src/server-client.ts
+import { spawn } from "child_process";
 import fs2 from "fs";
-import path4 from "path";
-import { randomUUID } from "crypto";
-function generateEntryId() {
-  return randomUUID();
-}
-function getHistoryPath(projectDir) {
-  return path4.join(projectDir, ".diffprism", "history", "reviews.json");
-}
-function readHistory(projectDir) {
-  const filePath = getHistoryPath(projectDir);
-  if (!fs2.existsSync(filePath)) {
-    return { version: 1, entries: [] };
-  }
-  try {
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    return parsed;
-  } catch {
-    return { version: 1, entries: [] };
-  }
-}
-function appendHistory(projectDir, entry) {
-  const filePath = getHistoryPath(projectDir);
-  const dir = path4.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+import path2 from "path";
+import os2 from "os";
+import { fileURLToPath } from "url";
+async function ensureServer(options = {}) {
+  const existing = await isServerAlive();
+  if (existing) {
+    return existing;
+  }
+  const spawnArgs = options.spawnCommand ?? buildDefaultSpawnCommand(options);
+  const logDir = path2.join(os2.homedir(), ".diffprism");
+  if (!fs2.existsSync(logDir)) {
+    fs2.mkdirSync(logDir, { recursive: true });
+  }
+  const logPath = path2.join(logDir, "server.log");
+  const logFd = fs2.openSync(logPath, "a");
+  const [cmd, ...args] = spawnArgs;
+  const child = spawn(cmd, args, {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env }
+  });
+  child.unref();
+  fs2.closeSync(logFd);
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const info = await isServerAlive();
+    if (info) {
+      return info;
+    }
   }
-  const history = readHistory(projectDir);
-  history.entries.push(entry);
-  history.entries.sort((a, b) => a.timestamp - b.timestamp);
-  fs2.writeFileSync(filePath, JSON.stringify(history, null, 2) + "\n");
-}
-function getRecentHistory(projectDir, limit = 50) {
-  const history = readHistory(projectDir);
-  return history.entries.slice(-limit);
+  throw new Error(
+    `DiffPrism server failed to start within ${timeoutMs / 1e3}s. Check logs at ${logPath}`
+  );
 }
-
-// packages/core/src/watch-bridge.ts
-import http from "http";
-import { WebSocketServer, WebSocket } from "ws";
-function createWatchBridge(port, callbacks) {
-  let client = null;
-  let initPayload = null;
-  let pendingInit = null;
-  let closeTimer = null;
-  let submitCallback = null;
-  let resultReject = null;
-  const httpServer = http.createServer(async (req, res) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    if (req.method === "GET" && req.url === "/api/status") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ running: true, pid: process.pid }));
-      return;
-    }
-    if (req.method === "POST" && req.url === "/api/context") {
-      let body = "";
-      req.on("data", (chunk) => {
-        body += chunk.toString();
-      });
-      req.on("end", () => {
-        try {
-          const payload = JSON.parse(body);
-          callbacks.onContextUpdate(payload);
-          sendToClient({ type: "context:update", payload });
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ ok: true }));
-        } catch {
-          res.writeHead(400, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Invalid JSON" }));
-        }
-      });
-      return;
-    }
-    if (req.method === "POST" && req.url === "/api/refresh") {
-      callbacks.onRefreshRequest();
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ ok: true }));
-      return;
-    }
-    const pathname = (req.url ?? "").split("?")[0];
-    if (req.method === "GET" && (pathname === "/api/refs" || /^\/api\/reviews\/[^/]+\/refs$/.test(pathname))) {
-      if (callbacks.onRefsRequest) {
-        const refsPayload = await callbacks.onRefsRequest();
-        if (refsPayload) {
-          res.writeHead(200, { "Content-Type": "application/json" });
-          res.end(JSON.stringify(refsPayload));
-        } else {
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(JSON.stringify({ error: "Failed to list git refs" }));
-        }
-      } else {
-        res.writeHead(404);
-        res.end("Not found");
-      }
-      return;
-    }
-    if (req.method === "POST" && (pathname === "/api/compare" || /^\/api\/reviews\/[^/]+\/compare$/.test(pathname))) {
-      if (callbacks.onCompareRequest) {
-        let body = "";
-        req.on("data", (chunk) => {
-          body += chunk.toString();
-        });
-        req.on("end", async () => {
-          try {
-            const { ref } = JSON.parse(body);
-            if (!ref) {
-              res.writeHead(400, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ error: "Missing ref" }));
-              return;
-            }
-            const success = await callbacks.onCompareRequest(ref);
-            if (success) {
-              res.writeHead(200, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ ok: true }));
-            } else {
-              res.writeHead(400, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ error: "Failed to compute diff" }));
-            }
-          } catch {
-            res.writeHead(400, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: "Invalid JSON" }));
-          }
-        });
-      } else {
-        res.writeHead(404);
-        res.end("Not found");
+function buildDefaultSpawnCommand(options) {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = path2.dirname(thisFile);
+  const workspaceRoot = path2.resolve(thisDir, "..", "..", "..");
+  const devBin = path2.join(workspaceRoot, "cli", "bin", "diffprism.mjs");
+  let binPath = "diffprism";
+  if (fs2.existsSync(devBin)) {
+    binPath = devBin;
+  } else {
+    let searchDir = thisDir;
+    while (searchDir !== path2.dirname(searchDir)) {
+      const candidate = path2.join(
+        searchDir,
+        "node_modules",
+        ".bin",
+        "diffprism"
+      );
+      if (fs2.existsSync(candidate)) {
+        binPath = candidate;
+        break;
       }
-      return;
-    }
-    res.writeHead(404);
-    res.end("Not found");
-  });
-  const wss2 = new WebSocketServer({ server: httpServer });
-  function sendToClient(msg) {
-    if (client && client.readyState === WebSocket.OPEN) {
-      client.send(JSON.stringify(msg));
+      searchDir = path2.dirname(searchDir);
     }
   }
-  wss2.on("connection", (ws) => {
-    if (closeTimer) {
-      clearTimeout(closeTimer);
-      closeTimer = null;
-    }
-    client = ws;
-    const payload = pendingInit ?? initPayload;
-    if (payload) {
-      sendToClient({ type: "review:init", payload });
-      pendingInit = null;
-    }
-    ws.on("message", (data) => {
-      try {
-        const msg = JSON.parse(data.toString());
-        if (msg.type === "review:submit" && submitCallback) {
-          submitCallback(msg.payload);
-        } else if (msg.type === "diff:change_ref" && callbacks.onDiffRefChange) {
-          callbacks.onDiffRefChange(msg.payload.diffRef);
-        }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      client = null;
-      if (resultReject) {
-        closeTimer = setTimeout(() => {
-          closeTimer = null;
-          if (resultReject) {
-            resultReject(new Error("Browser closed before review was submitted"));
-            resultReject = null;
-            submitCallback = null;
-          }
-        }, 2e3);
-      } else {
-        closeTimer = setTimeout(() => {
-          closeTimer = null;
-        }, 2e3);
-      }
-    });
-  });
-  return new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(port, () => {
-      resolve({
-        port,
-        sendInit(payload) {
-          initPayload = payload;
-          if (client && client.readyState === WebSocket.OPEN) {
-            sendToClient({ type: "review:init", payload });
-          } else {
-            pendingInit = payload;
-          }
-        },
-        storeInitPayload(payload) {
-          initPayload = payload;
-        },
-        sendDiffUpdate(payload) {
-          sendToClient({ type: "diff:update", payload });
-        },
-        sendContextUpdate(payload) {
-          sendToClient({ type: "context:update", payload });
-        },
-        sendDiffError(payload) {
-          sendToClient({ type: "diff:error", payload });
-        },
-        onSubmit(callback) {
-          submitCallback = callback;
-        },
-        waitForResult() {
-          return new Promise((resolve2, reject2) => {
-            submitCallback = resolve2;
-            resultReject = reject2;
-          });
-        },
-        triggerRefresh() {
-          callbacks.onRefreshRequest();
-        },
-        async close() {
-          if (closeTimer) {
-            clearTimeout(closeTimer);
-          }
-          for (const ws of wss2.clients) {
-            ws.close();
-          }
-          wss2.close();
-          await new Promise((resolve2) => {
-            httpServer.close(() => resolve2());
-          });
+  const args = [process.execPath, binPath, "server", "--_daemon"];
+  if (options.dev) {
+    args.push("--dev");
+  }
+  return args;
+}
+async function submitReviewToServer(serverInfo, diffRef, options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const projectPath = options.projectPath ?? cwd;
+  let payload;
+  if (options.injectedPayload) {
+    payload = options.injectedPayload;
+  } else {
+    const { getDiff: getDiff2, getCurrentBranch: getCurrentBranch2, detectWorktree } = await import("./src-AMCPIYDZ.js");
+    const { analyze: analyze2 } = await import("./src-JMPTSU3P.js");
+    const { diffSet, rawDiff } = getDiff2(diffRef, { cwd });
+    if (diffSet.files.length === 0) {
+      return {
+        result: {
+          decision: "approved",
+          comments: [],
+          summary: "No changes to review."
+        },
+        sessionId: ""
+      };
+    }
+    const briefing = analyze2(diffSet);
+    const currentBranch = getCurrentBranch2({ cwd });
+    const worktreeInfo = detectWorktree({ cwd });
+    payload = {
+      reviewId: "",
+      // Server assigns the real ID
+      diffSet,
+      rawDiff,
+      briefing,
+      metadata: {
+        title: options.title,
+        description: options.description,
+        reasoning: options.reasoning,
+        currentBranch,
+        worktree: worktreeInfo.isWorktree ? {
+          isWorktree: true,
+          worktreePath: worktreeInfo.worktreePath,
+          mainWorktreePath: worktreeInfo.mainWorktreePath
+        } : void 0
+      }
+    };
+  }
+  const createResponse = await fetch(
+    `http://localhost:${serverInfo.httpPort}/api/reviews`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        payload,
+        projectPath,
+        diffRef: options.diffRef ?? diffRef
+      })
+    }
+  );
+  if (!createResponse.ok) {
+    throw new Error(
+      `Global server returned ${createResponse.status} on create`
+    );
+  }
+  const { sessionId } = await createResponse.json();
+  if (options.annotations?.length) {
+    for (const ann of options.annotations) {
+      await fetch(
+        `http://localhost:${serverInfo.httpPort}/api/reviews/${sessionId}/annotations`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            file: ann.file,
+            line: ann.line,
+            body: ann.body,
+            type: ann.type,
+            confidence: ann.confidence ?? 1,
+            category: ann.category ?? "other",
+            source: {
+              agent: ann.source_agent ?? "unknown",
+              tool: "open_review"
+            }
+          })
         }
-      });
-    });
-  });
+      );
+    }
+  }
+  const pollIntervalMs = 2e3;
+  const maxWaitMs = options.timeoutMs ?? 6e5;
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    const resultResponse = await fetch(
+      `http://localhost:${serverInfo.httpPort}/api/reviews/${sessionId}/result`
+    );
+    if (resultResponse.ok) {
+      const data = await resultResponse.json();
+      if (data.result) {
+        return { result: data.result, sessionId };
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new Error("Review timed out waiting for submission.");
 }
 
 // packages/core/src/diff-utils.ts
@@ -1494,32 +447,18 @@ function createDiffPoller(options) {
   };
 }
 
-// packages/core/src/review-manager.ts
-var sessions = /* @__PURE__ */ new Map();
-var idCounter = 0;
-function createSession(options) {
-  const id = `review-${Date.now()}-${++idCounter}`;
-  const session = {
-    id,
-    options,
-    status: "pending",
-    createdAt: Date.now()
-  };
-  sessions.set(id, session);
-  return session;
-}
-function updateSession(id, update) {
-  const session = sessions.get(id);
-  if (session) {
-    Object.assign(session, update);
-  }
-}
+// packages/core/src/global-server.ts
+import http2 from "http";
+import { randomUUID as randomUUID2 } from "crypto";
+import getPort from "get-port";
+import open from "open";
+import { WebSocketServer, WebSocket } from "ws";
 
 // packages/core/src/ui-server.ts
-import http2 from "http";
+import http from "http";
 import fs3 from "fs";
-import path5 from "path";
-import { fileURLToPath } from "url";
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var MIME_TYPES = {
   ".html": "text/html",
   ".js": "application/javascript",
@@ -1532,15 +471,15 @@ var MIME_TYPES = {
   ".woff2": "font/woff2"
 };
 function resolveUiDist() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = path5.dirname(thisFile);
-  const publishedUiDist = path5.resolve(thisDir, "..", "ui-dist");
-  if (fs3.existsSync(path5.join(publishedUiDist, "index.html"))) {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = path3.dirname(thisFile);
+  const publishedUiDist = path3.resolve(thisDir, "..", "ui-dist");
+  if (fs3.existsSync(path3.join(publishedUiDist, "index.html"))) {
     return publishedUiDist;
   }
-  const workspaceRoot = path5.resolve(thisDir, "..", "..", "..");
-  const devUiDist = path5.join(workspaceRoot, "packages", "ui", "dist");
-  if (fs3.existsSync(path5.join(devUiDist, "index.html"))) {
+  const workspaceRoot = path3.resolve(thisDir, "..", "..", "..");
+  const devUiDist = path3.join(workspaceRoot, "packages", "ui", "dist");
+  if (fs3.existsSync(path3.join(devUiDist, "index.html"))) {
     return devUiDist;
   }
   throw new Error(
@@ -1548,11 +487,11 @@ function resolveUiDist() {
   );
 }
 function resolveUiRoot() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = path5.dirname(thisFile);
-  const workspaceRoot = path5.resolve(thisDir, "..", "..", "..");
-  const uiRoot = path5.join(workspaceRoot, "packages", "ui");
-  if (fs3.existsSync(path5.join(uiRoot, "index.html"))) {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = path3.dirname(thisFile);
+  const workspaceRoot = path3.resolve(thisDir, "..", "..", "..");
+  const uiRoot = path3.join(workspaceRoot, "packages", "ui");
+  if (fs3.existsSync(path3.join(uiRoot, "index.html"))) {
     return uiRoot;
   }
   throw new Error(
@@ -1570,13 +509,13 @@ async function startViteDevServer(uiRoot, port, silent) {
   return vite;
 }
 function createStaticServer(distPath, port) {
-  const server = http2.createServer((req, res) => {
+  const server = http.createServer((req, res) => {
     const urlPath = req.url?.split("?")[0] ?? "/";
-    let filePath = path5.join(distPath, urlPath === "/" ? "index.html" : urlPath);
+    let filePath = path3.join(distPath, urlPath === "/" ? "index.html" : urlPath);
     if (!fs3.existsSync(filePath)) {
-      filePath = path5.join(distPath, "index.html");
+      filePath = path3.join(distPath, "index.html");
     }
-    const ext = path5.extname(filePath);
+    const ext = path3.extname(filePath);
     const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
     try {
       const content = fs3.readFileSync(filePath);
@@ -1593,476 +532,50 @@ function createStaticServer(distPath, port) {
   });
 }
 
-// packages/core/src/pipeline.ts
-async function startReview(options) {
-  const { diffRef, title, description, reasoning, cwd, silent, dev, injectedPayload } = options;
-  let diffSet;
-  let rawDiff;
-  let briefing;
-  let metadata;
-  if (injectedPayload) {
-    diffSet = injectedPayload.diffSet;
-    rawDiff = injectedPayload.rawDiff;
-    briefing = injectedPayload.briefing;
-    metadata = { ...injectedPayload.metadata };
-  } else {
-    const result = getDiff(diffRef, { cwd });
-    diffSet = result.diffSet;
-    rawDiff = result.rawDiff;
-    const currentBranch = getCurrentBranch({ cwd });
-    if (diffSet.files.length === 0) {
-      if (!silent) {
-        console.log("No changes to review.");
-      }
-      return {
-        decision: "approved",
-        comments: [],
-        summary: "No changes to review."
-      };
-    }
-    briefing = analyze(diffSet);
-    const worktreeInfo = detectWorktree({ cwd });
-    metadata = {
-      title,
-      description,
-      reasoning,
-      currentBranch,
-      worktree: worktreeInfo.isWorktree ? {
-        isWorktree: true,
-        worktreePath: worktreeInfo.worktreePath,
-        mainWorktreePath: worktreeInfo.mainWorktreePath
-      } : void 0
-    };
-  }
-  if (diffSet.files.length === 0) {
-    if (!silent) {
-      console.log("No changes to review.");
-    }
-    return {
-      decision: "approved",
-      comments: [],
-      summary: "No changes to review."
-    };
-  }
-  const session = createSession(options);
-  updateSession(session.id, { status: "in_progress" });
-  const isInjected = !!injectedPayload;
-  let poller = null;
-  const [bridgePort, httpPort] = await Promise.all([
-    getPort(),
-    getPort()
-  ]);
-  function handleDiffRefChange(newRef) {
-    if (isInjected) return;
-    const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, { cwd });
-    const newBriefing = analyze(newDiffSet);
-    bridge.sendDiffUpdate({
-      diffSet: newDiffSet,
-      rawDiff: newRawDiff,
-      briefing: newBriefing,
-      changedFiles: newDiffSet.files.map((f) => f.path),
-      timestamp: Date.now()
-    });
-    bridge.storeInitPayload({
-      reviewId: session.id,
-      diffSet: newDiffSet,
-      rawDiff: newRawDiff,
-      briefing: newBriefing,
-      metadata,
-      watchMode: true
-    });
-    poller?.setDiffRef(newRef);
-  }
-  const bridge = await createWatchBridge(bridgePort, {
-    onRefreshRequest: () => {
-      poller?.refresh();
-    },
-    onContextUpdate: (payload) => {
-      if (payload.reasoning !== void 0) metadata.reasoning = payload.reasoning;
-      if (payload.title !== void 0) metadata.title = payload.title;
-      if (payload.description !== void 0) metadata.description = payload.description;
-    },
-    onDiffRefChange: (newRef) => {
-      if (isInjected) return;
-      try {
-        handleDiffRefChange(newRef);
-      } catch (err) {
-        bridge.sendDiffError({
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    },
-    onRefsRequest: async () => {
-      if (isInjected) return null;
-      try {
-        const resolvedCwd = cwd ?? process.cwd();
-        const branches = listBranches({ cwd: resolvedCwd });
-        const commits = listCommits({ cwd: resolvedCwd });
-        const branch = getCurrentBranch({ cwd: resolvedCwd });
-        return { branches, commits, currentBranch: branch };
-      } catch {
-        return null;
-      }
-    },
-    onCompareRequest: async (ref) => {
-      if (isInjected) return false;
-      try {
-        handleDiffRefChange(ref);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  });
-  let httpServer = null;
-  let viteServer = null;
-  try {
-    if (dev) {
-      const uiRoot = resolveUiRoot();
-      viteServer = await startViteDevServer(uiRoot, httpPort, !!silent);
-    } else {
-      const uiDist = resolveUiDist();
-      httpServer = await createStaticServer(uiDist, httpPort);
-    }
-    writeWatchFile(cwd, {
-      wsPort: bridgePort,
-      uiPort: httpPort,
-      pid: process.pid,
-      cwd: cwd ?? process.cwd(),
-      diffRef,
-      startedAt: Date.now()
-    });
-    const url = `http://localhost:${httpPort}?wsPort=${bridgePort}&httpPort=${bridgePort}&reviewId=${session.id}`;
-    if (!silent) {
-      console.log(`
-DiffPrism Review: ${title ?? briefing.summary}`);
-      console.log(`Opening browser at ${url}
-`);
-    }
-    await open(url);
-    const initPayload = {
-      reviewId: session.id,
-      diffSet,
-      rawDiff,
-      briefing,
-      metadata,
-      watchMode: !isInjected
-    };
-    bridge.sendInit(initPayload);
-    if (!isInjected) {
-      poller = createDiffPoller({
-        diffRef,
-        cwd: cwd ?? process.cwd(),
-        pollInterval: 1e3,
-        onDiffChanged: (updatePayload) => {
-          bridge.storeInitPayload({
-            reviewId: session.id,
-            diffSet: updatePayload.diffSet,
-            rawDiff: updatePayload.rawDiff,
-            briefing: updatePayload.briefing,
-            metadata,
-            watchMode: true
-          });
-          bridge.sendDiffUpdate(updatePayload);
-          if (!silent && updatePayload.changedFiles.length > 0) {
-            console.log(
-              `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Diff updated: ${updatePayload.changedFiles.length} file(s) changed`
-            );
-          }
-        }
-      });
-      poller.start();
-    }
-    const result = await bridge.waitForResult();
-    poller?.stop();
-    updateSession(session.id, { status: "completed", result });
-    try {
-      const projectDir = cwd ?? process.cwd();
-      const entry = {
-        id: generateEntryId(),
-        timestamp: Date.now(),
-        diffRef,
-        decision: result.decision,
-        filesReviewed: diffSet.files.length,
-        additions: diffSet.files.reduce((sum, f) => sum + f.additions, 0),
-        deletions: diffSet.files.reduce((sum, f) => sum + f.deletions, 0),
-        commentCount: result.comments.length,
-        branch: metadata.currentBranch,
-        title: metadata.title,
-        summary: result.summary ?? briefing.summary
-      };
-      appendHistory(projectDir, entry);
-    } catch {
-    }
-    return result;
-  } finally {
-    poller?.stop();
-    await bridge.close();
-    removeWatchFile(cwd);
-    if (viteServer) {
-      await viteServer.close();
-    }
-    if (httpServer) {
-      httpServer.close();
-    }
-  }
-}
-
-// packages/core/src/server-file.ts
+// packages/core/src/review-history.ts
 import fs4 from "fs";
-import path6 from "path";
-import os from "os";
-function serverDir() {
-  return path6.join(os.homedir(), ".diffprism");
-}
-function serverFilePath() {
-  return path6.join(serverDir(), "server.json");
-}
-function isPidAlive2(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
+import path4 from "path";
+import { randomUUID } from "crypto";
+function generateEntryId() {
+  return randomUUID();
 }
-function writeServerFile(info) {
-  const dir = serverDir();
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
-  }
-  fs4.writeFileSync(serverFilePath(), JSON.stringify(info, null, 2) + "\n");
+function getHistoryPath(projectDir) {
+  return path4.join(projectDir, ".diffprism", "history", "reviews.json");
 }
-function readServerFile() {
-  const filePath = serverFilePath();
+function readHistory(projectDir) {
+  const filePath = getHistoryPath(projectDir);
   if (!fs4.existsSync(filePath)) {
-    return null;
+    return { version: 1, entries: [] };
   }
   try {
     const raw = fs4.readFileSync(filePath, "utf-8");
-    const info = JSON.parse(raw);
-    if (!isPidAlive2(info.pid)) {
-      fs4.unlinkSync(filePath);
-      return null;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function removeServerFile() {
-  try {
-    const filePath = serverFilePath();
-    if (fs4.existsSync(filePath)) {
-      fs4.unlinkSync(filePath);
-    }
+    const parsed = JSON.parse(raw);
+    return parsed;
   } catch {
+    return { version: 1, entries: [] };
   }
 }
-async function isServerAlive() {
-  const info = readServerFile();
-  if (!info) {
-    return null;
-  }
-  try {
-    const response = await fetch(`http://localhost:${info.httpPort}/api/status`, {
-      signal: AbortSignal.timeout(2e3)
-    });
-    if (response.ok) {
-      return info;
-    }
-    return null;
-  } catch {
-    removeServerFile();
-    return null;
+function appendHistory(projectDir, entry) {
+  const filePath = getHistoryPath(projectDir);
+  const dir = path4.dirname(filePath);
+  if (!fs4.existsSync(dir)) {
+    fs4.mkdirSync(dir, { recursive: true });
   }
+  const history = readHistory(projectDir);
+  history.entries.push(entry);
+  history.entries.sort((a, b) => a.timestamp - b.timestamp);
+  fs4.writeFileSync(filePath, JSON.stringify(history, null, 2) + "\n");
 }
-
-// packages/core/src/watch.ts
-import getPort2 from "get-port";
-import open2 from "open";
-async function startWatch(options) {
-  const {
-    diffRef,
-    title,
-    description,
-    reasoning,
-    cwd,
-    silent,
-    dev,
-    pollInterval = 1e3
-  } = options;
-  const { diffSet: initialDiffSet, rawDiff: initialRawDiff } = getDiff(diffRef, { cwd });
-  const currentBranch = getCurrentBranch({ cwd });
-  const initialBriefing = analyze(initialDiffSet);
-  const metadata = {
-    title,
-    description,
-    reasoning,
-    currentBranch
-  };
-  const [bridgePort, uiPort] = await Promise.all([
-    getPort2(),
-    getPort2()
-  ]);
-  const reviewId = "watch-session";
-  function handleDiffRefChange(newRef) {
-    const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, { cwd });
-    const newBriefing = analyze(newDiffSet);
-    bridge.sendDiffUpdate({
-      diffSet: newDiffSet,
-      rawDiff: newRawDiff,
-      briefing: newBriefing,
-      changedFiles: newDiffSet.files.map((f) => f.path),
-      timestamp: Date.now()
-    });
-    bridge.storeInitPayload({
-      reviewId,
-      diffSet: newDiffSet,
-      rawDiff: newRawDiff,
-      briefing: newBriefing,
-      metadata,
-      watchMode: true
-    });
-    poller.setDiffRef(newRef);
-  }
-  const bridge = await createWatchBridge(bridgePort, {
-    onRefreshRequest: () => {
-      poller.refresh();
-    },
-    onContextUpdate: (payload) => {
-      if (payload.reasoning !== void 0) metadata.reasoning = payload.reasoning;
-      if (payload.title !== void 0) metadata.title = payload.title;
-      if (payload.description !== void 0) metadata.description = payload.description;
-    },
-    onDiffRefChange: (newRef) => {
-      try {
-        handleDiffRefChange(newRef);
-      } catch (err) {
-        bridge.sendDiffError({
-          error: err instanceof Error ? err.message : String(err)
-        });
-      }
-    },
-    onRefsRequest: async () => {
-      try {
-        const resolvedCwd = cwd ?? process.cwd();
-        const branches = listBranches({ cwd: resolvedCwd });
-        const commits = listCommits({ cwd: resolvedCwd });
-        const branch = getCurrentBranch({ cwd: resolvedCwd });
-        return { branches, commits, currentBranch: branch };
-      } catch {
-        return null;
-      }
-    },
-    onCompareRequest: async (ref) => {
-      try {
-        handleDiffRefChange(ref);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-  });
-  let httpServer = null;
-  let viteServer = null;
-  if (dev) {
-    const uiRoot = resolveUiRoot();
-    viteServer = await startViteDevServer(uiRoot, uiPort, !!silent);
-  } else {
-    const uiDist = resolveUiDist();
-    httpServer = await createStaticServer(uiDist, uiPort);
-  }
-  writeWatchFile(cwd, {
-    wsPort: bridgePort,
-    uiPort,
-    pid: process.pid,
-    cwd: cwd ?? process.cwd(),
-    diffRef,
-    startedAt: Date.now()
-  });
-  const url = `http://localhost:${uiPort}?wsPort=${bridgePort}&httpPort=${bridgePort}&reviewId=${reviewId}`;
-  if (!silent) {
-    console.log(`
-DiffPrism Watch: ${title ?? `watching ${diffRef}`}`);
-    console.log(`Browser: ${url}`);
-    console.log(`API: http://localhost:${bridgePort}`);
-    console.log(`Polling every ${pollInterval}ms
-`);
-  }
-  await open2(url);
-  const initPayload = {
-    reviewId,
-    diffSet: initialDiffSet,
-    rawDiff: initialRawDiff,
-    briefing: initialBriefing,
-    metadata,
-    watchMode: true
-  };
-  bridge.sendInit(initPayload);
-  bridge.onSubmit((result) => {
-    if (!silent) {
-      console.log(`
-Review submitted: ${result.decision}`);
-      if (result.comments.length > 0) {
-        console.log(`  ${result.comments.length} comment(s)`);
-      }
-      console.log("Continuing to watch...\n");
-    }
-    writeReviewResult(cwd, result);
-  });
-  const poller = createDiffPoller({
-    diffRef,
-    cwd: cwd ?? process.cwd(),
-    pollInterval,
-    onDiffChanged: (updatePayload) => {
-      bridge.storeInitPayload({
-        reviewId,
-        diffSet: updatePayload.diffSet,
-        rawDiff: updatePayload.rawDiff,
-        briefing: updatePayload.briefing,
-        metadata,
-        watchMode: true
-      });
-      bridge.sendDiffUpdate(updatePayload);
-      if (!silent && updatePayload.changedFiles.length > 0) {
-        console.log(
-          `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Diff updated: ${updatePayload.changedFiles.length} file(s) changed`
-        );
-      }
-    }
-  });
-  poller.start();
-  async function stop() {
-    poller.stop();
-    await bridge.close();
-    if (viteServer) {
-      await viteServer.close();
-    }
-    if (httpServer) {
-      httpServer.close();
-    }
-    removeWatchFile(cwd);
-  }
-  function updateContext(payload) {
-    if (payload.reasoning !== void 0) metadata.reasoning = payload.reasoning;
-    if (payload.title !== void 0) metadata.title = payload.title;
-    if (payload.description !== void 0) metadata.description = payload.description;
-    bridge.sendContextUpdate(payload);
-  }
-  return { stop, updateContext };
+function getRecentHistory(projectDir, limit = 50) {
+  const history = readHistory(projectDir);
+  return history.entries.slice(-limit);
 }
 
 // packages/core/src/global-server.ts
-import http3 from "http";
-import { randomUUID as randomUUID2 } from "crypto";
-import getPort3 from "get-port";
-import open3 from "open";
-import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket2 } from "ws";
 var SUBMITTED_TTL_MS = 5 * 60 * 1e3;
 var ABANDONED_TTL_MS = 60 * 60 * 1e3;
 var CLEANUP_INTERVAL_MS = 60 * 1e3;
-var sessions2 = /* @__PURE__ */ new Map();
+var sessions = /* @__PURE__ */ new Map();
 var clientSessions = /* @__PURE__ */ new Map();
 var sessionWatchers = /* @__PURE__ */ new Map();
 var serverPollInterval = 2e3;
@@ -2124,7 +637,7 @@ function broadcastToAll(msg) {
   if (!wss) return;
   const data = JSON.stringify(msg);
   for (const client of wss.clients) {
-    if (client.readyState === WebSocket2.OPEN) {
+    if (client.readyState === WebSocket.OPEN) {
       client.send(data);
     }
   }
@@ -2133,7 +646,7 @@ function sendToSessionClients(sessionId, msg) {
   if (!wss) return;
   const data = JSON.stringify(msg);
   for (const [client, sid] of clientSessions.entries()) {
-    if (sid === sessionId && client.readyState === WebSocket2.OPEN) {
+    if (sid === sessionId && client.readyState === WebSocket.OPEN) {
       client.send(data);
     }
   }
@@ -2157,7 +670,7 @@ function broadcastSessionRemoved(sessionId) {
 }
 function hasViewersForSession(sessionId) {
   for (const [client, sid] of clientSessions.entries()) {
-    if (sid === sessionId && client.readyState === WebSocket2.OPEN) {
+    if (sid === sessionId && client.readyState === WebSocket.OPEN) {
       return true;
     }
   }
@@ -2165,14 +678,14 @@ function hasViewersForSession(sessionId) {
 }
 function startSessionWatcher(sessionId) {
   if (sessionWatchers.has(sessionId)) return;
-  const session = sessions2.get(sessionId);
+  const session = sessions.get(sessionId);
   if (!session?.diffRef) return;
   const poller = createDiffPoller({
     diffRef: session.diffRef,
     cwd: session.projectPath,
     pollInterval: serverPollInterval,
     onDiffChanged: (updatePayload) => {
-      const s = sessions2.get(sessionId);
+      const s = sessions.get(sessionId);
       if (!s) return;
       s.payload = {
         ...s.payload,
@@ -2205,7 +718,7 @@ function stopSessionWatcher(sessionId) {
   }
 }
 function startAllWatchers() {
-  for (const [id, session] of sessions2.entries()) {
+  for (const [id, session] of sessions.entries()) {
     if (session.diffRef && !sessionWatchers.has(id)) {
       startSessionWatcher(id);
     }
@@ -2220,15 +733,16 @@ function stopAllWatchers() {
 function hasConnectedClients() {
   if (!wss) return false;
   for (const client of wss.clients) {
-    if (client.readyState === WebSocket2.OPEN) return true;
+    if (client.readyState === WebSocket.OPEN) return true;
   }
   return false;
 }
 function broadcastSessionList() {
-  const summaries = Array.from(sessions2.values()).map(toSummary);
+  const summaries = Array.from(sessions.values()).map(toSummary);
   broadcastToAll({ type: "session:list", payload: summaries });
 }
 function recordReviewHistory(session, result) {
+  if (session.projectPath.startsWith("github:")) return;
   try {
     const { payload } = session;
     const entry = {
@@ -2266,7 +780,7 @@ async function handleApiRequest(req, res) {
     jsonResponse(res, 200, {
       running: true,
       pid: process.pid,
-      sessions: sessions2.size,
+      sessions: sessions.size,
       uptime: process.uptime()
     });
     return true;
@@ -2276,7 +790,7 @@ async function handleApiRequest(req, res) {
       const body = await readBody(req);
       const { payload, projectPath, diffRef } = JSON.parse(body);
       let existingSession;
-      for (const session of sessions2.values()) {
+      for (const session of sessions.values()) {
         if (session.projectPath === projectPath) {
           existingSession = session;
           break;
@@ -2298,7 +812,7 @@ async function handleApiRequest(req, res) {
         existingSession.lastDiffSet = diffRef ? payload.diffSet : void 0;
         existingSession.hasNewChanges = false;
         existingSession.annotations = [];
-        if (diffRef && hasConnectedClients()) {
+        if (diffRef) {
           startSessionWatcher(sessionId);
         }
         if (hasViewersForSession(sessionId)) {
@@ -2329,8 +843,8 @@ async function handleApiRequest(req, res) {
           hasNewChanges: false,
           annotations: []
         };
-        sessions2.set(sessionId, session);
-        if (diffRef && hasConnectedClients()) {
+        sessions.set(sessionId, session);
+        if (diffRef) {
           startSessionWatcher(sessionId);
         }
         broadcastToAll({
@@ -2346,13 +860,13 @@ async function handleApiRequest(req, res) {
     return true;
   }
   if (method === "GET" && url === "/api/reviews") {
-    const summaries = Array.from(sessions2.values()).map(toSummary);
+    const summaries = Array.from(sessions.values()).map(toSummary);
     jsonResponse(res, 200, { sessions: summaries });
     return true;
   }
   const getReviewParams = matchRoute(method, url, "GET", "/api/reviews/:id");
   if (getReviewParams) {
-    const session = sessions2.get(getReviewParams.id);
+    const session = sessions.get(getReviewParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
@@ -2362,7 +876,7 @@ async function handleApiRequest(req, res) {
   }
   const postResultParams = matchRoute(method, url, "POST", "/api/reviews/:id/result");
   if (postResultParams) {
-    const session = sessions2.get(postResultParams.id);
+    const session = sessions.get(postResultParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
@@ -2386,7 +900,7 @@ async function handleApiRequest(req, res) {
   }
   const getResultParams = matchRoute(method, url, "GET", "/api/reviews/:id/result");
   if (getResultParams) {
-    const session = sessions2.get(getResultParams.id);
+    const session = sessions.get(getResultParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
@@ -2400,7 +914,7 @@ async function handleApiRequest(req, res) {
   }
   const postContextParams = matchRoute(method, url, "POST", "/api/reviews/:id/context");
   if (postContextParams) {
-    const session = sessions2.get(postContextParams.id);
+    const session = sessions.get(postContextParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
@@ -2429,7 +943,7 @@ async function handleApiRequest(req, res) {
   }
   const postAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations");
   if (postAnnotationParams) {
-    const session = sessions2.get(postAnnotationParams.id);
+    const session = sessions.get(postAnnotationParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
@@ -2462,7 +976,7 @@ async function handleApiRequest(req, res) {
   }
   const getAnnotationsParams = matchRoute(method, url, "GET", "/api/reviews/:id/annotations");
   if (getAnnotationsParams) {
-    const session = sessions2.get(getAnnotationsParams.id);
+    const session = sessions.get(getAnnotationsParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
@@ -2472,7 +986,7 @@ async function handleApiRequest(req, res) {
   }
   const dismissAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations/:annotationId/dismiss");
   if (dismissAnnotationParams) {
-    const session = sessions2.get(dismissAnnotationParams.id);
+    const session = sessions.get(dismissAnnotationParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
@@ -2493,7 +1007,7 @@ async function handleApiRequest(req, res) {
   const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
   if (deleteParams) {
     stopSessionWatcher(deleteParams.id);
-    if (sessions2.delete(deleteParams.id)) {
+    if (sessions.delete(deleteParams.id)) {
       broadcastSessionRemoved(deleteParams.id);
       jsonResponse(res, 200, { ok: true });
     } else {
@@ -2503,11 +1017,15 @@ async function handleApiRequest(req, res) {
   }
   const getRefsParams = matchRoute(method, url, "GET", "/api/reviews/:id/refs");
   if (getRefsParams) {
-    const session = sessions2.get(getRefsParams.id);
+    const session = sessions.get(getRefsParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
     }
+    if (session.projectPath.startsWith("github:")) {
+      jsonResponse(res, 400, { error: "Ref listing not available for GitHub PRs" });
+      return true;
+    }
     try {
       const branches = listBranches({ cwd: session.projectPath });
       const commits = listCommits({ cwd: session.projectPath });
@@ -2520,11 +1038,15 @@ async function handleApiRequest(req, res) {
   }
   const postCompareParams = matchRoute(method, url, "POST", "/api/reviews/:id/compare");
   if (postCompareParams) {
-    const session = sessions2.get(postCompareParams.id);
+    const session = sessions.get(postCompareParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
     }
+    if (session.projectPath.startsWith("github:")) {
+      jsonResponse(res, 400, { error: "Ref comparison not available for GitHub PRs" });
+      return true;
+    }
     try {
       const body = await readBody(req);
       const { ref } = JSON.parse(body);
@@ -2568,7 +1090,7 @@ async function handleApiRequest(req, res) {
   }
   const getSessionHistoryParams = matchRoute(method, url, "GET", "/api/reviews/:id/history");
   if (getSessionHistoryParams) {
-    const session = sessions2.get(getSessionHistoryParams.id);
+    const session = sessions.get(getSessionHistoryParams.id);
     if (!session) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
@@ -2607,40 +1129,41 @@ async function startGlobalServer(options = {}) {
     wsPort: preferredWsPort = 24681,
     silent = false,
     dev = false,
-    pollInterval = 2e3
+    pollInterval = 2e3,
+    openBrowser = true
   } = options;
   serverPollInterval = pollInterval;
   const [httpPort, wsPort] = await Promise.all([
-    getPort3({ port: preferredHttpPort }),
-    getPort3({ port: preferredWsPort })
+    getPort({ port: preferredHttpPort }),
+    getPort({ port: preferredWsPort })
   ]);
   let uiPort;
   let uiHttpServer = null;
   let viteServer = null;
   if (dev) {
-    uiPort = await getPort3();
+    uiPort = await getPort();
     const uiRoot = resolveUiRoot();
     viteServer = await startViteDevServer(uiRoot, uiPort, silent);
   } else {
-    uiPort = await getPort3();
+    uiPort = await getPort();
     const uiDist = resolveUiDist();
     uiHttpServer = await createStaticServer(uiDist, uiPort);
   }
-  const httpServer = http3.createServer(async (req, res) => {
+  const httpServer = http2.createServer(async (req, res) => {
     const handled = await handleApiRequest(req, res);
     if (!handled) {
       res.writeHead(404);
       res.end("Not found");
     }
   });
-  wss = new WebSocketServer2({ port: wsPort });
+  wss = new WebSocketServer({ port: wsPort });
   wss.on("connection", (ws, req) => {
     startAllWatchers();
     const url = new URL(req.url ?? "/", `http://localhost:${wsPort}`);
     const sessionId = url.searchParams.get("sessionId");
     if (sessionId) {
       clientSessions.set(ws, sessionId);
-      const session = sessions2.get(sessionId);
+      const session = sessions.get(sessionId);
       if (session) {
         session.status = "in_review";
         session.hasNewChanges = false;
@@ -2658,14 +1181,14 @@ async function startGlobalServer(options = {}) {
         }
       }
     } else {
-      const summaries = Array.from(sessions2.values()).map(toSummary);
+      const summaries = Array.from(sessions.values()).map(toSummary);
       const msg = {
         type: "session:list",
         payload: summaries
       };
       ws.send(JSON.stringify(msg));
       if (summaries.length === 1) {
-        const session = sessions2.get(summaries[0].id);
+        const session = sessions.get(summaries[0].id);
         if (session) {
           clientSessions.set(ws, session.id);
           session.status = "in_review";
@@ -2690,7 +1213,7 @@ async function startGlobalServer(options = {}) {
         if (msg.type === "review:submit") {
           const sid = clientSessions.get(ws);
           if (sid) {
-            const session = sessions2.get(sid);
+            const session = sessions.get(sid);
             if (session) {
               session.result = msg.payload;
               session.status = "submitted";
@@ -2703,7 +1226,7 @@ async function startGlobalServer(options = {}) {
             }
           }
         } else if (msg.type === "session:select") {
-          const session = sessions2.get(msg.payload.sessionId);
+          const session = sessions.get(msg.payload.sessionId);
           if (session) {
             clientSessions.set(ws, session.id);
             session.status = "in_review";
@@ -2724,7 +1247,7 @@ async function startGlobalServer(options = {}) {
         } else if (msg.type === "session:close") {
           const closedId = msg.payload.sessionId;
           stopSessionWatcher(closedId);
-          const closedSession = sessions2.get(closedId);
+          const closedSession = sessions.get(closedId);
           if (closedSession && !closedSession.result) {
             closedSession.result = { decision: "dismissed", comments: [] };
             closedSession.status = "submitted";
@@ -2733,7 +1256,7 @@ async function startGlobalServer(options = {}) {
         } else if (msg.type === "diff:change_ref") {
           const sid = clientSessions.get(ws);
           if (sid) {
-            const session = sessions2.get(sid);
+            const session = sessions.get(sid);
             if (session) {
               const newRef = msg.payload.diffRef;
               try {
@@ -2779,9 +1302,6 @@ async function startGlobalServer(options = {}) {
     });
     ws.on("close", () => {
       clientSessions.delete(ws);
-      if (!hasConnectedClients()) {
-        stopAllWatchers();
-      }
     });
   });
   await new Promise((resolve, reject) => {
@@ -2790,12 +1310,12 @@ async function startGlobalServer(options = {}) {
   });
   function cleanupExpiredSessions() {
     const now = Date.now();
-    for (const [id, session] of sessions2.entries()) {
+    for (const [id, session] of sessions.entries()) {
       const age = now - session.createdAt;
       const expired = session.status === "submitted" && age > SUBMITTED_TTL_MS || session.status === "pending" && age > ABANDONED_TTL_MS;
       if (expired) {
         stopSessionWatcher(id);
-        sessions2.delete(id);
+        sessions.delete(id);
         broadcastSessionRemoved(id);
       }
     }
@@ -2820,10 +1340,12 @@ Waiting for reviews...
 `);
   }
   const uiUrl = `http://localhost:${uiPort}?wsPort=${wsPort}&httpPort=${httpPort}&serverMode=true`;
-  await open3(uiUrl);
+  if (openBrowser) {
+    await open(uiUrl);
+  }
   reopenBrowserIfNeeded = () => {
     if (!hasConnectedClients()) {
-      open3(uiUrl);
+      open(uiUrl);
     }
   };
   async function stop() {
@@ -2837,7 +1359,7 @@ Waiting for reviews...
       wss = null;
     }
     clientSessions.clear();
-    sessions2.clear();
+    sessions.clear();
     reopenBrowserIfNeeded = null;
     await new Promise((resolve) => {
       httpServer.close(() => resolve());
@@ -2854,17 +1376,17 @@ Waiting for reviews...
 }
 
 // packages/github/src/auth.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync } from "child_process";
 import fs5 from "fs";
-import path7 from "path";
-import os2 from "os";
+import path5 from "path";
+import os3 from "os";
 function resolveGitHubToken() {
   const envToken = process.env.GITHUB_TOKEN;
   if (envToken) {
     return envToken;
   }
   try {
-    const token = execSync3("gh auth token", {
+    const token = execSync("gh auth token", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -2873,7 +1395,7 @@ function resolveGitHubToken() {
     }
   } catch {
   }
-  const configPath = path7.join(os2.homedir(), ".diffprism", "config.json");
+  const configPath = path5.join(os3.homedir(), ".diffprism", "config.json");
   try {
     if (fs5.existsSync(configPath)) {
       const raw = fs5.readFileSync(configPath, "utf-8");
@@ -3837,17 +2359,17 @@ function requestLog(octokit) {
     octokit.log.debug("request", options);
     const start = Date.now();
     const requestOptions = octokit.request.endpoint.parse(options);
-    const path8 = requestOptions.url.replace(options.baseUrl, "");
+    const path6 = requestOptions.url.replace(options.baseUrl, "");
     return request2(options).then((response) => {
       const requestId = response.headers["x-github-request-id"];
       octokit.log.info(
-        `${requestOptions.method} ${path8} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
+        `${requestOptions.method} ${path6} - ${response.status} with id ${requestId} in ${Date.now() - start}ms`
       );
       return response;
     }).catch((error) => {
       const requestId = error.response?.headers["x-github-request-id"] || "UNKNOWN";
       octokit.log.error(
-        `${requestOptions.method} ${path8} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`
+        `${requestOptions.method} ${path6} - ${error.status} with id ${requestId} in ${Date.now() - start}ms`
       );
       throw error;
     });
@@ -6586,18 +5108,11 @@ function buildReviewBody(result) {
 }
 
 export {
-  getCurrentBranch,
-  detectWorktree,
-  getDiff,
-  analyze,
-  readWatchFile,
-  readReviewResult,
-  consumeReviewResult,
-  startReview,
-  startWatch,
   readServerFile,
   isServerAlive,
   startGlobalServer,
+  ensureServer,
+  submitReviewToServer,
   resolveGitHubToken,
   createGitHubClient,
   fetchPullRequest,