@levistudio/redline 0.2.0 → 0.4.0

package/src/client/sse.ts

@@ -1,4 +1,4 @@
-import { state } from "./state";
+import { state, markSessionEnded } from "./state";
 import {
   renderComments,
   applyHighlights,
@@ -10,6 +10,11 @@ import {
 let sseHasConnectedOnce = false;
 let currentEs: EventSource | null = null;
 let lastEventAt = Date.now();
+// Consecutive failed connection attempts with no successful open in between.
+// A transient blip resolves on the next reconnect (resetting this to 0); a
+// dead server never reconnects, so a sustained run means the server is gone.
+let consecutiveSseErrors = 0;
+const MAX_SSE_ERRORS = 4;
 
 export async function softRefresh({ rehighlight = false } = {}): Promise<void> {
   try {
@@ -53,6 +58,24 @@ export function initSSE(): void {
   document.addEventListener("visibilitychange", onVisibleOrFocus);
   window.addEventListener("focus", onVisibleOrFocus);
 
+  // Tell the server explicitly when this tab is going away, so it can
+  // distinguish a real close from a bare SSE drop (sleep, network blip) and
+  // not abandon a session the user means to keep. `keepalive` lets the POST
+  // survive unload; `pagehide` is more reliable than `beforeunload`. Skip the
+  // bfcache case (e.persisted) — the page may be restored and reconnect.
+  window.addEventListener("pagehide", (e) => {
+    if ((e as PageTransitionEvent).persisted) return;
+    try {
+      fetch("/api/tab-closed", {
+        method: "POST",
+        keepalive: true,
+        headers: { "X-Redline-Token": state.csrfToken },
+      });
+    } catch {
+      /* unload is best-effort */
+    }
+  });
+
   setInterval(() => {
     const banner = document.getElementById("sidebar-status-banner");
     const revising = banner?.classList.contains("revising");
@@ -74,6 +97,7 @@ export function initSSE(): void {
       });
     es.onopen = () => {
       lastEventAt = Date.now();
+      consecutiveSseErrors = 0;
       if (sseHasConnectedOnce) {
         softRefresh({ rehighlight: true });
       }
@@ -168,11 +192,19 @@ export function initSSE(): void {
     });
     on("finished", () => {
       document.body.innerHTML =
-        '<div style="display:flex;align-items:center;justify-content:center;height:100vh;font-family:system-ui;flex-direction:column;gap:16px;color:#374151"><div style="font-size:48px">\u2713</div><div style="font-size:20px;font-weight:600">Review complete</div><div style="color:#6b7280">You can close this tab and continue in Claude Code.</div></div>';
+        '<div style="display:flex;align-items:center;justify-content:center;height:100vh;font-family:system-ui;flex-direction:column;gap:16px;color:#374151"><div style="font-size:48px">\u2713</div><div style="font-size:20px;font-weight:600">Review complete</div><div style="color:#6b7280">You can close this tab and continue in your agent environment.</div></div>';
     });
     es.onerror = () => {
       es.close();
       if (currentEs === es) currentEs = null;
+      consecutiveSseErrors += 1;
+      // A run of failures with no successful open in between means the server
+      // is gone for good (it exited, or restarted on a fresh port this tab
+      // can't reach). Stop the silent retry loop and tell the user.
+      if (consecutiveSseErrors >= MAX_SSE_ERRORS) {
+        markSessionEnded();
+        return;
+      }
       setTimeout(connectEvents, 3000);
     };
   })();

package/src/client/state.ts

@@ -25,6 +25,7 @@ export const state = {
   pendingSelection: null as PendingSelection | null,
   navIdx: 0,
   deliberateScrollUntil: 0,
+  sessionEnded: false,
 };
 
 export type PendingSelection = {
@@ -54,3 +55,24 @@ export function showError(msg: string): void {
   el.style.display = "block";
   setTimeout(() => (el.style.display = "none"), 4000);
 }
+
+// The redline server has exited (session ended, or process killed). This tab
+// can no longer do anything useful — show a persistent banner instead of
+// letting actions fail with a cryptic "Failed to fetch". Idempotent.
+export function markSessionEnded(): void {
+  if (state.sessionEnded) return;
+  state.sessionEnded = true;
+  const el = document.getElementById("session-ended-banner");
+  if (el) el.style.display = "block";
+}
+
+// A fetch network failure (TypeError) on a mutating request means the server
+// is unreachable — treat it as a definitively ended session. A non-network
+// failure (server replied with an error) is shown as a transient toast.
+export function reportMutationFailure(action: string, err: unknown): void {
+  if (err instanceof TypeError) {
+    markSessionEnded();
+  } else {
+    showError(action + ": " + (err as Error).message);
+  }
+}

package/src/client/styles.css

@@ -569,6 +569,7 @@ mark.rl-highlight.rl-img:hover, mark.rl-highlight.rl-img.active {
   line-height: 1.5;
 }
 .verdict.revise { color: #92400e; }
+.verdict.escalate { color: #5b21b6; }
 
 /* Warm-tinted resolve button when the latest verdict implies an edit */
 .btn-resolve-comment.revise {
@@ -596,6 +597,22 @@ mark.rl-highlight.rl-img:hover, mark.rl-highlight.rl-img.active {
 .verdict-badge.revise { background: #fef3c7; color: #92400e; }
 .verdict-badge.accept { background: #e5e7eb; color: var(--text-muted); }
 
+/* Escalation badge on the quote line — comment routed to the launching agent */
+.escalate-badge {
+  display: inline-flex;
+  align-items: center;
+  margin-left: 6px;
+  padding: 1px 6px;
+  font-size: 10.5px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  border-radius: 3px;
+  font-style: normal;
+  background: #ede9fe;
+  color: #5b21b6;
+}
+
 /* Round-level secondary action (under the primary banner button) */
 .round-secondary {
   margin-top: 8px;
@@ -786,6 +803,16 @@ mark.rl-highlight.rl-img:hover, mark.rl-highlight.rl-img.active {
   align-items: center;
   gap: 8px;
 }
+/* Escalation sub-line under the round banner — purple to match the
+   ↑ Escalated comment badges, distinct from the green verdict copy. */
+.banner-escalation {
+  margin-top: 6px;
+  padding-top: 6px;
+  border-top: 1px solid #a5d6a7;
+  color: #5b21b6;
+  font-size: 12.5px;
+  font-weight: 600;
+}
 #sidebar-status-banner.revising {
   background: #fff3e0;
   border-bottom-color: #ffb74d;

package/src/parseReply.ts

@@ -7,6 +7,7 @@
 // text into the UI. The delimiter form needs no escaping:
 //
 //   REQUIRES_REVISION: <true|false>
+//   ESCALATE: <true|false>   (optional — absent means false)
 //   REASON: <one short sentence, or empty>
 //   ---MESSAGE---
 //   <free-form prose, may contain anything>
@@ -25,6 +26,10 @@ export interface ParsedReply {
   message: string;
   requires_revision: boolean;
   reason: string;
+  // True when the agent flagged the comment for the launching ("outer") agent
+  // — something it couldn't act on from inside the review. Optional in the
+  // envelope; absent means false.
+  escalate: boolean;
 }
 
 function tryDelimiterEnvelope(s: string): ParsedReply | null {
@@ -37,11 +42,13 @@ function tryDelimiterEnvelope(s: string): ParsedReply | null {
 
   const reqMatch = header.match(/REQUIRES_REVISION\s*:\s*(true|false)\b/i);
   const reasonMatch = header.match(/REASON\s*:\s*(.*?)\s*(?:\n|$)/i);
+  const escMatch = header.match(/ESCALATE\s*:\s*(true|false)\b/i);
 
   return {
     message,
     requires_revision: reqMatch ? reqMatch[1].toLowerCase() === "true" : true,
     reason: reasonMatch ? reasonMatch[1].trim() : "",
+    escalate: escMatch ? escMatch[1].toLowerCase() === "true" : false,
   };
 }
 
@@ -93,6 +100,7 @@ export function parseReply(raw: string): ParsedReply {
           message: obj.message.trim(),
           requires_revision: obj.requires_revision !== false, // default true if missing/non-bool
           reason: typeof obj.reason === "string" ? obj.reason.trim() : "",
+          escalate: obj.escalate === true,
         };
       }
     } catch { /* fall through */ }
@@ -111,5 +119,5 @@ export function parseReply(raw: string): ParsedReply {
     if (obj) return obj;
   }
 
-  return { message: trimmed, requires_revision: true, reason: "" };
+  return { message: trimmed, requires_revision: true, reason: "", escalate: false };
 }

package/src/pickModel.ts

@@ -1,12 +1,14 @@
-// Heuristic for picking which Claude model to use based on the human's message.
-// Short / simple → Haiku. Long, question, or "involved" keyword → Sonnet.
+// Heuristic for picking how much model capacity to use based on the human's
+// message. Providers map these tiers to concrete model ids.
 //
 // Used in two places:
 //   - agent.ts picks per-reply, looking at the last human message in the thread
 //   - resolve.ts picks per-revision, scanning every human message across settled comments
 
-export const FAST_MODEL = "claude-haiku-4-5-20251001";
-export const SMART_MODEL = "claude-sonnet-4-6";
+export type ModelTier = "fast" | "smart";
+
+export const FAST_MODEL: ModelTier = "fast";
+export const SMART_MODEL: ModelTier = "smart";
 
 export const REPLY_INVOLVED_PATTERNS =
   /\b(what|why|how|which|who|suggest|suggestion|alternative|option|idea|propose|explain|think|consider|recommend|help|could|would|should)\b/i;

package/src/promptEnvelope.ts

@@ -1,5 +1,5 @@
 // Per-prompt envelope around user-controlled strings before they reach
-// `claude -p`. Same delimiter-over-JSON principle the agent reply path
+// the selected local agent provider. Same delimiter-over-JSON principle the agent reply path
 // already uses (see retro entry 2026-05-07 — "delimiter envelope for agent
 // replies"), applied to the *input* side: comment text, document body,
 // thread messages.

package/src/resolve.ts

@@ -1,15 +1,17 @@
 import { appendFile, copyFile, mkdir, readFile, writeFile } from "fs/promises";
 import path from "path";
 import { loadSidecar, saveSidecar } from "./sidecar";
-import type { Round } from "./sidecar";
+import type { Round, Comment } from "./sidecar";
 import { pickRevisionModel } from "./pickModel";
 import { newEnvelope } from "./promptEnvelope";
 import { contextBlock } from "./contextBlock";
+import { getAgentProvider, resolveProviderId, type AgentProviderId } from "./agentProvider";
 
 const serverBase = () => `http://localhost:${process.env.REDLINE_PORT ?? "3000"}`;
 const csrfHeader = (): Record<string, string> => ({ "X-Redline-Token": process.env.REDLINE_TOKEN ?? "" });
 
-export async function resolve(filePath: string, options: { model?: string } = {}) {
+export async function resolve(filePath: string, options: { model?: string; agentProvider?: AgentProviderId } = {}) {
+  const provider = getAgentProvider(options.agentProvider ?? resolveProviderId());
   const model = options.model ?? null;
   const sidecar = await loadSidecar(filePath);
 
@@ -20,7 +22,7 @@ export async function resolve(filePath: string, options: { model?: string } = {}
   }
   const round: Round = resolvedRounds[resolvedRounds.length - 1];
   const settled = round.comments.filter((c) => c.resolved);
-  const chosenModel = model ?? pickRevisionModel(settled);
+  const chosenModel = model ?? provider.modelForTier(pickRevisionModel(settled));
 
   const docText = await readFile(filePath, "utf-8");
 
@@ -89,42 +91,6 @@ export async function resolve(filePath: string, options: { model?: string } = {}
     contextBlock(sidecar.context, env) +
     `<comments-to-apply>\n${commentsBlock}\n</comments-to-apply>${priorChangesBlock}\n\n<document>\n${env.wrap("document", docText)}\n</document>`;
 
-  // Call the claude CLI (inherits auth from the user's Claude Code session — no API key needed)
-  console.log(`Revising with ${chosenModel}...\n`);
-  console.log("─".repeat(60));
-  const revisionStartedAt = Date.now();
-
-  const cliBin = process.env.CLAUDE_CODE_EXECPATH ?? "claude";
-  const proc = Bun.spawn(
-    [cliBin, "-p", "--system-prompt", systemPrompt, "--model", chosenModel,
-     "--output-format", "stream-json", "--include-partial-messages", "--verbose"],
-    {
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-    }
-  );
-
-  proc.stdin.write(userMessage);
-  proc.stdin.end();
-
-  // Drain stderr concurrently so we can include it in any error report
-  let stderrText = "";
-  (async () => {
-    const r = proc.stderr.getReader();
-    const dec = new TextDecoder();
-    while (true) {
-      const { done, value } = await r.read();
-      if (done) break;
-      const chunk = dec.decode(value);
-      stderrText += chunk;
-      process.stderr.write(chunk);
-    }
-  })();
-
-  let revised = "";
-  let buffer = "";
-  const reader = proc.stdout.getReader();
   const broadcastChunk = (text: string, kind: "thinking" | "text") => {
     fetch(`${serverBase()}/api/revision-chunk`, {
       method: "POST",
@@ -132,40 +98,17 @@ export async function resolve(filePath: string, options: { model?: string } = {}
       body: JSON.stringify({ text, kind }),
     }).catch(() => {});
   };
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += new TextDecoder().decode(value);
-    const lines = buffer.split("\n");
-    buffer = lines.pop() ?? "";
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const obj = JSON.parse(line);
-        if (obj.type === "stream_event" && obj.event?.type === "content_block_delta") {
-          const delta = obj.event.delta;
-          if (delta?.type === "text_delta" && delta.text) {
-            revised += delta.text;
-            process.stdout.write(delta.text);
-            broadcastChunk(delta.text, "text");
-          } else if (delta?.type === "thinking_delta" && delta.thinking) {
-            broadcastChunk(delta.thinking, "thinking");
-          }
-        }
-      } catch { /* malformed JSON line, skip */ }
-    }
-  }
 
-  const exitCode = await proc.exited;
-  const revisionDurationMs = Date.now() - revisionStartedAt;
-  console.log("\n" + "─".repeat(60));
-  console.log(`Model: ${chosenModel}  ·  Duration: ${(revisionDurationMs / 1000).toFixed(1)}s  ·  Exit: ${exitCode}`);
-  console.log("─".repeat(60) + "\n");
+  // Per-attempt state, hoisted so fail() can report whatever the latest
+  // attempt produced.
+  let revised = "";
+  let exitCode = 0;
+  let stderrText = "";
 
   const fail = async (reason: string) => {
     await logRevisionFailure(filePath, {
       reason,
-      model: chosenModel,
+      model: `${provider.id}/${chosenModel}`,
       exitCode,
       stderr: stderrText.trim(),
       stdoutSample: revised.slice(0, 2000),
@@ -174,37 +117,52 @@ export async function resolve(filePath: string, options: { model?: string } = {}
     throw new Error(reason);
   };
 
-  if (exitCode !== 0) {
-    await fail(`claude CLI exited with code ${exitCode}${stderrText.trim() ? ` — ${stderrText.trim().split("\n").slice(-3).join(" | ")}` : ""}`);
-  }
+  // A mangled revision is usually a one-off model stumble — Haiku dropping an
+  // uncommented section, streaming a preamble, etc. Retry once before giving
+  // up. A non-zero CLI exit is NOT retried: that's an environment/auth failure
+  // a re-run won't fix.
+  const MAX_ATTEMPTS = 2;
+  let trimmed = "";
 
-  // Validate output. Strip a wrapping code fence if present, a preamble before the
-  // first heading, any <document> wrapper tags, and any meta-sections the model
-  // sometimes appends (Settled comments, Previously agreed changes, Changelog).
-  let trimmed = revised.trim()
-    .replace(/^```(?:markdown)?\n([\s\S]*)\n```$/, "$1")
-    .replace(/^<document>\s*/i, "")
-    .replace(/\s*<\/document>\s*$/i, "")
-    .trim();
-  // Strip trailing meta-sections at any heading level (## or ###).
-  const metaHeading = trimmed.match(/\n#{2,3} (Settled comments|Previously agreed changes|Changelog|Revision notes)\b/i);
-  if (metaHeading) {
-    console.log(`Stripping trailing meta-section: ${metaHeading[1]}`);
-    trimmed = trimmed.slice(0, metaHeading.index).trimEnd();
-    // Strip a trailing horizontal rule that often precedes the meta-section.
-    trimmed = trimmed.replace(/\n+---\s*$/, "").trimEnd();
-  }
-  if (!trimmed) {
-    await fail("Agent returned empty output (no text deltas streamed)");
-  }
-  if (!trimmed.startsWith("#")) {
-    const firstHeadingIdx = trimmed.search(/^# /m);
-    if (firstHeadingIdx > 0) {
-      console.log("Stripping preamble before first heading.");
-      trimmed = trimmed.slice(firstHeadingIdx).trim();
-    } else {
-      await fail("Output contains no Markdown heading — model returned non-document content");
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    console.log(
+      attempt === 1
+        ? `Revising with ${provider.id}/${chosenModel}...\n`
+        : `\nRetrying revision with ${provider.id}/${chosenModel} (attempt ${attempt}/${MAX_ATTEMPTS})...\n`
+    );
+    console.log("─".repeat(60));
+    const run = await provider.runRevision({
+      systemPrompt,
+      userMessage,
+      model: chosenModel,
+      cwd: process.cwd(),
+      onChunk: broadcastChunk,
+    });
+    revised = run.revised;
+    stderrText = run.stderr;
+    exitCode = run.exitCode;
+    console.log("\n" + "─".repeat(60));
+    console.log(`Model: ${provider.id}/${chosenModel}  ·  Duration: ${(run.durationMs / 1000).toFixed(1)}s  ·  Exit: ${exitCode}`);
+    console.log("─".repeat(60) + "\n");
+
+    // A CLI crash is not retryable — fail immediately.
+    if (exitCode !== 0) {
+      await fail(`${provider.id} CLI exited with code ${exitCode}${stderrText.trim() ? ` — ${stderrText.trim().split("\n").slice(-3).join(" | ")}` : ""}`);
+    }
+
+    const result = validateRevision(revised, docText, settled);
+    if (result.ok) {
+      trimmed = result.doc;
+      break;
+    }
+
+    // Validation failed — the model returned mangled output. Retry once; on
+    // the last attempt, log and throw so the session surfaces the error.
+    if (attempt < MAX_ATTEMPTS) {
+      console.log(`Revision output rejected: ${result.reason}`);
+      continue;
     }
+    await fail(result.reason);
   }
 
   // If the model made no changes, skip the write and signal the browser
@@ -230,6 +188,85 @@ export async function resolve(filePath: string, options: { model?: string } = {}
   } catch { /* server may not be running — non-fatal */ }
 }
 
+const HEADING_RE = /^#{1,6} .+$/gm;
+
+// Headings present in `inputDoc` but missing from `outputDoc` whose section the
+// reviewer never commented on. A comment quoting text inside a section means
+// the reviewer was working there, so dropping/reworking it is authorized; a
+// section vanishing with no comment near it means the model mangled the doc.
+function droppedSections(inputDoc: string, outputDoc: string, settled: Comment[]): string[] {
+  const outHeadings = new Set(outputDoc.match(HEADING_RE) ?? []);
+  const inMatches = [...inputDoc.matchAll(HEADING_RE)];
+  const quotes = settled.map((c) => c.quote.trim()).filter((q) => q.length > 0);
+
+  const unauthorized: string[] = [];
+  for (let i = 0; i < inMatches.length; i++) {
+    const heading = inMatches[i]![0];
+    if (outHeadings.has(heading)) continue;
+    // This heading's section runs from the heading to the next one (or EOF).
+    const start = inMatches[i]!.index!;
+    const end = i + 1 < inMatches.length ? inMatches[i + 1]!.index! : inputDoc.length;
+    const section = inputDoc.slice(start, end);
+    const commented = quotes.some((q) => section.includes(q));
+    if (!commented) unauthorized.push(heading);
+  }
+  return unauthorized;
+}
+
+// Validate (and lightly normalize) a revision pass's raw output. Pure — the
+// retry loop and tests both drive it. Returns the cleaned document on success,
+// or a human-readable reason on failure.
+export function validateRevision(
+  revised: string,
+  inputDoc: string,
+  settled: Comment[]
+): { ok: true; doc: string } | { ok: false; reason: string } {
+  // Strip a wrapping code fence and any <document> wrapper tags the model
+  // sometimes includes despite the system prompt.
+  let trimmed = revised.trim()
+    .replace(/^```(?:markdown)?\n([\s\S]*)\n```$/, "$1")
+    .replace(/^<document>\s*/i, "")
+    .replace(/\s*<\/document>\s*$/i, "")
+    .trim();
+
+  // Strip a trailing meta-section the model sometimes appends (Settled
+  // comments, Changelog, …), plus a horizontal rule that often precedes it.
+  const metaHeading = trimmed.match(/\n#{2,3} (Settled comments|Previously agreed changes|Changelog|Revision notes)\b/i);
+  if (metaHeading) {
+    trimmed = trimmed.slice(0, metaHeading.index).trimEnd().replace(/\n+---\s*$/, "").trimEnd();
+  }
+
+  if (!trimmed) {
+    return { ok: false, reason: "Revision produced empty output — no text was streamed back" };
+  }
+
+  // If the input had headings, the output should too. Strip a preamble before
+  // the first heading; if there's no heading at all, the model returned prose
+  // (an apology, a summary) instead of the document. A genuinely heading-less
+  // input is left alone — headings can't be the structural anchor there.
+  if (/^#{1,6} /m.test(inputDoc) && !/^#{1,6} /.test(trimmed)) {
+    const firstHeadingIdx = trimmed.search(/^#{1,6} /m);
+    if (firstHeadingIdx > 0) {
+      trimmed = trimmed.slice(firstHeadingIdx).trim();
+    } else {
+      return { ok: false, reason: "Revision output has no Markdown headings — the model returned non-document content, not a revised document" };
+    }
+  }
+
+  // Structural integrity: the revision must not silently drop a section the
+  // reviewer never commented on.
+  const dropped = droppedSections(inputDoc, trimmed, settled);
+  if (dropped.length > 0) {
+    const list = dropped.map((h) => `"${h}"`).join(", ");
+    return {
+      ok: false,
+      reason: `Revision dropped section${dropped.length > 1 ? "s" : ""} the reviewer never commented on: ${list} — the model mangled the document instead of editing it`,
+    };
+  }
+
+  return { ok: true, doc: trimmed };
+}
+
 async function logRevisionFailure(
   filePath: string,
   details: { reason: string; model: string; exitCode: number; stderr: string; stdoutSample: string; stdoutLength: number }

package/src/reviewSummary.ts

@@ -0,0 +1,93 @@
+// Closeout summary of a finished review.
+//
+// The inline review agent (src/agent.ts) and the agent that *launched* redline
+// share no live channel — the sidecar is the only persisted artifact, and the
+// launching agent only regains control when the session exits. So at closeout
+// the CLI prints every comment thread verbatim. Anything the reviewer said —
+// including feedback meant for the launching agent — lands in front of it.
+//
+// Comments the inline agent explicitly flagged (`escalate: true`) get a
+// dedicated section so they aren't lost in the full transcript.
+
+import type { Sidecar, Comment } from "./sidecar";
+
+export interface EscalationItem {
+  round: number;
+  quote: string;
+  request: string; // the reviewer message the inline agent couldn't act on
+  note: string;    // the agent's escalation note
+}
+
+function flatten(s: string, n: number): string {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length > n ? flat.slice(0, n - 1).trimEnd() + "…" : flat;
+}
+
+function isEscalated(c: Comment): boolean {
+  return c.thread.some((e) => e.role === "agent" && e.escalate === true);
+}
+
+// Pull out every comment the inline agent routed to the launching agent.
+export function collectEscalations(sidecar: Sidecar): EscalationItem[] {
+  const items: EscalationItem[] = [];
+  for (const round of sidecar.rounds) {
+    for (const c of round.comments) {
+      const escIdx = c.thread.findIndex((e) => e.role === "agent" && e.escalate === true);
+      if (escIdx === -1) continue;
+      const agentEntry = c.thread[escIdx]!;
+      // The reviewer message immediately before the escalation is the request
+      // the inline agent couldn't fulfill.
+      let request = "";
+      for (let i = escIdx - 1; i >= 0; i--) {
+        if (c.thread[i]!.role === "human") { request = c.thread[i]!.message; break; }
+      }
+      items.push({
+        round: round.round,
+        quote: flatten(c.quote, 80),
+        request: flatten(request, 300),
+        note: flatten(agentEntry.revision_reason || agentEntry.message, 300),
+      });
+    }
+  }
+  return items;
+}
+
+// A readable transcript of every comment thread, plus an escalation callout.
+// Printed to stdout on session close so the launching agent can read it.
+export function formatReviewSummary(sidecar: Sidecar): string {
+  const lines: string[] = [`Review threads — ${sidecar.file}`];
+
+  for (const round of sidecar.rounds) {
+    if (round.comments.length === 0) continue;
+    lines.push("", `Round ${round.round}`);
+    round.comments.forEach((c, i) => {
+      const tags = [c.resolved ? "resolved" : "open"];
+      if (isEscalated(c)) tags.push("escalated");
+      lines.push(`  ${i + 1}. "${flatten(c.quote, 80)}" — ${tags.join(" · ")}`);
+      for (const e of c.thread) {
+        const who = e.role === "human" ? "Reviewer" : (e.name || "Agent");
+        lines.push(`     ${who}: ${flatten(e.message, 280)}`);
+      }
+    });
+  }
+
+  const esc = collectEscalations(sidecar);
+  if (esc.length > 0) {
+    lines.push(
+      "",
+      `⚠ ${esc.length} comment${esc.length !== 1 ? "s" : ""} escalated to you (the launching agent):`,
+    );
+    for (const e of esc) {
+      lines.push(`  • "${e.quote}" (round ${e.round})`);
+      if (e.request) lines.push(`    Reviewer asked: ${e.request}`);
+      if (e.note) lines.push(`    Agent note: ${e.note}`);
+    }
+    lines.push(
+      "",
+      "The inline review agent couldn't act on these. Address them in the",
+      "document or with the user before considering the review closed out.",
+    );
+  }
+
+  return lines.join("\n");
+}

package/src/server-page.ts

@@ -17,7 +17,8 @@ function pageTemplate(
   context?: string,
   readOnly = false,
   csrfToken = "",
-  noAgent = false
+  noAgent = false,
+  agentName = "selected local"
 ): string {
   const commentsJson = JSON.stringify(comments);
 
@@ -51,7 +52,7 @@ function pageTemplate(
         </span>
         <div class="header-actions">
           <span id="agent-status" class="agent-status" hidden></span>
-          ${noAgent ? `<span class="manual-mode-pill" title="Started with --no-agent. No Claude replies, no revision pass.">Manual mode</span>` : ''}
+          ${noAgent ? `<span class="manual-mode-pill" title="Started with --no-agent. No ${escapeHtml(agentName)} replies, no revision pass.">Manual mode</span>` : ''}
           ${!readOnly && totalRounds > 1 ? `<button class="btn-toggle-diff" id="btn-toggle-diff" type="button" aria-pressed="false">Show changes</button>` : ''}
           ${readOnly
             ? `<span style="font-size:13px;color:var(--text-muted);font-style:italic">Read-only — <a href="/" style="color:var(--accent)">back to current</a></span>`
@@ -65,7 +66,7 @@ function pageTemplate(
       </div>` : ''}
       ${!readOnly ? `<div class="first-run-banner" id="first-run-banner" hidden>
         <span class="first-run-icon" aria-hidden="true">⚠</span>
-        <span class="first-run-text">Redline sends document and comment text to your local Claude Code agent. Use trusted docs.</span>
+        <span class="first-run-text">Redline sends document and comment text to your ${escapeHtml(agentName)} agent. Use trusted docs.</span>
         <button class="first-run-dismiss" id="first-run-dismiss" aria-label="Dismiss">Got it</button>
       </div>` : ''}
       <article class="prose" id="prose">
@@ -97,6 +98,7 @@ function pageTemplate(
     </div>
   </div>
   <div id="error-banner" style="display:none;position:fixed;bottom:24px;left:50%;transform:translateX(-50%);background:#b71c1c;color:white;padding:12px 24px;border-radius:6px;font-size:14px;font-weight:500;box-shadow:0 1px 4px rgba(0,0,0,0.08);z-index:999;white-space:nowrap;"></div>
+  <div id="session-ended-banner" style="display:none;position:fixed;top:0;left:0;right:0;background:#92400e;color:white;padding:10px 24px;font-size:14px;font-weight:500;text-align:center;z-index:1000;box-shadow:0 1px 4px rgba(0,0,0,0.15);">Review session ended — the redline server is no longer running. Your changes up to this point are saved; close this tab and continue in your agent environment.</div>
 
   <script>
     window.__REDLINE__ = {