bunnyquery 1.8.5 → 1.8.8

package/src/engine/session.ts

@@ -32,17 +32,21 @@ import {
 	MAX_CONCURRENT_BG_POLLS,
 	bgIndexingQueueName,
 	isBgIndexingQueue,
+	buildHistoryItemFullId,
 	ANTHROPIC_MESSAGES_API_URL,
 	OPENAI_RESPONSES_API_URL,
+	upsertIndexRunRecordSafe,
+	type IndexRunStatus,
+	type IndexRunPatch,
 	type BgTaskEntry,
 } from './requests';
 import { isPagedReadFile, isImageVisionFile, isWindowedReadFile } from './office';
-import { windowedIndexingEnabled } from './config';
+import { windowedIndexingEnabled, chatEngineConfig } from './config';
 import { isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError, getErrorMessage } from './errors';
 import { buildBoundedChatMessages } from './budget';
-import { createInlineLinkRegex } from './links';
+import { createInlineLinkRegex, sanitizeAttachmentLinksForHistory } from './links';
 import { markImagePreviewStale } from './image_preview';
-import { mapHistoryListToMessages, extractLastUserTextFromRequest, isIndexingRequestText, parseIndexingRequestText } from './history';
+import { mapHistoryListToMessages, extractLastUserTextFromRequest, isIndexingRequestText, parseIndexingRequestText, probeBgQueue, BG_PROBE_TTL_MS, getSplitChatHistory } from './history';
 import { wallClockNow } from './time';
 import { parseAttachmentContent } from './attachment_parsers';
 import type { ChatHost, ChatState, ChatMessage, ChatIdentity, PinnedDispatchContext } from './host';
@@ -92,6 +96,11 @@ const INDEXING_DRAIN_IDLE_LOOKS = 2;
 // about. Costs nothing in the normal case, where the queue reports work
 // immediately and the wait is far longer than this anyway.
 const INDEXING_DRAIN_MIN_MS = 8000;
+
+// Ownership sequence for state.bgHistoryLoading (see the deferred-batch handler
+// in loadHistory): the latest minted batch owns the flag; older handlers
+// settling late must neither clear nor keep it.
+let _bgHistoryBatchSeq = 0;
 // Ceiling on that wait. Past it the turn is sent regardless: an answer computed
 // against a partly-indexed file is a poor outcome, but a question that is never
 // asked at all because one chain wedged server-side is a worse one.
@@ -216,6 +225,9 @@ export class ChatSession {
 			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,
@@ -384,11 +396,13 @@ export class ChatSession {
 			return Promise.resolve();
 		}
 		var queue = bgIndexingQueueName(id.userId, id.projectId);
+		// Snapshot reader: a young shared answer (this session's own adopt
+		// ladder, or the db-files page's probe) is as good as a fresh one.
 		var ask = function (status: 'pending' | 'running') {
-			return Promise.resolve(getChatHistory(
-				{ service: id.projectId, owner: id.owner, platform: platform as 'claude' | 'openai', queue: queue, status: status },
-				{ limit: WORKER_PASS_ADOPT_LIMIT },
-			)).catch(function () { return null; });
+			return Promise.resolve(probeBgQueue(
+				{ service: id.projectId, owner: id.owner, platform: platform as 'claude' | 'openai', queue: queue, status: status, limit: WORKER_PASS_ADOPT_LIMIT },
+				{ maxAgeMs: BG_PROBE_TTL_MS },
+			)).then(function (entry) { return entry.result; }).catch(function () { return null; });
 		};
 		return Promise.all([ask('pending'), ask('running')]).then(function (results) {
 			if (results[0] === null || results[1] === null) return;
@@ -500,7 +514,13 @@ export class ChatSession {
 	 * instead of merely unconfirmed.
 	 */
 	refreshLiveIndexState(): void {
-		this._adoptWorkerIndexingPasses(0);
+		// PASSIVE: this is the first-page/resume refresh, not a settle. One
+		// fresh look (two status queries) always happens; the 2s/6s ladder
+		// climb is reserved for when there is EVIDENCE of live work — the
+		// pass-boundary gap the ladder exists for presumes a chain was alive,
+		// and on an idle tab return the climb was three round trips of asking
+		// a question whose answer had not changed.
+		this._adoptWorkerIndexingPasses(0, true);
 	}
 
 	/** Forget what we know about which files are indexing — but ONLY when the
@@ -688,6 +708,79 @@ export class ChatSession {
 		return id.projectId + '#' + id.platform;
 	}
 
+	// ─── 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.
+	private _hydratedBodies: { [chatKey: string]: { [itemId: string]: string } } = {};
+	private _hydratingItems: { [key: string]: boolean } = {};
+
+	/** 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: ChatMessage[]): void {
+		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: any = 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: string[]): Promise<void> {
+		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] !== undefined;
+			var inflightKey = chatKey + '|' + itemId;
+			if (already || self._hydratingItems[inflightKey]) return Promise.resolve();
+			self._hydratingItems[inflightKey] = true;
+			return Promise.resolve(lookup(buildHistoryItemFullId(platform as 'claude' | 'openai', id.projectId, itemId), id.projectId, id.owner)).then(function (body: any) {
+				// Chat may have switched while the lookup flew; the memo is
+				// per-chat so record under the key we started with, and only
+				// touch the live list if it is still that chat's.
+				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: any = 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 () { /* stub stays; expand retries */ }).then(function () {
+				delete self._hydratingItems[inflightKey];
+			});
+		});
+		return Promise.all(jobs).then(function () {
+			if (self.getHistoryCacheKey() !== chatKey) return;
+			self.host.notify();
+			self.updateHistoryCache();
+		});
+	}
+
 	updateHistoryCache(): void {
 		var key = this.getHistoryCacheKey();
 		if (!key) return;
@@ -1069,10 +1162,13 @@ export class ChatSession {
 					res(v);
 				};
 				bail = setTimeout(function () { settle(null); }, INDEXING_DRAIN_LOOK_TIMEOUT_MS);
-				Promise.resolve(getChatHistory(
-					{ service: svcId, owner: owner, platform: platform as 'claude' | 'openai', queue: queue, status: status },
-					{ limit: WORKER_PASS_ADOPT_LIMIT },
-				)).then(function (r: any) { settle(r); }, function () { settle(null); });
+				// maxAgeMs 0: this loop is WAITING for the queue to change, so a
+				// cached answer is useless to it — but its fresh answers write
+				// through into the shared probe memo for the snapshot readers.
+				Promise.resolve(probeBgQueue(
+					{ service: svcId, owner: owner, platform: platform as 'claude' | 'openai', queue: queue, status: status, limit: WORKER_PASS_ADOPT_LIMIT },
+					{ maxAgeMs: 0 },
+				)).then(function (entry: any) { settle(entry.result); }, function () { settle(null); });
 			});
 		};
 		// Ordinary chats are routed onto this queue too (_isOnBgQueue), and those
@@ -1837,6 +1933,32 @@ export class ChatSession {
 				if (e && e.id && self._indexKeyOf(e) === scoped) stoppedIds[e.id] = true;
 			});
 			this.state.stoppedIndexIds = stoppedIds;
+			// Close the durable run:: record too — inside this !finished guard on
+			// purpose, for the same reason as stoppedIndexIds: a stop that landed
+			// after the run was over must not relabel an indexed file as cancelled.
+			// Path over key: `key` degrades to a bare filename for path-less compact
+			// stubs, and run:: is keyed by storage path only — no derivable path
+			// means no record to close (restored stubs of old runs), which is fine.
+			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() });
+				}
+			}
 		}
 		// Ask the QUEUE what else is live for this file, and cancel that too.
 		//
@@ -2449,7 +2571,7 @@ export class ChatSession {
 	 * shape that previously looped fetchHistoryPage after an already-DONE index.
 	 */
 	private _adoptingWorkerPasses = false;
-	private _adoptWorkerIndexingPasses(attempt: number): void {
+	private _adoptWorkerIndexingPasses(attempt: number, passive?: boolean): void {
 		var self = this;
 		// One in flight at a time. The query is queue-WIDE, so a second file's pass
 		// settling in the same moment is covered by the query already running.
@@ -2460,11 +2582,15 @@ export class ChatSession {
 		if (this.isPollingPaused() || !this.host.isViewMounted()) return;
 		var svcId = id.projectId, owner = id.owner;
 		var queue = bgIndexingQueueName(id.userId, id.projectId);
+		// maxAgeMs 0: adoption exists to notice passes the worker JUST minted,
+		// so it must always look fresh — but its answers write through into the
+		// shared probe memo, which is what keeps the snapshot readers (and the
+		// db-files page's badge probe) from re-asking seconds later.
 		var ask = function (status: 'pending' | 'running') {
-			return Promise.resolve(getChatHistory(
-				{ service: svcId, owner: owner, platform: platform as 'claude' | 'openai', queue: queue, status: status },
-				{ limit: WORKER_PASS_ADOPT_LIMIT },
-			)).catch(function () { return null; });
+			return Promise.resolve(probeBgQueue(
+				{ service: svcId, owner: owner, platform: platform as 'claude' | 'openai', queue: queue, status: status, limit: WORKER_PASS_ADOPT_LIMIT },
+				{ maxAgeMs: 0 },
+			)).then(function (entry) { return entry.result; }).catch(function () { return null; });
 		};
 		this._adoptingWorkerPasses = true;
 		Promise.all([ask('running'), ask('pending')]).then(function (results: any[]) {
@@ -2505,6 +2631,15 @@ export class ChatSession {
 			// empty queue for a chain that is very much alive — and with no pass
 			// left to settle, nothing would ever ask again. Look once or twice more
 			// before believing the file is finished.
+			//
+			// PASSIVE calls (first-page/resume refresh) climb only on EVIDENCE of
+			// live work — a queued local entry for this project, a live key the
+			// look above just recorded, or an attached poll. The gap rationale
+			// presumes a chain was alive; with nothing suggesting one, the climb
+			// re-asked an unchanged question three more times on every tab return.
+			// (No nudge here either: a send waiting on indexing implies local
+			// entries, which IS evidence, so the passive stop never starves it.)
+			if (passive && !self._hasLiveIndexEvidence(svcId)) return;
 			if (attempt + 1 >= WORKER_PASS_ADOPT_ATTEMPTS.length) {
 				// The ladder is the only thing that can tell a worker-driven chain has
 				// really ended, and it just did. This is the earliest honest moment to
@@ -2516,11 +2651,29 @@ export class ChatSession {
 				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. */
+	private _hasLiveIndexEvidence(svcId: string): boolean {
+		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; }
+		// BG polls only: a pending ORDINARY chat turn also holds a poll, and
+		// counting it made every tab return during a conversation climb the
+		// full passive ladder for indexing that does not exist.
+		var found = false;
+		this.historyItemPolls.forEach(function (h: any) { if (h && h.kind === 'bg') found = true; });
+		return found;
+	}
+
 	/** Any of these ids still queued or still polled, i.e. surviving work. */
 	private _isTrackingAny(ids: string[]): boolean {
 		for (var i = 0; i < ids.length; i++) {
@@ -2631,7 +2784,16 @@ export class ChatSession {
 		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]) {
+				// Settled while nobody was polling (hidden tab, dead poll): the
+				// answer reached the chat as HISTORY, so no settle handler ever
+				// ran for this entry — maybeResumeIndexing's flips included. For
+				// a single-pass file that settle IS the whole run; close its
+				// records off the settled bubbles' own flags before the entry
+				// goes. (8 of 10 files in a real batch hit exactly this.)
+				this._flipRunFromSettledEntry(e);
+				this.bgTaskQueue.splice(i, 1);
+			}
 		}
 		// Poll budget for this drain (see MAX_CONCURRENT_BG_POLLS). bgTaskQueue is
 		// in push order, i.e. oldest first, which is also the order the server
@@ -2755,6 +2917,13 @@ export class ChatSession {
 					// looks into the window where the new pass is not yet in the status
 					// index, which is the same way a nudge on work STARTING went wrong.
 					if (!self._isWorkerDrivenIndexing(capturedEntry.filename, capturedEntry.mime)) {
+						// Also close the run record: for a CLIENT-driven file a failed
+						// pass ends the chain on every path, and a removed row reads as
+						// a cancel. Worker-driven files are excluded for the same reason
+						// as the nudge — this catch fires on dropped polls too, and the
+						// worker may be writing the next pass regardless.
+						if (isNotExists) self._flipRunRecord(capturedEntry, 'cancelled');
+						else self._flipRunRecord(capturedEntry, 'error', self._runErrorText(err));
 						self._nudgeIndexingDrain();
 					}
 				}).then(function () {
@@ -2795,6 +2964,76 @@ export class ChatSession {
 	// 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: BgTaskEntry): void {
+		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) { /* best-effort */ }
+	}
+
+	/** Short, storable form of an error body for the run:: record. */
+	_runErrorText(response: any): string {
+		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: BgTaskEntry): void {
+		try {
+			if (!entry || !entry.storagePath || !entry.id || !entry.projectId) return;
+			if (isPagedReadFile(entry.filename, entry.mime)) return;
+			// A stopped run's verdict belongs to the stop funnel — never let a
+			// late clean settle of its pass relabel 'cancelled' as 'done'.
+			if (this.cancelledIndexKeys.has(this._indexKeyOf(entry))) return;
+			if (this.state.stoppedIndexIds[entry.id]) return;
+			var userMsg: any = null, replyMsg: any = null;
+			this.state.messages.forEach(function (m: any) {
+				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');
+			}
+			// No reply bubble at all: nothing to judge from — leave the record.
+		} catch (_e) { /* best-effort */ }
+	}
+
+	/** 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: BgTaskEntry, status: IndexRunStatus, error?: string): void {
+		if (!entry || !entry.storagePath || !entry.projectId) return;
+		var patch: IndexRunPatch = { status: status, finished: Date.now() };
+		if (error) patch.error = error;
+		upsertIndexRunRecordSafe(entry.projectId, entry.storagePath, patch);
+	}
+
 	maybeResumeIndexing(entry: BgTaskEntry, response: any, platform: string): void {
 		var self = this;
 		// This client is the ONLY driver of the chains that reach the returns below,
@@ -2811,7 +3050,31 @@ export class ChatSession {
 			// pass here is exactly what "stop" has to prevent — the cancelled pass
 			// settles, and without this the chain simply carries on.
 			if (this.cancelledIndexKeys.has(this._indexKeyOf(entry))) return;
-			if (!isPagedReadFile(entry.filename, entry.mime)) { endOfClientChain(); return; }
+			if (!isPagedReadFile(entry.filename, entry.mime)) {
+				// Single-pass file: one settled pass IS the whole job. This is
+				// deterministic knowledge (this client is the only dispatcher),
+				// so record the durable done:: marker — single-pass runs never
+				// get one from the worker. Errors don't count as completion
+				// (this branch sits above the error check on purpose: the chain
+				// is over either way, but only success gets a marker), and
+				// neither does a CANCELLED poll shape — a row stopped from
+				// another tab/device settles through here as {status:
+				// 'cancelled', queue fields} with no provider payload, and
+				// cancelledIndexKeys only records stops issued from THIS tab.
+				if (!isErrorResponseBody(response) && !this._isCancelledPollResult(response)) {
+					this._mintDoneMarker(entry);
+					this._flipRunRecord(entry, 'done');
+				} else if (this._isCancelledPollResult(response)) {
+					// Stopped elsewhere (another tab/device): the stopping side
+					// usually wrote 'cancelled' already; writing it again is a
+					// same-value terminal update, and it closes the record when
+					// the stopping tab died before its write landed.
+					this._flipRunRecord(entry, 'cancelled');
+				} else {
+					this._flipRunRecord(entry, 'error', this._runErrorText(response));
+				}
+				endOfClientChain(); return;
+			}
 			if (isImageVisionFile(entry.filename, entry.mime)) return; // worker owns this loop (PDF vision)
 			// When windowed indexing is on, the WORKER drives the text/grid loop too. The
 			// client MUST NOT also resume, or two drivers each enqueue a continuation per
@@ -2819,13 +3082,41 @@ export class ChatSession {
 			// PDFs early-return above. Gated on the flag so the old client-driven path is
 			// untouched when windowing is off.
 			if (windowedIndexingEnabled() && isWindowedReadFile(entry.filename, entry.mime)) return;
-			if (isErrorResponseBody(response)) { endOfClientChain(); return; } // a failed pass is not "incomplete"
+			if (isErrorResponseBody(response)) {
+				// A failed pass is not "incomplete" — the client-driven chain is over.
+				this._flipRunRecord(entry, 'error', this._runErrorText(response));
+				endOfClientChain(); return;
+			}
 			var answer = (platform === 'openai' ? extractOpenAIText(response) : extractClaudeText(response)) || '';
-			if (answer.indexOf(INDEXING_COMPLETE_MARKER) !== -1) { endOfClientChain(); return; } // fully indexed
+			if (answer.indexOf(INDEXING_COMPLETE_MARKER) !== -1) {
+				// Client-driven chain, and the model's reply carried the
+				// completion token — the same signal the worker requires before
+				// minting for its own chains. Deterministic here: this client
+				// is the only dispatcher and it is deciding, right now, that no
+				// further pass will run.
+				this._mintDoneMarker(entry);
+				this._flipRunRecord(entry, 'done');
+				endOfClientChain(); return; // fully indexed
+			}
 			var pass = (entry.resumePass || 0) + 1;
-			if (pass > MAX_INDEXING_RESUME_PASSES) { endOfClientChain(); return; } // give up after the cap
+			if (pass > MAX_INDEXING_RESUME_PASSES) {
+				// Gave up after the cap: the file is only partially indexed, and no
+				// further pass will ever run. 'error' rather than 'done' — the badge
+				// must not claim a file the chain abandoned.
+				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 client is the only driver of this chain and it just declined
+				// to dispatch the next pass — the chain is over, as an ending, not a
+				// pause: the queue entry is spliced on settle and nothing revisits
+				// it. Close the record (it writes with entry.projectId, so it lands
+				// after a project switch) or it lies 'working' for the stale window.
+				this._flipRunRecord(entry, 'error', 'Indexing stopped: the session or project changed before the file finished.');
+				endOfClientChain();
+				return;
+			}
 			// Counted as live work from here, not from the ack: awaitIndexingDrained
 			// asks the SERVER what is queued, and this pass is not queued until the
 			// call below returns. Without it a chat can slip in between two passes.
@@ -2905,8 +3196,15 @@ export class ChatSession {
 		var projectId = id.projectId, owner = id.owner;
 		var options: any = { fetchMore: fetchMore };
 		if (fetchMore && this.state.historyStartKeyHistory.length) options.startKeyHistory = this.state.historyStartKeyHistory.slice();
+		// First page: paint the CONVERSATION immediately and let the indexing
+		// stubs arrive as a deferred batch (merged below when it lands).
+		if (!fetchMore) options.deferBg = true;
 
-		var fetchHistory = function () { return getChatHistory({ service: projectId, owner: owner, platform: platform }, options); };
+		// Split fetch v2: surface (full bodies, bg queue excluded) + bg compact
+		// stubs, tiled to the surface page's time window with module-level
+		// state (buffering + retry safety) — see getSplitChatHistory. Returns
+		// the exact single-fetch shape; startKeyHistory is bookkeeping only.
+		var fetchHistory = function () { return getSplitChatHistory({ service: projectId, owner: owner, platform: platform, userId: id.userId }, options); };
 
 		return Promise.resolve().then(fetchHistory).catch(function (err: any) {
 			if (isAuthExpiredError(err) && !isNonRetryableRequestError(err)) return self.host.refreshSession().then(fetchHistory);
@@ -2916,7 +3214,11 @@ export class ChatSession {
 			var chatList = history && Array.isArray(history.list) ? history.list : [];
 			chatList.forEach(function (item: any) {
 				if (isBgIndexingQueue(item.queue_name)) {
-					if (isIndexingRequestText(extractLastUserTextFromRequest(item.request_body))) item._isBgTask = true;
+					// Compact stubs carry the label as request_text — the body
+					// never left the server — so classify from whichever form
+					// this item arrived in.
+					var clsText = item.compact ? item.request_text : extractLastUserTextFromRequest(item.request_body);
+					if (isIndexingRequestText(clsText)) item._isBgTask = true;
 					else item._isOnBgQueue = true;
 				}
 			});
@@ -2929,17 +3231,77 @@ export class ChatSession {
 				projectId: id.projectId,
 				formatIndexingLabel: self.host.formatIndexingLabel,
 			}).messages;
+			// Re-apply any previously-hydrated compact bodies: a refresh maps
+			// fresh stubs, and without this a bubble the user already expanded
+			// would silently revert to its 200-char head.
+			self.applyHydratedBodies(mapped);
 
 			// Set when a first-page refresh re-prepended already-loaded older pages,
 			// so the cursor reset below knows not to rewind to page 1's boundary.
 			var keptOlderPages = false;
+			// The empty-page-1 keep below was taken ONLY on the strength of a
+			// deferred batch still flying — if that batch then proves the chat
+			// empty server-side, the kept screen must be let go (see the batch
+			// handler), or an emptied transcript is indelible.
+			var keptScreenAwaitingBg = false;
 
 			if (fetchMore) {
-				self.state.messages = mapped.concat(self.state.messages);
+				// STRIP-THEN-MERGE keyed on SERVER ITEM ID. Incoming bubbles are
+				// the fresher server state (queued→running→settled transitions),
+				// so existing copies of incoming id|role bubbles are REMOVED first
+				// (in-flight cancel flags carried over), then the page merges by
+				// item id — ids are creation-ordered and BOTH lists are already
+				// id-sorted, unlike _ts (assistant _ts is `updated`, which any
+				// long-running turn makes non-monotonic and would misorder the
+				// walk). Id-less bubbles on screen (staged/local, always the tail)
+				// end the merge region; id-less incoming sorts first (oldest).
+				var incomingKeys: any = {};
+				mapped.forEach(function (m: any) { if (m._serverItemId) incomingKeys[m._serverItemId + '|' + m.role] = m; });
+				var existing = self.state.messages.filter(function (m: any) {
+					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: ChatMessage[] = [];
+				var pi = 0, ei = 0;
+				while (pi < mapped.length && ei < existing.length) {
+					var pm: any = mapped[pi], em: any = existing[ei];
+					var eid = em._serverItemId;
+					if (typeof eid !== 'string') break; // staged/local tail
+					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 as any).bgPending)
+				&& self.state.messages.some(function (m: any) { return m._ownerKey === undefined || m._ownerKey === loadKey; })) {
+				// Empty first page that cannot judge the chat empty: either
+				// empty-but-not-end (a pure-bg band past every hop cap), or an
+				// empty DEFERRED page whose bg batch is still flying — a chat
+				// whose whole conversation rides the bg queue has a genuinely
+				// empty surface (endOfList true on a head refresh), and the
+				// batch carries everything. REPLACING with it would blank the
+				// chat for the batch's flight time — the greeting flashed over
+				// real messages on every tab return. Keep what is on screen.
+				// Kept ONLY on the batch's word: the batch handler revisits.
+				if (history.endOfList !== false) keptScreenAwaitingBg = true;
 			} else {
 				if (self.state.typing) self.state.typingAbort = true;
 				var serverIds: any = {};
 				mapped.forEach(function (m: any) { if (m._serverItemId) serverIds[m._serverItemId] = 1; });
+				// The retention boundary must be the SURFACE frontier: page 1 also
+				// emits bg stubs reaching arbitrarily deep, and keying retention on
+				// a weeks-old stub id would wipe (or gap) the scrolled-in pages.
+				var surfaceOldestId: string | undefined = undefined;
+				mapped.forEach(function (m: any) {
+					if (typeof m._serverItemId !== 'string' || m._fromBgChain) return;
+					if (surfaceOldestId === undefined || m._serverItemId < surfaceOldestId) surfaceOldestId = m._serverItemId;
+				});
 				var locallyCancelled: any = {};
 				self.state.messages.forEach(function (m) { if (m.isCancelled && m._serverItemId) locallyCancelled[m._serverItemId] = m; });
 				// A cancel the server has not acknowledged yet. Without carrying these
@@ -3009,7 +3371,13 @@ export class ChatSession {
 				var sharesPage1 = self.state.messages.some(function (m) {
 					return typeof m._serverItemId === 'string' && !!serverIds[m._serverItemId as string];
 				});
-				var retainedOlder: ChatMessage[] = (!sharesPage1 || oldestInPage1 === undefined) ? [] : self.state.messages.filter(function (m) {
+				var deferredBg = !!(history && (history as any).bgPending);
+				// Boundary for retention: the SURFACE frontier when page 1 has any
+				// surface item (bg stubs can reach weeks deeper and would otherwise
+				// wipe or gap the scrolled-in pages); whole-page oldest only as the
+				// fallback for a surface-empty page.
+				var retainBoundary: string | undefined = surfaceOldestId !== undefined ? surfaceOldestId : oldestInPage1;
+				var retainedOlder: ChatMessage[] = (!sharesPage1 || retainBoundary === undefined) ? [] : self.state.messages.filter(function (m) {
 					// Settled server history only; in-flight bubbles are the rescue
 					// loop's job below and would otherwise be kept twice.
 					if (typeof m._serverItemId !== 'string') return false;
@@ -3017,10 +3385,49 @@ export class ChatSession {
 					// project's bubbles onto this chat (the cross-project leak fix).
 					// Compare against the snapshotted loadKey, never a live read.
 					if (m._ownerKey !== undefined && m._ownerKey !== loadKey) return false;
-					return (m._serverItemId as string) < (oldestInPage1 as string);
+					// While a deferred stub batch is in flight, KEEP already-loaded
+					// indexing bubbles wherever they sit — the surface-only page has
+					// none, and dropping them here would flicker every row until the
+					// batch lands (its apply strips+re-merges them by id anyway).
+					if (deferredBg && m.isBackgroundTask) return true;
+					// Bg-chain bubbles already on screen stay put regardless of the
+					// boundary — their ids interleave with deep history and the strip
+					// in later merges replaces them when fresher copies arrive.
+					if (m._fromBgChain) return true;
+					return (m._serverItemId as string) < (retainBoundary as string);
+				});
+				// Prepend only the STRICTLY-older bubbles. Retained bg bubbles whose
+				// ids sit inside page 1's own range are ID-MERGED into it instead —
+				// blanket prepending hoisted every indexing row above the whole
+				// conversation, and after a head refresh the single-page batch
+				// never re-placed the deep ones, so they sat hoisted for good.
+				var prependOlder: ChatMessage[] = [];
+				var interleave: ChatMessage[] = [];
+				retainedOlder.forEach(function (m) {
+					var sid = m._serverItemId as string;
+					if (serverIds[sid]) return; // page 1 carries a fresher copy
+					if (retainBoundary !== undefined && sid < (retainBoundary as string)) prependOlder.push(m);
+					else interleave.push(m);
 				});
-				keptOlderPages = retainedOlder.length > 0;
-				self.state.messages = keptOlderPages ? retainedOlder.concat(mapped) : mapped;
+				var page1: ChatMessage[] = mapped;
+				if (interleave.length) {
+					// Both sides are id-sorted oldest-first (retention preserves the
+					// on-screen order; the mapper emits oldest-first).
+					var mergedP: ChatMessage[] = [];
+					var ii2 = 0, mi2 = 0;
+					while (ii2 < interleave.length && mi2 < mapped.length) {
+						var iv: any = interleave[ii2], mv: any = mapped[mi2];
+						var mid2 = typeof mv._serverItemId === 'string' ? mv._serverItemId : undefined;
+						if (mid2 === undefined) break; // defensive: id-less tail
+						if ((iv._serverItemId as string) <= 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); });
 				if (Object.keys(locallyCancelled).length) {
 					for (var ci = 0; ci < self.state.messages.length; ci++) {
@@ -3060,9 +3467,16 @@ export class ChatSession {
 				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) {
+					// SURFACE items only: page 1 also carries bg stubs reaching far
+					// past the horizon, and reading their age as "the frontier is
+					// pre-horizon" falsely ended the pager with post-horizon surface
+					// pages still unfetched.
+					var surfaceItems = chatList.filter(function (it: any) { 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;
+					}
 				}
 			}
 			// Clear loading flags BEFORE this render so the final paint is
@@ -3071,6 +3485,96 @@ export class ChatSession {
 			self.updateHistoryCache();
 			self.host.notify();
 
+			// ── deferred indexing-stub batch (first-paint split) ──────────────
+			// The conversation is already on screen; when the stub batch lands it
+			// is classified/mapped like any page and STRIP-THEN-MERGED: existing
+			// copies of incoming ids are removed first (retained rows may sit at
+			// provisional positions), then the batch merges by timestamp.
+			var bgPending = !fetchMore && history && (history as any).bgPending;
+			if (bgPending) {
+				// Ownership id for the shared loading flag: a same-token refetch can
+				// mint a SECOND bgPending, and the older handler settling later must
+				// not clear (or keep) the flag the newer batch owns.
+				var batchId = ++_bgHistoryBatchSeq;
+				// SILENT unless this is the chat's genuine FIRST PAINT. Two quiet
+				// cases: an ended chain's head refresh (endOfList already true),
+				// and a MID-WALK tab return — the walk restarts for cursor
+				// safety, but the conversation is already on screen and flashing
+				// "Loading indexing history" over it on every return was the
+				// reported bug. Only a never-walked chat announces the batch.
+				if (history.endOfList !== true && (history as any).firstLoad === true) {
+					self.state.bgHistoryLoading = true;
+					self.host.notify();
+				}
+				var releaseBgFlag = function () {
+					if (_bgHistoryBatchSeq === batchId) self.state.bgHistoryLoading = false;
+				};
+				(bgPending as Promise<any>).then(function (batch: any) {
+					if (token !== self.state.gateRefreshToken) { releaseBgFlag(); return; }
+					var bList: any[] = (batch && Array.isArray(batch.list)) ? batch.list : [];
+					bList.forEach(function (item: any) {
+						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: any, b: any) {
+						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) {
+						// The empty page 1 was kept ONLY on this batch's word — and it
+						// just proved the chat empty server-side (an emptied/cleared
+						// transcript). Let the kept screen go: drop this chat's settled
+						// server bubbles, keep staged and in-flight local work and any
+						// other chat's strays for their own reconcilers, and remember
+						// the end. Without this the stale transcript was indelible and
+						// even re-persisted itself into the history cache.
+						self.state.messages = self.state.messages.filter(function (m: any) {
+							if (typeof m._serverItemId !== 'string') return true;
+							if (m._ownerKey !== undefined && m._ownerKey !== loadKey) return true;
+							return false;
+						});
+						self.state.historyEndOfList = true;
+						releaseBgFlag();
+						self.updateHistoryCache();
+						self.host.notify();
+						return;
+					}
+					var incoming: any = {};
+					m2.forEach(function (m: any) { if (m._serverItemId) incoming[m._serverItemId + '|' + m.role] = true; });
+					var baseList = self.state.messages.filter(function (m: any) { return !(m._serverItemId && incoming[m._serverItemId + '|' + m.role]); });
+					var mergedList: ChatMessage[] = [];
+					var pi2 = 0, ei2 = 0;
+					while (pi2 < m2.length && ei2 < baseList.length) {
+						var pm2: any = m2[pi2], em2: any = baseList[ei2];
+						var eid2 = em2._serverItemId;
+						if (typeof eid2 !== 'string') break; // staged/local tail
+						var pid2 = pm2._serverItemId;
+						if (typeof pid2 !== 'string' || pid2 <= eid2) { mergedList.push(pm2); pi2++; }
+						else { mergedList.push(em2); ei2++; }
+					}
+					while (pi2 < m2.length) mergedList.push(m2[pi2++]);
+					while (ei2 < baseList.length) mergedList.push(baseList[ei2++]);
+					self.state.messages = mergedList;
+					if (batch && batch.endOfList === true) self.state.historyEndOfList = true;
+					releaseBgFlag();
+					self.updateHistoryCache();
+					self.host.notify();
+				}, function () {
+					// Stubs missing until the next refresh re-asks; never fatal.
+					releaseBgFlag();
+					self.host.notify();
+				});
+			}
+
 			if (!fetchMore) {
 				// Ration BACKGROUND polls here exactly as the drain does (see
 				// MAX_CONCURRENT_BG_POLLS); foreground items — a reply the user is
@@ -3211,7 +3715,12 @@ export class ChatSession {
 	uploadSingleAttachment(att: any, stageId?: string): Promise<Array<{ name: string; url: string; storagePath: string }>> {
 		var self = this;
 		var id = this.host.getIdentity();
-		att.status = 'uploading'; att.progress = 0; att.errorMessage = '';
+		// progress stays null until the first byte-progress event. Every upload
+		// opens with a get-signed-url round trip that reports nothing, so a chip
+		// initialised to 0 rendered an empty, motionless bar for the whole
+		// preparing phase and read as hung. null is the signal for "preparing"
+		// (barber pole); a number means bytes are actually moving (real bar).
+		att.status = 'uploading'; att.progress = null; att.errorMessage = '';
 		att.errorCode = ''; att.errorDetail = ''; // clear any prior failure (retry)
 		this.host.renderAttachmentChips();
 		var members = (att.kind === 'folder')