diffprism 0.48.2 → 1.0.0

package/dist/{chunk-EPUCA2N5.js → chunk-CU2BAL6Q.js}

@@ -1,9 +1,10 @@
 import {
   getCurrentBranch,
   getDiff,
+  getRepoRoot,
   listBranches,
   listCommits
-} from "./chunk-QGWYCEJN.js";
+} from "./chunk-3GMPE2ZR.js";
 import {
   analyze
 } from "./chunk-DHCVZGHE.js";
@@ -78,24 +79,162 @@ async function isServerAlive() {
   }
 }
 
-// packages/core/src/server-client.ts
-import { spawn } from "child_process";
+// packages/core/src/diff-scope.ts
+var DEFAULT_DIFF_REF = "working-copy";
+var COMMIT_GATE_DIFF_REF = "staged";
+var DIFF_REF_DESCRIPTION = 'Which changes to review. "working-copy" (the default): everything not yet committed, staged and unstaged shown as separate groups. "staged": only what the next commit would contain. "unstaged": only edits not yet staged. Or a ref range such as "HEAD~3..HEAD" or "main..feature".';
+
+// packages/core/src/build-info.ts
 import fs2 from "fs";
 import path2 from "path";
-import os2 from "os";
 import { fileURLToPath } from "url";
+function getBuildInfo() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  while (dir !== path2.dirname(dir)) {
+    const manifest = path2.join(dir, "package.json");
+    if (fs2.existsSync(manifest) && isOwnManifest(manifest)) {
+      return fs2.existsSync(path2.join(dir, ".git")) ? { dev: true, root: dir } : { dev: false, root: null };
+    }
+    dir = path2.dirname(dir);
+  }
+  return { dev: false, root: null };
+}
+function isOwnManifest(manifestPath) {
+  try {
+    const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+    return manifest.name === "diffprism";
+  } catch {
+    return false;
+  }
+}
+function describeVersion(version) {
+  const info = getBuildInfo();
+  return info.dev ? `${version} (dev build \u2014 ${info.root})` : version;
+}
+
+// packages/core/src/feedback.ts
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
+var ISSUES_NEW_URL = "https://github.com/CodeJonesW/diffprism/issues/new";
+var MAX_ERROR_CHARS = 1500;
+function currentVersion() {
+  return true ? "1.0.0" : "0.0.0-dev";
+}
+function describeEnvironment() {
+  return {
+    version: currentVersion(),
+    // Whether it is a dev build, but not where: the checkout path is private.
+    build: getBuildInfo().dev ? "dev build" : "release",
+    os: `${os2.type()} ${os2.release()} (${os2.arch()})`,
+    node: process.version
+  };
+}
+function lastErrorFile() {
+  return path3.join(os2.homedir(), ".diffprism", "last-error.json");
+}
+function recordError(command, err) {
+  const report = {
+    command,
+    message: err instanceof Error ? err.message : String(err),
+    at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    fs3.mkdirSync(path3.dirname(lastErrorFile()), { recursive: true });
+    fs3.writeFileSync(lastErrorFile(), JSON.stringify(report, null, 2));
+  } catch {
+  }
+}
+function readLastError() {
+  try {
+    return JSON.parse(fs3.readFileSync(lastErrorFile(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+var REPORT_HINT = "Think this is a DiffPrism bug? Report it: diffprism feedback --bug";
+function redactHome(text) {
+  const home = os2.homedir();
+  return home ? text.split(home).join("~") : text;
+}
+function buildFeedbackUrl(options) {
+  const env = options.environment ?? describeEnvironment();
+  const message = options.message?.trim();
+  const error = options.kind === "bug" ? options.error : null;
+  const firstLine = (text) => text.split("\n")[0].slice(0, 80);
+  const title = options.kind === "bug" ? `Bug: ${firstLine(message || (error ? redactHome(error.message) : "")) || "describe the problem"}` : `Feedback: ${message ? firstLine(message) : "your idea or experience"}`;
+  const sections = [];
+  if (options.kind === "bug") {
+    sections.push(`### What happened
+
+${message || "<!-- What were you doing, and what went wrong? -->"}`);
+    sections.push("### What you expected\n\n<!-- What should have happened instead? -->");
+  } else {
+    sections.push(`### Feedback
+
+${message || "<!-- What's working, what isn't, what you wish it did. -->"}`);
+  }
+  if (error) {
+    let errorText = redactHome(error.message);
+    if (errorText.length > MAX_ERROR_CHARS) {
+      errorText = `${errorText.slice(0, MAX_ERROR_CHARS)}
+\u2026 (truncated)`;
+    }
+    sections.push(`### Last error
+
+\`diffprism ${error.command}\` at ${error.at}
+
+\`\`\`
+${errorText}
+\`\`\``);
+  }
+  sections.push(
+    [
+      "### Environment",
+      "",
+      "| | |",
+      "|---|---|",
+      `| DiffPrism | ${env.version} (${env.build}) |`,
+      `| OS | ${env.os} |`,
+      `| Node | ${env.node} |`
+    ].join("\n")
+  );
+  sections.push("<!-- Everything above is visible before you submit. Remove anything you don't want to share publicly. -->");
+  const params = new URLSearchParams({
+    title,
+    body: sections.join("\n\n"),
+    labels: options.kind === "bug" ? "bug" : "feedback"
+  });
+  return `${ISSUES_NEW_URL}?${params.toString()}`;
+}
+
+// packages/core/src/threads.ts
+function lastAuthor(annotation) {
+  const replies = annotation.replies ?? [];
+  return replies.length > 0 ? replies[replies.length - 1].author : annotation.author ?? "agent";
+}
+function awaitingAgent(annotation) {
+  return !annotation.dismissed && lastAuthor(annotation) === "reviewer";
+}
+
+// packages/core/src/server-client.ts
+import { spawn } from "child_process";
+import fs4 from "fs";
+import path4 from "path";
+import os3 from "os";
+import { fileURLToPath as fileURLToPath2 } 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 logDir = path4.join(os3.homedir(), ".diffprism");
+  if (!fs4.existsSync(logDir)) {
+    fs4.mkdirSync(logDir, { recursive: true });
   }
-  const logPath = path2.join(logDir, "server.log");
-  const logFd = fs2.openSync(logPath, "a");
+  const logPath = path4.join(logDir, "server.log");
+  const logFd = fs4.openSync(logPath, "a");
   const [cmd, ...args] = spawnArgs;
   const child = spawn(cmd, args, {
     detached: true,
@@ -103,7 +242,7 @@ async function ensureServer(options = {}) {
     env: { ...process.env }
   });
   child.unref();
-  fs2.closeSync(logFd);
+  fs4.closeSync(logFd);
   const timeoutMs = options.timeoutMs ?? 15e3;
   const startTime = Date.now();
   while (Date.now() - startTime < timeoutMs) {
@@ -118,15 +257,15 @@ async function ensureServer(options = {}) {
   );
 }
 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");
-  if (fs2.existsSync(devBin)) {
+  const thisFile = fileURLToPath2(import.meta.url);
+  const thisDir = path4.dirname(thisFile);
+  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
+  const devBin = path4.join(workspaceRoot, "cli", "bin", "diffprism.mjs");
+  if (fs4.existsSync(devBin)) {
     return withDevFlag([process.execPath, devBin, "server", "--_daemon"], options);
   }
   let searchDir = thisDir;
-  while (searchDir !== path2.dirname(searchDir)) {
+  while (searchDir !== path4.dirname(searchDir)) {
     const ownBin = readOwnBinPath(searchDir);
     if (ownBin) {
       return withDevFlag(
@@ -134,11 +273,11 @@ function buildDefaultSpawnCommand(options) {
         options
       );
     }
-    const shim = path2.join(searchDir, "node_modules", ".bin", "diffprism");
-    if (fs2.existsSync(shim)) {
+    const shim = path4.join(searchDir, "node_modules", ".bin", "diffprism");
+    if (fs4.existsSync(shim)) {
       return withDevFlag([shim, "server", "--_daemon"], options);
     }
-    searchDir = path2.dirname(searchDir);
+    searchDir = path4.dirname(searchDir);
   }
   return withDevFlag(["diffprism", "server", "--_daemon"], options);
 }
@@ -146,22 +285,71 @@ function withDevFlag(args, options) {
   return options.dev ? [...args, "--dev"] : args;
 }
 function readOwnBinPath(dir) {
-  const manifestPath = path2.join(dir, "package.json");
-  if (!fs2.existsSync(manifestPath)) {
+  const manifestPath = path4.join(dir, "package.json");
+  if (!fs4.existsSync(manifestPath)) {
     return null;
   }
   try {
-    const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+    const manifest = JSON.parse(fs4.readFileSync(manifestPath, "utf8"));
     const entry = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.diffprism;
     if (!entry) {
       return null;
     }
-    const resolved = path2.resolve(dir, entry);
-    return fs2.existsSync(resolved) ? resolved : null;
+    const resolved = path4.resolve(dir, entry);
+    return fs4.existsSync(resolved) ? resolved : null;
   } catch {
     return null;
   }
 }
+var ReviewTimeoutError = class extends Error {
+  sessionId;
+  waitedMs;
+  constructor(sessionId, waitedMs) {
+    super(
+      `Review ${sessionId} is still open after ${Math.round(waitedMs / 1e3)}s without a decision.`
+    );
+    this.name = "ReviewTimeoutError";
+    this.sessionId = sessionId;
+    this.waitedMs = waitedMs;
+  }
+};
+var ReviewerAskedError = class extends Error {
+  sessionId;
+  threads;
+  constructor(sessionId, threads) {
+    super(
+      `The reviewer asked ${threads.length} question${threads.length === 1 ? "" : "s"} on review ${sessionId} before deciding.`
+    );
+    this.name = "ReviewerAskedError";
+    this.sessionId = sessionId;
+    this.threads = threads;
+  }
+};
+async function waitForDecision(serverInfo, sessionId, maxWaitMs, pollIntervalMs = 2e3) {
+  const base = `http://localhost:${serverInfo.httpPort}/api/reviews/${sessionId}`;
+  const start = Date.now();
+  while (Date.now() - start < maxWaitMs) {
+    const resultResponse = await fetch(`${base}/result`);
+    if (!resultResponse.ok) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const { result } = await resultResponse.json();
+    if (result) {
+      return result;
+    }
+    const annotationsResponse = await fetch(`${base}/annotations`);
+    if (!annotationsResponse.ok) {
+      throw new Error(`Could not read threads for ${sessionId}: server returned ${annotationsResponse.status}`);
+    }
+    const { annotations } = await annotationsResponse.json();
+    const asked = annotations.filter(awaitingAgent);
+    if (asked.length > 0) {
+      throw new ReviewerAskedError(sessionId, asked);
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+  throw new ReviewTimeoutError(sessionId, maxWaitMs);
+}
 async function submitReviewToServer(serverInfo, diffRef, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const projectPath = options.projectPath ?? cwd;
@@ -169,7 +357,7 @@ async function submitReviewToServer(serverInfo, diffRef, options = {}) {
   if (options.injectedPayload) {
     payload = options.injectedPayload;
   } else {
-    const { getDiff: getDiff2, getCurrentBranch: getCurrentBranch2, detectWorktree } = await import("./src-AMCPIYDZ.js");
+    const { getDiff: getDiff2, getCurrentBranch: getCurrentBranch2, detectWorktree } = await import("./src-OZQ32NDN.js");
     const { analyze: analyze2 } = await import("./src-JMPTSU3P.js");
     const { diffSet, rawDiff } = getDiff2(diffRef, { cwd });
     if (diffSet.files.length === 0) {
@@ -249,49 +437,7 @@ async function submitReviewToServer(serverInfo, diffRef, options = {}) {
   if (maxWaitMs <= 0) {
     return { result: null, sessionId };
   }
-  const pollIntervalMs = 2e3;
-  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/build-info.ts
-import fs3 from "fs";
-import path3 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function getBuildInfo() {
-  let dir = path3.dirname(fileURLToPath2(import.meta.url));
-  while (dir !== path3.dirname(dir)) {
-    const manifest = path3.join(dir, "package.json");
-    if (fs3.existsSync(manifest) && isOwnManifest(manifest)) {
-      return fs3.existsSync(path3.join(dir, ".git")) ? { dev: true, root: dir } : { dev: false, root: null };
-    }
-    dir = path3.dirname(dir);
-  }
-  return { dev: false, root: null };
-}
-function isOwnManifest(manifestPath) {
-  try {
-    const manifest = JSON.parse(fs3.readFileSync(manifestPath, "utf8"));
-    return manifest.name === "diffprism";
-  } catch {
-    return false;
-  }
-}
-function describeVersion(version) {
-  const info = getBuildInfo();
-  return info.dev ? `${version} (dev build \u2014 ${info.root})` : version;
+  return { result: await waitForDecision(serverInfo, sessionId, maxWaitMs), sessionId };
 }
 
 // packages/core/src/diff-utils.ts
@@ -334,8 +480,20 @@ function createDiffPoller(options) {
   let lastDiffHash = null;
   let lastDiffSet = null;
   let refreshRequested = false;
-  let interval = null;
+  let timer = null;
   let running = false;
+  let quietPolls = 0;
+  function nextDelay() {
+    return typeof pollInterval === "number" ? pollInterval : pollInterval({ quietPolls });
+  }
+  function schedule() {
+    if (!running) return;
+    timer = setTimeout(() => {
+      timer = null;
+      poll();
+      schedule();
+    }, nextDelay());
+  }
   function poll() {
     if (!running) return;
     try {
@@ -343,6 +501,7 @@ function createDiffPoller(options) {
       const newHash = hashDiff(newRawDiff);
       if (newHash !== lastDiffHash || refreshRequested) {
         refreshRequested = false;
+        quietPolls = 0;
         const newBriefing = analyze(newDiffSet);
         const changedFiles = detectChangedFiles(lastDiffSet, newDiffSet);
         lastDiffHash = newHash;
@@ -355,8 +514,11 @@ function createDiffPoller(options) {
           timestamp: Date.now()
         };
         onDiffChanged(updatePayload);
+      } else {
+        quietPolls++;
       }
     } catch (err) {
+      quietPolls++;
       if (onError && err instanceof Error) {
         onError(err);
       }
@@ -372,13 +534,13 @@ function createDiffPoller(options) {
         lastDiffSet = initialDiffSet;
       } catch {
       }
-      interval = setInterval(poll, pollInterval);
+      schedule();
     },
     stop() {
       running = false;
-      if (interval) {
-        clearInterval(interval);
-        interval = null;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
       }
     },
     setDiffRef(newRef) {
@@ -388,6 +550,15 @@ function createDiffPoller(options) {
     },
     refresh() {
       refreshRequested = true;
+    },
+    wake() {
+      if (!running) return;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      poll();
+      schedule();
     }
   };
 }
@@ -398,12 +569,13 @@ import { randomUUID as randomUUID2 } from "crypto";
 import getPort from "get-port";
 import open from "open";
 import { WebSocketServer, WebSocket } from "ws";
-import fs6 from "fs";
+import fs7 from "fs";
+import path7 from "path";
 
 // packages/core/src/ui-server.ts
 import http from "http";
-import fs4 from "fs";
-import path4 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var MIME_TYPES = {
   ".html": "text/html",
@@ -418,14 +590,14 @@ var MIME_TYPES = {
 };
 function resolveUiDist() {
   const thisFile = fileURLToPath3(import.meta.url);
-  const thisDir = path4.dirname(thisFile);
-  const publishedUiDist = path4.resolve(thisDir, "..", "ui-dist");
-  if (fs4.existsSync(path4.join(publishedUiDist, "index.html"))) {
+  const thisDir = path5.dirname(thisFile);
+  const publishedUiDist = path5.resolve(thisDir, "..", "ui-dist");
+  if (fs5.existsSync(path5.join(publishedUiDist, "index.html"))) {
     return publishedUiDist;
   }
-  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
-  const devUiDist = path4.join(workspaceRoot, "packages", "ui", "dist");
-  if (fs4.existsSync(path4.join(devUiDist, "index.html"))) {
+  const workspaceRoot = path5.resolve(thisDir, "..", "..", "..");
+  const devUiDist = path5.join(workspaceRoot, "packages", "ui", "dist");
+  if (fs5.existsSync(path5.join(devUiDist, "index.html"))) {
     return devUiDist;
   }
   throw new Error(
@@ -434,10 +606,10 @@ function resolveUiDist() {
 }
 function resolveUiRoot() {
   const thisFile = fileURLToPath3(import.meta.url);
-  const thisDir = path4.dirname(thisFile);
-  const workspaceRoot = path4.resolve(thisDir, "..", "..", "..");
-  const uiRoot = path4.join(workspaceRoot, "packages", "ui");
-  if (fs4.existsSync(path4.join(uiRoot, "index.html"))) {
+  const thisDir = path5.dirname(thisFile);
+  const workspaceRoot = path5.resolve(thisDir, "..", "..", "..");
+  const uiRoot = path5.join(workspaceRoot, "packages", "ui");
+  if (fs5.existsSync(path5.join(uiRoot, "index.html"))) {
     return uiRoot;
   }
   throw new Error(
@@ -457,14 +629,14 @@ async function startViteDevServer(uiRoot, port, silent) {
 function createStaticServer(distPath, port) {
   const server = http.createServer((req, res) => {
     const urlPath = req.url?.split("?")[0] ?? "/";
-    let filePath = path4.join(distPath, urlPath === "/" ? "index.html" : urlPath);
-    if (!fs4.existsSync(filePath)) {
-      filePath = path4.join(distPath, "index.html");
+    let filePath = path5.join(distPath, urlPath === "/" ? "index.html" : urlPath);
+    if (!fs5.existsSync(filePath)) {
+      filePath = path5.join(distPath, "index.html");
     }
-    const ext = path4.extname(filePath);
+    const ext = path5.extname(filePath);
     const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
     try {
-      const content = fs4.readFileSync(filePath);
+      const content = fs5.readFileSync(filePath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch {
@@ -478,23 +650,70 @@ function createStaticServer(distPath, port) {
   });
 }
 
+// packages/core/src/pr-review.ts
+var EVENTS = ["APPROVE", "REQUEST_CHANGES", "COMMENT"];
+var PR_EVENT_DECISION = {
+  APPROVE: "approved",
+  REQUEST_CHANGES: "changes_requested",
+  // A GitHub "Comment" review neither approves nor blocks; this is the
+  // closest DiffPrism decision.
+  COMMENT: "approved_with_comments"
+};
+function buildGitHubReview(submission, annotations) {
+  if (!EVENTS.includes(submission.event)) {
+    return { error: `Unknown review event: ${String(submission.event)}` };
+  }
+  const body = submission.summary?.trim() ?? "";
+  if (!body && submission.event !== "APPROVE") {
+    return { error: "GitHub needs a summary to request changes or comment" };
+  }
+  const comments = [];
+  for (const id of submission.threadIds ?? []) {
+    const thread = annotations.find((a) => a.id === id);
+    if (!thread) return { error: `Thread not found: ${id}` };
+    if (thread.author !== "reviewer") return { error: `Only your own threads can be posted: ${id}` };
+    if (thread.dismissed) return { error: `Thread was dismissed: ${id}` };
+    comments.push({
+      path: thread.file,
+      line: thread.line,
+      side: thread.side === "old" ? "LEFT" : "RIGHT",
+      body: thread.body
+    });
+  }
+  return { review: { event: submission.event, body, comments } };
+}
+
+// packages/core/src/watch-schedule.ts
+var DEFAULT_WATCH_SCHEDULE = {
+  viewedMs: 2e3,
+  unviewedMs: 3e4,
+  unviewedMaxMs: 5 * 6e4
+};
+function watcherPollDelay(state, options = DEFAULT_WATCH_SCHEDULE) {
+  if (state.viewed) {
+    return options.viewedMs;
+  }
+  const backedOff = options.unviewedMs * 2 ** Math.min(state.quietPolls, 20);
+  return Math.min(backedOff, options.unviewedMaxMs);
+}
+
 // packages/core/src/review-history.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs6 from "fs";
+import path6 from "path";
 import { randomUUID } from "crypto";
 function generateEntryId() {
   return randomUUID();
 }
 function getHistoryPath(projectDir) {
-  return path5.join(projectDir, ".diffprism", "history", "reviews.json");
+  return path6.join(projectDir, ".diffprism", "history", "reviews.json");
 }
 function readHistory(projectDir) {
   const filePath = getHistoryPath(projectDir);
-  if (!fs5.existsSync(filePath)) {
+  if (!fs6.existsSync(filePath)) {
     return { version: 1, entries: [] };
   }
   try {
-    const raw = fs5.readFileSync(filePath, "utf-8");
+    const raw = fs6.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch {
@@ -503,14 +722,14 @@ function readHistory(projectDir) {
 }
 function appendHistory(projectDir, entry) {
   const filePath = getHistoryPath(projectDir);
-  const dir = path5.dirname(filePath);
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true });
+  const dir = path6.dirname(filePath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
   }
   const history = readHistory(projectDir);
   history.entries.push(entry);
   history.entries.sort((a, b) => a.timestamp - b.timestamp);
-  fs5.writeFileSync(filePath, JSON.stringify(history, null, 2) + "\n");
+  fs6.writeFileSync(filePath, JSON.stringify(history, null, 2) + "\n");
 }
 function getRecentHistory(projectDir, limit = 50) {
   const history = readHistory(projectDir);
@@ -521,10 +740,126 @@ function getRecentHistory(projectDir, limit = 50) {
 var SUBMITTED_TTL_MS = 5 * 60 * 1e3;
 var ABANDONED_TTL_MS = 60 * 60 * 1e3;
 var CLEANUP_INTERVAL_MS = 60 * 1e3;
+var IDLE_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+function touch(session) {
+  session.lastActivityAt = Date.now();
+}
 var sessions = /* @__PURE__ */ new Map();
+function listedSummaries() {
+  return Array.from(sessions.values()).filter((session) => session.closedAt === void 0).map(toSummary);
+}
+function localIdentity(projectPath) {
+  const repoRoot = getRepoRoot({ cwd: projectPath }) ?? path7.resolve(projectPath);
+  return { key: `repo:${repoRoot}`, repoRoot };
+}
+function findSessionByKey(key) {
+  for (const session of sessions.values()) {
+    if (session.key === key) return session;
+  }
+  return void 0;
+}
+function openSession(request) {
+  const { payload, diffRef } = request;
+  if (diffRef) {
+    payload.watchMode = true;
+  }
+  const existing = findSessionByKey(request.key);
+  if (!existing) {
+    const id2 = `session-${randomUUID2().slice(0, 8)}`;
+    payload.reviewId = id2;
+    const session = {
+      id: id2,
+      key: request.key,
+      repoRoot: request.repoRoot,
+      payload,
+      projectPath: request.projectPath,
+      source: request.source,
+      status: "pending",
+      createdAt: Date.now(),
+      result: null,
+      diffRef,
+      openedDiffRef: diffRef,
+      lastDiffHash: diffRef ? hashDiff(payload.rawDiff) : void 0,
+      lastDiffSet: diffRef ? payload.diffSet : void 0,
+      hasNewChanges: false,
+      annotations: [],
+      attentionClearedAt: 0,
+      lastActivityAt: Date.now()
+    };
+    sessions.set(id2, session);
+    if (diffRef) {
+      startSessionWatcher(id2);
+    }
+    broadcastToAll({ type: "session:added", payload: toSummary(session) });
+    return { session, reused: false };
+  }
+  const id = existing.id;
+  payload.reviewId = id;
+  stopSessionWatcher(id);
+  const wasClosed = existing.closedAt !== void 0;
+  existing.closedAt = void 0;
+  const incomingHash = hashDiff(payload.rawDiff);
+  const contentChanged = hashDiff(existing.payload.rawDiff) !== incomingHash;
+  const stillAnswered = existing.result !== null && existing.result.decision !== "dismissed" && existing.verdictDiffHash === incomingHash;
+  if (existing.result !== null && !stillAnswered) {
+    existing.result = null;
+    existing.status = "pending";
+    existing.verdictDiffHash = void 0;
+  }
+  existing.payload = payload;
+  existing.projectPath = request.projectPath;
+  existing.repoRoot = request.repoRoot;
+  existing.diffRef = diffRef;
+  existing.openedDiffRef = diffRef;
+  existing.lastDiffHash = diffRef ? incomingHash : void 0;
+  existing.lastDiffSet = diffRef ? payload.diffSet : void 0;
+  existing.createdAt = Date.now();
+  touch(existing);
+  if (diffRef) {
+    startSessionWatcher(id);
+  }
+  if (hasViewersForSession(id)) {
+    if (existing.status === "pending") {
+      existing.status = "in_review";
+    }
+    existing.hasNewChanges = false;
+    sendToSessionClients(id, { type: "review:init", payload });
+    for (const annotation of existing.annotations) {
+      sendToSessionClients(id, { type: "annotation:added", payload: annotation });
+    }
+  } else if (contentChanged || wasClosed) {
+    existing.hasNewChanges = true;
+  }
+  if (wasClosed) {
+    broadcastToAll({ type: "session:added", payload: toSummary(existing) });
+  } else {
+    broadcastSessionUpdate(existing);
+  }
+  return { session: existing, reused: true };
+}
+function attachViewer(ws, session) {
+  clientSessions.set(ws, session.id);
+  session.status = "in_review";
+  session.hasNewChanges = false;
+  session.attentionClearedAt = Date.now();
+  touch(session);
+  const watcher = sessionWatchers.get(session.id);
+  startSessionWatcher(session.id);
+  broadcastSessionUpdate(session);
+  ws.send(JSON.stringify({ type: "review:init", payload: session.payload }));
+  for (const annotation of session.annotations) {
+    ws.send(JSON.stringify({ type: "annotation:added", payload: annotation }));
+  }
+  watcher?.wake();
+}
+function needsAttention(session) {
+  return session.annotations.some(
+    (a) => a.type === "warning" && !a.dismissed && a.createdAt > session.attentionClearedAt
+  );
+}
 var clientSessions = /* @__PURE__ */ new Map();
 var sessionWatchers = /* @__PURE__ */ new Map();
-var serverPollInterval = 2e3;
+var watchSchedule = DEFAULT_WATCH_SCHEDULE;
 var reopenBrowserIfNeeded = null;
 var serverUiUrl = null;
 function toSummary(session) {
@@ -549,6 +884,8 @@ function toSummary(session) {
     decision: session.result?.decision,
     createdAt: session.createdAt,
     hasNewChanges: session.hasNewChanges,
+    needsAttention: needsAttention(session),
+    diffRef: session.diffRef,
     source: session.source
   };
 }
@@ -632,10 +969,13 @@ function startSessionWatcher(sessionId) {
   const poller = createDiffPoller({
     diffRef: session.diffRef,
     cwd: session.projectPath,
-    pollInterval: serverPollInterval,
+    // Asked before every poll, so a session speeds up the moment someone views
+    // it and backs off while nobody is — see watch-schedule.ts.
+    pollInterval: ({ quietPolls }) => watcherPollDelay({ viewed: hasViewersForSession(sessionId), quietPolls }, watchSchedule),
     onDiffChanged: (updatePayload) => {
       const s = sessions.get(sessionId);
       if (!s) return;
+      touch(s);
       s.payload = {
         ...s.payload,
         diffSet: updatePayload.diffSet,
@@ -687,9 +1027,16 @@ function hasConnectedClients() {
   return false;
 }
 function broadcastSessionList() {
-  const summaries = Array.from(sessions.values()).map(toSummary);
+  const summaries = listedSummaries();
   broadcastToAll({ type: "session:list", payload: summaries });
 }
+function recordVerdict(session, result) {
+  session.result = result;
+  session.status = "submitted";
+  session.verdictDiffHash = hashDiff(session.payload.rawDiff);
+  touch(session);
+  recordReviewHistory(session, result);
+}
 function recordReviewHistory(session, result) {
   if (session.projectPath.startsWith("github:")) return;
   try {
@@ -714,12 +1061,12 @@ function recordReviewHistory(session, result) {
 function isInsideGitRepo(dirPath) {
   let current = dirPath;
   while (current !== "/") {
-    if (fs6.existsSync(`${current}/.git`)) return true;
+    if (fs7.existsSync(`${current}/.git`)) return true;
     const parent = current.replace(/\/[^/]+$/, "") || "/";
     if (parent === current) break;
     current = parent;
   }
-  return fs6.existsSync(`${current}/.git`);
+  return fs7.existsSync(`${current}/.git`);
 }
 async function handleApiRequest(req, res) {
   const method = req.method ?? "GET";
@@ -742,7 +1089,18 @@ async function handleApiRequest(req, res) {
       sessions: sessions.size,
       uptime: process.uptime(),
       uiUrl: serverUiUrl,
-      cwd: process.cwd()
+      cwd: process.cwd(),
+      // The dashboard reads its default scope from here rather than keeping
+      // its own copy — Vite can't import @diffprism/core, and a copy drifts.
+      defaultDiffRef: DEFAULT_DIFF_REF
+    });
+    return true;
+  }
+  if (method === "GET" && url === "/api/feedback") {
+    const parsed = new URL(req.url ?? "/", "http://localhost");
+    const kind = parsed.searchParams.get("kind") === "bug" ? "bug" : "feedback";
+    jsonResponse(res, 200, {
+      url: buildFeedbackUrl({ kind, error: kind === "bug" ? readLastError() : null })
     });
     return true;
   }
@@ -750,72 +1108,17 @@ async function handleApiRequest(req, res) {
     try {
       const body = await readBody(req);
       const { payload, projectPath, diffRef } = JSON.parse(body);
-      let existingSession;
-      for (const session of sessions.values()) {
-        if (session.projectPath === projectPath && session.source === "agent") {
-          existingSession = session;
-          break;
-        }
-      }
-      if (existingSession) {
-        const sessionId = existingSession.id;
-        payload.reviewId = sessionId;
-        if (diffRef) {
-          payload.watchMode = true;
-        }
-        stopSessionWatcher(sessionId);
-        existingSession.payload = payload;
-        existingSession.status = "pending";
-        existingSession.result = null;
-        existingSession.createdAt = Date.now();
-        existingSession.diffRef = diffRef;
-        existingSession.lastDiffHash = diffRef ? hashDiff(payload.rawDiff) : void 0;
-        existingSession.lastDiffSet = diffRef ? payload.diffSet : void 0;
-        existingSession.hasNewChanges = false;
-        existingSession.annotations = [];
-        if (diffRef) {
-          startSessionWatcher(sessionId);
-        }
-        if (hasViewersForSession(sessionId)) {
-          sendToSessionClients(sessionId, {
-            type: "review:init",
-            payload
-          });
-        }
-        broadcastSessionUpdate(existingSession);
-        reopenBrowserIfNeeded?.();
-        jsonResponse(res, 200, { sessionId });
-      } else {
-        const sessionId = `session-${randomUUID2().slice(0, 8)}`;
-        payload.reviewId = sessionId;
-        if (diffRef) {
-          payload.watchMode = true;
-        }
-        const session = {
-          id: sessionId,
-          payload,
-          projectPath,
-          source: "agent",
-          status: "pending",
-          createdAt: Date.now(),
-          result: null,
-          diffRef,
-          lastDiffHash: diffRef ? hashDiff(payload.rawDiff) : void 0,
-          lastDiffSet: diffRef ? payload.diffSet : void 0,
-          hasNewChanges: false,
-          annotations: []
-        };
-        sessions.set(sessionId, session);
-        if (diffRef) {
-          startSessionWatcher(sessionId);
-        }
-        broadcastToAll({
-          type: "session:added",
-          payload: toSummary(session)
-        });
-        reopenBrowserIfNeeded?.();
-        jsonResponse(res, 201, { sessionId });
-      }
+      const identity = localIdentity(projectPath);
+      const { session, reused } = openSession({
+        key: identity.key,
+        repoRoot: identity.repoRoot,
+        projectPath: identity.repoRoot,
+        payload,
+        diffRef,
+        source: "agent"
+      });
+      reopenBrowserIfNeeded?.();
+      jsonResponse(res, reused ? 200 : 201, { sessionId: session.id });
     } catch {
       jsonResponse(res, 400, { error: "Invalid request body" });
     }
@@ -824,13 +1127,13 @@ async function handleApiRequest(req, res) {
   if (method === "POST" && url === "/api/projects/open") {
     try {
       const body = await readBody(req);
-      const { projectPath, diffRef = "working-copy" } = JSON.parse(body);
+      const { projectPath, diffRef = DEFAULT_DIFF_REF } = JSON.parse(body);
       if (!projectPath) {
         jsonResponse(res, 400, { error: "Missing projectPath" });
         return true;
       }
       try {
-        const stat = fs6.statSync(projectPath);
+        const stat = fs7.statSync(projectPath);
         if (!stat.isDirectory()) {
           jsonResponse(res, 400, { error: "Path is not a directory" });
           return true;
@@ -855,40 +1158,30 @@ async function handleApiRequest(req, res) {
         currentBranch = getCurrentBranch({ cwd: projectPath });
       } catch {
       }
-      const sessionId = `session-${randomUUID2().slice(0, 8)}`;
-      const projectName = projectPath.split("/").pop() || projectPath;
+      const identity = localIdentity(projectPath);
+      const projectName = identity.repoRoot.split("/").pop() || identity.repoRoot;
       const payload = {
-        reviewId: sessionId,
+        reviewId: "",
         diffSet,
         rawDiff,
         briefing,
         metadata: {
           title: projectName,
           currentBranch
-        },
-        watchMode: true
+        }
       };
-      const session = {
-        id: sessionId,
+      const { session, reused } = openSession({
+        key: identity.key,
+        repoRoot: identity.repoRoot,
+        projectPath: identity.repoRoot,
         payload,
-        projectPath,
-        source: "manual",
-        status: "pending",
-        createdAt: Date.now(),
-        result: null,
         diffRef,
-        lastDiffHash: hashDiff(rawDiff),
-        lastDiffSet: diffSet,
-        hasNewChanges: false,
-        annotations: []
-      };
-      sessions.set(sessionId, session);
-      startSessionWatcher(sessionId);
-      broadcastToAll({
-        type: "session:added",
-        payload: toSummary(session)
+        source: "manual"
+      });
+      jsonResponse(res, reused ? 200 : 201, {
+        sessionId: session.id,
+        fileCount: diffSet.files.length
       });
-      jsonResponse(res, 201, { sessionId, fileCount: diffSet.files.length });
     } catch {
       jsonResponse(res, 400, { error: "Invalid request body" });
     }
@@ -910,7 +1203,7 @@ async function handleApiRequest(req, res) {
         fetchPullRequest,
         fetchPullRequestDiff,
         normalizePr
-      } = await import("./src-KF5HRJPX.js");
+      } = await import("./src-DNNNQ2RD.js");
       if (!isPrRef(prUrl)) {
         jsonResponse(res, 400, {
           error: "Invalid PR URL. Expected https://github.com/owner/repo/pull/123 or owner/repo#123"
@@ -947,26 +1240,15 @@ async function handleApiRequest(req, res) {
         }
       } catch {
       }
-      const sessionId = `session-${randomUUID2().slice(0, 8)}`;
-      normalized.payload.reviewId = sessionId;
-      const session = {
-        id: sessionId,
-        payload: normalized.payload,
+      const { session, reused } = openSession({
+        key: `pr:${owner}/${repo}#${prNumber}`.toLowerCase(),
+        repoRoot: localRepoPath ? getRepoRoot({ cwd: localRepoPath }) ?? localRepoPath : null,
         projectPath: localRepoPath ?? `github:${owner}/${repo}#${prNumber}`,
-        source: "manual",
-        status: "pending",
-        createdAt: Date.now(),
-        result: null,
-        hasNewChanges: false,
-        annotations: []
-      };
-      sessions.set(sessionId, session);
-      broadcastToAll({
-        type: "session:added",
-        payload: toSummary(session)
+        payload: normalized.payload,
+        source: "manual"
       });
-      jsonResponse(res, 201, {
-        sessionId,
+      jsonResponse(res, reused ? 200 : 201, {
+        sessionId: session.id,
         fileCount: normalized.diffSet.files.length,
         localRepoPath,
         pr: {
@@ -989,7 +1271,7 @@ async function handleApiRequest(req, res) {
     if (parsedUrl.pathname === "/api/fs/list") {
       const dirPath = parsedUrl.searchParams.get("path") || process.cwd();
       try {
-        const stat = fs6.statSync(dirPath);
+        const stat = fs7.statSync(dirPath);
         if (!stat.isDirectory()) {
           jsonResponse(res, 400, { error: "Not a directory" });
           return true;
@@ -999,13 +1281,13 @@ async function handleApiRequest(req, res) {
         return true;
       }
       try {
-        const entries = fs6.readdirSync(dirPath, { withFileTypes: true });
+        const entries = fs7.readdirSync(dirPath, { withFileTypes: true });
         const dirs = [];
         for (const entry of entries) {
           if (!entry.isDirectory()) continue;
           if (entry.name.startsWith(".")) continue;
           const fullPath = `${dirPath}/${entry.name}`;
-          const isGitRepo2 = fs6.existsSync(`${fullPath}/.git`);
+          const isGitRepo2 = fs7.existsSync(`${fullPath}/.git`);
           dirs.push({ name: entry.name, path: fullPath, isGitRepo: isGitRepo2 });
         }
         dirs.sort((a, b) => {
@@ -1022,10 +1304,22 @@ async function handleApiRequest(req, res) {
     }
   }
   if (method === "GET" && url === "/api/reviews") {
-    const summaries = Array.from(sessions.values()).map(toSummary);
+    const summaries = listedSummaries();
     jsonResponse(res, 200, { sessions: summaries });
     return true;
   }
+  if (method === "GET" && url === "/api/reviews/resolve") {
+    const parsed = new URL(req.url ?? "/", "http://localhost");
+    const rawPath = parsed.searchParams.get("path");
+    if (!rawPath) {
+      jsonResponse(res, 400, { error: "Missing path" });
+      return true;
+    }
+    const repoRoot = getRepoRoot({ cwd: rawPath }) ?? path7.resolve(rawPath);
+    const matches = Array.from(sessions.values()).filter((session) => session.closedAt === void 0 && session.repoRoot === repoRoot).map(toSummary);
+    jsonResponse(res, 200, { repoRoot, sessions: matches });
+    return true;
+  }
   const getReviewParams = matchRoute(method, url, "GET", "/api/reviews/:id");
   if (getReviewParams) {
     const session = sessions.get(getReviewParams.id);
@@ -1060,9 +1354,7 @@ async function handleApiRequest(req, res) {
     try {
       const body = await readBody(req);
       const result = JSON.parse(body);
-      session.result = result;
-      session.status = "submitted";
-      recordReviewHistory(session, result);
+      recordVerdict(session, result);
       if (result.decision === "dismissed") {
         broadcastSessionRemoved(postResultParams.id);
       } else {
@@ -1081,6 +1373,7 @@ async function handleApiRequest(req, res) {
       jsonResponse(res, 404, { error: "Session not found" });
       return true;
     }
+    touch(session);
     if (session.result) {
       jsonResponse(res, 200, { result: session.result, status: "submitted" });
     } else {
@@ -1126,24 +1419,44 @@ async function handleApiRequest(req, res) {
     }
     try {
       const body = await readBody(req);
-      const { file, line, body: annotationBody, type, confidence, category, source } = JSON.parse(body);
+      const { file, line, side, body: annotationBody, type, confidence, category, source, author } = JSON.parse(body);
+      if (author !== void 0 && author !== "agent" && author !== "reviewer") {
+        jsonResponse(res, 400, { error: `Unknown author: ${String(author)}` });
+        return true;
+      }
+      if (side !== void 0 && side !== "old" && side !== "new") {
+        jsonResponse(res, 400, { error: `Unknown side: ${String(side)}` });
+        return true;
+      }
       const annotation = {
         id: randomUUID2(),
         sessionId: session.id,
         file,
         line,
+        // Agents annotate lines of the changed file; only the dashboard can
+        // point at a deleted line, and it says so.
+        side: side ?? "new",
         body: annotationBody,
         type,
         confidence: confidence ?? 1,
         category: category ?? "other",
         source,
-        createdAt: Date.now()
+        createdAt: Date.now(),
+        author: author ?? "agent",
+        replies: []
       };
       session.annotations.push(annotation);
+      touch(session);
       sendToSessionClients(session.id, {
         type: "annotation:added",
         payload: annotation
       });
+      if (annotation.type === "warning") {
+        if (hasViewersForSession(session.id)) {
+          session.attentionClearedAt = annotation.createdAt;
+        }
+        broadcastSessionUpdate(session);
+      }
       jsonResponse(res, 200, { annotationId: annotation.id });
     } catch {
       jsonResponse(res, 400, { error: "Invalid request body" });
@@ -1160,6 +1473,94 @@ async function handleApiRequest(req, res) {
     jsonResponse(res, 200, { annotations: session.annotations });
     return true;
   }
+  const replyParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations/:annotationId/replies");
+  if (replyParams) {
+    const session = sessions.get(replyParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    const annotation = session.annotations.find((a) => a.id === replyParams.annotationId);
+    if (!annotation) {
+      jsonResponse(res, 404, { error: "Annotation not found" });
+      return true;
+    }
+    try {
+      const { author, agent, body: replyBody } = JSON.parse(await readBody(req));
+      if (author !== "agent" && author !== "reviewer") {
+        jsonResponse(res, 400, { error: 'author must be "agent" or "reviewer"' });
+        return true;
+      }
+      if (!replyBody?.trim()) {
+        jsonResponse(res, 400, { error: "A reply needs a body" });
+        return true;
+      }
+      const reply = {
+        id: randomUUID2(),
+        author,
+        ...author === "agent" ? { agent: agent ?? "unknown" } : {},
+        body: replyBody,
+        createdAt: Date.now()
+      };
+      annotation.replies = [...annotation.replies ?? [], reply];
+      touch(session);
+      sendToSessionClients(session.id, { type: "annotation:updated", payload: annotation });
+      jsonResponse(res, 200, { replyId: reply.id, annotation });
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+    }
+    return true;
+  }
+  const githubReviewParams = matchRoute(method, url, "POST", "/api/reviews/:id/github-review");
+  if (githubReviewParams) {
+    const session = sessions.get(githubReviewParams.id);
+    if (!session) {
+      jsonResponse(res, 404, { error: "Session not found" });
+      return true;
+    }
+    const pr = session.payload.metadata.githubPr;
+    if (!pr) {
+      jsonResponse(res, 400, { error: "Not a pull request review" });
+      return true;
+    }
+    let submission;
+    try {
+      submission = JSON.parse(await readBody(req));
+    } catch {
+      jsonResponse(res, 400, { error: "Invalid request body" });
+      return true;
+    }
+    const built = buildGitHubReview(submission, session.annotations);
+    if ("error" in built) {
+      jsonResponse(res, 400, { error: built.error });
+      return true;
+    }
+    const { resolveGitHubToken, createGitHubClient, submitGitHubReview } = await import("./src-DNNNQ2RD.js");
+    let token;
+    try {
+      token = resolveGitHubToken();
+    } catch (err) {
+      jsonResponse(res, 401, { error: err instanceof Error ? err.message : String(err) });
+      return true;
+    }
+    let posted;
+    try {
+      posted = await submitGitHubReview(createGitHubClient(token), pr.owner, pr.repo, pr.number, built.review);
+    } catch (err) {
+      jsonResponse(res, 502, {
+        error: `GitHub rejected the review: ${err instanceof Error ? err.message : String(err)}`
+      });
+      return true;
+    }
+    recordVerdict(session, {
+      decision: PR_EVENT_DECISION[built.review.event],
+      comments: [],
+      summary: built.review.body || void 0
+    });
+    broadcastSessionUpdate(session);
+    jsonResponse(res, 200, { url: posted.url });
+    return true;
+  }
   const dismissAnnotationParams = matchRoute(method, url, "POST", "/api/reviews/:id/annotations/:annotationId/dismiss");
   if (dismissAnnotationParams) {
     const session = sessions.get(dismissAnnotationParams.id);
@@ -1177,6 +1578,9 @@ async function handleApiRequest(req, res) {
       type: "annotation:dismissed",
       payload: { annotationId: dismissAnnotationParams.annotationId }
     });
+    if (annotation.type === "warning") {
+      broadcastSessionUpdate(session);
+    }
     jsonResponse(res, 200, { ok: true });
     return true;
   }
@@ -1257,7 +1661,8 @@ async function handleApiRequest(req, res) {
     }
     try {
       const body = await readBody(req);
-      const { ref } = JSON.parse(body);
+      const { ref: requestedRef, reset } = JSON.parse(body);
+      const ref = reset ? session.openedDiffRef ?? DEFAULT_DIFF_REF : requestedRef;
       if (!ref) {
         jsonResponse(res, 400, { error: "Missing ref in request body" });
         return true;
@@ -1277,6 +1682,7 @@ async function handleApiRequest(req, res) {
       session.lastDiffSet = newDiffSet;
       stopSessionWatcher(session.id);
       session.diffRef = ref;
+      touch(session);
       if (hasConnectedClients()) {
         startSessionWatcher(session.id);
       }
@@ -1337,10 +1743,18 @@ async function startGlobalServer(options = {}) {
     wsPort: preferredWsPort = 24681,
     silent = false,
     dev = false,
-    pollInterval = 2e3,
+    pollInterval = DEFAULT_WATCH_SCHEDULE.viewedMs,
+    unviewedPollInterval = DEFAULT_WATCH_SCHEDULE.unviewedMs,
+    unviewedPollMaxInterval = DEFAULT_WATCH_SCHEDULE.unviewedMaxMs,
+    idleSessionTtl = IDLE_SESSION_TTL_MS,
+    cleanupInterval = CLEANUP_INTERVAL_MS,
     openBrowser = true
   } = options;
-  serverPollInterval = pollInterval;
+  watchSchedule = {
+    viewedMs: pollInterval,
+    unviewedMs: unviewedPollInterval,
+    unviewedMaxMs: unviewedPollMaxInterval
+  };
   const [httpPort, wsPort] = await Promise.all([
     getPort({ port: preferredHttpPort }),
     getPort({ port: preferredWsPort })
@@ -1370,26 +1784,14 @@ async function startGlobalServer(options = {}) {
     const url = new URL(req.url ?? "/", `http://localhost:${wsPort}`);
     const sessionId = url.searchParams.get("sessionId");
     if (sessionId) {
-      clientSessions.set(ws, sessionId);
       const session = sessions.get(sessionId);
       if (session) {
-        session.status = "in_review";
-        session.hasNewChanges = false;
-        broadcastSessionUpdate(session);
-        const msg = {
-          type: "review:init",
-          payload: session.payload
-        };
-        ws.send(JSON.stringify(msg));
-        for (const annotation of session.annotations) {
-          ws.send(JSON.stringify({
-            type: "annotation:added",
-            payload: annotation
-          }));
-        }
+        attachViewer(ws, session);
+      } else {
+        clientSessions.set(ws, sessionId);
       }
     } else {
-      const summaries = Array.from(sessions.values()).map(toSummary);
+      const summaries = listedSummaries();
       const msg = {
         type: "session:list",
         payload: summaries
@@ -1398,20 +1800,7 @@ async function startGlobalServer(options = {}) {
       if (summaries.length === 1) {
         const session = sessions.get(summaries[0].id);
         if (session) {
-          clientSessions.set(ws, session.id);
-          session.status = "in_review";
-          session.hasNewChanges = false;
-          broadcastSessionUpdate(session);
-          ws.send(JSON.stringify({
-            type: "review:init",
-            payload: session.payload
-          }));
-          for (const annotation of session.annotations) {
-            ws.send(JSON.stringify({
-              type: "annotation:added",
-              payload: annotation
-            }));
-          }
+          attachViewer(ws, session);
         }
       }
     }
@@ -1423,9 +1812,7 @@ async function startGlobalServer(options = {}) {
           if (sid) {
             const session = sessions.get(sid);
             if (session) {
-              session.result = msg.payload;
-              session.status = "submitted";
-              recordReviewHistory(session, msg.payload);
+              recordVerdict(session, msg.payload);
               if (msg.payload.decision === "dismissed") {
                 broadcastSessionRemoved(sid);
               } else {
@@ -1436,29 +1823,18 @@ async function startGlobalServer(options = {}) {
         } else if (msg.type === "session:select") {
           const session = sessions.get(msg.payload.sessionId);
           if (session) {
-            clientSessions.set(ws, session.id);
-            session.status = "in_review";
-            session.hasNewChanges = false;
-            startSessionWatcher(session.id);
-            broadcastSessionUpdate(session);
-            ws.send(JSON.stringify({
-              type: "review:init",
-              payload: session.payload
-            }));
-            for (const annotation of session.annotations) {
-              ws.send(JSON.stringify({
-                type: "annotation:added",
-                payload: annotation
-              }));
-            }
+            attachViewer(ws, session);
           }
         } else if (msg.type === "session:close") {
           const closedId = msg.payload.sessionId;
           stopSessionWatcher(closedId);
           const closedSession = sessions.get(closedId);
-          if (closedSession && !closedSession.result) {
-            closedSession.result = { decision: "dismissed", comments: [] };
-            closedSession.status = "submitted";
+          if (closedSession) {
+            closedSession.closedAt = Date.now();
+            if (!closedSession.result) {
+              closedSession.result = { decision: "dismissed", comments: [] };
+              closedSession.status = "submitted";
+            }
           }
           broadcastSessionRemoved(closedId);
         } else if (msg.type === "diff:change_ref") {
@@ -1519,19 +1895,18 @@ async function startGlobalServer(options = {}) {
   function cleanupExpiredSessions() {
     const now = Date.now();
     for (const [id, session] of sessions.entries()) {
-      if (session.source === "manual" && session.status !== "submitted") {
-        continue;
-      }
+      const idle = session.status !== "submitted" && !hasViewersForSession(id) && now - session.lastActivityAt > idleSessionTtl;
       const age = now - session.createdAt;
-      const expired = session.status === "submitted" && age > SUBMITTED_TTL_MS || session.status === "pending" && age > ABANDONED_TTL_MS;
-      if (expired) {
+      const ageRulesApply = !(session.source === "manual" && session.status !== "submitted");
+      const expiredByAge = ageRulesApply && (session.status === "submitted" && age > SUBMITTED_TTL_MS || session.status === "pending" && age > ABANDONED_TTL_MS);
+      if (idle || expiredByAge) {
         stopSessionWatcher(id);
         sessions.delete(id);
         broadcastSessionRemoved(id);
       }
     }
   }
-  const cleanupTimer = setInterval(cleanupExpiredSessions, CLEANUP_INTERVAL_MS);
+  const cleanupTimer = setInterval(cleanupExpiredSessions, cleanupInterval);
   const serverInfo = {
     httpPort,
     wsPort,
@@ -1588,12 +1963,54 @@ Waiting for reviews...
   return { httpPort, wsPort, stop };
 }
 
+// packages/core/src/mcp-tools.ts
+var MCP_TOOL_NAMES = [
+  "open_review",
+  "get_review_result",
+  "update_review_context",
+  "get_diff",
+  "analyze_diff",
+  "annotate",
+  "get_review_state",
+  "get_review_comments",
+  "reply",
+  "wait_for_comments",
+  "get_user_focus",
+  "get_pr_context",
+  "get_file_diff",
+  "get_file_context"
+];
+var RETIRED_MCP_TOOL_NAMES = [
+  "add_annotation",
+  "add_review_comment",
+  "flag_for_attention",
+  "review_pr"
+];
+function mcpToolPermission(name) {
+  return `mcp__diffprism__${name}`;
+}
+
 export {
   readServerFile,
   isServerAlive,
+  DEFAULT_DIFF_REF,
+  COMMIT_GATE_DIFF_REF,
+  DIFF_REF_DESCRIPTION,
+  getBuildInfo,
+  describeVersion,
+  currentVersion,
+  recordError,
+  readLastError,
+  REPORT_HINT,
+  buildFeedbackUrl,
   startGlobalServer,
+  awaitingAgent,
   ensureServer,
+  ReviewTimeoutError,
+  ReviewerAskedError,
+  waitForDecision,
   submitReviewToServer,
-  getBuildInfo,
-  describeVersion
+  MCP_TOOL_NAMES,
+  RETIRED_MCP_TOOL_NAMES,
+  mcpToolPermission
 };