getgloss 0.5.0 → 0.6.0

package/dist/cli/index.js

@@ -12,7 +12,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.5.0",
+  version: "0.6.0",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -42,31 +42,31 @@ var package_default = {
     node: ">=20"
   },
   dependencies: {
-    "@hono/node-server": "^1.14.4",
-    "@pierre/diffs": "^1.2.1",
-    "@tailwindcss/vite": "^4.1.7",
-    commander: "^14.0.0",
-    execa: "^9.5.3",
-    "get-port": "^7.1.0",
-    hono: "^4.7.10",
-    "lucide-react": "^1.16.0",
-    open: "^10.1.2",
-    react: "^19.1.0",
-    "react-dom": "^19.1.0",
-    ulid: "^3.0.0",
-    zustand: "^5.0.5"
+    "@hono/node-server": "1.19.14",
+    "@tailwindcss/vite": "4.3.0",
+    commander: "14.0.3",
+    execa: "9.6.1",
+    "get-port": "7.2.0",
+    hono: "4.12.21",
+    "lucide-react": "1.16.0",
+    open: "10.2.0",
+    react: "19.2.6",
+    "react-dom": "19.2.6",
+    ulid: "3.0.2",
+    zustand: "5.0.13"
   },
   devDependencies: {
-    "@biomejs/biome": "^2.0.6",
-    "@types/node": "^24.0.1",
-    "@types/react": "^19.1.6",
-    "@types/react-dom": "^19.1.5",
-    "@vitejs/plugin-react": "^4.5.2",
-    tsup: "^8.5.0",
-    tsx: "^4.20.3",
-    typescript: "^5.8.3",
-    vite: "^6.3.5",
-    vitest: "^3.2.3"
+    "@biomejs/biome": "2.4.15",
+    "@types/node": "24.12.4",
+    "@types/react": "19.2.15",
+    "@types/react-dom": "19.2.3",
+    "@vitejs/plugin-react": "4.7.0",
+    tailwindcss: "4.3.0",
+    tsup: "8.5.1",
+    tsx: "4.22.3",
+    typescript: "5.9.3",
+    vite: "6.4.2",
+    vitest: "3.2.4"
   },
   keywords: [
     "diff",
@@ -139,32 +139,40 @@ async function ensureDir(dir) {
 // src/cli/git.ts
 import { execa } from "execa";
 
-// src/cli/diff-parser.ts
+// src/shared/language.ts
 import path2 from "path";
-var hunkHeaderPattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
-function stripGitPath(input) {
-  return input.replace(/^[ab]\//, "");
-}
+var languageByExtension = {
+  cjs: "js",
+  css: "css",
+  go: "go",
+  html: "html",
+  js: "js",
+  json: "json",
+  jsx: "jsx",
+  md: "markdown",
+  mjs: "js",
+  py: "python",
+  rb: "ruby",
+  rs: "rust",
+  sh: "bash",
+  swift: "swift",
+  ts: "ts",
+  tsx: "tsx",
+  yaml: "yaml",
+  yml: "yaml"
+};
 function languageForPath(filePath) {
   const ext = path2.extname(filePath).slice(1).toLowerCase();
   if (!ext) {
     return null;
   }
-  const map = {
-    cjs: "js",
-    mjs: "js",
-    js: "js",
-    jsx: "jsx",
-    ts: "ts",
-    tsx: "tsx",
-    py: "python",
-    rb: "ruby",
-    sh: "bash",
-    md: "markdown",
-    yml: "yaml",
-    yaml: "yaml"
-  };
-  return map[ext] ?? ext;
+  return languageByExtension[ext] ?? ext;
+}
+
+// src/cli/diff-parser.ts
+var hunkHeaderPattern = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/;
+function stripGitPath(input) {
+  return input.replace(/^[ab]\//, "");
 }
 function emptyFile() {
   return {
@@ -466,10 +474,198 @@ async function assertGitAvailable() {
 // src/cli/lifecycle.ts
 import { spawn } from "child_process";
 import { existsSync, openSync } from "fs";
-import { readFile, rm, writeFile } from "fs/promises";
+import { rm } from "fs/promises";
 import { fileURLToPath } from "url";
 import getPort from "get-port";
 
+// src/shared/server-info.ts
+import { readFile } from "fs/promises";
+
+// src/shared/json.ts
+import { writeFile } from "fs/promises";
+function serializeJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+async function writeJsonFile(filePath, value) {
+  await writeFile(filePath, serializeJson(value));
+}
+
+// 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);
+}
+function parseJsonValue(value, guard, label) {
+  if (!guard(value)) {
+    throw new Error(`Invalid ${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 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);
+}
+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);
+}
+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);
+}
+function isReviewRecord(value) {
+  return isRecord(value) && isReviewMeta(value.meta) && 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);
+}
+function isReviewMeta(value) {
+  return isStoredReviewMeta(value) && isString(value.artifactDir);
+}
+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);
+}
+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);
+}
+function isResolutionBundle(value) {
+  return isRecord(value) && isString(value.reviewId) && 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)) {
+    return false;
+  }
+  switch (value.type) {
+    case "review.opened":
+    case "review.cancelled":
+      return true;
+    case "review.submitted":
+      return 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);
+    default:
+      return false;
+  }
+}
+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));
+}
+function isDiffRef(value) {
+  return isRecord(value) && isString(value.ref) && isNullableString(value.sha);
+}
+function isBaseRef(value) {
+  return isRecord(value) && isString(value.ref) && isString(value.sha);
+}
+function isDiffStats(value) {
+  return isRecord(value) && isNumber(value.files) && isNumber(value.additions) && isNumber(value.deletions);
+}
+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);
+}
+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);
+}
+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);
+}
+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);
+}
+function isResolutionStatus(value) {
+  return isOneOf(value, resolutionStatuses);
+}
+function isReviewUpdateReason(value) {
+  return isOneOf(value, reviewUpdateReasons);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(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";
+}
+function isOptionalString(value) {
+  return value === void 0 || isString(value);
+}
+function isNullableString(value) {
+  return value === null || isString(value);
+}
+function isNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isOptionalNumber(value) {
+  return value === void 0 || isNumber(value);
+}
+function isNullableNumber(value) {
+  return value === null || isNumber(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isOneOf(value, options) {
+  return typeof value === "string" && options.includes(value);
+}
+
+// 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);
+}
+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 {
   constructor(baseUrl) {
@@ -477,31 +673,53 @@ var ServerClient = class {
   }
   baseUrl;
   async health() {
-    return this.get("/api/health");
+    return this.get("/api/health", isHealthResponse, "health response");
   }
   async createReview(diff) {
-    return this.post("/api/reviews", diff);
+    return this.post("/api/reviews", diff, isCreateReviewResponse, "create review response");
   }
   async getReview(reviewId) {
-    return this.get(`/api/reviews/${reviewId}`);
+    return this.get(`/api/reviews/${reviewId}`, isReviewRecord, "review response");
   }
   async listReviews() {
-    return this.get("/api/reviews");
+    return this.get("/api/reviews", isListReviewsResponse, "review list response");
   }
   async getFeedback(reviewId) {
-    return this.get(`/api/reviews/${reviewId}/feedback`);
+    return this.get(`/api/reviews/${reviewId}/feedback`, isFeedbackBundle, "feedback response");
   }
   async markResolved(reviewId, summary) {
-    return this.post(`/api/reviews/${reviewId}/resolved`, { summary });
+    const request = { summary };
+    return this.post(
+      `/api/reviews/${reviewId}/resolved`,
+      request,
+      isResolveResult,
+      "resolve response"
+    );
   }
   async resolveComment(reviewId, commentId, summary) {
-    return this.post(`/api/reviews/${reviewId}/comments/${commentId}/resolved`, { summary });
+    const request = { summary };
+    return this.post(
+      `/api/reviews/${reviewId}/comments/${commentId}/resolved`,
+      request,
+      isResolveResult,
+      "resolve comment response"
+    );
   }
   async reopenComment(reviewId, commentId) {
-    return this.delete(`/api/reviews/${reviewId}/comments/${commentId}/resolved`);
+    return this.delete(
+      `/api/reviews/${reviewId}/comments/${commentId}/resolved`,
+      isResolveResult,
+      "reopen comment response"
+    );
   }
   async submitReview(reviewId, comments) {
-    return this.post(`/api/reviews/${reviewId}/submit`, { comments });
+    const request = { comments };
+    return this.post(
+      `/api/reviews/${reviewId}/submit`,
+      request,
+      isOpenResult,
+      "submit review response"
+    );
   }
   async watchReview(reviewId, timeoutSeconds) {
     const deadline = timeoutSeconds && timeoutSeconds > 0 ? Date.now() + timeoutSeconds * 1e3 : null;
@@ -552,7 +770,7 @@ var ServerClient = class {
         if (!dataLine) {
           continue;
         }
-        const event = JSON.parse(dataLine.slice(5).trim());
+        const event = parseJson(dataLine.slice(5).trim(), isReviewEvent, "review event");
         if (event.type === "review.submitted" || event.type === "review.cancelled") {
           await reader.cancel().catch(() => void 0);
           return event;
@@ -560,28 +778,29 @@ var ServerClient = class {
       }
     }
   }
-  async get(path3) {
+  async get(path3, guard, label) {
     const response = await fetch(`${this.baseUrl}${path3}`);
-    return parseResponse(response);
+    return parseResponse(response, guard, label);
   }
-  async post(path3, body) {
+  async post(path3, body, guard, label) {
     const response = await fetch(`${this.baseUrl}${path3}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body)
     });
-    return parseResponse(response);
+    return parseResponse(response, guard, label);
   }
-  async delete(path3) {
+  async delete(path3, guard, label) {
     const response = await fetch(`${this.baseUrl}${path3}`, { method: "DELETE" });
-    return parseResponse(response);
+    return parseResponse(response, guard, label);
   }
 };
-async function parseResponse(response) {
+async function parseResponse(response, guard, label) {
   if (!response.ok) {
     throw new Error(`${response.status} ${response.statusText}: ${await response.text()}`);
   }
-  return await response.json();
+  const value = await response.json();
+  return parseJsonValue(value, guard, label);
 }
 function isPrematureWatchEnd(error) {
   return error instanceof Error && error.message === "watch stream ended before completion";
@@ -594,13 +813,6 @@ async function sleep(milliseconds) {
 }
 
 // src/cli/lifecycle.ts
-async function readServerInfo() {
-  try {
-    return JSON.parse(await readFile(globalServerFile(), "utf8"));
-  } catch {
-    return null;
-  }
-}
 function serverUrl(info) {
   return `http://localhost:${info.port}`;
 }
@@ -652,8 +864,7 @@ async function startServer(options = {}) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     stateDir: globalStateDir()
   };
-  await writeFile(globalServerFile(), `${JSON.stringify(info, null, 2)}
-`);
+  await writeServerInfo(info);
   const deadline = Date.now() + 8e3;
   while (Date.now() < deadline) {
     if (await isServerResponsive(info)) {
@@ -687,17 +898,37 @@ function isPidAlive(pid) {
 }
 
 // src/server/store.ts
-import { readdir, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { readdir, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 import { ulid } from "ulid";
 
-// src/shared/markdown.ts
-function formatLineRange(comment) {
-  const prefix = comment.side;
-  if (comment.startLine === comment.endLine) {
-    return `${prefix}${comment.startLine}`;
-  }
-  return `${prefix}${comment.startLine}-${prefix}${comment.endLine}`;
+// src/shared/comments.ts
+function compareCommentsByLocation(a, b) {
+  return a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine || a.endLine - b.endLine || a.side.localeCompare(b.side);
 }
+function countCommentFiles(comments) {
+  return new Set(comments.map((comment) => comment.filePath)).size;
+}
+function formatLineRange(range, options = {}) {
+  const startLine = Math.min(range.startLine, range.endLine);
+  const endLine = Math.max(range.startLine, range.endLine);
+  if (startLine === endLine) {
+    return `${range.side}${startLine}`;
+  }
+  const endPrefix = options.repeatSideOnEnd === false ? "" : range.side;
+  return `${range.side}${startLine}-${endPrefix}${endLine}`;
+}
+function resolutionCounts(feedback, resolvedComments = []) {
+  const comments = feedback?.comments ?? [];
+  const resolvedIds = new Set(resolvedComments.map((comment) => comment.commentId));
+  const resolved = comments.filter((comment) => resolvedIds.has(comment.id)).length;
+  return {
+    total: comments.length,
+    resolved,
+    open: comments.length - resolved
+  };
+}
+
+// src/shared/markdown.ts
 function fenceFor(snippet) {
   let fence = "```";
   while (snippet.includes(fence)) {
@@ -705,40 +936,13 @@ function fenceFor(snippet) {
   }
   return fence;
 }
-function languageForPath2(filePath) {
-  const ext = filePath.split(".").pop()?.toLowerCase();
-  const map = {
-    cjs: "js",
-    css: "css",
-    go: "go",
-    html: "html",
-    js: "js",
-    json: "json",
-    jsx: "jsx",
-    md: "markdown",
-    mjs: "js",
-    py: "python",
-    rb: "ruby",
-    rs: "rust",
-    sh: "bash",
-    swift: "swift",
-    ts: "ts",
-    tsx: "tsx",
-    yaml: "yaml",
-    yml: "yaml"
-  };
-  return ext ? map[ext] ?? ext : "";
-}
 function languageForSnippet(filePath, snippet) {
   const lines = snippet.split("\n").filter((line) => line.length > 0);
   const looksLikeUnifiedDiff = lines.length > 0 && lines.some((line) => line.startsWith("+") || line.startsWith("-")) && lines.every((line) => line.startsWith("+") || line.startsWith("-") || line.startsWith(" "));
-  return looksLikeUnifiedDiff ? "diff" : languageForPath2(filePath);
-}
-function byFileThenLine(a, b) {
-  return a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine || a.endLine - b.endLine || a.side.localeCompare(b.side);
+  return looksLikeUnifiedDiff ? "diff" : languageForPath(filePath) ?? "";
 }
 function serializeFeedbackMarkdown(bundle) {
-  const comments = [...bundle.comments].sort(byFileThenLine);
+  const comments = [...bundle.comments].sort(compareCommentsByLocation);
   const files = [...new Set(comments.map((comment) => comment.filePath))];
   const lines = [
     `# Gloss feedback - ${bundle.timestamp}`,
@@ -764,6 +968,11 @@ function serializeFeedbackMarkdown(bundle) {
 `;
 }
 
+// src/shared/reviews.ts
+function isResolvableReviewStatus(status) {
+  return status === "submitted" || status === "resolved";
+}
+
 // src/server/store.ts
 var ReviewStore = class {
   reviews = /* @__PURE__ */ new Map();
@@ -808,9 +1017,7 @@ var ReviewStore = class {
       timestamp,
       base: record.diff.base,
       branch: record.diff.branch,
-      comments: [...comments].sort(
-        (a, b) => a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine || a.endLine - b.endLine || a.side.localeCompare(b.side)
-      )
+      comments: [...comments].sort(compareCommentsByLocation)
     };
     record.feedback = feedback;
     record.meta = { ...record.meta, status: "submitted", submittedAt: timestamp };
@@ -826,17 +1033,15 @@ var ReviewStore = class {
     };
     await ensureDir(artifactDir);
     await Promise.all([
-      writeFile2(globalReviewMetaFile(id), `${JSON.stringify(record.meta, null, 2)}
-`),
-      writeFile2(feedbackPath, `${JSON.stringify(feedback, null, 2)}
-`),
+      writeJsonFile(globalReviewMetaFile(id), record.meta),
+      writeJsonFile(feedbackPath, feedback),
       writeFile2(markdownPath, serializeFeedbackMarkdown(feedback))
     ]);
     this.emit({
       type: "review.submitted",
       reviewId: id,
       counts: {
-        files: new Set(feedback.comments.map((comment) => comment.filePath)).size,
+        files: countCommentFiles(feedback.comments),
         comments: feedback.comments.length
       }
     });
@@ -898,7 +1103,7 @@ var ReviewStore = class {
       ],
       record
     );
-    const counts = this.resolutionCounts(record, comments);
+    const counts = resolutionCounts(record.feedback, comments);
     const fullyResolved = counts.total === counts.resolved;
     const resolution = {
       reviewId: id,
@@ -921,7 +1126,7 @@ var ReviewStore = class {
       (record.resolution?.comments ?? []).filter((comment) => comment.commentId !== commentId),
       record
     );
-    const counts = this.resolutionCounts(record, comments);
+    const counts = resolutionCounts(record.feedback, comments);
     const fullyResolved = counts.total > 0 && counts.total === counts.resolved;
     const resolvedAt = fullyResolved ? (/* @__PURE__ */ new Date()).toISOString() : null;
     const resolution = {
@@ -954,10 +1159,8 @@ var ReviewStore = class {
     const dir = globalReviewDir(record.meta.id);
     await ensureDir(dir);
     await Promise.all([
-      writeFile2(globalReviewMetaFile(record.meta.id), `${JSON.stringify(record.meta, null, 2)}
-`),
-      writeFile2(globalReviewDiffFile(record.meta.id), `${JSON.stringify(record.diff, null, 2)}
-`)
+      writeJsonFile(globalReviewMetaFile(record.meta.id), record.meta),
+      writeJsonFile(globalReviewDiffFile(record.meta.id), record.diff)
     ]);
   }
   async loadKnownReview(id) {
@@ -971,56 +1174,65 @@ var ReviewStore = class {
     let entries;
     try {
       entries = await readdir(globalReviewsDir(), { withFileTypes: true });
-    } catch {
-      return;
+    } catch (error) {
+      if (isFileNotFound2(error)) {
+        return;
+      }
+      throw new Error(
+        `Could not read reviews directory at ${globalReviewsDir()}: ${formatError2(error)}`,
+        {
+          cause: error
+        }
+      );
     }
     await Promise.all(
       entries.filter((entry) => entry.isDirectory()).map((entry) => this.loadReview(entry.name))
     );
   }
   async loadReview(id) {
+    const metaPath = globalReviewMetaFile(id);
+    const diffPath = globalReviewDiffFile(id);
+    let metaRaw;
+    let diffRaw;
     try {
-      const [metaRaw, diffRaw] = await Promise.all([
-        readFile2(globalReviewMetaFile(id), "utf8"),
-        readFile2(globalReviewDiffFile(id), "utf8")
+      [metaRaw, diffRaw] = await Promise.all([
+        readFile2(metaPath, "utf8"),
+        readFile2(diffPath, "utf8")
       ]);
-      const meta = JSON.parse(metaRaw);
-      const diff = JSON.parse(diffRaw);
-      let feedback;
-      let resolution;
-      try {
-        feedback = JSON.parse(
-          await readFile2(globalReviewFeedbackFile(id), "utf8")
-        );
-      } catch {
-        feedback = void 0;
-      }
-      try {
-        resolution = JSON.parse(
-          await readFile2(globalReviewResolvedFile(id), "utf8")
-        );
-      } catch {
-        resolution = void 0;
+    } catch (error) {
+      if (isFileNotFound2(error)) {
+        return null;
       }
-      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
-      };
-      this.reviews.set(id, record);
-      return record;
-    } catch {
-      return null;
+      throw new Error(`Could not load review ${id}: ${formatError2(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
+    };
+    this.reviews.set(id, record);
+    return record;
   }
   assertResolvable(record, id) {
-    if (record.meta.status !== "submitted" && record.meta.status !== "resolved") {
+    if (!isResolvableReviewStatus(record.meta.status)) {
       throw new Error(`Review ${id} is ${record.meta.status} and cannot be resolved`);
     }
     if (!record.feedback) {
@@ -1038,17 +1250,15 @@ var ReviewStore = class {
     const resolvedPath = globalReviewResolvedFile(record.meta.id);
     await ensureDir(globalReviewDir(record.meta.id));
     await Promise.all([
-      writeFile2(resolvedPath, `${JSON.stringify(resolution, null, 2)}
-`),
-      writeFile2(globalReviewMetaFile(record.meta.id), `${JSON.stringify(record.meta, null, 2)}
-`)
+      writeJsonFile(resolvedPath, resolution),
+      writeJsonFile(globalReviewMetaFile(record.meta.id), record.meta)
     ]);
     const result = {
       ok: true,
       reviewId: record.meta.id,
       status: record.meta.status,
       resolutionStatus: resolution.status,
-      comments: this.resolutionCounts(record, resolution.comments),
+      comments: resolutionCounts(record.feedback, resolution.comments),
       path: resolvedPath,
       resolution
     };
@@ -1070,19 +1280,34 @@ var ReviewStore = class {
       (a, b) => (feedbackIndex.get(a.commentId) ?? Number.MAX_SAFE_INTEGER) - (feedbackIndex.get(b.commentId) ?? Number.MAX_SAFE_INTEGER)
     );
   }
-  resolutionCounts(record, comments) {
-    const total = record.feedback.comments.length;
-    const resolvedIds = new Set(comments.map((comment) => comment.commentId));
-    const resolved = record.feedback.comments.filter(
-      (comment) => resolvedIds.has(comment.id)
-    ).length;
-    return {
-      total,
-      resolved,
-      open: total - resolved
-    };
-  }
 };
+async function readOptionalJsonFile(filePath, guard, label) {
+  let raw;
+  try {
+    raw = await readFile2(filePath, "utf8");
+  } catch (error) {
+    if (isFileNotFound2(error)) {
+      return void 0;
+    }
+    throw new Error(`Could not read ${label} at ${filePath}: ${formatError2(error)}`, {
+      cause: error
+    });
+  }
+  return parseJsonFile(raw, guard, label, filePath);
+}
+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 });
+  }
+}
+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
@@ -1179,7 +1404,7 @@ 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").option("--all", "reserved for future multi-server cleanup").action(async () => {
+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");
@@ -1230,11 +1455,6 @@ program.command("doctor").description("Diagnose setup and validate git/state").a
     ok: info ? await isServerResponsive(info) : false,
     detail: info ? serverUrl(info) : "not started"
   });
-  checks.push({
-    name: "@pierre/diffs license",
-    ok: true,
-    detail: "apache-2.0 dependency present"
-  });
   if (globals.json) {
     printJson({ checks });
   } else {