getgloss 0.13.2 → 0.14.0

package/dist/server/daemon.js

@@ -10,7 +10,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.13.2",
+  version: "0.14.0",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -92,6 +92,7 @@ var package_default = {
 
 // src/shared/paths.ts
 var packageVersion = package_default.version;
+var protocolVersion = 1;
 function expandHome(input) {
   if (input === "~") {
     return homedir();
@@ -149,6 +150,9 @@ function globalReviewMarkdownFile(reviewId) {
 function globalReviewResolvedFile(reviewId) {
   return path.join(globalReviewDir(reviewId), "resolved.json");
 }
+function globalReviewEventsFile(reviewId) {
+  return path.join(globalReviewDir(reviewId), "events.jsonl");
+}
 async function ensureDir(dir) {
   await mkdir(dir, { recursive: true });
 }
@@ -205,6 +209,14 @@ var SOURCE_PEEK_MAX_BYTES = 35e4;
 var SOURCE_PEEK_RANGE_MAX_LINES = 240;
 var REVIEW_SCOPE_MODES = ["all", "single", "range"];
 var RESOLUTION_STATUSES = ["partial", "resolved"];
+var REVIEW_EVENT_ACTORS = ["human", "agent", "system"];
+var AGENT_STATUSES = ["claimed", "working", "blocked", "completed", "failed"];
+var REVIEW_UPDATE_REASONS = [
+  "review-resolved",
+  "comment-resolved",
+  "comment-reopened",
+  "turn-created"
+];
 var OPEN_FILE_SCOPES = ["review", "repo"];
 var OPEN_FILE_TARGETS = [
   "default",
@@ -253,7 +265,7 @@ function parseJsonValue(value, guard, label) {
   return value;
 }
 function isServerInfo(value) {
-  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir) && isOptionalString(value.cwd) && isOptionalString(value.daemonPath);
+  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isOptionalNumber(value.protocolVersion) && isString(value.startedAt) && isString(value.stateDir) && isOptionalString(value.cwd) && isOptionalString(value.daemonPath);
 }
 function isClearReviewsRequest(value) {
   return isRecord(value) && isOptionalNonNegativeInteger(value.olderThanDays) && isOptionalBoolean(value.dryRun);
@@ -276,6 +288,12 @@ function isSourcePeekRequest(value) {
 function isSourcePeekRangeRequest(value) {
   return isRecord(value) && isString(value.filePath) && isOptionalString(value.turnId) && isDiffContextSource(value.source) && isOneOf(value.side, SIDES) && isPositiveInteger(value.startLine) && isPositiveInteger(value.lineCount) && value.lineCount <= SOURCE_PEEK_RANGE_MAX_LINES;
 }
+function isAgentClaimRequest(value) {
+  return isRecord(value) && isOptionalString(value.message) && isOptionalString(value.turn);
+}
+function isAgentNoteRequest(value) {
+  return isRecord(value) && isString(value.message) && isOptional(value.status, isAgentStatus) && isOptionalString(value.turn);
+}
 function isSubmitReviewRequest(value) {
   return isRecord(value) && isArrayOf(value.comments, isComment) && isOptional(value.reviewScope, isReviewScope);
 }
@@ -300,6 +318,31 @@ function isFeedbackBundle(value) {
 function isResolutionBundle(value) {
   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)) {
+    return false;
+  }
+  if (!hasValidReviewEventEnvelope(value)) {
+    return false;
+  }
+  switch (value.type) {
+    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 isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isRecord(value.counts) && isNumber(value.counts.files) && isNumber(value.counts.comments);
+    case "review.updated":
+      return isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isReviewUpdateReason(value.reason) && isReviewStatus(value.status) && isResolutionStatus(value.resolutionStatus) && isResolutionCounts(value.counts);
+    case "agent.claimed":
+      return isString(value.turnId) && isNumber(value.turnIndex) && value.status === "claimed" && isOptionalString(value.message);
+    case "agent.note":
+      return isOptionalString(value.turnId) && isOptionalNumber(value.turnIndex) && isOptional(value.status, isAgentStatus) && isString(value.message);
+    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);
 }
@@ -391,6 +434,18 @@ function isOpenFileScope(value) {
 function isOpenFileTarget(value) {
   return isOneOf(value, OPEN_FILE_TARGETS);
 }
+function isReviewUpdateReason(value) {
+  return isOneOf(value, REVIEW_UPDATE_REASONS);
+}
+function isReviewEventActor(value) {
+  return isOneOf(value, REVIEW_EVENT_ACTORS);
+}
+function isAgentStatus(value) {
+  return isOneOf(value, AGENT_STATUSES);
+}
+function hasValidReviewEventEnvelope(value) {
+  return isOptionalString(value.id) && isOptionalNumber(value.seq) && isOptionalString(value.createdAt) && isOptional(value.actor, isReviewEventActor);
+}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -585,50 +640,6 @@ import { fileURLToPath } from "url";
 import { Hono } from "hono";
 import { streamSSE } from "hono/streaming";
 
-// src/shared/comments.ts
-function isLineComment(comment) {
-  return comment.kind === void 0 || comment.kind === "line";
-}
-function compareCommentsByLocation(a, b) {
-  const aIsLine = isLineComment(a);
-  const bIsLine = isLineComment(b);
-  if (!aIsLine || !bIsLine) {
-    if (aIsLine !== bIsLine) {
-      return aIsLine ? 1 : -1;
-    }
-    return a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id);
-  }
-  return a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine || a.endLine - b.endLine || a.side.localeCompare(b.side);
-}
-function countCommentFiles(comments) {
-  const filePaths = /* @__PURE__ */ new Set();
-  for (const comment of comments) {
-    if (isLineComment(comment)) {
-      filePaths.add(comment.filePath);
-    }
-  }
-  return filePaths.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/git-diff.ts
 import { readFile as readFile2 } from "fs/promises";
 import path5 from "path";
@@ -884,11 +895,6 @@ function splitFileLines(contents) {
   return lines;
 }
 
-// src/shared/reviews.ts
-function isResolvableReviewStatus(status) {
-  return status === "submitted" || status === "resolved";
-}
-
 // src/server/local-open.ts
 import { execFile } from "child_process";
 import { access } from "fs/promises";
@@ -1652,7 +1658,7 @@ function escapeExtendedGrep(value) {
 
 // src/server/store.ts
 import { createHash } from "crypto";
-import { readdir as readdir2, readFile as readFile5 } from "fs/promises";
+import { appendFile, readdir as readdir2, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
 import path8 from "path";
 import { ulid } from "ulid";
 
@@ -1870,6 +1876,50 @@ function cleanupResult({
   };
 }
 
+// src/shared/comments.ts
+function isLineComment(comment) {
+  return comment.kind === void 0 || comment.kind === "line";
+}
+function compareCommentsByLocation(a, b) {
+  const aIsLine = isLineComment(a);
+  const bIsLine = isLineComment(b);
+  if (!aIsLine || !bIsLine) {
+    if (aIsLine !== bIsLine) {
+      return aIsLine ? 1 : -1;
+    }
+    return a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id);
+  }
+  return a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine || a.endLine - b.endLine || a.side.localeCompare(b.side);
+}
+function countCommentFiles(comments) {
+  const filePaths = /* @__PURE__ */ new Set();
+  for (const comment of comments) {
+    if (isLineComment(comment)) {
+      filePaths.add(comment.filePath);
+    }
+  }
+  return filePaths.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/review-scope.ts
 var ALL_REVIEW_SCOPE = { mode: "all" };
 function normalizeReviewScope(diff, scope = ALL_REVIEW_SCOPE) {
@@ -1992,6 +2042,11 @@ function firstNonEmptyLine(text) {
   return void 0;
 }
 
+// src/shared/reviews.ts
+function isResolvableReviewStatus(status) {
+  return status === "submitted" || status === "resolved";
+}
+
 // src/server/store.ts
 var ReviewStore = class {
   reviews = /* @__PURE__ */ new Map();
@@ -2013,8 +2068,11 @@ var ReviewStore = class {
     const record = normalizeRecord({ meta, turns: [turn], diff: turn.diff });
     this.reviews.set(id, record);
     await this.persistInitial(record, turn);
-    this.emit({ type: "review.opened", reviewId: id });
-    return record;
+    const event = await this.appendReviewEvent(id, "system", {
+      type: "review.opened",
+      reviewId: id
+    });
+    return withEvents(record, [event]);
   }
   async appendTurn(id, diff) {
     const record = await this.get(id);
@@ -2027,14 +2085,18 @@ var ReviewStore = class {
     const latest = latestTurn(record);
     if (latest.status === "pending") {
       if (diffFingerprint(latest.diff) === diffFingerprint(diff)) {
-        this.emit({
+        await this.appendReviewEvent(id, "system", {
           type: "review.turn.created",
           reviewId: id,
           turnId: latest.id,
           turnIndex: latest.index,
           reused: true
         });
-        return { record, turn: latest, reused: true };
+        return {
+          record: withEvents(record, await this.readEvents(id)),
+          turn: latest,
+          reused: true
+        };
       }
       throw new Error(`Review ${id} already has a pending turn`);
     }
@@ -2049,14 +2111,18 @@ var ReviewStore = class {
     });
     this.reviews.set(id, nextRecord);
     await this.persistInitial(nextRecord, turn);
-    this.emit({
+    await this.appendReviewEvent(id, "system", {
       type: "review.turn.created",
       reviewId: id,
       turnId: turn.id,
       turnIndex: turn.index,
       reused: false
     });
-    return { record: nextRecord, turn, reused: false };
+    return {
+      record: withEvents(nextRecord, await this.readEvents(id)),
+      turn,
+      reused: false
+    };
   }
   async list() {
     await this.loadAllReviews();
@@ -2128,7 +2194,7 @@ var ReviewStore = class {
       writeTextFile(markdownPath, serializeFeedbackMarkdown(feedback))
     ]);
     await this.persistMeta(nextRecord);
-    this.emit({
+    await this.appendReviewEvent(id, "human", {
       type: "review.submitted",
       reviewId: id,
       turnId: nextTurn.id,
@@ -2138,12 +2204,86 @@ var ReviewStore = class {
         comments: feedback.comments.length
       }
     });
-    return { record: nextRecord, feedbackPath, markdownPath, turn: nextTurn };
+    return {
+      record: withEvents(nextRecord, await this.readEvents(id)),
+      feedbackPath,
+      markdownPath,
+      turn: nextTurn
+    };
   }
   async feedback(id) {
     const record = await this.get(id);
     return record?.feedback ?? null;
   }
+  async events(id, afterSeq = 0) {
+    const record = await this.get(id);
+    if (!record) {
+      return [];
+    }
+    return this.readEvents(id, afterSeq);
+  }
+  async claim(id, message, turnSelector) {
+    const record = await this.get(id);
+    if (!record) {
+      throw new Error(`Review ${id} not found`);
+    }
+    const turn = turnSelector ? this.resolveTurnSelector(record, turnSelector) : [...record.turns].reverse().find((candidate) => candidate.status === "submitted");
+    if (!turn) {
+      throw new Error(`Review ${id} has no submitted unresolved turn to claim`);
+    }
+    if (turn.status !== "submitted") {
+      throw new Error(`Review ${id} turn ${turn.index} is ${turn.status} and cannot be claimed`);
+    }
+    this.assertResolvable(turn, id);
+    if (!turn.feedbackPath || !turn.markdownPath) {
+      throw new Error(`Review ${id} turn ${turn.index} is missing feedback paths`);
+    }
+    const event = await this.appendReviewEvent(id, "agent", {
+      type: "agent.claimed",
+      reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
+      status: "claimed",
+      ...message ? { message } : {}
+    });
+    return {
+      ok: true,
+      reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
+      status: "claimed",
+      feedbackPath: turn.feedbackPath,
+      markdownPath: turn.markdownPath,
+      artifactDir: turn.artifactDir,
+      feedback: turn.feedback,
+      ...turn.resolution ? { resolution: turn.resolution } : {},
+      event
+    };
+  }
+  async addAgentNote(id, message, status, turnSelector) {
+    const record = await this.get(id);
+    if (!record) {
+      throw new Error(`Review ${id} not found`);
+    }
+    const turn = turnSelector ? this.resolveTurnSelector(record, turnSelector) : activeTurn(record);
+    const event = await this.appendReviewEvent(id, "agent", {
+      type: "agent.note",
+      reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
+      ...status ? { status } : {},
+      message
+    });
+    return {
+      ok: true,
+      reviewId: id,
+      turnId: turn.id,
+      turnIndex: turn.index,
+      ...status ? { status } : {},
+      message,
+      event
+    };
+  }
   async markResolved(id, summary, turnSelector) {
     const record = await this.get(id);
     if (!record) {
@@ -2272,6 +2412,75 @@ var ReviewStore = class {
       }
     };
   }
+  async appendReviewEvent(reviewId, actor, input) {
+    const persistedEvents = await this.readPersistedEvents(reviewId);
+    let existingEvents = persistedEvents ?? [];
+    if (!persistedEvents && input.type !== "review.opened") {
+      const record2 = this.reviews.get(reviewId) ?? await this.loadKnownReview(reviewId);
+      existingEvents = record2 ? synthesizeReviewEvents(record2) : [];
+      if (existingEvents.length > 0) {
+        await ensureDir(globalReviewDir(reviewId));
+        await writeFile3(
+          globalReviewEventsFile(reviewId),
+          `${existingEvents.map((event2) => JSON.stringify(event2)).join("\n")}
+`
+        );
+      }
+    }
+    const event = {
+      ...input,
+      id: ulid(),
+      seq: nextEventSeq(existingEvents),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      actor
+    };
+    await ensureDir(globalReviewDir(reviewId));
+    await appendFile(globalReviewEventsFile(reviewId), `${JSON.stringify(event)}
+`);
+    const record = this.reviews.get(reviewId);
+    if (record) {
+      this.reviews.set(reviewId, withEvents(record, [...existingEvents, event]));
+    }
+    this.emit(event);
+    return event;
+  }
+  async readEvents(reviewId, afterSeq = 0) {
+    const persistedEvents = await this.readPersistedEvents(reviewId);
+    if (!persistedEvents) {
+      const record = this.reviews.get(reviewId) ?? await this.loadKnownReview(reviewId);
+      if (!record) {
+        return [];
+      }
+      const synthesized = synthesizeReviewEvents(record);
+      if (synthesized.length > 0) {
+        await ensureDir(globalReviewDir(reviewId));
+        await writeFile3(
+          globalReviewEventsFile(reviewId),
+          `${synthesized.map((event) => JSON.stringify(event)).join("\n")}
+`
+        );
+      }
+      this.reviews.set(reviewId, withEvents(record, synthesized));
+      return synthesized.filter((event) => (event.seq ?? 0) > afterSeq);
+    }
+    return persistedEvents.filter((event) => (event.seq ?? 0) > afterSeq);
+  }
+  async readPersistedEvents(reviewId) {
+    let raw;
+    try {
+      raw = await readFile5(globalReviewEventsFile(reviewId), "utf8");
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return null;
+      }
+      throw new Error(`Could not read review events for ${reviewId}: ${formatError(error)}`, {
+        cause: error
+      });
+    }
+    return raw.split("\n").map((line) => line.trim()).filter(Boolean).map(
+      (line) => parseJsonFile(line, isReviewEvent, "review event", globalReviewEventsFile(reviewId))
+    ).filter((event) => event.reviewId === reviewId);
+  }
   emit(event) {
     for (const listener of this.listeners.get(event.reviewId) ?? []) {
       listener(event);
@@ -2357,7 +2566,9 @@ var ReviewStore = class {
       diff: latest.diff
     });
     this.reviews.set(id, record);
-    return record;
+    const withTimeline = withEvents(record, await this.readEvents(id));
+    this.reviews.set(id, withTimeline);
+    return withTimeline;
   }
   async loadReviewFromTurnsOnly(id) {
     const turns = await this.loadPersistedTurns(id);
@@ -2380,8 +2591,10 @@ var ReviewStore = class {
       diff: latest.diff
     });
     this.reviews.set(id, record);
-    await this.persistMeta(record);
-    return record;
+    const withTimeline = withEvents(record, await this.readEvents(id));
+    this.reviews.set(id, withTimeline);
+    await this.persistMeta(withTimeline);
+    return withTimeline;
   }
   async loadPersistedTurns(id) {
     let entries;
@@ -2526,7 +2739,7 @@ var ReviewStore = class {
       path: resolvedPath,
       resolution
     };
-    this.emit({
+    await this.appendReviewEvent(record.meta.id, "agent", {
       type: "review.updated",
       reviewId: record.meta.id,
       turnId: nextTurn.id,
@@ -2618,6 +2831,88 @@ function turnSummary(turn) {
     comments: resolutionCounts(turn.feedback, turn.resolution?.comments ?? [])
   };
 }
+function withEvents(record, events) {
+  return { ...record, events: events.toSorted(compareReviewEvents) };
+}
+function nextEventSeq(events) {
+  return Math.max(0, ...events.map((event) => event.seq ?? 0)) + 1;
+}
+function synthesizeReviewEvents(record) {
+  let seq = 1;
+  const next = (actor, input, createdAt) => ({
+    ...input,
+    id: ulid(),
+    seq: seq++,
+    createdAt,
+    actor
+  });
+  const events = [
+    next("system", { type: "review.opened", reviewId: record.meta.id }, record.meta.createdAt)
+  ];
+  const turns = record.turns.toSorted((a, b) => a.index - b.index);
+  for (const turn of turns) {
+    if (turn.index > 1) {
+      events.push(
+        next(
+          "system",
+          {
+            type: "review.turn.created",
+            reviewId: record.meta.id,
+            turnId: turn.id,
+            turnIndex: turn.index,
+            reused: false
+          },
+          turn.createdAt
+        )
+      );
+    }
+    if (turn.feedback) {
+      events.push(
+        next(
+          "human",
+          {
+            type: "review.submitted",
+            reviewId: record.meta.id,
+            turnId: turn.id,
+            turnIndex: turn.index,
+            counts: {
+              files: countCommentFiles(turn.feedback.comments),
+              comments: turn.feedback.comments.length
+            }
+          },
+          turn.submittedAt ?? turn.feedback.timestamp
+        )
+      );
+    }
+    if (turn.feedback && turn.resolution) {
+      const counts = resolutionCounts(turn.feedback, turn.resolution.comments);
+      events.push(
+        next(
+          "agent",
+          {
+            type: "review.updated",
+            reviewId: record.meta.id,
+            turnId: turn.id,
+            turnIndex: turn.index,
+            reason: turn.resolution.status === "resolved" ? "review-resolved" : "comment-resolved",
+            status: turn.status,
+            resolutionStatus: turn.resolution.status,
+            counts
+          },
+          turn.resolution.resolvedAt ?? turn.resolution.comments.at(-1)?.resolvedAt ?? turn.resolvedAt ?? turn.submittedAt ?? turn.createdAt
+        )
+      );
+    }
+  }
+  return events.toSorted(compareReviewEvents);
+}
+function compareReviewEvents(left, right) {
+  const seqDelta = (left.seq ?? 0) - (right.seq ?? 0);
+  if (seqDelta !== 0) {
+    return seqDelta;
+  }
+  return (left.createdAt ?? "").localeCompare(right.createdAt ?? "");
+}
 function reconcileTurn(meta, diff, feedback, resolution) {
   const status = resolution?.status === "resolved" ? "resolved" : feedback ? "submitted" : "pending";
   return {
@@ -2700,7 +2995,9 @@ function createApp(origin2, options = {}) {
     const response = {
       ok: true,
       version: packageVersion,
+      protocolVersion,
       activeReviews: reviews.filter((review) => review.status === "pending").length,
+      stateDir: globalStateDir(),
       ...options.health?.()
     };
     return c.json(response);
@@ -2782,14 +3079,56 @@ function createApp(origin2, options = {}) {
     }
     return c.json(feedback);
   });
+  app.post("/api/reviews/:id/agent/claim", async (c) => {
+    const id = c.req.param("id");
+    const existing = await reviewStore.get(id);
+    if (!existing) {
+      return c.json({ error: "review not found" }, 404);
+    }
+    const parsed = await readOptionalJsonBody(c, isAgentClaimRequest, "agent claim request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const body = parsed.body;
+    try {
+      const result = await reviewStore.claim(id, body.message, body.turn);
+      options.onReviewActivity?.();
+      return c.json(result);
+    } catch (error) {
+      return c.json({ error: formatError(error) }, statusForStoreError(error));
+    }
+  });
+  app.post("/api/reviews/:id/agent/notes", async (c) => {
+    const id = c.req.param("id");
+    const existing = await reviewStore.get(id);
+    if (!existing) {
+      return c.json({ error: "review not found" }, 404);
+    }
+    const parsed = await readJsonBody(c, isAgentNoteRequest, "agent note request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const body = parsed.body;
+    try {
+      const result = await reviewStore.addAgentNote(id, body.message, body.status, body.turn);
+      options.onReviewActivity?.();
+      return c.json(result);
+    } catch (error) {
+      return c.json({ error: formatError(error) }, statusForStoreError(error));
+    }
+  });
   app.get("/api/reviews/:id/events", async (c) => {
     const id = c.req.param("id");
     const record = await reviewStore.get(id);
     if (!record) {
       return c.json({ error: "review not found" }, 404);
     }
+    const afterSeq = eventReplayAfterSeq(c);
     return streamSSE(c, async (stream) => {
       let closed = false;
+      let replaying = true;
+      let lastSentSeq = afterSeq;
+      const bufferedEvents = [];
       let pending = Promise.resolve();
       let cleanup = null;
       let close = null;
@@ -2806,14 +3145,30 @@ function createApp(origin2, options = {}) {
       });
       unregisterEventStream = options.registerEventStream?.(() => close?.()) ?? null;
       const send = (event) => {
-        pending = pending.then(() => stream.writeSSE({ data: JSON.stringify(event) })).then(() => {
+        const eventSeq = event.seq ?? 0;
+        if (eventSeq > 0 && eventSeq <= lastSentSeq) {
+          return;
+        }
+        if (eventSeq > 0) {
+          lastSentSeq = eventSeq;
+        }
+        pending = pending.then(() => {
+          const data = JSON.stringify(event);
+          return event.seq ? stream.writeSSE({ data, id: String(event.seq) }) : stream.writeSSE({ data });
+        }).then(() => {
           if (event.type === "review.cancelled") {
             close?.();
           }
         });
         void pending.catch(() => close?.());
       };
-      const unsubscribe = reviewStore.subscribe(id, send);
+      const unsubscribe = reviewStore.subscribe(id, (event) => {
+        if (replaying) {
+          bufferedEvents.push(event);
+          return;
+        }
+        send(event);
+      });
       const heartbeat = setInterval(() => {
         pending = pending.then(async () => {
           await stream.write(`: keep-alive ${Date.now()}
@@ -2829,18 +3184,12 @@ function createApp(origin2, options = {}) {
         unregisterEventStream = null;
       };
       stream.onAbort(() => close?.());
-      send({ type: "review.opened", reviewId: id });
-      if (isResolvableReviewStatus(record.meta.status) && record.feedback) {
-        send({
-          type: "review.submitted",
-          reviewId: id,
-          turnId: record.meta.activeTurnId,
-          turnIndex: record.meta.turns?.find((turn) => turn.id === record.meta.activeTurnId)?.index,
-          counts: {
-            files: countCommentFiles(record.feedback.comments),
-            comments: record.feedback.comments.length
-          }
-        });
+      for (const event of await reviewStore.events(id, afterSeq)) {
+        send(event);
+      }
+      replaying = false;
+      for (const event of bufferedEvents) {
+        send(event);
       }
       await closedPromise;
     });
@@ -3310,6 +3659,12 @@ function serveRootFile(fileName, contentType) {
     }
   };
 }
+function eventReplayAfterSeq(c) {
+  const url = new URL(c.req.url);
+  const rawAfter = url.searchParams.get("after") ?? c.req.header("last-event-id") ?? "0";
+  const afterSeq = Number(rawAfter);
+  return Number.isInteger(afterSeq) && afterSeq > 0 ? afterSeq : 0;
+}
 async function readJsonBody(c, guard, label) {
   let body;
   try {
@@ -3329,6 +3684,34 @@ async function readJsonBody(c, guard, label) {
     };
   }
 }
+async function readOptionalJsonBody(c, guard, label) {
+  let raw;
+  try {
+    raw = await c.req.text();
+  } catch (error) {
+    return {
+      ok: false,
+      response: c.json({ error: `invalid JSON body: ${formatError(error)}` }, 400)
+    };
+  }
+  let body;
+  try {
+    body = raw.trim().length > 0 ? JSON.parse(raw) : {};
+  } catch (error) {
+    return {
+      ok: false,
+      response: c.json({ error: `invalid JSON body: ${formatError(error)}` }, 400)
+    };
+  }
+  try {
+    return { ok: true, body: parseJsonValue(body, guard, label) };
+  } catch (error) {
+    return {
+      ok: false,
+      response: c.json({ error: formatError(error) }, 400)
+    };
+  }
+}
 function isPathWithin(parentPath, childPath) {
   const relative = path9.relative(parentPath, childPath);
   return relative === "" || !relative.startsWith("..") && !path9.isAbsolute(relative);
@@ -3473,6 +3856,7 @@ await writeServerInfo({
   pid: process.pid,
   port,
   version: packageVersion,
+  protocolVersion,
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   stateDir: globalStateDir(),
   cwd: process.cwd(),