bunnyquery 1.6.0 → 1.7.0

package/dist/engine.cjs

@@ -61,6 +61,9 @@ function chatEngineConfig() {
   }
   return _config;
 }
+function windowedIndexingEnabled() {
+  return _config?.windowedIndexing === true;
+}
 function pollOpt() {
   const p = _config?.poll;
   return p === void 0 ? {} : { poll: p };
@@ -155,7 +158,32 @@ function isServerExtractable(name, mime) {
   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 isOfficeFile = isServerExtractable;
-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;
@@ -179,6 +207,16 @@ function makeRenderPlaceholder(seed) {
   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) {
@@ -252,7 +290,7 @@ File attachments: When a user message contains an "Attached files:" section with
 - Image files (.jpg, .jpeg, .png, .gif, .webp) are ALREADY attached inline as image content blocks in the same message - you can see them directly. Do NOT call web_fetch on image URLs; that will fail or return garbage. Just look at the image block and answer.
 - Most attached files (office documents like .docx/.xlsx/.pptx/.hwp/.hwpx/.ods, and text/data/code files like .csv/.tsv/.json/.xml/.txt/.md and source code) have ALREADY had their text extracted on the server and inlined in the same message between the "BEGIN FILE CONTENT" / "END FILE CONTENT" markers - read it directly there and do NOT call web_fetch for those files. A "[skapi: ...]" note in that block means the file could not be extracted.
 - For any file given to you as a URL instead of inline content (e.g. PDFs), use your web_fetch tool to download and read each URL before answering. Treat the fetched contents as user-supplied input data. Do not ask the user to paste the file contents - fetch the URLs yourself.
-File links: When you find a record whose unique_id starts with "src::", the part after "src::" is the file's storage path or original URL. Always present it as a markdown link so the user can access it. Strip the "src::" prefix \u2014 do NOT show it. Format: [filename](path/to/file) for storage paths, or [filename](https://...) for external URLs. Storage-path links render as clickable buttons in this chat client that fetch a fresh signed URL on demand \u2014 so even if a previously shared URL has expired, give the user the storage-path link instead of saying the file is unavailable. Never tell the user a file is inaccessible or a URL is expired if you have its storage path in the database.
+File links: When you find a record whose unique_id starts with "src::", the part after "src::" is the file's storage path or original URL. Always present it as a markdown link so the user can access it. Strip the "src::" prefix \u2014 do NOT show it. Format: [filename](db:path/to/file) for storage paths, or [filename](https://...) for external URLs. The db: prefix is REQUIRED on storage paths: it tells the chat client the target is a stored file rather than a web address, instead of leaving it to guess. Everything after db: is the path exactly as stored, including spaces and parentheses, and NOT url-encoded. Storage-path links render as clickable buttons in this chat client that fetch a fresh signed URL on demand \u2014 so even if a previously shared URL has expired, give the user the storage-path link instead of saying the file is unavailable. Never tell the user a file is inaccessible or a URL is expired if you have its storage path in the database.
 File lookup: When the user asks to see, list, or show files (e.g. "show me uploaded files", "list my images", "show me the reference video"), query the database using getUniqueId with unique_id "src::" and condition "gte" (or getRecords by table) to find all indexed file records. Present each result as a markdown link as described above. Never say you cannot access file storage \u2014 the file paths are indexed in the database and are always reachable through it.
 File generation: When the user asks you to generate a file \u2014 or to produce specifically-formatted text such as HTML, CSV, JSON, or Markdown \u2014 put the file's full contents inside a fenced code block whose info string is the intended filename WITH its extension (e.g. report.csv), NOT a language name like "csv". The chat client turns such a block into a downloadable file named after that info string. Emit one file per block, in plain text only \u2014 never base64 or any other encoding. Example for CSV:
 \`\`\`filename.csv
@@ -326,32 +364,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 ${positionLabel || 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}`;
@@ -461,8 +527,10 @@ function isAuthExpiredError(input) {
 var EXPIRED_ATTACHMENT_URL_HOST = "_expired_.url";
 var EXPIRED_ATTACHMENT_URL_ORIGIN = "https://" + EXPIRED_ATTACHMENT_URL_HOST;
 var LINK_LABEL_MAX_DISPLAY_CHARS = 32;
+var EXPIRED_LINK_REFRESH_EXPIRES_SECONDS = 20 * 60;
+var LINK_REFRESH_WINDOW_MS = (EXPIRED_LINK_REFRESH_EXPIRES_SECONDS - 5 * 60) * 1e3;
 function createInlineLinkRegex() {
-  return /src::(\S+)|\[([^\]\n]+)\]\((https?:\/\/(?:[^\s()]+|\([^\s()]*\))+)\)|\[([^\]\n]+)\]\(((?:[^()\n]+|\([^()\n]*\))+)\)|(https?:\/\/[^\s<>"']+)/g;
+  return /src::(\S+)|\[([^\]\n]+)\]\((https?:\/\/(?:[^\s()]|\([^\s()]*\))+)\)|\[([^\]\n]+)\]\(((?:[^()\n]|\([^()\n]*\))+)\)|(https?:\/\/[^\s<>"']+)/g;
 }
 function safeDecodeURIComponent(v) {
   try {
@@ -522,18 +590,150 @@ function isServiceDbAttachmentHref(href, serviceId) {
     return false;
   }
 }
+function readExpiredAttachmentHref(href) {
+  if (!href) return null;
+  try {
+    var parsed = new URL(href);
+    if (parsed.hostname !== EXPIRED_ATTACHMENT_URL_HOST) return null;
+    return normalizeAttachmentPathCandidate(parsed.pathname || "") || null;
+  } catch (e) {
+    return null;
+  }
+}
 function sanitizeAttachmentLinksForHistory(content, serviceId, forAssistant) {
   if (!content) return content;
   if (!forAssistant && content.indexOf("Attached files:") === -1) return content;
   return content.replace(/\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)/g, function(_m, label, href) {
-    if (forAssistant && !isServiceDbAttachmentHref(href, serviceId)) return _m;
+    if (!isServiceDbAttachmentHref(href, serviceId)) return _m;
     var remotePath = extractRemotePathFromAttachmentHref(href, serviceId);
-    var labelPath = normalizeAttachmentPathCandidate(label);
-    var fullPath = remotePath || labelPath;
-    if (!fullPath) return forAssistant ? _m : "[" + label + "](" + EXPIRED_ATTACHMENT_URL_ORIGIN + "/file)";
+    var fullPath = remotePath || normalizeAttachmentPathCandidate(label);
+    if (!fullPath) return _m;
     return "[" + label + "](" + buildDisplayExpiredAttachmentHref(fullPath, label) + ")";
   });
 }
+function isHttpUrlLike(target) {
+  return /^https?:\/\//i.test((target || "").trim());
+}
+function repairUrlWhitespace(href) {
+  if (!href || !/\s/.test(href)) return href;
+  var stripped = href.replace(/\s+/g, "");
+  if (/^https?:\/\/[^/\s]+\/download\/[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)?$/i.test(stripped)) return stripped;
+  return href.trim().replace(/\s/g, "%20");
+}
+function normalizeTrailingInlineToken(value) {
+  if (!value) return value;
+  var out = value.replace(/[.,;:!?]+$/, "");
+  var trimUnmatched = function(openCh, closeCh) {
+    while (out.charAt(out.length - 1) === closeCh) {
+      var openCount = (out.match(new RegExp("\\" + openCh, "g")) || []).length;
+      var closeCount = (out.match(new RegExp("\\" + closeCh, "g")) || []).length;
+      if (closeCount > openCount) out = out.slice(0, -1);
+      else break;
+    }
+  };
+  trimUnmatched("(", ")");
+  trimUnmatched("[", "]");
+  trimUnmatched("{", "}");
+  out = out.replace(/[`'"*>]+$/, "");
+  return out;
+}
+function classifyInlineLink(full, groups, ctx) {
+  var g1 = groups[0], g2 = groups[1], g3 = groups[2], g4 = groups[3], g5 = groups[4], g6 = groups[5];
+  var dbHostPrefix = (ctx.dbHostPrefix || "").toLowerCase();
+  var fresh = function(expiredHref) {
+    return ctx.resolveFreshHref ? ctx.resolveFreshHref(expiredHref) : void 0;
+  };
+  var isDbHost = function(url) {
+    return !!dbHostPrefix && url.toLowerCase().indexOf(dbHostPrefix) === 0;
+  };
+  var asStoredFile = function(remotePath2, label) {
+    if (!remotePath2) return null;
+    var expiredHref = buildDisplayExpiredAttachmentHref(remotePath2, label);
+    var cached = fresh(expiredHref);
+    return {
+      part: {
+        type: "link",
+        label: truncateLabelForDisplay(label),
+        fullLabel: label,
+        href: cached || expiredHref,
+        expired: !cached,
+        expiredHref,
+        remotePath: remotePath2
+      }
+    };
+  };
+  if (g1) {
+    var rawPath = normalizeTrailingInlineToken(g1);
+    var tail = full.slice(("src::" + rawPath).length);
+    var srcIsUrl = isHttpUrlLike(rawPath);
+    if (srcIsUrl && !isDbHost(rawPath) && !readExpiredAttachmentHref(rawPath)) {
+      return {
+        part: { type: "link", label: truncateLabelForDisplay(rawPath), fullLabel: rawPath, href: rawPath, expired: false },
+        tail
+      };
+    }
+    var srcPath = readExpiredAttachmentHref(rawPath) || (srcIsUrl ? extractRemotePathFromAttachmentHref(rawPath, ctx.serviceId) || normalizeAttachmentPathCandidate(rawPath) : normalizeAttachmentPathCandidate(rawPath));
+    var srcBuilt = asStoredFile(srcPath, srcPath);
+    return srcBuilt ? { part: srcBuilt.part, tail } : null;
+  }
+  if (g4 && g5) {
+    var dbTarget = /^db:(.+)$/i.exec(g5.trim());
+    if (dbTarget) {
+      var declared = asStoredFile(normalizeAttachmentPathCandidate(dbTarget[1]), g4);
+      if (!declared) return null;
+      declared.part.label = truncateLabelForDisplay(g4);
+      declared.part.fullLabel = g4;
+      return declared;
+    }
+    if (isHttpUrlLike(g5)) {
+      return classifyInlineLink(full, [void 0, g4, repairUrlWhitespace(g5), void 0, void 0, void 0], ctx);
+    }
+    var trimmedTarget = g5.trim();
+    if (/^[a-z][a-z0-9+.-]*:/i.test(trimmedTarget) || trimmedTarget.charAt(0) === "#") {
+      return {
+        part: { type: "link", label: truncateLabelForDisplay(g4), fullLabel: g4, href: trimmedTarget, expired: false }
+      };
+    }
+    var built = asStoredFile(normalizeAttachmentPathCandidate(g5), g4);
+    if (!built) return null;
+    built.part.label = truncateLabelForDisplay(g4);
+    built.part.fullLabel = g4;
+    return built;
+  }
+  var originalHref = g3 || g6 || "";
+  if (!originalHref) return null;
+  var urlTail;
+  if (!g3 && g6) {
+    var trimmedUrl = normalizeTrailingInlineToken(originalHref);
+    if (trimmedUrl !== originalHref) urlTail = originalHref.slice(trimmedUrl.length);
+    originalHref = trimmedUrl;
+  }
+  var withTail = function(r) {
+    return urlTail ? { part: r.part, tail: urlTail } : r;
+  };
+  var urlLabel = g2 || originalHref;
+  var carried = readExpiredAttachmentHref(originalHref);
+  if (carried) {
+    var carriedBuilt = asStoredFile(carried, g2 || carried);
+    if (carriedBuilt) {
+      if (g2) {
+        carriedBuilt.part.label = truncateLabelForDisplay(g2);
+        carriedBuilt.part.fullLabel = g2;
+      }
+      return withTail(carriedBuilt);
+    }
+  }
+  if (isServiceDbAttachmentHref(originalHref, ctx.serviceId)) {
+    var remotePath = extractRemotePathFromAttachmentHref(originalHref, ctx.serviceId);
+    if (remotePath) {
+      var dbBuilt = asStoredFile(remotePath, getExpiredAttachmentVisiblePath(remotePath, urlLabel));
+      if (dbBuilt) return withTail(dbBuilt);
+    }
+  }
+  return withTail({
+    part: { type: "link", label: truncateLabelForDisplay(urlLabel), fullLabel: urlLabel, href: originalHref, expired: false }
+  });
+}
 function truncateLabelForDisplay(label) {
   if (!label) return label;
   if (label.length <= LINK_LABEL_MAX_DISPLAY_CHARS) return label;
@@ -619,24 +819,27 @@ var DEFAULT_OPENAI_IMAGE_DETAIL = "auto";
 var OPENAI_WEB_SEARCH_EXTERNAL_WEB_ACCESS = true;
 var MCP_NAME = "BunnyQuery";
 var DEFAULT_CLAUDE_MODEL = "claude-sonnet-4-6";
-var DEFAULT_OPENAI_MODEL = "gpt-5.4";
+var DEFAULT_OPENAI_MODEL = "gpt-5.6-luna";
 var mcpUrl = () => chatEngineConfig().mcpBaseUrl;
 var clientSecretRequest = (opts) => chatEngineConfig().clientSecretRequest(opts);
 var getOpenAIImageDetail = (model) => {
   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) {
@@ -881,17 +1084,44 @@ async function notifyAgentSaveAttachment(info) {
   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 pagedRead = !visionFile && (continuing || !parsedContent && isPagedReadFile(attachment.name, attachment.mime));
-  const serverExtract = !visionFile && !continuing && !parsedContent && !pagedRead && isServerExtractable(attachment.name, attachment.mime);
+  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 && !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
   );
@@ -920,6 +1150,7 @@ async function notifyAgentSaveAttachment(info) {
         max_output_tokens: MAX_TOKENS,
         ...skapiExtract,
         ...skapiRender,
+        ...skapiWindow,
         input: [
           { role: "system", content: systemPrompt },
           {
@@ -965,6 +1196,7 @@ async function notifyAgentSaveAttachment(info) {
       max_tokens: MAX_TOKENS,
       ...skapiExtract,
       ...skapiRender,
+      ...skapiWindow,
       system: [
         {
           type: "text",
@@ -1061,9 +1293,15 @@ async function listOpenAIModels(service, owner) {
   });
 }
 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(
@@ -1127,18 +1365,29 @@ function mapHistoryListToMessages(list, platform, opts) {
     var serverItemId = item && typeof item.id === "string" && item.id ? item.id : void 0;
     if (userText) {
       var displayContent;
+      var indexFile = void 0;
       if (item._isBgTask) {
         var nameMatch = userText.match(/^- name: (.+)$/m);
         if (nameMatch) {
           var mimeMatch = userText.match(/^- mime type: (.+)$/m);
           var sizeMatch = userText.match(/^- size \(bytes\): (\d+)$/m);
           var pathMatch = userText.match(/^- storage path: (.+)$/m);
+          var isContinuePass = userText.indexOf("CONTINUE indexing") === 0;
           displayContent = opts.formatIndexingLabel(
             nameMatch[1].trim(),
             mimeMatch ? mimeMatch[1].trim() : "",
             sizeMatch ? Number(sizeMatch[1]) : null,
-            pathMatch ? pathMatch[1].trim() : void 0
+            pathMatch ? pathMatch[1].trim() : void 0,
+            false,
+            isContinuePass
           );
+          indexFile = {
+            name: nameMatch[1].trim(),
+            path: pathMatch ? pathMatch[1].trim() : void 0,
+            mime: mimeMatch ? mimeMatch[1].trim() : void 0,
+            size: sizeMatch ? Number(sizeMatch[1]) : void 0,
+            continued: isContinuePass
+          };
         } else {
           displayContent = userText;
         }
@@ -1150,6 +1399,7 @@ function mapHistoryListToMessages(list, platform, opts) {
       if (isQueued) userMsg.isPendingQueued = true;
       if (isCancelledItem) userMsg.isCancelled = true;
       if (item._isBgTask) userMsg.isBackgroundTask = true;
+      if (indexFile) userMsg._indexFile = indexFile;
       if (item._isOnBgQueue) userMsg._useBgQueue = true;
       if (serverItemId !== void 0) userMsg._serverItemId = serverItemId;
       mapped.push(userMsg);
@@ -1177,6 +1427,91 @@ function mapHistoryListToMessages(list, platform, opts) {
   return { messages: mapped, runningItemIds };
 }
 
+// src/engine/viewport_fill.ts
+var HISTORY_FILL_SLACK_PX = 64;
+var MAX_HISTORY_FILL_PAGES = 24;
+var IDLE_WAIT_STEP_MS = 120;
+var IDLE_WAIT_MAX_MS = 15e3;
+async function waitForIdle(opts, stale) {
+  var waited = 0;
+  while (opts.isLoading()) {
+    if (stale() || waited >= IDLE_WAIT_MAX_MS) return false;
+    await new Promise(function(r) {
+      setTimeout(r, IDLE_WAIT_STEP_MS);
+    });
+    waited += IDLE_WAIT_STEP_MS;
+  }
+  return !stale();
+}
+async function fillHistoryViewport(opts) {
+  var maxPages = typeof opts.maxPages === "number" ? opts.maxPages : MAX_HISTORY_FILL_PAGES;
+  var stale = function() {
+    return !!(opts.isStale && opts.isStale());
+  };
+  var swallowed = 0;
+  for (var page = 0; page < maxPages; page++) {
+    if (stale() || opts.isEndOfList()) return;
+    if (!await waitForIdle(opts, stale)) return;
+    var satisfied = false;
+    try {
+      satisfied = !!await opts.isSatisfied();
+    } catch {
+      return;
+    }
+    if (satisfied || stale()) return;
+    if (!await waitForIdle(opts, stale)) return;
+    var before = opts.messageCount();
+    var attempted;
+    try {
+      attempted = await opts.fetchOlder();
+    } catch {
+      return;
+    }
+    if (stale()) return;
+    if (attempted === false) {
+      if (++swallowed > 3) return;
+      page--;
+      continue;
+    }
+    if (opts.messageCount() <= before) return;
+  }
+}
+function createHistoryFiller(base) {
+  var pending = [];
+  var running = false;
+  async function allSatisfied() {
+    var next = [];
+    for (var i = 0; i < pending.length; i++) {
+      if (!await pending[i]()) next.push(pending[i]);
+    }
+    pending = next;
+    return pending.length === 0;
+  }
+  return {
+    isRunning: function() {
+      return running;
+    },
+    fill: function(isSatisfied) {
+      pending.push(isSatisfied);
+      if (running) return Promise.resolve();
+      running = true;
+      var done = function() {
+        running = false;
+        pending = [];
+      };
+      return fillHistoryViewport({
+        isSatisfied: allSatisfied,
+        isEndOfList: base.isEndOfList,
+        isLoading: base.isLoading,
+        messageCount: base.messageCount,
+        fetchOlder: base.fetchOlder,
+        isStale: base.isStale,
+        maxPages: base.maxPages
+      }).then(done, done);
+    }
+  };
+}
+
 // src/engine/session.ts
 var _g = typeof globalThis !== "undefined" ? globalThis : {};
 function nowMs() {
@@ -1191,6 +1526,9 @@ function nextFrame(cb) {
     cb(nowMs());
   }, 16);
 }
+function isPollStopped(res) {
+  return !!res && typeof res === "object" && res.status === "stopped";
+}
 var ChatSession = class {
   constructor(host) {
     this.typewriterQueue = Promise.resolve();
@@ -1211,11 +1549,104 @@ var ChatSession = class {
     };
     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;
@@ -1229,29 +1660,97 @@ var ChatSession = class {
     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;
       });
@@ -1304,20 +1803,57 @@ var ChatSession = class {
   // 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;
@@ -1330,15 +1866,16 @@ var ChatSession = class {
         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) {
@@ -1348,26 +1885,27 @@ var ChatSession = class {
           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;
     });
@@ -1401,10 +1939,10 @@ var ChatSession = class {
     });
     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);
       });
     });
   }
@@ -1418,10 +1956,13 @@ var ChatSession = class {
     if (nextIdx === -1) return;
     var existing = this.state.messages[nextIdx];
     var promoted = { role: "user", content: existing.content, isPendingInProcess: true, isBackgroundTask: true };
+    if (existing._indexFile) promoted._indexFile = existing._indexFile;
     if (existing._serverItemId !== void 0) promoted._serverItemId = existing._serverItemId;
+    if (existing._ownerKey !== void 0) promoted._ownerKey = existing._ownerKey;
     this.state.messages[nextIdx] = promoted;
     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();
   }
@@ -1436,15 +1977,22 @@ var ChatSession = class {
     var existing = this.state.messages[nextIdx];
     var promoted = { role: "user", content: existing.content, isPendingInProcess: true };
     if (existing.isBackgroundTask) promoted.isBackgroundTask = true;
+    if (existing._indexFile) promoted._indexFile = existing._indexFile;
     if (existing._serverItemId !== void 0) promoted._serverItemId = existing._serverItemId;
+    if (existing._ownerKey !== void 0) promoted._ownerKey = existing._ownerKey;
     if (existing.isSendingToServer) promoted.isSendingToServer = true;
     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) {
@@ -1453,19 +2001,19 @@ var ChatSession = class {
     }
     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;
         });
@@ -1478,6 +2026,7 @@ var ChatSession = class {
       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) {
@@ -1490,8 +2039,14 @@ var ChatSession = class {
     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();
@@ -1523,10 +2078,16 @@ var ChatSession = class {
     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) {
@@ -1567,7 +2128,7 @@ var ChatSession = class {
       this.promoteNextQueuedToRunning();
       this.updateHistoryCache();
       this.host.notify();
-      this.host.scrollToBottom(true);
+      this.host.scrollToBottomIfSticky(true);
       return;
     }
     var targetIdx = this.resolveQueuedUserBubble(serverId);
@@ -1581,7 +2142,7 @@ var ChatSession = class {
     this.promoteNextQueuedToRunning();
     this.updateHistoryCache();
     this.host.notify();
-    this.host.scrollToBottom(true);
+    this.host.scrollToBottomIfSticky(true);
   }
   cancelQueuedMessage(msg, idx) {
     var self = this;
@@ -1605,6 +2166,7 @@ var ChatSession = class {
     })).then(function(result) {
       if (result && result.removed) {
         self.cancelledServerIds.add(serverId);
+        self._stopPoll(serverId);
         var qi = self.bgTaskQueue.findIndex(function(e) {
           return e.id === serverId;
         });
@@ -1613,7 +2175,13 @@ var ChatSession = class {
           return m._serverItemId === serverId && (m.isPendingQueued || m.isPendingInProcess) && m.role === "user";
         });
         if (removeIdx !== -1) {
-          self.state.messages[removeIdx] = { role: "user", content: self.state.messages[removeIdx].content, isCancelled: true, _serverItemId: serverId };
+          var wasMsg = self.state.messages[removeIdx];
+          var cancelledMsg = { role: "user", content: wasMsg.content, isCancelled: true, _serverItemId: serverId };
+          if (wasMsg.isBackgroundTask) cancelledMsg.isBackgroundTask = true;
+          if (wasMsg._indexFile) cancelledMsg._indexFile = wasMsg._indexFile;
+          if (wasMsg._useBgQueue) cancelledMsg._useBgQueue = true;
+          if (wasMsg._ownerKey !== void 0) cancelledMsg._ownerKey = wasMsg._ownerKey;
+          self.state.messages[removeIdx] = cancelledMsg;
           var thById = self.state.messages.findIndex(function(m) {
             return m._serverItemId === serverId && m.isPending && m.role === "assistant";
           });
@@ -1650,6 +2218,42 @@ var ChatSession = class {
       }
     });
   }
+  /**
+   * Stop indexing a file, from its collapsed row — every pass at once, not just
+   * the bubble the user happens to see.
+   *
+   * A big file is indexed as a CHAIN of passes, so cancelling only the live one
+   * accomplishes nothing: the next pass is dispatched as soon as it settles.
+   * Three things end the chain:
+   *   1. every queued/running pass of this file is cancelled server-side
+   *      (csr-cancel deletes a queued row and flags a running one "cancelled",
+   *      which is also the worker's gate for NOT enqueueing the next window);
+   *   2. the file is remembered in cancelledIndexKeys, so the client-driven
+   *      resume (maybeResumeIndexing) stops dispatching CONTINUE passes; and
+   *   3. any of its passes still sitting in bgTaskQueue is dropped by the next
+   *      drain rather than surfacing a fresh "Indexing…" bubble.
+   *
+   * Records already written by the passes that DID run are kept — this stops the
+   * work, it does not undo it.
+   */
+  cancelIndexingGroup(group) {
+    var self = this;
+    if (!group || !group.key) return;
+    var scoped = this.getHistoryCacheKey() + "|" + group.key;
+    this.cancelledIndexKeys.add(scoped);
+    var ids = group.cancellableIds || [];
+    if (!ids.length) {
+      this.host.notify();
+      return;
+    }
+    ids.forEach(function(serverId) {
+      var idx = self.state.messages.findIndex(function(m) {
+        return m._serverItemId === serverId && m.role === "user" && (m.isPendingQueued || m.isPendingInProcess);
+      });
+      if (idx === -1) return;
+      self.cancelQueuedMessage(self.state.messages[idx], idx);
+    });
+  }
   // --- typewriter -------------------------------------------------------
   // Reveal `fullText` into a message bubble at a constant wall-clock RATE
   // (chars/second) driven by requestAnimationFrame, rather than a fixed number
@@ -1836,6 +2440,7 @@ var ChatSession = class {
     var u = this.state.messages[uIdx];
     var cleaned = { role: "user", content: u.content, _serverItemId: itemId };
     if (u.isBackgroundTask) cleaned.isBackgroundTask = true;
+    if (u._indexFile) cleaned._indexFile = u._indexFile;
     this.state.messages[uIdx] = cleaned;
   }
   // If an immediate-send request for the current cache key is still in flight
@@ -1853,13 +2458,13 @@ var ChatSession = class {
       return (m.isPending || m.isPendingQueued) && !m.isBackgroundTask && !m._useBgQueue;
     })) return Promise.resolve();
     this.state.sending = true;
-    this.host.scrollToBottom(true);
+    this.host.scrollToBottomIfSticky(true);
     return Promise.resolve(pending).catch(function() {
     }).then(function() {
       if (token !== self.state.gateRefreshToken) return;
       self.state.sending = false;
       return Promise.resolve(self.typewriteLatestReply(key)).then(function() {
-        self.host.scrollToBottom(true);
+        self.host.scrollToBottomIfSticky(true);
       });
     });
   }
@@ -1878,8 +2483,17 @@ var ChatSession = class {
     });
     if (idx !== -1) {
       this._clearPendingUserBubble(itemId);
+      var wasBgTask = !!this.state.messages[idx].isBackgroundTask;
       if (isErr) {
         this.state.messages[idx] = { role: "assistant", content: answer, isError: true, _serverItemId: itemId };
+        if (wasBgTask) this.state.messages[idx].isBackgroundTask = true;
+        this.host.notify();
+        this.updateHistoryCache();
+        return;
+      }
+      var text = answer || "No text response received from AI provider.";
+      if (wasBgTask) {
+        this.state.messages[idx] = { role: "assistant", content: text, isBackgroundTask: true, _serverItemId: itemId };
         this.host.notify();
         this.updateHistoryCache();
         return;
@@ -1887,7 +2501,7 @@ var ChatSession = class {
       var lid = this._newLocalId();
       this.state.messages[idx] = { role: "assistant", content: "", _localId: lid, _serverItemId: itemId };
       this.host.notify();
-      this.enqueueTypewrite(idx, answer || "No text response received from AI provider.", lid);
+      this.enqueueTypewrite(idx, text, lid);
       this.updateHistoryCache();
       return;
     }
@@ -1896,25 +2510,124 @@ var ChatSession = class {
     });
     if (userIdx === -1) return;
     var ex = this.state.messages[userIdx];
-    this.state.messages[userIdx] = { role: "user", content: ex.content, _serverItemId: itemId };
+    var settledUser = { role: "user", content: ex.content, _serverItemId: itemId };
+    if (ex.isBackgroundTask) settledUser.isBackgroundTask = true;
+    if (ex._indexFile) settledUser._indexFile = ex._indexFile;
+    if (ex._useBgQueue) settledUser._useBgQueue = true;
+    this.state.messages[userIdx] = settledUser;
     if (isErr) {
-      this.state.messages.splice(userIdx + 1, 0, { role: "assistant", content: answer, isError: true, _serverItemId: itemId });
+      var errReply = { role: "assistant", content: answer, isError: true, _serverItemId: itemId };
+      if (ex.isBackgroundTask) errReply.isBackgroundTask = true;
+      this.state.messages.splice(userIdx + 1, 0, errReply);
+      this.host.notify();
+      this.updateHistoryCache();
+      return;
+    }
+    var text2 = answer || "No text response received from AI provider.";
+    if (ex.isBackgroundTask) {
+      this.state.messages.splice(userIdx + 1, 0, { role: "assistant", content: text2, isBackgroundTask: true, _serverItemId: itemId });
       this.host.notify();
       this.updateHistoryCache();
       return;
     }
     var lid2 = this._newLocalId();
-    this.state.messages.splice(userIdx + 1, 0, { role: "assistant", content: "", _localId: lid2, _serverItemId: itemId });
+    var reply = { role: "assistant", content: "", _localId: lid2, _serverItemId: itemId };
+    this.state.messages.splice(userIdx + 1, 0, reply);
     this.host.notify();
-    this.enqueueTypewrite(userIdx + 1, answer || "No text response received from AI provider.", lid2);
+    this.enqueueTypewrite(userIdx + 1, text2, lid2);
     this.updateHistoryCache();
   }
+  /** How a bg task maps onto a collapsed row: the row's own key (storage path
+   *  when known, else the filename), scoped to the chat it belongs to. A storage
+   *  path is project-relative ("report.xlsx"), and ONE ChatSession serves every
+   *  project — unscoped, stopping a file in one project would silently suppress
+   *  the same filename's continuations in another. */
+  _indexKeyOf(entry) {
+    if (!entry) return "";
+    var file = entry.storagePath || entry.filename;
+    if (!file) return "";
+    return entry.serviceId + "#" + entry.platform + "|" + file;
+  }
+  /**
+   * Reconcile the bg queue with the files the user has stopped.
+   *
+   * A FIRST pass (no resumePass) is a fresh indexing request — a re-upload, or a
+   * Reindex from the file manager — so it LIFTS the stop: the key is a storage
+   * path, and without this an earlier cancel would silently kill every future
+   * index of the same path. A continuation of a stopped file is dropped instead,
+   * covering the pass that was dispatched in the moment before the cancel landed.
+   */
+  _applyIndexCancellations() {
+    if (!this.cancelledIndexKeys.size) return;
+    for (var i = this.bgTaskQueue.length - 1; i >= 0; i--) {
+      var entry = this.bgTaskQueue[i];
+      var key = this._indexKeyOf(entry);
+      if (!key || !this.cancelledIndexKeys.has(key)) continue;
+      if (!entry.resumePass) {
+        this.cancelledIndexKeys.delete(key);
+        continue;
+      }
+      this.bgTaskQueue.splice(i, 1);
+      this._stopPoll(entry.id);
+      this._cancelServerItem(entry.id);
+    }
+  }
+  /**
+   * Cancel any live pass of a stopped file that turned up on its own.
+   *
+   * The client is not the only thing that continues a file: for PDFs and (when
+   * windowed indexing is on) text/grid files the WORKER enqueues the next window
+   * itself, and that pass reaches the chat through the history poll, never
+   * through bgTaskQueue. The worker's own gate stops the chain when the running
+   * row is cancelled — but if the row had already finished when the user hit
+   * stop, the next window was queued a moment earlier and still arrives. Stop it
+   * here rather than making the user hit stop again.
+   *
+   * Runs from drainBgTaskQueue, which both clients call after a history load.
+   */
+  _sweepCancelledIndexing() {
+    if (!this.cancelledIndexKeys.size) return;
+    var self = this;
+    var chatKey = this.getHistoryCacheKey();
+    var targets = [];
+    this.state.messages.forEach(function(m, i) {
+      if (!m.isBackgroundTask || m.role !== "user" || !m._serverItemId) return;
+      if (m._cancelling || m.isSendingToServer) return;
+      if (!(m.isPendingQueued || m.isPendingInProcess)) return;
+      var ref = m._indexFile;
+      var file = ref && (ref.path || ref.name);
+      if (!file || !self.cancelledIndexKeys.has(chatKey + "|" + file)) return;
+      targets.push({ msg: m, idx: i });
+    });
+    targets.forEach(function(t) {
+      var idx = self.state.messages.indexOf(t.msg);
+      self.cancelQueuedMessage(t.msg, idx === -1 ? t.idx : idx);
+    });
+  }
+  /** Best-effort server-side cancel of a bg-queue item that has no bubble (so
+   *  cancelQueuedMessage, which drives one, has nothing to act on). */
+  _cancelServerItem(serverId) {
+    var id = this.host.getIdentity();
+    if (!serverId || id.platform !== "claude" && id.platform !== "openai") return;
+    var url = id.platform === "claude" ? ANTHROPIC_MESSAGES_API_URL : OPENAI_RESPONSES_API_URL;
+    Promise.resolve(this.host.cancelRequest({
+      url,
+      method: "POST",
+      id: serverId,
+      queue: (id.userId || id.serviceId) + BG_INDEXING_QUEUE_SUFFIX,
+      service: id.serviceId,
+      owner: id.owner
+    })).catch(function() {
+    });
+  }
   // Inject "Indexing: <file>" bubbles for queued bg tasks + attach their polls.
   drainBgTaskQueue() {
     var self = this;
     var id = this.host.getIdentity();
     var svcId = id.serviceId, plat = id.platform;
     if (!svcId || plat === "none" || !this.host.isViewMounted()) return;
+    this._applyIndexCancellations();
+    this._sweepCancelledIndexing();
     var presentIds = {};
     var pendingIds = {};
     this.state.messages.forEach(function(m) {
@@ -1930,39 +2643,70 @@ var ChatSession = class {
     }
     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;
           });
@@ -1973,25 +2717,32 @@ var ChatSession = class {
     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,
@@ -2000,7 +2751,6 @@ var ChatSession = class {
         userId: id.userId || id.serviceId,
         serviceName: id.serviceName,
         serviceDescription: id.serviceDescription,
-        renderFrom,
         attachment: {
           name: entry.filename,
           storagePath: entry.storagePath,
@@ -2040,6 +2790,7 @@ var ChatSession = class {
   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();
@@ -2062,9 +2813,9 @@ var ChatSession = class {
       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;
         }
       });
@@ -2077,6 +2828,7 @@ var ChatSession = class {
         serviceId: id.serviceId,
         formatIndexingLabel: self.host.formatIndexingLabel
       }).messages;
+      var keptOlderPages = false;
       if (fetchMore) {
         self.state.messages = mapped.concat(self.state.messages);
       } else {
@@ -2087,7 +2839,12 @@ var ChatSession = class {
         });
         var locallyCancelled = {};
         self.state.messages.forEach(function(m) {
-          if (m.isCancelled && m._serverItemId) locallyCancelled[m._serverItemId] = 1;
+          if (m.isCancelled && m._serverItemId) locallyCancelled[m._serverItemId] = m;
+        });
+        var inFlightCancel = {};
+        self.state.messages.forEach(function(m) {
+          if (!m._serverItemId) return;
+          if (m._cancelling || m._cancelError) inFlightCancel[m._serverItemId] = m;
         });
         var mappedHasPendingAssistant = mapped.some(function(m) {
           return m.isPending && m.role === "assistant" && !m.isBackgroundTask;
@@ -2096,6 +2853,7 @@ var ChatSession = class {
         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;
@@ -2106,7 +2864,22 @@ var ChatSession = class {
             }
           }
         }
-        self.state.messages = mapped;
+        var oldestInPage1 = void 0;
+        mapped.forEach(function(m) {
+          var sid = m._serverItemId;
+          if (typeof sid !== "string") return;
+          if (oldestInPage1 === void 0 || sid < oldestInPage1) oldestInPage1 = sid;
+        });
+        var sharesPage1 = self.state.messages.some(function(m) {
+          return typeof m._serverItemId === "string" && !!serverIds[m._serverItemId];
+        });
+        var retainedOlder = !sharesPage1 || oldestInPage1 === void 0 ? [] : self.state.messages.filter(function(m) {
+          if (typeof m._serverItemId !== "string") return false;
+          if (m._ownerKey !== void 0 && m._ownerKey !== loadKey) return false;
+          return m._serverItemId < oldestInPage1;
+        });
+        keptOlderPages = retainedOlder.length > 0;
+        self.state.messages = keptOlderPages ? retainedOlder.concat(mapped) : mapped;
         rescued.forEach(function(m) {
           self.state.messages.push(m);
         });
@@ -2114,19 +2887,38 @@ var ChatSession = class {
           for (var ci = 0; ci < self.state.messages.length; ci++) {
             var c = self.state.messages[ci];
             if (!c._serverItemId || !locallyCancelled[c._serverItemId] || c.isCancelled) continue;
-            self.state.messages[ci] = { role: "user", content: c.content, isCancelled: true, _serverItemId: c._serverItemId };
+            self.state.messages[ci] = {
+              role: "user",
+              content: c.content,
+              isCancelled: true,
+              _serverItemId: c._serverItemId,
+              isBackgroundTask: c.isBackgroundTask,
+              _indexFile: c._indexFile,
+              _useBgQueue: c._useBgQueue,
+              _ownerKey: c._ownerKey
+            };
             if (ci + 1 < self.state.messages.length && self.state.messages[ci + 1].isPending && self.state.messages[ci + 1]._serverItemId === c._serverItemId) {
               self.state.messages.splice(ci + 1, 1);
             }
           }
         }
+        for (var fi = 0; fi < self.state.messages.length; fi++) {
+          var fm = self.state.messages[fi];
+          var was = fm._serverItemId && inFlightCancel[fm._serverItemId];
+          if (!was || fm.isCancelled) continue;
+          if (!(fm.isPendingQueued || fm.isPendingInProcess || fm.isPending)) continue;
+          if (was._cancelling) fm._cancelling = true;
+          if (was._cancelError) fm._cancelError = was._cancelError;
+        }
       }
-      self.state.historyEndOfList = !!(history && history.endOfList);
-      self.state.historyStartKeyHistory = history && Array.isArray(history.startKeyHistory) ? history.startKeyHistory : [];
-      var clearedAt = self.host.getClearedAt();
-      if (clearedAt && chatList.length > 0) {
-        var oldestUpdated = Number(chatList[chatList.length - 1] && chatList[chatList.length - 1].updated);
-        if (isFinite(oldestUpdated) && oldestUpdated <= clearedAt) self.state.historyEndOfList = true;
+      if (!keptOlderPages) {
+        self.state.historyEndOfList = !!(history && history.endOfList);
+        self.state.historyStartKeyHistory = history && Array.isArray(history.startKeyHistory) ? history.startKeyHistory : [];
+        var clearedAt = self.host.getClearedAt();
+        if (clearedAt && chatList.length > 0) {
+          var oldestUpdated = Number(chatList[chatList.length - 1] && chatList[chatList.length - 1].updated);
+          if (isFinite(oldestUpdated) && oldestUpdated <= clearedAt) self.state.historyEndOfList = true;
+        }
       }
       if (self.state.historyRequestToken === token) {
         self.state.loadingHistory = false;
@@ -2140,11 +2932,12 @@ var ChatSession = class {
           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) {
@@ -2154,18 +2947,25 @@ var ChatSession = class {
                 return m.isPending && m._serverItemId === capturedId;
               });
               if (isNotExists) {
-                var isBg = aIdx !== -1 ? !!self.state.messages[aIdx].isBackgroundTask : false;
+                var uIdx = self.state.messages.findIndex(function(m) {
+                  return m.role === "user" && m._serverItemId === capturedId && !m.isCancelled;
+                });
+                var isBg = aIdx !== -1 && !!self.state.messages[aIdx].isBackgroundTask || uIdx !== -1 && !!self.state.messages[uIdx].isBackgroundTask;
                 if (aIdx !== -1) self.state.messages.splice(aIdx, 1);
                 if (!isBg) {
-                  var uIdx = self.state.messages.findIndex(function(m) {
-                    return m.role === "user" && m._serverItemId === capturedId && !m.isCancelled;
-                  });
                   if (uIdx !== -1) {
                     var ex = self.state.messages[uIdx];
                     self.state.messages[uIdx] = { role: "user", content: ex.content, isCancelled: true, _serverItemId: ex._serverItemId };
                   }
                   self.cancelledServerIds.delete(capturedId);
                   self.promoteNextQueuedToRunning();
+                } else if (uIdx !== -1) {
+                  var bex = self.state.messages[uIdx];
+                  var bcancelled = { role: "user", content: bex.content, isCancelled: true, isBackgroundTask: true, _serverItemId: bex._serverItemId };
+                  if (bex._indexFile) bcancelled._indexFile = bex._indexFile;
+                  if (bex._useBgQueue) bcancelled._useBgQueue = true;
+                  self.state.messages[uIdx] = bcancelled;
+                  self.promoteNextBgQueuedToRunning();
                 }
                 self.host.notify();
                 self.updateHistoryCache();
@@ -2180,12 +2980,13 @@ var ChatSession = class {
               }
             }
           });
+          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() {
@@ -2195,6 +2996,7 @@ var ChatSession = class {
         self.state.loadingOlderHistory = false;
         if (wasLoading) self.host.notify();
       }
+      if (self.host.onHistoryLoaded) self.host.onHistoryLoaded(!!fetchMore, token);
     });
   }
   // --- attachment upload orchestration ---------------------------------
@@ -2392,6 +3194,189 @@ var ChatSession = class {
   }
 };
 
+// src/engine/indexing_groups.ts
+var INDEXING_LABEL_RE = /^(Re)?[Ii]ndexing(\s*\(continuing\))?\s*:?\s+(.+)$/;
+var LEADING_MD_LINK_RE = /^\[([^\]]+)\]\(([^)]+)\)/;
+function parseIndexingLabel(content) {
+  if (typeof content !== "string" || !content) return null;
+  var firstLine = content.split("\n")[0].trim();
+  var m = firstLine.match(INDEXING_LABEL_RE);
+  if (!m) return null;
+  var head = m[3].split(" \xB7 ")[0].trim();
+  var link = head.match(LEADING_MD_LINK_RE);
+  var name = link ? link[1].trim() : head;
+  if (!name) return null;
+  return {
+    name,
+    path: link ? link[2].trim() : void 0,
+    continued: !!m[2],
+    isReindex: !!m[1]
+  };
+}
+function readFileRef(msg) {
+  var ref = msg && msg._indexFile;
+  if (ref && (ref.path || ref.name)) {
+    return {
+      name: ref.name || ref.path || "",
+      path: ref.path,
+      mime: ref.mime,
+      size: ref.size,
+      isReindex: ref.isReindex,
+      continued: !!ref.continued
+    };
+  }
+  var parsed = parseIndexingLabel(msg && msg.content);
+  if (!parsed) return null;
+  return {
+    name: parsed.name,
+    path: parsed.path,
+    isReindex: parsed.isReindex,
+    continued: parsed.continued
+  };
+}
+function isPendingMsg(m) {
+  return !!(m.isPending || m.isPendingInProcess || m.isPendingQueued || m.isSendingToServer);
+}
+function buildChatDisplayList(messages, opts) {
+  var list = Array.isArray(messages) ? messages : [];
+  var hasMoreHistory = !!(opts && opts.hasMoreHistory);
+  var groups = {};
+  var order = [];
+  var runOfIndex = new Array(list.length);
+  var runByItemId = {};
+  var keyByName = {};
+  var openRunOfKey = {};
+  var runsOfKey = {};
+  var keyOfRun = {};
+  var runSeq = 0;
+  for (var i = 0; i < list.length; i++) {
+    var msg = list[i];
+    if (!msg || !msg.isBackgroundTask) continue;
+    var runId;
+    var ref = msg.role === "user" ? readFileRef(msg) : null;
+    if (ref) {
+      var key = ref.path || keyByName[ref.name] || ref.name;
+      if (!ref.continued && openRunOfKey[key]) delete openRunOfKey[key];
+      runId = openRunOfKey[key];
+      if (!runId) {
+        runId = "run" + runSeq++;
+        openRunOfKey[key] = runId;
+        keyOfRun[runId] = key;
+        (runsOfKey[key] || (runsOfKey[key] = [])).push(runId);
+      }
+    } else if (msg._serverItemId && runByItemId[msg._serverItemId]) {
+      runId = runByItemId[msg._serverItemId];
+    } else if (msg.role !== "user") {
+      runId = runOfIndex[i - 1];
+    }
+    if (!runId) continue;
+    var g = groups[runId];
+    if (!g) {
+      var fileKey = keyOfRun[runId];
+      g = groups[runId] = {
+        key: fileKey,
+        runKey: runId,
+        // provisional; renumbered newest-first below
+        name: ref ? ref.name : fileKey,
+        path: ref ? ref.path : void 0,
+        mime: ref ? ref.mime : void 0,
+        size: ref ? ref.size : void 0,
+        isReindex: !!(ref && ref.isReindex),
+        members: [],
+        passCount: 0,
+        status: "done",
+        cancellableIds: [],
+        cancelling: false,
+        mayHaveOlder: false,
+        anchorIndex: i
+      };
+      order.push(runId);
+    }
+    if (ref) {
+      if (ref.name) g.name = ref.name;
+      if (ref.path) g.path = ref.path;
+      if (ref.mime) g.mime = ref.mime;
+      if (typeof ref.size === "number") g.size = ref.size;
+      if (ref.isReindex) g.isReindex = true;
+      if (!ref.continued) g.mayHaveOlder = false;
+      g.passCount++;
+    }
+    g.members.push({ msg, index: i });
+    g.anchorIndex = i;
+    runOfIndex[i] = runId;
+    if (msg._serverItemId) runByItemId[msg._serverItemId] = runId;
+    if (ref && ref.name) keyByName[ref.name] = g.key;
+  }
+  for (var rk in runsOfKey) {
+    var runIds = runsOfKey[rk];
+    for (var ri = 0; ri < runIds.length; ri++) {
+      var grpR = groups[runIds[ri]];
+      if (!grpR) continue;
+      var first = grpR.members[0];
+      var firstId = first && first.msg && (first.msg._serverItemId || first.msg._localId);
+      grpR.runKey = rk + "#" + (firstId || "n" + ri);
+    }
+  }
+  for (var oi = 0; oi < order.length; oi++) {
+    var grp = groups[order[oi]];
+    var lastSettled = -1;
+    for (var si = 0; si < grp.members.length; si++) {
+      if (!isPendingMsg(grp.members[si].msg)) lastSettled = si;
+    }
+    var active = false;
+    for (var mi = lastSettled + 1; mi < grp.members.length; mi++) {
+      if (isPendingMsg(grp.members[mi].msg)) {
+        active = true;
+        break;
+      }
+    }
+    for (var xi = 0; xi < grp.members.length; xi++) {
+      if (grp.members[xi].msg._cancelling) {
+        grp.cancelling = true;
+        break;
+      }
+    }
+    var seenIds = {};
+    for (var ci = 0; ci < grp.members.length; ci++) {
+      var cm = grp.members[ci].msg;
+      if (cm._cancelError && (active || grp.cancelling)) grp.cancelError = cm._cancelError;
+      if (cm.role !== "user" || !cm._serverItemId || cm._cancelling || cm.isSendingToServer) continue;
+      if (!(cm.isPendingQueued || cm.isPendingInProcess)) continue;
+      if (ci < lastSettled) continue;
+      if (seenIds[cm._serverItemId]) continue;
+      seenIds[cm._serverItemId] = true;
+      grp.cancellableIds.push(cm._serverItemId);
+    }
+    if (active) {
+      grp.status = "active";
+    } else {
+      var last = grp.members[grp.members.length - 1].msg;
+      grp.status = last.isError ? "error" : last.isCancelled ? "cancelled" : "done";
+    }
+    var sawFirstPass = false;
+    for (var pi = 0; pi < grp.members.length; pi++) {
+      var pm = grp.members[pi].msg;
+      if (pm.role !== "user") continue;
+      var pref = readFileRef(pm);
+      if (pref && !pref.continued) {
+        sawFirstPass = true;
+        break;
+      }
+    }
+    grp.mayHaveOlder = !sawFirstPass && hasMoreHistory;
+  }
+  var out = [];
+  for (var j = 0; j < list.length; j++) {
+    var r = runOfIndex[j];
+    if (r === void 0) {
+      out.push({ kind: "message", msg: list[j], index: j });
+      continue;
+    }
+    if (groups[r].anchorIndex === j) out.push({ kind: "indexing", group: groups[r], index: j });
+  }
+  return out;
+}
+
 exports.BG_INDEXING_QUEUE_SUFFIX = BG_INDEXING_QUEUE_SUFFIX;
 exports.CLAUDE_PER_REQUEST_INPUT_CAP = CLAUDE_PER_REQUEST_INPUT_CAP;
 exports.CONTEXT_WINDOW_BY_MODEL = CONTEXT_WINDOW_BY_MODEL;
@@ -2401,29 +3386,39 @@ exports.DEFAULT_CLAUDE_MODEL = DEFAULT_CLAUDE_MODEL;
 exports.DEFAULT_OPENAI_MODEL = DEFAULT_OPENAI_MODEL;
 exports.EXPIRED_ATTACHMENT_URL_HOST = EXPIRED_ATTACHMENT_URL_HOST;
 exports.EXPIRED_ATTACHMENT_URL_ORIGIN = EXPIRED_ATTACHMENT_URL_ORIGIN;
+exports.EXPIRED_LINK_REFRESH_EXPIRES_SECONDS = EXPIRED_LINK_REFRESH_EXPIRES_SECONDS;
+exports.HISTORY_FILL_SLACK_PX = HISTORY_FILL_SLACK_PX;
 exports.HISTORY_TOKEN_BUDGET = HISTORY_TOKEN_BUDGET;
 exports.LINK_LABEL_MAX_DISPLAY_CHARS = LINK_LABEL_MAX_DISPLAY_CHARS;
+exports.LINK_REFRESH_WINDOW_MS = LINK_REFRESH_WINDOW_MS;
+exports.MAX_HISTORY_FILL_PAGES = MAX_HISTORY_FILL_PAGES;
 exports.MAX_HISTORY_MESSAGES = MAX_HISTORY_MESSAGES;
 exports.MAX_PARSED_CONTENT_CHARS = MAX_PARSED_CONTENT_CHARS;
 exports.MCP_NAME = MCP_NAME;
 exports.MIN_INPUT_TOKEN_BUDGET = MIN_INPUT_TOKEN_BUDGET;
 exports.OUTPUT_TOKEN_RESERVE = OUTPUT_TOKEN_RESERVE;
 exports.POLL_INTERVAL = POLL_INTERVAL;
+exports.RENDER_FROM_TOKEN = RENDER_FROM_TOKEN;
 exports.TOOL_AND_RESPONSE_BUFFER = TOOL_AND_RESPONSE_BUFFER;
 exports.buildBoundedChatMessages = buildBoundedChatMessages;
+exports.buildChatDisplayList = buildChatDisplayList;
 exports.buildChatSystemPrompt = buildChatSystemPrompt;
 exports.buildDisplayExpiredAttachmentHref = buildDisplayExpiredAttachmentHref;
 exports.buildIndexingContinueMessage = buildIndexingContinueMessage;
+exports.buildIndexingRenderContinueTemplate = buildIndexingRenderContinueTemplate;
 exports.buildIndexingRenderMessage = buildIndexingRenderMessage;
 exports.buildIndexingSystemPrompt = buildIndexingSystemPrompt;
 exports.buildIndexingUserMessage = buildIndexingUserMessage;
+exports.buildIndexingWindowMessage = buildIndexingWindowMessage;
 exports.callClaudeWithMcp = callClaudeWithMcp;
 exports.callClaudeWithPublicMcp = callClaudeWithPublicMcp;
 exports.callOpenAIWithPublicMcp = callOpenAIWithPublicMcp;
 exports.chatEngineConfig = chatEngineConfig;
+exports.classifyInlineLink = classifyInlineLink;
 exports.clearAttachmentParsers = clearAttachmentParsers;
 exports.composeUserMessage = composeUserMessage;
 exports.configureChatEngine = configureChatEngine;
+exports.createHistoryFiller = createHistoryFiller;
 exports.createInlineLinkRegex = createInlineLinkRegex;
 exports.encodePathSegments = encodePathSegments;
 exports.estimateMessageTokens = estimateMessageTokens;
@@ -2432,6 +3427,7 @@ exports.extractClaudeText = extractClaudeText;
 exports.extractLastUserTextFromRequest = extractLastUserTextFromRequest;
 exports.extractOpenAIText = extractOpenAIText;
 exports.extractRemotePathFromAttachmentHref = extractRemotePathFromAttachmentHref;
+exports.fillHistoryViewport = fillHistoryViewport;
 exports.filterListByClearHorizon = filterListByClearHorizon;
 exports.findAttachmentParser = findAttachmentParser;
 exports.getAttachmentParsers = getAttachmentParsers;
@@ -2441,7 +3437,9 @@ exports.getErrorMessage = getErrorMessage;
 exports.getExpiredAttachmentVisiblePath = getExpiredAttachmentVisiblePath;
 exports.groupAttachmentFailures = groupAttachmentFailures;
 exports.isAuthExpiredError = isAuthExpiredError;
+exports.isBgIndexingQueue = isBgIndexingQueue;
 exports.isErrorResponseBody = isErrorResponseBody;
+exports.isHttpUrlLike = isHttpUrlLike;
 exports.isNonRetryableRequestError = isNonRetryableRequestError;
 exports.isOfficeFile = isOfficeFile;
 exports.isServerExtractable = isServerExtractable;
@@ -2452,9 +3450,13 @@ exports.makeExtractPlaceholder = makeExtractPlaceholder;
 exports.mapHistoryListToMessages = mapHistoryListToMessages;
 exports.normalizeAttachmentPathCandidate = normalizeAttachmentPathCandidate;
 exports.normalizeTextContent = normalizeTextContent;
+exports.normalizeTrailingInlineToken = normalizeTrailingInlineToken;
 exports.notifyAgentSaveAttachment = notifyAgentSaveAttachment;
 exports.parseAttachmentContent = parseAttachmentContent;
+exports.parseIndexingLabel = parseIndexingLabel;
+exports.readExpiredAttachmentHref = readExpiredAttachmentHref;
 exports.registerAttachmentParser = registerAttachmentParser;
+exports.repairUrlWhitespace = repairUrlWhitespace;
 exports.safeDecodeURIComponent = safeDecodeURIComponent;
 exports.sanitizeAttachmentLinksForHistory = sanitizeAttachmentLinksForHistory;
 exports.stripFileBlocksFromHistory = stripFileBlocksFromHistory;