@shiyuphan/follow-me 0.5.0 → 0.5.1

package/dist/src/cli.js

@@ -11,7 +11,7 @@ import { naiveDraft } from "./naive.js";
 import { isCommentId, isConcernId, isFields, serializePlanFile, validatePlan, } from "./plan.js";
 import { renderEvents, renderPrompt, renderReport, renderShownComment, renderShownConcern, renderShownUnit, reportItems, } from "./prompt.js";
 import { RegistrationError, sessionIdOf } from "./server.js";
-import { BranchMovedError, cleanSessions, extractSession, MissingDraftError, NotARepositoryError, openSession, SessionFileError, SessionLockedError, sinceLastPlan, } from "./session.js";
+import { BranchMovedError, cleanSessions, extractSession, MissingDraftError, NotARepositoryError, openSession, SessionFileError, SessionLockedError, sessionComments, sinceLastPlan, } from "./session.js";
 import { checkSyntax } from "./syntax.js";
 class UsageError extends Error {
     name = "UsageError";
@@ -909,7 +909,9 @@ function finished(session, stored) {
     const text = renderStored(session, stored);
     if (text === null)
         return 1;
-    say(`review v${stored.version} ended with ${plural(stored.review.comments.length, "comment")}`);
+    // A review that swapped versions holds what its earlier versions said too.
+    const said = stored.review.comments.length + (stored.review.carried?.length ?? 0);
+    say(`review v${stored.version} ended with ${plural(said, "comment")}`);
     process.stdout.write(text);
     say();
     next("done; the user can port it with follow-me report --json");
@@ -1240,7 +1242,19 @@ function renderStored(session, stored, format = "markdown") {
         .plans()
         .filter((p) => p.version > stored.version)
         .flatMap((p) => p.file.responses);
-    const opts = { branch: session.anchor.branch, responses };
+    const { carried } = stored.review;
+    const said = reviewsOf(session)
+        .filter((r) => r.version <= stored.version)
+        .map((r) => r.review);
+    const earlier = carried === undefined
+        ? {}
+        : {
+            earlier: {
+                comments: sessionComments(carried, said),
+                concerns: stored.review.carriedConcerns ?? [],
+            },
+        };
+    const opts = { branch: session.anchor.branch, responses, ...earlier };
     if (format === "json") {
         const items = reportItems(stored.review, verdict.plan.commits, session.diff.units, opts);
         return `${JSON.stringify(items, null, 2)}\n`;

package/dist/src/comments.js

@@ -1,5 +1,5 @@
 import { isRepoPath, isUnitId } from "./diff.js";
-import { diagramProblem, isArray, isCommentId, isConcernId, isFields, isPlanVersion, isSeverity, } from "./plan.js";
+import { diagramProblem, isArray, isCommentId, isConcernId, isFields, isPlanVersion, isSeverity, parsePlacedConcern, } from "./plan.js";
 /**
  * The wire formats of review state, parsed once at the boundary: comments, replies, concern
  * decisions, the review file, its autosaved draft and the events a hosted session logs. Every
@@ -253,13 +253,7 @@ function parseEarlierReplies(v) {
 function isLine(v) {
     return typeof v === "number" && Number.isInteger(v) && v >= 1;
 }
-export function parseCarried(v) {
-    if (!isFields(v)) {
-        return "not an object";
-    }
-    const comment = parseComment(v.comment);
-    if (typeof comment === "string")
-        return comment;
+function parsePlacement(v) {
     const { unit, offsets, changed, path, newLine } = v;
     if (unit !== null && !(typeof unit === "string" && isUnitId(unit)))
         return "unit is not a unit id";
@@ -273,7 +267,6 @@ export function parseCarried(v) {
     if (newLine !== null && !isLine(newLine))
         return "newLine is not null or a line";
     return {
-        comment,
         unit,
         offsets: offsets === null ? null : offsets.filter(isIndex),
         changed,
@@ -281,6 +274,56 @@ export function parseCarried(v) {
         newLine,
     };
 }
+export function parseCarried(v) {
+    if (!isFields(v))
+        return "not an object";
+    const comment = parseComment(v.comment);
+    if (typeof comment === "string")
+        return comment;
+    const placement = parsePlacement(v);
+    return typeof placement === "string" ? placement : { comment, ...placement };
+}
+function parseSince(v) {
+    if (v === null)
+        return null;
+    return isPlanVersion(v) ? v : "since is not null or a plan version";
+}
+function parseCarriedRef(v) {
+    if (!isFields(v))
+        return "not an object";
+    const comment = asCommentId(v.comment);
+    if (comment === null)
+        return "comment is not a comment id";
+    if (!isPlanVersion(v.version))
+        return "version is not a plan version";
+    const since = parseSince(v.since);
+    if (typeof since === "string")
+        return since;
+    const placement = parsePlacement(v);
+    if (typeof placement === "string")
+        return placement;
+    return { ...placement, comment, version: v.version, since };
+}
+function parseCarriedConcern(v) {
+    if (!isFields(v)) {
+        return "not an object";
+    }
+    const concern = parsePlacedConcern(v.concern);
+    if (typeof concern === "string")
+        return `concern: ${concern}`;
+    if (!isIndex(v.commit))
+        return "commit is not a commit index";
+    const decision = parseDecision(v.decision);
+    if (typeof decision === "string")
+        return `decision: ${decision}`;
+    const since = parseSince(v.since);
+    if (typeof since === "string")
+        return since;
+    const placement = parsePlacement(v);
+    if (typeof placement === "string")
+        return placement;
+    return { ...placement, concern, commit: v.commit, decision, since };
+}
 /** Boundary parse of reviews/vN.json. Files written before walk mode existed have no mode. */
 export function parseReview(v) {
     if (!isFields(v)) {
@@ -314,6 +357,12 @@ export function parseReview(v) {
     const earlier = parseList(v.earlierReplies, parseEarlierReplies, "earlierReplies");
     if (typeof earlier === "string")
         return earlier;
+    const carried = v.carried === undefined ? null : parseList(v.carried, parseCarriedRef, "carried");
+    if (typeof carried === "string")
+        return carried;
+    const concernsCarried = parseList(v.carriedConcerns, parseCarriedConcern, "carriedConcerns");
+    if (typeof concernsCarried === "string")
+        return concernsCarried;
     return {
         schema: v.schema,
         mode,
@@ -325,6 +374,8 @@ export function parseReview(v) {
         ...(resolved.length === 0 ? {} : { resolved }),
         ...(anyExcluded ? { excluded } : {}),
         ...(earlier.length === 0 ? {} : { earlierReplies: earlier }),
+        ...(carried === null ? {} : { carried }),
+        ...(concernsCarried.length === 0 ? {} : { carriedConcerns: concernsCarried }),
     };
 }
 function lenient(items, parse) {
@@ -350,6 +401,8 @@ export function parseDraft(v) {
         resolved: lenientIds(v.resolved, isCommentIdValue),
         excluded: typeof excluded === "string" ? { comments: [], concerns: [] } : excluded,
         earlierReplies: lenient(v.earlierReplies, parseEarlierReplies),
+        carried: v.carried === undefined ? null : lenient(v.carried, parseCarriedRef),
+        carriedConcerns: lenient(v.carriedConcerns, parseCarriedConcern),
     };
 }
 export function parseEvent(v) {

package/dist/src/evolve.js

@@ -78,50 +78,166 @@ 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));
+/** The body row whose tip line is `line`; a kept row before a removal at the same line. */
+function rowAt(hunk, units, line) {
+    if (line === null)
+        return 0;
+    const lines = tipLines(hunk, units);
+    const row = hunk.body.findIndex((r, i) => r.op !== "-" && lines[i] === line);
+    return row === -1 ? 0 : row;
 }
-function carry(comment, oldUnits, newUnits) {
+function pinnedComment(comment) {
     const { anchor } = comment;
-    const nowhere = { comment, unit: null, offsets: null, newLine: null };
-    if (anchor.kind !== "hunk")
-        return { ...nowhere, changed: false, path: comment.context.path };
     // A comment on a whole hunk has no line; inventing one moves its card off the hunk's end.
-    const whole = anchor.changes === null && anchor.offsets === undefined;
-    const kept = newUnits.get(anchor.unit);
+    const whole = anchor.kind === "hunk" && anchor.changes === null && anchor.offsets === undefined;
+    return { whole, row: (hunk) => firstRow(comment, hunk) };
+}
+function pinnedConcern(concern) {
+    const { lines } = concern;
+    if (lines === undefined)
+        return { whole: true, row: () => 0 };
+    return {
+        whole: false,
+        row: (hunk) => {
+            const row = hunk.body.findIndex((r) => r.op !== " " && lines.includes(r.change));
+            return row === -1 ? 0 : row;
+        },
+    };
+}
+/** Where a comment points on the version it was made on. */
+function placedOwn(comment) {
+    const { anchor } = comment;
+    return {
+        unit: anchor.kind === "hunk" ? anchor.unit : null,
+        offsets: anchor.kind === "hunk" ? (anchor.offsets ?? null) : null,
+        changed: false,
+        path: comment.context.path,
+        newLine: null,
+    };
+}
+/**
+ * Pure. Moves a placement on the old diff to the new one: a unit the new diff still has keeps its
+ * place, else the hunk of the same path nearest its old tip line takes it, marked changed. A
+ * placement on no unit stays as it is.
+ */
+function move(at, pinned, oldUnits, newUnits) {
+    if (at.unit === null)
+        return at;
+    const kept = newUnits.get(at.unit);
+    const old = oldUnits.get(at.unit);
     if (kept !== undefined) {
-        const newLine = kept.kind === "hunk" && !whole
-            ? (tipLines(kept, newUnits)[firstRow(comment, kept)] ?? null)
-            : null;
-        return {
-            comment,
-            unit: kept.id,
-            offsets: anchor.offsets ?? null,
-            changed: false,
-            path: kept.path,
-            newLine,
-        };
+        let newLine = null;
+        if (kept.kind === "hunk" && !pinned.whole) {
+            if (!at.changed)
+                newLine = tipLines(kept, newUnits)[pinned.row(kept)] ?? null;
+            else if (at.newLine !== null && old?.kind === "hunk") {
+                newLine = at.newLine - tipStartOf(old, oldUnits) + tipStartOf(kept, newUnits);
+            }
+            else
+                newLine = at.newLine;
+        }
+        return { ...at, path: kept.path, newLine };
     }
-    const old = oldUnits.get(anchor.unit);
-    const path = old?.path ?? comment.context.path;
+    const path = old?.path ?? at.path;
     const onPath = [...newUnits.values()].filter((u) => u.path === path);
     const first = onPath[0];
+    const moved = { offsets: null, changed: true, path };
     if (first === undefined)
-        return { ...nowhere, changed: true, path };
-    const moved = { comment, offsets: null, changed: true, path };
+        return { ...moved, unit: null, newLine: null };
     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 row = at.changed ? rowAt(old, oldUnits, at.newLine) : pinned.row(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: whole ? null : landing(nearest, newUnits, oldLine, old.body[row]?.text),
+        newLine: pinned.whole ? null : landing(nearest, newUnits, oldLine, old.body[row]?.text),
     };
 }
+/**
+ * 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) => ({
+        comment,
+        ...move(placedOwn(comment), pinnedComment(comment), oldUnits, newUnits),
+    }));
+}
+/** since stays once set; a first change records the version the code still matched. */
+function sinceOf(before, after, since, at) {
+    return since ?? (after.changed && !before.changed ? at : null);
+}
+/**
+ * Pure. What an open review carries from version `at` into the next: what it carried already,
+ * moved again, then the comments said on `at`. Nothing is dropped, so a comment of v1 is still
+ * there after the second swap.
+ */
+export function carrySession(carried, said, at, oldUnits, newUnits) {
+    const again = carried.map((c) => {
+        const moved = move(c, pinnedComment(c.comment), oldUnits, newUnits);
+        return { ...c, ...moved, since: sinceOf(c, moved, c.since, at) };
+    });
+    const fresh = said.map((comment) => {
+        const own = placedOwn(comment);
+        const moved = move(own, pinnedComment(comment), oldUnits, newUnits);
+        return { comment, version: at, ...moved, since: sinceOf(own, moved, null, at) };
+    });
+    return [...again, ...fresh];
+}
+/**
+ * Pure. Kept concerns of version `at` that the next plan no longer has, plus those carried before,
+ * placed on the new diff. A concern the next plan has again keeps its decision there instead, so
+ * it is left out here.
+ */
+export function carryConcerns(carried, kept, inNext, at, oldUnits, newUnits) {
+    const fresh = kept.map((k) => {
+        const unit = k.concern.unit ?? null;
+        const path = unit === null ? null : (oldUnits.get(unit)?.path ?? null);
+        return { ...k, unit, offsets: null, changed: false, path, newLine: null, since: null };
+    });
+    return [...carried, ...fresh]
+        .filter((c) => !inNext.has(c.concern.id))
+        .map((c) => {
+        const moved = move(c, pinnedConcern(c.concern), oldUnits, newUnits);
+        return { ...c, ...moved, since: sinceOf(c, moved, c.since, at) };
+    });
+}
+/**
+ * Pure. Where a carried hunk comment points on the diff it was carried to, as an anchor of that
+ * diff: its own rows when the hunk is unchanged, the row at its new line when it changed, the
+ * whole hunk when it has no line. Null when the code is gone or the comment is not on a hunk.
+ */
+export function anchorOn(carried, units, commit) {
+    const { anchor } = carried.comment;
+    if (anchor.kind !== "hunk" || carried.unit === null)
+        return null;
+    if (!carried.changed)
+        return { ...anchor, commit };
+    const hunk = units.get(carried.unit);
+    if (hunk?.kind !== "hunk" || carried.newLine === null) {
+        return { kind: "hunk", unit: carried.unit, commit, changes: null };
+    }
+    const row = rowAt(hunk, units, carried.newLine);
+    const at = hunk.body[row];
+    const changes = at === undefined || at.op === " " ? [] : [at.change];
+    return { kind: "hunk", unit: carried.unit, commit, changes, offsets: [row] };
+}
+/** Pure. A carried concern as a concern of the diff it was carried to; see anchorOn. */
+export function concernOn(carried, units) {
+    const { concern } = carried;
+    if (carried.unit === null)
+        return concern;
+    if (!carried.changed)
+        return { ...concern, unit: carried.unit };
+    const { lines: _old, ...rest } = concern;
+    const hunk = units.get(carried.unit);
+    if (hunk?.kind !== "hunk" || carried.newLine === null)
+        return { ...rest, unit: carried.unit };
+    const at = hunk.body[rowAt(hunk, units, carried.newLine)];
+    return at === undefined || at.op === " "
+        ? { ...rest, unit: carried.unit }
+        : { ...rest, unit: carried.unit, lines: [at.change] };
+}

package/dist/src/host.js

@@ -6,8 +6,8 @@ import { join } from "node:path";
 import { parseCarried, parseComment, 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, diffOfPlan, isAlive, openSessionAt, SessionFileError, SessionLockedError, } from "./session.js";
+import { HEALTH_APP, isSessionId, loadDraft, PortInUseError, RegistrationError, startServer, } from "./server.js";
+import { BranchMovedError, diffOfPlan, isAlive, openSessionAt, SessionFileError, SessionLockedError, sessionComments, } from "./session.js";
 const RECORD = "server.json";
 const DEFAULT_IDLE_MS = 30_000;
 const START_TIMEOUT_MS = 10_000;
@@ -127,7 +127,15 @@ async function loadHosted(registration, held) {
             throw new RegistrationError(`plan v${version} no longer fits ${branch}; check it again`);
         }
         const reviewsDir = session.reviewsDir();
-        const comments = await loadDraftComments(reviewsDir, version);
+        const draft = await loadDraft(reviewsDir, version);
+        const { comments } = draft;
+        // A restart in the middle of a review that swapped: the draft names what was said before.
+        const earlier = draft.carried === null
+            ? null
+            : {
+                comments: sessionComments(draft.carried, reviewed.filter((r) => r.version < version).map((r) => r.review)),
+                concerns: draft.carriedConcerns,
+            };
         const prior = session.priorReview(mode, version);
         const previous = prior === null || prior.comments.length === 0
             ? null
@@ -151,6 +159,7 @@ async function loadHosted(registration, held) {
             release,
             previous,
             carried,
+            earlier,
             state: {
                 mode,
                 anchor: session.anchor,

package/dist/src/plan.js

@@ -90,6 +90,20 @@ function parseConcern(v, onUnit) {
         return "lines: expected a list of change indices";
     return { severity, kind, text, lines: [...new Set(indices)].sort((a, b) => a - b) };
 }
+/** A concern as validation placed it, stored beside a review: with its id and its unit. */
+export function parsePlacedConcern(v) {
+    if (!isFields(v))
+        return "expected an object";
+    if (!isConcernId(v.id))
+        return "id: expected a concern id";
+    if (v.unit !== undefined && !(typeof v.unit === "string" && isUnitId(v.unit))) {
+        return "unit: expected a unit id";
+    }
+    const concern = parseConcern(v, v.unit !== undefined);
+    if (typeof concern === "string")
+        return concern;
+    return { ...concern, id: v.id, ...(v.unit === undefined ? {} : { unit: v.unit }) };
+}
 /** Absent, null and [] all mean no concerns, so a planner may always write the field. */
 function parseConcerns(v, onUnit) {
     if (v === undefined || v === null)

package/dist/src/prompt.js

@@ -1,4 +1,5 @@
 import { tipStartOf } from "./diff.js";
+import { anchorOn, concernOn } from "./evolve.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);
@@ -383,10 +384,23 @@ function quoteHunk(units, commits, unit, k, picked) {
     return { line, text: lines.map((l) => l.text) };
 }
 const SEVERITY_RANK = { blocker: 0, major: 1, minor: 2 };
+/** Marks the label of what was said before its code changed, and places what lost its code. */
+function marked(ctx, id, where, quote) {
+    const mark = ctx.marks?.get(id);
+    if (mark === undefined)
+        return where;
+    if (mark.gone) {
+        return { path: mark.path, line: null, label: `the code is gone after v${mark.since}`, quote };
+    }
+    return { ...where, label: `${where.label} · the code changed after v${mark.since}` };
+}
 function lineLabel(line, fallback) {
     return line === null ? fallback : `line ${line}`;
 }
 function whereComment(ctx, c) {
+    return marked(ctx, c.id, whereOnTip(ctx, c), c.context.lines ?? []);
+}
+function whereOnTip(ctx, c) {
     const { anchor } = c;
     switch (anchor.kind) {
         case "plan":
@@ -429,6 +443,9 @@ function whereComment(ctx, c) {
     }
 }
 function whereConcern(ctx, kept) {
+    return marked(ctx, kept.concern.id, concernOnTip(ctx, kept), []);
+}
+function concernOnTip(ctx, kept) {
     const { concern, commit } = kept;
     if (concern.unit === undefined) {
         return { path: null, line: null, label: `commit ${commit + 1}`, quote: [] };
@@ -727,8 +744,12 @@ function threadOf(c) {
 function withSeverity(severity, text) {
     return severity === null ? text : `**${severity}**\n\n${text}`;
 }
-function collectItems(review, commits, units, responses) {
-    const ctx = { commits, units };
+function changedOf(ctx, id) {
+    const mark = ctx.marks?.get(id);
+    return mark === undefined ? {} : { changed: { since: mark.since, gone: mark.gone } };
+}
+function collectItems(review, ctx, responses) {
+    const { commits, units } = ctx;
     const fromReviewer = review.comments.filter((c) => c.author !== "agent");
     const walk = review.mode === "walk";
     const rest = fromReviewer.filter((c) => c.kind !== "question");
@@ -748,6 +769,7 @@ function collectItems(review, commits, units, responses) {
             return {
                 where: it.where,
                 item: {
+                    id: kept.concern.id,
                     ...concernSpan(ctx, kept.concern),
                     path: it.where.path,
                     oldPath: it.where.path,
@@ -757,6 +779,7 @@ function collectItems(review, commits, units, responses) {
                     thread,
                     resolved: false,
                     excluded: noConcerns.has(kept.concern.id),
+                    ...changedOf(ctx, kept.concern.id),
                 },
             };
         }
@@ -765,6 +788,7 @@ function collectItems(review, commits, units, responses) {
         return {
             where: it.where,
             item: {
+                id: first.id,
                 ...commentSpan(ctx, first),
                 path: it.where.path,
                 oldPath: it.where.path,
@@ -774,6 +798,7 @@ function collectItems(review, commits, units, responses) {
                 thread: threadOf(first),
                 resolved: resolved.has(first.id),
                 excluded: noComments.has(first.id),
+                ...changedOf(ctx, first.id),
             },
         };
     });
@@ -786,6 +811,7 @@ function collectItems(review, commits, units, responses) {
         out.push({
             where,
             item: {
+                id: q.id,
                 ...commentSpan(ctx, q),
                 path: where.path,
                 oldPath: where.path,
@@ -795,6 +821,7 @@ function collectItems(review, commits, units, responses) {
                 thread: threadOf(q),
                 resolved: resolved.has(q.id),
                 excluded: noComments.has(q.id),
+                ...changedOf(ctx, q.id),
             },
         });
     }
@@ -805,7 +832,8 @@ function collectItems(review, commits, units, responses) {
  * Excluded ones are present and marked; whoever posts them skips those.
  */
 export function reportItems(review, commits, units, opts) {
-    return collectItems(review, commits, units, opts.responses).map((c) => c.item);
+    const session = folded(review, commits, units, opts.earlier);
+    return collectItems(session.review, session.ctx, opts.responses).map((c) => c.item);
 }
 /** A short list of what the reviewer left out, so nothing vanishes without a trace. */
 function renderExcluded(collected) {
@@ -821,6 +849,64 @@ function renderExcluded(collected) {
     out.push("");
     return out;
 }
+/**
+ * The review of the whole session on this version's diff: the earlier versions' comments on
+ * their carried anchors, the concerns kept there that this plan lost added to the commit now
+ * taking their unit, and a mark on each whose code changed. Each id appears once; this
+ * version's own copy wins.
+ */
+function folded(review, commits, units, earlier) {
+    if (earlier === undefined)
+        return { review, ctx: { commits, units } };
+    const marks = new Map();
+    const mark = (id, at) => {
+        if (at.since !== null)
+            marks.set(id, { since: at.since, gone: at.unit === null, path: at.path });
+    };
+    const owner = (unit, fallback) => {
+        const k = commits.findIndex((c) => c.refs.some((r) => r.unit === unit));
+        return k === -1 ? Math.min(fallback, Math.max(commits.length - 1, 0)) : k;
+    };
+    const own = new Set(review.comments.map((c) => c.id));
+    const comments = earlier.comments
+        .filter((c) => !own.has(c.comment.id))
+        .map((c) => {
+        mark(c.comment.id, c);
+        const { anchor } = c.comment;
+        if (anchor.kind !== "hunk")
+            return c.comment;
+        const moved = anchorOn(c, units, owner(c.unit, anchor.commit));
+        return moved === null ? c.comment : { ...c.comment, anchor: moved };
+    });
+    const inPlan = new Set(commits.flatMap((c) => (c.concerns ?? []).map((k) => k.id)));
+    const lost = earlier.concerns.filter((c) => !inPlan.has(c.concern.id));
+    for (const c of lost)
+        mark(c.concern.id, c);
+    const decided = new Set((review.concerns ?? []).map((d) => d.concern));
+    return {
+        review: {
+            ...review,
+            comments: [...comments, ...review.comments],
+            concerns: [
+                ...lost.filter((c) => !decided.has(c.concern.id)).map((c) => c.decision),
+                ...(review.concerns ?? []),
+            ],
+        },
+        ctx: {
+            units,
+            marks,
+            commits: commits.map((commit, k) => {
+                const mine = lost.filter((c) => owner(c.unit, c.commit) === k);
+                if (mine.length === 0)
+                    return commit;
+                return {
+                    ...commit,
+                    concerns: [...(commit.concerns ?? []), ...mine.map((c) => concernOn(c, units))],
+                };
+            }),
+        },
+    };
+}
 /**
  * The consolidated report of a review, in the voices of both the reviewer and the agent: the
  * reviewer's comments and the agent's concerns the reviewer kept, grouped by file and ordered by
@@ -829,22 +915,24 @@ function renderExcluded(collected) {
  * Concerns the reviewer has not decided are left out, as are those dismissed.
  */
 export function renderReport(full, commits, units, opts) {
-    const excluded = full.excluded;
+    const session = folded(full, commits, units, opts.earlier);
+    const { ctx } = session;
+    const excluded = session.review.excluded;
     if (excluded === undefined)
-        return renderIncluded(full, commits, units, opts);
+        return renderIncluded(session.review, ctx, opts);
     const noComments = new Set(excluded.comments);
     const noConcerns = new Set(excluded.concerns);
     const review = {
-        ...full,
-        comments: full.comments.filter((c) => !noComments.has(c.id)),
-        concerns: (full.concerns ?? []).filter((d) => !noConcerns.has(d.concern)),
+        ...session.review,
+        comments: session.review.comments.filter((c) => !noComments.has(c.id)),
+        concerns: (session.review.concerns ?? []).filter((d) => !noConcerns.has(d.concern)),
     };
-    const tail = renderExcluded(collectItems(full, commits, units, opts.responses));
-    const main = renderIncluded(review, commits, units, opts);
+    const tail = renderExcluded(collectItems(session.review, ctx, opts.responses));
+    const main = renderIncluded(review, ctx, opts);
     return tail.length === 0 ? main : `${main}${main.endsWith("\n") ? "" : "\n"}${tail.join("\n")}`;
 }
-function renderIncluded(review, commits, units, opts) {
-    const ctx = { commits, units };
+function renderIncluded(review, ctx, opts) {
+    const { commits, units } = ctx;
     const walk = review.mode === "walk";
     const fromReviewer = review.comments.filter((c) => c.author !== "agent");
     // A thread the agent started matters to it only once the reviewer has answered.