bunnyquery 1.6.0 → 1.7.0

package/bunnyquery.js

@@ -56,6 +56,9 @@
     }
     return _config;
   }
+  function windowedIndexingEnabled() {
+    return _config?.windowedIndexing === true;
+  }
   function pollOpt() {
     const p = _config?.poll;
     return p === void 0 ? {} : { poll: p };
@@ -149,7 +152,32 @@
     if (isTextMime(m)) return true;
     return m.includes("officedocument") || m.includes("opendocument") || m.includes("hwp") || m.includes("epub") || m === "application/msword" || m === "application/vnd.ms-excel" || m === "application/vnd.ms-powerpoint";
   }
-  var PAGED_READ_EXTENSIONS = /* @__PURE__ */ new Set(["xls", "xlsx", "xlsm", "ods", "pdf"]);
+  var PAGED_READ_EXTENSIONS = /* @__PURE__ */ new Set([
+    // grids
+    "xls",
+    "xlsx",
+    "xlsm",
+    "ods",
+    // delimited text (row-windowed by the layer)
+    "csv",
+    "tsv",
+    "tab",
+    // documents
+    "pdf",
+    "docx",
+    "pptx",
+    // plain text / data / markup
+    "txt",
+    "md",
+    "markdown",
+    "log",
+    "json",
+    "jsonl",
+    "ndjson",
+    "xml",
+    "yaml",
+    "yml"
+  ]);
   function isPagedReadFile(name, mime) {
     const ext = (name || "").split(".").pop()?.toLowerCase() || "";
     if (PAGED_READ_EXTENSIONS.has(ext)) return true;
@@ -173,6 +201,16 @@
     return `{{SKAPI_RENDER::${slug}-${_renderPlaceholderSeq}}}`;
   }
   var RENDER_PAGES_PER_WINDOW = 5;
+  var _windowPlaceholderSeq = 0;
+  function makeWindowPlaceholder(seed) {
+    _windowPlaceholderSeq += 1;
+    const slug = (seed || "file").replace(/[^a-zA-Z0-9]+/g, "_").slice(-48);
+    return `{{SKAPI_WINDOW::${slug}-${_windowPlaceholderSeq}}}`;
+  }
+  function isWindowedReadFile(name, mime) {
+    if (isImageVisionFile(name, mime)) return false;
+    return isPagedReadFile(name, mime);
+  }
   function composeUserMessage(text, attachmentUrls) {
     let composed = text;
     if (attachmentUrls.length > 0) {
@@ -246,7 +284,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
@@ -320,32 +358,60 @@ Read this file with the readFileContent tool, using the storage path above - do
     }
     return head + `- temporary URL (fetch this to read the file contents): ${attachment.url}`;
   }
+  var RENDER_FROM_TOKEN = "{{RENDER_FROM}}";
+  var WINDOW_CURSOR_TOKEN = RENDER_FROM_TOKEN;
   function buildIndexingRenderMessage(attachment, placeholder, renderFrom) {
     const from = Math.max(0, renderFrom || 0);
+    if (from > 0) return buildIndexingRenderContinueTemplate(attachment, placeholder, String(from + 1));
+    return `A new file has just been uploaded. Index it now.
+
+` + buildRenderMeta(attachment) + `
+This is a PDF. Its pages are delivered to you as RENDERED PAGE IMAGES embedded directly in this message (you do NOT need any tool, URL, or web_fetch to see them). You are shown a WINDOW of pages at a time, starting at page ${from + 1}.
+` + buildRenderDatafy(placeholder);
+  }
+  function buildIndexingRenderContinueTemplate(attachment, placeholder, pageLabel = RENDER_FROM_TOKEN) {
     const src = `src::${attachment.storagePath}`;
-    const meta = `File metadata:
+    return `CONTINUE indexing a PDF whose previous pass did not finish.
+
+` + buildRenderMeta(attachment) + `
+Records for the earlier pages are ALREADY saved (they reference "${src}"). The NEXT window of rendered page images (starting at page ${pageLabel}) is embedded in this message. Datafy each page as before and do NOT re-save pages that are already saved.
+` + buildRenderDatafy(placeholder);
+  }
+  function buildRenderMeta(attachment) {
+    return `File metadata:
 - name: ${attachment.name}
 - storage path: ${attachment.storagePath}
 ` + (attachment.mime ? `- mime type: ${attachment.mime}
 ` : "");
-    const datafy = `
+  }
+  function buildRenderDatafy(placeholder) {
+    return `
 ${placeholder}
 
 LOOK at each rendered page image in this message and DATAFY what it shows: for EVERY page call postRecords and save records - one record per row / table entry / line item visible on the page (or one record for the page if it is prose), capturing every value you can read (OCR the text, read tables cell by cell, describe any photos/diagrams). Use the storage path above for the "src::" unique_id.
 
-The note next to the images tells you whether MORE pages remain after this window. If MORE remain: save this window's records and STOP - do NOT write INDEXING_COMPLETE; another pass shows the next window automatically. Only when the note says this is the LAST window (you have seen the whole file) AND everything is saved, end your message with the token INDEXING_COMPLETE.`;
-    if (from === 0) {
-      return `A new file has just been uploaded. Index it now.
+Save records for THIS window of pages only, then stop and report what you saved. Do NOT try to read the rest of the file and do NOT worry about the pages after this window: if any remain, the next window is rendered and sent to you automatically. Report only the pages you were actually shown - never imply you have seen the whole document.`;
+  }
+  function buildIndexingWindowMessage(attachment, placeholder, isContinuation, positionLabel) {
+    const src = `src::${attachment.storagePath}`;
+    const head = isContinuation ? `CONTINUE indexing a file whose previous pass did not finish.
 
-` + meta + `
-This is a PDF. Its pages are delivered to you as RENDERED PAGE IMAGES embedded directly in this message (you do NOT need any tool, URL, or web_fetch to see them). You are shown a WINDOW of pages at a time, starting at page ${from + 1}.
-` + datafy;
-    }
-    return `CONTINUE indexing a PDF whose previous pass did not finish.
+` : `A new file has just been uploaded. Index it now.
+
+`;
+    const where = isContinuation ? `
+Records for the earlier windows are ALREADY saved (they reference "${src}"). The NEXT window (starting at ${WINDOW_CURSOR_TOKEN}) is embedded below. Do NOT re-save windows that are already saved.
+` : `
+This file is delivered to you ONE WINDOW at a time, embedded directly in this message. You do NOT need any tool, URL, or web_fetch to read it.
+`;
+    return head + buildRenderMeta(attachment) + where + `
+${placeholder}
 
-` + meta + `
-Records for the earlier pages are ALREADY saved (they reference "${src}"). The NEXT window of rendered page images (starting at page ${from + 1}) is embedded in this message. Datafy each page as before and do NOT re-save pages that are already saved.
-` + datafy;
+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) {
     const src = `src::${attachment.storagePath}`;
@@ -455,8 +521,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   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 {
@@ -516,18 +584,150 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       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;
@@ -610,24 +810,27 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   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) => {
     const normalized = (model || DEFAULT_OPENAI_MODEL).trim().toLowerCase();
-    const match = normalized.match(/^gpt-(\d+)(?:\.(\d+))?$/);
+    const match = normalized.match(/^gpt-(\d+)(?:\.(\d+))?(-[a-z0-9.\-]+)?$/);
     if (!match) {
       return DEFAULT_OPENAI_IMAGE_DETAIL;
     }
     const major = Number(match[1]);
     const minor = match[2] === void 0 ? null : Number(match[2]);
-    if (major > 5) {
-      return "original";
-    }
-    if (major === 5 && minor !== null && minor >= 4) {
-      return "original";
+    const isVariant = !!match[3];
+    const supportsOriginal = major > 5 || major === 5 && minor !== null && minor >= 4;
+    if (!supportsOriginal) {
+      return DEFAULT_OPENAI_IMAGE_DETAIL;
     }
-    return DEFAULT_OPENAI_IMAGE_DETAIL;
+    return isVariant ? "high" : "original";
+  };
+  var getRenderImageDetail = (model) => {
+    const detail = getOpenAIImageDetail(model);
+    return detail === DEFAULT_OPENAI_IMAGE_DETAIL ? "high" : detail;
   };
   var IMAGE_URL_REGEX = /\bhttps?:\/\/[^\s<>"'()\[\]]+?\.(?:jpg|jpeg|png|gif|webp)(?:\?[^\s<>"'()\[\]]*)?/gi;
   function transformContentWithImages(content) {
@@ -872,17 +1075,44 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     const visionFile = !parsedContent && isImageVisionFile(attachment.name, attachment.mime);
     const renderFrom = Math.max(0, info.renderFrom || 0);
     const renderPlaceholder = visionFile ? makeRenderPlaceholder(attachment.storagePath) : void 0;
+    const renderDetail = platform === "openai" ? getRenderImageDetail(info.model || DEFAULT_OPENAI_MODEL) : void 0;
     const skapiRender = visionFile && renderPlaceholder ? {
       _skapi_render: [
-        { path: attachment.storagePath, from: renderFrom, count: RENDER_PAGES_PER_WINDOW, placeholder: renderPlaceholder, name: attachment.name, mime: attachment.mime }
+        {
+          path: attachment.storagePath,
+          from: renderFrom,
+          count: RENDER_PAGES_PER_WINDOW,
+          placeholder: renderPlaceholder,
+          name: attachment.name,
+          mime: attachment.mime,
+          detail: renderDetail,
+          auto_continue: true,
+          continue_text: buildIndexingRenderContinueTemplate(attachment, renderPlaceholder)
+        }
+      ]
+    } : {};
+    const windowedRead = !visionFile && !parsedContent && windowedIndexingEnabled() && isWindowedReadFile(attachment.name, attachment.mime);
+    const windowPlaceholder = windowedRead ? makeWindowPlaceholder(attachment.storagePath) : void 0;
+    const skapiWindow = windowedRead && windowPlaceholder ? {
+      _skapi_window: [
+        {
+          path: attachment.storagePath,
+          cursor: null,
+          placeholder: windowPlaceholder,
+          name: attachment.name,
+          mime: attachment.mime,
+          kind: "window",
+          auto_continue: true,
+          continue_text: buildIndexingWindowMessage(attachment, windowPlaceholder, true)
+        }
       ]
     } : {};
-    const pagedRead = !visionFile && (continuing || !parsedContent && isPagedReadFile(attachment.name, attachment.mime));
-    const serverExtract = !visionFile && !continuing && !parsedContent && !pagedRead && isServerExtractable(attachment.name, attachment.mime);
+    const pagedRead = !visionFile && !windowedRead && (continuing || !parsedContent && isPagedReadFile(attachment.name, attachment.mime));
+    const serverExtract = !visionFile && !windowedRead && !continuing && !parsedContent && !pagedRead && isServerExtractable(attachment.name, attachment.mime);
     const placeholder = serverExtract ? makeExtractPlaceholder(attachment.storagePath) : void 0;
     const extractContent = serverExtract && placeholder ? [{ path: attachment.storagePath, placeholder, name: attachment.name, mime: attachment.mime }] : void 0;
     const skapiExtract = extractContent && extractContent.length ? { _skapi_extract: extractContent } : {};
-    const userMessage = visionFile && renderPlaceholder ? buildIndexingRenderMessage(attachment, renderPlaceholder, renderFrom) : continuing ? buildIndexingContinueMessage(attachment) : buildIndexingUserMessage(
+    const userMessage = visionFile && renderPlaceholder ? buildIndexingRenderMessage(attachment, renderPlaceholder, renderFrom) : windowedRead && windowPlaceholder ? buildIndexingWindowMessage(attachment, windowPlaceholder, false) : continuing ? buildIndexingContinueMessage(attachment) : buildIndexingUserMessage(
       attachment,
       parsedContent ? { inlineContent: parsedContent } : placeholder ? { inlineContentPlaceholder: placeholder } : pagedRead ? { pagedRead: true } : void 0
     );
@@ -911,6 +1141,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           max_output_tokens: MAX_TOKENS,
           ...skapiExtract,
           ...skapiRender,
+          ...skapiWindow,
           input: [
             { role: "system", content: systemPrompt },
             {
@@ -956,6 +1187,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         max_tokens: MAX_TOKENS,
         ...skapiExtract,
         ...skapiRender,
+        ...skapiWindow,
         system: [
           {
             type: "text",
@@ -1027,9 +1259,15 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     return "";
   }
   var BG_INDEXING_QUEUE_SUFFIX = "-bg";
+  function isBgIndexingQueue(queueName) {
+    if (typeof queueName !== "string" || !queueName) return false;
+    const prefix = queueName.split("|")[0];
+    const idx = prefix.lastIndexOf(":");
+    const name = idx === -1 ? prefix : prefix.slice(idx + 1);
+    return name.slice(-BG_INDEXING_QUEUE_SUFFIX.length) === BG_INDEXING_QUEUE_SUFFIX;
+  }
   var INDEXING_COMPLETE_MARKER = "INDEXING_COMPLETE";
   var MAX_INDEXING_RESUME_PASSES = 6;
-  var MAX_VISION_RESUME_PASSES = 40;
   async function getChatHistory(params, fetchOptions) {
     const url = params.platform === "claude" ? ANTHROPIC_MESSAGES_API_URL : OPENAI_RESPONSES_API_URL;
     const p = Object.assign(
@@ -1093,18 +1331,29 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       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;
           }
@@ -1116,6 +1365,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         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);
@@ -1143,6 +1393,91 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     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() {
@@ -1157,6 +1492,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       cb(nowMs());
     }, 16);
   }
+  function isPollStopped(res) {
+    return !!res && typeof res === "object" && res.status === "stopped";
+  }
   var ChatSession = class {
     constructor(host) {
       this.typewriterQueue = Promise.resolve();
@@ -1177,11 +1515,104 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       };
       this.bgTaskQueue = [];
       this.cancelledServerIds = /* @__PURE__ */ new Set();
+      this.cancelledIndexKeys = /* @__PURE__ */ new Set();
       this.pendingAgentRequests = {};
       this.aiChatHistoryCache = {};
       this.historyItemPolls = /* @__PURE__ */ new Map();
+      this._pauseReasons = /* @__PURE__ */ new Set();
+      this._resuming = false;
       this._lidSeq = 0;
     }
+    /**
+     * Register a live poll so (a) a remount dedupes against it instead of stacking a
+     * SECOND poll on the same item, and (b) pausePolling can stop it.
+     *
+     * `stop` comes from the SDK and may be absent on an older skapi-js, in which case the
+     * poll simply cannot be stopped and is left running — see pausePolling.
+     */
+    _trackPoll(id, kind, p) {
+      var stop = p && typeof p.stop === "function" ? p.stop.bind(p) : void 0;
+      if (!stop) {
+        console.debug("[chat-engine] poll has no stop handle", { id, kind });
+      }
+      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;
+    }
+    /**
+     * Stop BACKGROUND polling until resumePolling. Foreground polls (a reply the user is
+     * waiting on) keep running deliberately: their results must still land in the history
+     * cache so resumePendingRequest can render them on return, otherwise a user who sends
+     * a message then navigates away comes back to a permanently stuck "Thinking...".
+     *
+     * Server-side work is untouched; this only stops asking about it. That is safe for
+     * document indexing because the worker drives that loop itself.
+     */
+    pausePolling(reason) {
+      this._pauseReasons.add(reason || "paused");
+      var self = this;
+      var stopped = [];
+      this.historyItemPolls.forEach(function(handle, id) {
+        if (!handle || handle.kind !== "bg") return;
+        if (typeof handle.stop !== "function") return;
+        try {
+          handle.stop();
+        } catch (e) {
+        }
+        stopped.push(id);
+      });
+      stopped.forEach(function(id) {
+        self.historyItemPolls.delete(id);
+      });
+    }
+    /**
+     * Lift a pause reason WITHOUT running the reconcile. For a caller that is about to
+     * reload history anyway (a view remounting), letting resumePolling also reconcile
+     * would race that load and can double-attach.
+     */
+    clearPauseReason(reason) {
+      this._pauseReasons.delete(reason || "paused");
+    }
+    /**
+     * Clear a pause reason and, once none remain, re-attach polling and reconcile.
+     * Deliberately does NOT touch gateRefreshToken: bumping it would silently discard
+     * the results of anything still in flight across the pause.
+     */
+    resumePolling(reason) {
+      this._pauseReasons.delete(reason || "paused");
+      if (this._pauseReasons.size > 0 || this._resuming) return Promise.resolve();
+      if (!this.host.isViewMounted || !this.host.isViewMounted()) return Promise.resolve();
+      var self = this;
+      this._resuming = true;
+      return Promise.resolve().then(function() {
+        self.drainBgTaskQueue();
+        return self.loadHistory(false, self.state.gateRefreshToken);
+      }).catch(function(e) {
+        console.error("[chat-engine] resume polling failed", e);
+      }).then(function() {
+        self._resuming = false;
+      });
+    }
     _newLocalId() {
       this._lidSeq += 1;
       return "lid_" + this._lidSeq;
@@ -1195,29 +1626,97 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       var key = this.getHistoryCacheKey();
       if (!key) return;
       this.aiChatHistoryCache[key] = {
-        messages: this.state.messages.slice(),
+        messages: this.state.messages.filter(function(m) {
+          return m._ownerKey === void 0 || m._ownerKey === key;
+        }),
         endOfList: this.state.historyEndOfList,
         startKeyHistory: this.state.historyStartKeyHistory.slice()
       };
     }
-    _callProviderFor(platform, prompt, messages, system, model, userId, extractContent, fileUrls) {
-      var id = this.host.getIdentity();
-      return platform === "openai" ? callOpenAIWithPublicMcp(prompt, id.serviceId, id.owner, messages, system, model, userId, extractContent, fileUrls) : callClaudeWithPublicMcp(prompt, id.serviceId, id.owner, messages, system, model, userId, extractContent, fileUrls);
+    /**
+     * Land a resolved reply in the history cache of a chat that is NOT currently
+     * visible, without touching state.messages. Mirrors the cache-only path in
+     * dispatchAgentRequest: REPLACE the trailing pending "Thinking..." bubble
+     * (append only when there is none), and settle the matching pending user
+     * bubble, so the cached copy never keeps a stuck "Thinking..." that a later
+     * cache-first load would re-render forever.
+     */
+    _applyReplyToCache(key, reply, serverId) {
+      if (!key) return;
+      var existing = this.aiChatHistoryCache[key] || { messages: [], endOfList: false, startKeyHistory: [] };
+      var msgs = existing.messages.slice();
+      var thIdx = -1;
+      for (var i = msgs.length - 1; i >= 0; i--) {
+        var m = msgs[i];
+        if (!m || !m.isPending || m.role !== "assistant" || m.isBackgroundTask) continue;
+        if (serverId && m._serverItemId && m._serverItemId !== serverId) continue;
+        thIdx = i;
+        break;
+      }
+      if (thIdx !== -1) {
+        if (reply._serverItemId === void 0 && msgs[thIdx]._serverItemId !== void 0) reply._serverItemId = msgs[thIdx]._serverItemId;
+        msgs[thIdx] = reply;
+      } else {
+        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];
+        if (!u || u.role !== "user" || u.isBackgroundTask) continue;
+        if (!(u.isPendingQueued || u.isPendingInProcess || u.isSendingToServer)) continue;
+        if (serverId && u._serverItemId && u._serverItemId !== serverId) continue;
+        var settled = { role: "user", content: u.content };
+        if (u._serverItemId !== void 0) settled._serverItemId = u._serverItemId;
+        if (u._ownerKey !== void 0) settled._ownerKey = u._ownerKey;
+        msgs[j] = settled;
+        break;
+      }
+      this.aiChatHistoryCache[key] = {
+        messages: msgs,
+        endOfList: existing.endOfList,
+        startKeyHistory: existing.startKeyHistory
+      };
+    }
+    /**
+     * serviceId/owner are passed explicitly by every caller: a request can be
+     * dispatched after the user moved to another project, and re-reading the live
+     * identity here would silently send the turn to THAT project instead of the
+     * one it was composed for. Falls back to the live read only when a caller
+     * omits them.
+     */
+    _callProviderFor(platform, prompt, messages, system, model, userId, extractContent, fileUrls, serviceId, owner) {
+      if (serviceId === void 0 || owner === void 0) {
+        var id = this.host.getIdentity();
+        if (serviceId === void 0) serviceId = id.serviceId;
+        if (owner === void 0) owner = id.owner;
+      }
+      return platform === "openai" ? callOpenAIWithPublicMcp(prompt, serviceId, owner, messages, system, model, userId, extractContent, fileUrls) : callClaudeWithPublicMcp(prompt, serviceId, owner, messages, system, model, userId, extractContent, fileUrls);
     }
     dispatchAgentRequest(params) {
       var self = this;
       var dispatchItemId;
       var sendAndPoll = function() {
         return Promise.resolve(
-          self._callProviderFor(params.aiPlatform, params.text, params.boundedMessages, params.systemPrompt, params.aiModel, params.userId, params.extractContent, params.fileUrls)
+          self._callProviderFor(params.aiPlatform, params.text, params.boundedMessages, params.systemPrompt, params.aiModel, params.userId, params.extractContent, params.fileUrls, params.serviceId, params.owner)
         ).then(function(initial) {
           if (initial && initial.poll && (initial.status === "pending" || initial.status === "running")) {
             if (initial.id) {
               if (dispatchItemId && dispatchItemId !== initial.id) self.historyItemPolls.delete(dispatchItemId);
               dispatchItemId = initial.id;
-              self.historyItemPolls.set(initial.id, true);
             }
-            return initial.poll({ latency: POLL_INTERVAL });
+            var dp = initial.poll({ latency: POLL_INTERVAL });
+            if (initial.id) self._trackPoll(initial.id, "fg", dp);
+            return dp;
           }
           return initial;
         });
@@ -1270,20 +1769,57 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     // composed = clean display text; composedForLlm carries office-extraction
     // placeholders for the provider only. useBgQueue routes a post-attachment turn
     // onto the "-bg" queue so it runs after indexing.
-    dispatchComposedMessage(composed, useBgQueue, composedForLlm, extractContent, fileUrls) {
+    dispatchComposedMessage(composed, useBgQueue, composedForLlm, extractContent, fileUrls, pinned) {
       var self = this;
       if (!composed) return;
-      var id = this.host.getIdentity();
+      var id = pinned ? pinned.identity : this.host.getIdentity();
       if (id.platform === "none") return;
       var llmComposed = composedForLlm || composed;
-      var isQueuedSend = useBgQueue || this.state.sending || this.state.messages.some(function(m) {
+      var key = !id.serviceId ? "" : id.serviceId + "#" + id.platform;
+      var offChat = !!key && key !== this.getHistoryCacheKey();
+      var isQueuedSend = !offChat && (useBgQueue || this.state.sending || this.state.messages.some(function(m) {
         return (m.isPending || m.isPendingQueued) && !m.isBackgroundTask && !m._useBgQueue;
-      });
+      }));
       var aiPlatform = id.platform;
       var aiModel = id.model || void 0;
-      var systemPrompt = this.host.buildSystemPrompt();
+      var systemPrompt = pinned ? pinned.systemPrompt : this.host.buildSystemPrompt();
       var userId = id.userId || id.serviceId;
       var chatQueue = useBgQueue ? userId + BG_INDEXING_QUEUE_SUFFIX : userId;
+      if (offChat) {
+        var offHistory = (this.aiChatHistoryCache[key] ? this.aiChatHistoryCache[key].messages : []).filter(function(m) {
+          return !m.isPending && !m.isPendingQueued && !m.isPendingInProcess && !m.isPendingOlder && !m.isCancelled && !m.isBackgroundTask;
+        });
+        var offBounded = buildBoundedChatMessages({
+          platform: aiPlatform,
+          model: aiModel,
+          systemPrompt,
+          serviceId: id.serviceId,
+          history: offHistory.concat([{ role: "user", content: llmComposed }])
+        });
+        var offExisting = this.aiChatHistoryCache[key] || { messages: [], endOfList: false, startKeyHistory: [] };
+        this.aiChatHistoryCache[key] = {
+          messages: offExisting.messages.concat([
+            { role: "user", content: composed, _ownerKey: key },
+            { role: "assistant", content: "", isPending: true, isPendingInProcess: true, _ownerKey: key }
+          ]),
+          endOfList: offExisting.endOfList,
+          startKeyHistory: offExisting.startKeyHistory
+        };
+        this.dispatchAgentRequest({
+          key,
+          serviceId: id.serviceId,
+          owner: id.owner,
+          aiPlatform,
+          aiModel,
+          systemPrompt,
+          text: composed,
+          boundedMessages: offBounded.messages,
+          userId: chatQueue,
+          extractContent,
+          fileUrls
+        });
+        return;
+      }
       if (isQueuedSend) {
         var resolvedHistory = this.state.messages.filter(function(m) {
           return !m.isPending && !m.isPendingQueued && !m.isPendingInProcess && !m.isPendingOlder && !m.isCancelled && !m.isBackgroundTask;
@@ -1296,15 +1832,16 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           history: resolvedHistory.concat([{ role: "user", content: llmComposed }])
         });
         var queuedBubble = { role: "user", content: composed, isPendingQueued: true, isSendingToServer: true };
+        if (key) queuedBubble._ownerKey = key;
         if (useBgQueue) queuedBubble._useBgQueue = true;
         this.state.messages.push(queuedBubble);
         this.host.notify();
         this.updateHistoryCache();
         this.host.scrollToBottom(true);
-        var capturedComposed = composed, capturedPlatform = aiPlatform;
-        Promise.resolve(this._callProviderFor(aiPlatform, composed, boundedQ.messages, systemPrompt, aiModel, chatQueue, extractContent, fileUrls)).then(function(result) {
-          var sendingIdx = self.state.messages.findIndex(function(m) {
-            return m.isSendingToServer && (m.isPendingQueued || m.isPendingInProcess) && m.role === "user";
+        var capturedComposed = composed, capturedPlatform = aiPlatform, capturedKey = key;
+        Promise.resolve(this._callProviderFor(aiPlatform, composed, boundedQ.messages, systemPrompt, aiModel, chatQueue, extractContent, fileUrls, id.serviceId, id.owner)).then(function(result) {
+          var sendingIdx = self.getHistoryCacheKey() !== capturedKey ? -1 : self.state.messages.findIndex(function(m) {
+            return m.isSendingToServer && (m.isPendingQueued || m.isPendingInProcess) && m.role === "user" && (m._ownerKey === void 0 || m._ownerKey === capturedKey);
           });
           var serverId = result && typeof result.id === "string" ? result.id : void 0;
           if (sendingIdx >= 0) {
@@ -1314,26 +1851,27 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             self.host.notify();
           }
           if (result && result.poll && (result.status === "pending" || result.status === "running")) {
-            if (serverId) self.historyItemPolls.set(serverId, true);
-            return result.poll({ latency: POLL_INTERVAL }).then(function(res) {
-              return self.onQueuedSendResponse(capturedComposed, res, capturedPlatform, serverId);
+            var qp = result.poll({ latency: POLL_INTERVAL });
+            if (serverId) self._trackPoll(serverId, "fg", qp);
+            return qp.then(function(res) {
+              if (isPollStopped(res)) return;
+              return self.onQueuedSendResponse(capturedComposed, res, capturedPlatform, serverId, capturedKey);
             }).catch(function(err) {
-              return self.onQueuedSendError(capturedComposed, err, serverId);
+              return self.onQueuedSendError(capturedComposed, err, serverId, capturedKey);
             });
           }
-          return self.onQueuedSendResponse(capturedComposed, result, capturedPlatform, serverId);
+          return self.onQueuedSendResponse(capturedComposed, result, capturedPlatform, serverId, capturedKey);
         }).catch(function(err) {
-          return self.onQueuedSendError(capturedComposed, err, void 0);
+          return self.onQueuedSendError(capturedComposed, err, void 0, capturedKey);
         });
         return;
       }
-      this.state.messages.push({ role: "user", content: composed });
-      this.state.messages.push({ role: "assistant", content: "", isPending: true, isPendingInProcess: true });
+      this.state.messages.push({ role: "user", content: composed, ...key ? { _ownerKey: key } : {} });
+      this.state.messages.push({ role: "assistant", content: "", isPending: true, isPendingInProcess: true, ...key ? { _ownerKey: key } : {} });
       this.host.notify();
       this.updateHistoryCache();
       this.state.sending = true;
       this.host.scrollToBottom(true);
-      var key = this.getHistoryCacheKey();
       var historyForLlm = this.state.messages.filter(function(m) {
         return !m.isCancelled && !m.isBackgroundTask;
       });
@@ -1367,10 +1905,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       });
       Promise.resolve(run).catch(function() {
       }).then(function() {
-        if (!(self.host.isViewMounted() && self.getHistoryCacheKey() === key)) return;
         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);
         });
       });
     }
@@ -1384,10 +1922,13 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       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;
       var placeholder = { role: "assistant", content: "", isPending: true, isPendingInProcess: true, isBackgroundTask: true };
       if (existing._serverItemId !== void 0) placeholder._serverItemId = existing._serverItemId;
+      if (existing._ownerKey !== void 0) placeholder._ownerKey = existing._ownerKey;
       this.state.messages.splice(nextIdx + 1, 0, placeholder);
       this.host.notify();
     }
@@ -1402,15 +1943,22 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       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;
       this.state.messages[nextIdx] = promoted;
       var placeholder = { role: "assistant", content: "", isPending: true };
       if (existing._serverItemId !== void 0) placeholder._serverItemId = existing._serverItemId;
+      if (existing._ownerKey !== void 0) placeholder._ownerKey = existing._ownerKey;
       this.state.messages.splice(nextIdx + 1, 0, placeholder);
       this.host.notify();
     }
     resolveQueuedUserBubble(serverId) {
+      var liveKey = this.getHistoryCacheKey();
+      var isLocal = function(m) {
+        return m._ownerKey === void 0 || m._ownerKey === liveKey;
+      };
       var userIdx = -1;
       if (serverId) {
         userIdx = this.state.messages.findIndex(function(m) {
@@ -1419,19 +1967,19 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       }
       if (userIdx === -1) {
         userIdx = this.state.messages.findIndex(function(m) {
-          return m.isPendingInProcess && m.role === "user" && !m.isBackgroundTask && !m._useBgQueue;
+          return m.isPendingInProcess && m.role === "user" && !m.isBackgroundTask && !m._useBgQueue && isLocal(m);
         });
       }
       if (userIdx === -1) {
         userIdx = this.state.messages.findIndex(function(m) {
-          return m.isPendingQueued && m.role === "user" && !m.isBackgroundTask && !m._useBgQueue;
+          return m.isPendingQueued && m.role === "user" && !m.isBackgroundTask && !m._useBgQueue && isLocal(m);
         });
       }
       if (serverId && this.cancelledServerIds.has(serverId)) {
         this.cancelledServerIds.delete(serverId);
         if (userIdx >= 0) {
           var ex = this.state.messages[userIdx];
-          this.state.messages[userIdx] = { role: "user", content: ex.content, isCancelled: true, _serverItemId: ex._serverItemId };
+          this.state.messages[userIdx] = { role: "user", content: ex.content, isCancelled: true, _serverItemId: ex._serverItemId, ...ex._ownerKey !== void 0 ? { _ownerKey: ex._ownerKey } : {} };
           var thIdx = this.state.messages.findIndex(function(m, i) {
             return i > userIdx && m.isPending && m.role === "assistant" && !m.isBackgroundTask;
           });
@@ -1444,6 +1992,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         var exist = this.state.messages[userIdx];
         var repl = { role: "user", content: exist.content };
         if (exist._serverItemId !== void 0) repl._serverItemId = exist._serverItemId;
+        if (exist._ownerKey !== void 0) repl._ownerKey = exist._ownerKey;
         this.state.messages[userIdx] = repl;
       }
       var thinkingIdx = userIdx >= 0 ? this.state.messages.findIndex(function(m, i) {
@@ -1456,8 +2005,14 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       else if (targetIdx >= 0) this.state.messages.splice(targetIdx, 0, msg);
       else this.state.messages.push(msg);
     }
-    onQueuedSendResponse(_composed, response, platform, serverId) {
+    onQueuedSendResponse(_composed, response, platform, serverId, ownerKey) {
       if (serverId) this.historyItemPolls.delete(serverId);
+      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);
+        if (serverId) this.cancelledServerIds.delete(serverId);
+        return;
+      }
       var targetIdx = this.resolveQueuedUserBubble(serverId);
       if (targetIdx === void 0) {
         this.host.notify();
@@ -1489,10 +2044,16 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       this.promoteNextQueuedToRunning();
       this.updateHistoryCache();
       this.host.notify();
-      this.host.scrollToBottom(true);
+      this.host.scrollToBottomIfSticky(true);
     }
-    onQueuedSendError(_composed, err, serverId) {
+    onQueuedSendError(_composed, err, serverId, ownerKey) {
       if (serverId) this.historyItemPolls.delete(serverId);
+      if (ownerKey && this.getHistoryCacheKey() !== ownerKey) {
+        var isGone = err && (err.code === "NOT_EXISTS" || err.body && err.body.code === "NOT_EXISTS");
+        this._applyReplyToCache(ownerKey, isGone ? { role: "assistant", content: "Request was cancelled.", isError: true } : { role: "assistant", content: getErrorMessage(err), isError: true }, serverId);
+        if (serverId) this.cancelledServerIds.delete(serverId);
+        return;
+      }
       var isNotExists = err && (err.code === "NOT_EXISTS" || err.body && err.body.code === "NOT_EXISTS");
       if (isNotExists) {
         var userIdx = serverId ? this.state.messages.findIndex(function(m) {
@@ -1533,7 +2094,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         this.promoteNextQueuedToRunning();
         this.updateHistoryCache();
         this.host.notify();
-        this.host.scrollToBottom(true);
+        this.host.scrollToBottomIfSticky(true);
         return;
       }
       var targetIdx = this.resolveQueuedUserBubble(serverId);
@@ -1547,7 +2108,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       this.promoteNextQueuedToRunning();
       this.updateHistoryCache();
       this.host.notify();
-      this.host.scrollToBottom(true);
+      this.host.scrollToBottomIfSticky(true);
     }
     cancelQueuedMessage(msg, idx) {
       var self = this;
@@ -1571,6 +2132,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       })).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;
           });
@@ -1579,7 +2141,13 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             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";
             });
@@ -1616,6 +2184,42 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
       });
     }
+    /**
+     * 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
@@ -1802,6 +2406,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       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
@@ -1819,13 +2424,13 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         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);
         });
       });
     }
@@ -1844,8 +2449,17 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       });
       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;
@@ -1853,7 +2467,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         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;
       }
@@ -1862,25 +2476,124 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       });
       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) {
@@ -1896,39 +2609,70 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       }
       this.bgTaskQueue.forEach(function(entry) {
         if (entry.serviceId !== svcId || entry.platform !== plat) return;
-        if (presentIds[entry.id]) return;
-        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 };
-        if (isRunning) userBubble.isPendingInProcess = true;
-        else userBubble.isPendingQueued = true;
-        self.state.messages.push(userBubble);
-        if (isRunning) {
-          self.state.messages.push({ role: "assistant", content: "", isPending: true, isPendingInProcess: true, isBackgroundTask: true, _serverItemId: entry.id });
+        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, !!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);
+          if (isRunning) {
+            self.state.messages.push({ role: "assistant", content: "", isPending: true, isPendingInProcess: true, isBackgroundTask: true, _serverItemId: entry.id });
+          }
+          presentIds[entry.id] = true;
+          self.host.notify();
+          self.updateHistoryCache();
+          self.host.scrollToBottomIfSticky(false);
         }
-        presentIds[entry.id] = true;
-        self.host.notify();
-        self.updateHistoryCache();
-        self.host.scrollToBottom(false);
-        if (!self.historyItemPolls.has(entry.id) && typeof entry.poll === "function") {
-          self.historyItemPolls.set(entry.id, true);
+        if (!self.isPollingPaused() && !self.historyItemPolls.has(entry.id) && typeof entry.poll === "function") {
           var capturedId = entry.id, capturedPlat = plat;
           var capturedEntry = entry;
-          entry.poll({ latency: POLL_INTERVAL }).then(function(response) {
+          var wasStopped = false;
+          var bp = entry.poll({ latency: POLL_INTERVAL });
+          self._trackPoll(entry.id, "bg", bp);
+          bp.then(function(response) {
+            if (isPollStopped(response)) {
+              wasStopped = true;
+              return;
+            }
             self.handleHistoryItemResolution(capturedId, response, capturedPlat);
             self.maybeResumeIndexing(capturedEntry, response, capturedPlat);
           }).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) {
               return q.id === capturedId;
             });
@@ -1939,25 +2683,32 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       this.promoteNextBgQueuedToRunning();
     }
     // Resume-across-passes: if a background INDEXING task for a paged file (spreadsheet or
-    // PDF) finished WITHOUT the completion marker, the agent ran out of room before reading
+    // text) finished WITHOUT the completion marker, the agent ran out of room before reading
     // the whole file - dispatch a CONTINUE pass (up to a cap) that resumes from where the
     // already-saved records leave off. Additive + guarded so it never loops forever and
     // never breaks the resolution path.
+    //
+    // VISION files (PDFs rendered to page images) are NOT resumed here: the proxy worker
+    // advances their page window itself, off the renderer's true page count. Driving them
+    // from the browser is what used to lose pages on long documents - the chain lived in tab
+    // memory (a reload or a closed tab ended it), and it stopped whenever the model claimed
+    // completion, which on an 88-page file happened at page 15. Continuing to dispatch here
+    // as well would now double-index every window.
     maybeResumeIndexing(entry, response, platform) {
       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;
         var pass = (entry.resumePass || 0) + 1;
-        var isVision = isImageVisionFile(entry.filename, entry.mime);
-        var maxPasses = isVision ? MAX_VISION_RESUME_PASSES : MAX_INDEXING_RESUME_PASSES;
-        if (pass > maxPasses) return;
+        if (pass > MAX_INDEXING_RESUME_PASSES) return;
         var id = this.host.getIdentity();
         if (!id || id.platform === "none" || id.serviceId !== entry.serviceId) return;
-        var renderFrom = isVision ? pass * RENDER_PAGES_PER_WINDOW : void 0;
         notifyAgentContinueIndexing({
           platform: id.platform,
           model: id.model,
@@ -1966,7 +2717,6 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           userId: id.userId || id.serviceId,
           serviceName: id.serviceName,
           serviceDescription: id.serviceDescription,
-          renderFrom,
           attachment: {
             name: entry.filename,
             storagePath: entry.storagePath,
@@ -2006,6 +2756,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     loadHistory(fetchMore, token) {
       var self = this;
       var id = this.host.getIdentity();
+      var loadKey = !id.serviceId || id.platform === "none" ? "" : id.serviceId + "#" + id.platform;
       if (token === void 0) token = this.state.gateRefreshToken;
       if (this.state.loadingHistory && this.state.historyRequestToken === token || id.platform === "none" || !id.serviceId) {
         return Promise.resolve();
@@ -2028,9 +2779,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         if (token !== self.state.gateRefreshToken) return;
         var chatList = history && Array.isArray(history.list) ? history.list : [];
         chatList.forEach(function(item) {
-          if (typeof item.queue_name === "string" && item.queue_name.slice(-BG_INDEXING_QUEUE_SUFFIX.length) === BG_INDEXING_QUEUE_SUFFIX) {
+          if (isBgIndexingQueue(item.queue_name)) {
             var userText = extractLastUserTextFromRequest(item.request_body);
-            if (typeof userText === "string" && userText.indexOf("A new file has just been uploaded") === 0) item._isBgTask = true;
+            if (typeof userText === "string" && (userText.indexOf("A new file has just been uploaded") === 0 || userText.indexOf("CONTINUE indexing") === 0)) item._isBgTask = true;
             else item._isOnBgQueue = true;
           }
         });
@@ -2043,6 +2794,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           serviceId: id.serviceId,
           formatIndexingLabel: self.host.formatIndexingLabel
         }).messages;
+        var keptOlderPages = false;
         if (fetchMore) {
           self.state.messages = mapped.concat(self.state.messages);
         } else {
@@ -2053,7 +2805,12 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           });
           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;
@@ -2062,6 +2819,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           for (var ri = 0; ri < self.state.messages.length; ri++) {
             var mm = self.state.messages[ri];
             if (mm.isBackgroundTask) continue;
+            if (mm._ownerKey !== void 0 && mm._ownerKey !== loadKey) continue;
             if (mm._serverItemId && serverIds[mm._serverItemId]) continue;
             if (!mm._serverItemId) {
               if (mappedHasPendingAssistant) continue;
@@ -2072,7 +2830,22 @@ Index the REMAINING windows - one record per row/item, looking at any page image
               }
             }
           }
-          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);
           });
@@ -2080,19 +2853,38 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             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;
@@ -2106,11 +2898,12 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             if (!item.poll || !item.id) return;
             if (self.historyItemPolls.has(item.id)) return;
             if (self.pendingAgentRequests[self.getHistoryCacheKey()] && !item._isBgTask && !item._isOnBgQueue) return;
-            self.historyItemPolls.set(item.id, true);
+            if ((item._isBgTask || item._isOnBgQueue) && self.isPollingPaused()) return;
             var capturedId = item.id;
             var pp = item.poll({
               latency: POLL_INTERVAL,
               onResponse: function(response) {
+                if (isPollStopped(response)) return;
                 self.handleHistoryItemResolution(capturedId, response, platform);
               },
               onError: function(err) {
@@ -2120,18 +2913,25 @@ Index the REMAINING windows - one record per row/item, looking at any page image
                   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();
@@ -2146,12 +2946,13 @@ Index the REMAINING windows - one record per row/item, looking at any page image
                 }
               }
             });
+            self._trackPoll(capturedId, item._isBgTask || item._isOnBgQueue ? "bg" : "fg", pp);
             if (pp && pp.catch) pp.catch(function() {
             });
           });
           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() {
@@ -2161,6 +2962,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           self.state.loadingOlderHistory = false;
           if (wasLoading) self.host.notify();
         }
+        if (self.host.onHistoryLoaded) self.host.onHistoryLoaded(!!fetchMore, token);
       });
     }
     // --- attachment upload orchestration ---------------------------------
@@ -2358,11 +3160,194 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
   };
 
+  // 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;
+  }
+
   // src/index.js
   (function() {
     var MCP_PROD = "https://mcp.broadwayinc.computer";
     var MCP_DEV = "https://mcp-dev.broadwayinc.computer";
-    var BQ_VERSION = "1.6.0" ;
+    var BQ_VERSION = "1.7.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";
@@ -3574,6 +4559,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       if (CS.composerEl && CS.chatEl && CS.composerEl.parentNode !== CS.chatEl) CS.chatEl.appendChild(CS.composerEl);
       renderMessages();
       scrollToBottom();
+      ensureHistoryFillsViewport();
     }
     function renderAccount() {
       if (!CS.messagesBox) return;
@@ -3941,8 +4927,12 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     var CS = {
       messages: [],
+      // Rendered .bq-message nodes, indexed BY MESSAGE INDEX (sparse: a message
+      // folded into a collapsed indexing row has no node of its own).
       messageEls: [],
-      // parallel rendered .bq-message nodes
+      // Expanded background-indexing rows, keyed by RUN (group.runKey), not by
+      // file: re-indexing a file is a separate row and expands separately.
+      indexGroupsOpen: {},
       messagesBox: null,
       // .bq-messages element
       sending: false,
@@ -4012,14 +5002,21 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       scrollToBottomIfSticky: function(smooth) {
         return scrollToBottomIfSticky(smooth);
       },
+      // A first page can render shorter than the box (a file's every indexing
+      // pass folds into ONE row), and a box that cannot scroll never fires the
+      // scroll-to-top that is the sole trigger for loading page 2. Page out of
+      // it here — only the view can measure.
+      onHistoryLoaded: function(fetchMore, token) {
+        if (!fetchMore) ensureHistoryFillsViewport(token);
+      },
       cancelRequest: function(opts) {
         return S.skapi.cancelClientSecretRequest(opts);
       },
       refreshSession: function() {
         return refreshSkapiSession();
       },
-      formatIndexingLabel: function(name, mime, size, storagePath, reindex) {
-        return buildIndexingLabel(name, mime, size, storagePath, reindex);
+      formatIndexingLabel: function(name, mime, size, storagePath, reindex, continued) {
+        return buildIndexingLabel(name, mime, size, storagePath, reindex, continued);
       },
       isViewMounted: function() {
         return !!CS.messagesBox;
@@ -4219,7 +5216,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       if (!CS.messagesBox || CS.chatSettingsOpen) return;
       var el = CS.messagesBox;
       CS.stickToBottom = el.scrollHeight - el.scrollTop - el.clientHeight <= 16;
-      if (el.scrollTop <= 60) fetchOlderHistoryIfNeeded();
+      if (el.scrollTop <= 60) pageOlderHistoryUntilTaller();
     }
     var _touchStartY = 0;
     function onMessagesWheel(e) {
@@ -4232,23 +5229,6 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       var y = e.touches && e.touches[0] ? e.touches[0].clientY : 0;
       if (y > _touchStartY + 4) CS.stickToBottom = false;
     }
-    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 getOrCreateFileHref(filename, body) {
       var key = filename + "\0" + body;
       var existing = fileBlobCache.get(key);
@@ -4289,41 +5269,13 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       return "<a " + attrs.join(" ") + ">" + escapeHtml(labelText) + "</a>";
     }
     function buildLinkPartFromGroups(full, g1, g2, g3, g4, g5, g6) {
-      var dbHostPrefix = "https://db." + hostDomain();
-      if (g1) {
-        var rawPath = normalizeTrailingInlineToken(g1);
-        var consumed = "src::" + rawPath;
-        var tail = full.slice(consumed.length);
-        var isUrl = /^https?:\/\//i.test(rawPath);
-        if (isUrl && /^https:\/\//i.test(rawPath) && rawPath.toLowerCase().indexOf(dbHostPrefix.toLowerCase()) !== 0) {
-          return { part: { type: "link", label: truncateLabelForDisplay(rawPath), fullLabel: rawPath, href: rawPath, expired: false }, tail };
+      return classifyInlineLink(full, [g1, g2, g3, g4, g5, g6], {
+        serviceId: S.serviceId,
+        dbHostPrefix: "https://db." + hostDomain(),
+        resolveFreshHref: function(expiredHref) {
+          return refreshedExpiredLinkMap[expiredHref];
         }
-        var remotePath = isUrl ? extractRemotePathFromAttachmentHref(rawPath, S.serviceId) || normalizeAttachmentPathCandidate(rawPath) : normalizeAttachmentPathCandidate(rawPath);
-        if (!remotePath) return null;
-        var expiredHref = buildDisplayExpiredAttachmentHref(remotePath, remotePath);
-        var cached = refreshedExpiredLinkMap[expiredHref];
-        return { part: { type: "link", label: truncateLabelForDisplay(remotePath), fullLabel: remotePath, href: cached || expiredHref, expired: !cached, expiredHref, remotePath }, tail };
-      }
-      if (g4 && g5) {
-        var rp = normalizeAttachmentPathCandidate(g5);
-        if (!rp) return null;
-        var eh = buildDisplayExpiredAttachmentHref(rp, rp);
-        var c2 = refreshedExpiredLinkMap[eh];
-        return { part: { type: "link", label: truncateLabelForDisplay(g4), fullLabel: g4, href: c2 || eh, expired: !c2, expiredHref: eh, remotePath: rp } };
-      }
-      var originalHref = g3 || g6 || "";
-      if (!originalHref) return null;
-      if (/^https:\/\//i.test(originalHref) && originalHref.toLowerCase().indexOf(dbHostPrefix.toLowerCase()) !== 0) {
-        var plainLabel = g2 || originalHref;
-        return { part: { type: "link", label: truncateLabelForDisplay(plainLabel), fullLabel: plainLabel, href: originalHref, expired: false } };
-      }
-      var rmp = extractRemotePathFromAttachmentHref(originalHref, S.serviceId);
-      var fbLabel = g2 || originalHref;
-      var ehref = rmp ? buildDisplayExpiredAttachmentHref(rmp, fbLabel) : originalHref;
-      var cfresh = refreshedExpiredLinkMap[ehref];
-      var expired = !!rmp && !cfresh;
-      var fullLabel = rmp ? getExpiredAttachmentVisiblePath(rmp, g2 || originalHref) : g2 || originalHref;
-      return { part: { type: "link", label: truncateLabelForDisplay(fullLabel), fullLabel, href: cfresh || ehref, expired, expiredHref: ehref, remotePath: rmp || void 0 } };
+      });
     }
     function parseMsgPartsHtml(content) {
       var placeholderHtml = [];
@@ -4389,9 +5341,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       if (n < 1024 * 1024) return (n / 1024).toFixed(1) + " KB";
       return (n / (1024 * 1024)).toFixed(1) + " MB";
     }
-    function buildIndexingLabel(name, mime, size, storagePath, reindex) {
-      var extras = [];
+    function buildIndexingLabel(name, mime, size, storagePath, reindex, continued) {
       var nameLabel = storagePath ? "[" + name + "](" + storagePath + ")" : name;
+      if (continued) return "Indexing (continuing) " + nameLabel;
+      var extras = [];
       if (mime) extras.push(mime);
       if (size != null && size !== "" && !isNaN(Number(size))) extras.push(formatBytes(size));
       return (reindex ? "Reindexing: " : "Indexing: ") + nameLabel + (extras.length ? " \xB7 " + extras.join(" \xB7 ") : "");
@@ -4462,16 +5415,17 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       return S.skapi.deleteRecords({ service: S.serviceId, unique_id: "src::" + storagePath }).catch(function() {
       });
     }
-    function getTemporaryUrlDb(path, expires) {
-      return S.skapi.util.request("get-signed-url", {
+    function getTemporaryUrlDb(path, expires, cdn) {
+      var body = {
         service: S.serviceId,
         owner: S.owner,
         request: "get-db",
         key: path,
-        expires: expires,
-        contentType: mimeGetType(path) || "application/octet-stream",
-        generate_temporary_cdn_url: true
-      }, { auth: true, method: "post" }).then(function(res) {
+        expires: expires || ATTACHMENT_URL_EXPIRES_SECONDS,
+        contentType: mimeGetType(path) || "application/octet-stream"
+      };
+      if (cdn !== false) body.generate_temporary_cdn_url = true;
+      return S.skapi.util.request("get-signed-url", body, { auth: true, method: "post" }).then(function(res) {
         var u = typeof res === "string" ? res : res && res.url;
         if (!u) throw new Error("No temporary URL returned.");
         return "https://db." + hostDomain() + "/" + u;
@@ -4975,7 +5929,21 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     function getPublicTemporaryUrl(remotePath) {
       if (!remotePath) return Promise.reject(new Error("Missing attachment path."));
-      return getTemporaryUrlDb(remotePath, ATTACHMENT_URL_EXPIRES_SECONDS);
+      return getTemporaryUrlDb(remotePath, EXPIRED_LINK_REFRESH_EXPIRES_SECONDS, false);
+    }
+    var refreshedLinkExpiryTimer = null;
+    function expireAllRefreshedLinks() {
+      for (var k in refreshedExpiredLinkMap) delete refreshedExpiredLinkMap[k];
+    }
+    function scheduleNextLinkExpiryBoundary() {
+      if (refreshedLinkExpiryTimer) clearTimeout(refreshedLinkExpiryTimer);
+      var now = Date.now();
+      var next = Math.ceil(now / LINK_REFRESH_WINDOW_MS) * LINK_REFRESH_WINDOW_MS;
+      refreshedLinkExpiryTimer = setTimeout(function() {
+        expireAllRefreshedLinks();
+        renderMessages();
+        scheduleNextLinkExpiryBoundary();
+      }, Math.max(1, next - now));
     }
     function fetchFreshHrefForExpiredLink(expiredHref, remotePath) {
       var cached = refreshedExpiredLinkMap[expiredHref];
@@ -4988,6 +5956,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         if (!resolved) return Promise.reject(new Error("Unable to refresh this expired attachment link."));
         return getPublicTemporaryUrl(resolved).then(function(fresh) {
           refreshedExpiredLinkMap[expiredHref] = fresh;
+          scheduleNextLinkExpiryBoundary();
           return fresh;
         });
       })().then(
@@ -5046,15 +6015,77 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       if (key) lsSet(key, String(ts));
     }
     function fetchOlderHistoryIfNeeded() {
-      if (CS.loadingHistory || CS.loadingOlderHistory || CS.historyEndOfList) return;
-      var prevH = CS.messagesBox ? CS.messagesBox.scrollHeight : 0;
-      var prevT = CS.messagesBox ? CS.messagesBox.scrollTop : 0;
-      session.loadHistory(true).then(function() {
-        if (!CS.messagesBox) return;
-        raf2().then(function() {
-          if (!CS.messagesBox) return;
-          CS.messagesBox.scrollTop = prevT + (CS.messagesBox.scrollHeight - prevH);
-        });
+      if (CS.historyEndOfList) return Promise.resolve(true);
+      if (CS.loadingHistory || CS.loadingOlderHistory) return Promise.resolve(false);
+      return session.loadHistory(true).then(function() {
+        return true;
+      });
+    }
+    function messagesBoxCanScroll() {
+      if (!CS.messagesBox || CS.chatSettingsOpen) return true;
+      return CS.messagesBox.scrollHeight - CS.messagesBox.clientHeight > HISTORY_FILL_SLACK_PX;
+    }
+    function topVisibleRowKey() {
+      var box = CS.messagesBox;
+      if (!box) return null;
+      var boxTop = box.getBoundingClientRect().top;
+      var kids = box.children;
+      for (var i = 0; i < kids.length; i++) {
+        var key = kids[i].getAttribute && kids[i].getAttribute("data-row-key");
+        if (!key) continue;
+        if (kids[i].getBoundingClientRect().top - boxTop + kids[i].offsetHeight > 0) return key;
+      }
+      return null;
+    }
+    function contentAboveRow(key) {
+      var box = CS.messagesBox;
+      if (!box) return null;
+      var boxTop = box.getBoundingClientRect().top;
+      var kids = box.children;
+      for (var i = 0; i < kids.length; i++) {
+        if (!kids[i].getAttribute || kids[i].getAttribute("data-row-key") !== key) continue;
+        return kids[i].getBoundingClientRect().top - boxTop + box.scrollTop;
+      }
+      return null;
+    }
+    var _historyFillToken = 0;
+    var _historyFiller = createHistoryFiller({
+      isEndOfList: function() {
+        return !!CS.historyEndOfList;
+      },
+      isLoading: function() {
+        return !!(CS.loadingHistory || CS.loadingOlderHistory);
+      },
+      // The settings panel occupies the messages box and suppresses
+      // renderMessages, so a fill started before it opened must stop.
+      isStale: function() {
+        return _historyFillToken !== CS.gateRefreshToken || !CS.messagesBox || CS.chatSettingsOpen;
+      },
+      messageCount: function() {
+        return CS.messages.length;
+      },
+      fetchOlder: function() {
+        return fetchOlderHistoryIfNeeded();
+      }
+    });
+    function pageOlderHistoryUntil(isSatisfied, token) {
+      if (token === void 0) token = CS.gateRefreshToken;
+      if (token !== CS.gateRefreshToken) return Promise.resolve();
+      _historyFillToken = token;
+      return _historyFiller.fill(function() {
+        return raf2().then(isSatisfied);
+      });
+    }
+    function ensureHistoryFillsViewport(token) {
+      return pageOlderHistoryUntil(messagesBoxCanScroll, token);
+    }
+    function pageOlderHistoryUntilTaller() {
+      var anchorKey = topVisibleRowKey();
+      var before = anchorKey ? contentAboveRow(anchorKey) : null;
+      return pageOlderHistoryUntil(function() {
+        if (!CS.messagesBox || !anchorKey || before === null) return true;
+        var now = contentAboveRow(anchorKey);
+        return now === null || now > before + HISTORY_FILL_SLACK_PX;
       });
     }
     function openClearHistoryModal() {
@@ -5148,6 +6179,102 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       }
       return h("div", { class: cls.join(" "), dataset: { msgIndex: String(idx) } }, bubble);
     }
+    var INDEX_ICON_ACTIVE = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M20.5 12a8.5 8.5 0 0 1-8.5 8.5 8.5 8.5 0 0 1-7.6-4.7"/><path d="M3.5 12A8.5 8.5 0 0 1 12 3.5a8.5 8.5 0 0 1 7.6 4.7"/><path d="M20 3.6v4.8h-4.8"/><path d="M4 20.4v-4.8h4.8"/></svg>';
+    var INDEX_ICON_DONE = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M4 12.5l5 5L20 6.5"/></svg>';
+    var INDEX_ICON_ERROR = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9"/><path d="M12 7.5v5.5"/><path d="M12 16.6h.01"/></svg>';
+    var INDEX_ICON_CANCELLED = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9"/><path d="M8.2 8.2l7.6 7.6"/></svg>';
+    function indexGroupIcon(group) {
+      if (group.status === "active") return INDEX_ICON_ACTIVE;
+      if (group.status === "error") return INDEX_ICON_ERROR;
+      if (group.status === "cancelled") return INDEX_ICON_CANCELLED;
+      return INDEX_ICON_DONE;
+    }
+    function indexGroupVerb(group) {
+      if (group.status === "active") return group.isReindex ? "Reindexing" : "Indexing";
+      if (group.status === "error") return "Indexing failed:";
+      if (group.status === "cancelled") return "Indexing cancelled:";
+      return group.isReindex ? "Reindexed" : "Indexed";
+    }
+    function indexGroupLabel(group) {
+      var nameLabel = group.path ? "[" + group.name + "](" + group.path + ")" : group.name;
+      return indexGroupVerb(group) + " " + nameLabel;
+    }
+    function indexGroupCount(group) {
+      if (group.passCount <= 1 && !group.mayHaveOlder) return "";
+      return group.passCount + (group.mayHaveOlder ? "+" : "") + " passes";
+    }
+    function toggleIndexGroup(key) {
+      if (CS.indexGroupsOpen[key]) delete CS.indexGroupsOpen[key];
+      else CS.indexGroupsOpen[key] = true;
+      renderMessages();
+      ensureHistoryFillsViewport();
+    }
+    function buildIndexGroupEl(group, isOpen) {
+      var cls = ["bq-index-group"];
+      if (group.status === "active") cls.push("is-active");
+      if (group.status === "error") cls.push("is-error");
+      if (isOpen) cls.push("is-open");
+      var label = h("span", { class: "bq-index-label", html: parseMsgPartsHtml(indexGroupLabel(group)) });
+      label.addEventListener("click", function(e) {
+        if (e.target && e.target.closest && e.target.closest("a")) e.stopPropagation();
+        onBubbleLinkClick(e);
+      });
+      var cancelBtn = null;
+      if (group.cancellableIds.length || group.cancelling) {
+        cancelBtn = h("button", {
+          class: "bq-index-cancel" + (group.cancelling ? " is-disabled" : ""),
+          type: "button",
+          title: group.cancelling ? "Stopping..." : "Stop indexing this file",
+          "aria-label": "Stop indexing " + group.name,
+          text: group.cancelling ? "Stopping..." : "Stop"
+        });
+        if (group.cancelling) cancelBtn.disabled = true;
+        else cancelBtn.addEventListener("click", function(e) {
+          e.stopPropagation();
+          session.cancelIndexingGroup(group);
+        });
+        cancelBtn.addEventListener("keydown", function(e) {
+          e.stopPropagation();
+        });
+      }
+      var head = h(
+        "div",
+        {
+          class: "bq-index-head",
+          role: "button",
+          tabindex: "0",
+          "aria-expanded": isOpen ? "true" : "false",
+          title: isOpen ? "Hide indexing steps" : "Show indexing steps",
+          onclick: function() {
+            toggleIndexGroup(group.runKey);
+          },
+          onkeydown: function(e) {
+            if (e.key !== "Enter" && e.key !== " " && e.key !== "Spacebar") return;
+            e.preventDefault();
+            toggleIndexGroup(group.runKey);
+          }
+        },
+        h("span", { class: "bq-index-icon", html: indexGroupIcon(group) }),
+        label,
+        indexGroupCount(group) ? h("span", { class: "bq-index-count", text: indexGroupCount(group) }) : null,
+        cancelBtn,
+        h("span", { class: "bq-index-chevron", text: "\u25B6" })
+      );
+      var el = h("div", { class: cls.join(" ") }, head);
+      if (group.cancelError) {
+        el.appendChild(h("div", {
+          class: "bq-index-note is-error",
+          text: "Could not stop this file: " + group.cancelError
+        }));
+      }
+      if (isOpen && group.mayHaveOlder) {
+        el.appendChild(h("div", {
+          class: "bq-index-note",
+          text: "Earlier passes of this file are further back in the conversation. Scroll up to load them."
+        }));
+      }
+      return el;
+    }
     function historyLoadingEl(initial) {
       if (initial) {
         return h(
@@ -5163,9 +6290,54 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         h("span", { class: "bq-loader" })
       );
     }
+    function rowAnchorKey(msg, index) {
+      if (!msg) return null;
+      var id = msg._serverItemId || msg._localId;
+      return id ? "s" + id + ":" + msg.role : "i" + index;
+    }
+    function indexGroupAnchorId(group) {
+      var last = group.members[group.members.length - 1];
+      return last && last.msg && last.msg._serverItemId || "";
+    }
+    function captureScrollAnchor() {
+      var box = CS.messagesBox;
+      if (!box || CS.stickToBottom) return null;
+      var boxTop = box.getBoundingClientRect().top;
+      var kids = box.children;
+      var fallback = null;
+      for (var i = 0; i < kids.length; i++) {
+        if (!kids[i].getAttribute) continue;
+        var key = kids[i].getAttribute("data-row-key");
+        if (!key) continue;
+        var top = kids[i].getBoundingClientRect().top - boxTop;
+        if (top + kids[i].offsetHeight <= 0) continue;
+        var cand = { key, top, scrollTop: box.scrollTop, pos: kids[i].getAttribute("data-row-pos") };
+        if (cand.pos === null) return cand;
+        if (!fallback) fallback = cand;
+      }
+      return fallback || { key: null, top: 0, scrollTop: box.scrollTop };
+    }
+    function restoreScrollAnchor(anchor) {
+      var box = CS.messagesBox;
+      if (!box) return;
+      if (!anchor || CS.stickToBottom) {
+        box.scrollTop = box.scrollHeight;
+        return;
+      }
+      var boxTop = box.getBoundingClientRect().top;
+      var kids = box.children;
+      for (var i = 0; anchor.key && i < kids.length; i++) {
+        if (!kids[i].getAttribute || kids[i].getAttribute("data-row-key") !== anchor.key) continue;
+        if (anchor.pos && kids[i].getAttribute("data-row-pos") !== anchor.pos) break;
+        box.scrollTop += kids[i].getBoundingClientRect().top - boxTop - anchor.top;
+        return;
+      }
+      box.scrollTop = anchor.scrollTop;
+    }
     function renderMessages() {
       if (!CS.messagesBox) return;
       if (CS.chatSettingsOpen) return;
+      var anchor = captureScrollAnchor();
       clear(CS.messagesBox);
       CS.messageEls = [];
       if (CS.loadingOlderHistory) CS.messagesBox.appendChild(historyLoadingEl(false));
@@ -5186,23 +6358,44 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         CS.messagesBox.appendChild(greet);
         return;
       }
-      CS.messages.forEach(function(msg, idx) {
-        var el = buildMessageEl(msg, idx);
-        CS.messageEls.push(el);
+      var rows = buildChatDisplayList(CS.messages, { hasMoreHistory: !CS.historyEndOfList });
+      rows.forEach(function(row) {
+        if (row.kind === "indexing") {
+          var isOpen = !!CS.indexGroupsOpen[row.group.runKey];
+          var groupEl = buildIndexGroupEl(row.group, isOpen);
+          groupEl.setAttribute("data-row-key", "g" + row.group.runKey);
+          groupEl.setAttribute("data-row-pos", indexGroupAnchorId(row.group));
+          CS.messagesBox.appendChild(groupEl);
+          if (!isOpen) return;
+          row.group.members.forEach(function(member) {
+            var pass = buildMessageEl(member.msg, member.index);
+            pass.classList.add("bq-index-pass");
+            pass.setAttribute("data-row-key", rowAnchorKey(member.msg, member.index));
+            CS.messageEls[member.index] = pass;
+            CS.messagesBox.appendChild(pass);
+          });
+          return;
+        }
+        var el = buildMessageEl(row.msg, row.index);
+        el.setAttribute("data-row-key", rowAnchorKey(row.msg, row.index));
+        CS.messageEls[row.index] = el;
         CS.messagesBox.appendChild(el);
       });
+      restoreScrollAnchor(anchor);
     }
     function refreshMessageBubble(idx) {
       if (idx < 0 || idx >= CS.messages.length) return;
       var oldEl = CS.messageEls[idx];
       if (!oldEl || !oldEl.parentNode) return;
       var newEl = buildMessageEl(CS.messages[idx], idx);
+      if (oldEl.classList.contains("bq-index-pass")) newEl.classList.add("bq-index-pass");
       oldEl.parentNode.replaceChild(newEl, oldEl);
       CS.messageEls[idx] = newEl;
     }
     function renderChat() {
       CS.messages = [];
       CS.messageEls = [];
+      CS.indexGroupsOpen = {};
       CS.sending = false;
       CS.typing = false;
       CS.typingAbort = true;
@@ -5620,12 +6813,24 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         S._resizeBound = true;
         window.addEventListener("resize", function() {
           scheduleAttachmentOverflowRecompute();
+          scrollToBottomIfSticky(false);
+          ensureHistoryFillsViewport();
         });
       }
       if (!S._visBound && typeof document !== "undefined" && document.addEventListener) {
         S._visBound = true;
         document.addEventListener("visibilitychange", function() {
-          if (document.visibilityState === "visible" && S.user) ensureMcpGrantFresh();
+          if (document.visibilityState === "hidden") {
+            if (session && session.pausePolling) session.pausePolling("hidden");
+            return;
+          }
+          if (document.visibilityState === "visible") {
+            var refreshed = S.user ? ensureMcpGrantFresh() : null;
+            Promise.resolve(refreshed).catch(function() {
+            }).then(function() {
+              if (session && session.resumePolling) session.resumePolling("hidden");
+            });
+          }
         });
       }
       boot();