@shiyuphan/follow-me 0.3.0 → 0.4.1

package/dist/src/evolve.js

@@ -0,0 +1,123 @@
+/**
+ * How a plan follows its branch when the tip moves. A unit id hashes its path and hunk body, so
+ * an id that survives names the same change and keeps its place in the plan; everything else is
+ * either gone or new, and the agent decides where the new units go.
+ */
+import { tipStartOf } from "./diff.js";
+/** Pure. Responses start empty: they answer the review of the old version, not this one. */
+export function evolvePlan(oldPlan, oldDiff, newDiff) {
+    const gone = new Map();
+    const commits = [];
+    oldPlan.commits.forEach((commit, index) => {
+        const units = commit.units.filter((ref) => newDiff.units.has(ref.unit));
+        for (const ref of commit.units) {
+            const unit = oldDiff.units.get(ref.unit);
+            if (newDiff.units.has(ref.unit) || unit === undefined)
+                continue;
+            const seen = gone.get(ref.unit)?.commits ?? [];
+            gone.set(ref.unit, { unit, commits: [...seen, { index, message: commit.message }] });
+        }
+        if (units.length > 0)
+            commits.push({ ...commit, units });
+    });
+    const taken = new Set(oldPlan.commits.flatMap((c) => c.units.map((ref) => ref.unit)));
+    return {
+        draft: {
+            schema: oldPlan.schema,
+            base: newDiff.base,
+            tip: newDiff.tip,
+            commits,
+            responses: [],
+        },
+        vanished: [...gone.values()],
+        added: [...newDiff.units.values()].filter((unit) => !taken.has(unit.id)),
+    };
+}
+/** The tip line of each body row; a removed row gets the line that follows it. */
+function tipLines(hunk, units) {
+    let line = tipStartOf(hunk, units);
+    return hunk.body.map((row) => {
+        const at = line;
+        if (row.op !== "-")
+            line += 1;
+        return at;
+    });
+}
+/** The body row a hunk comment points at first: its first picked row, else its first change. */
+function firstRow(comment, hunk) {
+    const { anchor } = comment;
+    if (anchor.kind !== "hunk")
+        return 0;
+    const picked = anchor.offsets?.[0];
+    if (picked !== undefined)
+        return picked;
+    const change = anchor.changes?.[0];
+    const row = hunk.body.findIndex((r) => r.op !== " " && r.change === change);
+    return change === undefined || row === -1 ? 0 : row;
+}
+/**
+ * Where an old line lands in a replacement hunk: the nearest row with the same text the tip
+ * keeps, else the old line clamped into the hunk's tip lines.
+ */
+function landing(hunk, units, oldLine, text) {
+    const lines = tipLines(hunk, units);
+    const same = hunk.body.flatMap((row, i) => row.op !== "-" && row.text === text ? [lines[i] ?? oldLine] : []);
+    if (same.length > 0) {
+        return same.reduce((a, b) => (Math.abs(b - oldLine) < Math.abs(a - oldLine) ? b : a));
+    }
+    const [from, to] = span(hunk, units);
+    return Math.min(Math.max(oldLine, from), to);
+}
+/** First and last tip line of a hunk; a pure removal spans the one line after it. */
+function span(hunk, units) {
+    const from = tipStartOf(hunk, units);
+    const kept = hunk.body.filter((row) => row.op !== "-").length;
+    return [from, from + Math.max(kept, 1) - 1];
+}
+function distance(hunk, units, line) {
+    const [from, to] = span(hunk, units);
+    return line < from ? from - line : line > to ? line - to : 0;
+}
+/**
+ * Pure. Places each comment of the previous version on the new diff: on its own unit when that
+ * hunk is unchanged, else on the hunk of the same path nearest its old tip line.
+ */
+export function carryComments(comments, oldUnits, newUnits) {
+    return comments.map((comment) => carry(comment, oldUnits, newUnits));
+}
+function carry(comment, oldUnits, newUnits) {
+    const { anchor } = comment;
+    const nowhere = { comment, unit: null, offsets: null, newLine: null };
+    if (anchor.kind !== "hunk")
+        return { ...nowhere, changed: false, path: comment.context.path };
+    const kept = newUnits.get(anchor.unit);
+    if (kept !== undefined) {
+        const newLine = kept.kind === "hunk" ? (tipLines(kept, newUnits)[firstRow(comment, kept)] ?? null) : null;
+        return {
+            comment,
+            unit: kept.id,
+            offsets: anchor.offsets ?? null,
+            changed: false,
+            path: kept.path,
+            newLine,
+        };
+    }
+    const old = oldUnits.get(anchor.unit);
+    const path = old?.path ?? comment.context.path;
+    const onPath = [...newUnits.values()].filter((u) => u.path === path);
+    const first = onPath[0];
+    if (first === undefined)
+        return { ...nowhere, changed: true, path };
+    const moved = { comment, offsets: null, changed: true, path };
+    const hunks = onPath.filter((u) => u.kind === "hunk");
+    if (old?.kind !== "hunk" || hunks.length === 0)
+        return { ...moved, unit: first.id, newLine: null };
+    const row = firstRow(comment, old);
+    const oldLine = tipLines(old, oldUnits)[row] ?? tipStartOf(old, oldUnits);
+    const nearest = hunks.reduce((a, b) => distance(b, newUnits, oldLine) < distance(a, newUnits, oldLine) ? b : a);
+    return {
+        ...moved,
+        unit: nearest.id,
+        newLine: landing(nearest, newUnits, oldLine, old.body[row]?.text),
+    };
+}

package/dist/src/host.js

@@ -3,10 +3,11 @@ import { randomUUID } from "node:crypto";
 import { closeSync, linkSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { parseEvent, parseEventBatch } from "./comments.js";
+import { parseCarried, parseEvent, parseEventBatch } from "./comments.js";
+import { carryComments } from "./evolve.js";
 import { isPlanVersion, serializePlanFile, validatePlan } from "./plan.js";
 import { HEALTH_APP, isSessionId, loadDraftComments, PortInUseError, RegistrationError, startServer, } from "./server.js";
-import { BranchMovedError, isAlive, openSessionAt, SessionFileError, SessionLockedError, } from "./session.js";
+import { BranchMovedError, diffOfPlan, isAlive, openSessionAt, SessionFileError, SessionLockedError, } from "./session.js";
 const RECORD = "server.json";
 const DEFAULT_IDLE_MS = 30_000;
 const START_TIMEOUT_MS = 10_000;
@@ -135,6 +136,11 @@ async function loadHosted(registration, held) {
                 comments: prior.comments,
                 responses: stored.file.responses,
             };
+        const priorPlan = session.plans().find((p) => p.version === previous?.version);
+        const before = priorPlan === undefined ? null : await diffOfPlan(session, priorPlan);
+        const carried = previous === null
+            ? []
+            : carryComments(previous.comments, before?.units ?? new Map(), session.diff.units);
         const command = "review";
         // A version swap runs inside the server that already owns this session's lock.
         const release = held ??
@@ -144,6 +150,7 @@ async function loadHosted(registration, held) {
             reviewsDir,
             release,
             previous,
+            carried,
             state: {
                 mode,
                 anchor: session.anchor,
@@ -275,9 +282,22 @@ export async function swapVersion(port, summary, version, hash) {
         throw new RegistrationError("the server answered with a malformed session");
     return swapped;
 }
+/** The previous version's comments as the open page places them on its plan. */
+export async function fetchCarried(port, summary) {
+    const state = await call(port, "GET", `${summary.url}api/state`);
+    const raw = isFields(state) ? state["carried"] : undefined;
+    if (!Array.isArray(raw))
+        throw new RegistrationError("the server sent no carried comments");
+    return raw.flatMap((item) => {
+        const carried = parseCarried(item);
+        if (typeof carried === "string")
+            throw new RegistrationError(`carried: ${carried}`);
+        return [carried];
+    });
+}
 /** One long poll of the session's event log: what happened after `since`, or nothing at timeout. */
 export async function pollEvents(port, summary, since, timeoutMs) {
-    const path = `${summary.url}api/events?since=${since}&timeout=${timeoutMs}&audience=agent`;
+    const path = `${summary.url}api/events?since=${since}&timeout=${timeoutMs}`;
     const batch = parseEventBatch(await call(port, "GET", path));
     if (typeof batch === "string")
         throw new RegistrationError(`the server sent bad events: ${batch}`);
@@ -288,7 +308,7 @@ export async function pollEvents(port, summary, since, timeoutMs) {
  * the server closes the stream, which it does after the `ended` event.
  */
 export async function followEvents(port, summary, since, onEvent) {
-    const res = await fetch(`${sessionUrl(port, summary)}api/events/stream?since=${since}&audience=agent`);
+    const res = await fetch(`${sessionUrl(port, summary)}api/events/stream?since=${since}`);
     if (!res.ok || res.body === null) {
         throw new RegistrationError(`GET api/events/stream failed with ${res.status}`);
     }

package/dist/src/prompt.js

@@ -1,3 +1,4 @@
+import { tipStartOf } from "./diff.js";
 /** Consecutive runs collapse: [0,1,2,3,7] becomes "0-3,7". */
 function formatRanges(changes) {
     const sorted = [...new Set(changes)].sort((a, b) => a - b);
@@ -269,6 +270,35 @@ const RULES = (checkCommand) => `- A unit is "h_…" (a text hunk), "f_…" (a w
 - Every commit needs a non-empty message and at least one unit.
 - Keep every file syntactically whole in every commit: a function with its closing brace, a block with both ends, an import before or with its first use. Commits need not build or pass tests, but each file a commit writes must parse.
 - Check your work with \`${checkCommand}\` and fix every issue it prints, syntax errors included.`;
+function renderUnit(unit) {
+    return unit.kind === "hunk" ? renderHunk(unit) : renderOtherUnit(unit);
+}
+/** The vanished and new units, and the reviewer's comments on hunks that vanished, quoted. */
+function renderChanges(changes, input, ctx) {
+    const { since, vanished, added } = changes;
+    const gone = new Set(vanished.map((v) => v.unit.id));
+    const review = input.mode === "split" ? input.review : null;
+    const orphans = (review?.comments ?? []).filter((c) => c.author !== "agent" && c.anchor.kind === "hunk" && gone.has(c.anchor.unit));
+    const parts = [
+        `## Changes since v${since}\n`,
+        `The branch moved after plan v${since}. ${input.draftPath} already holds that plan on the new tip: every unit whose hunk did not change keeps its commit, and any commit left with no unit was dropped. Put each new unit below into a commit, an existing one or a new one, and keep the rest as it is.`,
+    ];
+    if (vanished.length > 0) {
+        parts.push(`\nThese units of v${since} changed, so their ids are gone:`, ...vanished.map(({ unit, commits }) => {
+            const where = commits
+                .map((c) => `commit ${c.index + 1} ${JSON.stringify(c.message.split("\n")[0] ?? "")}`)
+                .join(", ");
+            return `- ${unit.id}  ${unit.path}, was in ${where}`;
+        }));
+    }
+    if (added.length > 0) {
+        parts.push("\nNew units, in no commit yet:\n", added.map(renderUnit).join("\n\n"));
+    }
+    if (orphans.length > 0) {
+        parts.push(`\nThe reviewer commented on hunks that changed. Write a response for each saying what you changed, and post the same with \`follow-me reply <id>\`:\n`, orphans.map((c) => renderComment(c, ctx)).join("\n"));
+    }
+    return parts.join("\n");
+}
 /** The planner prompt for a coding agent. Pure and deterministic for the same input. */
 export function renderPrompt(input) {
     const { diff, draftPath } = input;
@@ -282,13 +312,24 @@ export function renderPrompt(input) {
     if (input.mode === "walk") {
         const sections = [
             ...head,
+            ...(input.changes === undefined
+                ? []
+                : [renderChanges(input.changes, input, { commits: [], units: diff.units })]),
             `## Concerns\n\n${CONCERNS}`,
             `## Questions from the reviewer\n\n${QUESTIONS}\n\n${CONTEXT_RULE}`,
             units,
         ];
         return `${sections.join("\n\n")}\n`;
     }
-    const sections = [...head, units];
+    const ctx = {
+        commits: input.previousCommits ?? [],
+        units: diff.units,
+    };
+    const sections = [
+        ...head,
+        ...(input.changes === undefined ? [] : [renderChanges(input.changes, input, ctx)]),
+        units,
+    ];
     const { previousPlan, review } = input;
     if (previousPlan) {
         sections.push(`## Previous plan\n\nCommits are numbered from 1.\n\n${renderPreviousPlan(previousPlan)}`);
@@ -296,7 +337,6 @@ export function renderPrompt(input) {
     const theirs = review?.comments.filter((c) => c.author !== "agent") ?? [];
     const asked = theirs.filter((c) => c.kind === "question");
     const changes = theirs.filter((c) => c.kind !== "question");
-    const ctx = { commits: input.previousCommits ?? [], units: diff.units };
     const questions = [`## Questions from the reviewer\n`, QUESTIONS, `\n${CONTEXT_RULE}`];
     if (review && asked.length > 0) {
         questions.push(`\nThe reviewer asked ${asked.length === 1 ? "this question" : "these questions"} about plan v${review.planVersion}. Commits are numbered from 1. Write one response for each.\n`, asked.map((c) => renderComment(c, ctx)).join("\n"));
@@ -350,17 +390,6 @@ function excerpt(hunk, tipStart, owners, k) {
     }
     return lines;
 }
-/** Where the hunk starts in the tip: its base position shifted by earlier hunks of the file. */
-function tipStartOf(hunk, units) {
-    let shift = 0;
-    for (const u of units.values()) {
-        if (u.kind !== "hunk" || u.path !== hunk.path || u.oldStart >= hunk.oldStart)
-            continue;
-        for (const line of u.body)
-            shift += line.op === "+" ? 1 : line.op === "-" ? -1 : 0;
-    }
-    return hunk.oldStart + shift + 1;
-}
 /** A fence longer than any backtick run in the content, so quoted code cannot close it. */
 function fence(lines) {
     const longest = Math.max(0, ...lines.flatMap((l) => (l.match(/`+/g) ?? []).map((r) => r.length)));
@@ -927,7 +956,7 @@ function renderEvent(event, ctx) {
         case "version":
             return [`- plan v${event.version} is now open`];
         case "submitted":
-            return ["- the reviewer submitted the review; the held flags follow as new comments"];
+            return ["- the reviewer submitted the review"];
         case "ended":
             return [`- the reviewer ended the review; the report is next to ${event.review}`];
         default: {

package/dist/src/server.js

@@ -82,7 +82,13 @@ export async function loadDraft(reviewsDir, version) {
     }
     catch (error) {
         if (isRecord(error) && error["code"] === "ENOENT") {
-            return { comments: [], concerns: [], resolved: [], excluded: { comments: [], concerns: [] } };
+            return {
+                comments: [],
+                concerns: [],
+                resolved: [],
+                excluded: { comments: [], concerns: [] },
+                earlierReplies: [],
+            };
         }
         throw error;
     }
@@ -240,6 +246,7 @@ function viewOf(registration, loaded, draft) {
         resolved: new Set(draft.resolved),
         excludedComments: new Set(draft.excluded.comments),
         excludedConcerns: new Set(draft.excluded.concerns),
+        earlierReplies: new Map(draft.earlierReplies.map((e) => [e.comment, e.replies])),
         unitIds: new Set(state.units.map((u) => u.id)),
         hunkRows: new Map(state.units.flatMap((u) => u.kind === "hunk" ? [[u.id, u.body.length]] : [])),
         concernIds: new Set(state.commits.flatMap((c) => (c.concerns ?? []).map((k) => k.id))),
@@ -251,6 +258,47 @@ function withReplies(comment, replies) {
     const { replies: _dropped, ...rest } = comment;
     return replies === undefined || replies.length === 0 ? rest : { ...rest, replies };
 }
+/** A comment of the previous version with the replies it got during this one. */
+function withEarlier(view, comment) {
+    const later = view.earlierReplies.get(comment.id) ?? [];
+    return later.length === 0
+        ? comment
+        : withReplies(comment, [...(comment.replies ?? []), ...later]);
+}
+function previousOf(view) {
+    const { previous } = view.loaded;
+    if (previous === null)
+        return null;
+    return { ...previous, comments: previous.comments.map((c) => withEarlier(view, c)) };
+}
+function carriedOf(view) {
+    return view.loaded.carried.map((c) => ({ ...c, comment: withEarlier(view, c.comment) }));
+}
+function earlierOf(view) {
+    return [...view.earlierReplies].map(([comment, replies]) => ({ comment, replies }));
+}
+/**
+ * What a restarted server's log begins with: each saved comment and each reply as the event that
+ * first carried it, oldest first, so a client that reads from 0 sees the whole conversation.
+ */
+function replayOf(view) {
+    const said = [];
+    for (const comment of view.comments.values()) {
+        said.push({
+            at: comment.createdAt,
+            event: { type: "comment", comment: withReplies(comment, undefined) },
+        });
+        for (const reply of comment.replies ?? []) {
+            said.push({ at: reply.createdAt, event: { type: "reply", commentId: comment.id, reply } });
+        }
+    }
+    for (const [commentId, replies] of view.earlierReplies) {
+        for (const reply of replies) {
+            said.push({ at: reply.createdAt, event: { type: "reply", commentId, reply } });
+        }
+    }
+    return said.sort((a, b) => a.at.localeCompare(b.at)).map((s) => s.event);
+}
 function mintReplyId(taken) {
     for (;;) {
         let id = "r_";
@@ -260,38 +308,6 @@ function mintReplyId(taken) {
             return id;
     }
 }
-/**
- * What the agent may see of the log: a pending flag is held back with everything said about it,
- * and reaches the agent as an ordinary "comment" event when the reviewer submits.
- */
-function forAgent(log) {
-    const held = new Set();
-    const out = [];
-    for (const event of log) {
-        if (event.type === "comment" || event.type === "comment-updated") {
-            const { comment } = event;
-            if (comment.pending === true) {
-                held.add(comment.id);
-                continue;
-            }
-            if (held.delete(comment.id))
-                out.push({ ...event, type: "comment" });
-            else
-                out.push(event);
-        }
-        else if (event.type === "comment-deleted") {
-            if (!held.delete(event.id))
-                out.push(event);
-        }
-        else if (event.type === "reply") {
-            if (!held.has(event.commentId))
-                out.push(event);
-        }
-        else
-            out.push(event);
-    }
-    return out;
-}
 const DEFAULT_POLL_MS = 25_000;
 const MAX_POLL_MS = 60_000;
 const STREAM_PING_MS = 15_000;
@@ -314,9 +330,10 @@ function hostSession(id, registration, loaded, draft, load) {
         for (const listener of [...listeners])
             listener();
     };
-    const seen = (agent) => (agent ? forAgent(events) : events);
-    const waitForEvents = (since, timeoutMs, signal, agent) => new Promise((resolve) => {
-        const news = () => seen(agent).filter((e) => e.seq > since);
+    for (const event of replayOf(view))
+        emit(event);
+    const waitForEvents = (since, timeoutMs, signal) => new Promise((resolve) => {
+        const news = () => events.filter((e) => e.seq > since);
         const answer = () => resolve({ seq: events.length, events: news() });
         if (news().length > 0 || timeoutMs === 0 || signal.aborted)
             return answer();
@@ -356,6 +373,7 @@ function hostSession(id, registration, loaded, draft, load) {
         const concerns = [...view.decisions.values()];
         const resolved = [...view.resolved];
         const excluded = excludedOf();
+        const earlierReplies = earlierOf(view);
         const snapshot = JSON.stringify({
             schema: "follow-me/review-draft@1",
             planVersion: state.version,
@@ -363,6 +381,7 @@ function hostSession(id, registration, loaded, draft, load) {
             ...(concerns.length === 0 ? {} : { concerns }),
             ...(resolved.length === 0 ? {} : { resolved }),
             ...(excluded === null ? {} : { excluded }),
+            ...(earlierReplies.length === 0 ? {} : { earlierReplies }),
         }, null, 2);
         const dir = view.loaded.reviewsDir;
         writes = writes.then(async () => {
@@ -393,33 +412,22 @@ function hostSession(id, registration, loaded, draft, load) {
         }
         return parsed;
     };
-    /** Clears `pending` on every held flag at once and tells the agent what it missed. */
-    const release = () => {
-        const held = [...view.comments.values()].filter((c) => c.pending === true);
-        if (held.length === 0)
-            return 0;
-        emit({ type: "submitted" });
-        for (const comment of held) {
-            const { pending: _held, ...open } = comment;
-            view.comments.set(comment.id, open);
-            emit({ type: "comment", comment: open });
-        }
-        return held.length;
-    };
     const review = () => {
         const concerns = [...view.decisions.values()];
         const resolved = [...view.resolved];
         const excluded = excludedOf();
+        const earlierReplies = earlierOf(view);
         return {
             schema: "follow-me/review@1",
             mode: view.loaded.state.mode,
             planVersion: view.loaded.state.version,
             planHash: view.loaded.state.planHash,
             endedAt: new Date().toISOString(),
-            comments: [...view.comments.values()].filter((c) => c.pending !== true),
+            comments: [...view.comments.values()],
             ...(concerns.length === 0 ? {} : { concerns }),
             ...(resolved.length === 0 ? {} : { resolved }),
             ...(excluded === null ? {} : { excluded }),
+            ...(earlierReplies.length === 0 ? {} : { earlierReplies }),
         };
     };
     const report = (finished) => {
@@ -439,7 +447,7 @@ function hostSession(id, registration, loaded, draft, load) {
         await rm(view.draftFile, { force: true });
         return view.reviewFile;
     };
-    const hasWork = () => view.comments.size > 0 || view.decisions.size > 0;
+    const hasWork = () => view.comments.size > 0 || view.decisions.size > 0 || view.earlierReplies.size > 0;
     return {
         id,
         done,
@@ -464,17 +472,18 @@ function hostSession(id, registration, loaded, draft, load) {
             resolved: [...view.resolved],
             excluded: { comments: [...view.excludedComments], concerns: [...view.excludedConcerns] },
             seq: events.length,
-            previous: view.loaded.previous,
+            previous: previousOf(view),
+            carried: carriedOf(view),
         }),
         /** Events after `since`, now and as they happen, until unfollowed or the review ends. */
         latest: () => events.length,
-        follow: (since, send, stop, agent) => {
+        follow: (since, send, stop) => {
             if (since > events.length) {
                 throw new HttpError(409, `since ${since} is ahead of this session's log (${events.length})`);
             }
             let last = since;
             const flush = () => {
-                for (const event of seen(agent).filter((e) => e.seq > last)) {
+                for (const event of events.filter((e) => e.seq > last)) {
                     send(event);
                     last = event.seq;
                     if (event.type === "ended") {
@@ -488,11 +497,11 @@ function hostSession(id, registration, loaded, draft, load) {
             flush();
             return () => listeners.delete(flush);
         },
-        poll: (since, timeoutMs, signal, agent) => {
+        poll: (since, timeoutMs, signal) => {
             if (since > events.length) {
                 throw new HttpError(409, `since ${since} is ahead of this session's log (${events.length})`);
             }
-            return waitForEvents(since, timeoutMs, signal, agent);
+            return waitForEvents(since, timeoutMs, signal);
         },
         report: () => report(review()),
         reportItems: () => {
@@ -536,22 +545,33 @@ function hostSession(id, registration, loaded, draft, load) {
             emit({ type: "comment-deleted", id: gone.id });
             await saveDraft();
         },
+        /** Replies under a comment of this version, or of the previous one, as after a swap. */
         reply: async (target, raw) => {
             open();
             const comment = view.comments.get(target);
-            if (comment === undefined)
+            const earlier = view.loaded.previous?.comments.find((c) => c.id === target);
+            const owner = comment ?? earlier;
+            if (owner === undefined)
                 throw new HttpError(404, "no such comment");
             const parsed = parseNewReply(raw);
             if (typeof parsed === "string")
                 throw new HttpError(400, `malformed reply: ${parsed}`);
-            const taken = new Set([...view.comments.values()].flatMap((c) => c.replies ?? []).map((r) => r.id));
+            const taken = new Set([...view.comments.values(), ...(previousOf(view)?.comments ?? [])]
+                .flatMap((c) => c.replies ?? [])
+                .map((r) => r.id));
             const reply = {
                 id: mintReplyId(taken),
                 ...parsed,
                 createdAt: new Date().toISOString(),
             };
-            view.comments.set(comment.id, { ...comment, replies: [...(comment.replies ?? []), reply] });
-            emit({ type: "reply", commentId: comment.id, reply });
+            if (comment !== undefined) {
+                view.comments.set(comment.id, { ...comment, replies: [...(comment.replies ?? []), reply] });
+            }
+            else if (earlier !== undefined) {
+                const later = view.earlierReplies.get(earlier.id) ?? [];
+                view.earlierReplies.set(earlier.id, [...later, reply]);
+            }
+            emit({ type: "reply", commentId: owner.id, reply });
             await saveDraft();
             return reply.id;
         },
@@ -599,12 +619,14 @@ function hostSession(id, registration, loaded, draft, load) {
             await saveDraft();
             return { comments: [...view.excludedComments], concerns: [...view.excludedConcerns] };
         },
-        /** Releases every held flag in one go; the reviewer pressed Submit. */
-        submit: async () => {
+        /**
+         * The reviewer pressed Submit. Every comment already reached the agent, so this only tells it
+         * the reviewer is done; `released` stays for pages that still read it.
+         */
+        submit: () => {
             open();
-            const released = release();
-            await saveDraft();
-            return { released };
+            emit({ type: "submitted" });
+            return { released: 0 };
         },
         resolve: async (raw) => {
             open();
@@ -642,13 +664,12 @@ function hostSession(id, registration, loaded, draft, load) {
             try {
                 await writes;
                 const next = await load({ ...view.registration, version, hash, lockToken: null }, view.loaded.release);
-                release();
                 if (hasWork())
                     await writeReview(review());
                 else
                     await rm(view.draftFile, { force: true });
                 view = viewOf({ ...view.registration, version, hash }, next, await loadDraft(next.reviewsDir, version));
-                emit({ type: "version", version, hash });
+                emit({ type: "version", version, hash, carried: carriedOf(view) });
             }
             finally {
                 swapping = false;
@@ -658,7 +679,6 @@ function hostSession(id, registration, loaded, draft, load) {
         end: async () => {
             open();
             ending = true;
-            release();
             const finished = review();
             const file = await writeReview(finished);
             view.loaded.release();
@@ -832,7 +852,7 @@ export function startServer(opts) {
             });
             res.write(": follow-me\n\n");
             const ping = setInterval(() => res.write(": ping\n\n"), STREAM_PING_MS);
-            const unfollow = session.follow(since, (event) => res.write(`id: ${event.seq}\ndata: ${JSON.stringify(event)}\n\n`), () => res.end(), url.searchParams.get("audience") === "agent");
+            const unfollow = session.follow(since, (event) => res.write(`id: ${event.seq}\ndata: ${JSON.stringify(event)}\n\n`), () => res.end());
             res.on("close", () => {
                 clearInterval(ping);
                 unfollow();
@@ -844,8 +864,7 @@ export function startServer(opts) {
             res.on("close", () => abort.abort());
             const since = queryInt(url, "since", 0, Number.MAX_SAFE_INTEGER, 0);
             const timeout = queryInt(url, "timeout", 0, MAX_POLL_MS, DEFAULT_POLL_MS);
-            const agent = url.searchParams.get("audience") === "agent";
-            return sendJson(res, 200, await session.poll(since, timeout, abort.signal, agent));
+            return sendJson(res, 200, await session.poll(since, timeout, abort.signal));
         }
         if (method === "GET" && rest === "/api/report" && url.searchParams.get("format") === "json") {
             return sendJson(res, 200, session.reportItems());
@@ -866,7 +885,7 @@ export function startServer(opts) {
             return sendJson(res, 200, session.summary());
         }
         if (method === "POST" && rest === "/api/submit") {
-            return sendJson(res, 200, await session.submit());
+            return sendJson(res, 200, session.submit());
         }
         if (method === "POST" && rest === "/api/excluded") {
             return sendJson(res, 200, await session.exclude(await readJson(req)));