getgloss 0.7.2 → 0.8.1

package/dist/server/daemon.js

@@ -1,4 +1,5 @@
 // src/server/daemon.ts
+import { rm as rm3 } from "fs/promises";
 import { serve } from "@hono/node-server";
 
 // src/shared/paths.ts
@@ -9,7 +10,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.7.2",
+  version: "0.8.1",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -40,6 +41,8 @@ var package_default = {
   },
   dependencies: {
     "@hono/node-server": "1.19.14",
+    "@shikijs/langs": "4.1.0",
+    "@shikijs/themes": "4.1.0",
     "@tailwindcss/vite": "4.3.0",
     commander: "14.0.3",
     execa: "9.6.1",
@@ -49,6 +52,7 @@ var package_default = {
     open: "10.2.0",
     react: "19.2.6",
     "react-dom": "19.2.6",
+    shiki: "4.1.0",
     ulid: "3.0.2",
     zustand: "5.0.13"
   },
@@ -108,6 +112,27 @@ function globalReviewsDir() {
 function globalReviewDir(reviewId) {
   return path.join(globalReviewsDir(), reviewId);
 }
+function globalReviewTurnsDir(reviewId) {
+  return path.join(globalReviewDir(reviewId), "turns");
+}
+function globalReviewTurnDir(reviewId, turnId) {
+  return path.join(globalReviewTurnsDir(reviewId), turnId);
+}
+function globalReviewTurnMetaFile(reviewId, turnId) {
+  return path.join(globalReviewTurnDir(reviewId, turnId), "turn.json");
+}
+function globalReviewTurnDiffFile(reviewId, turnId) {
+  return path.join(globalReviewTurnDir(reviewId, turnId), "diff.json");
+}
+function globalReviewTurnFeedbackFile(reviewId, turnId) {
+  return path.join(globalReviewTurnDir(reviewId, turnId), "feedback.json");
+}
+function globalReviewTurnMarkdownFile(reviewId, turnId) {
+  return path.join(globalReviewTurnDir(reviewId, turnId), "feedback.md");
+}
+function globalReviewTurnResolvedFile(reviewId, turnId) {
+  return path.join(globalReviewTurnDir(reviewId, turnId), "resolved.json");
+}
 function globalReviewMetaFile(reviewId) {
   return path.join(globalReviewDir(reviewId), "meta.json");
 }
@@ -130,23 +155,49 @@ async function ensureDir(dir) {
 // src/shared/server-info.ts
 import { readFile } from "fs/promises";
 
+// src/shared/errors.ts
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isFileNotFound(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
 // src/shared/json.ts
-import { writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { rename, rm, writeFile } from "fs/promises";
+import path2 from "path";
 function serializeJson(value) {
   return `${JSON.stringify(value, null, 2)}
 `;
 }
 async function writeJsonFile(filePath, value) {
-  await writeFile(filePath, serializeJson(value));
+  await writeTextFile(filePath, serializeJson(value));
+}
+async function writeTextFile(filePath, value) {
+  const tempPath = path2.join(
+    path2.dirname(filePath),
+    `.${path2.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(tempPath, value);
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
 }
 
+// src/shared/types.ts
+var SIDES = ["L", "R"];
+var REVIEW_STATUSES = ["pending", "submitted", "cancelled", "resolved"];
+var DIFF_LINE_TYPES = ["context", "add", "delete"];
+var DIFF_SCOPE_MODES = ["working", "branch", "explicit"];
+var DIFF_FALLBACK_REASONS = ["working-tree-clean", "missing-branch-base"];
+var REVIEW_SCOPE_MODES = ["all", "single", "range"];
+var RESOLUTION_STATUSES = ["partial", "resolved"];
+
 // src/shared/validation.ts
-var reviewStatuses = ["pending", "submitted", "cancelled", "resolved"];
-var resolutionStatuses = ["partial", "resolved"];
-var sides = ["L", "R"];
-var diffLineTypes = ["context", "add", "delete"];
-var diffScopeModes = ["working", "branch", "explicit"];
-var diffFallbackReasons = ["working-tree-clean", "missing-branch-base"];
 function parseJson(raw, guard, label) {
   const parsed = JSON.parse(raw);
   return parseJsonValue(parsed, guard, label);
@@ -157,26 +208,53 @@ function parseJsonValue(value, guard, label) {
   }
   return value;
 }
+function isServerInfo(value) {
+  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir);
+}
+function isClearReviewsRequest(value) {
+  return isRecord(value) && isOptionalNonNegativeInteger(value.olderThanDays) && isOptionalBoolean(value.dryRun);
+}
+function isOpenFileRequest(value) {
+  return isRecord(value) && isString(value.filePath) && isOptionalString(value.turnId);
+}
+function isCommitRangeDiffRequest(value) {
+  return isRecord(value) && isString(value.fromSha) && isString(value.toSha) && isOptionalString(value.turnId);
+}
 function isSubmitReviewRequest(value) {
-  return isRecord(value) && isArrayOf(value.comments, isComment);
+  return isRecord(value) && isArrayOf(value.comments, isComment) && isOptional(value.reviewScope, isReviewScope);
 }
 function isResolutionRequest(value) {
-  return isRecord(value) && isOptionalString(value.summary);
+  return isRecord(value) && isOptionalString(value.summary) && isOptionalString(value.turn);
 }
 function isStoredReviewMeta(value) {
-  return isRecord(value) && isString(value.id) && isString(value.cwd) && isBaseRef(value.base) && isNullableString(value.branch) && isReviewStatus(value.status) && isString(value.createdAt) && isOptionalString(value.submittedAt) && isOptionalString(value.resolvedAt) && isOptionalString(value.artifactDir) && isOptionalString(value.feedbackPath) && isOptionalString(value.markdownPath);
+  return isRecord(value) && isString(value.id) && isString(value.cwd) && isBaseRef(value.base) && isNullableString(value.branch) && isReviewStatus(value.status) && isString(value.createdAt) && isOptionalString(value.submittedAt) && isOptionalString(value.resolvedAt) && isOptionalString(value.artifactDir) && isOptionalString(value.activeTurnId) && isOptional(
+    value.turns,
+    (turns) => isArrayOf(turns, isReviewTurnSummary)
+  ) && isOptionalString(value.feedbackPath) && isOptionalString(value.markdownPath);
 }
 function isDiffPayload(value) {
-  return isRecord(value) && isBaseRef(value.base) && isNullableString(value.branch) && isString(value.cwd) && isDiffScope(value.scope) && isDiffStats(value.stats) && isString(value.rawDiff) && isArrayOf(value.files, isDiffFile) && isString(value.capturedAt);
+  return isRecord(value) && isBaseRef(value.base) && isNullableString(value.branch) && isString(value.cwd) && isDiffScope(value.scope) && isDiffStats(value.stats) && isString(value.rawDiff) && isArrayOf(value.files, isDiffFile) && isOptional(
+    value.commitDiffs,
+    (commitDiffs) => isArrayOf(commitDiffs, isCommitDiff)
+  ) && isString(value.capturedAt);
 }
 function isFeedbackBundle(value) {
-  return isRecord(value) && value.version === 1 && isString(value.reviewId) && isString(value.timestamp) && isBaseRef(value.base) && isNullableString(value.branch) && isArrayOf(value.comments, isComment);
+  return isRecord(value) && value.version === 1 && isString(value.reviewId) && isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isString(value.timestamp) && isBaseRef(value.base) && isNullableString(value.branch) && isOptional(value.reviewScope, isReviewScope) && isArrayOf(value.comments, isComment);
 }
 function isResolutionBundle(value) {
-  return isRecord(value) && isString(value.reviewId) && isResolutionStatus(value.status) && isNullableString(value.summary) && isNullableString(value.resolvedAt) && isArrayOf(value.comments, isResolvedComment);
+  return isRecord(value) && isString(value.reviewId) && isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isResolutionStatus(value.status) && isNullableString(value.summary) && isNullableString(value.resolvedAt) && isArrayOf(value.comments, isResolvedComment);
+}
+function isReviewTurnMeta(value) {
+  return isRecord(value) && isString(value.id) && isNumber(value.index) && isReviewStatus(value.status) && isString(value.createdAt) && isOptionalString(value.submittedAt) && isOptionalString(value.resolvedAt) && isString(value.artifactDir) && isString(value.diffPath) && isOptionalString(value.feedbackPath) && isOptionalString(value.markdownPath) && isOptionalString(value.resolvedPath);
+}
+function isReviewTurnSummary(value) {
+  if (!isRecord(value) || !isReviewTurnMeta(value)) {
+    return false;
+  }
+  return isString(value.capturedAt) && isDiffStats(value.stats) && isResolutionCounts(value.comments);
 }
 function isDiffScope(value) {
-  return isRecord(value) && isOneOf(value.mode, diffScopeModes) && isNullableString(value.requestedBase) && isBaseRef(value.base) && isDiffRef(value.comparison) && (value.fallbackReason === null || isOneOf(value.fallbackReason, diffFallbackReasons));
+  return isRecord(value) && isOneOf(value.mode, DIFF_SCOPE_MODES) && isNullableString(value.requestedBase) && isBaseRef(value.base) && isDiffRef(value.comparison) && (value.fallbackReason === null || isOneOf(value.fallbackReason, DIFF_FALLBACK_REASONS));
 }
 function isDiffRef(value) {
   return isRecord(value) && isString(value.ref) && isNullableString(value.sha);
@@ -187,6 +265,25 @@ function isBaseRef(value) {
 function isDiffStats(value) {
   return isRecord(value) && isNumber(value.files) && isNumber(value.additions) && isNumber(value.deletions);
 }
+function isDiffCommit(value) {
+  return isRecord(value) && isString(value.sha) && isString(value.shortSha) && isString(value.subject) && isString(value.authorName) && isString(value.authorEmail) && isString(value.authoredAt) && isString(value.committedAt);
+}
+function isCommitDiff(value) {
+  return isRecord(value) && isDiffCommit(value.commit) && isDiffStats(value.stats) && isString(value.rawDiff) && isArrayOf(value.files, isDiffFile);
+}
+function isReviewScope(value) {
+  if (!isRecord(value) || !isOneOf(value.mode, REVIEW_SCOPE_MODES)) {
+    return false;
+  }
+  switch (value.mode) {
+    case "all":
+      return true;
+    case "single":
+      return isString(value.sha);
+    case "range":
+      return isString(value.fromSha) && isString(value.toSha);
+  }
+}
 function isDiffFile(value) {
   return isRecord(value) && isString(value.path) && isNullableString(value.oldPath) && isNumber(value.additions) && isNumber(value.deletions) && isBoolean(value.isBinary) && isBoolean(value.isDeleted) && isBoolean(value.isNew) && isBoolean(value.isRenamed) && isNullableString(value.language) && isArrayOf(value.hunks, isDiffHunk);
 }
@@ -194,19 +291,22 @@ function isDiffHunk(value) {
   return isRecord(value) && isNumber(value.oldStart) && isNumber(value.oldLines) && isNumber(value.newStart) && isNumber(value.newLines) && isString(value.header) && isArrayOf(value.lines, isDiffLine);
 }
 function isDiffLine(value) {
-  return isRecord(value) && isOneOf(value.type, diffLineTypes) && isNullableNumber(value.oldLine) && isNullableNumber(value.newLine) && isString(value.content);
+  return isRecord(value) && isOneOf(value.type, DIFF_LINE_TYPES) && isNullableNumber(value.oldLine) && isNullableNumber(value.newLine) && isString(value.content);
 }
 function isComment(value) {
-  return isRecord(value) && isString(value.id) && isString(value.filePath) && isNumber(value.startLine) && isNumber(value.endLine) && isOneOf(value.side, sides) && isString(value.body) && isString(value.originalSnippet) && isString(value.createdAt);
+  return isRecord(value) && isString(value.id) && isString(value.filePath) && isNumber(value.startLine) && isNumber(value.endLine) && isOneOf(value.side, SIDES) && isString(value.body) && isString(value.originalSnippet) && isString(value.createdAt);
 }
 function isResolvedComment(value) {
   return isRecord(value) && isString(value.commentId) && value.status === "resolved" && isOptionalString(value.summary) && isString(value.resolvedAt);
 }
+function isResolutionCounts(value) {
+  return isRecord(value) && isNumber(value.total) && isNumber(value.resolved) && isNumber(value.open);
+}
 function isReviewStatus(value) {
-  return isOneOf(value, reviewStatuses);
+  return isOneOf(value, REVIEW_STATUSES);
 }
 function isResolutionStatus(value) {
-  return isOneOf(value, resolutionStatuses);
+  return isOneOf(value, RESOLUTION_STATUSES);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -214,6 +314,9 @@ function isRecord(value) {
 function isArrayOf(value, guard) {
   return Array.isArray(value) && value.every(guard);
 }
+function isOptional(value, guard) {
+  return value === void 0 || guard(value);
+}
 function isString(value) {
   return typeof value === "string";
 }
@@ -226,6 +329,15 @@ function isNullableString(value) {
 function isNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
+function isOptionalNumber(value) {
+  return value === void 0 || isNumber(value);
+}
+function isOptionalNonNegativeInteger(value) {
+  return value === void 0 || isNumber(value) && Number.isInteger(value) && value >= 0;
+}
+function isOptionalBoolean(value) {
+  return value === void 0 || isBoolean(value);
+}
 function isNullableNumber(value) {
   return value === null || isNumber(value);
 }
@@ -237,14 +349,34 @@ function isOneOf(value, options) {
 }
 
 // src/shared/server-info.ts
+async function readServerInfo() {
+  let raw;
+  try {
+    raw = await readFile(globalServerFile(), "utf8");
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return null;
+    }
+    throw new Error(`Could not read server info at ${globalServerFile()}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+  try {
+    return parseJson(raw, isServerInfo, "server info");
+  } catch (error) {
+    throw new Error(`Invalid server info at ${globalServerFile()}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
 async function writeServerInfo(info) {
   await ensureDir(globalStateDir());
   await writeJsonFile(globalServerFile(), info);
 }
 
 // src/server/index.ts
-import { readFile as readFile3 } from "fs/promises";
-import path3 from "path";
+import { readFile as readFile4, realpath, stat } from "fs/promises";
+import path5 from "path";
 import { fileURLToPath } from "url";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
@@ -276,17 +408,11 @@ function resolutionCounts(feedback, resolvedComments = []) {
   };
 }
 
-// src/shared/reviews.ts
-function isResolvableReviewStatus(status) {
-  return status === "submitted" || status === "resolved";
-}
-
-// src/server/store.ts
-import { readdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-import { ulid } from "ulid";
+// src/shared/git-diff.ts
+import { execa } from "execa";
 
 // src/shared/language.ts
-import path2 from "path";
+import path3 from "path";
 var languageByExtension = {
   cjs: "js",
   css: "css",
@@ -308,13 +434,454 @@ var languageByExtension = {
   yml: "yaml"
 };
 function languageForPath(filePath) {
-  const ext = path2.extname(filePath).slice(1).toLowerCase();
+  const ext = path3.extname(filePath).slice(1).toLowerCase();
   if (!ext) {
     return null;
   }
   return languageByExtension[ext] ?? ext;
 }
 
+// src/shared/diff-parser.ts
+var hunkHeaderPattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
+function stripGitPath(input) {
+  return input.replace(/^[ab]\//, "");
+}
+function emptyFile() {
+  return {
+    path: "",
+    oldPath: null,
+    additions: 0,
+    deletions: 0,
+    isBinary: false,
+    isDeleted: false,
+    isNew: false,
+    isRenamed: false,
+    language: null,
+    hunks: []
+  };
+}
+function parseUnifiedDiff(diffText) {
+  const files = [];
+  let current = null;
+  let currentHunk = null;
+  let oldCursor = 0;
+  let newCursor = 0;
+  const finalizeFile = () => {
+    if (current?.path) {
+      current.language = languageForPath(current.path);
+      files.push(current);
+    }
+  };
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("diff --git ")) {
+      finalizeFile();
+      current = emptyFile();
+      currentHunk = null;
+      oldCursor = 0;
+      newCursor = 0;
+      const match = /^diff --git a\/(.+) b\/(.+)$/.exec(line);
+      if (match) {
+        current.oldPath = match[1];
+        current.path = match[2];
+      }
+      continue;
+    }
+    if (!current) {
+      continue;
+    }
+    if (line.startsWith("new file mode")) {
+      current.isNew = true;
+      continue;
+    }
+    if (line.startsWith("deleted file mode")) {
+      current.isDeleted = true;
+      continue;
+    }
+    if (line.startsWith("rename from ")) {
+      current.oldPath = line.slice("rename from ".length);
+      current.isRenamed = true;
+      continue;
+    }
+    if (line.startsWith("rename to ")) {
+      current.path = line.slice("rename to ".length);
+      current.isRenamed = true;
+      continue;
+    }
+    if (line.startsWith("Binary files ") || line.startsWith("GIT binary patch")) {
+      current.isBinary = true;
+      continue;
+    }
+    if (line.startsWith("--- ")) {
+      const oldPath = line.slice(4).trim();
+      current.oldPath = oldPath === "/dev/null" ? null : stripGitPath(oldPath);
+      continue;
+    }
+    if (line.startsWith("+++ ")) {
+      const newPath = line.slice(4).trim();
+      current.path = newPath === "/dev/null" ? current.oldPath ?? current.path : stripGitPath(newPath);
+      continue;
+    }
+    const hunkMatch = hunkHeaderPattern.exec(line);
+    if (hunkMatch) {
+      const oldStart = Number(hunkMatch[1]);
+      const oldLines = Number(hunkMatch[2] ?? "1");
+      const newStart = Number(hunkMatch[3]);
+      const newLines = Number(hunkMatch[4] ?? "1");
+      currentHunk = {
+        oldStart,
+        oldLines,
+        newStart,
+        newLines,
+        header: hunkMatch[5]?.trim() ?? "",
+        lines: []
+      };
+      current.hunks.push(currentHunk);
+      oldCursor = oldStart;
+      newCursor = newStart;
+      continue;
+    }
+    if (!currentHunk) {
+      continue;
+    }
+    const marker = line[0];
+    const content = line.slice(1);
+    let diffLine = null;
+    if (marker === "+") {
+      diffLine = { type: "add", oldLine: null, newLine: newCursor, content };
+      current.additions += 1;
+      newCursor += 1;
+    } else if (marker === "-") {
+      diffLine = { type: "delete", oldLine: oldCursor, newLine: null, content };
+      current.deletions += 1;
+      oldCursor += 1;
+    } else if (marker === " ") {
+      diffLine = { type: "context", oldLine: oldCursor, newLine: newCursor, content };
+      oldCursor += 1;
+      newCursor += 1;
+    } else if (line.startsWith("\")) {
+      continue;
+    }
+    if (diffLine) {
+      currentHunk.lines.push(diffLine);
+    }
+  }
+  finalizeFile();
+  return files;
+}
+
+// src/shared/diff-stats.ts
+function summarizeDiffFiles(files) {
+  return files.reduce(
+    (stats, file) => ({
+      files: stats.files + 1,
+      additions: stats.additions + file.additions,
+      deletions: stats.deletions + file.deletions
+    }),
+    { files: 0, additions: 0, deletions: 0 }
+  );
+}
+
+// src/shared/git-diff.ts
+var DIFF_ARGS = ["diff", "--no-color", "--find-renames", "--find-copies"];
+async function git(args, cwd) {
+  const result = await execa("git", args, { cwd });
+  return result.stdout.trimEnd();
+}
+async function captureCommitRangeDiff(fromSha, toSha, repoRoot) {
+  const rawDiff = await git([...DIFF_ARGS, `${fromSha}^`, toSha, "--"], repoRoot);
+  const files = parseUnifiedDiff(rawDiff);
+  return {
+    stats: summarizeDiffFiles(files),
+    rawDiff,
+    files
+  };
+}
+
+// src/shared/reviews.ts
+function isResolvableReviewStatus(status) {
+  return status === "submitted" || status === "resolved";
+}
+
+// src/server/local-open.ts
+import open from "open";
+async function openLocalPath(filePath) {
+  await open(filePath, { wait: false });
+}
+
+// src/server/store.ts
+import { createHash } from "crypto";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
+import path4 from "path";
+import { ulid } from "ulid";
+
+// src/shared/cleanup.ts
+import { readdir, readFile as readFile2, rm as rm2 } from "fs/promises";
+var DEFAULT_REVIEW_RETENTION_DAYS = 30;
+var clearableStatuses = /* @__PURE__ */ new Set(["submitted", "resolved", "cancelled"]);
+var millisecondsPerDay = 24 * 60 * 60 * 1e3;
+async function clearReviewArtifacts(options = {}) {
+  const olderThanDays = normalizeRetentionDays(options.olderThanDays);
+  const dryRun = options.dryRun === true;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const cutoff = new Date(now.getTime() - olderThanDays * millisecondsPerDay);
+  const reviewsDir = globalReviewsDir();
+  const candidates = [];
+  const deleted = [];
+  const skipped = [];
+  let entries;
+  try {
+    entries = await readdir(reviewsDir, { withFileTypes: true });
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return cleanupResult({
+        reviewsDir,
+        cutoff,
+        olderThanDays,
+        dryRun,
+        candidates,
+        deleted,
+        skipped
+      });
+    }
+    throw new Error(`Could not read reviews directory at ${reviewsDir}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const reviewId = entry.name;
+    const artifactDir = globalReviewDir(reviewId);
+    const candidate = await cleanupCandidate(reviewId, artifactDir, cutoff, skipped);
+    if (!candidate) {
+      continue;
+    }
+    candidates.push(candidate);
+    if (!dryRun) {
+      await rm2(artifactDir, { recursive: true, force: true });
+      deleted.push(candidate);
+    }
+  }
+  return cleanupResult({ reviewsDir, cutoff, olderThanDays, dryRun, candidates, deleted, skipped });
+}
+function normalizeRetentionDays(value) {
+  const days = value ?? DEFAULT_REVIEW_RETENTION_DAYS;
+  if (!Number.isInteger(days) || days < 0) {
+    throw new Error("olderThanDays must be a non-negative integer");
+  }
+  return days;
+}
+async function cleanupCandidate(reviewId, artifactDir, cutoff, skipped) {
+  let raw;
+  try {
+    raw = await readFile2(globalReviewMetaFile(reviewId), "utf8");
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      skipped.push({ reviewId, artifactDir, reason: "missing metadata" });
+      return null;
+    }
+    skipped.push({ reviewId, artifactDir, reason: `unreadable metadata: ${formatError(error)}` });
+    return null;
+  }
+  let meta;
+  try {
+    meta = parseJson(raw, isStoredReviewMeta, "review metadata");
+  } catch (error) {
+    skipped.push({ reviewId, artifactDir, reason: `invalid metadata: ${formatError(error)}` });
+    return null;
+  }
+  if (meta.id !== reviewId) {
+    skipped.push({ reviewId, artifactDir, reason: `metadata id mismatch: ${meta.id}` });
+    return null;
+  }
+  if (!clearableStatuses.has(meta.status)) {
+    return null;
+  }
+  const turnState = await persistedTurnCleanupState(reviewId, artifactDir, skipped);
+  if (turnState === "preserve") {
+    return null;
+  }
+  const lastActivityAt = latestTimestamp([
+    ...metadataTimestamps(meta),
+    ...turnState === "none" ? [] : turnState.timestamps
+  ]);
+  if (!lastActivityAt) {
+    skipped.push({ reviewId, artifactDir, reason: "missing valid activity timestamp" });
+    return null;
+  }
+  if (Date.parse(lastActivityAt) >= cutoff.getTime()) {
+    return null;
+  }
+  return {
+    reviewId,
+    status: meta.status,
+    artifactDir,
+    lastActivityAt
+  };
+}
+async function persistedTurnCleanupState(reviewId, artifactDir, skipped) {
+  let entries;
+  try {
+    entries = await readdir(globalReviewTurnsDir(reviewId), { withFileTypes: true });
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return "none";
+    }
+    skipped.push({
+      reviewId,
+      artifactDir,
+      reason: `unreadable turns directory: ${formatError(error)}`
+    });
+    return "preserve";
+  }
+  const turnDirs = entries.filter((entry) => entry.isDirectory());
+  if (turnDirs.length === 0) {
+    return "none";
+  }
+  const timestamps = [];
+  for (const entry of turnDirs) {
+    const turn = await readPersistedTurnMeta(reviewId, entry.name, artifactDir, skipped);
+    if (!turn) {
+      return "preserve";
+    }
+    if (turn.status === "pending" || !clearableStatuses.has(turn.status)) {
+      return "preserve";
+    }
+    timestamps.push(turn.createdAt, turn.submittedAt, turn.resolvedAt);
+  }
+  return { timestamps };
+}
+async function readPersistedTurnMeta(reviewId, turnDirName, artifactDir, skipped) {
+  let raw;
+  try {
+    raw = await readFile2(globalReviewTurnMetaFile(reviewId, turnDirName), "utf8");
+  } catch (error) {
+    skipped.push({
+      reviewId,
+      artifactDir,
+      reason: `${isFileNotFound(error) ? "missing" : "unreadable"} turn metadata for ${turnDirName}${isFileNotFound(error) ? "" : `: ${formatError(error)}`}`
+    });
+    return null;
+  }
+  try {
+    const turn = parseJson(raw, isReviewTurnMeta, "review turn metadata");
+    if (turn.id !== turnDirName) {
+      skipped.push({
+        reviewId,
+        artifactDir,
+        reason: `turn metadata id mismatch for ${turnDirName}: ${turn.id}`
+      });
+      return null;
+    }
+    return turn;
+  } catch (error) {
+    skipped.push({
+      reviewId,
+      artifactDir,
+      reason: `invalid turn metadata for ${turnDirName}: ${formatError(error)}`
+    });
+    return null;
+  }
+}
+function metadataTimestamps(meta) {
+  return [
+    meta.createdAt,
+    meta.submittedAt,
+    meta.resolvedAt,
+    ...(meta.turns ?? []).flatMap((turn) => [
+      turn.createdAt,
+      turn.capturedAt,
+      turn.submittedAt,
+      turn.resolvedAt
+    ])
+  ];
+}
+function latestTimestamp(timestamps) {
+  const latest = Math.max(
+    ...timestamps.map((timestamp) => timestamp ? Date.parse(timestamp) : Number.NaN).filter((timestamp) => Number.isFinite(timestamp))
+  );
+  return Number.isFinite(latest) ? new Date(latest).toISOString() : null;
+}
+function cleanupResult({
+  reviewsDir,
+  cutoff,
+  olderThanDays,
+  dryRun,
+  candidates,
+  deleted,
+  skipped
+}) {
+  return {
+    reviewsDir,
+    cutoff: cutoff.toISOString(),
+    olderThanDays,
+    dryRun,
+    candidates,
+    deleted,
+    skipped,
+    counts: {
+      candidates: candidates.length,
+      deleted: deleted.length,
+      skipped: skipped.length
+    }
+  };
+}
+
+// src/shared/review-scope.ts
+var ALL_REVIEW_SCOPE = { mode: "all" };
+function normalizeReviewScope(diff, scope = ALL_REVIEW_SCOPE) {
+  if (scope.mode === "all") {
+    return ALL_REVIEW_SCOPE;
+  }
+  const commitDiffs = diff.commitDiffs ?? [];
+  if (commitDiffs.length === 0) {
+    throw new Error("Review scope requires a review with per-commit diffs");
+  }
+  if (scope.mode === "single") {
+    const commit = commitDiffs.find((commitDiff) => commitDiff.commit.sha === scope.sha);
+    if (!commit) {
+      throw new Error("Review scope must use commits from this review");
+    }
+    return { mode: "single", sha: commit.commit.sha };
+  }
+  const fromIndex = commitDiffs.findIndex((commitDiff) => commitDiff.commit.sha === scope.fromSha);
+  const toIndex = commitDiffs.findIndex((commitDiff) => commitDiff.commit.sha === scope.toSha);
+  if (fromIndex < 0 || toIndex < 0) {
+    throw new Error("Review scope must use commits from this review");
+  }
+  if (fromIndex > toIndex) {
+    throw new Error("Review scope range must be in review order");
+  }
+  return {
+    mode: "range",
+    fromSha: commitDiffs[fromIndex].commit.sha,
+    toSha: commitDiffs[toIndex].commit.sha
+  };
+}
+function sameReviewScope(left, right) {
+  return JSON.stringify(left ?? ALL_REVIEW_SCOPE) === JSON.stringify(right ?? ALL_REVIEW_SCOPE);
+}
+function reviewScopeLabel(scope = ALL_REVIEW_SCOPE, commitDiffs = []) {
+  if (scope.mode === "all") {
+    return "All commits";
+  }
+  if (scope.mode === "single") {
+    const commit = commitDiffs.find((commitDiff) => commitDiff.commit.sha === scope.sha);
+    return commit ? `${commit.commit.shortSha} ${commit.commit.subject}` : `Commit ${shortSha(scope.sha)}`;
+  }
+  const fromIndex = commitDiffs.findIndex((commitDiff) => commitDiff.commit.sha === scope.fromSha);
+  const toIndex = commitDiffs.findIndex((commitDiff) => commitDiff.commit.sha === scope.toSha);
+  if (fromIndex >= 0 && toIndex >= fromIndex) {
+    const count = toIndex - fromIndex + 1;
+    return `${count} commits \xB7 ${commitDiffs[fromIndex].commit.shortSha} to ${commitDiffs[toIndex].commit.shortSha}`;
+  }
+  return `Commit range ${shortSha(scope.fromSha)} to ${shortSha(scope.toSha)}`;
+}
+function shortSha(sha) {
+  return sha.slice(0, 7);
+}
+
 // src/shared/markdown.ts
 function fenceFor(snippet) {
   let fence = "```";
@@ -329,20 +896,32 @@ function languageForSnippet(filePath, snippet) {
   return looksLikeUnifiedDiff ? "diff" : languageForPath(filePath) ?? "";
 }
 function serializeFeedbackMarkdown(bundle) {
-  const comments = [...bundle.comments].sort(compareCommentsByLocation);
-  const files = [...new Set(comments.map((comment) => comment.filePath))];
+  const comments = bundle.comments.toSorted(compareCommentsByLocation);
+  const commentsByFile = /* @__PURE__ */ new Map();
+  const files = [];
+  for (const comment of comments) {
+    const fileComments = commentsByFile.get(comment.filePath);
+    if (fileComments) {
+      fileComments.push(comment);
+    } else {
+      commentsByFile.set(comment.filePath, [comment]);
+      files.push(comment.filePath);
+    }
+  }
   const lines = [
     `# Gloss feedback - ${bundle.timestamp}`,
     `Review: ${bundle.reviewId}`,
+    ...bundle.turnIndex ? [`Turn: ${bundle.turnIndex} (${bundle.turnId ?? "unknown"})`] : [],
+    ...bundle.reviewScope ? [`Review scope: ${reviewScopeLabel(bundle.reviewScope)}`] : [],
     `Base: ${bundle.base.ref} (${bundle.base.sha.slice(0, 7)})  Branch: ${bundle.branch ?? "(detached)"}`,
     `Files: ${files.length}   Comments: ${comments.length}`,
     ""
   ];
   for (const filePath of files) {
     lines.push(`## ${filePath}`, "");
-    for (const comment of comments.filter((item) => item.filePath === filePath)) {
+    for (const comment of commentsByFile.get(filePath) ?? []) {
       const snippet = comment.originalSnippet.trimEnd();
-      const firstSnippetLine = snippet.split("\n").find((line) => line.trim().length > 0);
+      const firstSnippetLine = firstNonEmptyLine(snippet);
       const heading = comment.startLine === comment.endLine && firstSnippetLine ? `### ${formatLineRange(comment)} - \`${firstSnippetLine.trim().slice(0, 80)}\`` : `### ${formatLineRange(comment)}`;
       lines.push(heading, comment.body.trim(), "");
       if (snippet) {
@@ -354,6 +933,14 @@ function serializeFeedbackMarkdown(bundle) {
   return `${lines.join("\n").trimEnd()}
 `;
 }
+function firstNonEmptyLine(text) {
+  for (const line of text.split("\n")) {
+    if (line.trim().length > 0) {
+      return line;
+    }
+  }
+  return void 0;
+}
 
 // src/server/store.ts
 var ReviewStore = class {
@@ -362,6 +949,7 @@ var ReviewStore = class {
   async create(diff) {
     const id = ulid();
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const turn = createTurn(id, 1, diff, createdAt);
     const meta = {
       id,
       cwd: diff.cwd,
@@ -369,108 +957,197 @@ var ReviewStore = class {
       branch: diff.branch,
       status: "pending",
       createdAt,
-      artifactDir: globalReviewDir(id)
+      artifactDir: globalReviewDir(id),
+      activeTurnId: turn.id
     };
-    const record = { meta, diff };
+    const record = normalizeRecord({ meta, turns: [turn], diff: turn.diff });
     this.reviews.set(id, record);
-    await this.persistInitial(record);
+    await this.persistInitial(record, turn);
     this.emit({ type: "review.opened", reviewId: id });
     return record;
   }
+  async appendTurn(id, diff) {
+    const record = await this.get(id);
+    if (!record) {
+      throw new Error(`Review ${id} not found`);
+    }
+    if (record.meta.cwd !== diff.cwd) {
+      throw new Error(`Review ${id} belongs to ${record.meta.cwd}, not ${diff.cwd}`);
+    }
+    const latest = latestTurn(record);
+    if (latest.status === "pending") {
+      if (diffFingerprint(latest.diff) === diffFingerprint(diff)) {
+        this.emit({
+          type: "review.turn.created",
+          reviewId: id,
+          turnId: latest.id,
+          turnIndex: latest.index,
+          reused: true
+        });
+        return { record, turn: latest, reused: true };
+      }
+      throw new Error(`Review ${id} already has a pending turn`);
+    }
+    if (latest.status === "cancelled") {
+      throw new Error(`Review ${id} is cancelled and cannot be continued`);
+    }
+    const turn = createTurn(id, latest.index + 1, diff, (/* @__PURE__ */ new Date()).toISOString());
+    const nextRecord = normalizeRecord({
+      ...record,
+      meta: { ...record.meta, activeTurnId: turn.id },
+      turns: [...record.turns, turn]
+    });
+    this.reviews.set(id, nextRecord);
+    await this.persistInitial(nextRecord, turn);
+    this.emit({
+      type: "review.turn.created",
+      reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
+      reused: false
+    });
+    return { record: nextRecord, turn, reused: false };
+  }
   async list() {
     await this.loadAllReviews();
-    return [...this.reviews.values()].map((record) => record.meta).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return Array.from(this.reviews.values()).map((record) => record.meta).toSorted((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async clearReviewArtifacts(options = {}) {
+    const result = await clearReviewArtifacts(options);
+    if (!result.dryRun) {
+      for (const review of result.deleted) {
+        this.reviews.delete(review.reviewId);
+      }
+    }
+    return result;
   }
   async get(id) {
     return this.reviews.get(id) ?? await this.loadKnownReview(id);
   }
-  async submit(id, comments) {
+  async getTurn(id, turnId) {
+    const record = await this.get(id);
+    return record?.turns.find((turn) => turn.id === turnId) ?? null;
+  }
+  async submit(id, comments, reviewScope) {
     const record = await this.get(id);
     if (!record) {
       throw new Error(`Review ${id} not found`);
     }
-    if (record.meta.status !== "pending") {
-      throw new Error(`Review ${id} is ${record.meta.status} and cannot be submitted`);
+    const turn = activeTurn(record);
+    const sortedComments = comments.toSorted(compareCommentsByLocation);
+    const normalizedReviewScope = normalizeReviewScope(turn.diff, reviewScope);
+    if (turn.status !== "pending") {
+      if (turn.feedback && sameComments(turn.feedback.comments, sortedComments) && sameReviewScope(turn.feedback.reviewScope, normalizedReviewScope)) {
+        return {
+          record,
+          feedbackPath: requiredPath(turn.feedbackPath, "feedback path"),
+          markdownPath: requiredPath(turn.markdownPath, "markdown path"),
+          turn
+        };
+      }
+      throw new Error(`Review ${id} turn ${turn.index} is ${turn.status} and cannot be submitted`);
     }
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const feedbackPath = globalReviewTurnFeedbackFile(id, turn.id);
+    const markdownPath = globalReviewTurnMarkdownFile(id, turn.id);
     const feedback = {
       version: 1,
       reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
       timestamp,
-      base: record.diff.base,
-      branch: record.diff.branch,
-      comments: [...comments].sort(compareCommentsByLocation)
+      base: turn.diff.base,
+      branch: turn.diff.branch,
+      reviewScope: normalizedReviewScope,
+      comments: sortedComments
     };
-    record.feedback = feedback;
-    record.meta = { ...record.meta, status: "submitted", submittedAt: timestamp };
-    this.reviews.set(id, record);
-    const artifactDir = globalReviewDir(id);
-    const feedbackPath = globalReviewFeedbackFile(id);
-    const markdownPath = globalReviewMarkdownFile(id);
-    record.meta = {
-      ...record.meta,
-      artifactDir,
+    const nextTurn = {
+      ...turn,
+      status: "submitted",
+      submittedAt: timestamp,
       feedbackPath,
-      markdownPath
+      markdownPath,
+      feedback
     };
-    await ensureDir(artifactDir);
+    const nextRecord = normalizeRecord(replaceTurn(record, nextTurn));
+    this.reviews.set(id, nextRecord);
+    await ensureDir(globalReviewTurnDir(id, nextTurn.id));
     await Promise.all([
-      writeJsonFile(globalReviewMetaFile(id), record.meta),
+      writeJsonFile(globalReviewTurnMetaFile(id, nextTurn.id), turnMeta(nextTurn)),
       writeJsonFile(feedbackPath, feedback),
-      writeFile2(markdownPath, serializeFeedbackMarkdown(feedback))
+      writeTextFile(markdownPath, serializeFeedbackMarkdown(feedback))
     ]);
+    await this.persistMeta(nextRecord);
     this.emit({
       type: "review.submitted",
       reviewId: id,
+      turnId: nextTurn.id,
+      turnIndex: nextTurn.index,
       counts: {
         files: countCommentFiles(feedback.comments),
         comments: feedback.comments.length
       }
     });
-    return { record, feedbackPath, markdownPath };
+    return { record: nextRecord, feedbackPath, markdownPath, turn: nextTurn };
   }
   async feedback(id) {
     const record = await this.get(id);
     return record?.feedback ?? null;
   }
-  async markResolved(id, summary) {
+  async markResolved(id, summary, turnSelector) {
     const record = await this.get(id);
     if (!record) {
       throw new Error(`Review ${id} not found`);
     }
-    this.assertResolvable(record, id);
+    const turn = this.resolveTurnSelector(record, turnSelector);
+    this.assertResolvable(turn, id);
     const resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
     const existingById = new Map(
-      (record.resolution?.comments ?? []).map((comment) => [comment.commentId, comment])
+      (turn.resolution?.comments ?? []).map((comment) => [comment.commentId, comment])
     );
     const comments = this.sortResolvedComments(
-      (record.feedback?.comments ?? []).map((comment) => ({
+      (turn.feedback?.comments ?? []).map((comment) => ({
         ...existingById.get(comment.id),
         commentId: comment.id,
         status: "resolved",
         resolvedAt: existingById.get(comment.id)?.resolvedAt ?? resolvedAt
       })),
-      record
+      turn
     );
     const resolution = {
       reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
       status: "resolved",
-      summary: summary ?? record.resolution?.summary ?? null,
+      summary: summary ?? turn.resolution?.summary ?? null,
       resolvedAt,
       comments
     };
-    record.meta = { ...record.meta, status: "resolved", resolvedAt };
-    return this.persistResolution(record, resolution, "review-resolved");
+    const nextTurn = {
+      ...turn,
+      status: "resolved",
+      resolvedAt
+    };
+    return this.persistResolution(record, nextTurn, resolution, "review-resolved");
   }
   async resolveComment(id, commentId, summary) {
     const record = await this.get(id);
     if (!record) {
       throw new Error(`Review ${id} not found`);
     }
-    this.assertResolvable(record, id);
-    this.assertCommentExists(record, commentId);
+    const turn = this.findTurnForComment(record, commentId);
+    if (!turn) {
+      const currentTurn = activeTurn(record);
+      if (!isResolvableReviewStatus(currentTurn.status)) {
+        throw new Error(
+          `Review ${id} turn ${currentTurn.index} is ${currentTurn.status} and cannot be resolved`
+        );
+      }
+      throw new Error(`Comment ${commentId} not found`);
+    }
+    this.assertResolvable(turn, id);
     const resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const previous = record.resolution?.comments.find((comment) => comment.commentId === commentId);
+    const previous = turn.resolution?.comments.find((comment) => comment.commentId === commentId);
     const nextSummary = summary ?? previous?.summary;
     const nextComment = {
       commentId,
@@ -480,46 +1157,59 @@ var ReviewStore = class {
     };
     const comments = this.sortResolvedComments(
       [
-        ...(record.resolution?.comments ?? []).filter((comment) => comment.commentId !== commentId),
+        ...(turn.resolution?.comments ?? []).filter((comment) => comment.commentId !== commentId),
         nextComment
       ],
-      record
+      turn
     );
-    const counts = resolutionCounts(record.feedback, comments);
+    const counts = resolutionCounts(turn.feedback, comments);
     const fullyResolved = counts.total === counts.resolved;
     const resolution = {
       reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
       status: fullyResolved ? "resolved" : "partial",
-      summary: fullyResolved ? record.resolution?.summary ?? null : null,
+      summary: fullyResolved ? turn.resolution?.summary ?? null : null,
       resolvedAt: fullyResolved ? resolvedAt : null,
       comments
     };
-    record.meta = fullyResolved ? { ...record.meta, status: "resolved", resolvedAt } : { ...record.meta, status: "submitted", resolvedAt: void 0 };
-    return this.persistResolution(record, resolution, "comment-resolved");
+    const nextTurn = fullyResolved ? { ...turn, status: "resolved", resolvedAt } : { ...turn, status: "submitted", resolvedAt: void 0 };
+    return this.persistResolution(record, nextTurn, resolution, "comment-resolved");
   }
   async reopenComment(id, commentId) {
     const record = await this.get(id);
     if (!record) {
       throw new Error(`Review ${id} not found`);
     }
-    this.assertResolvable(record, id);
-    this.assertCommentExists(record, commentId);
+    const turn = this.findTurnForComment(record, commentId);
+    if (!turn) {
+      const currentTurn = activeTurn(record);
+      if (!isResolvableReviewStatus(currentTurn.status)) {
+        throw new Error(
+          `Review ${id} turn ${currentTurn.index} is ${currentTurn.status} and cannot be resolved`
+        );
+      }
+      throw new Error(`Comment ${commentId} not found`);
+    }
+    this.assertResolvable(turn, id);
     const comments = this.sortResolvedComments(
-      (record.resolution?.comments ?? []).filter((comment) => comment.commentId !== commentId),
-      record
+      (turn.resolution?.comments ?? []).filter((comment) => comment.commentId !== commentId),
+      turn
     );
-    const counts = resolutionCounts(record.feedback, comments);
+    const counts = resolutionCounts(turn.feedback, comments);
     const fullyResolved = counts.total > 0 && counts.total === counts.resolved;
     const resolvedAt = fullyResolved ? (/* @__PURE__ */ new Date()).toISOString() : null;
     const resolution = {
       reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
       status: fullyResolved ? "resolved" : "partial",
-      summary: fullyResolved ? record.resolution?.summary ?? null : null,
+      summary: fullyResolved ? turn.resolution?.summary ?? null : null,
       resolvedAt,
       comments
     };
-    record.meta = fullyResolved ? { ...record.meta, status: "resolved", resolvedAt: resolvedAt ?? void 0 } : { ...record.meta, status: "submitted", resolvedAt: void 0 };
-    return this.persistResolution(record, resolution, "comment-reopened");
+    const nextTurn = fullyResolved ? { ...turn, status: "resolved", resolvedAt: resolvedAt ?? void 0 } : { ...turn, status: "submitted", resolvedAt: void 0 };
+    return this.persistResolution(record, nextTurn, resolution, "comment-reopened");
   }
   subscribe(reviewId, listener) {
     const listeners = this.listeners.get(reviewId) ?? /* @__PURE__ */ new Set();
@@ -537,13 +1227,17 @@ var ReviewStore = class {
       listener(event);
     }
   }
-  async persistInitial(record) {
-    const dir = globalReviewDir(record.meta.id);
-    await ensureDir(dir);
+  async persistInitial(record, turn) {
+    await ensureDir(turn.artifactDir);
     await Promise.all([
-      writeJsonFile(globalReviewMetaFile(record.meta.id), record.meta),
-      writeJsonFile(globalReviewDiffFile(record.meta.id), record.diff)
+      writeJsonFile(globalReviewTurnMetaFile(record.meta.id, turn.id), turnMeta(turn)),
+      writeJsonFile(turn.diffPath, turn.diff)
     ]);
+    await this.persistMeta(record);
+  }
+  async persistMeta(record) {
+    await ensureDir(globalReviewDir(record.meta.id));
+    await writeJsonFile(globalReviewMetaFile(record.meta.id), record.meta);
   }
   async loadKnownReview(id) {
     const existing = this.reviews.get(id);
@@ -555,7 +1249,7 @@ var ReviewStore = class {
   async loadAllReviews() {
     let entries;
     try {
-      entries = await readdir(globalReviewsDir(), { withFileTypes: true });
+      entries = await readdir2(globalReviewsDir(), { withFileTypes: true });
     } catch (error) {
       if (isFileNotFound(error)) {
         return;
@@ -567,86 +1261,217 @@ var ReviewStore = class {
         }
       );
     }
-    await Promise.all(
-      entries.filter((entry) => entry.isDirectory()).map((entry) => this.loadReview(entry.name))
-    );
+    const reviewLoads = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        reviewLoads.push(this.loadReview(entry.name));
+      }
+    }
+    await Promise.all(reviewLoads);
   }
   async loadReview(id) {
     const metaPath = globalReviewMetaFile(id);
-    const diffPath = globalReviewDiffFile(id);
+    let metaRaw;
+    try {
+      metaRaw = await readFile3(metaPath, "utf8");
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return this.loadReviewFromTurnsOnly(id);
+      }
+      throw new Error(`Could not load review ${id}: ${formatError(error)}`, { cause: error });
+    }
+    const storedMeta = parseJsonFile(metaRaw, isStoredReviewMeta, "review metadata", metaPath);
+    const persistedTurns = await this.loadPersistedTurns(id);
+    const legacyTurn = await this.loadLegacyTurn(id, storedMeta);
+    const turns = mergeRecoveredTurns(legacyTurn, persistedTurns);
+    if (turns.length === 0) {
+      throw new Error(`Review ${id} has no recoverable turns`);
+    }
+    const latest = latestTurn({ turns });
+    const record = normalizeRecord({
+      meta: {
+        ...storedMeta,
+        artifactDir: storedMeta.artifactDir ?? globalReviewDir(id),
+        activeTurnId: latest.id
+      },
+      turns,
+      diff: latest.diff
+    });
+    this.reviews.set(id, record);
+    return record;
+  }
+  async loadReviewFromTurnsOnly(id) {
+    const turns = await this.loadPersistedTurns(id);
+    if (turns.length === 0) {
+      return null;
+    }
+    const latest = latestTurn({ turns });
+    const record = normalizeRecord({
+      meta: {
+        id,
+        cwd: latest.diff.cwd,
+        base: latest.diff.base,
+        branch: latest.diff.branch,
+        status: latest.status,
+        createdAt: turns[0]?.createdAt ?? latest.createdAt,
+        artifactDir: globalReviewDir(id),
+        activeTurnId: latest.id
+      },
+      turns,
+      diff: latest.diff
+    });
+    this.reviews.set(id, record);
+    await this.persistMeta(record);
+    return record;
+  }
+  async loadPersistedTurns(id) {
+    let entries;
+    try {
+      entries = await readdir2(globalReviewTurnsDir(id), { withFileTypes: true });
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return [];
+      }
+      throw new Error(`Could not read review turns for ${id}: ${formatError(error)}`, {
+        cause: error
+      });
+    }
+    const turns = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const turn = await this.loadPersistedTurn(id, entry.name);
+      if (turn) {
+        turns.push(turn);
+      }
+    }
+    return turns.toSorted((a, b) => a.index - b.index);
+  }
+  async loadPersistedTurn(id, turnId) {
+    const metaPath = globalReviewTurnMetaFile(id, turnId);
+    const diffPath = globalReviewTurnDiffFile(id, turnId);
     let metaRaw;
     let diffRaw;
     try {
       [metaRaw, diffRaw] = await Promise.all([
-        readFile2(metaPath, "utf8"),
-        readFile2(diffPath, "utf8")
+        readFile3(metaPath, "utf8"),
+        readFile3(diffPath, "utf8")
       ]);
     } catch (error) {
       if (isFileNotFound(error)) {
         return null;
       }
-      throw new Error(`Could not load review ${id}: ${formatError(error)}`, { cause: error });
+      throw new Error(`Could not load review ${id} turn ${turnId}: ${formatError(error)}`, {
+        cause: error
+      });
+    }
+    const meta = parseJsonFile(metaRaw, isReviewTurnMeta, "review turn metadata", metaPath);
+    const diff = parseJsonFile(diffRaw, isDiffPayload, "review turn diff", diffPath);
+    const [feedback, resolution] = await Promise.all([
+      readOptionalJsonFile(
+        globalReviewTurnFeedbackFile(id, turnId),
+        isFeedbackBundle,
+        "review feedback"
+      ),
+      readOptionalJsonFile(
+        globalReviewTurnResolvedFile(id, turnId),
+        isResolutionBundle,
+        "review resolution"
+      )
+    ]);
+    return reconcileTurn(meta, diff, feedback, resolution);
+  }
+  async loadLegacyTurn(id, storedMeta) {
+    const diffPath = globalReviewDiffFile(id);
+    let diffRaw;
+    try {
+      diffRaw = await readFile3(diffPath, "utf8");
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return null;
+      }
+      throw new Error(`Could not load legacy review ${id}: ${formatError(error)}`, {
+        cause: error
+      });
     }
-    const meta = parseJsonFile(metaRaw, isStoredReviewMeta, "review metadata", metaPath);
     const diff = parseJsonFile(diffRaw, isDiffPayload, "review diff", diffPath);
-    const feedback = await readOptionalJsonFile(
-      globalReviewFeedbackFile(id),
-      isFeedbackBundle,
-      "review feedback"
-    );
-    const resolution = await readOptionalJsonFile(
-      globalReviewResolvedFile(id),
-      isResolutionBundle,
-      "review resolution"
-    );
-    const record = {
-      meta: {
-        ...meta,
-        artifactDir: meta.artifactDir ?? globalReviewDir(id),
-        feedbackPath: meta.feedbackPath ?? (feedback ? globalReviewFeedbackFile(id) : void 0),
-        markdownPath: meta.markdownPath ?? (feedback ? globalReviewMarkdownFile(id) : void 0)
-      },
-      diff,
-      feedback,
-      resolution
+    const [feedback, resolution] = await Promise.all([
+      readOptionalJsonFile(globalReviewFeedbackFile(id), isFeedbackBundle, "review feedback"),
+      readOptionalJsonFile(globalReviewResolvedFile(id), isResolutionBundle, "review resolution")
+    ]);
+    const artifactDir = storedMeta.artifactDir ?? globalReviewDir(id);
+    const legacySummary = storedMeta.turns?.find(
+      (turn) => turn.artifactDir === artifactDir || turn.diffPath === diffPath
+    ) ?? storedMeta.turns?.find((turn) => turn.index === 1) ?? storedMeta.turns?.[0];
+    const meta = {
+      id: legacySummary?.id ?? storedMeta.activeTurnId ?? "turn-1",
+      index: legacySummary?.index ?? 1,
+      status: legacySummary?.status ?? storedMeta.status,
+      createdAt: legacySummary?.createdAt ?? storedMeta.createdAt,
+      submittedAt: legacySummary?.submittedAt ?? storedMeta.submittedAt,
+      resolvedAt: legacySummary?.resolvedAt ?? storedMeta.resolvedAt,
+      artifactDir: legacySummary?.artifactDir ?? artifactDir,
+      diffPath,
+      ...feedback ? { feedbackPath: globalReviewFeedbackFile(id), markdownPath: globalReviewMarkdownFile(id) } : {},
+      ...resolution ? { resolvedPath: globalReviewResolvedFile(id) } : {}
     };
-    this.reviews.set(id, record);
-    return record;
+    return reconcileTurn(meta, diff, feedback, resolution);
   }
-  assertResolvable(record, id) {
-    if (!isResolvableReviewStatus(record.meta.status)) {
-      throw new Error(`Review ${id} is ${record.meta.status} and cannot be resolved`);
+  assertResolvable(turn, id) {
+    if (!isResolvableReviewStatus(turn.status)) {
+      throw new Error(`Review ${id} turn ${turn.index} is ${turn.status} and cannot be resolved`);
     }
-    if (!record.feedback) {
-      throw new Error(`Review ${id} has no submitted feedback`);
+    if (!turn.feedback) {
+      throw new Error(`Review ${id} turn ${turn.index} has no submitted feedback`);
     }
   }
-  assertCommentExists(record, commentId) {
-    if (!record.feedback.comments.some((comment) => comment.id === commentId)) {
-      throw new Error(`Comment ${commentId} not found`);
+  resolveTurnSelector(record, selector) {
+    if (!selector) {
+      return activeTurn(record);
     }
+    const turn = record.turns.find((candidate) => candidate.id === selector) ?? record.turns.find((candidate) => String(candidate.index) === selector);
+    if (!turn) {
+      throw new Error(`Turn ${selector} not found in review ${record.meta.id}`);
+    }
+    return turn;
   }
-  async persistResolution(record, resolution, reason) {
-    record.resolution = resolution;
-    this.reviews.set(record.meta.id, record);
-    const resolvedPath = globalReviewResolvedFile(record.meta.id);
-    await ensureDir(globalReviewDir(record.meta.id));
+  findTurnForComment(record, commentId) {
+    return [...record.turns].reverse().find(
+      (candidate) => candidate.feedback?.comments.some((comment) => comment.id === commentId)
+    ) ?? null;
+  }
+  async persistResolution(record, turn, resolution, reason) {
+    const resolvedPath = globalReviewTurnResolvedFile(record.meta.id, turn.id);
+    const nextTurn = {
+      ...turn,
+      resolvedPath,
+      resolution
+    };
+    const nextRecord = normalizeRecord(replaceTurn(record, nextTurn));
+    this.reviews.set(record.meta.id, nextRecord);
+    await ensureDir(globalReviewTurnDir(record.meta.id, nextTurn.id));
     await Promise.all([
       writeJsonFile(resolvedPath, resolution),
-      writeJsonFile(globalReviewMetaFile(record.meta.id), record.meta)
+      writeJsonFile(globalReviewTurnMetaFile(record.meta.id, nextTurn.id), turnMeta(nextTurn))
     ]);
+    await this.persistMeta(nextRecord);
     const result = {
       ok: true,
       reviewId: record.meta.id,
-      status: record.meta.status,
+      turnId: nextTurn.id,
+      turnIndex: nextTurn.index,
+      status: nextTurn.status,
       resolutionStatus: resolution.status,
-      comments: resolutionCounts(record.feedback, resolution.comments),
+      comments: resolutionCounts(nextTurn.feedback, resolution.comments),
       path: resolvedPath,
       resolution
     };
     this.emit({
       type: "review.updated",
       reviewId: record.meta.id,
+      turnId: nextTurn.id,
+      turnIndex: nextTurn.index,
       reason,
       status: result.status,
       resolutionStatus: result.resolutionStatus,
@@ -654,19 +1479,129 @@ var ReviewStore = class {
     });
     return result;
   }
-  sortResolvedComments(comments, record) {
+  sortResolvedComments(comments, turn) {
     const feedbackIndex = new Map(
-      record.feedback.comments.map((comment, index) => [comment.id, index])
-    );
-    return comments.filter((comment) => feedbackIndex.has(comment.commentId)).sort(
-      (a, b) => (feedbackIndex.get(a.commentId) ?? Number.MAX_SAFE_INTEGER) - (feedbackIndex.get(b.commentId) ?? Number.MAX_SAFE_INTEGER)
+      turn.feedback.comments.map((comment, index) => [comment.id, index])
     );
+    return comments.map((comment) => ({ comment, index: feedbackIndex.get(comment.commentId) })).filter(
+      (entry) => entry.index !== void 0
+    ).sort((a, b) => a.index - b.index).map(({ comment }) => comment);
   }
 };
+function createTurn(reviewId, index, diff, createdAt) {
+  const id = ulid();
+  return {
+    id,
+    index,
+    status: "pending",
+    createdAt,
+    artifactDir: globalReviewTurnDir(reviewId, id),
+    diffPath: globalReviewTurnDiffFile(reviewId, id),
+    diff
+  };
+}
+function normalizeRecord(record) {
+  const turns = record.turns.toSorted((a, b) => a.index - b.index);
+  const active = turns.find((turn) => turn.id === record.meta.activeTurnId) ?? turns[turns.length - 1];
+  const meta = {
+    ...record.meta,
+    base: active.diff.base,
+    branch: active.diff.branch,
+    status: active.status,
+    submittedAt: active.submittedAt,
+    resolvedAt: active.resolvedAt,
+    artifactDir: record.meta.artifactDir ?? globalReviewDir(record.meta.id),
+    activeTurnId: active.id,
+    turns: turns.map(turnSummary),
+    feedbackPath: active.feedbackPath,
+    markdownPath: active.markdownPath
+  };
+  return {
+    meta,
+    turns,
+    diff: active.diff,
+    ...active.feedback ? { feedback: active.feedback } : {},
+    ...active.resolution ? { resolution: active.resolution } : {}
+  };
+}
+function replaceTurn(record, nextTurn) {
+  return {
+    ...record,
+    turns: record.turns.map((turn) => turn.id === nextTurn.id ? nextTurn : turn)
+  };
+}
+function activeTurn(record) {
+  return record.turns.find((turn) => turn.id === record.meta.activeTurnId) ?? record.turns[record.turns.length - 1];
+}
+function latestTurn(record) {
+  return record.turns.toSorted((a, b) => a.index - b.index)[record.turns.length - 1];
+}
+function turnMeta(turn) {
+  return {
+    id: turn.id,
+    index: turn.index,
+    status: turn.status,
+    createdAt: turn.createdAt,
+    submittedAt: turn.submittedAt,
+    resolvedAt: turn.resolvedAt,
+    artifactDir: turn.artifactDir,
+    diffPath: turn.diffPath,
+    feedbackPath: turn.feedbackPath,
+    markdownPath: turn.markdownPath,
+    resolvedPath: turn.resolvedPath
+  };
+}
+function turnSummary(turn) {
+  return {
+    ...turnMeta(turn),
+    capturedAt: turn.diff.capturedAt,
+    stats: turn.diff.stats,
+    comments: resolutionCounts(turn.feedback, turn.resolution?.comments ?? [])
+  };
+}
+function reconcileTurn(meta, diff, feedback, resolution) {
+  const status = resolution?.status === "resolved" ? "resolved" : feedback ? "submitted" : "pending";
+  return {
+    ...meta,
+    status,
+    submittedAt: feedback?.timestamp ?? meta.submittedAt,
+    resolvedAt: status === "resolved" ? resolution?.resolvedAt ?? meta.resolvedAt : void 0,
+    feedbackPath: feedback ? meta.feedbackPath ?? path4.join(meta.artifactDir, "feedback.json") : void 0,
+    markdownPath: feedback ? meta.markdownPath ?? path4.join(meta.artifactDir, "feedback.md") : void 0,
+    resolvedPath: resolution ? meta.resolvedPath ?? path4.join(meta.artifactDir, "resolved.json") : void 0,
+    diff,
+    ...feedback ? { feedback } : {},
+    ...resolution ? { resolution } : {}
+  };
+}
+function mergeRecoveredTurns(legacyTurn, persistedTurns) {
+  const turns = legacyTurn && !persistedTurns.some((turn) => turn.id === legacyTurn.id || turn.index === legacyTurn.index) ? [legacyTurn, ...persistedTurns] : persistedTurns;
+  return turns.toSorted((a, b) => a.index - b.index);
+}
+function diffFingerprint(diff) {
+  return createHash("sha256").update(
+    JSON.stringify({
+      base: diff.base,
+      branch: diff.branch,
+      cwd: diff.cwd,
+      scope: diff.scope,
+      rawDiff: diff.rawDiff
+    })
+  ).digest("hex");
+}
+function sameComments(left, right) {
+  return JSON.stringify(left.toSorted(compareCommentsByLocation)) === JSON.stringify(right.toSorted(compareCommentsByLocation));
+}
+function requiredPath(value, label) {
+  if (!value) {
+    throw new Error(`Submitted review is missing ${label}`);
+  }
+  return value;
+}
 async function readOptionalJsonFile(filePath, guard, label) {
   let raw;
   try {
-    raw = await readFile2(filePath, "utf8");
+    raw = await readFile3(filePath, "utf8");
   } catch (error) {
     if (isFileNotFound(error)) {
       return void 0;
@@ -684,12 +1619,6 @@ function parseJsonFile(raw, guard, label, filePath) {
     throw new Error(`Invalid ${label} at ${filePath}: ${formatError(error)}`, { cause: error });
   }
 }
-function isFileNotFound(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 var reviewStore = new ReviewStore();
 
 // src/server/index.ts
@@ -705,7 +1634,7 @@ var mimeTypes = {
   ".sh": "text/x-shellscript; charset=utf-8",
   ".svg": "image/svg+xml"
 };
-function createApp(origin2) {
+function createApp(origin2, options = {}) {
   const app = new Hono();
   app.get("/api/health", async (c) => {
     const reviews = await reviewStore.list();
@@ -720,6 +1649,15 @@ function createApp(origin2) {
     const response = { reviews: await reviewStore.list() };
     return c.json(response);
   });
+  app.post("/api/maintenance/clear-reviews", async (c) => {
+    const parsed = await readJsonBody(c, isClearReviewsRequest, "clear reviews request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const body = parsed.body;
+    const result = await reviewStore.clearReviewArtifacts(body);
+    return c.json(result);
+  });
   app.post("/api/reviews", async (c) => {
     const parsed = await readJsonBody(c, isDiffPayload, "review diff");
     if (!parsed.ok) {
@@ -729,10 +1667,36 @@ function createApp(origin2) {
     const record = await reviewStore.create(diff);
     const response = {
       meta: record.meta,
+      turn: activeTurnSummary(record.meta),
       url: `${origin2}/review/${record.meta.id}`
     };
+    options.onReviewActivity?.();
     return c.json(response, 201);
   });
+  app.post("/api/reviews/:id/turns", async (c) => {
+    const id = c.req.param("id");
+    const existing = await reviewStore.get(id);
+    if (!existing) {
+      return c.json({ error: "review not found" }, 404);
+    }
+    const parsed = await readJsonBody(c, isDiffPayload, "review diff");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    try {
+      const { record, turn, reused } = await reviewStore.appendTurn(id, parsed.body);
+      const response = {
+        meta: record.meta,
+        turn: turnSummary2(record.meta, turn.id),
+        url: `${origin2}/review/${id}`,
+        reused
+      };
+      options.onReviewActivity?.();
+      return c.json(response);
+    } catch (error) {
+      return c.json({ error: formatError(error) }, 409);
+    }
+  });
   app.get("/api/reviews/:id", async (c) => {
     const record = await reviewStore.get(c.req.param("id"));
     if (!record) {
@@ -740,6 +1704,13 @@ function createApp(origin2) {
     }
     return c.json(record);
   });
+  app.get("/api/reviews/:id/turns/:turnId", async (c) => {
+    const turn = await reviewStore.getTurn(c.req.param("id"), c.req.param("turnId"));
+    if (!turn) {
+      return c.json({ error: "turn not found" }, 404);
+    }
+    return c.json(turn);
+  });
   app.get("/api/reviews/:id/feedback", async (c) => {
     const feedback = await reviewStore.feedback(c.req.param("id"));
     if (!feedback) {
@@ -758,6 +1729,7 @@ function createApp(origin2) {
       let pending = Promise.resolve();
       let cleanup = null;
       let close = null;
+      let unregisterEventStream = null;
       const closedPromise = new Promise((resolve) => {
         close = () => {
           if (closed) {
@@ -768,6 +1740,7 @@ function createApp(origin2) {
           resolve();
         };
       });
+      unregisterEventStream = options.registerEventStream?.(() => close?.()) ?? null;
       const send = (event) => {
         pending = pending.then(() => stream.writeSSE({ data: JSON.stringify(event) })).then(() => {
           if (event.type === "review.cancelled") {
@@ -788,6 +1761,8 @@ function createApp(origin2) {
       cleanup = () => {
         clearInterval(heartbeat);
         unsubscribe();
+        unregisterEventStream?.();
+        unregisterEventStream = null;
       };
       stream.onAbort(() => close?.());
       send({ type: "review.opened", reviewId: id });
@@ -795,6 +1770,8 @@ function createApp(origin2) {
         send({
           type: "review.submitted",
           reviewId: id,
+          turnId: record.meta.activeTurnId,
+          turnIndex: record.meta.turns?.find((turn) => turn.id === record.meta.activeTurnId)?.index,
           counts: {
             files: countCommentFiles(record.feedback.comments),
             comments: record.feedback.comments.length
@@ -810,44 +1787,151 @@ function createApp(origin2) {
     if (!existing) {
       return c.json({ error: "review not found" }, 404);
     }
-    if (existing.meta.status !== "pending") {
-      return c.json({ error: `review is ${existing.meta.status} and cannot be submitted` }, 409);
-    }
     const parsed = await readJsonBody(c, isSubmitReviewRequest, "submit review request");
     if (!parsed.ok) {
       return parsed.response;
     }
     const body = parsed.body;
-    const { record, feedbackPath, markdownPath } = await reviewStore.submit(id, body.comments);
+    let submitted;
+    try {
+      submitted = await reviewStore.submit(id, body.comments, body.reviewScope);
+    } catch (error) {
+      return c.json({ error: formatError(error) }, 409);
+    }
+    const { feedbackPath, markdownPath, turn } = submitted;
     const response = {
       reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
       url: `${origin2}/review/${id}`,
-      files: record.diff.files.length,
+      files: turn.diff.files.length,
       comments: body.comments.length,
-      artifactDir: record.meta.artifactDir,
+      artifactDir: turn.artifactDir,
       feedbackPath,
       markdownPath
     };
+    options.onReviewActivity?.();
     return c.json(response);
   });
-  app.post("/api/reviews/:id/resolved", async (c) => {
+  app.post("/api/reviews/:id/commits/range", async (c) => {
     const id = c.req.param("id");
     const existing = await reviewStore.get(id);
     if (!existing) {
       return c.json({ error: "review not found" }, 404);
     }
-    if (!isResolvableReviewStatus(existing.meta.status)) {
-      return c.json({ error: `review is ${existing.meta.status} and cannot be resolved` }, 409);
+    const parsed = await readJsonBody(c, isCommitRangeDiffRequest, "commit range diff request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const requestedTurnId = parsed.body.turnId;
+    const turn = requestedTurnId ? await reviewStore.getTurn(id, requestedTurnId) : null;
+    if (requestedTurnId && !turn) {
+      return c.json({ error: "turn not found" }, 404);
     }
-    if (!existing.feedback) {
-      return c.json({ error: "submitted feedback not found" }, 409);
+    const diffPayload = turn?.diff ?? existing.diff;
+    const commitDiffs = diffPayload.commitDiffs ?? [];
+    if (commitDiffs.length === 0) {
+      return c.json({ error: "commit ranges are only available for branch reviews" }, 409);
+    }
+    const { fromSha, toSha } = parsed.body;
+    const fromIndex = commitDiffs.findIndex((commitDiff) => commitDiff.commit.sha === fromSha);
+    const toIndex = commitDiffs.findIndex((commitDiff) => commitDiff.commit.sha === toSha);
+    if (fromIndex < 0 || toIndex < 0) {
+      return c.json({ error: "commit range must use commits from this review" }, 404);
+    }
+    if (fromIndex > toIndex) {
+      return c.json({ error: "fromSha must come before or match toSha" }, 400);
+    }
+    const diff = fromSha === toSha ? commitDiffs[fromIndex] : await captureCommitRangeDiff(fromSha, toSha, diffPayload.cwd);
+    const response = {
+      fromSha,
+      toSha,
+      stats: diff.stats,
+      rawDiff: diff.rawDiff,
+      files: diff.files
+    };
+    return c.json(response);
+  });
+  app.post("/api/reviews/:id/files/open", async (c) => {
+    const id = c.req.param("id");
+    const existing = await reviewStore.get(id);
+    if (!existing) {
+      return c.json({ error: "review not found" }, 404);
+    }
+    const parsed = await readJsonBody(c, isOpenFileRequest, "open file request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const { filePath, turnId } = parsed.body;
+    if (!filePath || filePath.includes("\0") || path5.isAbsolute(filePath)) {
+      return c.json({ error: "filePath must be a repo-relative path" }, 400);
+    }
+    const repoRoot = path5.resolve(existing.diff.cwd);
+    const requestedAbsolutePath = path5.resolve(repoRoot, filePath);
+    if (!isPathWithin(repoRoot, requestedAbsolutePath)) {
+      return c.json({ error: "filePath must stay within the review cwd" }, 400);
+    }
+    const turn = turnId ? await reviewStore.getTurn(id, turnId) : null;
+    if (turnId && !turn) {
+      return c.json({ error: "turn not found" }, 404);
+    }
+    const diffPayload = turn?.diff ?? existing.diff;
+    const reviewFiles = [
+      ...diffPayload.files,
+      ...(diffPayload.commitDiffs ?? []).flatMap((commitDiff) => commitDiff.files)
+    ].filter((file) => file.path === filePath);
+    if (reviewFiles.length === 0) {
+      return c.json({ error: "file is not part of this review" }, 404);
+    }
+    if (reviewFiles.every((file) => file.isDeleted)) {
+      return c.json({ error: "deleted files cannot be opened locally" }, 409);
+    }
+    let realRepoRoot;
+    let realFilePath;
+    try {
+      [realRepoRoot, realFilePath] = await Promise.all([
+        realpath(repoRoot),
+        realpath(requestedAbsolutePath)
+      ]);
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return c.json({ error: "file no longer exists on disk" }, 404);
+      }
+      throw error;
+    }
+    if (!isPathWithin(realRepoRoot, realFilePath)) {
+      return c.json({ error: "filePath must stay within the review cwd" }, 400);
+    }
+    const fileStats = await stat(realFilePath);
+    if (!fileStats.isFile()) {
+      return c.json({ error: "path is not a file" }, 409);
+    }
+    try {
+      await openLocalPath(realFilePath);
+    } catch (error) {
+      return c.json({ error: `could not open file: ${formatError(error)}` }, 500);
+    }
+    const response = { ok: true, path: realFilePath };
+    return c.json(response);
+  });
+  app.post("/api/reviews/:id/resolved", async (c) => {
+    const id = c.req.param("id");
+    const existing = await reviewStore.get(id);
+    if (!existing) {
+      return c.json({ error: "review not found" }, 404);
     }
     const parsed = await readJsonBody(c, isResolutionRequest, "resolution request");
     if (!parsed.ok) {
       return parsed.response;
     }
     const body = parsed.body;
-    return c.json(await reviewStore.markResolved(id, body.summary));
+    try {
+      const result = await reviewStore.markResolved(id, body.summary, body.turn);
+      options.onReviewActivity?.();
+      return c.json(result);
+    } catch (error) {
+      return c.json({ error: formatError(error) }, statusForStoreError(error));
+    }
   });
   app.post("/api/reviews/:id/comments/:commentId/resolved", async (c) => {
     const id = c.req.param("id");
@@ -856,18 +1940,18 @@ function createApp(origin2) {
     if (!existing) {
       return c.json({ error: "review not found" }, 404);
     }
-    if (!isResolvableReviewStatus(existing.meta.status)) {
-      return c.json({ error: `review is ${existing.meta.status} and cannot be resolved` }, 409);
-    }
-    if (!existing.feedback?.comments.some((comment) => comment.id === commentId)) {
-      return c.json({ error: "comment not found" }, 404);
-    }
     const parsed = await readJsonBody(c, isResolutionRequest, "resolution request");
     if (!parsed.ok) {
       return parsed.response;
     }
     const body = parsed.body;
-    return c.json(await reviewStore.resolveComment(id, commentId, body.summary));
+    try {
+      const result = await reviewStore.resolveComment(id, commentId, body.summary);
+      options.onReviewActivity?.();
+      return c.json(result);
+    } catch (error) {
+      return c.json({ error: formatError(error) }, statusForStoreError(error));
+    }
   });
   app.delete("/api/reviews/:id/comments/:commentId/resolved", async (c) => {
     const id = c.req.param("id");
@@ -876,13 +1960,13 @@ function createApp(origin2) {
     if (!existing) {
       return c.json({ error: "review not found" }, 404);
     }
-    if (!isResolvableReviewStatus(existing.meta.status)) {
-      return c.json({ error: `review is ${existing.meta.status} and cannot be resolved` }, 409);
-    }
-    if (!existing.feedback?.comments.some((comment) => comment.id === commentId)) {
-      return c.json({ error: "comment not found" }, 404);
+    try {
+      const result = await reviewStore.reopenComment(id, commentId);
+      options.onReviewActivity?.();
+      return c.json(result);
+    } catch (error) {
+      return c.json({ error: formatError(error) }, statusForStoreError(error));
     }
-    return c.json(await reviewStore.reopenComment(id, commentId));
   });
   app.get("/logo.svg", serveRootFile("logo.svg", mimeTypes[".svg"]));
   app.get("/logo-mark.svg", serveRootFile("logo-mark.svg", mimeTypes[".svg"]));
@@ -899,37 +1983,46 @@ function createApp(origin2) {
 }
 async function serveAsset(c) {
   const requestPath = new URL(c.req.url).pathname.replace(/^\/assets\//, "");
-  const normalized = path3.normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, "");
-  const assetPath = path3.join(webRoot, "assets", normalized);
+  const normalized = path5.normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, "");
+  const assetPath = path5.join(webRoot, "assets", normalized);
   try {
-    const body = await readFile3(assetPath);
+    const body = await readFile4(assetPath);
     return new Response(body, {
       headers: {
-        "content-type": mimeTypes[path3.extname(assetPath)] ?? "application/octet-stream"
+        "content-type": mimeTypes[path5.extname(assetPath)] ?? "application/octet-stream"
       }
     });
-  } catch {
+  } catch (error) {
+    if (!isFileNotFound(error)) {
+      throw error;
+    }
     return new Response("Not found", { status: 404 });
   }
 }
 async function serveIndex() {
   try {
-    const body = await readFile3(path3.join(webRoot, "index.html"));
+    const body = await readFile4(path5.join(webRoot, "index.html"));
     return new Response(body, {
       headers: { "content-type": "text/html; charset=utf-8" }
     });
-  } catch {
+  } catch (error) {
+    if (!isFileNotFound(error)) {
+      throw error;
+    }
     return new Response("Gloss web assets are missing. Run pnpm build.", { status: 500 });
   }
 }
 function serveRootFile(fileName, contentType) {
   return async () => {
     try {
-      const body = await readFile3(path3.join(webRoot, fileName));
+      const body = await readFile4(path5.join(webRoot, fileName));
       return new Response(body, {
         headers: { "content-type": contentType }
       });
-    } catch {
+    } catch (error) {
+      if (!isFileNotFound(error)) {
+        throw error;
+      }
       return new Response(`${fileName} is missing. Run pnpm build.`, { status: 404 });
     }
   };
@@ -941,7 +2034,7 @@ async function readJsonBody(c, guard, label) {
   } catch (error) {
     return {
       ok: false,
-      response: c.json({ error: `invalid JSON body: ${formatError2(error)}` }, 400)
+      response: c.json({ error: `invalid JSON body: ${formatError(error)}` }, 400)
     };
   }
   try {
@@ -949,22 +2042,77 @@ async function readJsonBody(c, guard, label) {
   } catch (error) {
     return {
       ok: false,
-      response: c.json({ error: formatError2(error) }, 400)
+      response: c.json({ error: formatError(error) }, 400)
     };
   }
 }
-function formatError2(error) {
-  return error instanceof Error ? error.message : String(error);
+function isPathWithin(parentPath, childPath) {
+  const relative = path5.relative(parentPath, childPath);
+  return relative === "" || !relative.startsWith("..") && !path5.isAbsolute(relative);
+}
+function activeTurnSummary(meta) {
+  if (!meta.activeTurnId) {
+    throw new Error(`Review ${meta.id} has no active turn`);
+  }
+  return turnSummary2(meta, meta.activeTurnId);
+}
+function turnSummary2(meta, turnId) {
+  const summary = meta.turns?.find((turn) => turn.id === turnId);
+  if (!summary) {
+    throw new Error(`Review ${meta.id} is missing turn ${turnId}`);
+  }
+  return summary;
+}
+function statusForStoreError(error) {
+  return /not found/i.test(formatError(error)) ? 404 : 409;
+}
+
+// src/server/maintenance.ts
+var defaultLogger = {
+  info: (message) => {
+    process.stdout.write(`${message}
+`);
+  },
+  error: (message) => {
+    process.stderr.write(`${message}
+`);
+  }
+};
+async function runStartupCleanup(logger = defaultLogger) {
+  try {
+    const result = await reviewStore.clearReviewArtifacts({
+      olderThanDays: DEFAULT_REVIEW_RETENTION_DAYS
+    });
+    logger.info(
+      `Gloss cleanup deleted ${result.counts.deleted} review artifact(s); skipped ${result.counts.skipped}`
+    );
+  } catch (error) {
+    logger.error(`Gloss cleanup failed: ${formatError(error)}`);
+  }
 }
 
 // src/server/daemon.ts
 var port = Number(process.env.GLOSS_PORT ?? "0");
+var idleTimeoutMs = Number(process.env.GLOSS_IDLE_TIMEOUT_MS ?? "120000");
 if (!port) {
   throw new Error("GLOSS_PORT is required");
 }
 var origin = `http://localhost:${port}`;
+var eventStreams = /* @__PURE__ */ new Set();
+var idleTimer = null;
+var shuttingDown = false;
 var server = serve({
-  fetch: createApp(origin).fetch,
+  fetch: createApp(origin, {
+    onReviewActivity: () => {
+      void scheduleIdleShutdown();
+    },
+    registerEventStream: (close) => {
+      eventStreams.add(close);
+      return () => {
+        eventStreams.delete(close);
+      };
+    }
+  }).fetch,
   port
 });
 await writeServerInfo({
@@ -974,9 +2122,65 @@ await writeServerInfo({
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   stateDir: globalStateDir()
 });
-process.on("SIGTERM", () => {
-  server.close(() => {
-    process.exit(0);
+await runStartupCleanup();
+await scheduleIdleShutdown();
+for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+  process.on(signal, () => {
+    void shutdown(0);
   });
-});
+}
+async function scheduleIdleShutdown() {
+  if (shuttingDown || idleTimeoutMs <= 0) {
+    return;
+  }
+  const activeReviews = await countActiveReviews();
+  if (activeReviews > 0) {
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    return;
+  }
+  if (!idleTimer) {
+    idleTimer = setTimeout(() => {
+      idleTimer = null;
+      void shutdownIfIdle();
+    }, idleTimeoutMs);
+  }
+}
+async function shutdownIfIdle() {
+  if (await countActiveReviews() > 0) {
+    await scheduleIdleShutdown();
+    return;
+  }
+  await shutdown(0);
+}
+async function countActiveReviews() {
+  const reviews = await reviewStore.list();
+  return reviews.filter((review) => review.status === "pending").length;
+}
+async function shutdown(exitCode) {
+  if (shuttingDown) {
+    return;
+  }
+  shuttingDown = true;
+  if (idleTimer) {
+    clearTimeout(idleTimer);
+    idleTimer = null;
+  }
+  for (const close of [...eventStreams]) {
+    close();
+  }
+  await new Promise((resolve) => {
+    server.close(() => resolve());
+  });
+  await removeCurrentServerInfo();
+  process.exit(exitCode);
+}
+async function removeCurrentServerInfo() {
+  const info = await readServerInfo().catch(() => null);
+  if (!info || info.pid === process.pid) {
+    await rm3(globalServerFile(), { force: true });
+  }
+}
 //# sourceMappingURL=daemon.js.map