bunnyquery 1.11.1 → 1.13.0

package/README.md

@@ -34,6 +34,11 @@ you can build your own chat UI on top of it. See
   across as many passes as it takes. A file's passes collapse into a single
   status row in the chat that can be expanded, and stopped: "Stop" cancels every
   queued and running pass at once and ends the continuation chain.
+- **Stop waiting**: a reply that is taking too long can be given up on. The
+  "Thinking" bubble carries a small x that cancels the running request on the
+  server, marks the question as cancelled, and lets the next message go out
+  at once instead of queueing behind it. A message still waiting in the queue
+  has the same control on its own bubble.
 - **Attachment parser plugins**: register a client-side parser so the widget
   extracts text in the browser from formats the model can't otherwise read, and
   indexes it directly. See [Attachment parser plugins](#attachment-parser-plugins).

package/bunnyquery.css

@@ -1175,6 +1175,28 @@
 .bq-message.is-assistant:not(.is-error):not(.is-cancelled):not(.bq-index-pass) .bq-bubble:has(> .bq-loader) > .bq-loader {
     vertical-align: middle;
 }
+/* The dot-trail cycles '.', '..', '...', so left to itself it is a box that
+   changes width three times every 1.2s: the bubble pulsed with it, and the
+   stop-waiting control that follows the dots moved each time, which made it hard
+   to hit. Inside a bubble the loader therefore RESERVES the width of its widest
+   frame: a hidden '...' sets the box and the animated dots are laid over it from
+   the left. Sized by the text itself rather than by a length, so it is right in
+   any font and at any letter-spacing. Scoped to bubbles on purpose: a loader that
+   trails a label ("Saving...") has to keep hugging its text. */
+.bq-bubble > .bq-loader {
+    position: relative;
+    display: inline-block;
+    white-space: nowrap;
+}
+.bq-bubble > .bq-loader::before {
+    content: '...';
+    visibility: hidden;
+}
+.bq-bubble > .bq-loader::after {
+    position: absolute;
+    left: 0;
+    top: 0;
+}
 
 .bq-message.is-error .bq-bubble {
     background: var(--bq-danger-bg);
@@ -1187,6 +1209,14 @@
     color: var(--bq-danger);
     opacity: 0.65;
 }
+/* A failed pass the worker has already sent again: real, but not the file's
+   outcome (the replacement pass is), so it is told in the muted voice of a
+   note rather than the red of a dead end. */
+.bq-message.is-error.is-retried .bq-bubble {
+    background: var(--bq-paper);
+    border-color: var(--bq-line);
+    color: var(--bq-muted);
+}
 .bq-message.is-pending-older .bq-bubble {
     background: var(--bq-warning-bg);
     border-color: var(--bq-warning-border);
@@ -1245,6 +1275,35 @@
 }
 .bq-cancel-queue-btn:hover:not(.is-disabled) { background: var(--bq-warning-bg); color: var(--bq-warning); }
 .bq-cancel-queue-btn.is-disabled { opacity: 0.3; cursor: not-allowed; pointer-events: none; }
+/* Stop waiting for a reply: sits INLINE after the dot-trail in a chat turn's own
+   "Thinking" bubble, where the bunny is inline too (:has(> .bq-loader) above).
+   Same face as the queued-message × but placed differently: that one floats to
+   its bubble's corner, this one simply follows the dots. Muted at rest so the
+   dots stay the thing the eye lands on; hover changes opacity only, never its
+   colour. Shared by both chatboxes. */
+.bq-cancel-wait-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    vertical-align: middle;
+    margin-left: 0.55rem;
+    width: 1.1rem;
+    height: 1.1rem;
+    min-height: 0;
+    padding: 0;
+    border: 1px solid var(--bq-line);
+    background: transparent;
+    color: var(--bq-muted);
+    font-size: 0.85rem;
+    line-height: 1;
+    cursor: pointer;
+    box-shadow: none;
+    border-radius: 0;
+    flex-shrink: 0;
+    opacity: 0.7;
+}
+.bq-cancel-wait-btn:hover:not(.is-disabled) { opacity: 1; }
+.bq-cancel-wait-btn.is-disabled { opacity: 0.3; cursor: not-allowed; pointer-events: none; }
 
 /* ---- unfinalized streamed answer (ask for it) ----------------------------
    A turn whose answer was streamed and never finalized keeps its bytes in the

package/bunnyquery.js

@@ -352,10 +352,15 @@ Extracted content of attached office files (read inline below; do NOT fetch thei
     const { projectId, serviceName, serviceDescription, greeting, canUpload} = params;
     const g = params.indexAccessGroup;
     const indexGroupLiteral = typeof g === "number" ? String(g) : g === "public" || g === "private" || g === "authorized" || g === "admin" ? `"${g}"` : '"authorized"';
+    const groundingRules = `ANSWER ONLY FROM THE DATA. Every fact you state about this project's data - a name, a number, a date, a status, what a document says, whether something exists - must come from one of four places: a tool result returned in THIS conversation, a file or image attached to it (including one you read through its attachment link), the project description at the end of this prompt, or what the user told you themselves in this chat. Your general knowledge, the open internet and a plausible guess are NOT sources. Never use them to answer a question about the user's data, to fill a gap in it, or to complete a record that came back partial. A value that is not in what you retrieved is unknown: say it is not in the data instead of supplying a likely one.
+WHEN THE DATA DOES NOT HAVE IT, SAY SO. Once you have searched the way these rules require and nothing answers the question, tell the user plainly, in their language, that this project's data does not contain it, and say what you searched (the tables, files or terms) so they can tell missing data from a missed search. Do not answer from memory instead, and do not turn a missing answer into a general explanation of the topic. Offer what would let you answer it: ${canUpload === false ? `another name or file to look under, or asking the project's owner to add it` : `the document to upload, or another name or file to look under`}.
+KEEP WHAT THE DATA SAYS APART FROM WHAT YOU WORKED OUT. A total you computed, a comparison, a trend, an interpretation or a recommendation is yours, not the data's: label it as such ("calculated from...", "this suggests...") and name the rows or files it was made from. Never present an estimate, an assumption or an inference as something the data states.
+These three rules govern every claim about the project's data. They do not limit the About BunnyQuery section (answer product questions from it), a greeting, or text the user explicitly asks you to write.`;
     let systemPrompt = `
 You are a dedicated assistant for the project ID: "${projectId}".
 Scope: Only answer questions about this project and its data. Do not answer questions about other projects or topics unrelated to this project. When the user refers to "my database", "my data", or "my files", treat those as references to this project's database and file storage. The ONE exception is BunnyQuery itself - what this app is, what it can do, and how to use it - which is always in scope: answer it from the "About BunnyQuery" section at the end of this prompt.
 Knowledge lookup: Before saying you don't know or that something isn't in the chat history, ALWAYS query this project's database through the available MCP tools to look for the answer. The user's data is the source of truth - the chat transcript is not. Only respond with "I don't know" or "I couldn't find that" after you have actually searched the project's data and come back empty.
+${groundingRules}
 NUMBERS FROM A SPREADSHEET: use queryGrid, never mental arithmetic over records. A total, a count, an average, a "how many mention X", a "which one is biggest" - all of those are computed server-side over EVERY row of the file and come back with the sheet, the row count and the row numbers they were made from. Records are a SAMPLE, and a sample added up is a confident wrong number. Quote the row count and the sheet alongside the figure so the reader can check it.
 CALL queryGrid describe FIRST, before any figure. Workbooks routinely state the same money more than once: a detail sheet, then per-song, per-album and per-artist sheets that each re-total it, plus a summary sheet whose bottom row is the file total. Those look like four different answers and are one. describe names which sheets restate which, and which rows are totals. Pick ONE sheet, say which you picked, and never add figures across a sheet and its summary. If the reply carries a warning about restatement, repeat it to the user.
 A FILE TOTAL IS NOT A ROW'S TOTAL. The biggest number on a summary sheet is the whole file, not the thing that was asked about. Before quoting any figure, check it is scoped to what the question named: filter by the column that identifies it and report how many rows matched.
@@ -619,6 +624,11 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     return "Something went wrong.";
   }
+  function isRetriedFailure(input) {
+    var envErr = csrEnvelopeError(input);
+    if (envErr !== void 0) input = envErr;
+    return !!input && typeof input === "object" && input.retried === true;
+  }
   function isErrorResponseBody(response) {
     var envErr = csrEnvelopeError(response);
     if (envErr !== void 0) response = envErr;
@@ -3106,8 +3116,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       var createdTs = Number(item && item.created);
       var updatedTs = Number(item && item.updated);
       var executedTs = Number(item && item.executed);
+      var respondedTs = Number(item && item.responded);
       var userTs = isFinite(createdTs) && createdTs > 0 ? createdTs : isFinite(updatedTs) && updatedTs > 0 ? updatedTs : void 0;
-      var replyTs = isFinite(updatedTs) && updatedTs > 0 ? updatedTs : isFinite(createdTs) && createdTs > 0 ? createdTs : void 0;
+      var replyTs = isFinite(respondedTs) && respondedTs > 0 ? respondedTs : isFinite(updatedTs) && updatedTs > 0 ? updatedTs : isFinite(createdTs) && createdTs > 0 ? createdTs : void 0;
       if (userText) {
         var displayContent;
         var indexFile = void 0;
@@ -3154,6 +3165,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         mapped.push(ph);
       } else if (isQueued) ; else if (isErrorResponse) {
         var em = { role: "assistant", content: getErrorMessage(response), isError: true };
+        if (isRetriedFailure(response)) em.isRetried = true;
         if (item._fromBgChain) em._fromBgChain = true;
         if (item._isBgTask) em.isBackgroundTask = true;
         if (serverItemId !== void 0) em._serverItemId = serverItemId;
@@ -3733,6 +3745,13 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       // the request budget MAX_CONCURRENT_BG_POLLS exists to protect.
       /** Live streams by server item id. One per in-flight streamed turn. */
       this.liveStreams = {};
+      /** When skapi recorded a turn's response as having finished arriving, by server
+       *  item id. Read off the terminal envelope of a STREAMED turn (the only settle
+       *  that carries it, see _settleLiveStream) and used as the answer bubble's time
+       *  in place of this browser's clock. Entries are never removed: a settle reaches
+       *  here twice (the poll's onResponse, then the promise), and the value for an id
+       *  cannot change. */
+      this._respondedAt = {};
       // ─── compact-stub hydration ─────────────────────────────────────────────
       // Split-fetch bg pages arrive as label stubs (no bodies). When the user
       // expands a row, the real reply text is fetched per item (csr-poll point
@@ -4182,7 +4201,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         timers = [];
       };
       var stopBase = base && typeof base.stop === "function" ? base.stop.bind(base) : null;
+      var resolveRaced = null;
       var raced = new Promise(function(resolve, reject) {
+        resolveRaced = resolve;
         base.then(function(res) {
           if (settled) return;
           settled = true;
@@ -4223,9 +4244,16 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         });
       });
       raced.stop = function() {
+        if (settled) return;
         settled = true;
         clearProbes();
-        if (stopBase) stopBase();
+        if (stopBase) {
+          try {
+            stopBase();
+          } catch (e) {
+          }
+        }
+        if (resolveRaced) resolveRaced({ id: itemId, status: "stopped" });
       };
       return raced;
     }
@@ -4249,6 +4277,23 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       });
       return n;
     }
+    _noteRespondedAt(itemId, response) {
+      if (!itemId || !isCsrStatusEnvelope(response)) return;
+      var at = Number(response.responded);
+      if (!isFinite(at) || at <= 0) return;
+      if (!this._respondedAt) this._respondedAt = {};
+      this._respondedAt[itemId] = at;
+    }
+    /** The time a live answer bubble is stamped with: when skapi received the
+     *  response, if the settle told us, else now. "Now" is what every bubble got
+     *  before, and it is still right for a buffered turn, whose settle hands back the
+     *  destination's body and nothing of skapi's; a history load then replaces it
+     *  with the server's value. */
+    _replyStampFor(msg) {
+      var id = msg ? msg._serverItemId : void 0;
+      var at = typeof id === "string" && id && this._respondedAt ? this._respondedAt[id] : void 0;
+      return typeof at === "number" ? at : wallClockNow();
+    }
     /**
      * Open (or re-open) the live stream for `itemId`, or null when this poll must
      * not carry one.
@@ -4438,6 +4483,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     _settleLiveStream(st, response) {
       this._closeLiveStream(st, true);
       if (!isCsrStatusEnvelope(response)) return response;
+      this._noteRespondedAt(st.id, response);
       if (response.status !== "resolved") return response;
       if (!this._mayFinalize(st)) this._rec().incomplete[st.id] = true;
       if (st.finalBody == null) return response;
@@ -5238,6 +5284,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
         return response;
       }).then(function(response) {
+        if (isPollStopped(response) || self._isCancelledPollResult(response)) return { content: "", isError: false, cancelled: true };
         if (isErrorResponseBody(response)) return { content: getErrorMessage(response), isError: true };
         var answer = params.aiPlatform === "openai" ? extractOpenAIText(response) : extractClaudeText(response);
         answer = (answer || "").trim();
@@ -5247,6 +5294,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       }).then(function(result) {
         delete self.pendingAgentRequests[params.key];
         if (dispatchItemId) self.historyItemPolls.delete(dispatchItemId);
+        if (result.cancelled) {
+          if (dispatchItemId) self._settleCancelledTurn(dispatchItemId, params.key);
+          return result;
+        }
         var reply = { role: "assistant", content: result.content, isError: result.isError };
         if (dispatchItemId) reply._serverItemId = dispatchItemId;
         self._applyReplyToCache(params.key, reply, dispatchItemId);
@@ -5725,8 +5776,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
       });
       Promise.resolve(run).catch(function() {
-      }).then(function() {
+      }).then(function(result) {
         self.state.sending = false;
+        if (result && result.cancelled) return;
         if (!(self.host.isViewMounted() && self.getHistoryCacheKey() === key)) return;
         return Promise.resolve(self.typewriteLatestReply(key)).then(function() {
           self.host.scrollToBottomIfSticky(true);
@@ -5873,7 +5925,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       return thinkingIdx !== -1 ? thinkingIdx : userIdx >= 0 ? userIdx + 1 : -1;
     }
     insertAtTarget(msg, targetIdx) {
-      if (msg && msg.role === "assistant" && msg._ts === void 0) msg._ts = wallClockNow();
+      if (msg && msg.role === "assistant" && msg._ts === void 0) msg._ts = this._replyStampFor(msg);
       var tgt = targetIdx >= 0 ? this.state.messages[targetIdx] : void 0;
       var replaceable = !!tgt && !!tgt.isPending && !tgt.isBackgroundTask && this._isOwnPlaceholderOf(targetIdx, this._owningUserIndex(targetIdx));
       if (replaceable) this.state.messages[targetIdx] = msg;
@@ -5905,6 +5957,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     onQueuedSendResponse(_composed, response, platform, serverId, ownerKey) {
       if (serverId) this.historyItemPolls.delete(serverId);
+      if (this._isCancelledPollResult(response)) {
+        if (serverId) this._settleCancelledTurn(serverId, ownerKey);
+        return;
+      }
       if (ownerKey && this.getHistoryCacheKey() !== ownerKey) {
         var offReply = isErrorResponseBody(response) ? { role: "assistant", content: getErrorMessage(response), isError: true } : { role: "assistant", content: ((platform === "openai" ? extractOpenAIText(response) : extractClaudeText(response)) || "").trim() || "No text response received from AI provider." };
         this._applyReplyToCache(ownerKey, offReply, serverId);
@@ -6104,6 +6160,191 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
       });
     }
+    /**
+     * Stop waiting for the reply to the chat turn that is running now, and move on.
+     *
+     * `msg` is the turn's pending ASSISTANT bubble (the dot-trail "Thinking"
+     * placeholder), which is where both views draw the control. A turn's two bubbles
+     * carry the same _serverItemId, so it is also how the request is found.
+     * cancelQueuedMessage is the sibling for a turn still waiting in the queue and
+     * takes the USER bubble; the two differ in what they are handed and in what has
+     * to be unwound afterwards, not in what the server is asked.
+     *
+     * What ends the wait:
+     *   1. csr-cancel marks the running row cancelled. The worker stops relaying and
+     *      never stores an answer for it, so the reply cannot turn up later on this
+     *      device or another, and history replays the turn as cancelled;
+     *   2. the poll on it is stopped, which settles whichever chain was awaiting it
+     *      with a stopped result: dispatchAgentRequest's for an immediate send, the
+     *      queued chain for a promoted turn, the history poll after a reload. Each
+     *      reads a stopped or cancelled result as "no reply" and releases what it
+     *      holds (state.sending, pendingAgentRequests, historyItemPolls), which is
+     *      what lets the next send go out immediately instead of queueing;
+     *   3. the bubbles settle at once, without waiting for that chain: the user
+     *      bubble takes its cancelled form, the placeholder goes, and the next queued
+     *      turn, if there is one, is promoted so its own "Thinking" appears.
+     *
+     * What it does NOT do: the provider call already in flight on the worker runs
+     * to its end (a streamed one stops within about a second). A message sent
+     * behind it on the same queue starts once the worker acks the cancelled row.
+     *
+     * Refused without a server id (the ack has not come back yet; the views disable
+     * the control until it has) and while a cancel is already out. Indexing passes
+     * are not this method's business: their Stop is cancelIndexingGroup, which ends
+     * the file's whole chain.
+     */
+    cancelPendingReply(msg, idx) {
+      var self = this;
+      var id = this.host.getIdentity();
+      var serverId = msg._serverItemId;
+      if (!serverId || msg._cancelling) return;
+      if (msg.role !== "assistant" || !msg.isPending || msg.isBackgroundTask) return;
+      var platform = id.platform;
+      if (platform !== "claude" && platform !== "openai") return;
+      var url = platform === "claude" ? ANTHROPIC_MESSAGES_API_URL : OPENAI_RESPONSES_API_URL;
+      var queueBase = id.userId || id.projectId;
+      var queue = msg._useBgQueue ? bgIndexingQueueName(queueBase) : queueBase;
+      var findPlaceholder = function() {
+        return self.state.messages.findIndex(function(m) {
+          return m._serverItemId === serverId && m.role === "assistant" && !!m.isPending;
+        });
+      };
+      var at = this.state.messages[idx] && this.state.messages[idx]._serverItemId === serverId && this.state.messages[idx].role === "assistant" ? idx : findPlaceholder();
+      if (at !== -1) {
+        this.state.messages[at] = Object.assign({}, this.state.messages[at], { _cancelling: true, _cancelError: void 0 });
+      }
+      this.host.notify();
+      var unmark = function(errMsg) {
+        var ci = findPlaceholder();
+        if (ci === -1) return;
+        self.state.messages[ci] = Object.assign({}, self.state.messages[ci], { _cancelling: false, _cancelError: errMsg });
+        self.host.notify();
+      };
+      Promise.resolve(this.host.cancelRequest({
+        url,
+        method: "POST",
+        id: serverId,
+        queue,
+        service: id.projectId,
+        owner: id.owner
+      })).then(function(result) {
+        if (result && result.removed) {
+          self._stopPoll(serverId);
+          self._settleCancelledTurn(serverId);
+          return;
+        }
+        unmark(void 0);
+      }).catch(function(err) {
+        unmark(err && typeof err.message === "string" && err.message ? err.message : "Could not stop this request.");
+      });
+    }
+    /** The cancelled form of a request bubble, with everything that keeps it in
+     *  place carried over: the file markers that hold an indexing pass in its
+     *  collapsed row, the chat it belongs to, its send time and its render key. */
+    _cancelledCopyOf(m, itemId) {
+      var cancelled = { role: "user", content: m.content, isCancelled: true };
+      if (itemId !== void 0) cancelled._serverItemId = itemId;
+      else if (m._serverItemId !== void 0) cancelled._serverItemId = m._serverItemId;
+      if (m.isBackgroundTask) cancelled.isBackgroundTask = true;
+      if (m._indexFile) cancelled._indexFile = m._indexFile;
+      if (m._useBgQueue) cancelled._useBgQueue = true;
+      if (m._ownerKey !== void 0) cancelled._ownerKey = m._ownerKey;
+      if (m._ts !== void 0) cancelled._ts = m._ts;
+      if (m._localId !== void 0) cancelled._localId = m._localId;
+      return cancelled;
+    }
+    /**
+     * Settle a turn as cancelled wherever it lives, and let the queue move on.
+     *
+     * On the chat on screen: every pending placeholder carrying the id goes (a
+     * history refetch can have re-mapped the running turn into a second one), the
+     * request bubble takes its cancelled form, and the next queued turn is promoted
+     * so the conversation does not sit on an "(In queue)" bubble with nothing
+     * running. For a chat that is NOT on screen (the user moved on while the turn
+     * ran, and it was cancelled from elsewhere) the same edit is made in that chat's
+     * history cache, which is what the next visit renders.
+     *
+     * Idempotent on purpose: a cancel this client made settles the bubbles at once,
+     * and the chain that was awaiting the poll settles again a moment later when the
+     * stop resolves it. The second pass finds nothing to do. Deliberately NOT
+     * _removeStrayPendingAssistants: by then the placeholder on screen is the freshly
+     * promoted turn's, whose user bubble is pending, and the sweep would take it.
+     */
+    _settleCancelledTurn(itemId, ownerKey) {
+      if (!itemId) return;
+      if (ownerKey && this.getHistoryCacheKey() !== ownerKey) {
+        this._applyCancelToCache(ownerKey, itemId);
+        return;
+      }
+      var changed = false, wasBg = false;
+      for (var i = this.state.messages.length - 1; i >= 0; i--) {
+        var m = this.state.messages[i];
+        if (!m || m._serverItemId !== itemId) continue;
+        if (m.role === "assistant" && m.isPending) {
+          this.state.messages.splice(i, 1);
+          changed = true;
+          continue;
+        }
+        if (m.role === "user" && !m.isCancelled) {
+          if (m.isBackgroundTask) wasBg = true;
+          this.state.messages[i] = this._cancelledCopyOf(m, itemId);
+          changed = true;
+        }
+      }
+      this.cancelledServerIds.delete(itemId);
+      if (!changed) return;
+      if (wasBg) this.promoteNextBgQueuedToRunning();
+      else this.promoteNextQueuedToRunning();
+      this.updateHistoryCache();
+      this.host.notify();
+    }
+    /**
+     * _settleCancelledTurn for a chat that is not on screen: the same edit, made in
+     * its history cache. Matched by id where the cached bubbles carry one; an
+     * off-chat send caches its pair before the ack (see dispatchComposedMessage), so
+     * the fallback is positional, exactly as _applyReplyToCache's is: the trailing
+     * pending placeholder, and the last request bubble still marked in flight.
+     */
+    _applyCancelToCache(key, itemId) {
+      var existing = key ? this.aiChatHistoryCache[key] : void 0;
+      if (!existing) return;
+      var msgs = existing.messages.slice();
+      var changed = false;
+      var pIdx = -1, uIdx = -1;
+      for (var i = msgs.length - 1; i >= 0; i--) {
+        var m = msgs[i];
+        if (!m || m._serverItemId !== itemId) continue;
+        if (m.role === "assistant" && m.isPending) {
+          msgs.splice(i, 1);
+          changed = true;
+          pIdx = i;
+        } else if (m.role === "user" && !m.isCancelled && uIdx === -1) uIdx = i;
+      }
+      if (pIdx === -1) {
+        for (var p = msgs.length - 1; p >= 0; p--) {
+          var pm = msgs[p];
+          if (!pm || !pm.isPending || pm.role !== "assistant" || pm.isBackgroundTask || pm._serverItemId !== void 0) continue;
+          msgs.splice(p, 1);
+          changed = true;
+          break;
+        }
+      }
+      if (uIdx === -1) {
+        for (var u = msgs.length - 1; u >= 0; u--) {
+          var um = msgs[u];
+          if (!um || um.role !== "user" || um.isBackgroundTask || um._serverItemId !== void 0 || um._stageId) continue;
+          if (!(um.isPendingQueued || um.isPendingInProcess || um.isSendingToServer)) continue;
+          uIdx = u;
+          break;
+        }
+      }
+      if (uIdx !== -1) {
+        msgs[uIdx] = this._cancelledCopyOf(msgs[uIdx], itemId);
+        changed = true;
+      }
+      if (!changed) return;
+      this.aiChatHistoryCache[key] = { messages: msgs, endOfList: existing.endOfList, startKeyHistory: existing.startKeyHistory };
+    }
     /**
      * Stop indexing a file, from its collapsed row — every pass at once, not just
      * the bubble the user happens to see.
@@ -6170,6 +6411,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
       }
       this._adoptWorkerIndexingPasses(0);
+      this._sweepCancelledIndexing();
       var ids = group.cancellableIds || [];
       if (!ids.length) {
         this.host.notify();
@@ -6306,7 +6548,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     enqueueTypewrite(idx, fullText, localId, paintedText) {
       var self = this;
       var target = this.state.messages[idx];
-      if (target && target._ts === void 0) target._ts = wallClockNow();
+      if (target && target._ts === void 0) target._ts = this._replyStampFor(target);
       if (!this.typewriterQueue) this.typewriterQueue = Promise.resolve();
       this.typewriterQueue = this.typewriterQueue.then(function() {
         return self.typewriteIntoIndex(idx, fullText, localId, paintedText);
@@ -6452,9 +6694,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       this.state.sending = true;
       this.host.scrollToBottomIfSticky(true);
       return Promise.resolve(pending).catch(function() {
-      }).then(function() {
+      }).then(function(result) {
         if (token !== self.state.gateRefreshToken) return;
         self.state.sending = false;
+        if (result && result.cancelled) return;
         return Promise.resolve(self.typewriteLatestReply(key)).then(function() {
           self.host.scrollToBottomIfSticky(true);
         });
@@ -8083,8 +8326,19 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       } else if (stopped) {
         grp.status = "cancelled";
       } else {
-        var last = grp.members[grp.members.length - 1].msg;
-        grp.status = last.isError ? "error" : "done";
+        var retriedIds = {};
+        for (var ri = 0; ri < grp.members.length; ri++) {
+          var rm = grp.members[ri].msg;
+          if (rm.isRetried && rm._serverItemId) retriedIds[rm._serverItemId] = true;
+        }
+        var li = grp.members.length - 1;
+        while (li >= 0 && (grp.members[li].msg.isRetried || grp.members[li].msg._serverItemId && retriedIds[grp.members[li].msg._serverItemId])) li--;
+        if (li < 0) {
+          grp.status = "active";
+        } else {
+          var last = grp.members[li].msg;
+          grp.status = last.isError ? "error" : "done";
+        }
       }
       var sawFirstPass = false;
       for (var pi = 0; pi < grp.members.length; pi++) {
@@ -8374,7 +8628,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   (function() {
     var MCP_PROD = "https://mcp.broadwayinc.computer";
     var MCP_DEV = "https://mcp-dev.broadwayinc.computer";
-    var BQ_VERSION = "1.11.1" ;
+    var BQ_VERSION = "1.13.0" ;
     var ATTACHMENT_URL_EXPIRES_SECONDS = 600;
     var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
     var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
@@ -11657,12 +11911,29 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       var cls = ["bq-message"];
       cls.push(msg.role === "user" ? "is-user" : "is-assistant");
       if (msg.isError) cls.push("is-error");
+      if (msg.isRetried) cls.push("is-retried");
       if (msg.isCancelled) cls.push("is-cancelled");
       if (msg.isPendingQueued || msg.isPendingOlder) cls.push("is-pending-older");
       if (msg._dimSending || msg._cancelling) cls.push("is-sending-to-server");
       var bubble;
       if (msg.isPending && !msg._streaming || streamRecoveryPhase(msg) === "active") {
         bubble = h("div", { class: "bq-bubble" }, h("span", { class: "bq-loader" }));
+        if (msg.role === "assistant" && !msg.isBackgroundTask && !streamRecoveryPhase(msg)) {
+          var waitDisabled = !msg._serverItemId || msg._cancelling;
+          var stopWaitBtn = h("button", {
+            class: "bq-cancel-wait-btn" + (waitDisabled ? " is-disabled" : ""),
+            type: "button",
+            title: "Stop waiting for this reply",
+            "aria-label": "Stop waiting for this reply",
+            html: "&times;"
+          });
+          if (!waitDisabled) stopWaitBtn.addEventListener("click", function(e) {
+            e.stopPropagation();
+            session.cancelPendingReply(msg, idx);
+          });
+          bubble.appendChild(stopWaitBtn);
+          if (msg._cancelError) bubble.appendChild(h("span", { class: "bq-cancel-error", text: msg._cancelError }));
+        }
       } else if (streamRecoveryPhase(msg)) {
         var labels = streamRecoveryLabels(streamRecoveryPhase(msg));
         bubble = h("div", { class: "bq-bubble is-stream-recover" + (streamRecoveryPhase(msg) === "failed" ? " is-stream-failed" : "") });
@@ -11933,6 +12204,42 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       }
       return byFile;
     }
+    var stopIndexOthers = { checked: false, row: null, text: null, box: null };
+    function otherStoppableIndexGroups(target) {
+      if (!target) return [];
+      var list = buildChatDisplayList(CS.messages, displayListOptions());
+      var others = [];
+      for (var i = 0; i < list.length; i++) {
+        var row = list[i];
+        if (row.kind !== "indexing") continue;
+        if (!indexGroupStoppable(row.group) || row.group.key === target.key) continue;
+        others.push(row.group);
+      }
+      return others;
+    }
+    function countIndexFiles(groups) {
+      var seen = {}, n = 0;
+      for (var i = 0; i < groups.length; i++) {
+        if (seen[groups[i].key]) continue;
+        seen[groups[i].key] = true;
+        n++;
+      }
+      return n;
+    }
+    function stopOthersLabel(n) {
+      return n === 1 ? "Also stop the other file being indexed" : "Also stop the " + n + " other files being indexed";
+    }
+    function refreshStopIndexOthers() {
+      if (!stopIndexOthers.row) return;
+      var n = countIndexFiles(otherStoppableIndexGroups(findCancellableIndexGroup(stopIndexState.runKey, stopIndexState.fileKey)));
+      if (!n) {
+        stopIndexOthers.checked = false;
+        if (stopIndexOthers.box) stopIndexOthers.box.checked = false;
+      } else if (stopIndexOthers.text) {
+        stopIndexOthers.text.textContent = stopOthersLabel(n);
+      }
+      stopIndexOthers.row.style.display = n ? "" : "none";
+    }
     function stopIndexModalIsOpen() {
       var hnd = stopIndexState.handle;
       if (hnd && hnd.root && hnd.root.parentNode) return true;
@@ -11951,6 +12258,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     function syncStopIndexModal() {
       if (!stopIndexModalIsOpen()) return;
       if (!findCancellableIndexGroup(stopIndexState.runKey, stopIndexState.fileKey)) closeStopIndexModal();
+      else refreshStopIndexOthers();
     }
     function openStopIndexModal(group) {
       if (!indexGroupStoppable(group)) return;
@@ -11963,10 +12271,24 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         stopBtn.addEventListener("click", function() {
           var runKey = stopIndexState.runKey;
           var fileKey = stopIndexState.fileKey;
+          var alsoOthers = stopIndexOthers.checked;
           closeStopIndexModal();
           var live = findCancellableIndexGroup(runKey, fileKey);
+          var others = alsoOthers ? otherStoppableIndexGroups(live) : [];
           if (live) session.cancelIndexingGroup(live);
+          for (var oi = 0; oi < others.length; oi++) session.cancelIndexingGroup(others[oi]);
+        });
+        var othersBox = h("input", { type: "checkbox" });
+        othersBox.addEventListener("change", function() {
+          stopIndexOthers.checked = !!othersBox.checked;
         });
+        var othersText = h("span");
+        var othersRow = h("label", { class: "bq-overwrite-applyall" }, othersBox, othersText);
+        stopIndexOthers.checked = false;
+        stopIndexOthers.box = othersBox;
+        stopIndexOthers.text = othersText;
+        stopIndexOthers.row = othersRow;
+        refreshStopIndexOthers();
         return h(
           "div",
           { class: "bq-modal" },
@@ -11986,6 +12308,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             { class: "bq-modal-desc bq-modal-delete-warn" },
             "Whatever has been indexed so far stays searchable, and the pass already running finishes on the server. The remaining passes are dropped, not paused, so the file stays partly indexed until you reindex it."
           ),
+          othersRow,
           h(
             "div",
             { class: "bq-modal-btns" },