diffprism 0.27.0 → 0.30.0

package/dist/{chunk-BNCXGE4V.js → chunk-OJ723D6Z.js}

@@ -116,6 +116,46 @@ function listCommits(options) {
     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 {
@@ -398,17 +438,138 @@ function getWorkingCopyDiff(options) {
 }
 
 // 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(path7) {
+  return MECHANICAL_CONFIG_PATTERNS.some((re) => re.test(path7));
+}
+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 notable = files.map((f) => ({
-    file: f.path,
-    description: `${f.status} (${f.language || "unknown"}) +${f.additions} -${f.deletions}`,
-    reason: "Uncategorized in M0 \u2014 placed in notable by default"
-  }));
-  return {
-    critical: [],
-    notable,
-    mechanical: []
-  };
+  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) => ({
@@ -584,15 +745,15 @@ var CONFIG_PATTERNS = [
   /vite\.config/,
   /vitest\.config/
 ];
-function isTestFile(path6) {
-  return TEST_PATTERNS.some((re) => re.test(path6));
+function isTestFile(path7) {
+  return TEST_PATTERNS.some((re) => re.test(path7));
 }
-function isNonCodeFile(path6) {
-  const ext = path6.slice(path6.lastIndexOf("."));
+function isNonCodeFile(path7) {
+  const ext = path7.slice(path7.lastIndexOf("."));
   return NON_CODE_EXTENSIONS.has(ext);
 }
-function isConfigFile(path6) {
-  return CONFIG_PATTERNS.some((re) => re.test(path6));
+function isConfigFile(path7) {
+  return CONFIG_PATTERNS.some((re) => re.test(path7));
 }
 function detectTestCoverageGaps(files) {
   const filePaths = new Set(files.map((f) => f.path));
@@ -764,20 +925,222 @@ function analyze(diffSet) {
   };
 }
 
+// packages/core/src/watch-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;
+}
+function watchFilePath(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  return path3.join(gitRoot, ".diffprism", "watch.json");
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeWatchFile(cwd, info) {
+  const filePath = watchFilePath(cwd);
+  const dir = path3.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(info, null, 2) + "\n");
+}
+function readWatchFile(cwd) {
+  const filePath = watchFilePath(cwd);
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const info = JSON.parse(raw);
+    if (!isPidAlive(info.pid)) {
+      fs.unlinkSync(filePath);
+      return null;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+function removeWatchFile(cwd) {
+  try {
+    const filePath = watchFilePath(cwd);
+    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 {
+    return null;
+  }
+}
+function consumeReviewResult(cwd) {
+  try {
+    const filePath = reviewResultPath(cwd);
+    if (!fs.existsSync(filePath)) {
+      return;
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    data.consumed = true;
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  } catch {
+  }
+}
+
 // packages/core/src/pipeline.ts
 import getPort from "get-port";
 import open from "open";
 
-// packages/core/src/ws-bridge.ts
+// packages/core/src/watch-bridge.ts
+import http from "http";
 import { WebSocketServer, WebSocket } from "ws";
-function createWsBridge(port) {
-  const wss2 = new WebSocketServer({ port });
+function createWatchBridge(port, callbacks) {
   let client = null;
-  let resultResolve = null;
-  let resultReject = null;
-  let pendingInit = 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");
+      }
+      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));
+    }
+  }
   wss2.on("connection", (ws) => {
     if (closeTimer) {
       clearTimeout(closeTimer);
@@ -786,20 +1149,16 @@ function createWsBridge(port) {
     client = ws;
     const payload = pendingInit ?? initPayload;
     if (payload) {
-      const msg = {
-        type: "review:init",
-        payload
-      };
-      ws.send(JSON.stringify(msg));
+      sendToClient({ type: "review:init", payload });
       pendingInit = null;
     }
     ws.on("message", (data) => {
       try {
         const msg = JSON.parse(data.toString());
-        if (msg.type === "review:submit" && resultResolve) {
-          resultResolve(msg.payload);
-          resultResolve = null;
-          resultReject = null;
+        if (msg.type === "review:submit" && submitCallback) {
+          submitCallback(msg.payload);
+        } else if (msg.type === "diff:change_ref" && callbacks.onDiffRefChange) {
+          callbacks.onDiffRefChange(msg.payload.diffRef);
         }
       } catch {
       }
@@ -808,56 +1167,184 @@ function createWsBridge(port) {
       client = null;
       if (resultReject) {
         closeTimer = setTimeout(() => {
+          closeTimer = null;
           if (resultReject) {
             resultReject(new Error("Browser closed before review was submitted"));
-            resultResolve = null;
             resultReject = null;
+            submitCallback = null;
           }
         }, 2e3);
+      } else {
+        closeTimer = setTimeout(() => {
+          closeTimer = null;
+        }, 2e3);
       }
     });
   });
-  return {
-    port,
-    sendInit(payload) {
-      initPayload = payload;
-      if (client && client.readyState === WebSocket.OPEN) {
-        const msg = {
-          type: "review:init",
-          payload
-        };
-        client.send(JSON.stringify(msg));
-      } else {
-        pendingInit = payload;
-      }
-    },
-    waitForResult() {
-      return new Promise((resolve, reject) => {
-        resultResolve = resolve;
-        resultReject = reject;
-      });
-    },
-    close() {
-      for (const ws of wss2.clients) {
-        ws.close();
-      }
-      wss2.close();
-    }
-  };
-}
-
-// 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 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());
+          });
+        }
+      });
+    });
+  });
+}
+
+// packages/core/src/diff-utils.ts
+import { createHash } from "crypto";
+function hashDiff(rawDiff) {
+  return createHash("sha256").update(rawDiff).digest("hex");
+}
+function fileKey(file) {
+  return file.stage ? `${file.stage}:${file.path}` : file.path;
+}
+function detectChangedFiles(oldDiffSet, newDiffSet) {
+  if (!oldDiffSet) {
+    return newDiffSet.files.map(fileKey);
+  }
+  const oldFiles = new Map(
+    oldDiffSet.files.map((f) => [fileKey(f), f])
+  );
+  const changed = [];
+  for (const newFile of newDiffSet.files) {
+    const key = fileKey(newFile);
+    const oldFile = oldFiles.get(key);
+    if (!oldFile) {
+      changed.push(key);
+    } else if (oldFile.additions !== newFile.additions || oldFile.deletions !== newFile.deletions) {
+      changed.push(key);
+    }
+  }
+  for (const oldFile of oldDiffSet.files) {
+    if (!newDiffSet.files.some((f) => fileKey(f) === fileKey(oldFile))) {
+      changed.push(fileKey(oldFile));
+    }
+  }
+  return changed;
+}
+
+// packages/core/src/diff-poller.ts
+function createDiffPoller(options) {
+  let { diffRef } = options;
+  const { cwd, pollInterval, onDiffChanged, onError, silent } = options;
+  let lastDiffHash = null;
+  let lastDiffSet = null;
+  let refreshRequested = false;
+  let interval = null;
+  let running = false;
+  function poll() {
+    if (!running) return;
+    try {
+      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(diffRef, { cwd });
+      const newHash = hashDiff(newRawDiff);
+      if (newHash !== lastDiffHash || refreshRequested) {
+        refreshRequested = false;
+        const newBriefing = analyze(newDiffSet);
+        const changedFiles = detectChangedFiles(lastDiffSet, newDiffSet);
+        lastDiffHash = newHash;
+        lastDiffSet = newDiffSet;
+        const updatePayload = {
+          diffSet: newDiffSet,
+          rawDiff: newRawDiff,
+          briefing: newBriefing,
+          changedFiles,
+          timestamp: Date.now()
+        };
+        onDiffChanged(updatePayload);
+      }
+    } catch (err) {
+      if (onError && err instanceof Error) {
+        onError(err);
+      }
+    }
+  }
+  return {
+    start() {
+      if (running) return;
+      running = true;
+      try {
+        const { diffSet: initialDiffSet, rawDiff: initialRawDiff } = getDiff(diffRef, { cwd });
+        lastDiffHash = hashDiff(initialRawDiff);
+        lastDiffSet = initialDiffSet;
+      } catch {
+      }
+      interval = setInterval(poll, pollInterval);
+    },
+    stop() {
+      running = false;
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+    },
+    setDiffRef(newRef) {
+      diffRef = newRef;
+      lastDiffHash = null;
+      lastDiffSet = null;
+    },
+    refresh() {
+      refreshRequested = true;
+    }
+  };
+}
+
+// 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) {
@@ -868,9 +1355,9 @@ function updateSession(id, update) {
 }
 
 // packages/core/src/ui-server.ts
-import http from "http";
-import fs from "fs";
-import path3 from "path";
+import http2 from "http";
+import fs2 from "fs";
+import path4 from "path";
 import { fileURLToPath } from "url";
 var MIME_TYPES = {
   ".html": "text/html",
@@ -885,14 +1372,14 @@ var MIME_TYPES = {
 };
 function resolveUiDist() {
   const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = path3.dirname(thisFile);
-  const publishedUiDist = path3.resolve(thisDir, "..", "ui-dist");
-  if (fs.existsSync(path3.join(publishedUiDist, "index.html"))) {
+  const thisDir = path4.dirname(thisFile);
+  const publishedUiDist = path4.resolve(thisDir, "..", "ui-dist");
+  if (fs2.existsSync(path4.join(publishedUiDist, "index.html"))) {
     return publishedUiDist;
   }
-  const workspaceRoot = path3.resolve(thisDir, "..", "..", "..");
-  const devUiDist = path3.join(workspaceRoot, "packages", "ui", "dist");
-  if (fs.existsSync(path3.join(devUiDist, "index.html"))) {
+  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
+  const devUiDist = path4.join(workspaceRoot, "packages", "ui", "dist");
+  if (fs2.existsSync(path4.join(devUiDist, "index.html"))) {
     return devUiDist;
   }
   throw new Error(
@@ -901,10 +1388,10 @@ function resolveUiDist() {
 }
 function resolveUiRoot() {
   const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = path3.dirname(thisFile);
-  const workspaceRoot = path3.resolve(thisDir, "..", "..", "..");
-  const uiRoot = path3.join(workspaceRoot, "packages", "ui");
-  if (fs.existsSync(path3.join(uiRoot, "index.html"))) {
+  const thisDir = path4.dirname(thisFile);
+  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
+  const uiRoot = path4.join(workspaceRoot, "packages", "ui");
+  if (fs2.existsSync(path4.join(uiRoot, "index.html"))) {
     return uiRoot;
   }
   throw new Error(
@@ -922,16 +1409,16 @@ async function startViteDevServer(uiRoot, port, silent) {
   return vite;
 }
 function createStaticServer(distPath, port) {
-  const server = http.createServer((req, res) => {
+  const server = http2.createServer((req, res) => {
     const urlPath = req.url?.split("?")[0] ?? "/";
-    let filePath = path3.join(distPath, urlPath === "/" ? "index.html" : urlPath);
-    if (!fs.existsSync(filePath)) {
-      filePath = path3.join(distPath, "index.html");
+    let filePath = path4.join(distPath, urlPath === "/" ? "index.html" : urlPath);
+    if (!fs2.existsSync(filePath)) {
+      filePath = path4.join(distPath, "index.html");
     }
-    const ext = path3.extname(filePath);
+    const ext = path4.extname(filePath);
     const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
     try {
-      const content = fs.readFileSync(filePath);
+      const content = fs2.readFileSync(filePath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch {
@@ -963,392 +1450,228 @@ async function startReview(options) {
   const briefing = analyze(diffSet);
   const session = createSession(options);
   updateSession(session.id, { status: "in_progress" });
-  const [wsPort, httpPort] = await Promise.all([
+  const worktreeInfo = detectWorktree({ cwd });
+  const metadata = {
+    title,
+    description,
+    reasoning,
+    currentBranch,
+    worktree: worktreeInfo.isWorktree ? {
+      isWorktree: true,
+      worktreePath: worktreeInfo.worktreePath,
+      mainWorktreePath: worktreeInfo.mainWorktreePath
+    } : void 0
+  };
+  let poller = null;
+  const [bridgePort, httpPort] = await Promise.all([
     getPort(),
     getPort()
   ]);
-  const bridge = createWsBridge(wsPort);
-  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);
-    }
-    const url = `http://localhost:${httpPort}?wsPort=${wsPort}&reviewId=${session.id}`;
-    if (!silent) {
-      console.log(`
-DiffPrism Review: ${title ?? briefing.summary}`);
-      console.log(`Opening browser at ${url}
-`);
-    }
-    await open(url);
-    const initPayload = {
+  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: session.id,
-      diffSet,
-      rawDiff,
-      briefing,
-      metadata: { title, description, reasoning, currentBranch }
-    };
-    bridge.sendInit(initPayload);
-    const result = await bridge.waitForResult();
-    updateSession(session.id, { status: "completed", result });
-    return result;
-  } finally {
-    bridge.close();
-    if (viteServer) {
-      await viteServer.close();
-    }
-    if (httpServer) {
-      httpServer.close();
-    }
-  }
-}
-
-// packages/core/src/watch-file.ts
-import fs2 from "fs";
-import path4 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;
-}
-function watchFilePath(cwd) {
-  const gitRoot = findGitRoot(cwd);
-  return path4.join(gitRoot, ".diffprism", "watch.json");
-}
-function isPidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function writeWatchFile(cwd, info) {
-  const filePath = watchFilePath(cwd);
-  const dir = path4.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  fs2.writeFileSync(filePath, JSON.stringify(info, null, 2) + "\n");
-}
-function readWatchFile(cwd) {
-  const filePath = watchFilePath(cwd);
-  if (!fs2.existsSync(filePath)) {
-    return null;
-  }
-  try {
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const info = JSON.parse(raw);
-    if (!isPidAlive(info.pid)) {
-      fs2.unlinkSync(filePath);
-      return null;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function removeWatchFile(cwd) {
-  try {
-    const filePath = watchFilePath(cwd);
-    if (fs2.existsSync(filePath)) {
-      fs2.unlinkSync(filePath);
-    }
-  } catch {
-  }
-}
-function reviewResultPath(cwd) {
-  const gitRoot = findGitRoot(cwd);
-  return path4.join(gitRoot, ".diffprism", "last-review.json");
-}
-function writeReviewResult(cwd, result) {
-  const filePath = reviewResultPath(cwd);
-  const dir = path4.dirname(filePath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-  const data = {
-    result,
-    timestamp: Date.now(),
-    consumed: false
-  };
-  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-}
-function readReviewResult(cwd) {
-  try {
-    const filePath = reviewResultPath(cwd);
-    if (!fs2.existsSync(filePath)) {
-      return null;
-    }
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(raw);
-    if (data.consumed) {
-      return null;
-    }
-    return data;
-  } catch {
-    return null;
-  }
-}
-function consumeReviewResult(cwd) {
-  try {
-    const filePath = reviewResultPath(cwd);
-    if (!fs2.existsSync(filePath)) {
-      return;
-    }
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const data = JSON.parse(raw);
-    data.consumed = true;
-    fs2.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
-  } catch {
-  }
-}
-
-// packages/core/src/server-file.ts
-import fs3 from "fs";
-import path5 from "path";
-import os from "os";
-function serverDir() {
-  return path5.join(os.homedir(), ".diffprism");
-}
-function serverFilePath() {
-  return path5.join(serverDir(), "server.json");
-}
-function isPidAlive2(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function writeServerFile(info) {
-  const dir = serverDir();
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
-  }
-  fs3.writeFileSync(serverFilePath(), JSON.stringify(info, null, 2) + "\n");
-}
-function readServerFile() {
-  const filePath = serverFilePath();
-  if (!fs3.existsSync(filePath)) {
-    return null;
-  }
-  try {
-    const raw = fs3.readFileSync(filePath, "utf-8");
-    const info = JSON.parse(raw);
-    if (!isPidAlive2(info.pid)) {
-      fs3.unlinkSync(filePath);
-      return null;
-    }
-    return info;
-  } catch {
-    return null;
-  }
-}
-function removeServerFile() {
-  try {
-    const filePath = serverFilePath();
-    if (fs3.existsSync(filePath)) {
-      fs3.unlinkSync(filePath);
-    }
-  } catch {
-  }
-}
-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)
+      diffSet: newDiffSet,
+      rawDiff: newRawDiff,
+      briefing: newBriefing,
+      metadata,
+      watchMode: true
     });
-    if (response.ok) {
-      return info;
-    }
-    return null;
-  } catch {
-    removeServerFile();
-    return null;
-  }
-}
-
-// packages/core/src/watch.ts
-import getPort2 from "get-port";
-import open2 from "open";
-
-// packages/core/src/watch-bridge.ts
-import http2 from "http";
-import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket2 } from "ws";
-function createWatchBridge(port, callbacks) {
-  let client = null;
-  let initPayload = null;
-  let pendingInit = null;
-  let closeTimer = null;
-  let submitCallback = null;
-  const httpServer = http2.createServer((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;
-    }
-    res.writeHead(404);
-    res.end("Not found");
-  });
-  const wss2 = new WebSocketServer2({ server: httpServer });
-  function sendToClient(msg) {
-    if (client && client.readyState === WebSocket2.OPEN) {
-      client.send(JSON.stringify(msg));
-    }
+    poller?.setDiffRef(newRef);
   }
-  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) => {
+  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 {
-        const msg = JSON.parse(data.toString());
-        if (msg.type === "review:submit" && submitCallback) {
-          submitCallback(msg.payload);
-        }
-      } catch {
+        handleDiffRefChange(newRef);
+      } catch (err) {
+        bridge.sendDiffError({
+          error: err instanceof Error ? err.message : String(err)
+        });
       }
-    });
-    ws.on("close", () => {
-      client = null;
-      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 === WebSocket2.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 });
-        },
-        onSubmit(callback) {
-          submitCallback = callback;
-        },
-        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());
-          });
+    },
+    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;
+  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: true
+    };
+    bridge.sendInit(initPayload);
+    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 });
+    return result;
+  } finally {
+    poller?.stop();
+    await bridge.close();
+    removeWatchFile(cwd);
+    if (viteServer) {
+      await viteServer.close();
+    }
+    if (httpServer) {
+      httpServer.close();
+    }
+  }
 }
 
-// packages/core/src/diff-utils.ts
-import { createHash } from "crypto";
-function hashDiff(rawDiff) {
-  return createHash("sha256").update(rawDiff).digest("hex");
+// packages/core/src/server-file.ts
+import fs3 from "fs";
+import path5 from "path";
+import os from "os";
+function serverDir() {
+  return path5.join(os.homedir(), ".diffprism");
 }
-function fileKey(file) {
-  return file.stage ? `${file.stage}:${file.path}` : file.path;
+function serverFilePath() {
+  return path5.join(serverDir(), "server.json");
 }
-function detectChangedFiles(oldDiffSet, newDiffSet) {
-  if (!oldDiffSet) {
-    return newDiffSet.files.map(fileKey);
+function isPidAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
   }
-  const oldFiles = new Map(
-    oldDiffSet.files.map((f) => [fileKey(f), f])
-  );
-  const changed = [];
-  for (const newFile of newDiffSet.files) {
-    const key = fileKey(newFile);
-    const oldFile = oldFiles.get(key);
-    if (!oldFile) {
-      changed.push(key);
-    } else if (oldFile.additions !== newFile.additions || oldFile.deletions !== newFile.deletions) {
-      changed.push(key);
+}
+function writeServerFile(info) {
+  const dir = serverDir();
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(serverFilePath(), JSON.stringify(info, null, 2) + "\n");
+}
+function readServerFile() {
+  const filePath = serverFilePath();
+  if (!fs3.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const info = JSON.parse(raw);
+    if (!isPidAlive2(info.pid)) {
+      fs3.unlinkSync(filePath);
+      return null;
     }
+    return info;
+  } catch {
+    return null;
   }
-  for (const oldFile of oldDiffSet.files) {
-    if (!newDiffSet.files.some((f) => fileKey(f) === fileKey(oldFile))) {
-      changed.push(fileKey(oldFile));
+}
+function removeServerFile() {
+  try {
+    const filePath = serverFilePath();
+    if (fs3.existsSync(filePath)) {
+      fs3.unlinkSync(filePath);
     }
+  } catch {
+  }
+}
+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;
   }
-  return changed;
 }
 
 // packages/core/src/watch.ts
+import getPort2 from "get-port";
+import open2 from "open";
 async function startWatch(options) {
   const {
     diffRef,
@@ -1363,8 +1686,6 @@ async function startWatch(options) {
   const { diffSet: initialDiffSet, rawDiff: initialRawDiff } = getDiff(diffRef, { cwd });
   const currentBranch = getCurrentBranch({ cwd });
   const initialBriefing = analyze(initialDiffSet);
-  let lastDiffHash = hashDiff(initialRawDiff);
-  let lastDiffSet = initialDiffSet;
   const metadata = {
     title,
     description,
@@ -1375,15 +1696,63 @@ async function startWatch(options) {
     getPort2(),
     getPort2()
   ]);
-  let refreshRequested = false;
+  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: () => {
-      refreshRequested = true;
+      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;
@@ -1403,8 +1772,7 @@ async function startWatch(options) {
     diffRef,
     startedAt: Date.now()
   });
-  const reviewId = "watch-session";
-  const url = `http://localhost:${uiPort}?wsPort=${bridgePort}&reviewId=${reviewId}`;
+  const url = `http://localhost:${uiPort}?wsPort=${bridgePort}&httpPort=${bridgePort}&reviewId=${reviewId}`;
   if (!silent) {
     console.log(`
 DiffPrism Watch: ${title ?? `watching ${diffRef}`}`);
@@ -1434,46 +1802,30 @@ Review submitted: ${result.decision}`);
     }
     writeReviewResult(cwd, result);
   });
-  let pollRunning = true;
-  const pollLoop = setInterval(() => {
-    if (!pollRunning) return;
-    try {
-      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(diffRef, { cwd });
-      const newHash = hashDiff(newRawDiff);
-      if (newHash !== lastDiffHash || refreshRequested) {
-        refreshRequested = false;
-        const newBriefing = analyze(newDiffSet);
-        const changedFiles = detectChangedFiles(lastDiffSet, newDiffSet);
-        lastDiffHash = newHash;
-        lastDiffSet = newDiffSet;
-        bridge.storeInitPayload({
-          reviewId,
-          diffSet: newDiffSet,
-          rawDiff: newRawDiff,
-          briefing: newBriefing,
-          metadata,
-          watchMode: true
-        });
-        const updatePayload = {
-          diffSet: newDiffSet,
-          rawDiff: newRawDiff,
-          briefing: newBriefing,
-          changedFiles,
-          timestamp: Date.now()
-        };
-        bridge.sendDiffUpdate(updatePayload);
-        if (!silent && changedFiles.length > 0) {
-          console.log(
-            `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] Diff updated: ${changedFiles.length} file(s) changed`
-          );
-        }
+  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`
+        );
       }
-    } catch {
     }
-  }, pollInterval);
+  });
+  poller.start();
   async function stop() {
-    pollRunning = false;
-    clearInterval(pollLoop);
+    poller.stop();
     await bridge.close();
     if (viteServer) {
       await viteServer.close();
@@ -1497,7 +1849,7 @@ import http3 from "http";
 import { randomUUID } from "crypto";
 import getPort3 from "get-port";
 import open3 from "open";
-import { WebSocketServer as WebSocketServer3, WebSocket as WebSocket3 } from "ws";
+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;
@@ -1563,7 +1915,7 @@ function broadcastToAll(msg) {
   if (!wss) return;
   const data = JSON.stringify(msg);
   for (const client of wss.clients) {
-    if (client.readyState === WebSocket3.OPEN) {
+    if (client.readyState === WebSocket2.OPEN) {
       client.send(data);
     }
   }
@@ -1572,7 +1924,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 === WebSocket3.OPEN) {
+    if (sid === sessionId && client.readyState === WebSocket2.OPEN) {
       client.send(data);
     }
   }
@@ -1596,7 +1948,7 @@ function broadcastSessionRemoved(sessionId) {
 }
 function hasViewersForSession(sessionId) {
   for (const [client, sid] of clientSessions.entries()) {
-    if (sid === sessionId && client.readyState === WebSocket3.OPEN) {
+    if (sid === sessionId && client.readyState === WebSocket2.OPEN) {
       return true;
     }
   }
@@ -1606,54 +1958,40 @@ function startSessionWatcher(sessionId) {
   if (sessionWatchers.has(sessionId)) return;
   const session = sessions2.get(sessionId);
   if (!session?.diffRef) return;
-  const interval = setInterval(() => {
-    const s = sessions2.get(sessionId);
-    if (!s?.diffRef) {
-      stopSessionWatcher(sessionId);
-      return;
-    }
-    try {
-      const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(s.diffRef, {
-        cwd: s.projectPath
-      });
-      const newHash = hashDiff(newRawDiff);
-      if (newHash !== s.lastDiffHash) {
-        const newBriefing = analyze(newDiffSet);
-        const changedFiles = detectChangedFiles(s.lastDiffSet ?? null, newDiffSet);
-        s.payload = {
-          ...s.payload,
-          diffSet: newDiffSet,
-          rawDiff: newRawDiff,
-          briefing: newBriefing
-        };
-        s.lastDiffHash = newHash;
-        s.lastDiffSet = newDiffSet;
-        if (hasViewersForSession(sessionId)) {
-          sendToSessionClients(sessionId, {
-            type: "diff:update",
-            payload: {
-              diffSet: newDiffSet,
-              rawDiff: newRawDiff,
-              briefing: newBriefing,
-              changedFiles,
-              timestamp: Date.now()
-            }
-          });
-          s.hasNewChanges = false;
-        } else {
-          s.hasNewChanges = true;
-          broadcastSessionList();
-        }
+  const poller = createDiffPoller({
+    diffRef: session.diffRef,
+    cwd: session.projectPath,
+    pollInterval: serverPollInterval,
+    onDiffChanged: (updatePayload) => {
+      const s = sessions2.get(sessionId);
+      if (!s) return;
+      s.payload = {
+        ...s.payload,
+        diffSet: updatePayload.diffSet,
+        rawDiff: updatePayload.rawDiff,
+        briefing: updatePayload.briefing
+      };
+      s.lastDiffHash = hashDiff(updatePayload.rawDiff);
+      s.lastDiffSet = updatePayload.diffSet;
+      if (hasViewersForSession(sessionId)) {
+        sendToSessionClients(sessionId, {
+          type: "diff:update",
+          payload: updatePayload
+        });
+        s.hasNewChanges = false;
+      } else {
+        s.hasNewChanges = true;
+        broadcastSessionList();
       }
-    } catch {
     }
-  }, serverPollInterval);
-  sessionWatchers.set(sessionId, interval);
+  });
+  poller.start();
+  sessionWatchers.set(sessionId, poller);
 }
 function stopSessionWatcher(sessionId) {
-  const interval = sessionWatchers.get(sessionId);
-  if (interval) {
-    clearInterval(interval);
+  const poller = sessionWatchers.get(sessionId);
+  if (poller) {
+    poller.stop();
     sessionWatchers.delete(sessionId);
   }
 }
@@ -1665,15 +2003,15 @@ function startAllWatchers() {
   }
 }
 function stopAllWatchers() {
-  for (const [id, interval] of sessionWatchers.entries()) {
-    clearInterval(interval);
+  for (const [, poller] of sessionWatchers.entries()) {
+    poller.stop();
   }
   sessionWatchers.clear();
 }
 function hasConnectedClients() {
   if (!wss) return false;
   for (const client of wss.clients) {
-    if (client.readyState === WebSocket3.OPEN) return true;
+    if (client.readyState === WebSocket2.OPEN) return true;
   }
   return false;
 }
@@ -1730,6 +2068,7 @@ async function handleApiRequest(req, res) {
         existingSession.lastDiffHash = diffRef ? hashDiff(payload.rawDiff) : void 0;
         existingSession.lastDiffSet = diffRef ? payload.diffSet : void 0;
         existingSession.hasNewChanges = false;
+        existingSession.annotations = [];
         if (diffRef && hasConnectedClients()) {
           startSessionWatcher(sessionId);
         }
@@ -1758,7 +2097,8 @@ async function handleApiRequest(req, res) {
           diffRef,
           lastDiffHash: diffRef ? hashDiff(payload.rawDiff) : void 0,
           lastDiffSet: diffRef ? payload.diffSet : void 0,
-          hasNewChanges: false
+          hasNewChanges: false,
+          annotations: []
         };
         sessions2.set(sessionId, session);
         if (diffRef && hasConnectedClients()) {
@@ -1857,6 +2197,65 @@ async function handleApiRequest(req, res) {
     }
     return true;
   }
+  const postAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations");
+  if (postAnnotationParams) {
+    const session = sessions2.get(postAnnotationParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    try {
+      const body = await readBody(req);
+      const { file, line, body: annotationBody, type, confidence, category, source } = JSON.parse(body);
+      const annotation = {
+        id: randomUUID(),
+        sessionId: session.id,
+        file,
+        line,
+        body: annotationBody,
+        type,
+        confidence: confidence ?? 1,
+        category: category ?? "other",
+        source,
+        createdAt: Date.now()
+      };
+      session.annotations.push(annotation);
+      sendToSessionClients(session.id, {
+        type: "annotation:added",
+        payload: annotation
+      });
+      jsonResponse(res, 200, { annotationId: annotation.id });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const getAnnotationsParams = matchRoute(method, url, "GET", "/api/reviews/:id/annotations");
+  if (getAnnotationsParams) {
+    const session = sessions2.get(getAnnotationsParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    jsonResponse(res, 200, { annotations: session.annotations });
+    return true;
+  }
+  const dismissAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations/:annotationId/dismiss");
+  if (dismissAnnotationParams) {
+    const session = sessions2.get(dismissAnnotationParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    const annotation = session.annotations.find((a) => a.id === dismissAnnotationParams.annotationId);
+    if (!annotation) {
+      jsonResponse(res, 404, { error: "Annotation not found" });
+      return true;
+    }
+    annotation.dismissed = true;
+    jsonResponse(res, 200, { ok: true });
+    return true;
+  }
   const deleteParams = matchRoute(method, url, "DELETE", "/api/reviews/:id");
   if (deleteParams) {
     stopSessionWatcher(deleteParams.id);
@@ -1968,7 +2367,7 @@ async function startGlobalServer(options = {}) {
       res.end("Not found");
     }
   });
-  wss = new WebSocketServer3({ port: wsPort });
+  wss = new WebSocketServer2({ port: wsPort });
   wss.on("connection", (ws, req) => {
     startAllWatchers();
     const url = new URL(req.url ?? "/", `http://localhost:${wsPort}`);
@@ -2046,6 +2445,49 @@ async function startGlobalServer(options = {}) {
             closedSession.status = "submitted";
           }
           broadcastSessionRemoved(closedId);
+        } else if (msg.type === "diff:change_ref") {
+          const sid = clientSessions.get(ws);
+          if (sid) {
+            const session = sessions2.get(sid);
+            if (session) {
+              const newRef = msg.payload.diffRef;
+              try {
+                const { diffSet: newDiffSet, rawDiff: newRawDiff } = getDiff(newRef, {
+                  cwd: session.projectPath
+                });
+                const newBriefing = analyze(newDiffSet);
+                session.payload = {
+                  ...session.payload,
+                  diffSet: newDiffSet,
+                  rawDiff: newRawDiff,
+                  briefing: newBriefing
+                };
+                session.diffRef = newRef;
+                session.lastDiffHash = hashDiff(newRawDiff);
+                session.lastDiffSet = newDiffSet;
+                stopSessionWatcher(sid);
+                startSessionWatcher(sid);
+                sendToSessionClients(sid, {
+                  type: "diff:update",
+                  payload: {
+                    diffSet: newDiffSet,
+                    rawDiff: newRawDiff,
+                    briefing: newBriefing,
+                    changedFiles: newDiffSet.files.map((f) => f.path),
+                    timestamp: Date.now()
+                  }
+                });
+              } catch (err) {
+                const errorMsg = {
+                  type: "diff:error",
+                  payload: {
+                    error: err instanceof Error ? err.message : String(err)
+                  }
+                };
+                ws.send(JSON.stringify(errorMsg));
+              }
+            }
+          }
         }
       } catch {
       }
@@ -2126,14 +2568,20 @@ Waiting for reviews...
   return { httpPort, wsPort, stop };
 }
 
+// packages/core/src/review-history.ts
+import fs4 from "fs";
+import path6 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+
 export {
   getCurrentBranch,
+  detectWorktree,
   getDiff,
   analyze,
-  startReview,
   readWatchFile,
   readReviewResult,
   consumeReviewResult,
+  startReview,
   startWatch,
   readServerFile,
   isServerAlive,