lavish-axi 0.1.74 → 0.1.76

package/README.md

@@ -181,6 +181,10 @@ pnpm link
   `Resolved` requires a newer successful artifact load plus a complete check at the same viewport that no longer detects it; it then leaves the count but keeps a bounded history.
   `Still present` (recurring) means a queued issue survived a newer revision, so it is selectable again with its earlier attempt retained. `Unverified` means a reload or check failed or was incomplete, so the prior issue was preserved rather than cleared. `Returned` means a resolved issue came back on a later revision.
   Dismissal applies only to the current artifact revision; a later revision surfaces the issue again if it is still detected. A check at one viewport never clears an issue found at another, and a viewport removed from the configured diagnostic set (`LAVISH_AXI_DIAGNOSTIC_VIEWPORTS`, default all) is marked obsolete with an explicit reason rather than reading as fixed.
+- **Revisions legend** - Opt-in. After a round of feedback the agent regenerates the whole file, and a one-sentence edit is invisible on a long artifact. The agent can declare what it changed in the artifact itself: one `<script type="application/json" data-lavish-revisions>` array of `{ id, label, timestamp, summary }` entries, plus `data-lavish-revision="<id>"` on each block it edited or added. Run `lavish-axi design` for the snippet.
+  A **Revisions** button then appears in the top bar with a legend listing each round - colour swatch, label, time, and the agent's summary - and **Reveal** steps through that round's changed blocks, flashing them one at a time.
+  Each revision's swatch carries a distinct border style and fill pattern as well as a colour, so the rounds stay distinguishable without colour. Artifacts with no registry show no button and are otherwise unaffected, a malformed registry is ignored rather than surfaced as an error, and at most 6 revisions are listed - one per distinguishable swatch.
+  Lavish never marks up the artifact for this: the legend lives in the browser chrome, so the served page stays identical to the saved file, and the registry and marks travel with the file through export.
 - **Local assets** - Copy local images, CSS, fonts, and scripts next to the HTML artifact and reference them with relative paths from that directory; root-prefixed paths such as `/assets/logo.png` will not resolve through Lavish's artifact route.
 - **Export and sharing** - `lavish-axi export` writes `<name>.export.html` by inlining local assets only, stripping the annotation SDK, and leaving remote CDN/font references as links that still need network access.
   `lavish-axi share` publishes the same local-inlined HTML to [ht-ml.app](https://ht-ml.app), a third-party hosting service not part of Lavish.
@@ -205,7 +209,7 @@ pnpm link
 - **Keyboard shortcuts** - In the chrome composer, Enter sends queued prompts and Shift+Enter inserts a newline.
   In the annotation card, Enter queues the annotation, Shift+Enter inserts a newline, and Ctrl+Enter (Cmd+Enter on macOS) queues it and sends all queued prompts immediately. Escape closes the card, same as Cancel, but only while it is empty (no text, no attachment); with unsent text or an attachment present, Escape does nothing rather than risk discarding it.
   Cmd+I or Ctrl+I toggles between annotate and explore mode from either the browser chrome or the artifact iframe, including while focus is in a textarea or control.
-- **Agent presence** - The browser shows when no agent is listening, keeps queued feedback for the next successful `lavish-axi poll` send even across reloads, and keeps human feedback actions available while the agent is working because the server queues them for the next poll. An agent reply concludes delivered work and returns presence to waiting.
+- **Agent presence** - The browser shows when no agent is listening, keeps queued feedback for the next successful `lavish-axi poll` send even across reloads, and keeps human feedback actions available while the agent is working because the server queues them for the next poll. An agent reply concludes delivered work and returns presence to waiting. A supervisor-owned process listener is shown as an external listener rather than an idle captain turn.
   In a Herdr-managed pane, set `LAVISH_AXI_HERDR_CHIME=1` to show a Herdr request notification and play its chime once an indefinite poll enters the waiting state. Immediate queued feedback and timed debug polls do not trigger a notification. The integration is off unless both `LAVISH_AXI_HERDR_CHIME` and Herdr's `HERDR_ENV` session marker equal `1`; leaving either unset or using any other value opts out. Notification delivery runs without blocking feedback: if Herdr is unavailable, rejects the notification, stalls, or fails, the poll continues unchanged.
   Closing the last review tab while a poll is active starts a 10-second reconnect grace period. A reload or quick reconnect keeps an active poll waiting; if every review stays disconnected, the poll returns `browser_disconnected` without ending the resumable session, and the agent asks whether to reopen or end it instead of acting uninvited.
   The no-timeout poll always writes an immediate stderr banner so it is visibly not hung; it adds the periodic stderr wait ticks only in an interactive terminal, so when stderr is piped (as under agent harnesses) the captured output carries no tick noise. Stdout always stays reserved for the final response; if the poll is interrupted or times out before feedback arrives, re-run it because feedback remains queued until delivery. Poll delivery consumes the response, so read the complete response before truncating or filtering it.
@@ -286,6 +290,8 @@ For flows, architecture, state, or sequence diagrams, open the diagram playbook
 | `lavish-axi share`       | `--update-key <key>`        | The secret returned when the page was published; required to republish or unpublish it.                                                                                                                                                                                                                                       |
 | `lavish-axi share`       | `--unpublish`               | Replace a published page with a locked placeholder (ht-ml.app cannot delete); takes `--site` and `--update-key` and no file.                                                                                                                                                                                                  |
 | `lavish-axi share`       | `--token <t>`               | Attach an optional bearer token (`LAVISH_AXI_HTML_APP_TOKEN`) when creating a page; never required, and rejected on a republish or `--unpublish`, where the `update_key` is the credential.                                                                                                                                   |
+| `lavish-axi poll`        | `--owner <label>`           | Identify the process listening for this session; the non-empty label appears in the home session listing. `none` is reserved for sessions without a listener. A second concurrent poll is refused instead of silently returning `waiting`.                                                                                    |
+| `lavish-axi poll`        | `--takeover`                | Explicitly displace the current poll listener. The displaced poll exits with typed `LISTENER_REPLACED`; without this flag, the new poll fails with typed `LISTENER_ACTIVE`.                                                                                                                                                   |
 | `lavish-axi poll`        | `--agent-reply "..."`       | Show a concise agent reply in the existing browser chat, conclude delivered work, and return presence to waiting before polling again. Keep replies concise by default.                                                                                                                                                       |
 | `lavish-axi poll`        | `--agent-reply-file <path>` | When a longer reply is genuinely necessary, read Markdown from a file (`-` for stdin) so newlines survive quoting. Use blank-line paragraphs, `- ` / `1. ` lists, and `## ` headings so the Conversation panel renders it scannably. The Markdown subset is under Feedback controls. Cannot be combined with `--agent-reply`. |
 | `lavish-axi poll`        | `--timeout-ms <ms>`         | Test/debug escape hatch only; agents should normally omit it and leave the long poll running.                                                                                                                                                                                                                                 |

package/dist/chrome-client.js

@@ -178,6 +178,12 @@ const warningsSelectAll = /** @type {HTMLInputElement} */ (document.getElementBy
 const warningsSelected = /** @type {HTMLSpanElement} */ (document.getElementById("warningsSelected"));
 const warningsList = /** @type {HTMLDivElement} */ (document.getElementById("warningsList"));
 const warningsQueueButton = /** @type {HTMLButtonElement} */ (document.getElementById("warningsQueueButton"));
+const revisionsWrap = /** @type {HTMLDivElement} */ (document.getElementById("revisionsWrap"));
+const revisionsButton = /** @type {HTMLButtonElement} */ (document.getElementById("revisionsButton"));
+const revisionsCount = /** @type {HTMLSpanElement} */ (document.getElementById("revisionsCount"));
+const revisionsDrawer = /** @type {HTMLDivElement} */ (document.getElementById("revisionsDrawer"));
+const revisionsSummary = /** @type {HTMLParagraphElement} */ (document.getElementById("revisionsSummary"));
+const revisionsList = /** @type {HTMLDivElement} */ (document.getElementById("revisionsList"));
 const sendHint = /** @type {HTMLDivElement} */ (document.getElementById("sendHint"));
 const whiteboardOverlay = /** @type {HTMLDivElement} */ (document.getElementById("whiteboardOverlay"));
 const whiteboardFrame = /** @type {HTMLIFrameElement} */ (document.getElementById("whiteboardFrame"));
@@ -988,12 +994,14 @@ function syncChat(chat, revision) {
 }
 
 function setAgentPresence(state) {
-  agentPresence = state === "listening" || state === "working" ? state : "waiting";
+  agentPresence = state === "listening" || state === "external" || state === "working" ? state : "waiting";
   updateSendState();
   renderSheetSummary();
   if (presenceBanner) presenceBanner.hidden = ended || agentPresence !== "waiting";
 
-  if (agentPresence !== "working") {
+  // A supervisor-owned process-only listener is busy on the agent's behalf. It must not make the
+  // composer look like an idle captain turn while the owning agent is offline.
+  if (agentPresence !== "working" && agentPresence !== "external") {
     if (workingBubble) workingBubble.remove();
     workingBubble = null;
     return;
@@ -1209,6 +1217,7 @@ function sheetSummary() {
   }
   if (unreadAgentReply) return { text: unreadAgentReply, accent: false, unread: true };
   if (agentPresence === "working") return { text: "Agent is working…", accent: false, unread: false };
+  if (agentPresence === "external") return { text: "External listener active", accent: false, unread: false };
   if (agentPresence === "listening") return { text: "Agent listening", accent: false, unread: false };
   return { text: "Agent not listening", accent: false, unread: false };
 }
@@ -2428,6 +2437,265 @@ function revealWarning(warning) {
   postToFrame({ type: "lavish:revealElement", selector: warning.selector });
 }
 
+// ---------------------------------------------------------------------------
+// Revision legend
+//
+// The agent declares what it changed in the artifact HTML itself (a
+// `data-lavish-revisions` registry plus `data-lavish-revision` marks); the SDK
+// reads it and posts it here. The legend lives entirely in the chrome, so the
+// served artifact still matches the file on disk - Lavish never paints the
+// change indicator into the page. Reveal borrows the same transient marker the
+// layout-issues drawer uses, and only when the reader asks for it.
+
+// The payload crosses postMessage from a sandboxed frame rendering author
+// content, so it is untrusted here whatever built it. These bound what is
+// examined, not what is accepted: capping accepted rows alone would let a
+// registry of ten thousand records walk the whole array on the chrome's main
+// thread before yielding its handful of rows.
+// Server-owned, injected into the session JSON from src/artifact-revisions.js.
+// The swatch is presentation the chrome owes the reader, not something the
+// artifact gets a say in, so nothing about it is read from the message.
+const REVISION_PALETTE = (Array.isArray(sessionData.revisionPalette) ? sessionData.revisionPalette : []).filter(
+  (entry) => entry && /^#[0-9a-fA-F]{6}$/.test(String(entry.hex)),
+);
+const REVISION_LIMITS = {
+  // Derived from the server-injected palette (src/artifact-revisions.js) rather than a
+  // second hardcoded number, so the two can never drift; falls back to 6 only if the
+  // palette itself came through empty.
+  entries: REVISION_PALETTE.length > 0 ? REVISION_PALETTE.length : 6,
+  rawEntries: 256,
+  marks: 200,
+  rawMarks: 2000,
+  id: 60,
+  label: 80,
+  summary: 400,
+  timestamp: 40,
+  excerpt: 120,
+  selector: 400,
+};
+const REVISION_BORDER_STYLES = ["solid", "dashed", "dotted", "double"];
+
+/** @type {any[]} */
+let revisionEntries = [];
+/** @type {any[]} */
+let revisionMarks = [];
+/** @type {Map<string, number>} */
+const revisionRevealCursor = new Map();
+let revisionsDrawerOpen = false;
+
+// Display-only fields. Anything the legend merely shows can be shortened.
+function revisionText(value, max) {
+  if (typeof value !== "string" && typeof value !== "number") return "";
+  const text = String(value).trim();
+  return text.length > max ? text.slice(0, max) : text;
+}
+
+// Identity fields, mirroring `exactRevisionText` in src/artifact-revisions.js.
+// The message is untrusted here, so shortening an id or a selector is worse
+// than dropping it: two distinct overlong ids collapse into one legend row, and
+// the first 400 characters of a long selector are a different valid selector
+// that Reveal would resolve to some other block.
+function revisionExact(value, max) {
+  if (typeof value !== "string" && typeof value !== "number") return "";
+  const text = String(value).trim();
+  return text.length > 0 && text.length <= max ? text : "";
+}
+
+function revisionPatternFill(pattern) {
+  if (pattern === "diagonal") return "repeating-linear-gradient(45deg, currentColor 0 2px, transparent 2px 5px)";
+  if (pattern === "dots") return "radial-gradient(currentColor 1px, transparent 1px)";
+  return "";
+}
+
+// The swatch for a revision's position in the registry. Position is the only
+// thing the artifact influences, and it cannot repeat one: ids are deduplicated
+// before this runs, so each accepted revision gets a distinct index and
+// therefore a distinct swatch.
+function revisionPresentation(index) {
+  const entry = REVISION_PALETTE.length > 0 ? REVISION_PALETTE[index % REVISION_PALETTE.length] : null;
+  return {
+    color: entry ? String(entry.hex) : "#0072b2",
+    borderStyle: REVISION_BORDER_STYLES.includes(String(entry && entry.borderStyle))
+      ? String(entry.borderStyle)
+      : "solid",
+    pattern: revisionPatternFill(entry && entry.pattern),
+  };
+}
+
+// Only text crosses from the artifact into the legend, and it crosses as
+// textContent. Nothing the message carries reaches a style property.
+function normalizeRevisionMessage(msg) {
+  const rawRevisions = Array.isArray(msg && msg.revisions) ? msg.revisions : [];
+  const revisions = [];
+  const byId = new Map();
+  let examined = 0;
+  for (const raw of rawRevisions) {
+    if (examined >= REVISION_LIMITS.rawEntries || revisions.length >= REVISION_LIMITS.entries) break;
+    examined += 1;
+    if (!raw || typeof raw !== "object") continue;
+    const id = revisionExact(raw.id, REVISION_LIMITS.id);
+    if (!id || /\s/.test(id) || byId.has(id)) continue;
+    const entry = {
+      id,
+      label: revisionText(raw.label, REVISION_LIMITS.label) || id,
+      timestamp: revisionText(raw.timestamp, REVISION_LIMITS.timestamp),
+      summary: revisionText(raw.summary, REVISION_LIMITS.summary),
+      ...revisionPresentation(revisions.length),
+      marks: [],
+    };
+    byId.set(id, entry);
+    revisions.push(entry);
+  }
+
+  const rawMarks = Array.isArray(msg && msg.marks) ? msg.marks : [];
+  const marks = [];
+  examined = 0;
+  for (const raw of rawMarks) {
+    if (examined >= REVISION_LIMITS.rawMarks || marks.length >= REVISION_LIMITS.marks) break;
+    examined += 1;
+    if (!raw || typeof raw !== "object") continue;
+    const revisionId = revisionExact(raw.revision_id, REVISION_LIMITS.id);
+    const selector = revisionExact(raw.selector, REVISION_LIMITS.selector);
+    const owner = byId.get(revisionId);
+    if (!owner || !selector) continue;
+    const mark = {
+      revisionId,
+      selector,
+      tag: revisionText(raw.tag, 40).toLowerCase(),
+      excerpt: revisionText(raw.excerpt, REVISION_LIMITS.excerpt),
+    };
+    owner.marks.push(mark);
+    marks.push(mark);
+  }
+
+  return { revisions, marks };
+}
+
+function resetRevisionLegend() {
+  revisionEntries = [];
+  revisionMarks = [];
+  revisionRevealCursor.clear();
+  renderRevisionLegend();
+}
+
+function applyRevisionMessage(msg) {
+  const normalized = normalizeRevisionMessage(msg);
+  revisionEntries = normalized.revisions;
+  revisionMarks = normalized.marks;
+  for (const id of [...revisionRevealCursor.keys()]) {
+    if (!revisionEntries.some((entry) => entry.id === id)) revisionRevealCursor.delete(id);
+  }
+  renderRevisionLegend();
+}
+
+function revisionMarkSummary(entry) {
+  if (entry.marks.length === 0) return "no marked blocks";
+  return entry.marks.length === 1 ? "1 marked block" : entry.marks.length + " marked blocks";
+}
+
+function buildRevisionRow(entry) {
+  const row = document.createElement("div");
+  row.className = "revision-row";
+
+  const swatch = document.createElement("span");
+  swatch.className = "revision-swatch";
+  swatch.setAttribute("aria-hidden", "true");
+  swatch.style.color = entry.color;
+  swatch.style.borderColor = entry.color;
+  swatch.style.borderStyle = entry.borderStyle;
+  if (entry.pattern) swatch.style.backgroundImage = entry.pattern;
+  row.appendChild(swatch);
+
+  const body = document.createElement("div");
+  body.className = "revision-body";
+
+  const head = document.createElement("div");
+  head.className = "revision-head";
+  const label = document.createElement("span");
+  label.className = "revision-label";
+  label.textContent = entry.label;
+  head.appendChild(label);
+  if (entry.timestamp) {
+    const time = document.createElement("span");
+    time.className = "revision-time";
+    time.textContent = entry.timestamp;
+    head.appendChild(time);
+  }
+  body.appendChild(head);
+
+  if (entry.summary) {
+    const summary = document.createElement("p");
+    summary.className = "revision-summary";
+    summary.textContent = entry.summary;
+    body.appendChild(summary);
+  }
+
+  const foot = document.createElement("div");
+  foot.className = "revision-foot";
+  const count = document.createElement("span");
+  count.className = "revision-marks";
+  count.textContent = revisionMarkSummary(entry);
+  foot.appendChild(count);
+  if (entry.marks.length > 0) {
+    const reveal = document.createElement("button");
+    reveal.type = "button";
+    reveal.className = "revision-reveal";
+    const position = (revisionRevealCursor.get(entry.id) || 0) % entry.marks.length;
+    reveal.textContent = entry.marks.length === 1 ? "Reveal" : "Reveal " + (position + 1) + "/" + entry.marks.length;
+    reveal.setAttribute("aria-label", "Reveal the next block changed in " + entry.label);
+    // Bound per row rather than delegated from the list: the rows are rebuilt
+    // on every render anyway, so there is no listener to accumulate, and the
+    // button carries the revision it belongs to without a data attribute round
+    // trip through the DOM.
+    reveal.onclick = () => revealNextRevisionMark(entry.id);
+    foot.appendChild(reveal);
+  }
+  body.appendChild(foot);
+
+  row.appendChild(body);
+  return row;
+}
+
+function renderRevisionLegend() {
+  if (!revisionsWrap) return;
+  const count = revisionEntries.length;
+  revisionsWrap.hidden = count === 0 || ended;
+  if (revisionsWrap.hidden && revisionsDrawerOpen) setRevisionsDrawerOpen(false);
+  revisionsCount.textContent = String(count);
+  revisionsButton.setAttribute("aria-label", count === 1 ? "1 revision" : count + " revisions");
+  revisionsSummary.textContent =
+    (count === 1 ? "1 revision" : count + " revisions") +
+    " · " +
+    (revisionMarks.length === 1 ? "1 marked block" : revisionMarks.length + " marked blocks");
+
+  revisionsList.replaceChildren(...revisionEntries.map(buildRevisionRow));
+}
+
+function setRevisionsDrawerOpen(open) {
+  revisionsDrawerOpen = open && !ended;
+  revisionsDrawer.hidden = !revisionsDrawerOpen;
+  revisionsButton.setAttribute("aria-expanded", String(revisionsDrawerOpen));
+  if (revisionsDrawerOpen) closeMenus();
+}
+
+function closeRevisionsDrawer({ restoreFocus = false } = {}) {
+  if (!revisionsDrawerOpen) return;
+  setRevisionsDrawerOpen(false);
+  if (restoreFocus) revisionsButton.focus();
+}
+
+// Step through a revision's marked blocks one at a time. The existing reveal
+// path flashes one element and clears the previous marker, so a revision that
+// touched several blocks is walked rather than lit up all at once.
+function revealNextRevisionMark(id) {
+  const entry = revisionEntries.find((candidate) => candidate.id === id);
+  if (!entry || entry.marks.length === 0) return;
+  const position = (revisionRevealCursor.get(id) || 0) % entry.marks.length;
+  postToFrame({ type: "lavish:revealElement", selector: entry.marks[position].selector });
+  revisionRevealCursor.set(id, (position + 1) % entry.marks.length);
+  renderRevisionLegend();
+}
+
 async function dismissWarning(id) {
   try {
     const response = await fetch("/api/" + key + "/layout-warnings/dismiss", {
@@ -2527,6 +2795,8 @@ function markSessionEnded() {
   closeShareDialog();
   closeWarningsDrawer();
   renderWarnings();
+  closeRevisionsDrawer();
+  renderRevisionLegend();
   closeWhiteboard();
   annotationSwitch.disabled = true;
   moreButton.disabled = true;
@@ -2834,6 +3104,11 @@ async function replaceArtifactFrame({ recoveryRetry = false } = {}) {
   clearTimeout(artifactSilenceTimer);
   // The iframe is sandboxed, so reload by resetting the iframe URL from chrome.
   if (!artifactSrc) {
+    // The next document reports its own registry once it loads; until then the
+    // previous revision's legend would point at blocks that may no longer exist.
+    // Only clear it here, right before the frame is actually replaced - a preserved
+    // load (superseded/out-of-order/exhausted retries below) must leave it intact.
+    resetRevisionLegend();
     startLayoutGateCycle();
     const currentSrc = frame.src || "about:blank";
     frame.src = currentSrc + (currentSrc.includes("?") ? "&" : "?") + "lavish_reload=" + Date.now();
@@ -2950,6 +3225,9 @@ async function replaceArtifactFrame({ recoveryRetry = false } = {}) {
   inlineWhiteboardChannels.clear();
   setHandoffSuperseded(false);
   startLayoutGateCycle();
+  // The next document reports its own registry once it loads; until then the
+  // previous revision's legend would point at blocks that may no longer exist.
+  resetRevisionLegend();
   frame.src = artifactFrameSrcForLoad({ revision, token });
   return true;
 }
@@ -3685,6 +3963,7 @@ window.addEventListener("message", (event) => {
   // chrome cannot see every live reference, so reclamation is the sweeper's job.
   if (msg.type === "lavish:sendQueuedPrompts") sendQueued();
   if (msg.type === "lavish:endSession") endSession();
+  if (msg.type === "lavish:revisions") applyRevisionMessage(msg);
   if (msg.type === "lavish:toggleAnnotationMode") toggleAnnotationMode();
 });
 
@@ -3828,9 +4107,14 @@ sendButton.onclick = () => sendQueued(false);
 sendAndEndButton.onclick = () => sendQueued(true);
 moreButton.onclick = () => {
   closeWarningsDrawer();
+  closeRevisionsDrawer();
   toggleMenu(moreButton, moreMenu);
 };
 warningsButton.onclick = toggleWarningsDrawer;
+revisionsButton.onclick = () => {
+  closeWarningsDrawer();
+  setRevisionsDrawerOpen(revisionsDrawer.hidden);
+};
 warningsSelectAll.onchange = toggleSelectAllWarnings;
 warningsQueueButton.onclick = queueSelectedWarningFixes;
 chatAttachButton.onclick = () => chatAttachInput.click();
@@ -3960,6 +4244,7 @@ document.addEventListener("mousedown", (event) => {
   const target = /** @type {Node} */ (event.target);
   if (!moreMenu.hidden && !moreWrap.contains(target)) setMenuOpen(moreButton, moreMenu, false);
   if (warningsDrawerOpen && !warningsWrap.contains(target)) closeWarningsDrawer();
+  if (revisionsDrawerOpen && !revisionsWrap.contains(target)) closeRevisionsDrawer();
 });
 // A non-modal popover closes when focus leaves it, so keyboard users are never stranded inside a
 // panel they cannot see the end of.
@@ -3967,6 +4252,10 @@ warningsWrap.addEventListener("focusout", (event) => {
   const next = /** @type {Node | null} */ (event.relatedTarget);
   if (warningsDrawerOpen && next && !warningsWrap.contains(next)) closeWarningsDrawer();
 });
+revisionsWrap.addEventListener("focusout", (event) => {
+  const next = /** @type {Node | null} */ (event.relatedTarget);
+  if (revisionsDrawerOpen && next && !revisionsWrap.contains(next)) closeRevisionsDrawer();
+});
 whiteboardCloseButton.onclick = closeWhiteboard;
 document.addEventListener("keydown", (event) => {
   if (event.key === "Escape") {
@@ -3974,6 +4263,8 @@ document.addEventListener("keydown", (event) => {
       closeWhiteboard();
     } else if (!shareDialog.hidden) {
       closeShareDialog();
+    } else if (revisionsDrawerOpen) {
+      closeRevisionsDrawer({ restoreFocus: true });
     } else if (warningsDrawerOpen) {
       closeWarningsDrawer({ restoreFocus: true });
     } else if (!moreMenu.hidden) {
@@ -4075,7 +4366,7 @@ events.set("chat-sync", (data) => {
   rememberChatAckIds(data.ack_ids);
   syncChat(data.chat || [], data.chat_revision);
 });
-events.set("agent-presence", (data) => setAgentPresence(data.state));
+events.set("agent-presence", (data) => setAgentPresence(data.mode === "external-listener" ? "external" : data.state));
 events.set("layout-warnings", (data) => setLayoutWarnings(data.warnings || []));
 events.set("ended", () => markSessionEnded());
 connectLiveEvents();

package/dist/chrome.css

@@ -635,6 +635,158 @@ body.lavish {
   opacity: 0.8;
   flex-shrink: 0;
 }
+.revisions-wrap {
+  position: relative;
+  display: flex;
+  align-items: center;
+}
+.revisions-wrap[hidden] {
+  display: none;
+}
+
+.revisions-button {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  height: 34px;
+  padding: 0 10px;
+  border-radius: var(--radius-md);
+  border: 1px solid var(--border);
+  background: var(--bg-panel);
+  color: var(--fg);
+  font: 600 12px/1 var(--font-sans);
+  cursor: pointer;
+}
+
+.revisions-button:hover {
+  background: var(--bg-elevated);
+}
+
+.revisions-count {
+  min-width: 18px;
+  padding: 0 5px;
+  border-radius: 9px;
+  background: var(--accent);
+  color: var(--brass-ink);
+  font: 700 11px/18px var(--font-sans);
+  text-align: center;
+}
+
+.revisions-drawer {
+  right: 0;
+  top: 42px;
+  width: min(360px, calc(100vw - 24px));
+  padding: 0;
+}
+
+.revisions-head {
+  padding: 12px 14px 8px;
+}
+
+.revisions-title {
+  margin: 0;
+  font-size: 13px;
+  font-weight: 700;
+}
+
+.revisions-summary {
+  margin: 4px 0 0;
+  font-size: 11px;
+  color: var(--fg-faint);
+}
+
+.revisions-list {
+  max-height: 320px;
+  overflow-y: auto;
+  padding: 0 14px;
+}
+
+.revision-row {
+  display: flex;
+  gap: 10px;
+  padding: 10px 0;
+  border-top: 1px solid var(--border);
+}
+
+/* Colour is never the only signal: the swatch also carries the revision's
+   border style and fill pattern, so the legend still separates revisions in
+   greyscale or with a colour vision deficiency. */
+.revision-swatch {
+  flex: 0 0 auto;
+  width: 16px;
+  height: 16px;
+  margin-top: 2px;
+  border-width: 2px;
+  border-radius: 4px;
+}
+
+.revision-body {
+  min-width: 0;
+  flex: 1 1 auto;
+}
+
+.revision-head {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+}
+
+.revision-label {
+  font-size: 12px;
+  font-weight: 700;
+}
+
+.revision-time {
+  font-size: 11px;
+  color: var(--fg-faint);
+}
+
+.revision-summary {
+  margin: 4px 0 0;
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--fg-faint);
+}
+
+.revision-foot {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  margin-top: 6px;
+}
+
+.revision-marks {
+  font-size: 11px;
+  color: var(--fg-faint);
+}
+
+.revision-reveal {
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  background: var(--bg-elevated);
+  color: var(--fg);
+  padding: 4px 8px;
+  font: 700 11px/1 var(--font-sans);
+  cursor: pointer;
+}
+
+.revision-reveal:hover {
+  background: var(--steel-700);
+}
+
+.revisions-foot {
+  padding: 10px 14px 12px;
+  border-top: 1px solid var(--border);
+}
+
+.revisions-note {
+  margin: 0;
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--fg-faint);
+}
+
 .menu-item.danger {
   color: var(--danger);
 }