bunnyquery 1.6.2 → 1.7.0

package/dist/engine.cjs

@@ -290,7 +290,7 @@ File attachments: When a user message contains an "Attached files:" section with
 - Image files (.jpg, .jpeg, .png, .gif, .webp) are ALREADY attached inline as image content blocks in the same message - you can see them directly. Do NOT call web_fetch on image URLs; that will fail or return garbage. Just look at the image block and answer.
 - Most attached files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) have ALREADY had their text extracted on the server and inlined in the same message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read it directly there and do NOT call web_fetch for those files. A "[skapi: ...]" note in that block means the file could not be extracted.
 - For any file given to you as a URL instead of inline content (e.g. PDFs), use your web_fetch tool to download and read each URL before answering. Treat the fetched contents as user-supplied input data. Do not ask the user to paste the file contents - fetch the URLs yourself.
-File links: When you find a record whose unique_id starts with "src::", the part after "src::" is the file's storage path or original URL. Always present it as a markdown link so the user can access it. Strip the "src::" prefix \u2014 do NOT show it. Format: [filename](path/to/file) for storage paths, or [filename](https://...) for external URLs. Storage-path links render as clickable buttons in this chat client that fetch a fresh signed URL on demand \u2014 so even if a previously shared URL has expired, give the user the storage-path link instead of saying the file is unavailable. Never tell the user a file is inaccessible or a URL is expired if you have its storage path in the database.
+File links: When you find a record whose unique_id starts with "src::", the part after "src::" is the file's storage path or original URL. Always present it as a markdown link so the user can access it. Strip the "src::" prefix \u2014 do NOT show it. Format: [filename](db:path/to/file) for storage paths, or [filename](https://...) for external URLs. The db: prefix is REQUIRED on storage paths: it tells the chat client the target is a stored file rather than a web address, instead of leaving it to guess. Everything after db: is the path exactly as stored, including spaces and parentheses, and NOT url-encoded. Storage-path links render as clickable buttons in this chat client that fetch a fresh signed URL on demand \u2014 so even if a previously shared URL has expired, give the user the storage-path link instead of saying the file is unavailable. Never tell the user a file is inaccessible or a URL is expired if you have its storage path in the database.
 File lookup: When the user asks to see, list, or show files (e.g. "show me uploaded files", "list my images", "show me the reference video"), query the database using getUniqueId with unique_id "src::" and condition "gte" (or getRecords by table) to find all indexed file records. Present each result as a markdown link as described above. Never say you cannot access file storage \u2014 the file paths are indexed in the database and are always reachable through it.
 File generation: When the user asks you to generate a file \u2014 or to produce specifically-formatted text such as HTML, CSV, JSON, or Markdown \u2014 put the file's full contents inside a fenced code block whose info string is the intended filename WITH its extension (e.g. report.csv), NOT a language name like "csv". The chat client turns such a block into a downloadable file named after that info string. Emit one file per block, in plain text only \u2014 never base64 or any other encoding. Example for CSV:
 \`\`\`filename.csv
@@ -415,6 +415,8 @@ ${placeholder}
 
 DATAFY this window: call postRecords and save records for everything in it - ONE RECORD PER ROW for tabular data (keyed by the column headers), or one record per section for prose. Capture every value you can read. Use the storage path above for the "src::" unique_id on the file-level record, and link every row/section record to it by reference.
 
+If this window has PHOTOS attached as images, LOOK at each one and datafy what it actually shows into the record for the row it is anchored to (a \xABPHOTO A88\xBB marker in the grid text only says WHERE a picture sits - the picture itself is attached to this message). Never report that photo contents could not be extracted when images are attached here.
+
 Save records for THIS window only, then stop and report what you saved. Do NOT try to read the rest of the file, and do NOT call readFileContent - if more remains, the next window is read and sent to you automatically. Report only what you were actually shown, and never imply you have seen the whole file when the note beside the window says more remains.`;
 }
 function buildIndexingContinueMessage(attachment) {
@@ -525,8 +527,10 @@ function isAuthExpiredError(input) {
 var EXPIRED_ATTACHMENT_URL_HOST = "_expired_.url";
 var EXPIRED_ATTACHMENT_URL_ORIGIN = "https://" + EXPIRED_ATTACHMENT_URL_HOST;
 var LINK_LABEL_MAX_DISPLAY_CHARS = 32;
+var EXPIRED_LINK_REFRESH_EXPIRES_SECONDS = 20 * 60;
+var LINK_REFRESH_WINDOW_MS = (EXPIRED_LINK_REFRESH_EXPIRES_SECONDS - 5 * 60) * 1e3;
 function createInlineLinkRegex() {
-  return /src::(\S+)|\[([^\]\n]+)\]\((https?:\/\/(?:[^\s()]+|\([^\s()]*\))+)\)|\[([^\]\n]+)\]\(((?:[^()\n]+|\([^()\n]*\))+)\)|(https?:\/\/[^\s<>"']+)/g;
+  return /src::(\S+)|\[([^\]\n]+)\]\((https?:\/\/(?:[^\s()]|\([^\s()]*\))+)\)|\[([^\]\n]+)\]\(((?:[^()\n]|\([^()\n]*\))+)\)|(https?:\/\/[^\s<>"']+)/g;
 }
 function safeDecodeURIComponent(v) {
   try {
@@ -586,18 +590,150 @@ function isServiceDbAttachmentHref(href, serviceId) {
     return false;
   }
 }
+function readExpiredAttachmentHref(href) {
+  if (!href) return null;
+  try {
+    var parsed = new URL(href);
+    if (parsed.hostname !== EXPIRED_ATTACHMENT_URL_HOST) return null;
+    return normalizeAttachmentPathCandidate(parsed.pathname || "") || null;
+  } catch (e) {
+    return null;
+  }
+}
 function sanitizeAttachmentLinksForHistory(content, serviceId, forAssistant) {
   if (!content) return content;
   if (!forAssistant && content.indexOf("Attached files:") === -1) return content;
   return content.replace(/\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)/g, function(_m, label, href) {
-    if (forAssistant && !isServiceDbAttachmentHref(href, serviceId)) return _m;
+    if (!isServiceDbAttachmentHref(href, serviceId)) return _m;
     var remotePath = extractRemotePathFromAttachmentHref(href, serviceId);
-    var labelPath = normalizeAttachmentPathCandidate(label);
-    var fullPath = remotePath || labelPath;
-    if (!fullPath) return forAssistant ? _m : "[" + label + "](" + EXPIRED_ATTACHMENT_URL_ORIGIN + "/file)";
+    var fullPath = remotePath || normalizeAttachmentPathCandidate(label);
+    if (!fullPath) return _m;
     return "[" + label + "](" + buildDisplayExpiredAttachmentHref(fullPath, label) + ")";
   });
 }
+function isHttpUrlLike(target) {
+  return /^https?:\/\//i.test((target || "").trim());
+}
+function repairUrlWhitespace(href) {
+  if (!href || !/\s/.test(href)) return href;
+  var stripped = href.replace(/\s+/g, "");
+  if (/^https?:\/\/[^/\s]+\/download\/[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)?$/i.test(stripped)) return stripped;
+  return href.trim().replace(/\s/g, "%20");
+}
+function normalizeTrailingInlineToken(value) {
+  if (!value) return value;
+  var out = value.replace(/[.,;:!?]+$/, "");
+  var trimUnmatched = function(openCh, closeCh) {
+    while (out.charAt(out.length - 1) === closeCh) {
+      var openCount = (out.match(new RegExp("\\" + openCh, "g")) || []).length;
+      var closeCount = (out.match(new RegExp("\\" + closeCh, "g")) || []).length;
+      if (closeCount > openCount) out = out.slice(0, -1);
+      else break;
+    }
+  };
+  trimUnmatched("(", ")");
+  trimUnmatched("[", "]");
+  trimUnmatched("{", "}");
+  out = out.replace(/[`'"*>]+$/, "");
+  return out;
+}
+function classifyInlineLink(full, groups, ctx) {
+  var g1 = groups[0], g2 = groups[1], g3 = groups[2], g4 = groups[3], g5 = groups[4], g6 = groups[5];
+  var dbHostPrefix = (ctx.dbHostPrefix || "").toLowerCase();
+  var fresh = function(expiredHref) {
+    return ctx.resolveFreshHref ? ctx.resolveFreshHref(expiredHref) : void 0;
+  };
+  var isDbHost = function(url) {
+    return !!dbHostPrefix && url.toLowerCase().indexOf(dbHostPrefix) === 0;
+  };
+  var asStoredFile = function(remotePath2, label) {
+    if (!remotePath2) return null;
+    var expiredHref = buildDisplayExpiredAttachmentHref(remotePath2, label);
+    var cached = fresh(expiredHref);
+    return {
+      part: {
+        type: "link",
+        label: truncateLabelForDisplay(label),
+        fullLabel: label,
+        href: cached || expiredHref,
+        expired: !cached,
+        expiredHref,
+        remotePath: remotePath2
+      }
+    };
+  };
+  if (g1) {
+    var rawPath = normalizeTrailingInlineToken(g1);
+    var tail = full.slice(("src::" + rawPath).length);
+    var srcIsUrl = isHttpUrlLike(rawPath);
+    if (srcIsUrl && !isDbHost(rawPath) && !readExpiredAttachmentHref(rawPath)) {
+      return {
+        part: { type: "link", label: truncateLabelForDisplay(rawPath), fullLabel: rawPath, href: rawPath, expired: false },
+        tail
+      };
+    }
+    var srcPath = readExpiredAttachmentHref(rawPath) || (srcIsUrl ? extractRemotePathFromAttachmentHref(rawPath, ctx.serviceId) || normalizeAttachmentPathCandidate(rawPath) : normalizeAttachmentPathCandidate(rawPath));
+    var srcBuilt = asStoredFile(srcPath, srcPath);
+    return srcBuilt ? { part: srcBuilt.part, tail } : null;
+  }
+  if (g4 && g5) {
+    var dbTarget = /^db:(.+)$/i.exec(g5.trim());
+    if (dbTarget) {
+      var declared = asStoredFile(normalizeAttachmentPathCandidate(dbTarget[1]), g4);
+      if (!declared) return null;
+      declared.part.label = truncateLabelForDisplay(g4);
+      declared.part.fullLabel = g4;
+      return declared;
+    }
+    if (isHttpUrlLike(g5)) {
+      return classifyInlineLink(full, [void 0, g4, repairUrlWhitespace(g5), void 0, void 0, void 0], ctx);
+    }
+    var trimmedTarget = g5.trim();
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmedTarget) || trimmedTarget.charAt(0) === "#") {
+      return {
+        part: { type: "link", label: truncateLabelForDisplay(g4), fullLabel: g4, href: trimmedTarget, expired: false }
+      };
+    }
+    var built = asStoredFile(normalizeAttachmentPathCandidate(g5), g4);
+    if (!built) return null;
+    built.part.label = truncateLabelForDisplay(g4);
+    built.part.fullLabel = g4;
+    return built;
+  }
+  var originalHref = g3 || g6 || "";
+  if (!originalHref) return null;
+  var urlTail;
+  if (!g3 && g6) {
+    var trimmedUrl = normalizeTrailingInlineToken(originalHref);
+    if (trimmedUrl !== originalHref) urlTail = originalHref.slice(trimmedUrl.length);
+    originalHref = trimmedUrl;
+  }
+  var withTail = function(r) {
+    return urlTail ? { part: r.part, tail: urlTail } : r;
+  };
+  var urlLabel = g2 || originalHref;
+  var carried = readExpiredAttachmentHref(originalHref);
+  if (carried) {
+    var carriedBuilt = asStoredFile(carried, g2 || carried);
+    if (carriedBuilt) {
+      if (g2) {
+        carriedBuilt.part.label = truncateLabelForDisplay(g2);
+        carriedBuilt.part.fullLabel = g2;
+      }
+      return withTail(carriedBuilt);
+    }
+  }
+  if (isServiceDbAttachmentHref(originalHref, ctx.serviceId)) {
+    var remotePath = extractRemotePathFromAttachmentHref(originalHref, ctx.serviceId);
+    if (remotePath) {
+      var dbBuilt = asStoredFile(remotePath, getExpiredAttachmentVisiblePath(remotePath, urlLabel));
+      if (dbBuilt) return withTail(dbBuilt);
+    }
+  }
+  return withTail({
+    part: { type: "link", label: truncateLabelForDisplay(urlLabel), fullLabel: urlLabel, href: originalHref, expired: false }
+  });
+}
 function truncateLabelForDisplay(label) {
   if (!label) return label;
   if (label.length <= LINK_LABEL_MAX_DISPLAY_CHARS) return label;
@@ -683,7 +819,7 @@ var DEFAULT_OPENAI_IMAGE_DETAIL = "auto";
 var OPENAI_WEB_SEARCH_EXTERNAL_WEB_ACCESS = true;
 var MCP_NAME = "BunnyQuery";
 var DEFAULT_CLAUDE_MODEL = "claude-sonnet-4-6";
-var DEFAULT_OPENAI_MODEL = "gpt-5.4";
+var DEFAULT_OPENAI_MODEL = "gpt-5.6-luna";
 var mcpUrl = () => chatEngineConfig().mcpBaseUrl;
 var clientSecretRequest = (opts) => chatEngineConfig().clientSecretRequest(opts);
 var getOpenAIImageDetail = (model) => {
@@ -1229,18 +1365,29 @@ function mapHistoryListToMessages(list, platform, opts) {
     var serverItemId = item && typeof item.id === "string" && item.id ? item.id : void 0;
     if (userText) {
       var displayContent;
+      var indexFile = void 0;
       if (item._isBgTask) {
         var nameMatch = userText.match(/^- name: (.+)$/m);
         if (nameMatch) {
           var mimeMatch = userText.match(/^- mime type: (.+)$/m);
           var sizeMatch = userText.match(/^- size \(bytes\): (\d+)$/m);
           var pathMatch = userText.match(/^- storage path: (.+)$/m);
+          var isContinuePass = userText.indexOf("CONTINUE indexing") === 0;
           displayContent = opts.formatIndexingLabel(
             nameMatch[1].trim(),
             mimeMatch ? mimeMatch[1].trim() : "",
             sizeMatch ? Number(sizeMatch[1]) : null,
-            pathMatch ? pathMatch[1].trim() : void 0
+            pathMatch ? pathMatch[1].trim() : void 0,
+            false,
+            isContinuePass
           );
+          indexFile = {
+            name: nameMatch[1].trim(),
+            path: pathMatch ? pathMatch[1].trim() : void 0,
+            mime: mimeMatch ? mimeMatch[1].trim() : void 0,
+            size: sizeMatch ? Number(sizeMatch[1]) : void 0,
+            continued: isContinuePass
+          };
         } else {
           displayContent = userText;
         }
@@ -1252,6 +1399,7 @@ function mapHistoryListToMessages(list, platform, opts) {
       if (isQueued) userMsg.isPendingQueued = true;
       if (isCancelledItem) userMsg.isCancelled = true;
       if (item._isBgTask) userMsg.isBackgroundTask = true;
+      if (indexFile) userMsg._indexFile = indexFile;
       if (item._isOnBgQueue) userMsg._useBgQueue = true;
       if (serverItemId !== void 0) userMsg._serverItemId = serverItemId;
       mapped.push(userMsg);
@@ -1279,6 +1427,91 @@ function mapHistoryListToMessages(list, platform, opts) {
   return { messages: mapped, runningItemIds };
 }
 
+// src/engine/viewport_fill.ts
+var HISTORY_FILL_SLACK_PX = 64;
+var MAX_HISTORY_FILL_PAGES = 24;
+var IDLE_WAIT_STEP_MS = 120;
+var IDLE_WAIT_MAX_MS = 15e3;
+async function waitForIdle(opts, stale) {
+  var waited = 0;
+  while (opts.isLoading()) {
+    if (stale() || waited >= IDLE_WAIT_MAX_MS) return false;
+    await new Promise(function(r) {
+      setTimeout(r, IDLE_WAIT_STEP_MS);
+    });
+    waited += IDLE_WAIT_STEP_MS;
+  }
+  return !stale();
+}
+async function fillHistoryViewport(opts) {
+  var maxPages = typeof opts.maxPages === "number" ? opts.maxPages : MAX_HISTORY_FILL_PAGES;
+  var stale = function() {
+    return !!(opts.isStale && opts.isStale());
+  };
+  var swallowed = 0;
+  for (var page = 0; page < maxPages; page++) {
+    if (stale() || opts.isEndOfList()) return;
+    if (!await waitForIdle(opts, stale)) return;
+    var satisfied = false;
+    try {
+      satisfied = !!await opts.isSatisfied();
+    } catch {
+      return;
+    }
+    if (satisfied || stale()) return;
+    if (!await waitForIdle(opts, stale)) return;
+    var before = opts.messageCount();
+    var attempted;
+    try {
+      attempted = await opts.fetchOlder();
+    } catch {
+      return;
+    }
+    if (stale()) return;
+    if (attempted === false) {
+      if (++swallowed > 3) return;
+      page--;
+      continue;
+    }
+    if (opts.messageCount() <= before) return;
+  }
+}
+function createHistoryFiller(base) {
+  var pending = [];
+  var running = false;
+  async function allSatisfied() {
+    var next = [];
+    for (var i = 0; i < pending.length; i++) {
+      if (!await pending[i]()) next.push(pending[i]);
+    }
+    pending = next;
+    return pending.length === 0;
+  }
+  return {
+    isRunning: function() {
+      return running;
+    },
+    fill: function(isSatisfied) {
+      pending.push(isSatisfied);
+      if (running) return Promise.resolve();
+      running = true;
+      var done = function() {
+        running = false;
+        pending = [];
+      };
+      return fillHistoryViewport({
+        isSatisfied: allSatisfied,
+        isEndOfList: base.isEndOfList,
+        isLoading: base.isLoading,
+        messageCount: base.messageCount,
+        fetchOlder: base.fetchOlder,
+        isStale: base.isStale,
+        maxPages: base.maxPages
+      }).then(done, done);
+    }
+  };
+}
+
 // src/engine/session.ts
 var _g = typeof globalThis !== "undefined" ? globalThis : {};
 function nowMs() {
@@ -1316,6 +1549,7 @@ var ChatSession = class {
     };
     this.bgTaskQueue = [];
     this.cancelledServerIds = /* @__PURE__ */ new Set();
+    this.cancelledIndexKeys = /* @__PURE__ */ new Set();
     this.pendingAgentRequests = {};
     this.aiChatHistoryCache = {};
     this.historyItemPolls = /* @__PURE__ */ new Map();
@@ -1338,6 +1572,23 @@ var ChatSession = class {
     this.historyItemPolls.set(id, { kind, stop });
     return p;
   }
+  /**
+   * Stop and forget one item's poll. Used after a cancel: the row is either gone
+   * (cancelled while queued) or flagged cancelled (cancelled while running), so
+   * asking about it again only burns requests. Safe when no poll is attached, and
+   * safe on an older skapi-js with no stop handle (the entry is then LEFT in the
+   * map so a later drain cannot stack a second, unstoppable poll on the id).
+   */
+  _stopPoll(id) {
+    var handle = this.historyItemPolls.get(id);
+    if (!handle) return;
+    if (typeof handle.stop !== "function") return;
+    try {
+      handle.stop();
+    } catch (e) {
+    }
+    this.historyItemPolls.delete(id);
+  }
   /** True while any pause reason is active. */
   isPollingPaused() {
     return this._pauseReasons.size > 0;
@@ -1440,7 +1691,18 @@ var ChatSession = class {
       if (reply._serverItemId === void 0 && msgs[thIdx]._serverItemId !== void 0) reply._serverItemId = msgs[thIdx]._serverItemId;
       msgs[thIdx] = reply;
     } else {
-      msgs.push(reply);
+      var dupIdx = -1;
+      if (serverId) {
+        for (var d = msgs.length - 1; d >= 0; d--) {
+          var dm = msgs[d];
+          if (dm && dm.role === "assistant" && dm._serverItemId === serverId) {
+            dupIdx = d;
+            break;
+          }
+        }
+      }
+      if (dupIdx !== -1) msgs[dupIdx] = reply;
+      else msgs.push(reply);
     }
     for (var j = 0; j < msgs.length; j++) {
       var u = msgs[j];
@@ -1680,7 +1942,7 @@ var ChatSession = class {
       self.state.sending = false;
       if (!(self.host.isViewMounted() && self.getHistoryCacheKey() === key)) return;
       return Promise.resolve(self.typewriteLatestReply(key)).then(function() {
-        self.host.scrollToBottom(true);
+        self.host.scrollToBottomIfSticky(true);
       });
     });
   }
@@ -1694,6 +1956,7 @@ var ChatSession = class {
     if (nextIdx === -1) return;
     var existing = this.state.messages[nextIdx];
     var promoted = { role: "user", content: existing.content, isPendingInProcess: true, isBackgroundTask: true };
+    if (existing._indexFile) promoted._indexFile = existing._indexFile;
     if (existing._serverItemId !== void 0) promoted._serverItemId = existing._serverItemId;
     if (existing._ownerKey !== void 0) promoted._ownerKey = existing._ownerKey;
     this.state.messages[nextIdx] = promoted;
@@ -1714,6 +1977,7 @@ var ChatSession = class {
     var existing = this.state.messages[nextIdx];
     var promoted = { role: "user", content: existing.content, isPendingInProcess: true };
     if (existing.isBackgroundTask) promoted.isBackgroundTask = true;
+    if (existing._indexFile) promoted._indexFile = existing._indexFile;
     if (existing._serverItemId !== void 0) promoted._serverItemId = existing._serverItemId;
     if (existing._ownerKey !== void 0) promoted._ownerKey = existing._ownerKey;
     if (existing.isSendingToServer) promoted.isSendingToServer = true;
@@ -1814,7 +2078,7 @@ var ChatSession = class {
     this.promoteNextQueuedToRunning();
     this.updateHistoryCache();
     this.host.notify();
-    this.host.scrollToBottom(true);
+    this.host.scrollToBottomIfSticky(true);
   }
   onQueuedSendError(_composed, err, serverId, ownerKey) {
     if (serverId) this.historyItemPolls.delete(serverId);
@@ -1864,7 +2128,7 @@ var ChatSession = class {
       this.promoteNextQueuedToRunning();
       this.updateHistoryCache();
       this.host.notify();
-      this.host.scrollToBottom(true);
+      this.host.scrollToBottomIfSticky(true);
       return;
     }
     var targetIdx = this.resolveQueuedUserBubble(serverId);
@@ -1878,7 +2142,7 @@ var ChatSession = class {
     this.promoteNextQueuedToRunning();
     this.updateHistoryCache();
     this.host.notify();
-    this.host.scrollToBottom(true);
+    this.host.scrollToBottomIfSticky(true);
   }
   cancelQueuedMessage(msg, idx) {
     var self = this;
@@ -1902,6 +2166,7 @@ var ChatSession = class {
     })).then(function(result) {
       if (result && result.removed) {
         self.cancelledServerIds.add(serverId);
+        self._stopPoll(serverId);
         var qi = self.bgTaskQueue.findIndex(function(e) {
           return e.id === serverId;
         });
@@ -1910,7 +2175,13 @@ var ChatSession = class {
           return m._serverItemId === serverId && (m.isPendingQueued || m.isPendingInProcess) && m.role === "user";
         });
         if (removeIdx !== -1) {
-          self.state.messages[removeIdx] = { role: "user", content: self.state.messages[removeIdx].content, isCancelled: true, _serverItemId: serverId };
+          var wasMsg = self.state.messages[removeIdx];
+          var cancelledMsg = { role: "user", content: wasMsg.content, isCancelled: true, _serverItemId: serverId };
+          if (wasMsg.isBackgroundTask) cancelledMsg.isBackgroundTask = true;
+          if (wasMsg._indexFile) cancelledMsg._indexFile = wasMsg._indexFile;
+          if (wasMsg._useBgQueue) cancelledMsg._useBgQueue = true;
+          if (wasMsg._ownerKey !== void 0) cancelledMsg._ownerKey = wasMsg._ownerKey;
+          self.state.messages[removeIdx] = cancelledMsg;
           var thById = self.state.messages.findIndex(function(m) {
             return m._serverItemId === serverId && m.isPending && m.role === "assistant";
           });
@@ -1947,6 +2218,42 @@ var ChatSession = class {
       }
     });
   }
+  /**
+   * Stop indexing a file, from its collapsed row — every pass at once, not just
+   * the bubble the user happens to see.
+   *
+   * A big file is indexed as a CHAIN of passes, so cancelling only the live one
+   * accomplishes nothing: the next pass is dispatched as soon as it settles.
+   * Three things end the chain:
+   *   1. every queued/running pass of this file is cancelled server-side
+   *      (csr-cancel deletes a queued row and flags a running one "cancelled",
+   *      which is also the worker's gate for NOT enqueueing the next window);
+   *   2. the file is remembered in cancelledIndexKeys, so the client-driven
+   *      resume (maybeResumeIndexing) stops dispatching CONTINUE passes; and
+   *   3. any of its passes still sitting in bgTaskQueue is dropped by the next
+   *      drain rather than surfacing a fresh "Indexing…" bubble.
+   *
+   * Records already written by the passes that DID run are kept — this stops the
+   * work, it does not undo it.
+   */
+  cancelIndexingGroup(group) {
+    var self = this;
+    if (!group || !group.key) return;
+    var scoped = this.getHistoryCacheKey() + "|" + group.key;
+    this.cancelledIndexKeys.add(scoped);
+    var ids = group.cancellableIds || [];
+    if (!ids.length) {
+      this.host.notify();
+      return;
+    }
+    ids.forEach(function(serverId) {
+      var idx = self.state.messages.findIndex(function(m) {
+        return m._serverItemId === serverId && m.role === "user" && (m.isPendingQueued || m.isPendingInProcess);
+      });
+      if (idx === -1) return;
+      self.cancelQueuedMessage(self.state.messages[idx], idx);
+    });
+  }
   // --- typewriter -------------------------------------------------------
   // Reveal `fullText` into a message bubble at a constant wall-clock RATE
   // (chars/second) driven by requestAnimationFrame, rather than a fixed number
@@ -2133,6 +2440,7 @@ var ChatSession = class {
     var u = this.state.messages[uIdx];
     var cleaned = { role: "user", content: u.content, _serverItemId: itemId };
     if (u.isBackgroundTask) cleaned.isBackgroundTask = true;
+    if (u._indexFile) cleaned._indexFile = u._indexFile;
     this.state.messages[uIdx] = cleaned;
   }
   // If an immediate-send request for the current cache key is still in flight
@@ -2150,13 +2458,13 @@ var ChatSession = class {
       return (m.isPending || m.isPendingQueued) && !m.isBackgroundTask && !m._useBgQueue;
     })) return Promise.resolve();
     this.state.sending = true;
-    this.host.scrollToBottom(true);
+    this.host.scrollToBottomIfSticky(true);
     return Promise.resolve(pending).catch(function() {
     }).then(function() {
       if (token !== self.state.gateRefreshToken) return;
       self.state.sending = false;
       return Promise.resolve(self.typewriteLatestReply(key)).then(function() {
-        self.host.scrollToBottom(true);
+        self.host.scrollToBottomIfSticky(true);
       });
     });
   }
@@ -2175,8 +2483,17 @@ var ChatSession = class {
     });
     if (idx !== -1) {
       this._clearPendingUserBubble(itemId);
+      var wasBgTask = !!this.state.messages[idx].isBackgroundTask;
       if (isErr) {
         this.state.messages[idx] = { role: "assistant", content: answer, isError: true, _serverItemId: itemId };
+        if (wasBgTask) this.state.messages[idx].isBackgroundTask = true;
+        this.host.notify();
+        this.updateHistoryCache();
+        return;
+      }
+      var text = answer || "No text response received from AI provider.";
+      if (wasBgTask) {
+        this.state.messages[idx] = { role: "assistant", content: text, isBackgroundTask: true, _serverItemId: itemId };
         this.host.notify();
         this.updateHistoryCache();
         return;
@@ -2184,7 +2501,7 @@ var ChatSession = class {
       var lid = this._newLocalId();
       this.state.messages[idx] = { role: "assistant", content: "", _localId: lid, _serverItemId: itemId };
       this.host.notify();
-      this.enqueueTypewrite(idx, answer || "No text response received from AI provider.", lid);
+      this.enqueueTypewrite(idx, text, lid);
       this.updateHistoryCache();
       return;
     }
@@ -2193,25 +2510,124 @@ var ChatSession = class {
     });
     if (userIdx === -1) return;
     var ex = this.state.messages[userIdx];
-    this.state.messages[userIdx] = { role: "user", content: ex.content, _serverItemId: itemId };
+    var settledUser = { role: "user", content: ex.content, _serverItemId: itemId };
+    if (ex.isBackgroundTask) settledUser.isBackgroundTask = true;
+    if (ex._indexFile) settledUser._indexFile = ex._indexFile;
+    if (ex._useBgQueue) settledUser._useBgQueue = true;
+    this.state.messages[userIdx] = settledUser;
     if (isErr) {
-      this.state.messages.splice(userIdx + 1, 0, { role: "assistant", content: answer, isError: true, _serverItemId: itemId });
+      var errReply = { role: "assistant", content: answer, isError: true, _serverItemId: itemId };
+      if (ex.isBackgroundTask) errReply.isBackgroundTask = true;
+      this.state.messages.splice(userIdx + 1, 0, errReply);
+      this.host.notify();
+      this.updateHistoryCache();
+      return;
+    }
+    var text2 = answer || "No text response received from AI provider.";
+    if (ex.isBackgroundTask) {
+      this.state.messages.splice(userIdx + 1, 0, { role: "assistant", content: text2, isBackgroundTask: true, _serverItemId: itemId });
       this.host.notify();
       this.updateHistoryCache();
       return;
     }
     var lid2 = this._newLocalId();
-    this.state.messages.splice(userIdx + 1, 0, { role: "assistant", content: "", _localId: lid2, _serverItemId: itemId });
+    var reply = { role: "assistant", content: "", _localId: lid2, _serverItemId: itemId };
+    this.state.messages.splice(userIdx + 1, 0, reply);
     this.host.notify();
-    this.enqueueTypewrite(userIdx + 1, answer || "No text response received from AI provider.", lid2);
+    this.enqueueTypewrite(userIdx + 1, text2, lid2);
     this.updateHistoryCache();
   }
+  /** How a bg task maps onto a collapsed row: the row's own key (storage path
+   *  when known, else the filename), scoped to the chat it belongs to. A storage
+   *  path is project-relative ("report.xlsx"), and ONE ChatSession serves every
+   *  project — unscoped, stopping a file in one project would silently suppress
+   *  the same filename's continuations in another. */
+  _indexKeyOf(entry) {
+    if (!entry) return "";
+    var file = entry.storagePath || entry.filename;
+    if (!file) return "";
+    return entry.serviceId + "#" + entry.platform + "|" + file;
+  }
+  /**
+   * Reconcile the bg queue with the files the user has stopped.
+   *
+   * A FIRST pass (no resumePass) is a fresh indexing request — a re-upload, or a
+   * Reindex from the file manager — so it LIFTS the stop: the key is a storage
+   * path, and without this an earlier cancel would silently kill every future
+   * index of the same path. A continuation of a stopped file is dropped instead,
+   * covering the pass that was dispatched in the moment before the cancel landed.
+   */
+  _applyIndexCancellations() {
+    if (!this.cancelledIndexKeys.size) return;
+    for (var i = this.bgTaskQueue.length - 1; i >= 0; i--) {
+      var entry = this.bgTaskQueue[i];
+      var key = this._indexKeyOf(entry);
+      if (!key || !this.cancelledIndexKeys.has(key)) continue;
+      if (!entry.resumePass) {
+        this.cancelledIndexKeys.delete(key);
+        continue;
+      }
+      this.bgTaskQueue.splice(i, 1);
+      this._stopPoll(entry.id);
+      this._cancelServerItem(entry.id);
+    }
+  }
+  /**
+   * Cancel any live pass of a stopped file that turned up on its own.
+   *
+   * The client is not the only thing that continues a file: for PDFs and (when
+   * windowed indexing is on) text/grid files the WORKER enqueues the next window
+   * itself, and that pass reaches the chat through the history poll, never
+   * through bgTaskQueue. The worker's own gate stops the chain when the running
+   * row is cancelled — but if the row had already finished when the user hit
+   * stop, the next window was queued a moment earlier and still arrives. Stop it
+   * here rather than making the user hit stop again.
+   *
+   * Runs from drainBgTaskQueue, which both clients call after a history load.
+   */
+  _sweepCancelledIndexing() {
+    if (!this.cancelledIndexKeys.size) return;
+    var self = this;
+    var chatKey = this.getHistoryCacheKey();
+    var targets = [];
+    this.state.messages.forEach(function(m, i) {
+      if (!m.isBackgroundTask || m.role !== "user" || !m._serverItemId) return;
+      if (m._cancelling || m.isSendingToServer) return;
+      if (!(m.isPendingQueued || m.isPendingInProcess)) return;
+      var ref = m._indexFile;
+      var file = ref && (ref.path || ref.name);
+      if (!file || !self.cancelledIndexKeys.has(chatKey + "|" + file)) return;
+      targets.push({ msg: m, idx: i });
+    });
+    targets.forEach(function(t) {
+      var idx = self.state.messages.indexOf(t.msg);
+      self.cancelQueuedMessage(t.msg, idx === -1 ? t.idx : idx);
+    });
+  }
+  /** Best-effort server-side cancel of a bg-queue item that has no bubble (so
+   *  cancelQueuedMessage, which drives one, has nothing to act on). */
+  _cancelServerItem(serverId) {
+    var id = this.host.getIdentity();
+    if (!serverId || id.platform !== "claude" && id.platform !== "openai") return;
+    var url = id.platform === "claude" ? ANTHROPIC_MESSAGES_API_URL : OPENAI_RESPONSES_API_URL;
+    Promise.resolve(this.host.cancelRequest({
+      url,
+      method: "POST",
+      id: serverId,
+      queue: (id.userId || id.serviceId) + BG_INDEXING_QUEUE_SUFFIX,
+      service: id.serviceId,
+      owner: id.owner
+    })).catch(function() {
+    });
+  }
   // Inject "Indexing: <file>" bubbles for queued bg tasks + attach their polls.
   drainBgTaskQueue() {
     var self = this;
     var id = this.host.getIdentity();
     var svcId = id.serviceId, plat = id.platform;
     if (!svcId || plat === "none" || !this.host.isViewMounted()) return;
+    this._applyIndexCancellations();
+    this._sweepCancelledIndexing();
     var presentIds = {};
     var pendingIds = {};
     this.state.messages.forEach(function(m) {
@@ -2229,7 +2645,22 @@ var ChatSession = class {
       if (entry.serviceId !== svcId || entry.platform !== plat) return;
       if (!presentIds[entry.id]) {
         var isRunning = entry.status === "running";
-        var userBubble = { role: "user", content: self.host.formatIndexingLabel(entry.filename, entry.mime, entry.size, entry.storagePath, entry.isReindex), isBackgroundTask: true, _serverItemId: entry.id };
+        var userBubble = {
+          role: "user",
+          content: self.host.formatIndexingLabel(entry.filename, entry.mime, entry.size, entry.storagePath, entry.isReindex, !!entry.resumePass),
+          isBackgroundTask: true,
+          _serverItemId: entry.id,
+          // Structured ref so this live pass groups with the same file's passes
+          // rebuilt from history (see indexing_groups.buildChatDisplayList).
+          _indexFile: {
+            name: entry.filename,
+            path: entry.storagePath,
+            mime: entry.mime,
+            size: entry.size,
+            isReindex: !!entry.isReindex,
+            continued: !!entry.resumePass
+          }
+        };
         if (isRunning) userBubble.isPendingInProcess = true;
         else userBubble.isPendingQueued = true;
         self.state.messages.push(userBubble);
@@ -2239,7 +2670,7 @@ var ChatSession = class {
         presentIds[entry.id] = true;
         self.host.notify();
         self.updateHistoryCache();
-        self.host.scrollToBottom(false);
+        self.host.scrollToBottomIfSticky(false);
       }
       if (!self.isPollingPaused() && !self.historyItemPolls.has(entry.id) && typeof entry.poll === "function") {
         var capturedId = entry.id, capturedPlat = plat;
@@ -2257,15 +2688,23 @@ var ChatSession = class {
         }).catch(function(err) {
           self.historyItemPolls.delete(capturedId);
           var isNotExists = err && (err.code === "NOT_EXISTS" || err.body && err.body.code === "NOT_EXISTS");
+          self._clearPendingUserBubble(capturedId);
           var bi = self.state.messages.findIndex(function(m) {
             return m.isPending && m._serverItemId === capturedId;
           });
           if (bi !== -1) {
             if (isNotExists) self.state.messages.splice(bi, 1);
             else self.state.messages[bi] = { role: "assistant", content: getErrorMessage(err), isError: true, isBackgroundTask: true, _serverItemId: capturedId };
-            self.host.notify();
-            self.updateHistoryCache();
+          } else if (!isNotExists) {
+            var ui = self.state.messages.findIndex(function(m) {
+              return m.role === "user" && m._serverItemId === capturedId;
+            });
+            if (ui !== -1) {
+              self.state.messages.splice(ui + 1, 0, { role: "assistant", content: getErrorMessage(err), isError: true, isBackgroundTask: true, _serverItemId: capturedId });
+            }
           }
+          self.host.notify();
+          self.updateHistoryCache();
         }).then(function() {
           if (wasStopped) return;
           var qi = self.bgTaskQueue.findIndex(function(q) {
@@ -2293,8 +2732,10 @@ var ChatSession = class {
     var self = this;
     try {
       if (!entry || !entry.storagePath) return;
+      if (this.cancelledIndexKeys.has(this._indexKeyOf(entry))) return;
       if (!isPagedReadFile(entry.filename, entry.mime)) return;
       if (isImageVisionFile(entry.filename, entry.mime)) return;
+      if (windowedIndexingEnabled() && isWindowedReadFile(entry.filename, entry.mime)) return;
       if (isErrorResponseBody(response)) return;
       var answer = (platform === "openai" ? extractOpenAIText(response) : extractClaudeText(response)) || "";
       if (answer.indexOf(INDEXING_COMPLETE_MARKER) !== -1) return;
@@ -2387,6 +2828,7 @@ var ChatSession = class {
         serviceId: id.serviceId,
         formatIndexingLabel: self.host.formatIndexingLabel
       }).messages;
+      var keptOlderPages = false;
       if (fetchMore) {
         self.state.messages = mapped.concat(self.state.messages);
       } else {
@@ -2397,7 +2839,12 @@ var ChatSession = class {
         });
         var locallyCancelled = {};
         self.state.messages.forEach(function(m) {
-          if (m.isCancelled && m._serverItemId) locallyCancelled[m._serverItemId] = 1;
+          if (m.isCancelled && m._serverItemId) locallyCancelled[m._serverItemId] = m;
+        });
+        var inFlightCancel = {};
+        self.state.messages.forEach(function(m) {
+          if (!m._serverItemId) return;
+          if (m._cancelling || m._cancelError) inFlightCancel[m._serverItemId] = m;
         });
         var mappedHasPendingAssistant = mapped.some(function(m) {
           return m.isPending && m.role === "assistant" && !m.isBackgroundTask;
@@ -2417,7 +2864,22 @@ var ChatSession = class {
             }
           }
         }
-        self.state.messages = mapped;
+        var oldestInPage1 = void 0;
+        mapped.forEach(function(m) {
+          var sid = m._serverItemId;
+          if (typeof sid !== "string") return;
+          if (oldestInPage1 === void 0 || sid < oldestInPage1) oldestInPage1 = sid;
+        });
+        var sharesPage1 = self.state.messages.some(function(m) {
+          return typeof m._serverItemId === "string" && !!serverIds[m._serverItemId];
+        });
+        var retainedOlder = !sharesPage1 || oldestInPage1 === void 0 ? [] : self.state.messages.filter(function(m) {
+          if (typeof m._serverItemId !== "string") return false;
+          if (m._ownerKey !== void 0 && m._ownerKey !== loadKey) return false;
+          return m._serverItemId < oldestInPage1;
+        });
+        keptOlderPages = retainedOlder.length > 0;
+        self.state.messages = keptOlderPages ? retainedOlder.concat(mapped) : mapped;
         rescued.forEach(function(m) {
           self.state.messages.push(m);
         });
@@ -2425,19 +2887,38 @@ var ChatSession = class {
           for (var ci = 0; ci < self.state.messages.length; ci++) {
             var c = self.state.messages[ci];
             if (!c._serverItemId || !locallyCancelled[c._serverItemId] || c.isCancelled) continue;
-            self.state.messages[ci] = { role: "user", content: c.content, isCancelled: true, _serverItemId: c._serverItemId };
+            self.state.messages[ci] = {
+              role: "user",
+              content: c.content,
+              isCancelled: true,
+              _serverItemId: c._serverItemId,
+              isBackgroundTask: c.isBackgroundTask,
+              _indexFile: c._indexFile,
+              _useBgQueue: c._useBgQueue,
+              _ownerKey: c._ownerKey
+            };
             if (ci + 1 < self.state.messages.length && self.state.messages[ci + 1].isPending && self.state.messages[ci + 1]._serverItemId === c._serverItemId) {
               self.state.messages.splice(ci + 1, 1);
             }
           }
         }
+        for (var fi = 0; fi < self.state.messages.length; fi++) {
+          var fm = self.state.messages[fi];
+          var was = fm._serverItemId && inFlightCancel[fm._serverItemId];
+          if (!was || fm.isCancelled) continue;
+          if (!(fm.isPendingQueued || fm.isPendingInProcess || fm.isPending)) continue;
+          if (was._cancelling) fm._cancelling = true;
+          if (was._cancelError) fm._cancelError = was._cancelError;
+        }
       }
-      self.state.historyEndOfList = !!(history && history.endOfList);
-      self.state.historyStartKeyHistory = history && Array.isArray(history.startKeyHistory) ? history.startKeyHistory : [];
-      var clearedAt = self.host.getClearedAt();
-      if (clearedAt && chatList.length > 0) {
-        var oldestUpdated = Number(chatList[chatList.length - 1] && chatList[chatList.length - 1].updated);
-        if (isFinite(oldestUpdated) && oldestUpdated <= clearedAt) self.state.historyEndOfList = true;
+      if (!keptOlderPages) {
+        self.state.historyEndOfList = !!(history && history.endOfList);
+        self.state.historyStartKeyHistory = history && Array.isArray(history.startKeyHistory) ? history.startKeyHistory : [];
+        var clearedAt = self.host.getClearedAt();
+        if (clearedAt && chatList.length > 0) {
+          var oldestUpdated = Number(chatList[chatList.length - 1] && chatList[chatList.length - 1].updated);
+          if (isFinite(oldestUpdated) && oldestUpdated <= clearedAt) self.state.historyEndOfList = true;
+        }
       }
       if (self.state.historyRequestToken === token) {
         self.state.loadingHistory = false;
@@ -2466,18 +2947,25 @@ var ChatSession = class {
                 return m.isPending && m._serverItemId === capturedId;
               });
               if (isNotExists) {
-                var isBg = aIdx !== -1 ? !!self.state.messages[aIdx].isBackgroundTask : false;
+                var uIdx = self.state.messages.findIndex(function(m) {
+                  return m.role === "user" && m._serverItemId === capturedId && !m.isCancelled;
+                });
+                var isBg = aIdx !== -1 && !!self.state.messages[aIdx].isBackgroundTask || uIdx !== -1 && !!self.state.messages[uIdx].isBackgroundTask;
                 if (aIdx !== -1) self.state.messages.splice(aIdx, 1);
                 if (!isBg) {
-                  var uIdx = self.state.messages.findIndex(function(m) {
-                    return m.role === "user" && m._serverItemId === capturedId && !m.isCancelled;
-                  });
                   if (uIdx !== -1) {
                     var ex = self.state.messages[uIdx];
                     self.state.messages[uIdx] = { role: "user", content: ex.content, isCancelled: true, _serverItemId: ex._serverItemId };
                   }
                   self.cancelledServerIds.delete(capturedId);
                   self.promoteNextQueuedToRunning();
+                } else if (uIdx !== -1) {
+                  var bex = self.state.messages[uIdx];
+                  var bcancelled = { role: "user", content: bex.content, isCancelled: true, isBackgroundTask: true, _serverItemId: bex._serverItemId };
+                  if (bex._indexFile) bcancelled._indexFile = bex._indexFile;
+                  if (bex._useBgQueue) bcancelled._useBgQueue = true;
+                  self.state.messages[uIdx] = bcancelled;
+                  self.promoteNextBgQueuedToRunning();
                 }
                 self.host.notify();
                 self.updateHistoryCache();
@@ -2498,7 +2986,7 @@ var ChatSession = class {
         });
         self.drainBgTaskQueue();
       }
-      if (!fetchMore) return self.host.scrollToBottom();
+      if (!fetchMore) return self.host.scrollToBottomIfSticky();
     }).catch(function(err) {
       console.warn("[chat-engine] getChatHistory failed", err);
     }).then(function() {
@@ -2508,6 +2996,7 @@ var ChatSession = class {
         self.state.loadingOlderHistory = false;
         if (wasLoading) self.host.notify();
       }
+      if (self.host.onHistoryLoaded) self.host.onHistoryLoaded(!!fetchMore, token);
     });
   }
   // --- attachment upload orchestration ---------------------------------
@@ -2705,6 +3194,189 @@ var ChatSession = class {
   }
 };
 
+// src/engine/indexing_groups.ts
+var INDEXING_LABEL_RE = /^(Re)?[Ii]ndexing(\s*\(continuing\))?\s*:?\s+(.+)$/;
+var LEADING_MD_LINK_RE = /^\[([^\]]+)\]\(([^)]+)\)/;
+function parseIndexingLabel(content) {
+  if (typeof content !== "string" || !content) return null;
+  var firstLine = content.split("\n")[0].trim();
+  var m = firstLine.match(INDEXING_LABEL_RE);
+  if (!m) return null;
+  var head = m[3].split(" \xB7 ")[0].trim();
+  var link = head.match(LEADING_MD_LINK_RE);
+  var name = link ? link[1].trim() : head;
+  if (!name) return null;
+  return {
+    name,
+    path: link ? link[2].trim() : void 0,
+    continued: !!m[2],
+    isReindex: !!m[1]
+  };
+}
+function readFileRef(msg) {
+  var ref = msg && msg._indexFile;
+  if (ref && (ref.path || ref.name)) {
+    return {
+      name: ref.name || ref.path || "",
+      path: ref.path,
+      mime: ref.mime,
+      size: ref.size,
+      isReindex: ref.isReindex,
+      continued: !!ref.continued
+    };
+  }
+  var parsed = parseIndexingLabel(msg && msg.content);
+  if (!parsed) return null;
+  return {
+    name: parsed.name,
+    path: parsed.path,
+    isReindex: parsed.isReindex,
+    continued: parsed.continued
+  };
+}
+function isPendingMsg(m) {
+  return !!(m.isPending || m.isPendingInProcess || m.isPendingQueued || m.isSendingToServer);
+}
+function buildChatDisplayList(messages, opts) {
+  var list = Array.isArray(messages) ? messages : [];
+  var hasMoreHistory = !!(opts && opts.hasMoreHistory);
+  var groups = {};
+  var order = [];
+  var runOfIndex = new Array(list.length);
+  var runByItemId = {};
+  var keyByName = {};
+  var openRunOfKey = {};
+  var runsOfKey = {};
+  var keyOfRun = {};
+  var runSeq = 0;
+  for (var i = 0; i < list.length; i++) {
+    var msg = list[i];
+    if (!msg || !msg.isBackgroundTask) continue;
+    var runId;
+    var ref = msg.role === "user" ? readFileRef(msg) : null;
+    if (ref) {
+      var key = ref.path || keyByName[ref.name] || ref.name;
+      if (!ref.continued && openRunOfKey[key]) delete openRunOfKey[key];
+      runId = openRunOfKey[key];
+      if (!runId) {
+        runId = "run" + runSeq++;
+        openRunOfKey[key] = runId;
+        keyOfRun[runId] = key;
+        (runsOfKey[key] || (runsOfKey[key] = [])).push(runId);
+      }
+    } else if (msg._serverItemId && runByItemId[msg._serverItemId]) {
+      runId = runByItemId[msg._serverItemId];
+    } else if (msg.role !== "user") {
+      runId = runOfIndex[i - 1];
+    }
+    if (!runId) continue;
+    var g = groups[runId];
+    if (!g) {
+      var fileKey = keyOfRun[runId];
+      g = groups[runId] = {
+        key: fileKey,
+        runKey: runId,
+        // provisional; renumbered newest-first below
+        name: ref ? ref.name : fileKey,
+        path: ref ? ref.path : void 0,
+        mime: ref ? ref.mime : void 0,
+        size: ref ? ref.size : void 0,
+        isReindex: !!(ref && ref.isReindex),
+        members: [],
+        passCount: 0,
+        status: "done",
+        cancellableIds: [],
+        cancelling: false,
+        mayHaveOlder: false,
+        anchorIndex: i
+      };
+      order.push(runId);
+    }
+    if (ref) {
+      if (ref.name) g.name = ref.name;
+      if (ref.path) g.path = ref.path;
+      if (ref.mime) g.mime = ref.mime;
+      if (typeof ref.size === "number") g.size = ref.size;
+      if (ref.isReindex) g.isReindex = true;
+      if (!ref.continued) g.mayHaveOlder = false;
+      g.passCount++;
+    }
+    g.members.push({ msg, index: i });
+    g.anchorIndex = i;
+    runOfIndex[i] = runId;
+    if (msg._serverItemId) runByItemId[msg._serverItemId] = runId;
+    if (ref && ref.name) keyByName[ref.name] = g.key;
+  }
+  for (var rk in runsOfKey) {
+    var runIds = runsOfKey[rk];
+    for (var ri = 0; ri < runIds.length; ri++) {
+      var grpR = groups[runIds[ri]];
+      if (!grpR) continue;
+      var first = grpR.members[0];
+      var firstId = first && first.msg && (first.msg._serverItemId || first.msg._localId);
+      grpR.runKey = rk + "#" + (firstId || "n" + ri);
+    }
+  }
+  for (var oi = 0; oi < order.length; oi++) {
+    var grp = groups[order[oi]];
+    var lastSettled = -1;
+    for (var si = 0; si < grp.members.length; si++) {
+      if (!isPendingMsg(grp.members[si].msg)) lastSettled = si;
+    }
+    var active = false;
+    for (var mi = lastSettled + 1; mi < grp.members.length; mi++) {
+      if (isPendingMsg(grp.members[mi].msg)) {
+        active = true;
+        break;
+      }
+    }
+    for (var xi = 0; xi < grp.members.length; xi++) {
+      if (grp.members[xi].msg._cancelling) {
+        grp.cancelling = true;
+        break;
+      }
+    }
+    var seenIds = {};
+    for (var ci = 0; ci < grp.members.length; ci++) {
+      var cm = grp.members[ci].msg;
+      if (cm._cancelError && (active || grp.cancelling)) grp.cancelError = cm._cancelError;
+      if (cm.role !== "user" || !cm._serverItemId || cm._cancelling || cm.isSendingToServer) continue;
+      if (!(cm.isPendingQueued || cm.isPendingInProcess)) continue;
+      if (ci < lastSettled) continue;
+      if (seenIds[cm._serverItemId]) continue;
+      seenIds[cm._serverItemId] = true;
+      grp.cancellableIds.push(cm._serverItemId);
+    }
+    if (active) {
+      grp.status = "active";
+    } else {
+      var last = grp.members[grp.members.length - 1].msg;
+      grp.status = last.isError ? "error" : last.isCancelled ? "cancelled" : "done";
+    }
+    var sawFirstPass = false;
+    for (var pi = 0; pi < grp.members.length; pi++) {
+      var pm = grp.members[pi].msg;
+      if (pm.role !== "user") continue;
+      var pref = readFileRef(pm);
+      if (pref && !pref.continued) {
+        sawFirstPass = true;
+        break;
+      }
+    }
+    grp.mayHaveOlder = !sawFirstPass && hasMoreHistory;
+  }
+  var out = [];
+  for (var j = 0; j < list.length; j++) {
+    var r = runOfIndex[j];
+    if (r === void 0) {
+      out.push({ kind: "message", msg: list[j], index: j });
+      continue;
+    }
+    if (groups[r].anchorIndex === j) out.push({ kind: "indexing", group: groups[r], index: j });
+  }
+  return out;
+}
+
 exports.BG_INDEXING_QUEUE_SUFFIX = BG_INDEXING_QUEUE_SUFFIX;
 exports.CLAUDE_PER_REQUEST_INPUT_CAP = CLAUDE_PER_REQUEST_INPUT_CAP;
 exports.CONTEXT_WINDOW_BY_MODEL = CONTEXT_WINDOW_BY_MODEL;
@@ -2714,8 +3386,12 @@ exports.DEFAULT_CLAUDE_MODEL = DEFAULT_CLAUDE_MODEL;
 exports.DEFAULT_OPENAI_MODEL = DEFAULT_OPENAI_MODEL;
 exports.EXPIRED_ATTACHMENT_URL_HOST = EXPIRED_ATTACHMENT_URL_HOST;
 exports.EXPIRED_ATTACHMENT_URL_ORIGIN = EXPIRED_ATTACHMENT_URL_ORIGIN;
+exports.EXPIRED_LINK_REFRESH_EXPIRES_SECONDS = EXPIRED_LINK_REFRESH_EXPIRES_SECONDS;
+exports.HISTORY_FILL_SLACK_PX = HISTORY_FILL_SLACK_PX;
 exports.HISTORY_TOKEN_BUDGET = HISTORY_TOKEN_BUDGET;
 exports.LINK_LABEL_MAX_DISPLAY_CHARS = LINK_LABEL_MAX_DISPLAY_CHARS;
+exports.LINK_REFRESH_WINDOW_MS = LINK_REFRESH_WINDOW_MS;
+exports.MAX_HISTORY_FILL_PAGES = MAX_HISTORY_FILL_PAGES;
 exports.MAX_HISTORY_MESSAGES = MAX_HISTORY_MESSAGES;
 exports.MAX_PARSED_CONTENT_CHARS = MAX_PARSED_CONTENT_CHARS;
 exports.MCP_NAME = MCP_NAME;
@@ -2725,6 +3401,7 @@ exports.POLL_INTERVAL = POLL_INTERVAL;
 exports.RENDER_FROM_TOKEN = RENDER_FROM_TOKEN;
 exports.TOOL_AND_RESPONSE_BUFFER = TOOL_AND_RESPONSE_BUFFER;
 exports.buildBoundedChatMessages = buildBoundedChatMessages;
+exports.buildChatDisplayList = buildChatDisplayList;
 exports.buildChatSystemPrompt = buildChatSystemPrompt;
 exports.buildDisplayExpiredAttachmentHref = buildDisplayExpiredAttachmentHref;
 exports.buildIndexingContinueMessage = buildIndexingContinueMessage;
@@ -2737,9 +3414,11 @@ exports.callClaudeWithMcp = callClaudeWithMcp;
 exports.callClaudeWithPublicMcp = callClaudeWithPublicMcp;
 exports.callOpenAIWithPublicMcp = callOpenAIWithPublicMcp;
 exports.chatEngineConfig = chatEngineConfig;
+exports.classifyInlineLink = classifyInlineLink;
 exports.clearAttachmentParsers = clearAttachmentParsers;
 exports.composeUserMessage = composeUserMessage;
 exports.configureChatEngine = configureChatEngine;
+exports.createHistoryFiller = createHistoryFiller;
 exports.createInlineLinkRegex = createInlineLinkRegex;
 exports.encodePathSegments = encodePathSegments;
 exports.estimateMessageTokens = estimateMessageTokens;
@@ -2748,6 +3427,7 @@ exports.extractClaudeText = extractClaudeText;
 exports.extractLastUserTextFromRequest = extractLastUserTextFromRequest;
 exports.extractOpenAIText = extractOpenAIText;
 exports.extractRemotePathFromAttachmentHref = extractRemotePathFromAttachmentHref;
+exports.fillHistoryViewport = fillHistoryViewport;
 exports.filterListByClearHorizon = filterListByClearHorizon;
 exports.findAttachmentParser = findAttachmentParser;
 exports.getAttachmentParsers = getAttachmentParsers;
@@ -2759,6 +3439,7 @@ exports.groupAttachmentFailures = groupAttachmentFailures;
 exports.isAuthExpiredError = isAuthExpiredError;
 exports.isBgIndexingQueue = isBgIndexingQueue;
 exports.isErrorResponseBody = isErrorResponseBody;
+exports.isHttpUrlLike = isHttpUrlLike;
 exports.isNonRetryableRequestError = isNonRetryableRequestError;
 exports.isOfficeFile = isOfficeFile;
 exports.isServerExtractable = isServerExtractable;
@@ -2769,9 +3450,13 @@ exports.makeExtractPlaceholder = makeExtractPlaceholder;
 exports.mapHistoryListToMessages = mapHistoryListToMessages;
 exports.normalizeAttachmentPathCandidate = normalizeAttachmentPathCandidate;
 exports.normalizeTextContent = normalizeTextContent;
+exports.normalizeTrailingInlineToken = normalizeTrailingInlineToken;
 exports.notifyAgentSaveAttachment = notifyAgentSaveAttachment;
 exports.parseAttachmentContent = parseAttachmentContent;
+exports.parseIndexingLabel = parseIndexingLabel;
+exports.readExpiredAttachmentHref = readExpiredAttachmentHref;
 exports.registerAttachmentParser = registerAttachmentParser;
+exports.repairUrlWhitespace = repairUrlWhitespace;
 exports.safeDecodeURIComponent = safeDecodeURIComponent;
 exports.sanitizeAttachmentLinksForHistory = sanitizeAttachmentLinksForHistory;
 exports.stripFileBlocksFromHistory = stripFileBlocksFromHistory;