lavish-axi 0.1.69 → 0.1.71

package/README.md

@@ -197,7 +197,7 @@ pnpm link
 - **Feedback controls** - Native controls (radios, checkboxes, inputs, selects, buttons, labels, disclosure summaries, contenteditable) are interactive automatically, so they do not need `data-lavish-action`.
   For reversible choices, let option clicks update local state, then queue exactly one final answer from a per-question submit or Queue answer button with `window.lavish.queuePrompt()`.
   Mark only custom (non-native) clickable elements with `data-lavish-action` so Lavish does not annotate them, and use `data-lavish-question` or `queueKey` when pre-send updates for the same question should replace each other.
-  Everything you send is part of the conversation: a note on an element, a text selection, a table cell, a diagram node, a whiteboard, a layout-issue batch, or a composer message each becomes a bubble on your side of the Conversation panel, with an anchor line naming what it was attached to (the element tag, text selection, table cell, diagram node, whiteboard, or layout issues), a quoted excerpt, and, when available, the selector on hover. A note you have queued but not sent sits at the end of the conversation as a dashed bubble labelled **Queued** with a remove control; while its batch is in flight it reads **Sending**, and once the server accepts it, it settles in place as a sent bubble that stays in the history, in every tab of the session. Agent replies render a small Markdown subset - paragraphs, line breaks, headings as bold lead lines, bullet and numbered lists, fenced and inline code, bold, italic, and http(s) links - while tables, images, and raw HTML stay as the text the agent wrote; your own messages keep their line breaks and are never parsed.
+  Everything you send is part of the conversation: a note on an element, a text selection, a table cell, a diagram node, a whiteboard, a layout-issue batch, or a composer message each becomes a bubble on your side of the Conversation panel, with an anchor line naming what it was attached to (the element tag, text selection, table cell, diagram node, whiteboard, or layout issues), a quoted excerpt, and, when available, the selector on hover. A note you have queued but not sent sits at the end of the conversation as a dashed bubble labelled **Queued** with a remove control; while its batch is in flight it reads **Sending**, and once the server accepts it, it settles in place as a sent bubble in every tab of the session. The panel keeps the newest stored transcript up to 5 MiB; older bubbles drop from view, but an accepted note still settles and is not sent twice. Agent replies render a small Markdown subset - paragraphs, line breaks, headings as bold lead lines, bullet and numbered lists, fenced and inline code, bold, italic, and http(s) links - while tables, images, and raw HTML stay as the text the agent wrote; your own messages keep their line breaks and are never parsed.
   On wider screens, the conversation and the queued notes share one scrollable Conversation panel above a sticky composer, so long feedback queues do not push the text box or send controls off screen.
   The browser chrome keeps editing actions in the overflow menu (copy path, reload artifact, copy DOM snapshot, export standalone HTML, publish link, end session), while the composer exposes **Send & End** beside **Send to Agent** to submit queued prompts and user-ended attribution together. Once **Send & End** starts, Lavish pauses new feedback, waits up to 5 seconds for feedback preparation already underway, keeps any open annotation draft intact until delivery succeeds, then holds that exact terminal batch. A completed reservation survives a page reload, including when its prompts were already delivered and only the pending end remains; incomplete preparation is not restored. If preparation times out, Lavish keeps the review open and its existing queue editable with a visible error. A transient delivery failure permits only retrying the same terminal batch through **Send & End** until it succeeds. If a snapshot makes the request too large (HTTP 413), Lavish retries that exact batch once without the optional snapshot. An actionable attachment rejection (HTTP 400), recoverable layout-selection conflict (HTTP 409), or unrecoverable 413 instead cancels the terminal reservation without ending the session, keeps the prompts queued, and restores editing, removal, **Send to Agent**, **Send & End**, and **End session** so the reviewer can revise or remove stale feedback before submitting again.
   Composer feedback is visibly queued before the text box clears and stays queued until acknowledged. Send waits up to 5 seconds for the artifact's DOM snapshot, then delivers without that optional context if the frame no longer answers; a late snapshot cannot submit the batch twice. A failed or still-unacknowledged POST keeps the queue and shows persistent recovery guidance unless a transcript sync proves the server already accepted that feedback.
@@ -205,7 +205,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. The agent's reply (`--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.
   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.
   Codex-specific guidance keeps that poll attached to the active turn instead of hiding it in a background task, because completed background tasks may not resume the agent.
@@ -272,23 +272,24 @@ For flows, architecture, state, or sequence diagrams, open the diagram playbook
 
 ### Flags
 
-| Command                  | Flag                  | Description                                                                                                                                                                                                                         |
-| ------------------------ | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `lavish-axi <html-file>` | `--no-open`           | Ensure the server/session exists without opening another browser window.                                                                                                                                                            |
-| `lavish-axi <html-file>` | `--no-gate`           | Skip the open-time layout curtain for this browser open.                                                                                                                                                                            |
-| `lavish-axi <html-file>` | `--reopen`            | Reopen a session the user explicitly ended from the browser; without it, a plain open refuses and explains why instead of reopening uninvited.                                                                                      |
-| `lavish-axi update`      | `--check`             | Report current vs latest npm version without installing an update.                                                                                                                                                                  |
-| `lavish-axi export`      | `--out <path>`        | Write the export to a specific path instead of `<name>.export.html` next to the source.                                                                                                                                             |
-| `lavish-axi share`       | `--private`           | Make the page private behind a password Lavish generates and returns once; hand it to viewers as a shared secret.                                                                                                                   |
-| `lavish-axi share`       | `--password <pw>`     | Make the third-party ht-ml.app page private with a password you supply; viewers must supply the password. An empty or whitespace-only value (an unquoted `$PW` that is unset) is refused rather than publishing a public page.      |
-| `lavish-axi share`       | `--site <site_id>`    | Republish an existing page in place (with `--update-key`) instead of creating a new one; the URL does not change.                                                                                                                   |
-| `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`        | `--agent-reply "..."` | Show the agent's reply in the existing browser chat, conclude delivered work, and return presence to waiting before polling again.                                                                                                  |
-| `lavish-axi poll`        | `--timeout-ms <ms>`   | Test/debug escape hatch only; agents should normally omit it and leave the long poll running.                                                                                                                                       |
-| `lavish-axi stop`        | `--port <port>`       | Shut down a server running on a non-default port.                                                                                                                                                                                   |
-| `lavish-axi server`      | `--verbose`           | Log session and watcher events to stderr; can also be enabled with `LAVISH_AXI_DEBUG=1`. Detached server output is appended to `~/.lavish-axi/server.log` (or `LAVISH_AXI_STATE_DIR/server.log`) for startup and crash diagnostics. |
+| Command                  | Flag                        | Description                                                                                                                                                                                                                                                                                                                   |
+| ------------------------ | --------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `lavish-axi <html-file>` | `--no-open`                 | Ensure the server/session exists without opening another browser window.                                                                                                                                                                                                                                                      |
+| `lavish-axi <html-file>` | `--no-gate`                 | Skip the open-time layout curtain for this browser open.                                                                                                                                                                                                                                                                      |
+| `lavish-axi <html-file>` | `--reopen`                  | Reopen a session the user explicitly ended from the browser; without it, a plain open refuses and explains why instead of reopening uninvited.                                                                                                                                                                                |
+| `lavish-axi update`      | `--check`                   | Report current vs latest npm version without installing an update.                                                                                                                                                                                                                                                            |
+| `lavish-axi export`      | `--out <path>`              | Write the export to a specific path instead of `<name>.export.html` next to the source.                                                                                                                                                                                                                                       |
+| `lavish-axi share`       | `--private`                 | Make the page private behind a password Lavish generates and returns once; hand it to viewers as a shared secret.                                                                                                                                                                                                             |
+| `lavish-axi share`       | `--password <pw>`           | Make the third-party ht-ml.app page private with a password you supply; viewers must supply the password. An empty or whitespace-only value (an unquoted `$PW` that is unset) is refused rather than publishing a public page.                                                                                                |
+| `lavish-axi share`       | `--site <site_id>`          | Republish an existing page in place (with `--update-key`) instead of creating a new one; the URL does not change.                                                                                                                                                                                                             |
+| `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`        | `--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.                                                                                                                                                                                                                                 |
+| `lavish-axi stop`        | `--port <port>`             | Shut down a server running on a non-default port.                                                                                                                                                                                                                                                                             |
+| `lavish-axi server`      | `--verbose`                 | Log session and watcher events to stderr; can also be enabled with `LAVISH_AXI_DEBUG=1`. Detached server output is appended to `~/.lavish-axi/server.log` (or `LAVISH_AXI_STATE_DIR/server.log`) for startup and crash diagnostics.                                                                                           |
 
 ## Development
 

package/dist/chrome-client.js

@@ -23,6 +23,8 @@ const promptIdentityField = "prompt_id";
 const PROMPT_IDENTITY_MAX = 128;
 const PROMPT_IDENTITY_RE = /^[A-Za-z0-9_-]+$/;
 const initialChat = Array.isArray(sessionData.initialChat) ? sessionData.initialChat : [];
+const initialChatAckIds = Array.isArray(sessionData.initialChatAckIds) ? sessionData.initialChatAckIds : [];
+const initialChatRevision = parseChatRevision(sessionData.initialChatRevision) || 0;
 const MODE_TOGGLE_HOTKEY_KEY = String(sessionData.modeToggleHotkeyKey || "").toLowerCase();
 const attachmentMaxBytes = Number(sessionData.attachmentMaxBytes) || 0;
 const attachmentMaxCount = Number(sessionData.attachmentMaxCount) || 4;
@@ -222,6 +224,7 @@ let nextSnapshotRequestId = 0;
 let nextSendOperationOrder = 0;
 let workingBubble = null;
 let displayedChat = initialChat.slice();
+let chatRevision = initialChatRevision;
 // Settlement is by per-submission identity, not displayed content: two tabs can queue notes
 // whose chat projection is identical (same selected text under one container, different range
 // boundaries) without settling each other, and a reload after a lost POST response still
@@ -393,6 +396,15 @@ function promptIdentity(value) {
   return isPromptIdentity(value?.[promptIdentityField]) ? value[promptIdentityField] : "";
 }
 
+const chatAckIds = new Set();
+function rememberChatAckIds(ids) {
+  if (!Array.isArray(ids)) return;
+  for (const value of ids) {
+    if (isPromptIdentity(value)) chatAckIds.add(value);
+  }
+}
+rememberChatAckIds(initialChatAckIds);
+
 function createPromptIdentity() {
   if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
   return "p" + Date.now().toString(36) + Math.random().toString(36).slice(2, 12);
@@ -849,13 +861,26 @@ function chatEntriesMatch(left, right) {
   return !leftAt || !rightAt || leftAt === rightAt;
 }
 
+function parseChatRevision(value) {
+  const revision = Number(value);
+  return Number.isSafeInteger(revision) && revision >= 0 ? revision : null;
+}
+
 function chatContainsEntries(candidate, entries) {
-  if (candidate.length < entries.length) return false;
-  let matched = 0;
-  for (const entry of candidate) {
-    if (matched < entries.length && chatEntriesMatch(entry, entries[matched])) matched += 1;
+  if (!Array.isArray(candidate) || !Array.isArray(entries)) return false;
+  if (entries.length === 0) return true;
+  // A size-bound transcript may drop a prefix of what this tab already showed. The remaining
+  // displayed suffix must still appear in order; a stale sync that is missing a newer tail
+  // (including an empty wipe) is rejected.
+  for (let start = 0; start < entries.length; start += 1) {
+    const suffix = entries.slice(start);
+    let matched = 0;
+    for (const entry of candidate) {
+      if (matched < suffix.length && chatEntriesMatch(entry, suffix[matched])) matched += 1;
+    }
+    if (matched === suffix.length) return true;
   }
-  return matched === entries.length;
+  return false;
 }
 
 function chatStartsWith(candidate, prefix) {
@@ -868,10 +893,18 @@ function chatStartsWith(candidate, prefix) {
 }
 
 function mergeAcceptedChat(accepted, chatAtRequest) {
-  if (!chatStartsWith(accepted, chatAtRequest) || !chatStartsWith(displayedChat, chatAtRequest)) return null;
+  if (!Array.isArray(accepted) || !Array.isArray(chatAtRequest)) return null;
+  if (!chatStartsWith(displayedChat, chatAtRequest)) return null;
+  let requestOffset = chatAtRequest.length;
+  for (let i = 0; i <= chatAtRequest.length; i += 1) {
+    if (chatStartsWith(accepted, chatAtRequest.slice(i))) {
+      requestOffset = i;
+      break;
+    }
+  }
   const displayedTail = displayedChat.slice(chatAtRequest.length);
   const unmatchedDisplayed = [];
-  let acceptedIndex = chatAtRequest.length;
+  let acceptedIndex = chatAtRequest.length - requestOffset;
   for (const displayedEntry of displayedTail) {
     while (acceptedIndex < accepted.length && !chatEntriesMatch(accepted[acceptedIndex], displayedEntry)) {
       acceptedIndex += 1;
@@ -892,7 +925,9 @@ function queuedPromptMatchesEntry(prompt, entry) {
 
 function promptAcknowledgedInChat(prompt, chat) {
   const id = promptIdentity(prompt);
-  if (!id || !Array.isArray(chat)) return false;
+  if (!id) return false;
+  if (chatAckIds.has(id)) return true;
+  if (!Array.isArray(chat)) return false;
   return chat.some((entry) => queuedPromptMatchesEntry(prompt, entry));
 }
 
@@ -916,10 +951,15 @@ function settleQueuedFromTranscript(chat, shouldRender = true) {
   return true;
 }
 
-function syncChat(chat) {
+function syncChat(chat, revision) {
   const nextChat = Array.isArray(chat) ? chat : [];
   settleQueuedFromTranscript(nextChat);
-  if (!chatContainsEntries(nextChat, displayedChat)) return false;
+  const nextRevision = parseChatRevision(revision);
+  if (nextRevision !== null && nextRevision < chatRevision) return false;
+  if (nextRevision === null || nextRevision === chatRevision) {
+    if (!chatContainsEntries(nextChat, displayedChat)) return false;
+  }
+  if (nextRevision !== null) chatRevision = nextRevision;
   displayedChat = nextChat.slice();
   for (const el of [...chatLog.querySelectorAll(".bubble.user,.bubble.agent:not(.agent-working)")]) {
     el.remove();
@@ -1850,17 +1890,23 @@ async function submitQueuedOnce(submission, preserveFailureState = false) {
     throw new Error("failed to submit queued prompts");
   }
   const accepted = typeof response.json === "function" ? await response.json().catch(() => null) : null;
-  const reconciledChat = Array.isArray(accepted?.chat)
-    ? mergeAcceptedChat(accepted.chat, submission.chatAtRequest)
+  rememberChatAckIds(accepted?.ack_ids);
+  const acceptedChat = Array.isArray(accepted?.chat) ? accepted.chat : null;
+  if (acceptedChat) settleQueuedFromTranscript(acceptedChat);
+  const acceptedRevision = parseChatRevision(accepted?.chat_revision);
+  const reconciledChat = acceptedChat
+    ? acceptedRevision !== null && acceptedRevision > chatRevision
+      ? acceptedChat
+      : mergeAcceptedChat(acceptedChat, submission.chatAtRequest)
     : null;
-  if (!Array.isArray(accepted?.chat) || reconciledChat) {
+  if (!acceptedChat || reconciledChat) {
     for (const prompt of prompts) {
       deliveredPrompts.add(prompt);
       const index = queued.indexOf(prompt);
       if (index !== -1) queued.splice(index, 1);
     }
     persistQueuedPrompts();
-    if (reconciledChat) syncChat(reconciledChat);
+    if (reconciledChat) syncChat(reconciledChat, acceptedRevision);
   }
   render();
   settleAcknowledgementGuidance(submission, preserveFailureState);
@@ -3987,7 +4033,10 @@ events.set("agent-reply", (data) => {
   if (addChat(entry)) displayedChat.push(entry);
   noteAgentReply(entry.text);
 });
-events.set("chat-sync", (data) => syncChat(data.chat || []));
+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("layout-warnings", (data) => setLayoutWarnings(data.warnings || []));
 events.set("ended", () => markSessionEnded());

package/dist/cli.mjs

@@ -7,7 +7,16 @@ var __export = (target, all) => {
 
 // src/cli.js
 import { spawn, spawnSync } from "node:child_process";
-import { closeSync, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync2, realpathSync, writeFileSync as writeFileSync2 } from "node:fs";
+import {
+  closeSync,
+  createReadStream,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync as readFileSync2,
+  realpathSync,
+  writeFileSync as writeFileSync2
+} from "node:fs";
 import { access, readFile as readFile6, writeFile as writeFile4 } from "node:fs/promises";
 import os3 from "node:os";
 import path8 from "node:path";
@@ -7436,6 +7445,7 @@ var SELECTOR_MAX = 512;
 var LABEL_MAX = 40;
 var PROMPT_ID_MAX = 128;
 var PROMPT_ID_RE = /^[A-Za-z0-9_-]+$/;
+var MAX_CHAT_STORED_BYTES = 5242880;
 function normalizePromptId(value) {
   if (typeof value !== "string") return "";
   const id = value.trim();
@@ -7839,6 +7849,52 @@ function serializeChat(chat) {
   }
   return serialized;
 }
+function boundStoredChat(chat, maxBytes = MAX_CHAT_STORED_BYTES) {
+  const entries = Array.isArray(chat) ? chat.filter((entry) => entry && typeof entry === "object") : [];
+  if (entries.length === 0) return { chat: [], evicted: [] };
+  const limit = Number.isFinite(maxBytes) && maxBytes > 0 ? maxBytes : MAX_CHAT_STORED_BYTES;
+  let storedBytes = 2;
+  let cut = entries.length;
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const serialized = JSON.stringify(entries[index]);
+    const entryBytes = Buffer.byteLength(serialized === void 0 ? "null" : serialized, "utf8");
+    const nextBytes = storedBytes + entryBytes + (cut < entries.length ? 1 : 0);
+    if (nextBytes > limit) break;
+    storedBytes = nextBytes;
+    cut = index;
+  }
+  return { chat: entries.slice(cut), evicted: entries.slice(0, cut) };
+}
+function serializeChatAckIds(ids) {
+  const ackIds = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of Array.isArray(ids) ? ids : []) {
+    const id = normalizePromptId(value);
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    ackIds.push(id);
+  }
+  return ackIds;
+}
+function collectChatAckIds(evicted, existing = []) {
+  const ackIds = serializeChatAckIds(existing);
+  const seen = new Set(ackIds);
+  for (const entry of Array.isArray(evicted) ? evicted : []) {
+    const id = normalizePromptId(entry?.prompt_id);
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    ackIds.push(id);
+  }
+  return ackIds;
+}
+function serializeChatSync(session) {
+  const revision = Number(session?.chat_revision);
+  return {
+    chat: serializeChat(session?.chat || []),
+    ack_ids: serializeChatAckIds(session?.chat_ack_ids),
+    chat_revision: Number.isSafeInteger(revision) && revision >= 0 ? revision : 0
+  };
+}
 
 // src/html-transform.js
 function injectLavishSdk(html, key, artifactRevision, artifactLoadToken = "") {
@@ -8036,6 +8092,10 @@ var SessionStore = class {
       delivered_attachments: Array.isArray(existing.delivered_attachments) ? existing.delivered_attachments : [],
       dom_snapshot: existing.dom_snapshot || "",
       chat: existing.chat || [],
+      chat_revision: normalizeRevision(existing.chat_revision),
+      // Compact prompt_id acks for bubbles evicted by the stored-chat byte bound. Reopening
+      // must keep them: they are the settlement/dedup source once the visible entry is gone.
+      chat_ack_ids: Array.isArray(existing.chat_ack_ids) ? existing.chat_ack_ids : [],
       updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     state.sessions[key] = session;
@@ -8067,7 +8127,10 @@ var SessionStore = class {
     let normalized = prompts.map(normalizePrompt);
     if (!restoring) {
       const acknowledgedIds = new Set(
-        (session.chat || []).map((entry) => normalizePromptId(entry?.prompt_id)).filter(Boolean)
+        [
+          ...(session.chat || []).map((entry) => normalizePromptId(entry?.prompt_id)),
+          ...(session.chat_ack_ids || []).map((id) => normalizePromptId(id))
+        ].filter(Boolean)
       );
       normalized = normalized.filter(({ prompt }) => {
         const promptId = normalizePromptId(prompt.prompt_id);
@@ -8147,6 +8210,8 @@ var SessionStore = class {
     const storedPrompts = restoring ? acceptedPrompts : acceptedPrompts.map(agentFacingPrompt);
     session.prompts = restoring ? [...storedPrompts, ...existingPrompts] : [...existingPrompts, ...storedPrompts];
     session.chat = [...session.chat || [], ...userMessages];
+    applyTranscriptBound(session);
+    if (userMessages.length > 0) session.chat_revision = normalizeRevision(session.chat_revision) + 1;
     if (restoring) {
       const restoredFailures = Array.isArray(payload.artifact_failures) ? JSON.parse(JSON.stringify(payload.artifact_failures)) : [];
       const existingFailures = Array.isArray(session.artifact_failures) ? session.artifact_failures : [];
@@ -8467,11 +8532,11 @@ var SessionStore = class {
       if (!session) {
         return null;
       }
-      session.chat = [
-        ...session.chat || [],
-        { role: "agent", text: String(text || ""), at: (/* @__PURE__ */ new Date()).toISOString() }
-      ];
-      session.updated_at = (/* @__PURE__ */ new Date()).toISOString();
+      const at = (/* @__PURE__ */ new Date()).toISOString();
+      session.chat = [...session.chat || [], { role: "agent", text: String(text || ""), at }];
+      applyTranscriptBound(session);
+      session.chat_revision = normalizeRevision(session.chat_revision) + 1;
+      session.updated_at = at;
       await this.writeState(state);
       return session;
     });
@@ -8515,7 +8580,15 @@ var SessionStore = class {
     try {
       const raw = await readFile3(this.file, "utf8");
       const parsed = JSON.parse(raw);
-      return { sessions: parsed.sessions || {} };
+      const state = { sessions: parsed.sessions || {} };
+      let changed = false;
+      for (const session of Object.values(state.sessions)) {
+        if (!session || typeof session !== "object" || !applyTranscriptBound(session)) continue;
+        session.chat_revision = normalizeRevision(session.chat_revision) + 1;
+        changed = true;
+      }
+      if (changed) await this.writeState(state);
+      return state;
     } catch (error) {
       if (error && error.code === "ENOENT") {
         return { sessions: {} };
@@ -8535,6 +8608,16 @@ async function canonicalFile(file) {
 function sessionKey(file) {
   return crypto4.createHash("sha256").update(file).digest("hex").slice(0, 16);
 }
+function applyTranscriptBound(session) {
+  const originalChat = Array.isArray(session.chat) ? session.chat : [];
+  const { chat, evicted } = boundStoredChat(session.chat);
+  const chatChanged = !Array.isArray(session.chat) || chat.length !== originalChat.length || chat.some((entry, index) => entry !== originalChat[index]);
+  session.chat = chat;
+  if (evicted.length === 0) return chatChanged;
+  const existingAckCount = Array.isArray(session.chat_ack_ids) ? session.chat_ack_ids.length : 0;
+  session.chat_ack_ids = collectChatAckIds(evicted, session.chat_ack_ids);
+  return chatChanged || session.chat_ack_ids.length !== existingAckCount;
+}
 function normalizePrompt(prompt) {
   const normalized = {
     uid: String(prompt.uid || ""),
@@ -9400,7 +9483,7 @@ async function serve({
   }
   events.on("reload", (key) => broadcastLiveEvent("reload", key));
   events.on("agent-reply", (key, entry) => broadcastLiveEvent("agent-reply", key, entry));
-  events.on("chat-sync", (key, chat) => broadcastLiveEvent("chat-sync", key, { chat: serializeChat(chat) }));
+  events.on("chat-sync", (key, session) => broadcastLiveEvent("chat-sync", key, serializeChatSync(session)));
   events.on("agent-presence", (key, state) => broadcastLiveEvent("agent-presence", key, { state }));
   events.on("layout-warnings", (key, warnings) => broadcastLiveEvent("layout-warnings", key, { warnings }));
   events.on("ended", (key, endedBy) => broadcastLiveEvent("ended", key, { ended_by: endedBy || null }));
@@ -9447,7 +9530,7 @@ async function serve({
       cleanup();
       return;
     }
-    client.sendEvent("chat-sync", { chat: serializeChat(session?.chat || []) });
+    client.sendEvent("chat-sync", serializeChatSync(session));
     client.sendEvent("agent-presence", { state: computePresence(key, activePolls, deliveredFeedback) });
     if (session?.status === "ended") client.sendEvent("ended", { ended_by: session.ended_by || null });
   }
@@ -9475,11 +9558,8 @@ async function serve({
   }
   function finishFeedbackDelivery(key, result) {
     if (result.status !== "feedback") return;
-    const chat = result.chat;
-    delete result.chat;
     markFeedbackDelivered(key, activePolls, deliveredFeedback, events);
     if (result.session_ended) clearFeedbackDelivery(key, activePolls, deliveredFeedback, events);
-    if (Array.isArray(chat)) events.emit("chat-sync", key, chat);
   }
   async function restoreClosedFeedback(key, result) {
     if (result.status !== "feedback") return;
@@ -9816,11 +9896,11 @@ async function serve({
       }
       if (shouldEndSession) events.emit("ended", req.params.key, publishedSession.ended_by);
       else if (freshFeedback) events.emit("feedback", req.params.key, publishedSession.ended_by);
-      events.emit("chat-sync", req.params.key, publishedSession.chat);
+      events.emit("chat-sync", req.params.key, publishedSession);
       res.json({
         status: "queued",
         pending_prompts: publishedSession.pending_prompts,
-        chat: serializeChat(publishedSession.chat)
+        ...serializeChatSync(publishedSession)
       });
       if (shouldEndSession) await shutdownIfNoLiveSessions();
     } catch (error) {
@@ -9924,8 +10004,11 @@ async function serve({
         res.status(404).json({ error: "session not found" });
         return;
       }
-      const entry = serializeChat([session.chat?.at(-1)])[0];
+      const entry = serializeChat([
+        session.chat?.at(-1)?.role === "agent" ? session.chat.at(-1) : { role: "agent", text, at: session.updated_at }
+      ])[0];
       events.emit("agent-reply", req.params.key, entry);
+      events.emit("chat-sync", req.params.key, session);
       clearFeedbackDelivery(req.params.key, activePolls, deliveredFeedback, events);
       res.json({ status: "sent" });
     } catch (error) {
@@ -11099,6 +11182,8 @@ function createChromeHtml(session, {
     initialEnded: session.status === "ended",
     initialEndedBy: session.ended_by || null,
     initialChat: serializeChat(session.chat || []),
+    initialChatAckIds: serializeChatAckIds(session.chat_ack_ids),
+    initialChatRevision: Number.isSafeInteger(session.chat_revision) && session.chat_revision >= 0 ? session.chat_revision : 0,
     // Bootstrapping the inbox from the server is what makes it survive a browser refresh or a
     // reconnect: the chrome never owns warning state, it only renders it.
     initialLayoutWarnings: serializeLayoutWarnings(session.layout_warnings),
@@ -11398,8 +11483,16 @@ var POLL_WAKE_PATH_RULES = Object.freeze([
   "If it returns browser_disconnected, the review window stayed disconnected past its reconnect grace period but the session remains resumable; ask the user whether to reopen or end it, and do neither uninvited."
 ]);
 var POLL_SEND_AND_END_RULE = "`Send & End` ends the session. Its final feedback is still delivered once. After that response, polling stops, and the agent must not reopen the session uninvited.";
+var POLL_AGENT_REPLY_RULE = "Keep the reply concise. Only when a longer reply is genuinely necessary, use Markdown structure - blank-line paragraphs, `- ` / `1. ` lists, `## ` headings - so it renders scannably instead of a wall of text, and pass that body with `--agent-reply-file <path>` (`-` reads stdin) so newlines survive quoting.";
+var POLL_AGENT_REPLY_HELP_POINTER = "The Conversation panel's Markdown subset is in README's Feedback controls bullet.";
+var POLL_AGENT_REPLY_NEXT_POINTER = "The Conversation panel's Markdown subset is in `lavish-axi poll --help` and README.";
+var POLL_VALUE_FLAGS = ["--agent-reply", "--agent-reply-file", "--timeout-ms"];
+var AGENT_REPLY_JSON_LIMIT_BYTES = 2 * 1024 * 1024;
+var AGENT_REPLY_JSON_ENVELOPE_BYTES = Buffer.byteLength(JSON.stringify({ text: "" }));
+var AGENT_REPLY_INPUT_LIMIT_BYTES = AGENT_REPLY_JSON_LIMIT_BYTES - AGENT_REPLY_JSON_ENVELOPE_BYTES;
+var AGENT_REPLY_LIMIT_LABEL = "2 MB JSON request limit";
 var CODEX_POLL_WAKE_PATH_GUIDANCE = "Codex detected: completed background tasks may not resume Codex automatically, so keep the poll attached to the active turn.";
-var VERSION = "0.1.69";
+var VERSION = "0.1.71";
 function detectInvokingAgent(env = process.env) {
   return ["CODEX_SANDBOX", "CODEX_THREAD_ID"].some((key) => Object.hasOwn(env, key)) ? "codex" : "generic";
 }
@@ -11556,7 +11649,7 @@ function createOpenOutput({
     session: { file, url, status },
     ...networkWarning ? { network_warning: networkWarning } : {},
     ...selfPaintWarning ? { self_paint_warning: selfPaintWarning } : {},
-    next_step: `${selfPaintPrefix}Do not respond to the user just yet. Now you must run \`lavish-axi poll ${file}\`. This command long-polls until the user sends feedback, ends the session, or leaves every review window disconnected past the reconnect grace period, and it stays silent the whole time - that is normal, never kill it. Layout issues the browser detects do not return this poll; they wait in the user's Layout issues inbox until the user queues them, then arrive as an ordinary tag "layout-warnings" prompt. Do not pass --timeout-ms during normal agent use. ${pollExecutionGuidance({ agent })} After applying feedback, run \`lavish-axi poll ${file} --agent-reply "<message for the user>"\` without --timeout-ms to show your response in Lavish Editor and wait for more feedback. If the user ends the session, stop polling and do not reopen it by re-running \`lavish-axi ${file}\` unless the user asks for further review or something genuinely important needs their visual attention - deliver routine updates directly in this conversation instead. When reopening is warranted, run \`lavish-axi ${file} --reopen\`.`
+    next_step: `${selfPaintPrefix}Do not respond to the user just yet. Now you must run \`lavish-axi poll ${file}\`. This command long-polls until the user sends feedback, ends the session, or leaves every review window disconnected past the reconnect grace period, and it stays silent the whole time - that is normal, never kill it. Layout issues the browser detects do not return this poll; they wait in the user's Layout issues inbox until the user queues them, then arrive as an ordinary tag "layout-warnings" prompt. Do not pass --timeout-ms during normal agent use. ${pollExecutionGuidance({ agent })} After applying feedback, run \`lavish-axi poll ${file} --agent-reply "<message for the user>"\` without --timeout-ms to show a concise response in Lavish Editor and wait for more feedback. ${POLL_AGENT_REPLY_RULE} ${POLL_AGENT_REPLY_NEXT_POINTER} If the user ends the session, stop polling and do not reopen it by re-running \`lavish-axi ${file}\` unless the user asks for further review or something genuinely important needs their visual attention - deliver routine updates directly in this conversation instead. When reopening is warranted, run \`lavish-axi ${file} --reopen\`.`
   };
 }
 function createUserEndedOpenOutput({ file, url, networkWarning = void 0 }) {
@@ -11616,13 +11709,13 @@ function shouldOpenBrowser(args, env) {
   return !args.includes("--no-open") && env.LAVISH_AXI_NO_OPEN !== "1";
 }
 async function pollCommand(args) {
-  const file = firstPositionalArg(args, ["--agent-reply", "--timeout-ms"]);
+  const file = firstPositionalArg(args, POLL_VALUE_FLAGS);
   if (!file) {
     throw new AxiError("HTML file path is required", "VALIDATION_ERROR", ["Run `lavish-axi poll <html-file>`"]);
   }
+  const agentReply = await resolveAgentReply(args);
   const absolute = await canonicalFile(file);
   const baseUrl = await ensureServer();
-  const agentReply = flagValue(args, "--agent-reply");
   if (agentReply) {
     await postJson(`${baseUrl}/api/${sessionKey(absolute)}/agent-reply`, { text: agentReply });
   }
@@ -11740,7 +11833,7 @@ function createFeedbackNextStep(file, artifactFailures, sessionEnded, endedBy, p
     return `${failureNote}${layoutNote}${whiteboardNote}${attachmentNote}This was the last feedback before the Lavish Editor session ended. Stop polling ${file}. Deliver any remaining updates directly in this conversation, or run \`lavish-axi ${file}\` to open a fresh session if the user needs further visual review.`;
   }
   const prefix = count > 0 ? artifactFailuresPrefix(file, artifactFailures) : `Apply the requested changes to ${file}. `;
-  return `${prefix}${layoutNote}${whiteboardNote}${attachmentNote}Do not respond to the user just yet. Now you must run \`lavish-axi poll ${file} --agent-reply "<message for the user>"\` without --timeout-ms unless the user ended the session. The poll waits silently until the user sends more feedback, ends the session, or leaves every review window disconnected past the reconnect grace period - never kill it. ${pollExecutionGuidance({ agent })}`;
+  return `${prefix}${layoutNote}${whiteboardNote}${attachmentNote}Do not respond to the user just yet. Now you must run \`lavish-axi poll ${file} --agent-reply "<message for the user>"\` without --timeout-ms unless the user ended the session. ${POLL_AGENT_REPLY_RULE} ${POLL_AGENT_REPLY_NEXT_POINTER} The poll waits silently until the user sends more feedback, ends the session, or leaves every review window disconnected past the reconnect grace period - never kill it. ${pollExecutionGuidance({ agent })}`;
 }
 function artifactFailuresPrefix(file, artifactFailures) {
   const count = artifactFailures.length;
@@ -12773,6 +12866,103 @@ function flagValue(args, flag) {
   }
   return null;
 }
+function inspectValueFlag(args, flag) {
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--") return { present: false };
+    if (arg === flag) {
+      return { present: true, value: i + 1 < args.length ? args[i + 1] : null, swallows: true };
+    }
+    if (arg.startsWith(`${flag}=`)) {
+      return { present: true, value: arg.slice(flag.length + 1), swallows: false };
+    }
+  }
+  return { present: false };
+}
+var AGENT_REPLY_FILE_HINT = "Pass --agent-reply-file <path>, or --agent-reply-file - to read stdin";
+function agentReplyTooLargeError() {
+  return new AxiError(`Agent reply exceeds the ${AGENT_REPLY_LIMIT_LABEL}`, "VALIDATION_ERROR", [
+    "Shorten the reply, then retry the same poll command"
+  ]);
+}
+async function readAgentReplyStream(stream) {
+  const chunks = [];
+  let bytes = 0;
+  for await (const value of stream) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    bytes += chunk.length;
+    if (bytes > AGENT_REPLY_INPUT_LIMIT_BYTES) {
+      stream.destroy();
+      throw agentReplyTooLargeError();
+    }
+    chunks.push(chunk);
+  }
+  const text = Buffer.concat(chunks, bytes).toString("utf8");
+  if (Buffer.byteLength(JSON.stringify({ text })) > AGENT_REPLY_JSON_LIMIT_BYTES) {
+    throw agentReplyTooLargeError();
+  }
+  return text;
+}
+async function resolveAgentReply(args, { createReadStreamFn = createReadStream, stdin = process.stdin, stdinIsTTY = process.stdin.isTTY === true } = {}) {
+  const inline = inspectValueFlag(args, "--agent-reply");
+  const fromFile = inspectValueFlag(args, "--agent-reply-file");
+  if (inline.present && fromFile.present) {
+    throw new AxiError("--agent-reply and --agent-reply-file cannot be combined", "VALIDATION_ERROR", [
+      "Pass --agent-reply for a concise quoted reply, or --agent-reply-file <path> (`-` for stdin) when a longer Markdown body is necessary"
+    ]);
+  }
+  if (fromFile.present) {
+    return readAgentReplyFile(fromFile, { createReadStreamFn, stdin, stdinIsTTY });
+  }
+  if (!inline.present) return null;
+  return inline.value || null;
+}
+async function readAgentReplyFile(fromFile, { createReadStreamFn, stdin, stdinIsTTY }) {
+  if (fromFile.swallows && typeof fromFile.value === "string" && fromFile.value.startsWith("--")) {
+    throw new AxiError(
+      `--agent-reply-file was given no value: the next argument ${fromFile.value} is another flag, so it would have been used as the path`,
+      "VALIDATION_ERROR",
+      [AGENT_REPLY_FILE_HINT, "Use --agent-reply-file=<path> if the path itself starts with --"]
+    );
+  }
+  const spec = fromFile.value;
+  if (spec == null || !String(spec).trim()) {
+    throw new AxiError("--agent-reply-file was given an empty value", "VALIDATION_ERROR", [AGENT_REPLY_FILE_HINT]);
+  }
+  let text;
+  if (spec === "-") {
+    if (stdinIsTTY) {
+      throw new AxiError("--agent-reply-file - cannot read stdin from a terminal", "VALIDATION_ERROR", [
+        "Pipe a Markdown body into stdin, or pass --agent-reply-file <path>"
+      ]);
+    }
+    try {
+      text = await readAgentReplyStream(stdin);
+    } catch (error) {
+      if (error instanceof AxiError) throw error;
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new AxiError(`Cannot read --agent-reply-file stdin: ${detail}`, "VALIDATION_ERROR", [
+        "Pipe a Markdown body into stdin, or pass --agent-reply-file <path>"
+      ]);
+    }
+  } else {
+    try {
+      text = await readAgentReplyStream(createReadStreamFn(spec));
+    } catch (error) {
+      if (error instanceof AxiError) throw error;
+      const detail = error instanceof Error ? error.message : String(error);
+      throw new AxiError(`Cannot read --agent-reply-file ${spec}: ${detail}`, "VALIDATION_ERROR", [
+        "Pass a UTF-8 Markdown file, or `-` to read stdin"
+      ]);
+    }
+  }
+  if (!String(text || "").trim()) {
+    throw new AxiError("--agent-reply-file was empty", "VALIDATION_ERROR", [
+      'Write Markdown into the file, or pass --agent-reply "<message>" for a concise reply'
+    ]);
+  }
+  return String(text);
+}
 function isValueFlagToken(arg, flags) {
   for (const flag of flags) {
     if (arg === flag || arg.startsWith(`${flag}=`)) return true;
@@ -12791,7 +12981,7 @@ function createTopLevelHelp({ agent = "generic" } = {}) {
 Usage:
   lavish-axi
   lavish-axi <html-file> [--no-open] [--no-gate] [--reopen]
-  lavish-axi poll <html-file> [--agent-reply "..."]
+  lavish-axi poll <html-file> [--agent-reply "..."] [--agent-reply-file <path>]
   lavish-axi end <html-file>
   lavish-axi export <html-file> [--out <path>]
   lavish-axi share <html-file> [--private | --password <pw>] [--token <t>]
@@ -12815,9 +13005,16 @@ function createCommandHelp({ agent = "generic" } = {}) {
 
 Open or resume a Lavish Editor review session for an HTML artifact. Use --no-open when you need to ensure the server/session exists without opening another browser window. Use --no-gate to skip the open-time layout curtain for this browser open. If the user explicitly ended the session from the browser, this refuses to reopen it and returns guidance instead - pass --reopen to force it open when the user asks for further review or something important needs their visual attention. Sessions ended by the agent (\`lavish-axi end\`) reopen normally without the flag.
 `,
-    poll: `Usage: lavish-axi poll <html-file> [--agent-reply "..."]
+    poll: `Usage: lavish-axi poll <html-file> [--agent-reply "..."] [--agent-reply-file <path>]
+
+This command long-polls indefinitely for queued user prompts. It stays silent while it waits - that is normal, never kill it. Browser-detected layout issues do NOT return this poll: they are filed passively in the user's Layout issues inbox and arrive as an ordinary tag "layout-warnings" prompt only after the user selects them and queues the fixes. Warning lifecycle: an issue stays unresolved and counted while queued, becomes recurring if a newer artifact revision still shows it, and is resolved only after a newer artifact load plus a complete diagnostic pass at the same viewport no longer detects it. A failed or incomplete pass preserves it as unverified rather than clearing it. The only response that arrives without user action is artifact_failures - a fatal failure that made the review surface itself unusable. Do not pass --timeout-ms during normal agent use; it is for tests and debugging only. ${pollExecutionGuidance({ agent })} Use --agent-reply after applying prior feedback to display a concise response in Lavish Editor before waiting again. ${POLL_AGENT_REPLY_RULE} ${POLL_AGENT_REPLY_HELP_POINTER} Do not combine --agent-reply with --agent-reply-file.
+
+Examples:
+  lavish-axi poll report.html --agent-reply "Renamed the payment step."
+  lavish-axi poll report.html --agent-reply-file reply.md
+  lavish-axi poll report.html --agent-reply-file -
 
-This command long-polls indefinitely for queued user prompts. It stays silent while it waits - that is normal, never kill it. Browser-detected layout issues do NOT return this poll: they are filed passively in the user's Layout issues inbox and arrive as an ordinary tag "layout-warnings" prompt only after the user selects them and queues the fixes. Warning lifecycle: an issue stays unresolved and counted while queued, becomes recurring if a newer artifact revision still shows it, and is resolved only after a newer artifact load plus a complete diagnostic pass at the same viewport no longer detects it. A failed or incomplete pass preserves it as unverified rather than clearing it. The only response that arrives without user action is artifact_failures - a fatal failure that made the review surface itself unusable. Do not pass --timeout-ms during normal agent use; it is for tests and debugging only. ${pollExecutionGuidance({ agent })} Use --agent-reply after applying prior feedback to display your response in Lavish Editor before waiting again. ${POLL_SEND_AND_END_RULE}
+${POLL_SEND_AND_END_RULE}
 `,
     end: `Usage: lavish-axi end <html-file>
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lavish-axi",
-  "version": "0.1.69",
+  "version": "0.1.71",
   "packageManager": "pnpm@11.1.1",
   "description": "HTML is the new markdown. Lavish is the new editor for your HTML artifacts.",
   "type": "module",

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "lavish-axi",
-  "version": "0.1.69",
+  "version": "0.1.71",
   "description": "HTML is the new markdown. Lavish is the new editor for your HTML artifacts.",
   "author": {
     "name": "Kun Chen",