getgloss 0.3.0 → 0.4.1

package/dist/cli/index.js

@@ -4,18 +4,6 @@
 import { Command } from "commander";
 import openBrowser from "open";
 
-// src/mcp/index.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod/v4";
-
-// src/cli/lifecycle.ts
-import { spawn } from "child_process";
-import { existsSync, openSync } from "fs";
-import { readFile, rm, writeFile } from "fs/promises";
-import { fileURLToPath } from "url";
-import getPort from "get-port";
-
 // src/shared/paths.ts
 import { mkdir } from "fs/promises";
 import { homedir } from "os";
@@ -24,7 +12,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.3.0",
+  version: "0.4.1",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -55,7 +43,6 @@ var package_default = {
   },
   dependencies: {
     "@hono/node-server": "^1.14.4",
-    "@modelcontextprotocol/sdk": "^1.29.0",
     "@pierre/diffs": "^1.2.1",
     "@tailwindcss/vite": "^4.1.7",
     commander: "^14.0.0",
@@ -86,8 +73,7 @@ var package_default = {
   keywords: [
     "diff",
     "review",
-    "coding-agents",
-    "mcp"
+    "coding-agents"
   ],
   author: "Raj Joshi",
   license: "MIT",
@@ -152,265 +138,6 @@ async function ensureDir(dir) {
   await mkdir(dir, { recursive: true });
 }
 
-// src/cli/server-client.ts
-var ServerClient = class {
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl;
-  }
-  baseUrl;
-  async health() {
-    return this.get("/api/health");
-  }
-  async createReview(diff) {
-    return this.post("/api/reviews", diff);
-  }
-  async getReview(reviewId) {
-    return this.get(`/api/reviews/${reviewId}`);
-  }
-  async listReviews() {
-    return this.get("/api/reviews");
-  }
-  async getFeedback(reviewId) {
-    return this.get(`/api/reviews/${reviewId}/feedback`);
-  }
-  async markResolved(reviewId, summary) {
-    return this.post(`/api/reviews/${reviewId}/resolved`, { summary });
-  }
-  async submitReview(reviewId, comments) {
-    return this.post(`/api/reviews/${reviewId}/submit`, { comments });
-  }
-  async watchReview(reviewId, timeoutSeconds) {
-    const controller = new AbortController();
-    const timeout = timeoutSeconds && timeoutSeconds > 0 ? setTimeout(() => controller.abort(), timeoutSeconds * 1e3) : null;
-    try {
-      const response = await fetch(`${this.baseUrl}/api/reviews/${reviewId}/events`, {
-        signal: controller.signal
-      });
-      if (!response.ok || !response.body) {
-        throw new Error(`watch failed: ${response.status} ${await response.text()}`);
-      }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done) {
-          throw new Error("watch stream ended before completion");
-        }
-        buffer += decoder.decode(value, { stream: true });
-        const events = buffer.split("\n\n");
-        buffer = events.pop() ?? "";
-        for (const eventChunk of events) {
-          const dataLine = eventChunk.split("\n").find((line) => line.startsWith("data:"));
-          if (!dataLine) {
-            continue;
-          }
-          const event = JSON.parse(dataLine.slice(5).trim());
-          if (event.type === "review.completed" || event.type === "review.cancelled") {
-            return event;
-          }
-        }
-      }
-    } finally {
-      if (timeout) {
-        clearTimeout(timeout);
-      }
-    }
-  }
-  async get(path3) {
-    const response = await fetch(`${this.baseUrl}${path3}`);
-    return parseResponse(response);
-  }
-  async post(path3, body) {
-    const response = await fetch(`${this.baseUrl}${path3}`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(body)
-    });
-    return parseResponse(response);
-  }
-};
-async function parseResponse(response) {
-  if (!response.ok) {
-    throw new Error(`${response.status} ${response.statusText}: ${await response.text()}`);
-  }
-  return await response.json();
-}
-
-// 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}`;
-}
-async function isServerResponsive(info) {
-  if (!isPidAlive(info.pid)) {
-    return false;
-  }
-  try {
-    const health = await new ServerClient(serverUrl(info)).health();
-    return health.ok === true;
-  } catch {
-    return false;
-  }
-}
-async function ensureServer(options = {}) {
-  const existing = await readServerInfo();
-  if (existing && await isServerResponsive(existing)) {
-    return existing;
-  }
-  return startServer(options);
-}
-async function startServer(options = {}) {
-  const existing = await readServerInfo();
-  if (existing && await isServerResponsive(existing)) {
-    return existing;
-  }
-  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.`);
-  }
-  const logFd = openSync(globalServerLogFile(), "a");
-  const child = spawn(process.execPath, [daemonPath], {
-    detached: true,
-    env: {
-      ...process.env,
-      GLOSS_PORT: String(port),
-      GLOSS_STATE_DIR: globalStateDir()
-    },
-    stdio: ["ignore", logFd, logFd]
-  });
-  child.unref();
-  const info = {
-    pid: child.pid ?? -1,
-    port,
-    version: packageVersion,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    stateDir: globalStateDir()
-  };
-  await writeFile(globalServerFile(), `${JSON.stringify(info, null, 2)}
-`);
-  const deadline = Date.now() + 8e3;
-  while (Date.now() < deadline) {
-    if (await isServerResponsive(info)) {
-      return info;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 150));
-  }
-  throw new Error(`Server did not become responsive. See ${globalServerLogFile()}`);
-}
-async function stopServer() {
-  const info = await readServerInfo();
-  if (!info) {
-    return { stopped: false, info: null };
-  }
-  if (isPidAlive(info.pid)) {
-    process.kill(info.pid, "SIGTERM");
-  }
-  await rm(globalServerFile(), { force: true });
-  return { stopped: true, info };
-}
-function isPidAlive(pid) {
-  if (pid <= 0) {
-    return false;
-  }
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/mcp/index.ts
-function textResult(value) {
-  return {
-    content: [
-      {
-        type: "text",
-        text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
-      }
-    ]
-  };
-}
-async function client() {
-  const info = await ensureServer();
-  return new ServerClient(serverUrl(info));
-}
-async function startMcpServer() {
-  const server = new McpServer({
-    name: "gloss",
-    version: packageVersion
-  });
-  server.registerTool(
-    "list_pending_reviews",
-    {
-      title: "List pending Gloss reviews",
-      description: "List pending local Gloss review sessions."
-    },
-    async () => {
-      const api = await client();
-      const { reviews } = await api.listReviews();
-      return textResult({ reviews: reviews.filter((review) => review.status === "pending") });
-    }
-  );
-  server.registerTool(
-    "get_review",
-    {
-      title: "Get Gloss review",
-      description: "Fetch review metadata and diff payload.",
-      inputSchema: { id: z.string() }
-    },
-    async ({ id }) => textResult(await (await client()).getReview(id))
-  );
-  server.registerTool(
-    "watch_review",
-    {
-      title: "Watch Gloss review",
-      description: "Block until a review completes, then return feedback.",
-      inputSchema: {
-        id: z.string(),
-        timeout: z.number().optional()
-      }
-    },
-    async ({ id, timeout }) => {
-      const api = await client();
-      await api.watchReview(id, timeout);
-      return textResult(await api.getFeedback(id));
-    }
-  );
-  server.registerTool(
-    "get_review_feedback",
-    {
-      title: "Get Gloss review feedback",
-      description: "Fetch completed review feedback.",
-      inputSchema: { id: z.string() }
-    },
-    async ({ id }) => textResult(await (await client()).getFeedback(id))
-  );
-  server.registerTool(
-    "mark_review_resolved",
-    {
-      title: "Mark Gloss review resolved",
-      description: "Write a resolved marker for a completed review.",
-      inputSchema: {
-        id: z.string(),
-        summary: z.string().optional()
-      }
-    },
-    async ({ id, summary }) => textResult(await (await client()).markResolved(id, summary))
-  );
-  await server.connect(new StdioServerTransport());
-}
-
 // src/cli/git.ts
 import { execa } from "execa";
 
@@ -738,6 +465,228 @@ async function assertGitAvailable() {
   await execa("git", ["--version"]);
 }
 
+// src/cli/lifecycle.ts
+import { spawn } from "child_process";
+import { existsSync, openSync } from "fs";
+import { readFile, rm, writeFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import getPort from "get-port";
+
+// src/cli/server-client.ts
+var ServerClient = class {
+  constructor(baseUrl) {
+    this.baseUrl = baseUrl;
+  }
+  baseUrl;
+  async health() {
+    return this.get("/api/health");
+  }
+  async createReview(diff) {
+    return this.post("/api/reviews", diff);
+  }
+  async getReview(reviewId) {
+    return this.get(`/api/reviews/${reviewId}`);
+  }
+  async listReviews() {
+    return this.get("/api/reviews");
+  }
+  async getFeedback(reviewId) {
+    return this.get(`/api/reviews/${reviewId}/feedback`);
+  }
+  async markResolved(reviewId, summary) {
+    return this.post(`/api/reviews/${reviewId}/resolved`, { summary });
+  }
+  async resolveComment(reviewId, commentId, summary) {
+    return this.post(`/api/reviews/${reviewId}/comments/${commentId}/resolved`, { summary });
+  }
+  async reopenComment(reviewId, commentId) {
+    return this.delete(`/api/reviews/${reviewId}/comments/${commentId}/resolved`);
+  }
+  async submitReview(reviewId, comments) {
+    return this.post(`/api/reviews/${reviewId}/submit`, { comments });
+  }
+  async watchReview(reviewId, timeoutSeconds) {
+    const deadline = timeoutSeconds && timeoutSeconds > 0 ? Date.now() + timeoutSeconds * 1e3 : null;
+    while (true) {
+      const remainingMs = deadline ? deadline - Date.now() : null;
+      if (remainingMs !== null && remainingMs <= 0) {
+        throw new Error(`watch timed out after ${timeoutSeconds} seconds`);
+      }
+      const controller = new AbortController();
+      const timeout = remainingMs ? setTimeout(() => controller.abort(), remainingMs) : null;
+      try {
+        return await this.readReviewEvents(reviewId, controller.signal);
+      } catch (error) {
+        if (isAbortError(error)) {
+          throw new Error(`watch timed out after ${timeoutSeconds} seconds`);
+        }
+        if (!isPrematureWatchEnd(error)) {
+          throw error;
+        }
+        await sleep(500);
+      } finally {
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+      }
+    }
+  }
+  async readReviewEvents(reviewId, signal) {
+    const response = await fetch(`${this.baseUrl}/api/reviews/${reviewId}/events`, {
+      signal
+    });
+    if (!response.ok || !response.body) {
+      throw new Error(`watch failed: ${response.status} ${await response.text()}`);
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        throw new Error("watch stream ended before completion");
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const events = buffer.split("\n\n");
+      buffer = events.pop() ?? "";
+      for (const eventChunk of events) {
+        const dataLine = eventChunk.split("\n").find((line) => line.startsWith("data:"));
+        if (!dataLine) {
+          continue;
+        }
+        const event = JSON.parse(dataLine.slice(5).trim());
+        if (event.type === "review.submitted" || event.type === "review.cancelled") {
+          return event;
+        }
+      }
+    }
+  }
+  async get(path3) {
+    const response = await fetch(`${this.baseUrl}${path3}`);
+    return parseResponse(response);
+  }
+  async post(path3, body) {
+    const response = await fetch(`${this.baseUrl}${path3}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    return parseResponse(response);
+  }
+  async delete(path3) {
+    const response = await fetch(`${this.baseUrl}${path3}`, { method: "DELETE" });
+    return parseResponse(response);
+  }
+};
+async function parseResponse(response) {
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}: ${await response.text()}`);
+  }
+  return await response.json();
+}
+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";
+}
+async function sleep(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, 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}`;
+}
+async function isServerResponsive(info) {
+  if (!isPidAlive(info.pid)) {
+    return false;
+  }
+  try {
+    const health = await new ServerClient(serverUrl(info)).health();
+    return health.ok === true;
+  } catch {
+    return false;
+  }
+}
+async function ensureServer(options = {}) {
+  const existing = await readServerInfo();
+  if (existing && await isServerResponsive(existing)) {
+    return existing;
+  }
+  return startServer(options);
+}
+async function startServer(options = {}) {
+  const existing = await readServerInfo();
+  if (existing && await isServerResponsive(existing)) {
+    return existing;
+  }
+  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.`);
+  }
+  const logFd = openSync(globalServerLogFile(), "a");
+  const child = spawn(process.execPath, [daemonPath], {
+    detached: true,
+    env: {
+      ...process.env,
+      GLOSS_PORT: String(port),
+      GLOSS_STATE_DIR: globalStateDir()
+    },
+    stdio: ["ignore", logFd, logFd]
+  });
+  child.unref();
+  const info = {
+    pid: child.pid ?? -1,
+    port,
+    version: packageVersion,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stateDir: globalStateDir()
+  };
+  await writeFile(globalServerFile(), `${JSON.stringify(info, null, 2)}
+`);
+  const deadline = Date.now() + 8e3;
+  while (Date.now() < deadline) {
+    if (await isServerResponsive(info)) {
+      return info;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 150));
+  }
+  throw new Error(`Server did not become responsive. See ${globalServerLogFile()}`);
+}
+async function stopServer() {
+  const info = await readServerInfo();
+  if (!info) {
+    return { stopped: false, info: null };
+  }
+  if (isPidAlive(info.pid)) {
+    process.kill(info.pid, "SIGTERM");
+  }
+  await rm(globalServerFile(), { force: true });
+  return { stopped: true, info };
+}
+function isPidAlive(pid) {
+  if (pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/server/store.ts
 import { readdir, readFile as readFile2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { ulid } from "ulid";
@@ -850,6 +799,9 @@ var ReviewStore = class {
     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 timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const feedback = {
       version: 1,
@@ -862,7 +814,7 @@ var ReviewStore = class {
       )
     };
     record.feedback = feedback;
-    record.meta = { ...record.meta, status: "completed", completedAt: timestamp };
+    record.meta = { ...record.meta, status: "submitted", submittedAt: timestamp };
     this.reviews.set(id, record);
     const artifactDir = globalReviewDir(id);
     const feedbackPath = globalReviewFeedbackFile(id);
@@ -882,7 +834,7 @@ var ReviewStore = class {
       writeFile2(markdownPath, serializeFeedbackMarkdown(feedback))
     ]);
     this.emit({
-      type: "review.completed",
+      type: "review.submitted",
       reviewId: id,
       counts: {
         files: new Set(feedback.comments.map((comment) => comment.filePath)).size,
@@ -900,19 +852,88 @@ var ReviewStore = class {
     if (!record) {
       throw new Error(`Review ${id} not found`);
     }
+    this.assertResolvable(record, id);
     const resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const resolvedPath = globalReviewResolvedFile(id);
+    const existingById = new Map(
+      (record.resolution?.comments ?? []).map((comment) => [comment.commentId, comment])
+    );
+    const comments = this.sortResolvedComments(
+      (record.feedback?.comments ?? []).map((comment) => ({
+        ...existingById.get(comment.id),
+        commentId: comment.id,
+        status: "resolved",
+        resolvedAt: existingById.get(comment.id)?.resolvedAt ?? resolvedAt
+      })),
+      record
+    );
+    const resolution = {
+      reviewId: id,
+      status: "resolved",
+      summary: summary ?? record.resolution?.summary ?? null,
+      resolvedAt,
+      comments
+    };
     record.meta = { ...record.meta, status: "resolved", resolvedAt };
-    this.reviews.set(id, record);
-    await ensureDir(globalReviewDir(id));
-    await writeFile2(
-      resolvedPath,
-      `${JSON.stringify({ reviewId: id, summary: summary ?? null, resolvedAt }, null, 2)}
-`
+    return this.persistResolution(record, resolution);
+  }
+  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 resolvedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const previous = record.resolution?.comments.find((comment) => comment.commentId === commentId);
+    const nextSummary = summary ?? previous?.summary;
+    const nextComment = {
+      commentId,
+      status: "resolved",
+      ...nextSummary ? { summary: nextSummary } : {},
+      resolvedAt
+    };
+    const comments = this.sortResolvedComments(
+      [
+        ...(record.resolution?.comments ?? []).filter((comment) => comment.commentId !== commentId),
+        nextComment
+      ],
+      record
     );
-    await writeFile2(globalReviewMetaFile(id), `${JSON.stringify(record.meta, null, 2)}
-`);
-    return resolvedPath;
+    const counts = this.resolutionCounts(record, comments);
+    const fullyResolved = counts.total === counts.resolved;
+    const resolution = {
+      reviewId: id,
+      status: fullyResolved ? "resolved" : "partial",
+      summary: fullyResolved ? record.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);
+  }
+  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 comments = this.sortResolvedComments(
+      (record.resolution?.comments ?? []).filter((comment) => comment.commentId !== commentId),
+      record
+    );
+    const counts = this.resolutionCounts(record, comments);
+    const fullyResolved = counts.total > 0 && counts.total === counts.resolved;
+    const resolvedAt = fullyResolved ? (/* @__PURE__ */ new Date()).toISOString() : null;
+    const resolution = {
+      reviewId: id,
+      status: fullyResolved ? "resolved" : "partial",
+      summary: fullyResolved ? record.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);
   }
   subscribe(reviewId, listener) {
     const listeners = this.listeners.get(reviewId) ?? /* @__PURE__ */ new Set();
@@ -967,6 +988,7 @@ var ReviewStore = class {
       const meta = JSON.parse(metaRaw);
       const diff = JSON.parse(diffRaw);
       let feedback;
+      let resolution;
       try {
         feedback = JSON.parse(
           await readFile2(globalReviewFeedbackFile(id), "utf8")
@@ -974,6 +996,13 @@ var ReviewStore = class {
       } catch {
         feedback = void 0;
       }
+      try {
+        resolution = JSON.parse(
+          await readFile2(globalReviewResolvedFile(id), "utf8")
+        );
+      } catch {
+        resolution = void 0;
+      }
       const record = {
         meta: {
           ...meta,
@@ -982,7 +1011,8 @@ var ReviewStore = class {
           markdownPath: meta.markdownPath ?? (feedback ? globalReviewMarkdownFile(id) : void 0)
         },
         diff,
-        feedback
+        feedback,
+        resolution
       };
       this.reviews.set(id, record);
       return record;
@@ -990,6 +1020,60 @@ var ReviewStore = class {
       return null;
     }
   }
+  assertResolvable(record, id) {
+    if (record.meta.status !== "submitted" && record.meta.status !== "resolved") {
+      throw new Error(`Review ${id} is ${record.meta.status} and cannot be resolved`);
+    }
+    if (!record.feedback) {
+      throw new Error(`Review ${id} has no submitted feedback`);
+    }
+  }
+  assertCommentExists(record, commentId) {
+    if (!record.feedback.comments.some((comment) => comment.id === commentId)) {
+      throw new Error(`Comment ${commentId} not found`);
+    }
+  }
+  async persistResolution(record, resolution) {
+    record.resolution = resolution;
+    this.reviews.set(record.meta.id, record);
+    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)}
+`)
+    ]);
+    return {
+      ok: true,
+      reviewId: record.meta.id,
+      status: record.meta.status,
+      resolutionStatus: resolution.status,
+      comments: this.resolutionCounts(record, resolution.comments),
+      path: resolvedPath,
+      resolution
+    };
+  }
+  sortResolvedComments(comments, record) {
+    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)
+    );
+  }
+  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
+    };
+  }
 };
 var reviewStore = new ReviewStore();
 
@@ -1022,9 +1106,9 @@ program.command("open").description("Capture local changes and open them for rev
   async (options) => {
     const globals = program.opts();
     const info = await ensureServer();
-    const client2 = new ServerClient(serverUrl(info));
+    const client = new ServerClient(serverUrl(info));
     const diff = await captureDiff(options.base);
-    const { meta, url } = await client2.createReview(diff);
+    const { meta, url } = await client.createReview(diff);
     if (options.printUrl) {
       printPlain(url);
     }
@@ -1042,16 +1126,16 @@ program.command("open").description("Capture local changes and open them for rev
       globals.json ? printJson(result2) : printPlain(`Review ${meta.id}: ${url}`);
       return;
     }
-    const event = await client2.watchReview(meta.id, options.timeout);
+    const event = await client.watchReview(meta.id, options.timeout);
     if (event.type === "review.cancelled") {
       process.exitCode = 2;
       globals.json ? printJson(event) : printPlain(`Review ${meta.id} cancelled`);
       return;
     }
-    if (event.type !== "review.completed") {
+    if (event.type !== "review.submitted") {
       throw new Error(`Unexpected review event ${event.type}`);
     }
-    const feedback = await client2.getFeedback(meta.id);
+    const feedback = await client.getFeedback(meta.id);
     const result = {
       reviewId: meta.id,
       url,
@@ -1062,14 +1146,14 @@ program.command("open").description("Capture local changes and open them for rev
       artifactDir: globalReviewDir(meta.id),
       feedback
     };
-    globals.json ? printJson(result) : printPlain(`Review ${meta.id} completed with ${event.counts.comments} comments`);
+    globals.json ? printJson(result) : printPlain(`Review ${meta.id} submitted with ${event.counts.comments} comments`);
   }
 );
-program.command("watch").argument("<reviewId>", "review id").description("Wait for review.completed for an existing review").option("--timeout <seconds>", "watch timeout in seconds", Number).action(async (reviewId, options) => {
+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 client2 = new ServerClient(serverUrl(info));
-  const event = await client2.watchReview(reviewId, options.timeout);
+  const client = new ServerClient(serverUrl(info));
+  const event = await client.watchReview(reviewId, options.timeout);
   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) => {
@@ -1092,8 +1176,22 @@ program.command("stop").description("Stop the managed background server").option
   const result = await stopServer();
   globals.json ? printJson(result) : printPlain(result.stopped ? "Gloss server stopped" : "Gloss server was not running");
 });
-program.command("mcp").description("Start the experimental stdio MCP server").action(async () => {
-  await startMcpServer();
+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) => {
+  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`
+  );
 });
 program.command("doctor").description("Diagnose setup and validate git/state").action(async () => {
   const globals = program.opts();