lavish-axi 0.1.69 → 0.1.70

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.

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

@@ -7436,6 +7436,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 +7840,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 +8083,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 +8118,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 +8201,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 +8523,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 +8571,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 +8599,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 +9474,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 +9521,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 +9549,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 +9887,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 +9995,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 +11173,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),
@@ -11399,7 +11475,7 @@ var POLL_WAKE_PATH_RULES = Object.freeze([
 ]);
 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 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.70";
 function detectInvokingAgent(env = process.env) {
   return ["CODEX_SANDBOX", "CODEX_THREAD_ID"].some((key) => Object.hasOwn(env, key)) ? "codex" : "generic";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lavish-axi",
-  "version": "0.1.69",
+  "version": "0.1.70",
   "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.70",
   "description": "HTML is the new markdown. Lavish is the new editor for your HTML artifacts.",
   "author": {
     "name": "Kun Chen",