@levistudio/redline 0.1.0 → 0.3.0

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

@@ -1,5 +1,3 @@
-import type { Comment } from "./sidecar";
-
 function escapeHtml(s: string): string {
   return s
     .replace(/&/g, "&")
@@ -11,7 +9,7 @@ function escapeHtml(s: string): string {
 function pageTemplate(
   title: string,
   content: string,
-  comments: Comment[],
+  comments: unknown[],
   roundResolved: boolean,
   agentRepliedAt: string | null,
   roundNumber: number,
@@ -48,21 +46,20 @@ function pageTemplate(
                 const label = n === totalRounds ? 'Round ' + n + ' — current' : 'Round ' + n;
                 return `<a class="round-picker-item${isCurrent ? ' current' : ''}" href="${href}">${label}</a>`;
               }).join('')
-            }</div>` : ''}
+            }${!readOnly ? `<button class="round-picker-item round-picker-action" id="btn-compare" type="button">Compare with previous →</button>` : ''}</div>` : ''}
           </span>
         </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>` : ''}
+          ${!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>`
-            : `<button class="btn-accept" id="btn-accept" disabled>Revise document</button>
-               ${totalRounds > 1 ? `<button class="btn-diff-compare" id="btn-compare">Compare with previous</button>` : ''}`
+            : `<button class="btn-accept" id="btn-accept" disabled>Revise document</button>`
           }
         </div>
       </div>
       ${context ? `<div class="context-banner" id="context-banner">
-        <span class="context-label">Context</span>
         <span class="context-text">${escapeHtml(context)}</span>
         <button class="context-dismiss" onclick="dismissContextBanner()" aria-label="Dismiss">✕</button>
       </div>` : ''}
@@ -100,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

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import { readFile, realpath } from "fs/promises";
 import path from "path";
-import { renderMarkdown } from "./render";
+import { renderMarkdown, renderMessageMarkdown } from "./render";
 import { renderDocDiff } from "./diff";
 import { pageTemplate } from "./server-page";
 import {
@@ -13,6 +13,22 @@ import {
   type Comment,
 } from "./sidecar";
 
+// Attach a sanitized HTML rendering of each thread message so the client
+// can show markdown formatting (bold, lists, inline code) instead of the
+// raw source. Done server-side because renderMarkdown depends on marked +
+// sanitize-html which are Node-targeted. The HTML is added as a `messageHtml`
+// field alongside the original `message` so callers that read the source
+// (eg. agent prompt building) are unaffected.
+export function serializeCommentsForClient(comments: Comment[]): unknown[] {
+  return comments.map((c) => ({
+    ...c,
+    thread: c.thread.map((e) => ({
+      ...e,
+      messageHtml: renderMessageMarkdown(e.message),
+    })),
+  }));
+}
+
 // Bundle the client JS once per server lifetime. The build is ~50-100ms — felt
 // only at server startup, not on page loads (the bundle is cached in memory)
 // and not when the source file is re-read. See M10 for the on-disk cache idea.
@@ -113,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;
@@ -178,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);
     }
   }
 
@@ -239,7 +275,7 @@ export function createServer(
     const agentRepliedAt = latestRound?.agent_replied_at ?? null;
     const roundNumber = latestRound?.round ?? 1;
     const totalRounds = sidecar.rounds.length;
-    return c.html(pageTemplate(fileName, html, comments, roundResolved, agentRepliedAt, roundNumber, totalRounds, sidecar.context, false, csrfToken, opts.noAgent ?? false));
+    return c.html(pageTemplate(fileName, html, serializeCommentsForClient(comments), roundResolved, agentRepliedAt, roundNumber, totalRounds, sidecar.context, false, csrfToken, opts.noAgent ?? false));
   });
 
   // Add a comment to the active round
@@ -408,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");
@@ -424,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";
@@ -437,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 };
@@ -482,7 +533,7 @@ export function createServer(
     const sidecar = await loadSidecar(filePath);
     const latestRound = sidecar.rounds[sidecar.rounds.length - 1] ?? null;
     return c.json({
-      comments: latestRound?.comments ?? [],
+      comments: serializeCommentsForClient(latestRound?.comments ?? []),
       roundResolved: latestRound?.resolved_at != null,
       totalRounds: sidecar.rounds.length,
     });
@@ -529,7 +580,7 @@ export function createServer(
     return c.html(pageTemplate(
       fileName,
       html,
-      roundData.comments,
+      serializeCommentsForClient(roundData.comments),
       true,   // treat as resolved (read-only)
       roundData.agent_replied_at ?? null,
       n,

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: