bunnyquery 1.8.6 → 1.8.8

package/dist/engine.cjs

@@ -217,7 +217,8 @@ function isWindowedReadFile(name, mime) {
   if (isImageVisionFile(name, mime)) return false;
   return isPagedReadFile(name, mime);
 }
-function composeUserMessage(text, attachmentUrls) {
+function composeUserMessage(text, attachmentUrls, opts) {
+  const inlineExtracted = opts?.inlineExtractedContent !== false;
   let composed = text;
   let composedForLlm = composed;
   if (attachmentUrls.length > 0) {
@@ -231,7 +232,7 @@ ${lines.join("\n")}`;
   let extractContent;
   let fileUrls;
   if (attachmentUrls.length > 0) {
-    const extractFiles = attachmentUrls.filter((u) => isServerExtractable(u.name));
+    const extractFiles = inlineExtracted ? attachmentUrls.filter((u) => isServerExtractable(u.name)) : [];
     if (extractFiles.length > 0) {
       const directives = [];
       const sections = extractFiles.map((u) => {
@@ -292,7 +293,7 @@ Never assert absence from a partial read. Do not say "there is no X", "none", "n
 Embedded values: a search term is often stored inside a larger string. A merchant "GODADDY" appears as "DNH*GODADDY#4070277042", and a card as "4140****2941". Server-side index filters match only exact values, leading prefixes, or trailing suffixes, and tag filters only EXACT whole-tag values - never a partial or interior substring - so filtering on such a field silently drops rows. When the value you are looking for may be embedded, do not trust a narrow filter to be complete. Fetch the full set with fetch_all and match the substring yourself.
 File attachments: When a user message contains an "Attached files:" section with markdown links, those links point to short-lived signed URLs in this project's db storage and will expire.
 - 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.
+- Other 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) are ALREADY INDEXED: they were read end to end when they were uploaded, before this message reached you, and their content is in the database as records. Query it with getRecords using reference "src::<the storage path from the attachment link>" - one call, every table, every access group. Do NOT call web_fetch on their URLs. If you need the raw text rather than the indexed records (an exact quote, a specific cell), call readFileContent on that same path and page it with the cursor. Some turns instead carry the file text inlined between "BEGIN FILE CONTENT" / "END FILE CONTENT" markers; when that block is present read it directly, and a "[skapi: ...]" note inside it means that 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.
 Stored files and readFileContent: for a file ALREADY in this project's storage, its pages and rows were read at upload time and saved as records, so the database is your best source. Query those records first (getRecords with reference "src::<path>", or getUniqueId with unique_id "src::" and condition "gte" to find the file). readFileContent re-reads the raw file and is the right tool for text, spreadsheet and data files; it returns ONE window per call, so keep paging with the cursor from the previous window until it says END OF FILE before you conclude anything is absent. Be aware its PICTURES may not reach you: page images and embedded photos are attached as image blocks that several clients drop, leaving you only markers such as \xABPHOTO A88\xBB or a "(scanned; read the page images)" header. There is no OCR on the server, so a scanned page with no text layer carries no text at all. If you cannot actually see an image, say so plainly and fall back to the indexed records; never describe a picture you were not shown, and never tell the user the file is unreadable when its content is already 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 - 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 - 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.
@@ -566,6 +567,36 @@ function isAuthExpiredError(input) {
   if (!hay) return false;
   return hay.indexOf("token has expired") !== -1 || hay.indexOf("token is expired") !== -1 || hay.indexOf("expired_token") !== -1 || hay.indexOf("invalid_token") !== -1 || hay.indexOf("unauthorized") !== -1 || hay.indexOf("not authorized") !== -1 || hay.indexOf("invalid_request") !== -1 && hay.indexOf("token") !== -1;
 }
+function isProviderApiKeyError(input) {
+  if (!input) return false;
+  var blobs = [];
+  var push = function(v) {
+    if (typeof v === "string" && v) blobs.push(v);
+  };
+  if (typeof input === "string") push(input);
+  else {
+    push(input.message);
+    push(input.code);
+    push(input.type);
+    if (input.error) {
+      push(input.error.message);
+      push(input.error.code);
+      push(input.error.type);
+    }
+    if (input.body) {
+      push(input.body.message);
+      push(input.body.type);
+      if (input.body.error) {
+        push(input.body.error.message);
+        push(input.body.error.code);
+        push(input.body.error.type);
+      }
+    }
+  }
+  var hay = blobs.join(" | ").toLowerCase();
+  if (!hay) return false;
+  return hay.indexOf("authentication_error") !== -1 || hay.indexOf("invalid_api_key") !== -1 || hay.indexOf("invalid x-api-key") !== -1 || hay.indexOf("incorrect api key") !== -1 || hay.indexOf("invalid api key") !== -1 || hay.indexOf("no api key provided") !== -1;
+}
 
 // src/engine/links.ts
 var EXPIRED_ATTACHMENT_URL_HOST = "_expired_.url";
@@ -840,33 +871,85 @@ function truncateLabelForDisplay(label) {
 // src/engine/budget.ts
 var CONTEXT_WINDOW_DEFAULT = { claude: 2e5, openai: 128e3 };
 var CONTEXT_WINDOW_BY_MODEL = {
-  // exact ids
+  // claude, exact ids
+  "claude-fable-5": 1e6,
   "claude-opus-5": 1e6,
   "claude-opus-4-8": 1e6,
   "claude-opus-4-7": 1e6,
+  "claude-opus-4-6": 1e6,
+  "claude-opus-4-5": 2e5,
   "claude-sonnet-5": 1e6,
   "claude-sonnet-4-6": 1e6,
+  "claude-sonnet-4-5": 1e6,
   "claude-sonnet-4": 2e5,
   "claude-haiku-4-5": 2e5,
-  "gpt-5.4": 128e3,
-  "gpt-5.6-luna": 128e3,
+  "claude-3-5-sonnet": 2e5,
+  // openai, exact ids
+  "gpt-5.6-sol": 105e4,
+  "gpt-5.6-terra": 105e4,
+  "gpt-5.6-luna": 105e4,
+  "gpt-5.5": 1e6,
+  "gpt-5.4": 105e4,
+  "gpt-5.4-mini": 4e5,
+  "gpt-5.4-nano": 4e5,
+  "gpt-4.1": 104e4,
+  "gpt-4o": 128e3,
+  "o1": 2e5,
+  "o1-pro": 2e5,
   // family keys
+  "claude-fable": 1e6,
   "claude-opus": 1e6,
   "claude-sonnet": 1e6,
   "claude-haiku": 2e5,
+  "gpt-5.6": 105e4,
+  "gpt-5": 128e3
+};
+var MAX_OUTPUT_BY_MODEL = {
+  // claude
+  "claude-fable-5": 128e3,
+  "claude-opus-5": 128e3,
+  "claude-opus-4-8": 128e3,
+  "claude-sonnet-5": 128e3,
+  "claude-sonnet-4-6": 64e3,
+  "claude-haiku-4-5": 64e3,
+  "claude-3-5-sonnet": 8e3,
+  // openai
+  "gpt-5.6-sol": 128e3,
+  "gpt-5.6-terra": 128e3,
+  "gpt-5.6-luna": 128e3,
+  "gpt-5.5": 128e3,
+  "gpt-5.4": 128e3,
+  "gpt-5.4-mini": 128e3,
+  "gpt-5.4-nano": 128e3,
+  "gpt-4.1": 16e3,
+  "gpt-4o": 4e3,
+  "o1": 1e5,
+  "o1-pro": 1e5,
+  // family keys
+  "claude-fable": 128e3,
+  "claude-opus": 128e3,
+  "claude-sonnet": 64e3,
+  "claude-haiku": 64e3,
   "gpt-5.6": 128e3,
   "gpt-5": 128e3
 };
+var DEFAULT_CONTEXT_WINDOW = 88e4;
 var apiReportedContextWindows = {};
+var apiReportedMaxOutput = {};
 function registerModelContextWindows(models) {
   if (!Array.isArray(models)) return;
   for (var i = 0; i < models.length; i++) {
     var m = models[i];
     var id = (m && m.id ? String(m.id) : "").trim().toLowerCase();
+    if (!id) continue;
     var reported = m ? Number(m.max_input_tokens) : NaN;
-    if (id && Number.isFinite(reported) && reported > 0) {
+    if (Number.isFinite(reported) && reported > 0) {
       apiReportedContextWindows[id] = Math.floor(reported);
     }
+    var out = m ? Number(m.max_tokens) : NaN;
+    if (Number.isFinite(out) && out > 0) {
+      apiReportedMaxOutput[id] = Math.floor(out);
+    }
   }
 }
 var projectContextWindows = {};
@@ -881,13 +964,16 @@ function getProjectContextWindow(projectId) {
   var key = (projectId || "").trim();
   return key && projectContextWindows[key] ? projectContextWindows[key] : null;
 }
-var OUTPUT_TOKEN_RESERVE = 22e3;
+var MAX_OUTPUT_TOKENS = 25e3;
+var OUTPUT_TOKEN_RESERVE = MAX_OUTPUT_TOKENS;
 var TOOL_AND_RESPONSE_BUFFER = 4e3;
 var MIN_INPUT_TOKEN_BUDGET = 8e3;
-var CLAUDE_PER_REQUEST_INPUT_CAP = 28e3;
+var MIN_PER_REQUEST_INPUT_CAP = 28e3;
+var CLAUDE_PER_REQUEST_INPUT_CAP = MIN_PER_REQUEST_INPUT_CAP;
 var MAX_HISTORY_MESSAGES = 20;
 var HISTORY_TOKEN_BUDGET = 8e3;
-var CLAUDE_INPUT_CAP_RATIO = 0.16;
+var INPUT_CAP_RATIO = 0.16;
+var CLAUDE_INPUT_CAP_RATIO = INPUT_CAP_RATIO;
 var HISTORY_BUDGET_RATIO = 0.08;
 function estimateTextTokens(text) {
   return Math.ceil((text || "").length / 3);
@@ -895,38 +981,61 @@ function estimateTextTokens(text) {
 function estimateMessageTokens(msg) {
   return estimateTextTokens(msg.content) + estimateTextTokens(msg.role) + 6;
 }
+function resolveByModelId(apiTable, staticTable, model) {
+  var normalized = (model || "").trim().toLowerCase();
+  if (!normalized) return 0;
+  if (apiTable[normalized]) return apiTable[normalized];
+  if (staticTable[normalized]) return staticTable[normalized];
+  var parts = normalized.split("-");
+  for (var end = parts.length - 1; end > 0; end--) {
+    var family = parts.slice(0, end).join("-");
+    if (staticTable[family]) return staticTable[family];
+  }
+  return 0;
+}
+function getModelContextWindow(platform, model) {
+  return resolveByModelId(apiReportedContextWindows, CONTEXT_WINDOW_BY_MODEL, model) || CONTEXT_WINDOW_DEFAULT[platform];
+}
+function getMaxOutputTokens(platform, model) {
+  var cap = resolveByModelId(apiReportedMaxOutput, MAX_OUTPUT_BY_MODEL, model);
+  return cap ? Math.min(MAX_OUTPUT_TOKENS, cap) : MAX_OUTPUT_TOKENS;
+}
 function getContextWindow(platform, model, projectId) {
+  var ceiling = getModelContextWindow(platform, model);
   var override = projectId ? getProjectContextWindow(projectId) : null;
-  if (override) return override;
-  var normalized = (model || "").trim().toLowerCase();
-  if (normalized) {
-    if (apiReportedContextWindows[normalized]) return apiReportedContextWindows[normalized];
-    if (CONTEXT_WINDOW_BY_MODEL[normalized]) return CONTEXT_WINDOW_BY_MODEL[normalized];
-    var parts = normalized.split("-");
-    for (var end = parts.length - 1; end > 0; end--) {
-      var family = parts.slice(0, end).join("-");
-      if (CONTEXT_WINDOW_BY_MODEL[family]) return CONTEXT_WINDOW_BY_MODEL[family];
-    }
-  }
-  return CONTEXT_WINDOW_DEFAULT[platform];
+  return Math.min(override || DEFAULT_CONTEXT_WINDOW, ceiling);
+}
+function contextBasedBudgetFor(platform, model, projectId) {
+  var contextWindow = getContextWindow(platform, model, projectId);
+  return Math.max(
+    MIN_INPUT_TOKEN_BUDGET,
+    contextWindow - getMaxOutputTokens(platform, model) - TOOL_AND_RESPONSE_BUFFER
+  );
+}
+function getInputTokenBudget(platform, model, projectId) {
+  var contextBasedBudget = contextBasedBudgetFor(platform, model, projectId);
+  return Math.min(
+    contextBasedBudget,
+    Math.max(MIN_PER_REQUEST_INPUT_CAP, Math.round(contextBasedBudget * INPUT_CAP_RATIO))
+  );
 }
 function stripFileBlocksFromHistory(content) {
   if (!content) return content;
   return content.replace(/```([^\n`]+?\.[^\s.`]+)\n[\s\S]*?```/g, "[file previously attached: $1]");
 }
 function buildBoundedChatMessages(options) {
-  var contextWindow = getContextWindow(options.platform, options.model, options.projectId);
-  var contextBasedBudget = Math.max(
-    MIN_INPUT_TOKEN_BUDGET,
-    contextWindow - OUTPUT_TOKEN_RESERVE - TOOL_AND_RESPONSE_BUFFER
-  );
-  var scaled = !!(options.projectId && getProjectContextWindow(options.projectId));
-  var claudeInputCap = scaled ? Math.max(CLAUDE_PER_REQUEST_INPUT_CAP, Math.round(contextBasedBudget * CLAUDE_INPUT_CAP_RATIO)) : CLAUDE_PER_REQUEST_INPUT_CAP;
-  var availableInputBudget = options.platform === "claude" ? Math.min(contextBasedBudget, claudeInputCap) : contextBasedBudget;
+  var contextBasedBudget = contextBasedBudgetFor(options.platform, options.model, options.projectId);
+  var availableInputBudget = getInputTokenBudget(options.platform, options.model, options.projectId);
   var systemCost = estimateTextTokens(options.systemPrompt) + 12;
-  var historyAllowance = scaled ? Math.max(HISTORY_TOKEN_BUDGET, Math.round(contextBasedBudget * HISTORY_BUDGET_RATIO)) : HISTORY_TOKEN_BUDGET;
+  var historyAllowance = Math.max(
+    HISTORY_TOKEN_BUDGET,
+    Math.round(contextBasedBudget * HISTORY_BUDGET_RATIO)
+  );
   var budgetForHistory = Math.max(1e3, Math.min(historyAllowance, availableInputBudget - systemCost));
-  var maxHistoryMessages = scaled ? Math.max(MAX_HISTORY_MESSAGES, Math.round(MAX_HISTORY_MESSAGES * (budgetForHistory / HISTORY_TOKEN_BUDGET))) : MAX_HISTORY_MESSAGES;
+  var maxHistoryMessages = Math.max(
+    MAX_HISTORY_MESSAGES,
+    Math.round(MAX_HISTORY_MESSAGES * (budgetForHistory / HISTORY_TOKEN_BUDGET))
+  );
   var windowed = options.history.slice(-maxHistoryMessages);
   var latestIndex = windowed.length - 1;
   var trimmed = windowed.map(function(m, i2) {
@@ -1319,7 +1428,6 @@ var WEB_FETCH_MAX_USES = 40;
 var WEB_FETCH_MAX_CONTENT_TOKENS = 2e5;
 var OPENAI_RESPONSES_API_URL = "https://api.openai.com/v1/responses";
 var OPENAI_MODELS_API_URL = "https://api.openai.com/v1/models";
-var MAX_TOKENS = 25e3;
 var DEFAULT_OPENAI_IMAGE_DETAIL = "auto";
 var OPENAI_WEB_SEARCH_EXTERNAL_WEB_ACCESS = true;
 var MCP_NAME = "BunnyQuery";
@@ -1559,7 +1667,7 @@ async function callClaudeWithPublicMcp(prompt, service, owner, messages, system,
     owner,
     userId,
     model: model || DEFAULT_CLAUDE_MODEL,
-    maxTokens: MAX_TOKENS,
+    maxTokens: getMaxOutputTokens("claude", model || DEFAULT_CLAUDE_MODEL),
     system,
     extractContent,
     fileUrls,
@@ -1604,7 +1712,7 @@ async function callOpenAIWithPublicMcp(prompt, service, owner, messages, system,
     },
     data: {
       model: resolvedModel,
-      max_output_tokens: MAX_TOKENS,
+      max_output_tokens: getMaxOutputTokens("openai", resolvedModel),
       ...extractContent && extractContent.length ? { _skapi_extract: extractContent } : {},
       ...fileUrls && fileUrls.length ? { _skapi_file_urls: fileUrls } : {},
       input: responseInput,
@@ -1634,6 +1742,29 @@ async function notifyAgentContinueIndexing(info) {
 async function notifyAgentSaveAttachment(info) {
   const { platform, service, owner, attachment, parsedContent } = info;
   const continuing = !!info.continueIndexing;
+  if (!continuing) {
+    upsertIndexRunRecordSafe(service, attachment.storagePath, {
+      status: "working",
+      filename: attachment.name,
+      started: Date.now(),
+      queue: bgIndexingQueueName(info.userId, service),
+      platform
+    });
+  }
+  const tapDispatchFailure = (p) => {
+    if (continuing) return p;
+    return p.then(
+      (ack) => ack,
+      (err) => {
+        upsertIndexRunRecordSafe(service, attachment.storagePath, {
+          status: "error",
+          finished: Date.now(),
+          error: err && (err.message || String(err)) || "The indexing request could not be enqueued."
+        });
+        throw err;
+      }
+    );
+  };
   const visionFile = !parsedContent && isImageVisionFile(attachment.name, attachment.mime);
   const renderFrom = Math.max(0, info.renderFrom || 0);
   const renderPlaceholder = visionFile ? makeRenderPlaceholder(attachment.storagePath) : void 0;
@@ -1693,6 +1824,7 @@ async function notifyAgentSaveAttachment(info) {
       save_media: !continuing
     }))
   } : {};
+  const skapiFileUrls = attachment.url && attachment.storagePath ? { _skapi_file_urls: [{ path: attachment.storagePath, url: attachment.url }] } : {};
   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
@@ -1708,7 +1840,7 @@ async function notifyAgentSaveAttachment(info) {
   if (platform === "openai") {
     const resolvedModel2 = info.model || DEFAULT_OPENAI_MODEL;
     const imageDetail = getOpenAIImageDetail(resolvedModel2);
-    return clientSecretRequest({
+    return tapDispatchFailure(clientSecretRequest({
       clientSecretName: "openai",
       queue: bgIndexingQueueName(info.userId, service),
       service,
@@ -1722,12 +1854,13 @@ async function notifyAgentSaveAttachment(info) {
       },
       data: {
         model: resolvedModel2,
-        max_output_tokens: MAX_TOKENS,
+        max_output_tokens: getMaxOutputTokens("openai", resolvedModel2),
         // Nano-only transcription knobs. Indexing only; see variantIndexingOptions.
         ...variantIndexingOptions(resolvedModel2),
         ...skapiExtract,
         ...skapiRender,
         ...skapiWindow,
+        ...skapiFileUrls,
         input: [
           { role: "system", content: systemPrompt },
           {
@@ -1751,10 +1884,10 @@ async function notifyAgentSaveAttachment(info) {
           ] 
         ]
       }
-    });
+    }));
   }
   const resolvedModel = info.model || DEFAULT_CLAUDE_MODEL;
-  return clientSecretRequest({
+  return tapDispatchFailure(clientSecretRequest({
     clientSecretName: "claude",
     queue: bgIndexingQueueName(info.userId, service),
     service,
@@ -1770,10 +1903,11 @@ async function notifyAgentSaveAttachment(info) {
     },
     data: {
       model: resolvedModel,
-      max_tokens: MAX_TOKENS,
+      max_tokens: getMaxOutputTokens("claude", resolvedModel),
       ...skapiExtract,
       ...skapiRender,
       ...skapiWindow,
+      ...skapiFileUrls,
       system: [
         {
           type: "text",
@@ -1809,7 +1943,7 @@ async function notifyAgentSaveAttachment(info) {
         }
       ]
     }
-  });
+  }));
 }
 function extractClaudeText(response) {
   if (!Array.isArray(response?.content)) {
@@ -1870,6 +2004,21 @@ async function listOpenAIModels(service, owner) {
   });
 }
 var BG_INDEXING_QUEUE_SUFFIX = "-bg";
+function indexDoneUniqueId(storagePath) {
+  return "done::" + storagePath;
+}
+function runIndexUniqueId(storagePath) {
+  return "run::" + storagePath;
+}
+function upsertIndexRunRecordSafe(service, storagePath, patch) {
+  if (!service || !storagePath) return;
+  try {
+    const hook = chatEngineConfig().upsertIndexRunRecord;
+    if (typeof hook !== "function") return;
+    hook({ service, storagePath, patch });
+  } catch (e) {
+  }
+}
 function bgIndexingQueueName(userId, service) {
   return (userId || service || "") + BG_INDEXING_QUEUE_SUFFIX;
 }
@@ -1893,13 +2042,20 @@ async function getChatHistory(params, fetchOptions) {
     },
     { service: params.service, owner: params.owner },
     params.queue ? { queue: params.queue } : {},
-    params.status ? { status: params.status } : {}
+    params.status ? { status: params.status } : {},
+    params.queue_exact ? { queue_exact: true } : {},
+    params.compact ? { compact: true } : {},
+    params.queue_exclude ? { queue_exclude: params.queue_exclude } : {}
   );
   return chatEngineConfig().clientSecretRequestHistory(
     p,
     Object.assign({ ascending: false, limit: CHAT_HISTORY_PAGE_LIMIT }, fetchOptions)
   );
 }
+function buildHistoryItemFullId(platform, service, itemId) {
+  const url = platform === "claude" ? ANTHROPIC_MESSAGES_API_URL : OPENAI_RESPONSES_API_URL;
+  return `[POST]${url.toLowerCase()}#${service}:${itemId}`;
+}
 
 // src/engine/history.ts
 function filterListByClearHorizon(list, clearedAt) {
@@ -1949,6 +2105,278 @@ function parseIndexingRequestText(userText) {
     continued: userText.indexOf("CONTINUE indexing") === 0
   };
 }
+var LIVE_INDEX_PROBE_LIMIT = 20;
+var BG_PROBE_TTL_MS = 4e3;
+var bgProbeCache = {};
+var bgProbeInflight = {};
+function probeBgQueue(params, opts) {
+  const key = [params.service, params.owner, params.platform, params.queue, params.status, params.limit].join("|");
+  const maxAge = opts && typeof opts.maxAgeMs === "number" ? opts.maxAgeMs : 0;
+  const cached = bgProbeCache[key];
+  if (maxAge > 0 && cached && Date.now() - cached.at < maxAge) {
+    return Promise.resolve(cached);
+  }
+  const inflight = bgProbeInflight[key];
+  if (inflight) return inflight;
+  const p = Promise.resolve(getChatHistory(
+    { service: params.service, owner: params.owner, platform: params.platform, queue: params.queue, status: params.status },
+    { limit: params.limit, fetchMore: false }
+  )).then(function(result) {
+    const entry = { result, at: Date.now() };
+    bgProbeCache[key] = entry;
+    return entry;
+  });
+  bgProbeInflight[key] = p;
+  p.then(function() {
+    delete bgProbeInflight[key];
+  }, function() {
+    delete bgProbeInflight[key];
+  });
+  return p;
+}
+async function fetchLiveIndexingKeys(params) {
+  const queue = bgIndexingQueueName(params.userId, params.service);
+  const base = { service: params.service, owner: params.owner, platform: params.platform, queue };
+  const [pending, running] = await Promise.all([
+    probeBgQueue({ ...base, status: "pending", limit: LIVE_INDEX_PROBE_LIMIT }, { maxAgeMs: BG_PROBE_TTL_MS }),
+    probeBgQueue({ ...base, status: "running", limit: LIVE_INDEX_PROBE_LIMIT }, { maxAgeMs: BG_PROBE_TTL_MS })
+  ]);
+  const keys = /* @__PURE__ */ new Set();
+  let truncated = false;
+  for (const entry of [pending, running]) {
+    const res = entry.result;
+    const list = res && Array.isArray(res.list) ? res.list : [];
+    if (list.length >= LIVE_INDEX_PROBE_LIMIT) truncated = true;
+    for (const item of list) {
+      const text = extractLastUserTextFromRequest(item && item.request_body);
+      if (!text || !isIndexingRequestText(text)) continue;
+      const ref = parseIndexingRequestText(text);
+      if (!ref) continue;
+      if (ref.path) keys.add(ref.path);
+      if (ref.name) keys.add(ref.name);
+    }
+  }
+  return { keys, checked: !truncated, at: Math.min(pending.at, running.at) };
+}
+var BG_COVERAGE_MAX_PAGES = 2;
+var splitHistoryStates = {};
+var splitHistoryLocks = {};
+function freshSplitState() {
+  return { bgBuffer: [], bgEnd: false, bgStarted: false, surfaceEnd: false, pendingSurface: null, surfaceCarry: [], lastSurfaceKeys: [], newestBgId: "" };
+}
+function noteBgIds(state, list) {
+  for (const it of list) {
+    const id = it && typeof it.id === "string" ? it.id : "";
+    if (id && id > state.newestBgId) state.newestBgId = id;
+  }
+}
+function __resetSplitHistoryState(key) {
+  if (key !== void 0) {
+    delete splitHistoryStates[key];
+    delete splitHistoryLocks[key];
+    return;
+  }
+  for (const k in splitHistoryStates) delete splitHistoryStates[k];
+  for (const k in splitHistoryLocks) delete splitHistoryLocks[k];
+}
+var createdOf = (it) => {
+  const c = Number(it && it.created);
+  return isFinite(c) && c > 0 ? c : NaN;
+};
+var oldestCreated = (lst) => {
+  let m = Infinity;
+  for (const it of lst) {
+    const c = createdOf(it);
+    if (!isNaN(c) && c < m) m = c;
+  }
+  return m;
+};
+var SURFACE_EMPTY_MAX_PAGES = 10;
+async function getSplitChatHistory(params, fetchOptions, _fetchImpl) {
+  const key = [params.service, params.owner, params.platform, params.userId || ""].join("|");
+  const prev = splitHistoryLocks[key] || Promise.resolve();
+  let releaseLock;
+  const lockTail = new Promise((r) => {
+    releaseLock = r;
+  });
+  const run = () => _getSplitChatHistoryLocked(key, params, fetchOptions, releaseLock, _fetchImpl);
+  const p = prev.then(run, run);
+  p.then((res) => {
+    if (!res || !res.bgPending) releaseLock();
+  }, () => releaseLock());
+  splitHistoryLocks[key] = p.then(() => lockTail, () => lockTail);
+  return p;
+}
+async function _getSplitChatHistoryLocked(key, params, fetchOptions, releaseLock, _fetchImpl) {
+  const fetch = _fetchImpl || getChatHistory;
+  const bgQueue = bgIndexingQueueName(params.userId, params.service);
+  const base = { service: params.service, owner: params.owner, platform: params.platform };
+  const fetchMore = !!(fetchOptions && fetchOptions.fetchMore);
+  const limit = fetchOptions && fetchOptions.limit;
+  const firstLoad = !splitHistoryStates[key];
+  let headRefresh = false;
+  if (!splitHistoryStates[key]) {
+    splitHistoryStates[key] = freshSplitState();
+  } else if (!fetchMore) {
+    const prev = splitHistoryStates[key];
+    if (prev.surfaceEnd && prev.bgEnd) {
+      headRefresh = true;
+      prev.pendingSurface = null;
+      prev.surfaceCarry = [];
+      prev.bgBuffer = [];
+    } else {
+      splitHistoryStates[key] = freshSplitState();
+    }
+  }
+  const state = splitHistoryStates[key];
+  if (state.pendingSurface && state.pendingSurface.forFetchMore !== fetchMore) {
+    state.pendingSurface = null;
+  }
+  if (!state.pendingSurface) {
+    if (state.surfaceEnd && !headRefresh) {
+      state.pendingSurface = { list: [], endOfList: true, startKeyHistory: state.lastSurfaceKeys, forFetchMore: fetchMore };
+    } else {
+      const sOpts = { fetchMore };
+      if (limit) sOpts.limit = limit;
+      let s = await fetch({ ...base, queue_exclude: bgQueue }, sOpts);
+      let hops = 0;
+      while (s && !s.endOfList && !(s.list || []).length && hops < SURFACE_EMPTY_MAX_PAGES) {
+        hops++;
+        const nOpts = { fetchMore: true };
+        if (limit) nOpts.limit = limit;
+        s = await fetch({ ...base, queue_exclude: bgQueue }, nOpts);
+      }
+      state.pendingSurface = {
+        list: s && Array.isArray(s.list) ? s.list : [],
+        endOfList: !!(s && s.endOfList),
+        startKeyHistory: s && Array.isArray(s.startKeyHistory) ? s.startKeyHistory : [],
+        forFetchMore: fetchMore
+      };
+    }
+  }
+  const surface = state.pendingSurface;
+  if (fetchOptions && fetchOptions.deferBg && (!state.bgEnd || headRefresh)) {
+    const surfaceList0 = state.surfaceCarry.length ? state.surfaceCarry.concat(surface.list) : surface.list.slice();
+    state.surfaceCarry = [];
+    const emitNow = surfaceList0.concat(state.bgBuffer);
+    state.bgBuffer = [];
+    if (!headRefresh) state.surfaceEnd = surface.endOfList;
+    state.lastSurfaceKeys = surface.startKeyHistory;
+    state.pendingSurface = null;
+    const bgPending = (async () => {
+      try {
+        const batch = [];
+        if (headRefresh) {
+          const bOpts = { fetchMore: false };
+          if (limit) bOpts.limit = limit;
+          const b = await fetch({ ...base, queue: bgQueue, queue_exact: true, compact: true }, bOpts);
+          const bList = b && Array.isArray(b.list) ? b.list : [];
+          for (const it of bList) {
+            if (it && typeof it === "object") it._fromBgChain = true;
+            batch.push(it);
+          }
+          const prevNewest = state.newestBgId;
+          noteBgIds(state, bList);
+          if (prevNewest && !(b && b.endOfList) && !bList.some((it) => it && it.id === prevNewest)) {
+            state.bgEnd = false;
+            state.bgStarted = true;
+          }
+        } else {
+          let hops = 0;
+          while (!state.bgEnd && hops < BG_COVERAGE_MAX_PAGES) {
+            hops++;
+            const bOpts = { fetchMore: state.bgStarted };
+            if (limit) bOpts.limit = limit;
+            const b = await fetch({ ...base, queue: bgQueue, queue_exact: true, compact: true }, bOpts);
+            state.bgStarted = true;
+            const bList = b && Array.isArray(b.list) ? b.list : [];
+            for (const it of bList) {
+              if (it && typeof it === "object") it._fromBgChain = true;
+              batch.push(it);
+            }
+            noteBgIds(state, bList);
+            state.bgEnd = !!(b && b.endOfList);
+            if (!bList.length && !state.bgEnd) break;
+            if (state.bgEnd) break;
+          }
+        }
+        return { list: batch, endOfList: state.surfaceEnd && state.bgEnd };
+      } finally {
+        releaseLock();
+      }
+    })();
+    return {
+      list: emitNow,
+      // A head-refreshed ended chain KNOWS it is still ended — reporting
+      // the hardcoded false here was what un-gated the fill loop on every
+      // tab return. Mid-walk it computes to false exactly as before (this
+      // branch is only entered with bgEnd false then); the bg batch still
+      // carries the final word for that case.
+      endOfList: state.surfaceEnd && state.bgEnd,
+      startKeyHistory: surface.startKeyHistory,
+      firstLoad,
+      bgPending
+    };
+  }
+  const surfaceList = state.surfaceCarry.length ? state.surfaceCarry.concat(surface.list) : surface.list.slice();
+  const boundary = surface.endOfList ? -Infinity : oldestCreated(surfaceList);
+  if (headRefresh) {
+    const hOpts = { fetchMore: false };
+    if (limit) hOpts.limit = limit;
+    const hb = await fetch({ ...base, queue: bgQueue, queue_exact: true, compact: true }, hOpts);
+    const hbList = hb && Array.isArray(hb.list) ? hb.list : [];
+    for (const it of hbList) {
+      if (it && typeof it === "object") it._fromBgChain = true;
+      state.bgBuffer.push(it);
+    }
+    const prevNewestH = state.newestBgId;
+    noteBgIds(state, hbList);
+    if (prevNewestH && !(hb && hb.endOfList) && !hbList.some((it) => it && it.id === prevNewestH)) {
+      state.bgEnd = false;
+      state.bgStarted = true;
+    }
+  } else if (boundary !== Infinity || surface.endOfList) {
+    let hops = 0;
+    while (!state.bgEnd && hops < BG_COVERAGE_MAX_PAGES) {
+      const bufOldest = state.bgBuffer.length ? oldestCreated(state.bgBuffer) : Infinity;
+      if (state.bgBuffer.length && bufOldest <= boundary) break;
+      hops++;
+      const bOpts = { fetchMore: state.bgStarted };
+      if (limit) bOpts.limit = limit;
+      const b = await fetch({ ...base, queue: bgQueue, queue_exact: true, compact: true }, bOpts);
+      state.bgStarted = true;
+      const bList = b && Array.isArray(b.list) ? b.list : [];
+      for (const it of bList) {
+        if (it && typeof it === "object") it._fromBgChain = true;
+        state.bgBuffer.push(it);
+      }
+      noteBgIds(state, bList);
+      state.bgEnd = !!(b && b.endOfList);
+      if (!bList.length && !state.bgEnd) break;
+      if (state.bgEnd) break;
+    }
+  }
+  const emitSurface = surfaceList;
+  state.surfaceCarry = [];
+  const emitBg = state.bgBuffer;
+  state.bgBuffer = [];
+  const seen = {};
+  for (const it of emitSurface) {
+    if (it && typeof it.id === "string") seen[it.id] = true;
+  }
+  const merged = emitSurface.concat(emitBg.filter((it) => !(it && typeof it.id === "string" && seen[it.id])));
+  if (!headRefresh) state.surfaceEnd = surface.endOfList;
+  state.lastSurfaceKeys = surface.startKeyHistory;
+  state.pendingSurface = null;
+  return {
+    list: merged,
+    endOfList: state.surfaceEnd && state.bgEnd && state.bgBuffer.length === 0 && state.surfaceCarry.length === 0,
+    // Bookkeeping only (both the consumers and the SDK treat it opaquely);
+    // the real cursors are the SDK's internal ones plus this module's state.
+    startKeyHistory: surface.startKeyHistory,
+    firstLoad
+  };
+}
 function mapHistoryListToMessages(list, platform, opts) {
   var mapped = [], runningItemIds = [];
   var extractAssistantText = platform === "openai" ? extractOpenAIText : extractClaudeText;
@@ -1961,10 +2389,11 @@ function mapHistoryListToMessages(list, platform, opts) {
     var isPending = isInProcess || isQueued;
     var isFailed = item && item.status === "failed";
     var response = isFailed ? item.error != null ? item.error : item.response_body : item && item.response_body != null ? item.response_body : item && item.error;
-    var userText = extractLastUserTextFromRequest(requestBody);
-    var assistantText = isPending ? "" : (extractAssistantText(response) || "").trim() || "";
-    var isErrorResponse = !isPending && (isFailed || isErrorResponseBody(response));
-    var reportedComplete = !!(item && item._isBgTask) && !isErrorResponse && !!assistantText && assistantText.indexOf(INDEXING_COMPLETE_MARKER) !== -1;
+    var isCompact = !!(item && item.compact);
+    var userText = isCompact ? typeof item.request_text === "string" ? item.request_text : "" : extractLastUserTextFromRequest(requestBody);
+    var assistantText = isPending ? "" : isCompact ? (typeof item.response_text === "string" ? item.response_text : "").trim() : (extractAssistantText(response) || "").trim() || "";
+    var isErrorResponse = !isPending && (isFailed || !isCompact && isErrorResponseBody(response));
+    var reportedComplete = !!(item && item._isBgTask) && !isErrorResponse && (isCompact ? item.response_complete_marker === true : !!assistantText && assistantText.indexOf(INDEXING_COMPLETE_MARKER) !== -1);
     if (reportedComplete) assistantText = assistantText.split(INDEXING_COMPLETE_MARKER).join("").trim();
     var serverItemId = item && typeof item.id === "string" && item.id ? item.id : void 0;
     var createdTs = Number(item && item.created);
@@ -1993,9 +2422,11 @@ function mapHistoryListToMessages(list, platform, opts) {
         displayContent = sanitizeAttachmentLinksForHistory(userText, opts.projectId);
       }
       var userMsg = { role: "user", content: displayContent };
+      if (item._fromBgChain) userMsg._fromBgChain = true;
       if (isInProcess) userMsg.isPendingInProcess = true;
       if (isQueued) userMsg.isPendingQueued = true;
       if (isCancelledItem) userMsg.isCancelled = true;
+      if (isCompact) userMsg._compact = true;
       if (item._isBgTask) userMsg.isBackgroundTask = true;
       if (indexFile) userMsg._indexFile = indexFile;
       if (item._isOnBgQueue) userMsg._useBgQueue = true;
@@ -2005,6 +2436,8 @@ function mapHistoryListToMessages(list, platform, opts) {
     }
     if (isCancelledItem) ; else if (isInProcess) {
       var ph = { role: "assistant", content: "", isPending: true, isPendingInProcess: true };
+      if (userTs !== void 0) ph._ts = userTs;
+      if (item._fromBgChain) ph._fromBgChain = true;
       if (item._isBgTask) ph.isBackgroundTask = true;
       if (serverItemId !== void 0) {
         ph._serverItemId = serverItemId;
@@ -2013,19 +2446,26 @@ function mapHistoryListToMessages(list, platform, opts) {
       mapped.push(ph);
     } else if (isQueued) ; else if (isErrorResponse) {
       var em = { role: "assistant", content: getErrorMessage(response), isError: true };
+      if (item._fromBgChain) em._fromBgChain = true;
       if (item._isBgTask) em.isBackgroundTask = true;
       if (serverItemId !== void 0) em._serverItemId = serverItemId;
       if (replyTs !== void 0) em._ts = replyTs;
       mapped.push(em);
     } else if (assistantText || reportedComplete) {
       var okm = { role: "assistant", content: sanitizeAttachmentLinksForHistory(assistantText, opts.projectId, true) || EMPTY_INDEXING_REPLY };
+      if (item._fromBgChain) okm._fromBgChain = true;
       if (item._isBgTask) okm.isBackgroundTask = true;
+      if (isCompact) okm._compact = true;
       if (serverItemId !== void 0) okm._serverItemId = serverItemId;
       if (replyTs !== void 0) okm._ts = replyTs;
       if (reportedComplete) okm._indexComplete = true;
       mapped.push(okm);
     }
   });
+  if (opts.projectId) {
+    var ownerKey = opts.projectId + "#" + platform;
+    for (var oi = 0; oi < mapped.length; oi++) mapped[oi]._ownerKey = ownerKey;
+  }
   return { messages: mapped, runningItemIds };
 }
 
@@ -2143,6 +2583,7 @@ var INDEXING_DRAIN_BUSY_POLL_MS = 8e3;
 var INDEXING_DRAIN_CONFIRM_POLL_MS = 3e3;
 var INDEXING_DRAIN_IDLE_LOOKS = 2;
 var INDEXING_DRAIN_MIN_MS = 8e3;
+var _bgHistoryBatchSeq = 0;
 var INDEXING_DRAIN_TIMEOUT_MS = 15 * 60 * 1e3;
 var INDEXING_DRAIN_LOOK_TIMEOUT_MS = 45e3;
 var INDEXING_DRAIN_NUDGE_MIN_GAP_MS = 1500;
@@ -2164,6 +2605,14 @@ function isPollStopped(res) {
 }
 var ChatSession = class {
   constructor(host) {
+    // ─── compact-stub hydration ─────────────────────────────────────────────
+    // Split-fetch bg pages arrive as label stubs (no bodies). When the user
+    // expands a row, the real reply text is fetched per item (csr-poll point
+    // lookup) and MEMOIZED per chat: every later remap (first-page refresh,
+    // queue-detect tick, cache restore) re-applies the memo, so a hydrated
+    // bubble can never silently revert to its 200-char head.
+    this._hydratedBodies = {};
+    this._hydratingItems = {};
     this.typewriterQueue = Promise.resolve();
     /**
      * Pick up indexing passes the WORKER minted, which no client ever dispatched.
@@ -2204,6 +2653,9 @@ var ChatSession = class {
       typingAbort: false,
       loadingHistory: false,
       loadingOlderHistory: false,
+      // A deferred bg stub batch (first-paint split) is still in flight; the
+      // views show a small 'loading indexing history' hint while true.
+      bgHistoryLoading: false,
       historyEndOfList: false,
       historyStartKeyHistory: [],
       historyRequestToken: 0,
@@ -2353,10 +2805,12 @@ var ChatSession = class {
     }
     var queue = bgIndexingQueueName(id.userId, id.projectId);
     var ask = function(status) {
-      return Promise.resolve(getChatHistory(
-        { service: id.projectId, owner: id.owner, platform, queue, status },
-        { limit: WORKER_PASS_ADOPT_LIMIT }
-      )).catch(function() {
+      return Promise.resolve(probeBgQueue(
+        { service: id.projectId, owner: id.owner, platform, queue, status, limit: WORKER_PASS_ADOPT_LIMIT },
+        { maxAgeMs: BG_PROBE_TTL_MS }
+      )).then(function(entry) {
+        return entry.result;
+      }).catch(function() {
         return null;
       });
     };
@@ -2448,7 +2902,7 @@ var ChatSession = class {
    * instead of merely unconfirmed.
    */
   refreshLiveIndexState() {
-    this._adoptWorkerIndexingPasses(0);
+    this._adoptWorkerIndexingPasses(0, true);
   }
   /** Forget what we know about which files are indexing — but ONLY when the
    *  snapshot was taken for a different chat than the one on screen now. For a
@@ -2625,6 +3079,66 @@ var ChatSession = class {
     if (!id.projectId || id.platform === "none") return "";
     return id.projectId + "#" + id.platform;
   }
+  /** Re-apply memoized hydrated texts onto freshly-mapped messages. Both
+   *  clients call this right after their mapper runs (loadHistory does it
+   *  internally); it mutates the given array's items in place. */
+  applyHydratedBodies(messages) {
+    var key = this.getHistoryCacheKey();
+    var memo = key ? this._hydratedBodies[key] : null;
+    if (!memo) return;
+    var id = this.host.getIdentity();
+    for (var i = 0; i < messages.length; i++) {
+      var m = messages[i];
+      if (!m || !m._compact || m.role !== "assistant" || !m._serverItemId) continue;
+      var text = memo[m._serverItemId];
+      if (typeof text !== "string") continue;
+      m.content = sanitizeAttachmentLinksForHistory(text, id.projectId, true) || EMPTY_INDEXING_REPLY;
+      delete m._compact;
+    }
+  }
+  /** Fetch the real response bodies for compact history stubs (one csr-poll
+   *  point lookup per item id), memoize, and swap them into the live list.
+   *  Best-effort: a failed lookup leaves the stub (its head + fallback line
+   *  still render) and a later expand retries. */
+  hydrateCompactItems(itemIds) {
+    var self = this;
+    var lookup = chatEngineConfig().csrHistoryItemLookup;
+    if (!lookup || !itemIds || !itemIds.length) return Promise.resolve();
+    var id = this.host.getIdentity();
+    var platform = id.platform;
+    if (!id.projectId || platform !== "claude" && platform !== "openai") return Promise.resolve();
+    var chatKey = this.getHistoryCacheKey();
+    if (!chatKey) return Promise.resolve();
+    var jobs = itemIds.map(function(itemId) {
+      if (!itemId) return Promise.resolve();
+      var already = self._hydratedBodies[chatKey] && self._hydratedBodies[chatKey][itemId] !== void 0;
+      var inflightKey = chatKey + "|" + itemId;
+      if (already || self._hydratingItems[inflightKey]) return Promise.resolve();
+      self._hydratingItems[inflightKey] = true;
+      return Promise.resolve(lookup(buildHistoryItemFullId(platform, id.projectId, itemId), id.projectId, id.owner)).then(function(body) {
+        var text = ((platform === "openai" ? extractOpenAIText(body) : extractClaudeText(body)) || "").trim();
+        if (text.indexOf(INDEXING_COMPLETE_MARKER) !== -1) text = text.split(INDEXING_COMPLETE_MARKER).join("").trim();
+        if (!self._hydratedBodies[chatKey]) self._hydratedBodies[chatKey] = {};
+        self._hydratedBodies[chatKey][itemId] = text;
+        if (self.getHistoryCacheKey() !== chatKey) return;
+        for (var i = 0; i < self.state.messages.length; i++) {
+          var m = self.state.messages[i];
+          if (m && m._compact && m.role === "assistant" && m._serverItemId === itemId) {
+            m.content = sanitizeAttachmentLinksForHistory(text, id.projectId, true) || EMPTY_INDEXING_REPLY;
+            delete m._compact;
+          }
+        }
+      }).catch(function() {
+      }).then(function() {
+        delete self._hydratingItems[inflightKey];
+      });
+    });
+    return Promise.all(jobs).then(function() {
+      if (self.getHistoryCacheKey() !== chatKey) return;
+      self.host.notify();
+      self.updateHistoryCache();
+    });
+  }
   updateHistoryCache() {
     var key = this.getHistoryCacheKey();
     if (!key) return;
@@ -2947,11 +3461,11 @@ var ChatSession = class {
         bail = setTimeout(function() {
           settle(null);
         }, INDEXING_DRAIN_LOOK_TIMEOUT_MS);
-        Promise.resolve(getChatHistory(
-          { service: svcId, owner, platform, queue, status },
-          { limit: WORKER_PASS_ADOPT_LIMIT }
-        )).then(function(r) {
-          settle(r);
+        Promise.resolve(probeBgQueue(
+          { service: svcId, owner, platform, queue, status, limit: WORKER_PASS_ADOPT_LIMIT },
+          { maxAgeMs: 0 }
+        )).then(function(entry) {
+          settle(entry.result);
         }, function() {
           settle(null);
         });
@@ -3578,6 +4092,32 @@ var ChatSession = class {
         if (e && e.id && self._indexKeyOf(e) === scoped) stoppedIds[e.id] = true;
       });
       this.state.stoppedIndexIds = stoppedIds;
+      var runPath = group.path || "";
+      if (!runPath) {
+        (group.members || []).some(function(m) {
+          var p = m && m.msg && m.msg._indexFile && m.msg._indexFile.path;
+          if (p) {
+            runPath = p;
+            return true;
+          }
+          return false;
+        });
+      }
+      if (!runPath) {
+        this.bgTaskQueue.some(function(e) {
+          if (e && e.storagePath && self._indexKeyOf(e) === scoped) {
+            runPath = e.storagePath;
+            return true;
+          }
+          return false;
+        });
+      }
+      if (runPath) {
+        var ident = this.host.getIdentity();
+        if (ident && ident.projectId) {
+          upsertIndexRunRecordSafe(ident.projectId, runPath, { status: "cancelled", finished: Date.now() });
+        }
+      }
     }
     this._adoptWorkerIndexingPasses(0);
     var ids = group.cancellableIds || [];
@@ -4091,7 +4631,7 @@ var ChatSession = class {
     if (isImageVisionFile(filename, mime)) return true;
     return windowedIndexingEnabled() && isWindowedReadFile(filename, mime);
   }
-  _adoptWorkerIndexingPasses(attempt) {
+  _adoptWorkerIndexingPasses(attempt, passive) {
     var self = this;
     if (this._adoptingWorkerPasses) return;
     var id = this.host.getIdentity();
@@ -4101,10 +4641,12 @@ var ChatSession = class {
     var svcId = id.projectId, owner = id.owner;
     var queue = bgIndexingQueueName(id.userId, id.projectId);
     var ask = function(status) {
-      return Promise.resolve(getChatHistory(
-        { service: svcId, owner, platform, queue, status },
-        { limit: WORKER_PASS_ADOPT_LIMIT }
-      )).catch(function() {
+      return Promise.resolve(probeBgQueue(
+        { service: svcId, owner, platform, queue, status, limit: WORKER_PASS_ADOPT_LIMIT },
+        { maxAgeMs: 0 }
+      )).then(function(entry) {
+        return entry.result;
+      }).catch(function() {
         return null;
       });
     };
@@ -4126,6 +4668,7 @@ var ChatSession = class {
         self.drainBgTaskQueue();
         if (self._isTrackingAny(adoptedIds)) return;
       }
+      if (passive && !self._hasLiveIndexEvidence(svcId)) return;
       if (attempt + 1 >= WORKER_PASS_ADOPT_ATTEMPTS.length) {
         self._nudgeIndexingDrain();
         return;
@@ -4134,12 +4677,30 @@ var ChatSession = class {
         var later = self.host.getIdentity();
         if (later.projectId !== svcId || later.platform !== platform) return;
         if (self.isPollingPaused() || !self.host.isViewMounted()) return;
-        self._adoptWorkerIndexingPasses(attempt + 1);
+        self._adoptWorkerIndexingPasses(attempt + 1, passive);
       }, WORKER_PASS_ADOPT_ATTEMPTS[attempt + 1]);
     }, function() {
       self._adoptingWorkerPasses = false;
     });
   }
+  /** Anything at all suggesting THIS project's indexing may be live: a queued
+   *  local entry, a recorded live key (the adopt look just wrote them), or an
+   *  attached poll. Gates the passive adopt ladder's climb. */
+  _hasLiveIndexEvidence(svcId) {
+    for (var i = 0; i < this.bgTaskQueue.length; i++) {
+      var e = this.bgTaskQueue[i];
+      if (e && e.projectId === svcId) return true;
+    }
+    var keys = this.state.liveIndexKeys || {};
+    for (var k in keys) {
+      if (keys[k]) return true;
+    }
+    var found = false;
+    this.historyItemPolls.forEach(function(h) {
+      if (h && h.kind === "bg") found = true;
+    });
+    return found;
+  }
   /** Any of these ids still queued or still polled, i.e. surviving work. */
   _isTrackingAny(ids) {
     for (var i = 0; i < ids.length; i++) {
@@ -4230,7 +4791,10 @@ var ChatSession = class {
     for (var i = this.bgTaskQueue.length - 1; i >= 0; i--) {
       var e = this.bgTaskQueue[i];
       if (e.projectId !== svcId || e.platform !== plat) continue;
-      if (presentIds[e.id] && !pendingIds[e.id]) this.bgTaskQueue.splice(i, 1);
+      if (presentIds[e.id] && !pendingIds[e.id]) {
+        this._flipRunFromSettledEntry(e);
+        this.bgTaskQueue.splice(i, 1);
+      }
     }
     var bgPollBudget = MAX_CONCURRENT_BG_POLLS - this._countBgPolls();
     var injectedAny = false;
@@ -4304,6 +4868,8 @@ var ChatSession = class {
           self.host.notify();
           self.updateHistoryCache();
           if (!self._isWorkerDrivenIndexing(capturedEntry.filename, capturedEntry.mime)) {
+            if (isNotExists) self._flipRunRecord(capturedEntry, "cancelled");
+            else self._flipRunRecord(capturedEntry, "error", self._runErrorText(err));
             self._nudgeIndexingDrain();
           }
         }).then(function() {
@@ -4335,6 +4901,74 @@ var ChatSession = class {
   // 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.
+  /** Fire the consumer's done::-marker hook for a run whose completion this
+   *  client knows DETERMINISTICALLY (see the two call sites in
+   *  maybeResumeIndexing). Best-effort by contract; identity-checked so a
+   *  project switch mid-settle cannot stamp the wrong service. */
+  _mintDoneMarker(entry) {
+    try {
+      var mint = chatEngineConfig().mintIndexDoneMarker;
+      if (!mint || !entry || !entry.storagePath || !entry.projectId) return;
+      var id = this.host.getIdentity();
+      if (!id || id.projectId !== entry.projectId) return;
+      mint({ service: entry.projectId, storagePath: entry.storagePath });
+    } catch (_e) {
+    }
+  }
+  /** Short, storable form of an error body for the run:: record. */
+  _runErrorText(response) {
+    var msg = "";
+    try {
+      msg = String(getErrorMessage(response) || "");
+    } catch (_e) {
+    }
+    msg = msg.replace(/\s+/g, " ").trim();
+    return msg ? msg.slice(0, 300) : "Indexing failed.";
+  }
+  /** Close the records of a run whose pass settled OFF-POLL — the answer came
+   *  back as history (hidden tab, dead poll, resume refetch), so none of the
+   *  poll-side settle handlers ran. Only for SINGLE-PASS files, where one
+   *  settled pass is deterministically the whole run (the same contract as
+   *  maybeResumeIndexing's single-pass branch); paged files stay with their
+   *  drivers. Outcome is read from the settled bubbles' own flags, which is
+   *  all the history mapping left us. Best-effort and idempotent throughout. */
+  _flipRunFromSettledEntry(entry) {
+    try {
+      if (!entry || !entry.storagePath || !entry.id || !entry.projectId) return;
+      if (isPagedReadFile(entry.filename, entry.mime)) return;
+      if (this.cancelledIndexKeys.has(this._indexKeyOf(entry))) return;
+      if (this.state.stoppedIndexIds[entry.id]) return;
+      var userMsg = null, replyMsg = null;
+      this.state.messages.forEach(function(m) {
+        if (m._serverItemId !== entry.id) return;
+        if (m.role === "user") {
+          if (!userMsg) userMsg = m;
+        } else if (!replyMsg) replyMsg = m;
+      });
+      if (userMsg && userMsg.isCancelled || replyMsg && replyMsg.isCancelled) {
+        this._flipRunRecord(entry, "cancelled");
+      } else if (replyMsg && replyMsg.isError) {
+        var errText = typeof replyMsg.content === "string" ? replyMsg.content.replace(/\s+/g, " ").trim().slice(0, 300) : "";
+        this._flipRunRecord(entry, "error", errText || "Indexing failed.");
+      } else if (replyMsg) {
+        this._mintDoneMarker(entry);
+        this._flipRunRecord(entry, "done");
+      }
+    } catch (_e) {
+    }
+  }
+  /** Close the durable run:: record for an ending THIS client observed.
+   *  service comes from the ENTRY, not the current identity: unlike the done::
+   *  mint above, a status flip must land even if the user switched projects
+   *  mid-settle — otherwise the record lies 'working' forever. Best-effort
+   *  through upsertIndexRunRecordSafe; the consumer's precedence guard keeps
+   *  repeats and races harmless. */
+  _flipRunRecord(entry, status, error) {
+    if (!entry || !entry.storagePath || !entry.projectId) return;
+    var patch = { status, finished: Date.now() };
+    if (error) patch.error = error;
+    upsertIndexRunRecordSafe(entry.projectId, entry.storagePath, patch);
+  }
   maybeResumeIndexing(entry, response, platform) {
     var self = this;
     var endOfClientChain = function() {
@@ -4344,27 +4978,43 @@ var ChatSession = class {
       if (!entry || !entry.storagePath) return;
       if (this.cancelledIndexKeys.has(this._indexKeyOf(entry))) return;
       if (!isPagedReadFile(entry.filename, entry.mime)) {
+        if (!isErrorResponseBody(response) && !this._isCancelledPollResult(response)) {
+          this._mintDoneMarker(entry);
+          this._flipRunRecord(entry, "done");
+        } else if (this._isCancelledPollResult(response)) {
+          this._flipRunRecord(entry, "cancelled");
+        } else {
+          this._flipRunRecord(entry, "error", this._runErrorText(response));
+        }
         endOfClientChain();
         return;
       }
       if (isImageVisionFile(entry.filename, entry.mime)) return;
       if (windowedIndexingEnabled() && isWindowedReadFile(entry.filename, entry.mime)) return;
       if (isErrorResponseBody(response)) {
+        this._flipRunRecord(entry, "error", this._runErrorText(response));
         endOfClientChain();
         return;
       }
       var answer = (platform === "openai" ? extractOpenAIText(response) : extractClaudeText(response)) || "";
       if (answer.indexOf(INDEXING_COMPLETE_MARKER) !== -1) {
+        this._mintDoneMarker(entry);
+        this._flipRunRecord(entry, "done");
         endOfClientChain();
         return;
       }
       var pass = (entry.resumePass || 0) + 1;
       if (pass > MAX_INDEXING_RESUME_PASSES) {
+        this._flipRunRecord(entry, "error", "Stopped after " + MAX_INDEXING_RESUME_PASSES + " passes without finishing.");
         endOfClientChain();
         return;
       }
       var id = this.host.getIdentity();
-      if (!id || id.platform === "none" || id.projectId !== entry.projectId) return;
+      if (!id || id.platform === "none" || id.projectId !== entry.projectId) {
+        this._flipRunRecord(entry, "error", "Indexing stopped: the session or project changed before the file finished.");
+        endOfClientChain();
+        return;
+      }
       this.trackIndexDispatch(notifyAgentContinueIndexing({
         platform: id.platform,
         model: id.model,
@@ -4441,8 +5091,9 @@ var ChatSession = class {
     var projectId = id.projectId, owner = id.owner;
     var options = { fetchMore };
     if (fetchMore && this.state.historyStartKeyHistory.length) options.startKeyHistory = this.state.historyStartKeyHistory.slice();
+    if (!fetchMore) options.deferBg = true;
     var fetchHistory = function() {
-      return getChatHistory({ service: projectId, owner, platform }, options);
+      return getSplitChatHistory({ service: projectId, owner, platform, userId: id.userId }, options);
     };
     return Promise.resolve().then(fetchHistory).catch(function(err) {
       if (isAuthExpiredError(err) && !isNonRetryableRequestError(err)) return self.host.refreshSession().then(fetchHistory);
@@ -4452,7 +5103,8 @@ var ChatSession = class {
       var chatList = history && Array.isArray(history.list) ? history.list : [];
       chatList.forEach(function(item) {
         if (isBgIndexingQueue(item.queue_name)) {
-          if (isIndexingRequestText(extractLastUserTextFromRequest(item.request_body))) item._isBgTask = true;
+          var clsText = item.compact ? item.request_text : extractLastUserTextFromRequest(item.request_body);
+          if (isIndexingRequestText(clsText)) item._isBgTask = true;
           else item._isOnBgQueue = true;
         }
       });
@@ -4465,15 +5117,55 @@ var ChatSession = class {
         projectId: id.projectId,
         formatIndexingLabel: self.host.formatIndexingLabel
       }).messages;
+      self.applyHydratedBodies(mapped);
       var keptOlderPages = false;
+      var keptScreenAwaitingBg = false;
       if (fetchMore) {
-        self.state.messages = mapped.concat(self.state.messages);
+        var incomingKeys = {};
+        mapped.forEach(function(m) {
+          if (m._serverItemId) incomingKeys[m._serverItemId + "|" + m.role] = m;
+        });
+        var existing = self.state.messages.filter(function(m) {
+          if (!m._serverItemId) return true;
+          var inc = incomingKeys[m._serverItemId + "|" + m.role];
+          if (!inc) return true;
+          if (m._cancelling) inc._cancelling = m._cancelling;
+          if (m._cancelError) inc._cancelError = m._cancelError;
+          return false;
+        });
+        var mergedList = [];
+        var pi = 0, ei = 0;
+        while (pi < mapped.length && ei < existing.length) {
+          var pm = mapped[pi], em = existing[ei];
+          var eid = em._serverItemId;
+          if (typeof eid !== "string") break;
+          var pid = pm._serverItemId;
+          if (typeof pid !== "string" || pid <= eid) {
+            mergedList.push(pm);
+            pi++;
+          } else {
+            mergedList.push(em);
+            ei++;
+          }
+        }
+        while (pi < mapped.length) mergedList.push(mapped[pi++]);
+        while (ei < existing.length) mergedList.push(existing[ei++]);
+        self.state.messages = mergedList;
+      } else if (!mapped.length && history && (history.endOfList === false || history.bgPending) && self.state.messages.some(function(m) {
+        return m._ownerKey === void 0 || m._ownerKey === loadKey;
+      })) {
+        if (history.endOfList !== false) keptScreenAwaitingBg = true;
       } else {
         if (self.state.typing) self.state.typingAbort = true;
         var serverIds = {};
         mapped.forEach(function(m) {
           if (m._serverItemId) serverIds[m._serverItemId] = 1;
         });
+        var surfaceOldestId = void 0;
+        mapped.forEach(function(m) {
+          if (typeof m._serverItemId !== "string" || m._fromBgChain) return;
+          if (surfaceOldestId === void 0 || m._serverItemId < surfaceOldestId) surfaceOldestId = m._serverItemId;
+        });
         var locallyCancelled = {};
         self.state.messages.forEach(function(m) {
           if (m.isCancelled && m._serverItemId) locallyCancelled[m._serverItemId] = m;
@@ -4514,13 +5206,45 @@ var ChatSession = class {
         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) {
+        var deferredBg = !!(history && history.bgPending);
+        var retainBoundary = surfaceOldestId !== void 0 ? surfaceOldestId : oldestInPage1;
+        var retainedOlder = !sharesPage1 || retainBoundary === 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;
+          if (deferredBg && m.isBackgroundTask) return true;
+          if (m._fromBgChain) return true;
+          return m._serverItemId < retainBoundary;
         });
-        keptOlderPages = retainedOlder.length > 0;
-        self.state.messages = keptOlderPages ? retainedOlder.concat(mapped) : mapped;
+        var prependOlder = [];
+        var interleave = [];
+        retainedOlder.forEach(function(m) {
+          var sid = m._serverItemId;
+          if (serverIds[sid]) return;
+          if (retainBoundary !== void 0 && sid < retainBoundary) prependOlder.push(m);
+          else interleave.push(m);
+        });
+        var page1 = mapped;
+        if (interleave.length) {
+          var mergedP = [];
+          var ii2 = 0, mi2 = 0;
+          while (ii2 < interleave.length && mi2 < mapped.length) {
+            var iv = interleave[ii2], mv = mapped[mi2];
+            var mid2 = typeof mv._serverItemId === "string" ? mv._serverItemId : void 0;
+            if (mid2 === void 0) break;
+            if (iv._serverItemId <= mid2) {
+              mergedP.push(iv);
+              ii2++;
+            } else {
+              mergedP.push(mv);
+              mi2++;
+            }
+          }
+          while (ii2 < interleave.length) mergedP.push(interleave[ii2++]);
+          while (mi2 < mapped.length) mergedP.push(mapped[mi2++]);
+          page1 = mergedP;
+        }
+        keptOlderPages = prependOlder.length > 0 || interleave.length > 0;
+        self.state.messages = prependOlder.length ? prependOlder.concat(page1) : page1;
         rescued.forEach(function(m) {
           self.state.messages.push(m);
         });
@@ -4556,9 +5280,14 @@ var ChatSession = class {
         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 (clearedAt) {
+          var surfaceItems = chatList.filter(function(it) {
+            return !(it && it._fromBgChain);
+          });
+          if (surfaceItems.length > 0) {
+            var oldestUpdated = Number(surfaceItems[surfaceItems.length - 1] && surfaceItems[surfaceItems.length - 1].updated);
+            if (isFinite(oldestUpdated) && oldestUpdated <= clearedAt) self.state.historyEndOfList = true;
+          }
         }
       }
       if (self.state.historyRequestToken === token) {
@@ -4567,6 +5296,85 @@ var ChatSession = class {
       }
       self.updateHistoryCache();
       self.host.notify();
+      var bgPending = !fetchMore && history && history.bgPending;
+      if (bgPending) {
+        var batchId = ++_bgHistoryBatchSeq;
+        if (history.endOfList !== true && history.firstLoad === true) {
+          self.state.bgHistoryLoading = true;
+          self.host.notify();
+        }
+        var releaseBgFlag = function() {
+          if (_bgHistoryBatchSeq === batchId) self.state.bgHistoryLoading = false;
+        };
+        bgPending.then(function(batch) {
+          if (token !== self.state.gateRefreshToken) {
+            releaseBgFlag();
+            return;
+          }
+          var bList = batch && Array.isArray(batch.list) ? batch.list : [];
+          bList.forEach(function(item) {
+            if (isBgIndexingQueue(item.queue_name)) {
+              var t = item.compact ? item.request_text : extractLastUserTextFromRequest(item.request_body);
+              if (isIndexingRequestText(t)) item._isBgTask = true;
+              else item._isOnBgQueue = true;
+            }
+          });
+          var sorted = bList.sort(function(a, b) {
+            var ai = typeof a.id === "string" ? a.id : "", bi = typeof b.id === "string" ? b.id : "";
+            return ai > bi ? -1 : ai < bi ? 1 : 0;
+          });
+          var m2 = mapHistoryListToMessages(sorted, platform, {
+            clearedAt: self.host.getClearedAt(),
+            projectId: id.projectId,
+            formatIndexingLabel: self.host.formatIndexingLabel
+          }).messages;
+          self.applyHydratedBodies(m2);
+          if (keptScreenAwaitingBg && !m2.length && batch && batch.endOfList === true) {
+            self.state.messages = self.state.messages.filter(function(m) {
+              if (typeof m._serverItemId !== "string") return true;
+              if (m._ownerKey !== void 0 && m._ownerKey !== loadKey) return true;
+              return false;
+            });
+            self.state.historyEndOfList = true;
+            releaseBgFlag();
+            self.updateHistoryCache();
+            self.host.notify();
+            return;
+          }
+          var incoming = {};
+          m2.forEach(function(m) {
+            if (m._serverItemId) incoming[m._serverItemId + "|" + m.role] = true;
+          });
+          var baseList = self.state.messages.filter(function(m) {
+            return !(m._serverItemId && incoming[m._serverItemId + "|" + m.role]);
+          });
+          var mergedList2 = [];
+          var pi2 = 0, ei2 = 0;
+          while (pi2 < m2.length && ei2 < baseList.length) {
+            var pm2 = m2[pi2], em2 = baseList[ei2];
+            var eid2 = em2._serverItemId;
+            if (typeof eid2 !== "string") break;
+            var pid2 = pm2._serverItemId;
+            if (typeof pid2 !== "string" || pid2 <= eid2) {
+              mergedList2.push(pm2);
+              pi2++;
+            } else {
+              mergedList2.push(em2);
+              ei2++;
+            }
+          }
+          while (pi2 < m2.length) mergedList2.push(m2[pi2++]);
+          while (ei2 < baseList.length) mergedList2.push(baseList[ei2++]);
+          self.state.messages = mergedList2;
+          if (batch && batch.endOfList === true) self.state.historyEndOfList = true;
+          releaseBgFlag();
+          self.updateHistoryCache();
+          self.host.notify();
+        }, function() {
+          releaseBgFlag();
+          self.host.notify();
+        });
+      }
       if (!fetchMore) {
         var bgAllow = {};
         var bgHistBudget = MAX_CONCURRENT_BG_POLLS - self._countBgPolls();
@@ -4663,7 +5471,7 @@ var ChatSession = class {
     var self = this;
     var id = this.host.getIdentity();
     att.status = "uploading";
-    att.progress = 0;
+    att.progress = null;
     att.errorMessage = "";
     att.errorCode = "";
     att.errorDetail = "";
@@ -4894,6 +5702,7 @@ var ChatSession = class {
 };
 
 // src/engine/indexing_groups.ts
+var RUN_RECORD_WORKING_STALE_MS = 6 * 60 * 60 * 1e3;
 var INDEXING_LABEL_RE = /^(Re)?[Ii]ndexing(\s*\(continuing\))?\s*:?\s+(.+)$/;
 var LEADING_MD_LINK_RE = /^\[([^\]]+)\]\(([^)]+)\)/;
 function parseIndexingLabel(content) {
@@ -4948,10 +5757,12 @@ function buildChatDisplayList(messages, opts) {
   var list = Array.isArray(messages) ? messages : [];
   var liveIndexKeys = opts && opts.liveIndexKeys || {};
   var liveIndexChecked = !!(opts && opts.liveIndexChecked);
+  var doneKeys = opts && opts.doneKeys || {};
   var stoppedIndexIds = opts && opts.stoppedIndexIds || {};
   var windowedIndexing = opts && opts.windowedIndexing !== void 0 ? !!opts.windowedIndexing : windowedIndexingEnabled();
   var hasMoreHistory = !!(opts && opts.hasMoreHistory);
   var loadingOlderHistory = !!(opts && opts.loadingOlderHistory);
+  var stubPlatform = opts && opts.stubPlatform;
   var groups = {};
   var order = [];
   var runOfIndex = new Array(list.length);
@@ -5124,11 +5935,11 @@ function buildChatDisplayList(messages, opts) {
     } else if (grp.driver === "client") {
       grp.finished = sawComplete || grp.status === "error" || grp.passCount >= MAX_INDEXING_RESUME_PASSES;
     } else {
-      grp.finished = !newestRunOfKey[order[oi]] || liveIndexChecked && !liveIndexKeys[grp.key];
+      grp.finished = !newestRunOfKey[order[oi]] || !!doneKeys[grp.key] && !liveIndexKeys[grp.key] || liveIndexChecked && !liveIndexKeys[grp.key];
     }
     if (grp.status !== "done") {
       grp.resolving = false;
-    } else if (grp.mayHaveOlder && loadingOlderHistory && !liveIndexKeys[grp.key] && newestRunOfKey[order[oi]]) {
+    } else if (grp.mayHaveOlder && loadingOlderHistory && !liveIndexKeys[grp.key] && !doneKeys[grp.key] && newestRunOfKey[order[oi]]) {
       grp.resolving = true;
       grp.resolvingReason = "history";
     } else if (!grp.finished && grp.driver === "worker" && !liveIndexChecked && !liveIndexKeys[grp.key]) {
@@ -5138,14 +5949,126 @@ function buildChatDisplayList(messages, opts) {
       grp.resolving = false;
     }
   }
+  var stubList = [];
+  var runStubs = opts && opts.runStubs;
+  if (runStubs) {
+    var coveredPaths = {};
+    var coveredPathlessNames = {};
+    for (var ci = 0; ci < order.length; ci++) {
+      var cg = groups[order[ci]];
+      if (cg.path) {
+        coveredPaths[cg.path] = true;
+        if (cg.key) coveredPaths[cg.key] = true;
+      } else if (cg.name) coveredPathlessNames[cg.name] = true;
+      else if (cg.key) coveredPaths[cg.key] = true;
+    }
+    var now = opts && typeof opts.now === "number" ? opts.now : Date.now();
+    var stubClearedAt = opts && typeof opts.stubClearedAt === "number" && opts.stubClearedAt > 0 ? opts.stubClearedAt : 0;
+    for (var sp in runStubs) {
+      var rec = runStubs[sp];
+      if (!sp || !rec || !rec.status || coveredPaths[sp]) continue;
+      var fname = rec.filename || sp.split("/").pop() || sp;
+      if (coveredPathlessNames[fname]) continue;
+      if (stubPlatform && rec.platform && rec.platform !== stubPlatform) continue;
+      var live = !!liveIndexKeys[sp] || !!liveIndexKeys[fname];
+      var recWhen = typeof rec.finished === "number" ? rec.finished : typeof rec.started === "number" ? rec.started : void 0;
+      if (stubClearedAt && !live && recWhen !== void 0 && recWhen <= stubClearedAt) continue;
+      var st = "active";
+      var fin = false;
+      var res = false;
+      var reason;
+      if (!live) {
+        if (rec.status === "done" || doneKeys[sp] || doneKeys[fname]) {
+          st = "done";
+          fin = true;
+        } else if (rec.status === "error") {
+          st = "error";
+          fin = true;
+        } else if (rec.status === "cancelled") {
+          st = "cancelled";
+          fin = true;
+        } else if (liveIndexChecked) {
+          st = "done";
+          fin = true;
+        } else if (typeof rec.started === "number" && now - rec.started > RUN_RECORD_WORKING_STALE_MS) {
+          st = "error";
+          fin = true;
+        } else {
+          res = true;
+          reason = "status";
+        }
+      }
+      var sg = {
+        key: sp,
+        // ONE identity for the run whether it renders from the record or
+        // from its loaded passes: the views key the DOM off runKey, so a
+        // 'stub:'-prefixed key meant every handoff was an unmount plus a
+        // remount somewhere else. Named after the record's start, which
+        // the real group below reuses when it has one.
+        runKey: "run:" + sp + "#" + (typeof rec.started === "number" ? rec.started : "n"),
+        name: fname,
+        path: sp,
+        mime: void 0,
+        size: void 0,
+        isReindex: false,
+        members: [],
+        passCount: 0,
+        status: st,
+        cancellableIds: [],
+        cancelling: false,
+        stopped: st === "cancelled",
+        mayHaveOlder: hasMoreHistory,
+        anchorIndex: -1,
+        anchorId: "",
+        visibleMembers: [],
+        driver: !isPagedReadFile(fname, void 0) ? "single" : isImageVisionFile(fname, void 0) ? "worker" : windowedIndexing ? "worker" : "client",
+        finished: fin,
+        resolving: res,
+        resolvingReason: reason,
+        stub: true,
+        stubError: rec.error || (st === "error" && !rec.error ? "Indexing did not finish." : void 0)
+      };
+      stubList.push({ started: typeof rec.started === "number" ? rec.started : Infinity, group: sg });
+    }
+  }
+  var suppressAnchor = {};
+  if (runStubs) {
+    for (var ti2 = 0; ti2 < order.length; ti2++) {
+      var tg = groups[order[ti2]];
+      if (!newestRunOfKey[order[ti2]]) continue;
+      var trec = tg.path && runStubs[tg.path] || runStubs[tg.key];
+      if (!trec || typeof trec.started !== "number") continue;
+      if (stubPlatform && trec.platform && trec.platform !== stubPlatform) continue;
+      suppressAnchor[order[ti2]] = true;
+      tg.runKey = "run:" + (tg.path || tg.key) + "#" + trec.started;
+      stubList.push({ started: trec.started, group: tg });
+    }
+  }
+  stubList.sort(function(a, b) {
+    return a.started - b.started;
+  });
   var out = [];
+  var si = 0;
   for (var j = 0; j < list.length; j++) {
+    var mts = list[j] && typeof list[j]._ts === "number" ? list[j]._ts : void 0;
+    if (mts !== void 0) {
+      while (si < stubList.length && stubList[si].started <= mts) {
+        out.push({ kind: "indexing", group: stubList[si].group, index: -1 - si });
+        si++;
+      }
+    }
     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 });
+    if (groups[r].anchorIndex === j && !suppressAnchor[r]) {
+      out.push({ kind: "indexing", group: groups[r], index: j });
+    }
+  }
+  while (si < stubList.length) {
+    out.push({ kind: "indexing", group: stubList[si].group, index: -1 - si });
+    si++;
   }
   return out;
 }
@@ -5159,6 +6082,7 @@ exports.CONTEXT_WINDOW_BY_MODEL = CONTEXT_WINDOW_BY_MODEL;
 exports.CONTEXT_WINDOW_DEFAULT = CONTEXT_WINDOW_DEFAULT;
 exports.ChatSession = ChatSession;
 exports.DEFAULT_CLAUDE_MODEL = DEFAULT_CLAUDE_MODEL;
+exports.DEFAULT_CONTEXT_WINDOW = DEFAULT_CONTEXT_WINDOW;
 exports.DEFAULT_OPENAI_MODEL = DEFAULT_OPENAI_MODEL;
 exports.EMPTY_INDEXING_REPLY = EMPTY_INDEXING_REPLY;
 exports.EXPIRED_ATTACHMENT_URL_HOST = EXPIRED_ATTACHMENT_URL_HOST;
@@ -5175,22 +6099,28 @@ exports.INDEXING_COMPLETE_MARKER = INDEXING_COMPLETE_MARKER;
 exports.INLINE_LINK_GLYPH = INLINE_LINK_GLYPH;
 exports.INLINE_LINK_UNAVAILABLE_GLYPH = INLINE_LINK_UNAVAILABLE_GLYPH;
 exports.INLINE_LINK_UNAVAILABLE_SUFFIX = INLINE_LINK_UNAVAILABLE_SUFFIX;
+exports.INPUT_CAP_RATIO = INPUT_CAP_RATIO;
 exports.LINK_LABEL_MAX_DISPLAY_CHARS = LINK_LABEL_MAX_DISPLAY_CHARS;
 exports.LINK_REFRESH_WINDOW_MS = LINK_REFRESH_WINDOW_MS;
 exports.MAX_CONCURRENT_BG_POLLS = MAX_CONCURRENT_BG_POLLS;
 exports.MAX_HISTORY_FILL_PAGES = MAX_HISTORY_FILL_PAGES;
 exports.MAX_HISTORY_MESSAGES = MAX_HISTORY_MESSAGES;
+exports.MAX_OUTPUT_BY_MODEL = MAX_OUTPUT_BY_MODEL;
+exports.MAX_OUTPUT_TOKENS = MAX_OUTPUT_TOKENS;
 exports.MAX_PARSED_CONTENT_CHARS = MAX_PARSED_CONTENT_CHARS;
 exports.MCP_NAME = MCP_NAME;
 exports.MIN_INPUT_TOKEN_BUDGET = MIN_INPUT_TOKEN_BUDGET;
+exports.MIN_PER_REQUEST_INPUT_CAP = MIN_PER_REQUEST_INPUT_CAP;
 exports.OUTPUT_TOKEN_RESERVE = OUTPUT_TOKEN_RESERVE;
 exports.POLL_INTERVAL = POLL_INTERVAL;
 exports.PREVIEWABLE_IMAGE_CONTENT_TYPES = PREVIEWABLE_IMAGE_CONTENT_TYPES;
 exports.PREVIEW_BROWSER_CACHE_SECONDS = PREVIEW_BROWSER_CACHE_SECONDS;
 exports.RENDER_FROM_TOKEN = RENDER_FROM_TOKEN;
 exports.RTF_EXTS = RTF_EXTS;
+exports.RUN_RECORD_WORKING_STALE_MS = RUN_RECORD_WORKING_STALE_MS;
 exports.TOOL_AND_RESPONSE_BUFFER = TOOL_AND_RESPONSE_BUFFER;
 exports.XML_EXTS = XML_EXTS;
+exports.__resetSplitHistoryState = __resetSplitHistoryState;
 exports.applyEncodingDeclaration = applyEncodingDeclaration;
 exports.bgIndexingQueueName = bgIndexingQueueName;
 exports.buildAiAgentValue = buildAiAgentValue;
@@ -5198,6 +6128,7 @@ exports.buildBoundedChatMessages = buildBoundedChatMessages;
 exports.buildChatDisplayList = buildChatDisplayList;
 exports.buildChatSystemPrompt = buildChatSystemPrompt;
 exports.buildDisplayExpiredAttachmentHref = buildDisplayExpiredAttachmentHref;
+exports.buildHistoryItemFullId = buildHistoryItemFullId;
 exports.buildIndexingContinueMessage = buildIndexingContinueMessage;
 exports.buildIndexingRenderContinueTemplate = buildIndexingRenderContinueTemplate;
 exports.buildIndexingRenderMessage = buildIndexingRenderMessage;
@@ -5229,6 +6160,7 @@ exports.extractClaudeText = extractClaudeText;
 exports.extractLastUserTextFromRequest = extractLastUserTextFromRequest;
 exports.extractOpenAIText = extractOpenAIText;
 exports.extractRemotePathFromAttachmentHref = extractRemotePathFromAttachmentHref;
+exports.fetchLiveIndexingKeys = fetchLiveIndexingKeys;
 exports.fillHistoryViewport = fillHistoryViewport;
 exports.filterListByClearHorizon = filterListByClearHorizon;
 exports.findAttachmentParser = findAttachmentParser;
@@ -5238,11 +6170,16 @@ exports.getChatHistory = getChatHistory;
 exports.getContextWindow = getContextWindow;
 exports.getErrorMessage = getErrorMessage;
 exports.getExpiredAttachmentVisiblePath = getExpiredAttachmentVisiblePath;
+exports.getInputTokenBudget = getInputTokenBudget;
+exports.getMaxOutputTokens = getMaxOutputTokens;
+exports.getModelContextWindow = getModelContextWindow;
 exports.getProjectContextWindow = getProjectContextWindow;
+exports.getSplitChatHistory = getSplitChatHistory;
 exports.getVisionProfile = getVisionProfile;
 exports.groupAttachmentFailures = groupAttachmentFailures;
 exports.hasBom = hasBom;
 exports.hydrateImagePreviews = hydrateImagePreviews;
+exports.indexDoneUniqueId = indexDoneUniqueId;
 exports.isAuthExpiredError = isAuthExpiredError;
 exports.isBgIndexingQueue = isBgIndexingQueue;
 exports.isErrorResponseBody = isErrorResponseBody;
@@ -5252,6 +6189,7 @@ exports.isLinkUnavailable = isLinkUnavailable;
 exports.isNonRetryableRequestError = isNonRetryableRequestError;
 exports.isOfficeFile = isOfficeFile;
 exports.isPreviewableImagePath = isPreviewableImagePath;
+exports.isProviderApiKeyError = isProviderApiKeyError;
 exports.isServerExtractable = isServerExtractable;
 exports.isServiceDbAttachmentHref = isServiceDbAttachmentHref;
 exports.linkUnavailableKeyForHref = linkUnavailableKeyForHref;
@@ -5283,6 +6221,7 @@ exports.renderInlineLinkHtml = renderInlineLinkHtml;
 exports.repairUrlEntities = repairUrlEntities;
 exports.repairUrlWhitespace = repairUrlWhitespace;
 exports.resolveImagePreviewUrl = resolveImagePreviewUrl;
+exports.runIndexUniqueId = runIndexUniqueId;
 exports.safeDecodeURIComponent = safeDecodeURIComponent;
 exports.sanitizeAttachmentLinksForHistory = sanitizeAttachmentLinksForHistory;
 exports.setProjectContextWindow = setProjectContextWindow;
@@ -5290,6 +6229,7 @@ exports.stripFileBlocksFromHistory = stripFileBlocksFromHistory;
 exports.transformContentWithImages = transformContentWithImages;
 exports.transformContentWithOpenAIImages = transformContentWithOpenAIImages;
 exports.truncateLabelForDisplay = truncateLabelForDisplay;
+exports.upsertIndexRunRecordSafe = upsertIndexRunRecordSafe;
 exports.wallClockNow = wallClockNow;
 //# sourceMappingURL=engine.cjs.map
 //# sourceMappingURL=engine.cjs.map