lavish-axi 0.1.56 → 0.1.57

package/README.md

@@ -204,6 +204,7 @@ pnpm link
   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.
 - **Session end etiquette** - Lavish tracks who ended a session: a human clicking **End session** (or **Send & end session**) in the browser is a user-initiated end, while `lavish-axi end <html-file>` is agent-initiated.
+  When either side ends the session, every open review tab becomes visibly read-only and disables its feedback controls; feedback submitted after the end is refused instead of being accepted without an agent to receive it.
   A plain `lavish-axi <html-file>` after a user-initiated end refuses to reopen the browser and returns guidance instead; pass `--reopen` only when the user asks for further review or something important needs their visual attention.
   Agent-initiated ends keep reopening normally, same as before.
   `lavish-axi poll`'s `ended` response and the `feedback` response for the final batch before an end both carry `next_step` guidance telling the agent to stop polling and deliver remaining updates in chat instead of reopening.

package/dist/chrome-client.js

@@ -746,16 +746,16 @@ function setSheetOpen(open) {
   if (sheetOpen) scrollPanelToBottom();
 }
 
-// Re-derives every sheet attribute from the two facts that matter - whether the phone layout is
-// active and whether the sheet is open - so a viewport crossing the breakpoint in either direction
-// leaves nothing stale: a desktop panel is never inert, and a closed dock never traps focus.
+// Re-derives every sheet attribute from the phone layout, sheet-open, and session-ended state so a
+// viewport crossing the breakpoint in either direction cannot make an ended panel interactive or
+// leave a closed dock trapping focus.
 function applySheetState() {
   const mobile = isMobileSheet();
   const open = mobile && sheetOpen;
   document.body.classList.toggle("sheet-open", open);
   const docked = mobile && !open;
-  panelScroll.inert = docked;
-  chatComposer.inert = docked;
+  panelScroll.inert = ended || docked;
+  chatComposer.inert = ended || docked;
   const activeElement = document.activeElement;
   if (docked && activeElement && (panelScroll.contains(activeElement) || chatComposer.contains(activeElement))) {
     panelToggle.focus();
@@ -1217,6 +1217,14 @@ async function submitQueuedOnce() {
   if (!response.ok) {
     if (response.status === 409) {
       const data = await response.json().catch(() => null);
+      // The session already ended before this batch arrived - most likely this chrome missed the
+      // SSE `ended` event (a dropped connection). Go read-only now instead of leaving Send enabled
+      // for another attempt that will be refused the same way.
+      if (data?.status === "ended") {
+        endAfterSubmit = false;
+        markSessionEnded();
+        return false;
+      }
       if (Array.isArray(data?.warnings)) setLayoutWarnings(data.warnings);
       endAfterSubmit = false;
       return false;
@@ -1778,6 +1786,7 @@ function markSessionEnded() {
   ended = true;
   cancelArtifactLoadRecovery();
   closeMenus();
+  closeShareDialog();
   closeWarningsDrawer();
   renderWarnings();
   closeWhiteboard();
@@ -1785,7 +1794,7 @@ function markSessionEnded() {
   moreButton.disabled = true;
   chatInput.disabled = true;
   updateSendState();
-  renderSheetSummary();
+  applySheetState();
   if (presenceBanner) presenceBanner.hidden = true;
   if (handoffBanner) handoffBanner.hidden = true;
   if (outdatedBanner) outdatedBanner.hidden = true;
@@ -3123,6 +3132,7 @@ events.addEventListener("agent-reply", (event) => {
 events.addEventListener("chat-sync", (event) => syncChat(JSON.parse(event.data).chat || []));
 events.addEventListener("agent-presence", (event) => setAgentPresence(JSON.parse(event.data).state));
 events.addEventListener("layout-warnings", (event) => setLayoutWarnings(JSON.parse(event.data).warnings || []));
+events.addEventListener("ended", () => markSessionEnded());
 // A reconnecting stream means this chrome may have missed updates while it was away.
 events.addEventListener("open", () => refreshLayoutWarnings());
 
@@ -3134,6 +3144,9 @@ renderWarnings();
 initialChat.forEach((item) => addChat(item.role, item.text));
 retiredDrafts.forEach((text) => renderRetiredDraft(text));
 setAgentPresence("waiting");
+// The session already ended before this page (re)loaded, so there is no future SSE `ended` event
+// to wait for - start read-only instead of looking live until a Send gets silently refused.
+if (sessionData.initialEnded) markSessionEnded();
 
 // Reaching this line is the only proof that this file parsed and ran to completion. The page it
 // bootstraps ships with the layout-gate overlay already covering the artifact, and only this

package/dist/cli.mjs

@@ -7379,6 +7379,9 @@ var SessionStore = class {
     const shouldEndSession = Boolean(payload.endSession || payload.end_session);
     const restoring = options.restore === true;
     const alreadyEnded = session.status === "ended";
+    if (alreadyEnded && !restoring) {
+      return { ended: true, ended_by: session.ended_by };
+    }
     const normalized = prompts.map(normalizePrompt);
     const normalizedPrompts = normalized.map((entry) => entry.prompt);
     const rejected = boundAttachmentRefs(normalized, options);
@@ -8881,6 +8884,10 @@ async function serve({
         res.status(404).json({ error: "session not found" });
         return;
       }
+      if (result.ended) {
+        res.status(409).json({ status: "ended", error: "session already ended", ended_by: result.ended_by });
+        return;
+      }
       if (result.rejected) {
         res.status(400).json({
           error: "some attachments could not be delivered",
@@ -8904,7 +8911,7 @@ async function serve({
         await syncOutstandingRepairs(req.params.key);
         events.emit("layout-warnings", req.params.key, serializeLayoutWarnings(session.layout_warnings));
       }
-      events.emit(shouldEndSession ? "ended" : "feedback", req.params.key);
+      events.emit(shouldEndSession ? "ended" : "feedback", req.params.key, session.ended_by);
       res.json({ status: "queued", pending_prompts: session.pending_prompts });
       if (shouldEndSession) await shutdownIfNoLiveSessions();
     } catch (error) {
@@ -8991,9 +8998,9 @@ async function serve({
   });
   app.post("/api/:key/end", async (req, res, next) => {
     try {
-      await store.endSession(req.params.key, "user");
+      const session = await store.endSession(req.params.key, "user");
       clearFeedbackDelivery(req.params.key, activePolls, deliveredFeedback, events);
-      events.emit("ended", req.params.key);
+      events.emit("ended", req.params.key, session?.ended_by);
       res.json({ status: "ended" });
       await shutdownIfNoLiveSessions();
     } catch (error) {
@@ -9080,9 +9087,9 @@ async function serve({
     try {
       const file = await canonicalFile(req.body.file);
       const key = sessionKey(file);
-      await store.endSession(key, "agent");
+      const session = await store.endSession(key, "agent");
       clearFeedbackDelivery(key, activePolls, deliveredFeedback, events);
-      events.emit("ended", key);
+      events.emit("ended", key, session?.ended_by);
       res.json({ status: "ended" });
       await shutdownIfNoLiveSessions();
     } catch (error) {
@@ -9215,6 +9222,8 @@ async function serve({
     }
   });
   app.get("/events/:key", async (req, res, next) => {
+    let cleanup = () => {
+    };
     try {
       res.writeHead(200, {
         "content-type": "text/event-stream",
@@ -9223,7 +9232,6 @@ async function serve({
       });
       sseClients.set(res, String(req.params.key || ""));
       refreshIdleTimer();
-      const session = await store.findByKey(req.params.key);
       const sendReload = (key) => {
         if (key === req.params.key) {
           res.write("event: reload\ndata: {}\n\n");
@@ -9253,29 +9261,51 @@ data: ${JSON.stringify({ warnings })}
 `);
         }
       };
-      res.write(`event: chat-sync
-data: ${JSON.stringify({ chat: session?.chat || [] })}
+      const sendEnded = (key, endedBy) => {
+        if (key === req.params.key) {
+          res.write(`event: ended
+data: ${JSON.stringify({ ended_by: endedBy || null })}
 
 `);
-      res.write(
-        `event: agent-presence
-data: ${JSON.stringify({ state: computePresence(req.params.key, activePolls, deliveredFeedback) })}
-
-`
-      );
+        }
+      };
       events.on("reload", sendReload);
       events.on("agent-reply", sendAgentReply);
       events.on("agent-presence", sendPresence);
       events.on("layout-warnings", sendLayoutWarnings);
-      req.on("close", () => {
+      events.on("ended", sendEnded);
+      let cleanedUp = false;
+      cleanup = () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        req.off("close", cleanup);
         sseClients.delete(res);
         events.off("reload", sendReload);
         events.off("agent-reply", sendAgentReply);
         events.off("agent-presence", sendPresence);
         events.off("layout-warnings", sendLayoutWarnings);
+        events.off("ended", sendEnded);
         refreshIdleTimer();
-      });
+      };
+      req.once("close", cleanup);
+      const session = await store.findByKey(req.params.key);
+      if (req.destroyed || res.writableEnded) {
+        cleanup();
+        return;
+      }
+      res.write(`event: chat-sync
+data: ${JSON.stringify({ chat: session?.chat || [] })}
+
+`);
+      res.write(
+        `event: agent-presence
+data: ${JSON.stringify({ state: computePresence(req.params.key, activePolls, deliveredFeedback) })}
+
+`
+      );
+      if (session?.status === "ended") sendEnded(req.params.key, session.ended_by);
     } catch (error) {
+      cleanup();
       next(error);
     }
   });
@@ -10035,6 +10065,11 @@ function createChromeHtml(session, {
   const sessionJson = jsonScript({
     key: session.key,
     file: session.file,
+    // A page loaded (or reloaded) after the session already ended has no future SSE `ended`
+    // event to wait for - it must start read-only instead of looking live until the user tries
+    // to send and gets refused (#171).
+    initialEnded: session.status === "ended",
+    initialEndedBy: session.ended_by || null,
     initialChat: session.chat || [],
     // 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.
@@ -10334,7 +10369,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.56";
+var VERSION = "0.1.57";
 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.56",
+  "version": "0.1.57",
   "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.56",
+  "version": "0.1.57",
   "description": "HTML is the new markdown. Lavish is the new editor for your HTML artifacts.",
   "author": {
     "name": "Kun Chen",