@shiyuphan/follow-me 0.4.1 → 0.5.1

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);
@@ -22,11 +23,13 @@ function formatSelection(unit, select) {
 function stripEol(text) {
     return text.replace(/\r?\n$/, "");
 }
-function renderHunk(hunk) {
+/** Under a "### path" heading the path is left out of each hunk's own line. */
+function renderHunk(hunk, withPath = true) {
     const lines = hunk.body.map((line) => line.op === " "
         ? `    ${stripEol(line.text)}`
         : `[${line.change}]${line.op} ${stripEol(line.text)}`);
-    return [`${hunk.id}  ${hunk.path}  (${hunk.changeCount} change lines)`, ...lines].join("\n");
+    const where = withPath ? `  ${hunk.path}` : "";
+    return [`${hunk.id}${where}  (${hunk.changeCount} change lines)`, ...lines].join("\n");
 }
 function renderOtherUnit(unit) {
     if (unit.kind === "mode") {
@@ -41,7 +44,7 @@ function renderUnits(diff) {
         byPath.set(unit.path, [...(byPath.get(unit.path) ?? []), unit]);
     }
     const files = [...byPath].map(([path, units]) => {
-        const rendered = units.map((unit) => unit.kind === "hunk" ? renderHunk(unit) : renderOtherUnit(unit));
+        const rendered = units.map((unit) => unit.kind === "hunk" ? renderHunk(unit, false) : renderOtherUnit(unit));
         return [`### ${path}`, ...rendered].join("\n\n");
     });
     return files.join("\n\n");
@@ -162,8 +165,6 @@ function pickRows(ctx, anchor) {
         touchesContext: count(" ") > 0,
     };
 }
-/** Said once wherever comments reach the agent, with the same words. */
-const CONTEXT_RULE = "A comment on a context row (marked `>` with no + or -) is about code this branch leaves alone or depends on. The plan cannot move it, so do not move lines because of it. Answer a question with an explanation, or point at the commit that last touched those lines. Answer a change request as a code issue, not by reordering.";
 function renderComment(comment, ctx) {
     const lines = [`- ${comment.id}  on ${describeAnchor(comment.anchor, ctx)}`];
     const rows = anchorRows(ctx, comment.anchor);
@@ -188,165 +189,136 @@ function renderComment(comment, ctx) {
     }
     return lines.join("\n");
 }
-const QUESTIONS = `A question is not a request to change the plan. Answer it by explaining, not by moving lines. Where the asked-about lines now live, add or rewrite the \`narration\` (the page shows it as your note) of that commit or unit so it answers the question, in plain sentences. When the answer is about flow, structure or order across files, add a \`diagram\` there too. Then write one response with \`"status": "answered"\`, a \`note\` of one to three sentences that answers the question directly, and \`"at"\` naming the commit (1-based) and unit that carry the explanation. Move lines only if answering shows the order itself was wrong. Say so in the note, and answer the question as well. If the diff cannot answer it, use \`"deferred"\` and say what is missing.`;
-const CONCERNS = `You are also a careful reviewer. Add a concern only for something you would raise in a pull request: a bug or unhandled case, a change with no test where one is expected, a name that misleads, or a risky change such as a migration, concurrency or security. Pin it to the change lines with \`lines\`. Say what goes wrong and when, in one or two sentences. Severity: \`blocker\` breaks behaviour or loses data, \`major\` should be fixed before merge, \`minor\` is worth a note. Do not flag style, formatting or taste. Do not repeat the note. Most commits deserve no concern, and a plan with none is fine. Never write more than one concern per unit. Concerns are in your voice as a reviewer, while the note stays the author's.
-
-A concern is \`{ "severity": "blocker" | "major" | "minor", "kind": "bug" | "missing-test" | "naming" | "risk", "text": "...", "lines": [0, 1] }\`. \`lines\` holds change indices of that unit and is allowed only on a unit ref. Write \`"concerns": [ ... ]\` on a commit, or on a unit written as an object: \`{ "unit": "h_x:0-3", "concerns": [ ... ] }\`. Never write an id; follow-me derives one.`;
-const ORDERING = `Order the commits so the story reads naturally:
-- Scaffolding and types come before the code that uses them.
-- A failing test comes before the fix that makes it pass.
-- Renames and moves come before the edits that build on them.
-- One idea per commit. Prefer many small commits over a few large ones.
-- Commits do not need to compile or pass tests on their own.
-- The last commit must bring the tree to exactly the tip, which follows from covering every unit.
-
-Write each commit message as a short imperative title, then a blank line and a body that
-says why. Put the why in the body first, before anything else. Keep the title to 50
-characters or fewer; put detail in the body.`;
-const GOALS = {
-    split: {
-        title: "plan the commits",
-        goal: `You are reordering a finished branch into a series of commits that a reader can follow
-as the author's thought process. The final tree is fixed. You only decide how its change
-lines are grouped and ordered.
-
-${ORDERING}`,
-    },
-    walk: {
-        title: "tell the story of this branch",
-        goal: `The reader is a reviewer meeting this branch for the first time. They will read it commit
-by commit and comment on the code itself. The final tree is fixed. You decide how its change
-lines are grouped and ordered, and why each step is there.
-
-${ORDERING}
-
-Add a \`narration\` to a commit, or to a unit, only when it says something the commit message
-body does not. The page shows it as your note. A note is one plain paragraph on why, in plain
-text with no markdown. Say why, not what the lines already show. Leave it out when the body
-already says it.`,
-    },
+const TITLES = {
+    split: "plan the commits",
+    walk: "tell the story of this branch",
 };
-const FORMAT = (draftPath, base, tip) => `Write the plan as JSON to ${draftPath}. Write only the file, in this format:
-
-{
-  "schema": "follow-me/plan@1",
-  "base": "${base}",
-  "tip": "${tip}",
-  "commits": [
-    { "message": "Add the Token type\\n\\nThe parser needs it.", "units": ["h_0123456789ab", "h_ba9876543210:0-3,7"] },
-    {
-      "message": "Parse tokens",
-      "narration": "Tokens are read in one pass, so the loop below never backtracks.",
-      "units": [{ "unit": "h_ba9876543210", "narration": "The loop is boring on purpose." }, "f_0123456789ab"]
-    }
-  ],
-  "responses": [
-    { "comment": "c_abc234", "status": "addressed", "note": "Split the hunk and moved it earlier." }
-  ]
-}
-
-\`narration\` is optional on a commit and on a unit, and the page shows it as your note. A unit
-with a note is written as \`{ "unit": "<ref>", "narration": "..." }\` instead of the plain ref string.
-
-\`diagram\` is optional on a commit and on a unit, written the same way:
-\`{ "unit": "<ref>", "diagram": "..." }\`. It is Mermaid source that the review page draws beside
-the code: a commit's diagram under its commit, a unit's under its hunk. Add one only where a picture says what the code and prose cannot: data flowing between
-modules, a state machine, a call graph, or the before and after shape of a structure. Most commits
-need none. The first line names the diagram type, for example:
-
-  "diagram": "flowchart LR\\n  parse --> validate --> apply"
-
-The note stays plain text even when a diagram is present.
-\`responses\` is [] when there are no review comments. \`status\` is one of "addressed",
-"declined", "deferred" or, for a question, "answered", and \`note\` says what you did or why not.
-An "answered" response also carries \`"at": { "commit": 3, "unit": "h_x" }\`: the commit, counted from 1,
-and optionally the unit that holds the explanation.`;
-const RULES = (checkCommand) => `- A unit is "h_…" (a text hunk), "f_…" (a whole file) or "m_…" (a mode change).
-- "h_x:0-3,7" takes change lines 0, 1, 2, 3 and 7 of hunk h_x. Indices are the [n] shown below.
-- A bare "h_x" takes every change line of that hunk that no other commit claimed.
-- Every change line must be used exactly once across all commits. Never repeat a line.
-- Use the unit ids exactly as printed. Do not invent ids.
-- "f_…" and "m_…" units are taken whole, never with a line list.
-- 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.`;
+/** Where the fixed instructions live: the skill a harness loads once, not every prompt. */
+function pointer(input) {
+    const mode = input.mode === "split" ? "author mode" : "reviewer mode";
+    const where = input.skillPath === undefined ? "" : ` If it is not loaded, read ${input.skillPath}.`;
+    return `Write the draft as "Writing the draft" in the follow-me skill says, in ${mode}.${where}`;
+}
+function sessionLines(input) {
+    return [
+        `- draft: ${input.draftPath}`,
+        `- base: ${input.diff.base}`,
+        `- tip: ${input.diff.tip}`,
+        `- check: ${input.checkCommand}`,
+    ].join("\n");
+}
 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.`,
+const QUOTE_LINES = 6;
+const QUOTE_WIDTH = 160;
+/**
+ * At most six rows around the picked ones (marked ">"), each cut to 160 characters: enough to
+ * recognise the code without a file read, short enough to send with every comment.
+ */
+function shortQuote(rows) {
+    const picked = rows.flatMap((r, i) => (r.startsWith(">") ? [i] : []));
+    const first = picked[0] ?? 0;
+    const last = picked.at(-1) ?? 0;
+    const before = Math.max(0, Math.min(2, QUOTE_LINES - (last - first + 1)));
+    const start = Math.max(0, first - before);
+    return rows
+        .slice(start, start + QUOTE_LINES)
+        .map((r) => (r.length > QUOTE_WIDTH ? `${r.slice(0, QUOTE_WIDTH - 1)}…` : r));
+}
+/** One comment in a line or two, with its quote only when the agent cannot see the hunk now. */
+function renderOpen(c, ctx, quote) {
+    const what = c.kind === "question" ? "question" : (c.severity ?? "comment");
+    const lines = [
+        `- ${c.id} ${what} on ${describeAnchor(c.anchor, ctx)}: ${JSON.stringify(c.body)}`,
+    ];
+    if (c.follows)
+        lines.push(`  asks again after ${c.follows}`);
+    for (const reply of c.replies ?? []) {
+        lines.push(`  ${reply.author} replied: ${JSON.stringify(reply.body)}`);
+    }
+    if (quote) {
+        const rows = anchorRows(ctx, c.anchor);
+        const quoted = rows.length > 0 ? rows : (c.context.lines ?? []).map((l) => `> ${l}`);
+        lines.push(...shortQuote(quoted).map((r) => `    ${r}`));
+    }
+    return lines.join("\n");
+}
+/**
+ * The prompt after the branch moved. The agent wrote the plan and read every comment already, so
+ * only new units carry bodies; the rest are one line each, and a comment is quoted only when the
+ * hunk it was on changed.
+ */
+function renderMoved(input, changes, head) {
+    const { since, vanished, added, draft } = changes;
+    const { units } = input.diff;
+    const gone = new Map(vanished.map((v) => [v.unit.id, v.unit]));
+    const sections = [
+        head,
+        `## Changes since v${since}\n\nThe branch moved after plan v${since}. The draft holds that plan on the new tip.`,
     ];
     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}`;
-        }));
+        sections.push([
+            `## Units of v${since} that changed, so their ids are gone\n`,
+            ...vanished.map(({ unit, commits }) => {
+                const was = commits.map((c) => c.index + 1).join(", ");
+                return `- ${unit.id}  ${unit.path}  was in commit ${was}`;
+            }),
+        ].join("\n"));
     }
     if (added.length > 0) {
-        parts.push("\nNew units, in no commit yet:\n", added.map(renderUnit).join("\n\n"));
+        sections.push(`## New units, in no commit yet\n\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"));
+    const kept = draft.commits.flatMap((commit, k) => commit.units.map((ref) => {
+        const path = units.get(ref.unit)?.path ?? "";
+        return `- ${formatSelection(ref.unit, ref.select)}  ${path}  commit ${k + 1}`;
+    }));
+    if (kept.length > 0) {
+        sections.push(`## Unchanged units, in the draft's commits\n\n${kept.join("\n")}`);
     }
-    return parts.join("\n");
+    const review = input.mode === "split" ? input.review : null;
+    const theirs = review?.comments.filter((c) => c.author !== "agent") ?? [];
+    if (review !== null && theirs.length > 0) {
+        const ctx = { commits: [], units: new Map([...units, ...gone]) };
+        const changed = (c) => c.anchor.kind === "hunk" && gone.has(c.anchor.unit);
+        sections.push([
+            `## Open comments, on plan v${review.planVersion}\n`,
+            ...theirs.map((c) => renderOpen(c, ctx, changed(c))),
+        ].join("\n"));
+    }
+    return `${sections.join("\n\n")}\n`;
 }
 /** The planner prompt for a coding agent. Pure and deterministic for the same input. */
 export function renderPrompt(input) {
-    const { diff, draftPath } = input;
-    const { title, goal } = GOALS[input.mode];
+    const { diff } = input;
     const head = [
-        `# follow-me: ${title}\n\n${goal}`,
-        `## Output format\n\n${FORMAT(draftPath, diff.base, diff.tip)}`,
-        `## Rules\n\n${RULES(input.checkCommand)}`,
+        `# follow-me: ${TITLES[input.mode]}\n\n${pointer(input)}\n\n${sessionLines(input)}`,
     ];
-    const units = `## Units\n\nChange lines are shown as \`[n]+ text\` or \`[n]- text\`. Indented lines without a bracket are context and cannot be selected.\n\n${renderUnits(diff)}`;
-    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`;
-    }
+    if (input.changes !== undefined)
+        return renderMoved(input, input.changes, head.join(""));
+    const units = `## Units\n\n${renderUnits(diff)}`;
+    if (input.mode === "walk")
+        return `${[...head, units].join("\n\n")}\n`;
     const ctx = {
         commits: input.previousCommits ?? [],
         units: diff.units,
     };
-    const sections = [
-        ...head,
-        ...(input.changes === undefined ? [] : [renderChanges(input.changes, input, ctx)]),
-        units,
-    ];
+    const sections = [...head, units];
     const { previousPlan, review } = input;
-    if (previousPlan) {
-        sections.push(`## Previous plan\n\nCommits are numbered from 1.\n\n${renderPreviousPlan(previousPlan)}`);
-    }
+    if (previousPlan)
+        sections.push(`## Previous plan\n\n${renderPreviousPlan(previousPlan)}`);
     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 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"));
+        sections.push([
+            `## Questions from the reviewer, on plan v${review.planVersion}\n`,
+            asked.map((c) => renderComment(c, ctx)).join("\n"),
+        ].join("\n"));
     }
-    sections.push(questions.join("\n"));
     if (review && changes.length > 0) {
         sections.push([
-            `## Open review comments\n`,
-            `A reviewer commented on plan v${review.planVersion}. Commits are numbered from 1.`,
-            "Answer every comment below with one entry in `responses`, changing the plan where you agree.\n",
+            `## Open review comments, on plan v${review.planVersion}\n`,
             changes.map((c) => renderComment(c, ctx)).join("\n"),
         ].join("\n"));
     }
@@ -412,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":
@@ -458,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: [] };
@@ -756,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");
@@ -777,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,
@@ -786,6 +779,7 @@ function collectItems(review, commits, units, responses) {
                     thread,
                     resolved: false,
                     excluded: noConcerns.has(kept.concern.id),
+                    ...changedOf(ctx, kept.concern.id),
                 },
             };
         }
@@ -794,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,
@@ -803,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),
             },
         };
     });
@@ -815,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,
@@ -824,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),
             },
         });
     }
@@ -834,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) {
@@ -850,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
@@ -858,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.
@@ -914,47 +973,49 @@ function renderIncluded(review, commits, units, opts) {
     if (!walk && (feedback.length > 0 || questions.length > 0)) {
         out.push("Answer every comment id above in `responses` of the next draft, then run `follow-me check` and `follow-me apply`.", "");
     }
-    const onContext = review.comments.some((c) => pickRows(ctx, c.anchor)?.touchesContext);
-    if (onContext)
-        out.push(CONTEXT_RULE, "");
     if (!walk && items.length > 0) {
-        out.push("Fix the code issues on the original branch, then run `follow-me extract` again.", "");
+        out.push("Fix the code issues on the original branch, then run `follow-me` again.", "");
     }
     return out.join("\n");
 }
+function indented(body) {
+    return `  ${body.split("\n").join("\n  ")}`;
+}
+/** "- head: body" for a one-line body, else the body indented under the head. */
+function said(head, body) {
+    return body.includes("\n") ? [`${head}:`, indented(body)] : [`${head}: ${body}`];
+}
+/**
+ * A new comment carries its short quote, since the agent has not seen it; everything else is one
+ * line naming its id, because the agent already has the comment it refers to.
+ */
 function renderEvent(event, ctx) {
     switch (event.type) {
-        case "comment":
-        case "comment-updated": {
+        case "comment": {
             const { comment: c } = event;
-            const what = c.kind === "question" ? "question" : "comment";
-            const verb = event.type === "comment" ? "new" : "edited";
-            const lines = [`- ${verb} ${what} ${c.id} on ${describeAnchor(c.anchor, ctx)}`];
-            const rows = anchorRows(ctx, c.anchor);
-            if (rows.length > 0)
-                lines.push(...rows.map((r) => `  ${r}`));
-            if (c.context.path)
-                lines.push(`  - file: ${c.context.path}`);
-            if (c.severity)
-                lines.push(`  - severity: ${c.severity}`);
+            const what = c.kind === "question" ? "question" : (c.severity ?? "comment");
+            const lines = [`- ${c.id} ${what} on ${describeAnchor(c.anchor, ctx)}`];
             if (c.follows)
-                lines.push(`  - asks again after ${c.follows}`);
-            lines.push(`  - ${c.body.split("\n").join("\n    ")}`);
+                lines.push(`  asks again after ${c.follows}`);
+            lines.push(...shortQuote(anchorRows(ctx, c.anchor)).map((r) => `    ${r}`));
+            lines.push(indented(c.body));
             return lines;
         }
+        case "comment-updated":
+            return said(`- ${event.comment.id} edited`, event.comment.body);
         case "comment-deleted":
-            return [`- comment ${event.id} was deleted`];
+            return [`- ${event.id} deleted`];
         case "reply":
-            return [`- ${event.reply.author} replied under ${event.commentId}: ${event.reply.body}`];
+            return said(`- ${event.commentId} ${event.reply.author} replied`, event.reply.body);
         case "concern": {
             const severity = event.severity === undefined ? "" : ` as ${event.severity}`;
             const note = event.note === undefined ? "" : `: ${event.note}`;
-            return [`- concern ${event.concernId} ${event.decision}${severity}${note}`];
+            return [`- ${event.concernId} ${event.decision}${severity}${note}`];
         }
         case "resolved":
-            return [`- question ${event.commentId} marked ${event.resolved ? "resolved" : "open again"}`];
+            return [`- ${event.commentId} ${event.resolved ? "resolved" : "reopened"}`];
         case "version":
-            return [`- plan v${event.version} is now open`];
+            return [`- plan v${event.version} is open`];
         case "submitted":
             return ["- the reviewer submitted the review"];
         case "ended":
@@ -965,11 +1026,42 @@ function renderEvent(event, ctx) {
         }
     }
 }
-/** A markdown digest of what happened on the review page, for `follow-me watch`. */
+/** What happened on the review page, for the entry and `follow-me watch`. */
 export function renderEvents(events, ctx = null) {
-    const first = events[0]?.seq;
-    const last = events.at(-1)?.seq;
-    const range = first === last ? `event ${first}` : `events ${first}-${last}`;
-    const body = events.flatMap((event) => renderEvent(event, ctx));
-    return [`# Review activity (${range})`, "", ...body, ""].join("\n");
+    return `${events.flatMap((event) => renderEvent(event, ctx)).join("\n")}\n`;
+}
+/** A unit as prompt.md prints it, and which commits of the plan take its lines. */
+export function renderShownUnit(unit, commits) {
+    const taken = commits.flatMap((commit, k) => commit.refs
+        .filter((ref) => ref.unit === unit.id)
+        .map((ref) => `commit ${k + 1} takes ${formatSelection(ref.unit, ref.select)}`));
+    const where = taken.length === 0 ? "in no commit of the plan" : taken.join("; ");
+    return `${renderUnit(unit)}\n${where}\n`;
+}
+/** A comment with every row it was made on, its words and the whole thread under it. */
+export function renderShownComment(c, ctx, version) {
+    const what = c.kind === "question" ? "question" : (c.severity ?? "comment");
+    const lines = [`${c.id} ${what} on plan v${version}, on ${describeAnchor(c.anchor, ctx)}`];
+    if (c.follows)
+        lines.push(`asks again after ${c.follows}`);
+    const rows = anchorRows(ctx, c.anchor);
+    const quoted = rows.length > 0 ? rows : (c.context.lines ?? []).map((l) => `> ${l}`);
+    lines.push(...quoted.map((r) => `    ${r}`));
+    lines.push(...said(c.author === "agent" ? "agent" : "reviewer", c.body));
+    for (const reply of c.replies ?? []) {
+        const diagram = reply.diagram === undefined ? "" : " (with a diagram)";
+        lines.push(...said(`${reply.author} replied${diagram}`, reply.body));
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** A concern of the plan with the lines it is pinned to, as its commit writes them. */
+export function renderShownConcern(concern, commit, ctx) {
+    const where = whereConcern(ctx, { concern, commit, severity: concern.severity, note: null });
+    const place = where.path === null ? where.label : `${where.path} ${where.label}`;
+    return [
+        `${concern.id} ${concern.severity} ${concern.kind} in commit ${commit + 1}, ${place}`,
+        ...where.quote.map((r) => `    ${r}`),
+        concern.text,
+        "",
+    ].join("\n");
 }