getgloss 0.7.1 → 0.8.0

package/dist/cli/index.js

@@ -12,7 +12,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.7.1",
+  version: "0.8.0",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -43,6 +43,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",
@@ -52,6 +54,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"
   },
@@ -117,6 +120,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");
 }
@@ -169,7 +193,7 @@ function languageForPath(filePath) {
   return languageByExtension[ext] ?? ext;
 }
 
-// src/cli/diff-parser.ts
+// src/shared/diff-parser.ts
 var hunkHeaderPattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
 function stripGitPath(input) {
   return input.replace(/^[ab]\//, "");
@@ -297,6 +321,18 @@ function parseUnifiedDiff(diffText) {
   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/cli/git.ts
 var DIFF_ARGS = ["diff", "--no-color", "--find-renames", "--find-copies"];
 async function git(args, cwd = process.cwd()) {
@@ -317,16 +353,6 @@ async function gitLenient(args, cwd) {
 async function getRepoRoot(cwd = process.cwd()) {
   return git(["rev-parse", "--show-toplevel"], cwd);
 }
-function summarize(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 }
-  );
-}
 function buildPayload({
   repoRoot,
   branch,
@@ -335,7 +361,8 @@ function buildPayload({
   mode,
   requestedBase,
   comparison,
-  fallbackReason
+  fallbackReason,
+  commitDiffs
 }) {
   const files = parseUnifiedDiff(rawDiff);
   return {
@@ -349,9 +376,10 @@ function buildPayload({
       comparison,
       fallbackReason
     },
-    stats: summarize(files),
+    stats: summarizeDiffFiles(files),
     rawDiff,
     files,
+    ...commitDiffs ? { commitDiffs } : {},
     capturedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
@@ -407,6 +435,52 @@ async function resolveBranchBase(repoRoot) {
   }
   return null;
 }
+async function captureCommitDiffs(baseSha, comparisonRef, repoRoot) {
+  const rawLog = await gitMaybe(
+    [
+      "log",
+      "--reverse",
+      "--format=%H%x00%h%x00%an%x00%ae%x00%aI%x00%cI%x00%s%x1e",
+      `${baseSha}..${comparisonRef}`
+    ],
+    repoRoot
+  );
+  if (!rawLog) {
+    return [];
+  }
+  const commits = rawLog.split("").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+    const [
+      sha = "",
+      shortSha2 = "",
+      authorName = "",
+      authorEmail = "",
+      authoredAt = "",
+      committedAt = "",
+      ...subjectParts
+    ] = entry.split("\0");
+    return {
+      sha,
+      shortSha: shortSha2,
+      subject: subjectParts.join("\0"),
+      authorName,
+      authorEmail,
+      authoredAt,
+      committedAt
+    };
+  }).filter((commit) => commit.sha && commit.shortSha);
+  const commitDiffs = [];
+  for (const commit of commits) {
+    const rawDiff = await git([...DIFF_ARGS, `${commit.sha}^`, commit.sha, "--"], repoRoot);
+    const files = parseUnifiedDiff(rawDiff);
+    commitDiffs.push({
+      commit,
+      stats: summarizeDiffFiles(files),
+      rawDiff,
+      files
+    });
+  }
+  return commitDiffs;
+}
 async function captureDiff(baseRef, cwd = process.cwd()) {
   const repoRoot = await getRepoRoot(cwd);
   const [headSha, branch] = await Promise.all([
@@ -455,7 +529,10 @@ async function captureDiff(baseRef, cwd = process.cwd()) {
       fallbackReason: "missing-branch-base"
     });
   }
-  const rawDiff = await git([...DIFF_ARGS, branchBase.mergeBaseSha, "HEAD", "--"], repoRoot);
+  const [rawDiff, commitDiffs] = await Promise.all([
+    git([...DIFF_ARGS, branchBase.mergeBaseSha, "HEAD", "--"], repoRoot),
+    captureCommitDiffs(branchBase.mergeBaseSha, "HEAD", repoRoot)
+  ]);
   return buildPayload({
     repoRoot,
     branch,
@@ -464,7 +541,8 @@ async function captureDiff(baseRef, cwd = process.cwd()) {
     mode: "branch",
     requestedBase: null,
     comparison: { ref: "HEAD", sha: headSha },
-    fallbackReason: "working-tree-clean"
+    fallbackReason: "working-tree-clean",
+    commitDiffs
   });
 }
 async function assertGitAvailable() {
@@ -472,33 +550,66 @@ async function assertGitAvailable() {
 }
 
 // src/cli/lifecycle.ts
-import { spawn } from "child_process";
-import { existsSync, openSync } from "fs";
-import { rm } from "fs/promises";
+import { execFile, spawn } from "child_process";
+import { closeSync, existsSync, openSync } from "fs";
+import { rm as rm2 } from "fs/promises";
+import { userInfo } from "os";
 import { fileURLToPath } from "url";
+import { promisify } from "util";
 import getPort from "get-port";
 
 // 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 path3 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 = path3.join(
+    path3.dirname(filePath),
+    `.${path3.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"];
+var REVIEW_UPDATE_REASONS = [
+  "review-resolved",
+  "comment-resolved",
+  "comment-reopened",
+  "turn-created"
+];
+
 // src/shared/validation.ts
-var reviewStatuses = ["pending", "submitted", "cancelled", "resolved"];
-var resolutionStatuses = ["partial", "resolved"];
-var reviewUpdateReasons = ["review-resolved", "comment-resolved", "comment-reopened"];
-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);
@@ -516,34 +627,46 @@ function isHealthResponse(value) {
   return isRecord(value) && isBoolean(value.ok) && isString(value.version) && isNumber(value.activeReviews);
 }
 function isCreateReviewResponse(value) {
-  return isRecord(value) && isReviewMeta(value.meta) && isString(value.url);
+  return isRecord(value) && hasReviewRegistrationFields(value) && isOptional(value.turn, isReviewTurnSummary);
+}
+function isCreateReviewTurnResponse(value) {
+  return isRecord(value) && hasReviewRegistrationFields(value) && isReviewTurnSummary(value.turn) && isBoolean(value.reused);
 }
 function isListReviewsResponse(value) {
   return isRecord(value) && isArrayOf(value.reviews, isReviewMeta);
 }
 function isOpenResult(value) {
-  return isRecord(value) && isString(value.reviewId) && isString(value.url) && isNumber(value.files) && isOptionalNumber(value.comments) && isOptionalString(value.feedbackPath) && isOptionalString(value.markdownPath) && isOptionalString(value.artifactDir);
+  return isRecord(value) && isString(value.reviewId) && isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isString(value.url) && isNumber(value.files) && isOptionalNumber(value.comments) && isOptionalString(value.feedbackPath) && isOptionalString(value.markdownPath) && isOptionalString(value.artifactDir);
 }
 function isResolveResult(value) {
-  return isRecord(value) && value.ok === true && isString(value.reviewId) && isReviewStatus(value.status) && isResolutionStatus(value.resolutionStatus) && isResolutionCounts(value.comments) && isString(value.path) && isResolutionBundle(value.resolution);
+  return isRecord(value) && value.ok === true && isString(value.reviewId) && isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isReviewStatus(value.status) && isResolutionStatus(value.resolutionStatus) && isResolutionCounts(value.comments) && isString(value.path) && isResolutionBundle(value.resolution);
 }
 function isReviewRecord(value) {
-  return isRecord(value) && isReviewMeta(value.meta) && isDiffPayload(value.diff) && isOptional(value.feedback, isFeedbackBundle) && isOptional(value.resolution, isResolutionBundle);
+  return isRecord(value) && isReviewMeta(value.meta) && isArrayOf(value.turns, isReviewTurn) && isDiffPayload(value.diff) && isOptional(value.feedback, isFeedbackBundle) && isOptional(value.resolution, isResolutionBundle);
 }
 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 isReviewMeta(value) {
   return isStoredReviewMeta(value) && isString(value.artifactDir);
 }
+function hasReviewRegistrationFields(value) {
+  return isReviewMeta(value.meta) && isString(value.url);
+}
 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 isReviewEvent(value) {
   if (!isRecord(value) || !isString(value.reviewId) || !isString(value.type)) {
@@ -553,16 +676,33 @@ function isReviewEvent(value) {
     case "review.opened":
     case "review.cancelled":
       return true;
+    case "review.turn.created":
+      return isString(value.turnId) && isNumber(value.turnIndex) && isBoolean(value.reused);
     case "review.submitted":
-      return isRecord(value.counts) && isNumber(value.counts.files) && isNumber(value.counts.comments);
+      return isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isRecord(value.counts) && isNumber(value.counts.files) && isNumber(value.counts.comments);
     case "review.updated":
-      return isReviewUpdateReason(value.reason) && isReviewStatus(value.status) && isResolutionStatus(value.resolutionStatus) && isResolutionCounts(value.counts);
+      return isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isReviewUpdateReason(value.reason) && isReviewStatus(value.status) && isResolutionStatus(value.resolutionStatus) && isResolutionCounts(value.counts);
     default:
       return false;
   }
 }
+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 isReviewTurn(value) {
+  if (!isRecord(value) || !isReviewTurnMeta(value)) {
+    return false;
+  }
+  return isDiffPayload(value.diff) && isOptional(value.feedback, isFeedbackBundle) && isOptional(value.resolution, isResolutionBundle);
+}
 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);
@@ -573,6 +713,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);
 }
@@ -580,10 +739,10 @@ 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);
@@ -592,13 +751,13 @@ 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 isReviewUpdateReason(value) {
-  return isOneOf(value, reviewUpdateReasons);
+  return isOneOf(value, REVIEW_UPDATE_REASONS);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -659,12 +818,6 @@ async function writeServerInfo(info) {
   await ensureDir(globalStateDir());
   await writeJsonFile(globalServerFile(), info);
 }
-function isFileNotFound(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function formatError(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 
 // src/cli/server-client.ts
 var ServerClient = class {
@@ -678,6 +831,14 @@ var ServerClient = class {
   async createReview(diff) {
     return this.post("/api/reviews", diff, isCreateReviewResponse, "create review response");
   }
+  async appendReviewTurn(reviewId, diff) {
+    return this.post(
+      `/api/reviews/${reviewId}/turns`,
+      diff,
+      isCreateReviewTurnResponse,
+      "create review turn response"
+    );
+  }
   async getReview(reviewId) {
     return this.get(`/api/reviews/${reviewId}`, isReviewRecord, "review response");
   }
@@ -687,8 +848,8 @@ var ServerClient = class {
   async getFeedback(reviewId) {
     return this.get(`/api/reviews/${reviewId}/feedback`, isFeedbackBundle, "feedback response");
   }
-  async markResolved(reviewId, summary) {
-    const request = { summary };
+  async markResolved(reviewId, summary, turn) {
+    const request = { summary, turn };
     return this.post(
       `/api/reviews/${reviewId}/resolved`,
       request,
@@ -778,20 +939,20 @@ var ServerClient = class {
       }
     }
   }
-  async get(path3, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path3}`);
+  async get(path5, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path5}`);
     return parseResponse(response, guard, label);
   }
-  async post(path3, body, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path3}`, {
+  async post(path5, body, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path5}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body)
     });
     return parseResponse(response, guard, label);
   }
-  async delete(path3, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path3}`, { method: "DELETE" });
+  async delete(path5, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path5}`, { method: "DELETE" });
     return parseResponse(response, guard, label);
   }
 };
@@ -806,13 +967,16 @@ function isPrematureWatchEnd(error) {
   return error instanceof Error && error.message === "watch stream ended before completion";
 }
 function isAbortError(error) {
-  return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+  return error instanceof Error && error.name === "AbortError";
 }
 async function sleep(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
 // src/cli/lifecycle.ts
+var execFileAsync = promisify(execFile);
+var gracefulShutdownTimeoutMs = 2e3;
+var forceShutdownTimeoutMs = 1e3;
 function serverUrl(info) {
   return `http://localhost:${info.port}`;
 }
@@ -839,9 +1003,23 @@ async function startServer(options = {}) {
   if (existing && await isServerResponsive(existing)) {
     return existing;
   }
+  if (existing) {
+    await retireServer(existing);
+  }
+  const preferredPort = options.port ?? existing?.port ?? await getPort();
+  try {
+    return await launchServer(preferredPort);
+  } catch (error) {
+    if (options.port || !existing?.port) {
+      throw error;
+    }
+    await removeServerInfoForPid(existing.pid);
+    return launchServer(await getPort());
+  }
+}
+async function launchServer(port) {
   await ensureDir(globalStateDir());
   await ensureDir(globalLogDir());
-  const port = options.port ?? await getPort();
   const daemonPath = fileURLToPath(new URL("../server/daemon.js", import.meta.url));
   if (!existsSync(daemonPath)) {
     throw new Error(`Cannot find server daemon at ${daemonPath}. Run pnpm build first.`);
@@ -856,6 +1034,7 @@ async function startServer(options = {}) {
     },
     stdio: ["ignore", logFd, logFd]
   });
+  closeSync(logFd);
   child.unref();
   const info = {
     pid: child.pid ?? -1,
@@ -872,18 +1051,40 @@ async function startServer(options = {}) {
     }
     await new Promise((resolve) => setTimeout(resolve, 150));
   }
+  await terminatePid(info.pid);
+  await removeServerInfoForPid(info.pid);
   throw new Error(`Server did not become responsive. See ${globalServerLogFile()}`);
 }
-async function stopServer() {
+async function stopServer(options = {}) {
+  if (options.all) {
+    const info2 = await readServerInfo();
+    const daemonPids = await listGlossDaemonPids();
+    const stoppedPids = [];
+    for (const pid of daemonPids) {
+      if (await terminatePid(pid)) {
+        stoppedPids.push(pid);
+      }
+    }
+    await rm2(globalServerFile(), { force: true });
+    return { stopped: stoppedPids.length > 0, info: info2, stoppedPids };
+  }
   const info = await readServerInfo();
   if (!info) {
     return { stopped: false, info: null };
   }
-  if (isPidAlive(info.pid)) {
-    process.kill(info.pid, "SIGTERM");
+  if (!isPidAlive(info.pid)) {
+    await removeServerInfoForPid(info.pid);
+    return { stopped: false, info };
+  }
+  if (!await isGlossDaemonPid(info.pid)) {
+    await removeServerInfoForPid(info.pid);
+    return { stopped: false, info };
+  }
+  const stopped = await terminatePid(info.pid);
+  if (stopped) {
+    await removeServerInfoForPid(info.pid);
   }
-  await rm(globalServerFile(), { force: true });
-  return { stopped: true, info };
+  return { stopped, info };
 }
 function isPidAlive(pid) {
   if (pid <= 0) {
@@ -896,9 +1097,86 @@ function isPidAlive(pid) {
     return false;
   }
 }
+async function retireServer(info) {
+  if (isPidAlive(info.pid) && await isGlossDaemonPid(info.pid)) {
+    await terminatePid(info.pid);
+  }
+  await removeServerInfoForPid(info.pid);
+}
+async function terminatePid(pid) {
+  if (!isPidAlive(pid)) {
+    return true;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return !isPidAlive(pid);
+  }
+  if (await waitForPidExit(pid, gracefulShutdownTimeoutMs)) {
+    return true;
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return !isPidAlive(pid);
+  }
+  return waitForPidExit(pid, forceShutdownTimeoutMs);
+}
+async function waitForPidExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isPidAlive(pid)) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  return !isPidAlive(pid);
+}
+async function removeServerInfoForPid(pid) {
+  const current = await readServerInfo().catch(() => null);
+  if (!current || current.pid === pid) {
+    await rm2(globalServerFile(), { force: true });
+  }
+}
+async function isGlossDaemonPid(pid) {
+  const command = await readProcessCommand(pid);
+  return command ? isGlossDaemonCommand(command) : false;
+}
+async function readProcessCommand(pid) {
+  try {
+    const { stdout } = await execFileAsync("ps", ["-o", "command=", "-p", String(pid), "-ww"]);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function listGlossDaemonPids() {
+  let stdout;
+  try {
+    ({ stdout } = await execFileAsync("ps", ["-axo", "pid=,user=,command=", "-ww"]));
+  } catch {
+    return [];
+  }
+  const currentUser = userInfo().username;
+  return parseGlossDaemonPids(stdout, currentUser, process.pid);
+}
+function parseGlossDaemonPids(stdout, currentUser, currentPid = process.pid) {
+  return stdout.split("\n").map((line) => /^\s*(\d+)\s+(\S+)\s+(.+)$/.exec(line)).filter((match) => Boolean(match)).map((match) => ({
+    pid: Number(match[1]),
+    user: match[2],
+    command: match[3]
+  })).filter(
+    ({ pid, user, command }) => pid !== currentPid && user === currentUser && isGlossDaemonCommand(command)
+  ).map(({ pid }) => pid);
+}
+function isGlossDaemonCommand(command) {
+  return /(?:^|\s)(?:\S*\/)?node\s+\S*dist\/server\/daemon\.js(?:\s|$)/.test(command);
+}
 
 // src/server/store.ts
-import { readdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { createHash } from "crypto";
+import { readdir, readFile as readFile2 } from "fs/promises";
+import path4 from "path";
 import { ulid } from "ulid";
 
 // src/shared/comments.ts
@@ -928,6 +1206,60 @@ function resolutionCounts(feedback, resolvedComments = []) {
   };
 }
 
+// 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 = "```";
@@ -942,20 +1274,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) {
@@ -967,6 +1311,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/shared/reviews.ts
 function isResolvableReviewStatus(status) {
@@ -980,6 +1332,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,
@@ -987,108 +1340,188 @@ 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 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,
@@ -1098,46 +1531,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();
@@ -1155,13 +1601,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);
@@ -1175,23 +1625,106 @@ var ReviewStore = class {
     try {
       entries = await readdir(globalReviewsDir(), { withFileTypes: true });
     } catch (error) {
-      if (isFileNotFound2(error)) {
+      if (isFileNotFound(error)) {
         return;
       }
       throw new Error(
-        `Could not read reviews directory at ${globalReviewsDir()}: ${formatError2(error)}`,
+        `Could not read reviews directory at ${globalReviewsDir()}: ${formatError(error)}`,
         {
           cause: error
         }
       );
     }
-    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 readFile2(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 readdir(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 {
@@ -1200,71 +1733,119 @@ var ReviewStore = class {
         readFile2(diffPath, "utf8")
       ]);
     } catch (error) {
-      if (isFileNotFound2(error)) {
+      if (isFileNotFound(error)) {
+        return null;
+      }
+      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 readFile2(diffPath, "utf8");
+    } catch (error) {
+      if (isFileNotFound(error)) {
         return null;
       }
-      throw new Error(`Could not load review ${id}: ${formatError2(error)}`, { cause: error });
+      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);
     }
-  }
-  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));
+    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;
+  }
+  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,
@@ -1272,24 +1853,134 @@ 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");
   } catch (error) {
-    if (isFileNotFound2(error)) {
+    if (isFileNotFound(error)) {
       return void 0;
     }
-    throw new Error(`Could not read ${label} at ${filePath}: ${formatError2(error)}`, {
+    throw new Error(`Could not read ${label} at ${filePath}: ${formatError(error)}`, {
       cause: error
     });
   }
@@ -1299,15 +1990,9 @@ function parseJsonFile(raw, guard, label, filePath) {
   try {
     return parseJson(raw, guard, label);
   } catch (error) {
-    throw new Error(`Invalid ${label} at ${filePath}: ${formatError2(error)}`, { cause: error });
+    throw new Error(`Invalid ${label} at ${filePath}: ${formatError(error)}`, { cause: error });
   }
 }
-function isFileNotFound2(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-function formatError2(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 var reviewStore = new ReviewStore();
 
 // src/cli/status.ts
@@ -1335,31 +2020,61 @@ function printPlain(value) {
 }
 var program = new Command();
 program.name("gloss").description("Local browser-based diff review for coding-agent loops.").version(packageVersion).option("--json", "print JSON for supported commands").option("--no-color", "disable color output");
-program.command("open").description("Capture local changes and open them for review").option("--base <ref>", "explicit base git ref").option("--print-url", "print review URL").option("--no-open", "do not open a browser").option("--no-watch", "return immediately after registering the review").option("--timeout <seconds>", "watch timeout in seconds", Number).action(
+program.command("open").description("Capture local changes and open them for review").option("--base <ref>", "explicit base git ref").option("--review <reviewId>", "append or resume a turn in an existing review").option("--print-url", "print review URL").option("--no-open", "do not open a browser").option("--no-watch", "return immediately after registering the review").option("--timeout <seconds>", "watch timeout in seconds", Number).action(
   async (options) => {
     const globals = program.opts();
-    const info = await ensureServer();
-    const client = new ServerClient(serverUrl(info));
-    const diff = await captureDiff(options.base);
-    const { meta, url } = await client.createReview(diff);
+    let info = await ensureServer();
+    let client = new ServerClient(serverUrl(info));
+    const inheritedBase = options.review && !options.base ? await baseForExistingReview(client, options.review) : null;
+    const diff = await captureDiff(options.base ?? inheritedBase ?? void 0);
+    const created = options.review ? await client.appendReviewTurn(options.review, diff) : await client.createReview(diff);
+    const meta = created.meta;
+    const turn = created.turn ?? meta.turns?.find((summary) => summary.id === meta.activeTurnId);
+    if (!turn) {
+      throw new Error(`Review ${meta.id} has no active turn`);
+    }
+    const reused = "reused" in created ? created.reused === true : false;
+    let url = created.url;
+    const shouldWatch = options.watch !== false;
     if (options.printUrl) {
       printPlain(url);
     }
     if (options.open !== false) {
       await openBrowser(url);
     }
-    if (options.watch === false) {
+    if (!shouldWatch) {
       const result2 = {
         reviewId: meta.id,
+        turnId: turn.id,
+        turnIndex: turn.index,
         url,
         files: diff.files.length,
         scope: diff.scope.mode,
-        artifactDir: meta.artifactDir
+        artifactDir: turn.artifactDir,
+        reused
       };
       globals.json ? printJson(result2) : printPlain(`Review ${meta.id}: ${url}`);
       return;
     }
-    const event = await client.watchReview(meta.id, options.timeout);
+    const watched = await watchReviewWithReconnect(
+      meta.id,
+      info,
+      options.timeout,
+      async (nextInfo) => {
+        info = nextInfo;
+        client = new ServerClient(serverUrl(info));
+        url = `${serverUrl(info)}/review/${meta.id}`;
+        if (options.printUrl) {
+          printPlain(url);
+        }
+        if (options.open !== false) {
+          await openBrowser(url);
+        }
+      }
+    );
+    info = watched.info;
+    client = new ServerClient(serverUrl(info));
+    const event = watched.event;
     if (event.type === "review.cancelled") {
       process.exitCode = 2;
       globals.json ? printJson(event) : printPlain(`Review ${meta.id} cancelled`);
@@ -1368,16 +2083,26 @@ program.command("open").description("Capture local changes and open them for rev
     if (event.type !== "review.submitted") {
       throw new Error(`Unexpected review event ${event.type}`);
     }
-    const feedback = await client.getFeedback(meta.id);
+    const [feedback, submittedRecord] = await Promise.all([
+      client.getFeedback(meta.id),
+      client.getReview(meta.id)
+    ]);
+    const submittedTurn = submittedRecord.meta.turns?.find((summary) => summary.id === (event.turnId ?? turn.id)) ?? turn;
+    if (!submittedTurn.feedbackPath || !submittedTurn.markdownPath) {
+      throw new Error(`Review ${meta.id} turn ${submittedTurn.index} is missing feedback paths`);
+    }
     const result = {
       reviewId: meta.id,
+      turnId: submittedTurn.id,
+      turnIndex: submittedTurn.index,
       url,
       files: event.counts.files,
       comments: event.counts.comments,
-      feedbackPath: globalReviewFeedbackFile(meta.id),
-      markdownPath: globalReviewMarkdownFile(meta.id),
-      artifactDir: globalReviewDir(meta.id),
-      feedback
+      feedbackPath: submittedTurn.feedbackPath,
+      markdownPath: submittedTurn.markdownPath,
+      artifactDir: submittedTurn.artifactDir,
+      feedback,
+      reused
     };
     globals.json ? printJson(result) : printPlain(`Review ${meta.id} submitted with ${event.counts.comments} comments`);
   }
@@ -1385,8 +2110,12 @@ program.command("open").description("Capture local changes and open them for rev
 program.command("watch").argument("<reviewId>", "review id").description("Wait for review.submitted for an existing review").option("--timeout <seconds>", "watch timeout in seconds", Number).action(async (reviewId, options) => {
   const globals = program.opts();
   const info = await ensureServer();
-  const client = new ServerClient(serverUrl(info));
-  const event = await client.watchReview(reviewId, options.timeout);
+  const { event } = await watchReviewWithReconnect(
+    reviewId,
+    info,
+    options.timeout,
+    async () => void 0
+  );
   globals.json ? printJson(event) : printPlain(`${event.type} ${event.reviewId}`);
 });
 program.command("start").description("Start or reuse the background server").option("--port <port>", "port to bind", Number).action(async (options) => {
@@ -1404,28 +2133,33 @@ program.command("status").description("Show server and active reviews").action(a
     responsive && info ? `Gloss server running at ${serverUrl(info)} with ${reviews.length} active review(s)` : "Gloss server is not running"
   );
 });
-program.command("stop").description("Stop the managed background server").action(async () => {
-  const globals = program.opts();
-  const result = await stopServer();
-  globals.json ? printJson(result) : printPlain(result.stopped ? "Gloss server stopped" : "Gloss server was not running");
-});
-program.command("resolve").argument("<reviewId>", "review id").description("Mark a submitted review or one feedback comment as resolved").option("--comment <commentId>", "resolve one submitted feedback comment").option("--summary <text>", "brief summary of the fixes applied").action(async (reviewId, options) => {
+program.command("stop").description("Stop the managed background server").option("--all", "stop all Gloss daemon processes for the current user").action(async (options) => {
   const globals = program.opts();
-  const info = await ensureServer();
-  const client = new ServerClient(serverUrl(info));
-  const result = options.comment ? await client.resolveComment(reviewId, options.comment, options.summary) : await client.markResolved(reviewId, options.summary);
-  if (globals.json) {
-    printJson({
-      commentId: options.comment ?? null,
-      summary: options.summary ?? null,
-      ...result
-    });
-    return;
-  }
-  printPlain(
-    options.comment ? `Comment ${options.comment} resolved in review ${reviewId}` : `Review ${reviewId} resolved`
+  const result = await stopServer({ all: options.all });
+  globals.json ? printJson(result) : printPlain(
+    options.all && result.stoppedPids ? `Stopped ${result.stoppedPids.length} Gloss daemon(s)` : result.stopped ? "Gloss server stopped" : "Gloss server was not running"
   );
 });
+program.command("resolve").argument("<reviewId>", "review id").description("Mark a submitted review or one feedback comment as resolved").option("--comment <commentId>", "resolve one submitted feedback comment").option("--summary <text>", "brief summary of the fixes applied").option("--turn <idOrIndex>", "resolve a specific turn for whole-review resolution").action(
+  async (reviewId, options) => {
+    const globals = program.opts();
+    const info = await ensureServer();
+    const client = new ServerClient(serverUrl(info));
+    const result = options.comment ? await client.resolveComment(reviewId, options.comment, options.summary) : await client.markResolved(reviewId, options.summary, options.turn);
+    if (globals.json) {
+      printJson({
+        commentId: options.comment ?? null,
+        summary: options.summary ?? null,
+        turn: options.turn ?? null,
+        ...result
+      });
+      return;
+    }
+    printPlain(
+      options.comment ? `Comment ${options.comment} resolved in review ${reviewId}` : `Review ${reviewId} resolved`
+    );
+  }
+);
 program.command("doctor").description("Diagnose setup and validate git/state").action(async () => {
   const globals = program.opts();
   const checks = [];
@@ -1455,6 +2189,21 @@ program.command("doctor").description("Diagnose setup and validate git/state").a
     ok: info ? await isServerResponsive(info) : false,
     detail: info ? serverUrl(info) : "not started"
   });
+  try {
+    const daemonPids = await listGlossDaemonPids();
+    const unmanagedDaemonPids = daemonPids.filter((pid) => pid !== info?.pid);
+    checks.push({
+      name: "daemon-processes",
+      ok: unmanagedDaemonPids.length === 0,
+      detail: daemonPids.length === 0 ? "none" : `${daemonPids.length} found${unmanagedDaemonPids.length > 0 ? `; unmanaged pids ${unmanagedDaemonPids.join(", ")}` : ""}`
+    });
+  } catch (error) {
+    checks.push({
+      name: "daemon-processes",
+      ok: false,
+      detail: error instanceof Error ? error.message : String(error)
+    });
+  }
   if (globals.json) {
     printJson({ checks });
   } else {
@@ -1465,6 +2214,46 @@ program.command("doctor").description("Diagnose setup and validate git/state").a
     }
   }
 });
+async function watchReviewWithReconnect(reviewId, initialInfo, timeoutSeconds, onServerChanged) {
+  const startedAt = Date.now();
+  let info = initialInfo;
+  while (true) {
+    const remainingSeconds = timeoutSeconds && timeoutSeconds > 0 ? timeoutSeconds - (Date.now() - startedAt) / 1e3 : void 0;
+    if (remainingSeconds !== void 0 && remainingSeconds <= 0) {
+      throw new Error(`watch timed out after ${timeoutSeconds} seconds`);
+    }
+    try {
+      const event = await new ServerClient(serverUrl(info)).watchReview(reviewId, remainingSeconds);
+      return { event, info };
+    } catch (error) {
+      if (isWatchTimeout(error)) {
+        throw error;
+      }
+      if (!isReconnectableWatchError(error)) {
+        throw error;
+      }
+      await sleep2(500);
+      const nextInfo = await ensureServer();
+      if (nextInfo.port !== info.port) {
+        await onServerChanged(nextInfo);
+      }
+      info = nextInfo;
+    }
+  }
+}
+async function baseForExistingReview(client, reviewId) {
+  const record = await client.getReview(reviewId);
+  return record.diff.scope.mode === "explicit" ? record.diff.scope.requestedBase ?? record.diff.base.ref : null;
+}
+function isWatchTimeout(error) {
+  return error instanceof Error && /^watch timed out after/.test(error.message);
+}
+function isReconnectableWatchError(error) {
+  return error instanceof Error && !/^watch failed: [45]\d\d /.test(error.message);
+}
+async function sleep2(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
 program.parseAsync(process.argv).catch((error) => {
   process.stderr.write(`${error instanceof Error ? error.message : String(error)}
 `);