@levistudio/redline 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to Redline are documented here. The format follows [Keep a C
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-05-15
+
+### Added
+- **Escalation handoff** ([#86](https://github.com/alevi/redline/pull/86)). When a comment needs something the inline review agent can't provide — an external style guide, a spec it can't see, a decision that needs the wider project — the agent flags its reply with an escalate verdict. The comment shows an "Escalated" badge, the round banner notes the count, and the session's closeout summary and `.review/<file>.result` carry an `escalations` array so the agent that launched the review picks the feedback up.
+
+### Fixed
+- **Revision integrity check and retry** ([#86](https://github.com/alevi/redline/pull/86)). The revision pass now validates its output on every run and rejects a revision that silently drops document sections no comment touched, instead of writing a mangled document to disk. A failed validation retries once before surfacing an error.
+- **Cross-block and image-spanning selections** ([#85](https://github.com/alevi/redline/pull/85)) now anchor correctly. Selecting across a block boundary, or across an image, no longer fails with an anchoring error.
+- **Sessions are no longer abandoned on a transient SSE drop** ([#84](https://github.com/alevi/redline/pull/84)). A backgrounded tab, laptop sleep, or a brief network blip no longer causes the server to exit; only an explicit tab close ends the session. A server that does go away surfaces a clear "session ended" banner instead of a raw fetch error.
+
 ## [0.2.0] - 2026-05-11
 
 ### Added
@@ -41,6 +51,7 @@ Initial public release on npm as `@levistudio/redline`.
 - Auto-installs missing dependencies on first CLI run.
 - Initial test suite: server, sidecar, parsing, model-picking, rendering, diff, SSE, integration, happy-dom client.
 
-[Unreleased]: https://github.com/alevi/redline/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/alevi/redline/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/alevi/redline/releases/tag/v0.3.0
 [0.2.0]: https://github.com/alevi/redline/releases/tag/v0.2.0
 [0.1.0]: https://github.com/alevi/redline/releases/tag/v0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levistudio/redline",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Inline comments on Markdown files, for human-in-the-loop AI doc review.",
   "keywords": [
     "markdown",

package/src/agent.ts

@@ -89,8 +89,11 @@ const REPLY_SYSTEM_PROMPT_BODY =
   "Good: message: \"Got it.\"  reason: \"Add a third line to the hard line breaks example\"\n" +
   "When requires_revision is false, leave reason empty (or a very short note about why no edit). The reply IS the answer.\n" +
   "\n" +
+  "Separately, decide whether this comment needs the agent that LAUNCHED this review rather than you. That outer agent has the project context, tools, and authority you don't — e.g. an external style guide or canon you can't see, a spec to check the document against, or a decision that depends on the wider project. When the comment asks for something like that, set ESCALATE: true and briefly tell the reviewer in your message that you've routed it to the launching agent. Otherwise ESCALATE: false. Escalating does not change requires_revision — judge that on its own.\n" +
+  "\n" +
   "Output exactly this format and nothing else (no prose before/after, no code fences). Use these literal markers — do not escape quotes inside the message:\n" +
   "REQUIRES_REVISION: <true|false>\n" +
+  "ESCALATE: <true|false>\n" +
   "REASON: <one short sentence describing the edit, or empty>\n" +
   "---MESSAGE---\n" +
   "<your reply text — quotes, punctuation, anything>\n" +
@@ -114,12 +117,13 @@ async function postReply(
   commentId: string,
   message: string,
   requires_revision: boolean,
-  revision_reason: string
+  revision_reason: string,
+  escalate: boolean
 ) {
   await fetch(`${BASE_URL}/api/comment/${commentId}/reply`, {
     method: "POST",
     headers: { "Content-Type": "application/json", ...CSRF_HEADER },
-    body: JSON.stringify({ role: "agent", name: "Claude", message, requires_revision, revision_reason }),
+    body: JSON.stringify({ role: "agent", name: "Claude", message, requires_revision, revision_reason, escalate }),
   });
 }
 
@@ -185,8 +189,8 @@ async function handleComment(commentId: string) {
 
     if (reply.trim()) {
       const parsed = parseReply(reply);
-      console.log(`[agent] verdict for ${commentId}: requires_revision=${parsed.requires_revision}`);
-      await postReply(commentId, parsed.message, parsed.requires_revision, parsed.reason);
+      console.log(`[agent] verdict for ${commentId}: requires_revision=${parsed.requires_revision} escalate=${parsed.escalate}`);
+      await postReply(commentId, parsed.message, parsed.requires_revision, parsed.reason, parsed.escalate);
     }
   } catch (err) {
     await logReplyFailure(commentId, err);

package/src/cli.ts

@@ -4,6 +4,10 @@ import { mkdir, writeFile } from "fs/promises";
 import { spawnSync } from "child_process";
 import { createRequire } from "module";
 import path from "path";
+// reviewSummary only `import type`s from ./sidecar, so it pulls in no
+// third-party deps at runtime — safe to import statically ahead of the
+// preflight. abandon() needs it synchronously (signal context).
+import { collectEscalations, formatReviewSummary } from "./reviewSummary";
 
 // Ensure redline's own dependencies are resolvable before any third-party
 // imports load. `redline` is invoked from arbitrary projects: in a checkout
@@ -137,6 +141,7 @@ if (args[0] === "resolve") {
 
   const resultFile = path.join(path.dirname(resolved), ".review", path.basename(resolved) + ".result");
   const startupFile = path.join(path.dirname(resolved), ".review", path.basename(resolved) + ".startup.json");
+  const sidecarFile = path.join(path.dirname(resolved), ".review", path.basename(resolved) + ".json");
 
   // Clear stale state from a prior run so a polling agent can't be misled
   // by a leftover .result or .startup.json file that predates this process.
@@ -274,19 +279,36 @@ if (args[0] === "resolve") {
     const status = lastRevisionError ? "error" : "abandoned";
     const payload: Record<string, unknown> = { status, file: resolved };
     if (lastRevisionError) payload.reason = lastRevisionError;
+    // Carry escalations through the error/abandon path too — on an incomplete
+    // session they matter more, not less. Read the sidecar synchronously:
+    // abandon runs in signal context where async I/O may not complete.
+    let escalations: import("./reviewSummary").EscalationItem[] = [];
+    try {
+      if (existsSync(sidecarFile)) {
+        const raw = readFileSync(sidecarFile, "utf-8");
+        if (raw.trim()) escalations = collectEscalations(JSON.parse(raw));
+      }
+    } catch { /* best effort — never block shutdown on the summary */ }
+    payload.escalations = escalations;
     // Synchronous write so the result file lands even if the runtime is
     // terminating due to a signal (async I/O may not complete in that case).
     try {
       mkdirSync(path.dirname(resultFile), { recursive: true });
       writeFileSync(resultFile, JSON.stringify(payload, null, 2));
     } catch { /* best effort */ }
-    console.log(`\nREDLINE_RESULT: ${status}${lastRevisionError ? ` reason="${lastRevisionError}"` : ""}`);
+    if (escalations.length) {
+      console.log(
+        `\n⚠ ${escalations.length} comment${escalations.length !== 1 ? "s" : ""} escalated to the launching agent — see ${path.basename(resultFile)}`
+      );
+    }
+    const escSuffix = escalations.length ? ` escalations=${escalations.length}` : "";
+    console.log(`\nREDLINE_RESULT: ${status}${lastRevisionError ? ` reason="${lastRevisionError}"` : ""}${escSuffix}`);
     // Exit 3 = revision error; 2 = abandoned. Both still distinguish from 0 (approved).
     process.exit(lastRevisionError ? 3 : 2);
   };
 
   // Happy-path finish: human clicked Done.
-  app.onFinished(({ totalRounds, totalComments }) => {
+  app.onFinished(async ({ totalRounds, totalComments }) => {
     serverExiting = true;
     killAgent().catch(() => { /* shutdown already in flight */ });
     try { unlinkSync(startupFile); } catch { /* best effort */ }
@@ -296,10 +318,25 @@ if (args[0] === "resolve") {
     console.log(`   ${totalRounds} round${totalRounds !== 1 ? "s" : ""} · ${totalComments} comment${totalComments !== 1 ? "s" : ""} addressed`);
     console.log(`   Revised document: ${resolved}`);
     console.log(`${line}`);
+
+    // Print the full comment threads so the launching agent — which has no
+    // live channel to the inline review agent — sees everything the reviewer
+    // said, including escalated feedback meant for it.
+    let escalations: import("./reviewSummary").EscalationItem[] = [];
+    try {
+      const { loadSidecar } = await import("./sidecar");
+      const sidecar = await loadSidecar(resolved);
+      escalations = collectEscalations(sidecar);
+      console.log(`\n${formatReviewSummary(sidecar)}`);
+    } catch (e) {
+      console.error("[redline] Failed to build review summary:", e);
+    }
+
     // Machine-greppable result line for a calling agent. Keep this stable.
-    console.log(`REDLINE_RESULT: approved file=${resolved} rounds=${totalRounds} comments=${totalComments}`);
+    const escSuffix = escalations.length ? ` escalations=${escalations.length}` : "";
+    console.log(`\nREDLINE_RESULT: approved file=${resolved} rounds=${totalRounds} comments=${totalComments}${escSuffix}`);
     console.log("");
-    writeResult({ status: "approved", file: resolved, rounds: totalRounds, comments: totalComments })
+    writeResult({ status: "approved", file: resolved, rounds: totalRounds, comments: totalComments, escalations })
       .finally(() => process.exit(0));
   });
 

package/src/client/cards.ts

@@ -1,4 +1,4 @@
-import { escapeHtml, latestVerdict, type ClientComment, type ThreadEntry } from "./lib";
+import { escapeHtml, isEscalated, latestVerdict, type ClientComment, type ThreadEntry } from "./lib";
 import { state } from "./state";
 
 export type CardCallbacks = {
@@ -41,6 +41,12 @@ export function buildCommentCard(comment: ClientComment): HTMLDivElement {
       quote.appendChild(vbadge);
     }
   }
+  if (isEscalated(comment)) {
+    const ebadge = document.createElement("span");
+    ebadge.className = "escalate-badge";
+    ebadge.textContent = "↑ Escalated";
+    quote.appendChild(ebadge);
+  }
   quote.appendChild(document.createTextNode('"' + comment.quote + '"'));
   card.appendChild(quote);
 
@@ -166,6 +172,9 @@ function buildThreadEntry(entry: ThreadEntry, isLatestVerdict: boolean): HTMLDiv
     const reason = entry.revision_reason ? escapeHtml(entry.revision_reason) : "edit queued";
     verdictHtml = `<div class="verdict revise"><span class="verdict-icon">\u270E</span><span>${reason}</span></div>`;
   }
+  if (role === "agent" && entry.escalate === true) {
+    verdictHtml += `<div class="verdict escalate"><span class="verdict-icon">\u2191</span><span>Routed to the launching agent</span></div>`;
+  }
   const messageHtml = entry.messageHtml ?? escapeHtml(entry.message);
   div.innerHTML = `
     <div class="thread-role ${role}">${escapeHtml(label)}</div>

package/src/client/lib.ts

@@ -22,6 +22,7 @@ export type ThreadEntry = {
   messageHtml?: string;
   requires_revision?: boolean;
   revision_reason?: string;
+  escalate?: boolean;
 };
 
 export function escapeHtml(s: string): string {
@@ -44,6 +45,11 @@ export function latestVerdict(comment: ClientComment): "revise" | "accept" | nul
   return null;
 }
 
+// True when an agent reply flagged this comment for the launching agent.
+export function isEscalated(comment: ClientComment): boolean {
+  return (comment.thread || []).some((e) => e.role === "agent" && e.escalate === true);
+}
+
 export function nearestCell(node: Node): HTMLElement | null {
   const el = node.nodeType === Node.TEXT_NODE ? node.parentNode : node;
   return el && (el as Element).closest ? ((el as Element).closest("td, th") as HTMLElement | null) : null;
@@ -86,63 +92,138 @@ export type Captured = {
   context_after: string;
 };
 
-// Walk the prose container's text nodes, locate the selection's start, and
-// return the quote with surrounding context. Returns null when the selection
-// can't be relocated against flat text (e.g. crossed an <img>).
-export function captureSelection(prose: Element, sel: Selection, text: string): Captured | null {
-  const range = sel.getRangeAt(0);
+type FlatSegment = {
+  node: Text | HTMLImageElement;
+  start: number;
+  len: number;
+  isImg: boolean;
+};
 
-  const walker = (prose.ownerDocument || document).createTreeWalker(prose, NodeFilter.SHOW_TEXT);
-  const segments: { node: Text; start: number }[] = [];
+// An <img> contributes no characters of its own, so on its own it can't be
+// anchored against. We give it a presence in the flat text as an
+// `[image: alt]` token — the same shape the image-only comment path uses — so
+// a selection can run text → image → text and still round-trip.
+function imgToken(img: HTMLImageElement): string {
+  return "[image: " + (img.alt || "") + "]";
+}
+
+// Walk a container into a flat string plus the segments that produced it.
+// Text nodes contribute their value; <img> elements contribute an
+// `[image: alt]` token. Segments are in document order. captureSelection and
+// highlightText both build flat through here so their coordinates agree.
+function buildFlat(container: Element): { flat: string; segments: FlatSegment[] } {
+  const doc = container.ownerDocument || document;
+  const walker = doc.createTreeWalker(container, NodeFilter.SHOW_TEXT | NodeFilter.SHOW_ELEMENT, {
+    acceptNode(n: Node) {
+      if (n.nodeType === Node.TEXT_NODE) return NodeFilter.FILTER_ACCEPT;
+      return (n as Element).tagName === "IMG" ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    },
+  });
+  const segments: FlatSegment[] = [];
   let flat = "";
   let node: Node | null;
   while ((node = walker.nextNode())) {
-    const tn = node as Text;
-    segments.push({ node: tn, start: flat.length });
-    flat += tn.nodeValue ?? "";
-  }
-
-  let quoteStart = -1;
-  for (const seg of segments) {
-    if (seg.node === range.startContainer) {
-      quoteStart = seg.start + range.startOffset;
-      break;
+    if (node.nodeType === Node.TEXT_NODE) {
+      const v = (node as Text).nodeValue ?? "";
+      segments.push({ node: node as Text, start: flat.length, len: v.length, isImg: false });
+      flat += v;
+    } else {
+      const img = node as HTMLImageElement;
+      const tok = imgToken(img);
+      segments.push({ node: img, start: flat.length, len: tok.length, isImg: true });
+      flat += tok;
     }
   }
+  return { flat, segments };
+}
 
-  if (quoteStart === -1) {
-    return { quote: text, context_before: "", context_after: "" };
-  }
+// Map both range endpoints onto the flat text and return the quote with
+// surrounding context. Returns null only when the selection can't be resolved
+// against the flat text at all.
+//
+// The quote is sliced straight out of `flat` rather than reconstructed from
+// `sel.toString()`. sel.toString() joins blocks with "\n"/"\n\n" separators
+// that don't exist in the walker's output, and marked emits stray whitespace
+// text nodes between block tags — so the two never line up across a block
+// boundary. Working in flat coordinates sidesteps the mismatch: `flat` is the
+// single source of truth, and highlightText re-finds the quote against the
+// same flat string later. `text` is kept only as a last-resort fallback for
+// the rare case where an endpoint can't be resolved.
+export function captureSelection(prose: Element, sel: Selection, text: string): Captured | null {
+  const range = sel.getRangeAt(0);
+  const { flat, segments } = buildFlat(prose);
+  if (segments.length === 0) return null;
 
-  // Block boundaries: sel.toString() inserts "\n\n" between blocks (e.g. a
-  // heading followed by a paragraph), but the text-node walker concatenates
-  // with no separator. Strip those runs from `text` so it can match `flat`.
-  // We keep single \n (which can appear inside a single text node, e.g. a
-  // code block) untouched.
-  const normalized = text.replace(/\n{2,}/g, "");
+  // Map a range boundary point onto an index into `flat`. Text-node boundaries
+  // are the common case; Chrome sometimes anchors a drag to an element node
+  // plus a child index, which we resolve to the nearest segment edge.
+  const pointToFlat = (container: Node, offset: number, side: "start" | "end"): number => {
+    for (const seg of segments) {
+      if (seg.node === container) {
+        if (seg.isImg) return offset > 0 ? seg.start + seg.len : seg.start;
+        return seg.start + offset;
+      }
+    }
+    if (container.nodeType === Node.TEXT_NODE) return -1;
+    const kids = container.childNodes;
+    const segEnd = (seg: FlatSegment) => seg.start + seg.len;
+    if (side === "start") {
+      const ref = offset < kids.length ? kids[offset]! : null;
+      if (ref) {
+        for (const seg of segments) {
+          if (ref === seg.node || ref.contains(seg.node)) return seg.start;
+          if (ref.compareDocumentPosition(seg.node) & Node.DOCUMENT_POSITION_FOLLOWING)
+            return seg.start;
+        }
+        return flat.length;
+      }
+      let end = -1;
+      for (const seg of segments) if (container.contains(seg.node)) end = segEnd(seg);
+      return end === -1 ? flat.length : end;
+    }
+    const ref = offset > 0 ? kids[offset - 1]! : null;
+    if (ref) {
+      let end = -1;
+      for (const seg of segments) {
+        if (
+          ref === seg.node ||
+          ref.contains(seg.node) ||
+          ref.compareDocumentPosition(seg.node) & Node.DOCUMENT_POSITION_PRECEDING
+        ) {
+          end = segEnd(seg);
+        }
+      }
+      return end === -1 ? 0 : end;
+    }
+    for (const seg of segments) if (container.contains(seg.node)) return seg.start;
+    return 0;
+  };
 
-  const slice = flat.slice(quoteStart, quoteStart + normalized.length);
-  if (slice !== normalized) {
-    // Trimming in the caller can shift the true start a few chars away from
-    // range.startOffset. Search a small window around quoteStart for the
-    // normalized text before giving up.
-    const windowStart = Math.max(0, quoteStart - 64);
-    const windowEnd = Math.min(flat.length, quoteStart + normalized.length + 64);
-    const found = flat.indexOf(normalized, windowStart);
-    if (found === -1 || found >= windowEnd) return null;
-    quoteStart = found;
+  let flatStart = pointToFlat(range.startContainer, range.startOffset, "start");
+  let flatEnd = pointToFlat(range.endContainer, range.endOffset, "end");
+  if (flatStart === -1 || flatEnd === -1 || flatEnd <= flatStart) {
+    return text ? { quote: text, context_before: "", context_after: "" } : null;
   }
 
+  // Trim whitespace overshoot: a drag that ends a hair past a block — or
+  // starts in the gap before one — shouldn't fail or carry stray newlines.
+  // This is the "clamp": a small overshoot anchors to what the user meant.
+  while (flatStart < flatEnd && /\s/.test(flat[flatStart]!)) flatStart++;
+  while (flatEnd > flatStart && /\s/.test(flat[flatEnd - 1]!)) flatEnd--;
+  if (flatEnd <= flatStart) return null;
+
   return {
-    quote: normalized,
-    context_before: flat.slice(Math.max(0, quoteStart - 32), quoteStart),
-    context_after: flat.slice(quoteStart + normalized.length, quoteStart + normalized.length + 32),
+    quote: flat.slice(flatStart, flatEnd),
+    context_before: flat.slice(Math.max(0, flatStart - 32), flatStart),
+    context_after: flat.slice(flatEnd, flatEnd + 32),
   };
 }
 
 // Wrap occurrences of `text` inside `container` with <mark> elements. Uses
-// `contextBefore` to disambiguate when a quote appears multiple times.
-// Image quotes (`[image: alt]`) wrap the matching <img> instead.
+// `contextBefore` to disambiguate when a quote appears multiple times. The
+// quote is matched against the same flat text captureSelection produced, so
+// `[image: alt]` tokens in the quote wrap the corresponding <img> — whether
+// the quote is image-only or text mixed with an image.
 // Returns the marks created (caller can attach event listeners).
 export function highlightText(
   container: Element,
@@ -154,35 +235,9 @@ export function highlightText(
   const doc = container.ownerDocument || document;
   const marks: HTMLElement[] = [];
 
-  const imgMatch = text.match(/^\[image:\s*(.*)\]$/);
-  if (imgMatch) {
-    const alt = imgMatch[1];
-    const imgs = container.querySelectorAll("img");
-    for (const img of imgs) {
-      if ((img.alt || "") === alt) {
-        const mark = doc.createElement("mark");
-        mark.className = "rl-highlight rl-img" + (resolved ? " resolved" : "");
-        mark.dataset.commentId = id;
-        img.parentNode!.insertBefore(mark, img);
-        mark.appendChild(img);
-        marks.push(mark);
-        return marks;
-      }
-    }
-    return marks;
-  }
-
   (container as HTMLElement).normalize();
 
-  const walker = doc.createTreeWalker(container, NodeFilter.SHOW_TEXT);
-  const segments: { node: Text; start: number }[] = [];
-  let flat = "";
-  let node: Node | null;
-  while ((node = walker.nextNode())) {
-    const tn = node as Text;
-    segments.push({ node: tn, start: flat.length });
-    flat += tn.nodeValue ?? "";
-  }
+  const { flat, segments } = buildFlat(container);
 
   let quoteStart = -1;
   if (contextBefore) {
@@ -194,18 +249,28 @@ export function highlightText(
 
   const quoteEnd = quoteStart + text.length;
 
-  const toWrap: { node: Text; localStart: number; localEnd: number }[] = [];
   for (const seg of segments) {
-    const segEnd = seg.start + (seg.node.nodeValue?.length ?? 0);
-    if (segEnd <= quoteStart || seg.start >= quoteEnd) continue;
-    toWrap.push({
-      node: seg.node,
-      localStart: Math.max(0, quoteStart - seg.start),
-      localEnd: Math.min(seg.node.nodeValue?.length ?? 0, quoteEnd - seg.start),
-    });
-  }
+    const segStart = seg.start;
+    const segEnd = seg.start + seg.len;
+    if (segEnd <= quoteStart || segStart >= quoteEnd) continue;
+
+    if (seg.isImg) {
+      // Image tokens are atomic — wrap the <img> only when the quote covers
+      // the whole token, never on a partial overlap.
+      if (segStart < quoteStart || segEnd > quoteEnd) continue;
+      const img = seg.node as HTMLImageElement;
+      const mark = doc.createElement("mark");
+      mark.className = "rl-highlight rl-img" + (resolved ? " resolved" : "");
+      mark.dataset.commentId = id;
+      img.parentNode!.insertBefore(mark, img);
+      mark.appendChild(img);
+      marks.push(mark);
+      continue;
+    }
 
-  for (const { node: tn, localStart, localEnd } of toWrap) {
+    const tn = seg.node as Text;
+    const localStart = Math.max(0, quoteStart - segStart);
+    const localEnd = Math.min(seg.len, quoteEnd - segStart);
     const mark = doc.createElement("mark");
     mark.className = "rl-highlight" + (resolved ? " resolved" : "");
     mark.dataset.commentId = id;

package/src/client/render.ts

@@ -3,8 +3,9 @@ import {
   highlightText as _highlightText,
   preserveScroll as _preserveScroll,
   latestVerdict,
+  isEscalated,
 } from "./lib";
-import { state, apiFetch, showError } from "./state";
+import { state, apiFetch, showError, reportMutationFailure } from "./state";
 import {
   buildCommentCard,
   captureTypingState,
@@ -171,7 +172,7 @@ export async function saveComment(
       showError(data.error || "Failed to save comment");
     }
   } catch (err: unknown) {
-    showError("Failed to save comment: " + (err as Error).message);
+    reportMutationFailure("Failed to save comment", err);
   }
 }
 
@@ -195,7 +196,7 @@ export async function submitReply(id: string, message: string): Promise<void> {
       showError(data.error || "Failed to save reply");
     }
   } catch (err: unknown) {
-    showError("Failed to save reply: " + (err as Error).message);
+    reportMutationFailure("Failed to save reply", err);
   }
 }
 
@@ -220,7 +221,7 @@ export async function resolveComment(id: string): Promise<void> {
       showError(data.error || "Failed to resolve comment");
     }
   } catch (err: unknown) {
-    showError("Failed to resolve: " + (err as Error).message);
+    reportMutationFailure("Failed to resolve", err);
   }
 }
 
@@ -240,7 +241,7 @@ export async function reopenComment(id: string): Promise<void> {
       showError(data.error || "Failed to reopen comment");
     }
   } catch (err: unknown) {
-    showError("Failed to reopen: " + (err as Error).message);
+    reportMutationFailure("Failed to reopen", err);
   }
 }
 
@@ -345,6 +346,17 @@ export function applyRoundState(): void {
           bannerText = `${reviseCount} of ${total} comments imply edits.`;
         }
         banner.textContent = bannerText;
+        // Escalations are orthogonal to the revise/accept verdict — a comment
+        // can be answered in-thread yet still need the launching agent. Call
+        // it out on its own line so it survives all three banner branches.
+        const escCount = state.comments.filter(isEscalated).length;
+        if (escCount > 0) {
+          const escLine = document.createElement("div");
+          escLine.className = "banner-escalation";
+          escLine.textContent =
+            `↑ ${escCount} comment${escCount !== 1 ? "s" : ""} escalated to the launching agent.`;
+          banner.appendChild(escLine);
+        }
         banner.style.display = "block";
       }
 

package/src/client/selection.ts

@@ -197,7 +197,7 @@ export function initSelectionHandlers(): void {
 
       const captured = captureSelection(sel, text);
       if (!captured) {
-        showError("Highlight a single passage \u2014 selections that cross images or sections can't be anchored.");
+        showError("Couldn't anchor that selection \u2014 try highlighting the passage again.");
         sel.removeAllRanges();
         return;
       }

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 });
       }
@@ -173,6 +197,14 @@ export function initSSE(): void {
     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/resolve.ts

@@ -1,7 +1,7 @@
 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";
@@ -90,41 +90,8 @@ export async function resolve(filePath: string, options: { model?: string } = {}
     `<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,35 +99,12 @@ 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, {
@@ -174,37 +118,97 @@ 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 ${chosenModel}...\n`
+        : `\nRetrying revision with ${chosenModel} (attempt ${attempt}/${MAX_ATTEMPTS})...\n`
+    );
+    console.log("─".repeat(60));
+    const revisionStartedAt = Date.now();
+
+    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.
+    stderrText = "";
+    const stderrDone = (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);
+      }
+    })();
+
+    revised = "";
+    let buffer = "";
+    const reader = proc.stdout.getReader();
+    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 */ }
+      }
     }
+
+    exitCode = await proc.exited;
+    await stderrDone;
+    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");
+
+    // A CLI crash is not retryable — fail immediately.
+    if (exitCode !== 0) {
+      await fail(`claude 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 +234,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

@@ -97,6 +97,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 Claude Code.</div>
 
   <script>
     window.__REDLINE__ = {

package/src/server.ts

@@ -129,12 +129,23 @@ export function createServer(
 
   // Abandonment detection: if no browser is connected for ABANDON_GRACE_MS after
   // the first one ever connected, fire onAbandonCallback so the CLI can exit.
-  // Default 10min — DevTools-offline debugging, brief network blips, and tab
-  // sleeps all reconnect well within that. The previous 2min default tripped on
-  // routine offline-mode testing. Override with REDLINE_ABANDON_MS for tests.
+  // Default 10min — this is now only the *backstop* for the no-beacon case
+  // (browser crash, kill -9, OS-killed tab). A cleanly closed tab fires an
+  // explicit /api/tab-closed beacon and takes the much shorter TAB_CLOSE_GRACE_MS
+  // path instead. The long backstop must stay generous: a bare SSE drop (laptop
+  // sleep, network blip, DevTools offline) is NOT a closed tab, and exiting on
+  // it kills a session the user means to continue. Override with
+  // REDLINE_ABANDON_MS for tests.
   const ABANDON_GRACE_MS = process.env.REDLINE_ABANDON_MS
     ? parseInt(process.env.REDLINE_ABANDON_MS, 10)
     : 10 * 60 * 1000;
+  // Grace applied after an explicit tab-close beacon. A reload also fires the
+  // beacon, so we can't exit immediately — but a reload reconnects its SSE
+  // within ~1s, while a real close never does. A few seconds covers the
+  // reconnect. Override with REDLINE_TABCLOSE_MS for tests.
+  const TAB_CLOSE_GRACE_MS = process.env.REDLINE_TABCLOSE_MS
+    ? parseInt(process.env.REDLINE_TABCLOSE_MS, 10)
+    : 8000;
   let hadBrowser = false;
   let abandonTimer: ReturnType<typeof setTimeout> | null = null;
   let onAbandonCallback: (() => void) | undefined;
@@ -194,15 +205,24 @@ export function createServer(
     }, REVISION_TIMEOUT_MS);
   }
 
+  function armAbandonTimer(graceMs: number) {
+    if (abandonTimer) clearTimeout(abandonTimer);
+    abandonTimer = setTimeout(() => {
+      abandonTimer = null;
+      // Re-check at fire time: a tab may have (re)connected during the grace
+      // — a reload, or a second tab — in which case nothing is abandoned.
+      if (browserClients.size > 0) return;
+      console.log(`\n[redline] No browser connected for ${graceMs / 1000}s — assuming abandoned.`);
+      onAbandonCallback?.();
+    }, graceMs);
+  }
+
   function checkBrowserPresence() {
     if (browserClients.size > 0) {
       hadBrowser = true;
       if (abandonTimer) { clearTimeout(abandonTimer); abandonTimer = null; }
     } else if (hadBrowser && !abandonTimer) {
-      abandonTimer = setTimeout(() => {
-        console.log(`\n[redline] No browser connected for ${ABANDON_GRACE_MS / 1000}s — assuming abandoned.`);
-        onAbandonCallback?.();
-      }, ABANDON_GRACE_MS);
+      armAbandonTimer(ABANDON_GRACE_MS);
     }
   }
 
@@ -424,6 +444,17 @@ export function createServer(
     return c.json({ ok: true });
   });
 
+  // A browser tab fired pagehide — it is closing, reloading, or navigating away.
+  // This is a hint, not proof of abandonment (a reload fires it too), so we
+  // shorten the abandon grace rather than exiting outright. On a real close the
+  // SSE never reconnects and the short timer fires; on a reload the new page
+  // reconnects within ~1s and checkBrowserPresence clears the timer. Crashes
+  // and kill -9 send no beacon and fall back to the long ABANDON_GRACE_MS.
+  app.post("/api/tab-closed", (c) => {
+    if (hadBrowser) armAbandonTimer(TAB_CLOSE_GRACE_MS);
+    return c.json({ ok: true });
+  });
+
   // Agent signals it is composing a reply (shows typing indicator in thread)
   app.post("/api/comment/:id/thinking", async (c) => {
     const id = c.req.param("id");
@@ -440,6 +471,7 @@ export function createServer(
       name?: string;
       requires_revision?: boolean;
       revision_reason?: string;
+      escalate?: boolean;
     }>();
     if (!body.message?.trim()) return c.json({ ok: false, error: "message is required" }, 400);
     const role = (body.role === "human" ? "human" : "agent") as "human" | "agent";
@@ -453,9 +485,12 @@ export function createServer(
       const entry: import("./sidecar").ThreadEntry = { role, message: body.message.trim(), at: new Date().toISOString() };
       if (name) entry.name = name;
       // Verdict only meaningful on agent replies; ignore on human entries.
-      if (role === "agent" && typeof body.requires_revision === "boolean") {
-        entry.requires_revision = body.requires_revision;
-        if (body.revision_reason?.trim()) entry.revision_reason = body.revision_reason.trim();
+      if (role === "agent") {
+        if (typeof body.requires_revision === "boolean") {
+          entry.requires_revision = body.requires_revision;
+          if (body.revision_reason?.trim()) entry.revision_reason = body.revision_reason.trim();
+        }
+        if (body.escalate === true) entry.escalate = true;
       }
       comment.thread.push(entry);
       return { skip: false as const, roundNumber: round.round, comment };

package/src/sidecar.ts

@@ -13,6 +13,11 @@ export interface ThreadEntry {
   // action defaults to "Revise" or "Accept as-is". Only set on agent entries.
   requires_revision?: boolean;
   revision_reason?: string;
+  // Set true on an agent reply when the comment can't be acted on from inside
+  // this review — it needs the agent that *launched* redline (project context,
+  // tools, or authority the inline agent lacks). Surfaced in the closeout
+  // summary so the launching agent picks it up. Only set on agent entries.
+  escalate?: boolean;
 }
 
 // Latest agent verdict on a comment thread: