shadok-ai 0.15.6 → 0.15.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shadok-ai",
-  "version": "0.15.6",
+  "version": "0.15.7",
   "main": "dist/session.js",
   "scripts": {
     "test": "node --import tsx --test --test-timeout=120000 test/*.ts context/*/test/*.test.mjs",

package/public/index.html

@@ -5546,6 +5546,16 @@
   function scheduleReconnect(t) {
     if (t.closing) return;
     if (t.reconnectTimer) clearTimeout(t.reconnectTimer);
+    // The socket that owed us a `working` is gone, so the optimistic gap can
+    // never close by itself: drop it and hand back anything queued behind it.
+    // Without this a drop INSIDE that gap latched `awaitingTurn` for good — the
+    // reattach only sends `working` when the session is still busy, so a turn
+    // that finished while we were away leaves no event to clear it, and every
+    // later Enter queued behind a turn that will never end: box cleared, draft
+    // dropped, nothing on the wire, nothing on screen. Measured in a browser.
+    if (drainQueueToBox(t)) {
+      addTurn(t, "system", "", "Your unsent message is back in the box — the link dropped before it was sent.");
+    }
     const n = t.reconnectAttempts++;
     const delay = Math.min(15000, 1000 * 2 ** n) + Math.floor(Math.random() * 500);
     setTabState(t, "dead", "link lost — reconnecting…");
@@ -6195,9 +6205,17 @@
         if (msg.lastTurnMs) showFrozenTime(t, msg.lastTurnMs);
         else t.timerEl.classList.add("done"); // freeze whatever's shown; don't keep ticking
         addTurn(t, "system", "", "Session established. The pilot has the controls.");
+        // Backstop to the same rule: "ready" asserts the process is idle NOW,
+        // so there is no turn in flight to wait on — whatever path got us here.
+        if (drainQueueToBox(t)) {
+          addTurn(t, "system", "", "Your unsent message is back in the box — the turn it was waiting for is over.");
+        }
         if (t === active) promptInput.focus();
         break;
       case "working":
+        // The turn is confirmed running: the optimistic gap is over, and any
+        // further send now goes through the busy (takeover) path.
+        t.awaitingTurn = false;
         // Another client may have resolved the pending dialog.
         retireChoices(t);
         // Covers turns started elsewhere (other client, dialog answer, cron) and
@@ -6326,11 +6344,13 @@
           persistChannels();
         }
         stopTurnTimer(t);
-        // A message was typed during this turn (a takeover): the turn has just
-        // settled, so send it now. Mirrors the Telegram bridge's preempt.
-        if (t.preempting) {
-          const queued = t.preempting;
-          t.preempting = null;
+        t.awaitingTurn = false;
+        // Messages queued during this turn — a takeover (preemptTurn) or a fast
+        // double-send (queueForNextTurn) — settle now. Send the NEXT one, in
+        // order; submitPrompt re-arms the gap, so the rest flush on the following
+        // turn-done. Mirrors the Telegram bridge's preempt.
+        if (t.sendQueue && t.sendQueue.length) {
+          const queued = t.sendQueue.shift();
           clearTimeout(t.preemptTimer);
           setTabState(t, "ready", "ready");
           submitPrompt(t, queued);
@@ -6382,6 +6402,7 @@
         // to restore it and forget it so it doesn't resurrect every reload.
         addTurn(t, "system", "", msg.message);
         forgetChannel(msg.sessionId);
+        drainQueueToBox(t);
         stopTurnTimer(t);
         setTabMood(t, null);
         setTabState(t, "dead", "directory gone");
@@ -6391,6 +6412,11 @@
         // the instance's. Surface the fix instead of a line in the transcript.
         if (msg.code === "logged-out") { openAuthCard(); }
         addTurn(t, "system", "", "Error: " + msg.message);
+        // A turn died before it could flush what was queued behind it (a fast
+        // double-send): hand those back to the box rather than strand them.
+        if (drainQueueToBox(t)) {
+          addTurn(t, "system", "", "Your next message is back in the box — the turn didn't complete.");
+        }
         // Failed before ever going live (e.g. a bad restore): mark dead so it
         // doesn't hang on "connecting…".
         if (t.status === "connecting") setTabState(t, "dead", "failed to start");
@@ -6402,6 +6428,7 @@
         break;
       case "exited":
         addTurn(t, "system", "", "The claude process exited (code " + msg.code + ").");
+        drainQueueToBox(t);
         stopTurnTimer(t);
         setTabMood(t, null);
         setTabState(t, "dead", "session ended");
@@ -6445,6 +6472,11 @@
         // pilot exits while the server awaits getUsage(), "exited" marks the tab
         // dead and this refusal would resurrect it as ready with a green LED,
         // with no later message to correct it.
+        // The refused prompt never became a turn: close the optimistic gap. Its
+        // own text is re-offered by renderPaceConfirm below; anything queued
+        // BEHIND it (a fast follow-up) has no turn to ride on, so hand it back.
+        t.awaitingTurn = false;
+        drainQueueToBox(t);
         const rollback = t.status === "ready";
         if (rollback) {
           stopTurnTimer(t);
@@ -6585,21 +6617,54 @@
   function preemptTurn(t, text) {
     // Socket down: leave the text in the box, like submitPrompt's own guard.
     if (!sendTo(t, { type: "key", key: "escape" })) return;
-    t.preempting = text;
-    t.transcriptEl._stickBottom = true;
-    if (t === active) { promptInput.value = ""; promptInput.style.height = "auto"; }
-    dropDraft(t);
-    clearAttachments(t); // their paths are already folded into `text`
+    queueForNextTurn(t, text);
     setTabState(t, "busy", "interrupting…");
     clearTimeout(t.preemptTimer);
     t.preemptTimer = setTimeout(() => {
-      if (t.preempting !== text) return; // already sent, or replaced by a newer one
-      t.preempting = null;
-      if (t === active && !promptInput.value) { promptInput.value = text; active.draft = text; }
+      // Interrupt never landed (a wedged turn): hand the still-queued messages
+      // back rather than lose them or loop. Only the interrupt path arms this —
+      // a message merely QUEUED behind a healthy long turn must wait as long as
+      // the turn takes, which can far exceed this failsafe.
+      if (!t.sendQueue || !t.sendQueue.length) return;
+      const stuck = t.sendQueue.join("\n");
+      t.sendQueue = [];
+      if (t === active && !promptInput.value) { promptInput.value = stuck; active.draft = stuck; }
       addTurn(t, "system", "", "Couldn't interrupt the running turn — your message is back in the box. Try again, or use ⎋.");
     }, PREEMPT_TIMEOUT_MS);
   }
 
+  /**
+   * Stash a message to send once the in-flight turn settles, and clear the
+   * composer so the user sees it was accepted. Nothing is rendered now: the
+   * message appears as an ordinary prompt when it is actually sent (on
+   * `turn-done`), so the transcript stays in order. Shared by the takeover
+   * (preemptTurn, which also interrupts) and the fast-double-send guard, where a
+   * second Enter lands before the server's `working` has flipped the tab to
+   * busy — without this it fired a SECOND raw prompt, which the server refused as
+   * "a response is already in progress" while the box was already cleared, so the
+   * message was lost. A FIFO queue, not a single slot: several quick messages all
+   * survive, delivered in order.
+   */
+  function queueForNextTurn(t, text) {
+    (t.sendQueue ||= []).push(text);
+    t.transcriptEl._stickBottom = true;
+    if (t === active) { promptInput.value = ""; promptInput.style.height = "auto"; }
+    dropDraft(t);
+    clearAttachments(t); // their paths are already folded into `text`
+  }
+
+  /** Hand any queued-but-unsent messages back to the composer (a turn died
+   *  before they could be flushed), so a fast double-send is never swallowed by
+   *  an error/exit. Returns true if something was restored. */
+  function drainQueueToBox(t) {
+    t.awaitingTurn = false;
+    if (!t.sendQueue || !t.sendQueue.length) return false;
+    const stuck = t.sendQueue.join("\n");
+    t.sendQueue = [];
+    if (t === active && !promptInput.value) { promptInput.value = stuck; active.draft = stuck; autosizePrompt(); }
+    return true;
+  }
+
   function submitPrompt(t, text, force) {
     // Send BEFORE touching the UI. Everything below is optimistic — it shows the
     // turn, marks the tab busy, clears the composer and drops the draft — so on
@@ -6609,6 +6674,12 @@
       addTurn(t, "system", "", "Not sent: this agent is not connected. Your text is still in the box.");
       return;
     }
+    // The turn is in flight but the server's `working` has not come back yet, so
+    // t.status is still "ready". Mark the gap so a second fast Enter QUEUES
+    // (queueForNextTurn) instead of firing another raw prompt the server would
+    // refuse as busy — the fast-double-send bug. Cleared on `working` (the busy
+    // path takes over from there) and on every turn settle/terminal.
+    t.awaitingTurn = true;
     // Any outstanding pace question is answered by the fact that something is
     // being sent — whether by clicking its own button or by a fresh submit.
     retirePaceConfirm(t);
@@ -6714,6 +6785,12 @@
     // Sending during a running turn is a takeover: interrupt it, then send the
     // message once the turn settles. Same behaviour as Telegram.
     if (t.status === "busy") return preemptTurn(t, text);
+    // A prompt is already in flight but the server's `working` has not come back
+    // yet (t.status still "ready"): a fast second Enter. QUEUE it instead of
+    // firing a second raw prompt the server refuses as busy — the message would
+    // otherwise be lost with the box already cleared. No interrupt: the turn is
+    // only just starting, so let it finish and send this next.
+    if (t.awaitingTurn) return queueForNextTurn(t, text);
     if (t.status !== "ready") return;
     // Checked here so nothing is optimistically rendered before the server
     // refuses. The server re-checks anyway — it is the authority.