bunnyquery 1.6.2 → 1.8.0

package/src/engine/session.ts

@@ -34,13 +34,16 @@ import {
 	OPENAI_RESPONSES_API_URL,
 	type BgTaskEntry,
 } from './requests';
-import { isPagedReadFile, isImageVisionFile } from './office';
+import { isPagedReadFile, isImageVisionFile, isWindowedReadFile } from './office';
+import { windowedIndexingEnabled } from './config';
 import { isErrorResponseBody, isAuthExpiredError, isNonRetryableRequestError, getErrorMessage } from './errors';
 import { buildBoundedChatMessages } from './budget';
 import { createInlineLinkRegex } from './links';
 import { mapHistoryListToMessages, extractLastUserTextFromRequest } from './history';
+import { wallClockNow } from './time';
 import { parseAttachmentContent } from './attachment_parsers';
 import type { ChatHost, ChatState, ChatMessage, PinnedDispatchContext } from './host';
+import type { IndexingGroup } from './indexing_groups';
 
 function sleep(ms: number): Promise<void> {
 	return new Promise(function (r) { setTimeout(r, ms); });
@@ -79,6 +82,13 @@ export class ChatSession {
 	state: ChatState;
 	bgTaskQueue: BgTaskEntry[];
 	cancelledServerIds: Set<string>;
+	/** Files whose indexing the user stopped, keyed exactly as buildChatDisplayList
+	 *  keys a group (storage path, else filename). Cancelling one pass is not
+	 *  enough on its own: the client dispatches CONTINUE passes for paged files, so
+	 *  without this the next pass is enqueued the moment the cancelled one settles.
+	 *  Cleared when a FIRST pass for the same file is queued again (a re-upload or a
+	 *  Reindex from the file manager), so stopping a file never poisons it. */
+	cancelledIndexKeys: Set<string>;
 	pendingAgentRequests: Record<string, Promise<any>>;
 	aiChatHistoryCache: Record<string, { messages: ChatMessage[]; endOfList: boolean; startKeyHistory: string[] }>;
 	historyItemPolls: Map<string, PollHandle>;
@@ -106,6 +116,7 @@ export class ChatSession {
 		};
 		this.bgTaskQueue = [];
 		this.cancelledServerIds = new Set();
+		this.cancelledIndexKeys = new Set();
 		this.pendingAgentRequests = {};
 		this.aiChatHistoryCache = {};
 		this.historyItemPolls = new Map();
@@ -132,6 +143,21 @@ export class ChatSession {
 		return p;
 	}
 
+	/**
+	 * Stop and forget one item's poll. Used after a cancel: the row is either gone
+	 * (cancelled while queued) or flagged cancelled (cancelled while running), so
+	 * asking about it again only burns requests. Safe when no poll is attached, and
+	 * safe on an older skapi-js with no stop handle (the entry is then LEFT in the
+	 * map so a later drain cannot stack a second, unstoppable poll on the id).
+	 */
+	private _stopPoll(id: string): void {
+		var handle = this.historyItemPolls.get(id);
+		if (!handle) return;
+		if (typeof handle.stop !== 'function') return;
+		try { handle.stop(); } catch (e) { /* best effort */ }
+		this.historyItemPolls.delete(id);
+	}
+
 	/** True while any pause reason is active. */
 	isPollingPaused(): boolean {
 		return this._pauseReasons.size > 0;
@@ -249,7 +275,21 @@ export class ChatSession {
 			if (reply._serverItemId === undefined && msgs[thIdx]._serverItemId !== undefined) reply._serverItemId = msgs[thIdx]._serverItemId;
 			msgs[thIdx] = reply;
 		} else {
-			msgs.push(reply);
+			// No pending placeholder left to replace. Before appending, check whether
+			// this turn is ALREADY in the cache — a history fetch may have mapped the
+			// resolved turn in while the reply was in flight. Appending blindly is how
+			// one turn ended up rendered twice (the duplicated question+answer): the
+			// cache is restored verbatim on the next mount, so a duplicate written
+			// here survives every later visit.
+			var dupIdx = -1;
+			if (serverId) {
+				for (var d = msgs.length - 1; d >= 0; d--) {
+					var dm = msgs[d];
+					if (dm && dm.role === 'assistant' && dm._serverItemId === serverId) { dupIdx = d; break; }
+				}
+			}
+			if (dupIdx !== -1) msgs[dupIdx] = reply;
+			else msgs.push(reply);
 		}
 
 		// Settle the user bubble this turn belongs to (first pending one, or the
@@ -438,7 +478,7 @@ export class ChatSession {
 			var offExisting = this.aiChatHistoryCache[key] || { messages: [], endOfList: false, startKeyHistory: [] };
 			this.aiChatHistoryCache[key] = {
 				messages: offExisting.messages.concat([
-					{ role: 'user', content: composed, _ownerKey: key },
+					{ role: 'user', content: composed, _ownerKey: key, _ts: wallClockNow() },
 					{ role: 'assistant', content: '', isPending: true, isPendingInProcess: true, _ownerKey: key },
 				]),
 				endOfList: offExisting.endOfList,
@@ -461,7 +501,7 @@ export class ChatSession {
 				platform: aiPlatform, model: aiModel, systemPrompt: systemPrompt, serviceId: id.serviceId,
 				history: resolvedHistory.concat([{ role: 'user', content: llmComposed }]),
 			});
-			var queuedBubble: ChatMessage = { role: 'user', content: composed, isPendingQueued: true, isSendingToServer: true };
+			var queuedBubble: ChatMessage = { role: 'user', content: composed, isPendingQueued: true, isSendingToServer: true, _ts: wallClockNow() };
 			if (key) queuedBubble._ownerKey = key;
 			if (useBgQueue) queuedBubble._useBgQueue = true;
 			this.state.messages.push(queuedBubble);
@@ -503,7 +543,7 @@ export class ChatSession {
 		// view unmount), then rendered from the cache via typewriteLatestReply. A
 		// later resumePendingRequest() re-renders it if the view remounted while the
 		// request was still in flight.
-		this.state.messages.push({ role: 'user', content: composed, ...(key ? { _ownerKey: key } : {}) });
+		this.state.messages.push({ role: 'user', content: composed, _ts: wallClockNow(), ...(key ? { _ownerKey: key } : {}) });
 		this.state.messages.push({ role: 'assistant', content: '', isPending: true, isPendingInProcess: true, ...(key ? { _ownerKey: key } : {}) });
 		this.host.notify(); this.updateHistoryCache(); this.state.sending = true; this.host.scrollToBottom(true);
 
@@ -546,7 +586,7 @@ export class ChatSession {
 			// under `key`, so a later loadChatHistory renders it.
 			self.state.sending = false;
 			if (!(self.host.isViewMounted() && self.getHistoryCacheKey() === key)) return;
-			return Promise.resolve(self.typewriteLatestReply(key)).then(function () { self.host.scrollToBottom(true); });
+			return Promise.resolve(self.typewriteLatestReply(key)).then(function () { self.host.scrollToBottomIfSticky(true); });
 		});
 	}
 
@@ -558,6 +598,8 @@ export class ChatSession {
 		if (nextIdx === -1) return;
 		var existing = this.state.messages[nextIdx];
 		var promoted: ChatMessage = { role: 'user', content: existing.content, isPendingInProcess: true, isBackgroundTask: true };
+		if (existing._indexFile) promoted._indexFile = existing._indexFile;
+		if (existing._ts !== undefined) promoted._ts = existing._ts;
 		if (existing._serverItemId !== undefined) promoted._serverItemId = existing._serverItemId;
 		if (existing._ownerKey !== undefined) promoted._ownerKey = existing._ownerKey;
 		this.state.messages[nextIdx] = promoted;
@@ -577,6 +619,8 @@ export class ChatSession {
 		var existing = this.state.messages[nextIdx];
 		var promoted: ChatMessage = { role: 'user', content: existing.content, isPendingInProcess: true };
 		if (existing.isBackgroundTask) promoted.isBackgroundTask = true;
+		if (existing._indexFile) promoted._indexFile = existing._indexFile;
+		if (existing._ts !== undefined) promoted._ts = existing._ts;
 		if (existing._serverItemId !== undefined) promoted._serverItemId = existing._serverItemId;
 		if (existing._ownerKey !== undefined) promoted._ownerKey = existing._ownerKey;
 		if (existing.isSendingToServer) promoted.isSendingToServer = true;
@@ -636,6 +680,7 @@ export class ChatSession {
 			var repl: ChatMessage = { role: 'user', content: exist.content };
 			if (exist._serverItemId !== undefined) repl._serverItemId = exist._serverItemId;
 			if (exist._ownerKey !== undefined) repl._ownerKey = exist._ownerKey;
+			if (exist._ts !== undefined) repl._ts = exist._ts;
 			this.state.messages[userIdx] = repl;
 		}
 		var thinkingIdx = userIdx >= 0
@@ -645,6 +690,9 @@ export class ChatSession {
 	}
 
 	insertAtTarget(msg: ChatMessage, targetIdx: number): void {
+		// Error/direct replies land here rather than through the typewriter, so this
+		// is where they pick up their display time.
+		if (msg && msg.role === 'assistant' && msg._ts === undefined) msg._ts = wallClockNow();
 		if (targetIdx >= 0 && this.state.messages[targetIdx] && this.state.messages[targetIdx].isPending) this.state.messages[targetIdx] = msg;
 		else if (targetIdx >= 0) this.state.messages.splice(targetIdx, 0, msg);
 		else this.state.messages.push(msg);
@@ -689,7 +737,9 @@ export class ChatSession {
 		this.promoteNextQueuedToRunning();
 		this.updateHistoryCache();
 		this.host.notify();
-		this.host.scrollToBottom(true);
+		// ARRIVAL, not a user action: only follow if the user is still pinned to
+		// the bottom. Scrolled-up readers keep their position.
+		this.host.scrollToBottomIfSticky(true);
 	}
 
 	onQueuedSendError(_composed: string, err: any, serverId?: string, ownerKey?: string): void {
@@ -732,14 +782,14 @@ export class ChatSession {
 			}
 			if (serverId) this.cancelledServerIds.delete(serverId);
 			this._removeStrayPendingAssistants();
-			this.promoteNextQueuedToRunning(); this.updateHistoryCache(); this.host.notify(); this.host.scrollToBottom(true);
+			this.promoteNextQueuedToRunning(); this.updateHistoryCache(); this.host.notify(); this.host.scrollToBottomIfSticky(true);
 			return;
 		}
 		var targetIdx = this.resolveQueuedUserBubble(serverId);
 		if (targetIdx === undefined) { this.host.notify(); this.updateHistoryCache(); return; }
 		this.insertAtTarget({ role: 'assistant', content: getErrorMessage(err), isError: true }, targetIdx);
 		this._removeStrayPendingAssistants();
-		this.promoteNextQueuedToRunning(); this.updateHistoryCache(); this.host.notify(); this.host.scrollToBottom(true);
+		this.promoteNextQueuedToRunning(); this.updateHistoryCache(); this.host.notify(); this.host.scrollToBottomIfSticky(true);
 	}
 
 	cancelQueuedMessage(msg: ChatMessage, idx: number): void {
@@ -759,13 +809,25 @@ export class ChatSession {
 		})).then(function (result: any) {
 			if (result && result.removed) {
 				self.cancelledServerIds.add(serverId as string);
+				self._stopPoll(serverId as string);
 				var qi = self.bgTaskQueue.findIndex(function (e) { return e.id === serverId; });
 				if (qi !== -1) self.bgTaskQueue.splice(qi, 1);
 				var removeIdx = self.state.messages.findIndex(function (m) {
 					return m._serverItemId === serverId && (m.isPendingQueued || m.isPendingInProcess) && m.role === 'user';
 				});
 				if (removeIdx !== -1) {
-					self.state.messages[removeIdx] = { role: 'user', content: self.state.messages[removeIdx].content, isCancelled: true, _serverItemId: serverId };
+					// Carry the background/file markers onto the rebuild. Dropping them
+					// took a cancelled INDEXING pass out of its file's collapsed row
+					// (buildChatDisplayList only groups isBackgroundTask bubbles), so the
+					// row stayed "Indexing…" forever while a bare "Indexing: file" bubble
+					// appeared beside it.
+					var wasMsg = self.state.messages[removeIdx];
+					var cancelledMsg: ChatMessage = { role: 'user', content: wasMsg.content, isCancelled: true, _serverItemId: serverId };
+					if (wasMsg.isBackgroundTask) cancelledMsg.isBackgroundTask = true;
+					if (wasMsg._indexFile) cancelledMsg._indexFile = wasMsg._indexFile;
+					if (wasMsg._useBgQueue) cancelledMsg._useBgQueue = true;
+					if (wasMsg._ownerKey !== undefined) cancelledMsg._ownerKey = wasMsg._ownerKey;
+					self.state.messages[removeIdx] = cancelledMsg;
 					var thById = self.state.messages.findIndex(function (m) { return m._serverItemId === serverId && m.isPending && m.role === 'assistant'; });
 					if (thById !== -1) self.state.messages.splice(thById, 1);
 					else {
@@ -791,6 +853,47 @@ export class ChatSession {
 		});
 	}
 
+	/**
+	 * Stop indexing a file, from its collapsed row — every pass at once, not just
+	 * the bubble the user happens to see.
+	 *
+	 * A big file is indexed as a CHAIN of passes, so cancelling only the live one
+	 * accomplishes nothing: the next pass is dispatched as soon as it settles.
+	 * Three things end the chain:
+	 *   1. every queued/running pass of this file is cancelled server-side
+	 *      (csr-cancel deletes a queued row and flags a running one "cancelled",
+	 *      which is also the worker's gate for NOT enqueueing the next window);
+	 *   2. the file is remembered in cancelledIndexKeys, so the client-driven
+	 *      resume (maybeResumeIndexing) stops dispatching CONTINUE passes; and
+	 *   3. any of its passes still sitting in bgTaskQueue is dropped by the next
+	 *      drain rather than surfacing a fresh "Indexing…" bubble.
+	 *
+	 * Records already written by the passes that DID run are kept — this stops the
+	 * work, it does not undo it.
+	 */
+	cancelIndexingGroup(group: IndexingGroup): void {
+		var self = this;
+		if (!group || !group.key) return;
+		// The group belongs to the chat on screen, so scope its key the same way
+		// _indexKeyOf scopes a queued task's.
+		var scoped = this.getHistoryCacheKey() + '|' + group.key;
+		this.cancelledIndexKeys.add(scoped);
+		var ids = group.cancellableIds || [];
+		if (!ids.length) { this.host.notify(); return; }
+		ids.forEach(function (serverId) {
+			// Address the message by IDENTITY, not by the index captured when the
+			// display list was built: an earlier cancel in this same loop may already
+			// have spliced the array (a group can have more than one live pass), and a
+			// stale index would mark the WRONG bubble as cancelling.
+			var idx = self.state.messages.findIndex(function (m) {
+				return m._serverItemId === serverId && m.role === 'user' &&
+					(m.isPendingQueued || m.isPendingInProcess);
+			});
+			if (idx === -1) return;
+			self.cancelQueuedMessage(self.state.messages[idx], idx);
+		});
+	}
+
 	// --- typewriter -------------------------------------------------------
 	// Reveal `fullText` into a message bubble at a constant wall-clock RATE
 	// (chars/second) driven by requestAnimationFrame, rather than a fixed number
@@ -904,6 +1007,12 @@ export class ChatSession {
 	private typewriterQueue: Promise<any> = Promise.resolve();
 	enqueueTypewrite(idx: number, fullText: string, localId?: string): Promise<any> {
 		var self = this;
+		// Stamp the reply bubble's display time as it starts revealing. This is the
+		// single chokepoint every typed reply (immediate, queued, and bg-resolution)
+		// passes through, so it is where a live reply gets its "when it arrived"
+		// timestamp; a history reload later replaces it with the server `updated`.
+		var target = this.state.messages[idx];
+		if (target && target._ts === undefined) target._ts = wallClockNow();
 		this.typewriterQueue = this.typewriterQueue.then(function () { return self.typewriteIntoIndex(idx, fullText, localId); });
 		return this.typewriterQueue;
 	}
@@ -972,6 +1081,10 @@ export class ChatSession {
 		var u = this.state.messages[uIdx];
 		var cleaned: ChatMessage = { role: 'user', content: u.content, _serverItemId: itemId };
 		if (u.isBackgroundTask) cleaned.isBackgroundTask = true;
+		if (u._ts !== undefined) cleaned._ts = u._ts;
+		// Carry the file ref: it is what keeps this pass in its file's collapsed
+		// row (the label parser is only a fallback for older cached bubbles).
+		if (u._indexFile) cleaned._indexFile = u._indexFile;
 		this.state.messages[uIdx] = cleaned;
 	}
 
@@ -988,11 +1101,11 @@ export class ChatSession {
 		if (!pending) return Promise.resolve();
 		if (this.state.messages.some(function (m) { return (m.isPending || m.isPendingQueued) && !m.isBackgroundTask && !m._useBgQueue; })) return Promise.resolve();
 		this.state.sending = true;
-		this.host.scrollToBottom(true);
+		this.host.scrollToBottomIfSticky(true);
 		return Promise.resolve(pending).catch(function () { }).then(function () {
 			if (token !== self.state.gateRefreshToken) return;
 			self.state.sending = false;
-			return Promise.resolve(self.typewriteLatestReply(key)).then(function () { self.host.scrollToBottom(true); });
+			return Promise.resolve(self.typewriteLatestReply(key)).then(function () { self.host.scrollToBottomIfSticky(true); });
 		});
 	}
 
@@ -1016,13 +1129,35 @@ export class ChatSession {
 			// bubble stuck pending — and drainBgTaskQueue then never clears its queue
 			// entry (its stillPending check stays true). Un-pend it here too.
 			this._clearPendingUserBubble(itemId);
+			// Carry isBackgroundTask onto the REPLACEMENT. These rebuilds are fresh
+			// object literals, so anything not copied is lost — and dropping this flag
+			// made a pass that resolved LIVE fall out of its file's collapsed row
+			// (buildChatDisplayList only considers isBackgroundTask messages), while
+			// the same pass rebuilt from history stayed grouped. That mismatch is the
+			// "new indexing response renders outside the group" bug.
+			var wasBgTask = !!this.state.messages[idx].isBackgroundTask;
 			if (isErr) {
 				this.state.messages[idx] = { role: 'assistant', content: answer, isError: true, _serverItemId: itemId };
+				if (wasBgTask) this.state.messages[idx].isBackgroundTask = true;
+				this.host.notify(); this.updateHistoryCache(); return;
+			}
+			var text = answer || 'No text response received from AI provider.';
+			// A background-indexing reply is INSIDE a collapsed row: nothing of it is
+			// on screen. Typewriting it anyway put it on the one shared, serial
+			// typewriter queue, so the user's own next reply — which IS on screen —
+			// lost its "Thinking..." spinner and sat as an EMPTY bubble for however
+			// long the invisible indexing summary took to reveal (seconds per pass,
+			// additive across files). It also held state.typing true for the whole
+			// time, which disables the platform/model pickers and no-ops Clear
+			// history, and ran a per-frame scroll for content nobody can see.
+			// Write it straight in; expanding the row then shows it complete.
+			if (wasBgTask) {
+				this.state.messages[idx] = { role: 'assistant', content: text, isBackgroundTask: true, _serverItemId: itemId };
 				this.host.notify(); this.updateHistoryCache(); return;
 			}
 			var lid = this._newLocalId();
 			this.state.messages[idx] = { role: 'assistant', content: '', _localId: lid, _serverItemId: itemId };
-			this.host.notify(); this.enqueueTypewrite(idx, answer || 'No text response received from AI provider.', lid);
+			this.host.notify(); this.enqueueTypewrite(idx, text, lid);
 			this.updateHistoryCache(); return;
 		}
 		var userIdx = this.state.messages.findIndex(function (m) {
@@ -1030,23 +1165,126 @@ export class ChatSession {
 		});
 		if (userIdx === -1) return;
 		var ex = this.state.messages[userIdx];
-		this.state.messages[userIdx] = { role: 'user', content: ex.content, _serverItemId: itemId };
+		// Same carry-over as above, plus _indexFile / _useBgQueue: this rebuild is
+		// what keeps an indexing REQUEST bubble in its file's collapsed row (and a
+		// bg-queued chat cancelling against the right queue) once the pass settles.
+		var settledUser: ChatMessage = { role: 'user', content: ex.content, _serverItemId: itemId };
+		if (ex.isBackgroundTask) settledUser.isBackgroundTask = true;
+		if (ex._ts !== undefined) settledUser._ts = ex._ts;
+		if (ex._indexFile) settledUser._indexFile = ex._indexFile;
+		if (ex._useBgQueue) settledUser._useBgQueue = true;
+		this.state.messages[userIdx] = settledUser;
 		if (isErr) {
-			this.state.messages.splice(userIdx + 1, 0, { role: 'assistant', content: answer, isError: true, _serverItemId: itemId });
+			var errReply: ChatMessage = { role: 'assistant', content: answer, isError: true, _serverItemId: itemId };
+			if (ex.isBackgroundTask) errReply.isBackgroundTask = true;
+			this.state.messages.splice(userIdx + 1, 0, errReply);
+			this.host.notify(); this.updateHistoryCache(); return;
+		}
+		var text2 = answer || 'No text response received from AI provider.';
+		// Same as above: a collapsed row's reply is not on screen, so revealing it
+		// character by character only blocks the queue the visible reply needs.
+		if (ex.isBackgroundTask) {
+			this.state.messages.splice(userIdx + 1, 0, { role: 'assistant', content: text2, isBackgroundTask: true, _serverItemId: itemId });
 			this.host.notify(); this.updateHistoryCache(); return;
 		}
 		var lid2 = this._newLocalId();
-		this.state.messages.splice(userIdx + 1, 0, { role: 'assistant', content: '', _localId: lid2, _serverItemId: itemId });
-		this.host.notify(); this.enqueueTypewrite(userIdx + 1, answer || 'No text response received from AI provider.', lid2);
+		var reply: ChatMessage = { role: 'assistant', content: '', _localId: lid2, _serverItemId: itemId };
+		this.state.messages.splice(userIdx + 1, 0, reply);
+		this.host.notify(); this.enqueueTypewrite(userIdx + 1, text2, lid2);
 		this.updateHistoryCache();
 	}
 
+	/** How a bg task maps onto a collapsed row: the row's own key (storage path
+	 *  when known, else the filename), scoped to the chat it belongs to. A storage
+	 *  path is project-relative ("report.xlsx"), and ONE ChatSession serves every
+	 *  project — unscoped, stopping a file in one project would silently suppress
+	 *  the same filename's continuations in another. */
+	private _indexKeyOf(entry: BgTaskEntry): string {
+		if (!entry) return '';
+		var file = entry.storagePath || entry.filename;
+		if (!file) return '';
+		return entry.serviceId + '#' + entry.platform + '|' + file;
+	}
+
+	/**
+	 * Reconcile the bg queue with the files the user has stopped.
+	 *
+	 * A FIRST pass (no resumePass) is a fresh indexing request — a re-upload, or a
+	 * Reindex from the file manager — so it LIFTS the stop: the key is a storage
+	 * path, and without this an earlier cancel would silently kill every future
+	 * index of the same path. A continuation of a stopped file is dropped instead,
+	 * covering the pass that was dispatched in the moment before the cancel landed.
+	 */
+	private _applyIndexCancellations(): void {
+		if (!this.cancelledIndexKeys.size) return;
+		for (var i = this.bgTaskQueue.length - 1; i >= 0; i--) {
+			var entry = this.bgTaskQueue[i];
+			var key = this._indexKeyOf(entry);
+			if (!key || !this.cancelledIndexKeys.has(key)) continue;
+			if (!entry.resumePass) { this.cancelledIndexKeys.delete(key); continue; }
+			this.bgTaskQueue.splice(i, 1);
+			this._stopPoll(entry.id);
+			this._cancelServerItem(entry.id);
+		}
+	}
+
+	/**
+	 * Cancel any live pass of a stopped file that turned up on its own.
+	 *
+	 * The client is not the only thing that continues a file: for PDFs and (when
+	 * windowed indexing is on) text/grid files the WORKER enqueues the next window
+	 * itself, and that pass reaches the chat through the history poll, never
+	 * through bgTaskQueue. The worker's own gate stops the chain when the running
+	 * row is cancelled — but if the row had already finished when the user hit
+	 * stop, the next window was queued a moment earlier and still arrives. Stop it
+	 * here rather than making the user hit stop again.
+	 *
+	 * Runs from drainBgTaskQueue, which both clients call after a history load.
+	 */
+	private _sweepCancelledIndexing(): void {
+		if (!this.cancelledIndexKeys.size) return;
+		var self = this;
+		var chatKey = this.getHistoryCacheKey();
+		var targets: { msg: ChatMessage; idx: number }[] = [];
+		this.state.messages.forEach(function (m, i) {
+			if (!m.isBackgroundTask || m.role !== 'user' || !m._serverItemId) return;
+			if (m._cancelling || m.isSendingToServer) return;
+			if (!(m.isPendingQueued || m.isPendingInProcess)) return;
+			var ref = m._indexFile;
+			var file = ref && (ref.path || ref.name);
+			if (!file || !self.cancelledIndexKeys.has(chatKey + '|' + file)) return;
+			targets.push({ msg: m, idx: i });
+		});
+		targets.forEach(function (t) {
+			var idx = self.state.messages.indexOf(t.msg);
+			self.cancelQueuedMessage(t.msg, idx === -1 ? t.idx : idx);
+		});
+	}
+
+	/** Best-effort server-side cancel of a bg-queue item that has no bubble (so
+	 *  cancelQueuedMessage, which drives one, has nothing to act on). */
+	private _cancelServerItem(serverId: string): void {
+		var id = this.host.getIdentity();
+		if (!serverId || (id.platform !== 'claude' && id.platform !== 'openai')) return;
+		var url = id.platform === 'claude' ? ANTHROPIC_MESSAGES_API_URL : OPENAI_RESPONSES_API_URL;
+		Promise.resolve(this.host.cancelRequest({
+			url: url, method: 'POST', id: serverId,
+			queue: (id.userId || id.serviceId) + BG_INDEXING_QUEUE_SUFFIX,
+			service: id.serviceId, owner: id.owner,
+		})).catch(function () { /* the pass may already have finished; nothing to do */ });
+	}
+
 	// Inject "Indexing: <file>" bubbles for queued bg tasks + attach their polls.
 	drainBgTaskQueue(): void {
 		var self = this;
 		var id = this.host.getIdentity();
 		var svcId = id.serviceId, plat = id.platform;
 		if (!svcId || plat === 'none' || !this.host.isViewMounted()) return;
+		// Before anything is surfaced: drop continuations of files the user stopped
+		// (and let a fresh first pass lift the stop), then cancel any worker-queued
+		// pass of a stopped file that reached the chat through history.
+		this._applyIndexCancellations();
+		this._sweepCancelledIndexing();
 		// Index messages by _serverItemId ONCE, so the per-entry presence/pending
 		// checks below are O(1) instead of a full messages.some() scan each. With a
 		// large bg queue (bulk uploads) the old nested scan was O(queue x messages)
@@ -1072,14 +1310,29 @@ export class ChatSession {
 			// "Thinking..." once polling resumed.
 			if (!presentIds[entry.id]) {
 			var isRunning = entry.status === 'running';
-			var userBubble: ChatMessage = { role: 'user', content: self.host.formatIndexingLabel(entry.filename, entry.mime, entry.size, entry.storagePath, entry.isReindex), isBackgroundTask: true, _serverItemId: entry.id };
+			var userBubble: ChatMessage = {
+				role: 'user',
+				content: self.host.formatIndexingLabel(entry.filename, entry.mime, entry.size, entry.storagePath, entry.isReindex, !!entry.resumePass),
+				isBackgroundTask: true,
+				_serverItemId: entry.id,
+				// Structured ref so this live pass groups with the same file's passes
+				// rebuilt from history (see indexing_groups.buildChatDisplayList).
+				_indexFile: {
+					name: entry.filename,
+					path: entry.storagePath,
+					mime: entry.mime,
+					size: entry.size,
+					isReindex: !!entry.isReindex,
+					continued: !!entry.resumePass,
+				},
+			};
 			if (isRunning) userBubble.isPendingInProcess = true; else userBubble.isPendingQueued = true;
 			self.state.messages.push(userBubble);
 			if (isRunning) {
 				self.state.messages.push({ role: 'assistant', content: '', isPending: true, isPendingInProcess: true, isBackgroundTask: true, _serverItemId: entry.id });
 			}
 			presentIds[entry.id] = true; // keep the index consistent with the pushed bubbles
-			self.host.notify(); self.updateHistoryCache(); self.host.scrollToBottom(false);
+			self.host.notify(); self.updateHistoryCache(); self.host.scrollToBottomIfSticky(false);
 			}
 			if (!self.isPollingPaused() && !self.historyItemPolls.has(entry.id) && typeof entry.poll === 'function') {
 				var capturedId = entry.id, capturedPlat = plat;
@@ -1096,12 +1349,28 @@ export class ChatSession {
 				}).catch(function (err: any) {
 					self.historyItemPolls.delete(capturedId);
 					var isNotExists = err && (err.code === 'NOT_EXISTS' || (err.body && err.body.code === 'NOT_EXISTS'));
+					// Settle the REQUEST bubble first, unconditionally. Only a RUNNING
+					// pass gets an assistant placeholder, so for a queued one the lookup
+					// below finds nothing and every branch was skipped — leaving the
+					// request bubble isPendingQueued with its queue entry about to be
+					// spliced away, i.e. no poll left to ever clear it. One such bubble
+					// pins the whole collapsed row to "active": a spinner and a Stop
+					// button against a dead id, until the page is reloaded.
+					self._clearPendingUserBubble(capturedId);
 					var bi = self.state.messages.findIndex(function (m) { return m.isPending && m._serverItemId === capturedId; });
 					if (bi !== -1) {
 						if (isNotExists) self.state.messages.splice(bi, 1);
 						else self.state.messages[bi] = { role: 'assistant', content: getErrorMessage(err), isError: true, isBackgroundTask: true, _serverItemId: capturedId };
-						self.host.notify(); self.updateHistoryCache();
+					} else if (!isNotExists) {
+						// No placeholder to turn into the error (a queued pass). Put one
+						// after the request bubble so the row reports the failure instead
+						// of quietly settling to "Indexed".
+						var ui = self.state.messages.findIndex(function (m) { return m.role === 'user' && m._serverItemId === capturedId; });
+						if (ui !== -1) {
+							self.state.messages.splice(ui + 1, 0, { role: 'assistant', content: getErrorMessage(err), isError: true, isBackgroundTask: true, _serverItemId: capturedId });
+						}
 					}
+					self.host.notify(); self.updateHistoryCache();
 				}).then(function () {
 					// Keep the queue entry when the poll was merely stopped, or resuming
 					// would have nothing left to re-attach to.
@@ -1130,8 +1399,18 @@ export class ChatSession {
 		var self = this;
 		try {
 			if (!entry || !entry.storagePath) return;
+			// The user stopped this file from its collapsed row. Dispatching the next
+			// 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)) return;
-			if (isImageVisionFile(entry.filename, entry.mime)) return; // worker owns this loop
+			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
+			// pass and the chain FORKS - duplicate records, runaway passes. Same reason
+			// 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)) return; // a failed pass is not "incomplete"
 			var answer = (platform === 'openai' ? extractOpenAIText(response) : extractClaudeText(response)) || '';
 			if (answer.indexOf(INDEXING_COMPLETE_MARKER) !== -1) return; // fully indexed
@@ -1221,6 +1500,10 @@ export class ChatSession {
 				formatIndexingLabel: self.host.formatIndexingLabel,
 			}).messages;
 
+			// 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;
+
 			if (fetchMore) {
 				self.state.messages = mapped.concat(self.state.messages);
 			} else {
@@ -1228,7 +1511,17 @@ export class ChatSession {
 				var serverIds: any = {};
 				mapped.forEach(function (m: any) { if (m._serverItemId) serverIds[m._serverItemId] = 1; });
 				var locallyCancelled: any = {};
-				self.state.messages.forEach(function (m) { if (m.isCancelled && m._serverItemId) locallyCancelled[m._serverItemId] = 1; });
+				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
+				// across the replace, a collapsed row mid-cancel drops its "Stopping..."
+				// state and re-offers Stop; the second click cancels an id that is
+				// already gone and writes a bogus "Could not remove from queue." onto a
+				// run that WAS stopped successfully.
+				var inFlightCancel: any = {};
+				self.state.messages.forEach(function (m) {
+					if (!m._serverItemId) return;
+					if (m._cancelling || m._cancelError) inFlightCancel[m._serverItemId] = m;
+				});
 				// If the freshly-mapped server list ALREADY shows this in-flight turn
 				// as a pending placeholder (a non-bg pending assistant, which carries
 				// a real _serverItemId), re-pushing the local no-_serverItemId
@@ -1257,25 +1550,83 @@ export class ChatSession {
 						}
 					}
 				}
-				self.state.messages = mapped;
+				// PRESERVE already-loaded older pages. `mapped` is only page 1, so a
+				// blind replace threw away every page the user had scrolled in. This
+				// path runs from resumePolling (visibilitychange), so merely leaving
+				// the tab and coming back wiped the whole scrolled-in history.
+				//
+				// The list is oldest-first (fetchMore PREPENDS), and ids sort with
+				// newest largest, so anything already in the list whose _serverItemId
+				// sorts BELOW page 1's oldest id is an older page. Those are disjoint
+				// from `mapped` (strict <), so re-prepending cannot duplicate.
+				var oldestInPage1: string | undefined = undefined;
+				mapped.forEach(function (m: any) {
+					var sid = m._serverItemId;
+					if (typeof sid !== 'string') return;
+					if (oldestInPage1 === undefined || sid < (oldestInPage1 as string)) oldestInPage1 = sid;
+				});
+				// Only merge when the current list is genuinely a continuation of THIS
+				// page 1 (shares at least one id with it). A project switch, a cleared
+				// horizon, or a wholly-new page means the head is unrelated history and
+				// must be replaced, not spliced.
+				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) {
+					// 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;
+					// Same ownership predicate as the rescue loop: never carry another
+					// 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);
+				});
+				keptOlderPages = retainedOlder.length > 0;
+				self.state.messages = keptOlderPages ? retainedOlder.concat(mapped) : mapped;
 				rescued.forEach(function (m) { self.state.messages.push(m); });
 				if (Object.keys(locallyCancelled).length) {
 					for (var ci = 0; ci < self.state.messages.length; ci++) {
 						var c = self.state.messages[ci];
 						if (!c._serverItemId || !locallyCancelled[c._serverItemId] || c.isCancelled) continue;
-						self.state.messages[ci] = { role: 'user', content: c.content, isCancelled: true, _serverItemId: c._serverItemId };
+						// Rebuild FROM the mapped bubble rather than as a bare literal:
+						// dropping isBackgroundTask / _indexFile here ejected a stopped
+						// indexing pass from its file's collapsed row, where it then rendered
+						// as a standalone "Indexing: <file>" chat bubble and left the row
+						// recomputing its passes as if that one had never happened.
+						self.state.messages[ci] = {
+							role: 'user', content: c.content, isCancelled: true, _serverItemId: c._serverItemId,
+							isBackgroundTask: c.isBackgroundTask, _indexFile: c._indexFile,
+							_useBgQueue: c._useBgQueue, _ownerKey: c._ownerKey,
+						};
 						if (ci + 1 < self.state.messages.length && self.state.messages[ci + 1].isPending && self.state.messages[ci + 1]._serverItemId === c._serverItemId) {
 							self.state.messages.splice(ci + 1, 1);
 						}
 					}
 				}
+				// Re-stamp a cancel that is still in flight (see inFlightCancel above).
+				// Only onto a bubble the server still reports as pending — once it has
+				// settled the flags describe nothing the user can act on.
+				for (var fi = 0; fi < self.state.messages.length; fi++) {
+					var fm = self.state.messages[fi];
+					var was = fm._serverItemId && inFlightCancel[fm._serverItemId];
+					if (!was || fm.isCancelled) continue;
+					if (!(fm.isPendingQueued || fm.isPendingInProcess || fm.isPending)) continue;
+					if (was._cancelling) fm._cancelling = true;
+					if (was._cancelError) fm._cancelError = was._cancelError;
+				}
 			}
-			self.state.historyEndOfList = !!(history && history.endOfList);
-			self.state.historyStartKeyHistory = history && Array.isArray(history.startKeyHistory) ? history.startKeyHistory : [];
-			var clearedAt = self.host.getClearedAt();
-			if (clearedAt && chatList.length > 0) {
-				var oldestUpdated = Number(chatList[chatList.length - 1] && chatList[chatList.length - 1].updated);
-				if (isFinite(oldestUpdated) && oldestUpdated <= clearedAt) self.state.historyEndOfList = true;
+			// Only adopt page 1's cursor when page 1 IS the whole list. If older pages
+			// survived the merge, rewinding here would make the next scroll-up
+			// re-fetch page 2 (already on screen) and duplicate it.
+			if (!keptOlderPages) {
+				self.state.historyEndOfList = !!(history && history.endOfList);
+				self.state.historyStartKeyHistory = history && Array.isArray(history.startKeyHistory) ? history.startKeyHistory : [];
+				var clearedAt = self.host.getClearedAt();
+				if (clearedAt && chatList.length > 0) {
+					var oldestUpdated = Number(chatList[chatList.length - 1] && chatList[chatList.length - 1].updated);
+					if (isFinite(oldestUpdated) && oldestUpdated <= clearedAt) self.state.historyEndOfList = true;
+				}
 			}
 			// Clear loading flags BEFORE this render so the final paint is
 			// indicator-free (and the view's scroll-restore math sees matching heights).
@@ -1321,12 +1672,30 @@ export class ChatSession {
 							var isNotExists = err && (err.code === 'NOT_EXISTS' || (err.body && err.body.code === 'NOT_EXISTS'));
 							var aIdx = self.state.messages.findIndex(function (m) { return m.isPending && m._serverItemId === capturedId; });
 							if (isNotExists) {
-								var isBg = aIdx !== -1 ? !!self.state.messages[aIdx].isBackgroundTask : false;
+								var uIdx = self.state.messages.findIndex(function (m) { return m.role === 'user' && m._serverItemId === capturedId && !m.isCancelled; });
+								// Decide bg-ness from whichever bubble actually exists. A
+								// QUEUED pass has no assistant placeholder (history.ts emits
+								// none), so reading it off the placeholder alone classified
+								// every queued indexing pass as foreground: the rebuild below
+								// then dropped isBackgroundTask/_indexFile, ejecting the pass
+								// from its collapsed row as a raw "Indexing: <file>" chat
+								// bubble, and promoteNextQueuedToRunning span up a "Thinking..."
+								// on an unrelated queued FOREGROUND message.
+								var isBg = (aIdx !== -1 && !!self.state.messages[aIdx].isBackgroundTask)
+									|| (uIdx !== -1 && !!self.state.messages[uIdx].isBackgroundTask);
 								if (aIdx !== -1) self.state.messages.splice(aIdx, 1);
 								if (!isBg) {
-									var uIdx = self.state.messages.findIndex(function (m) { return m.role === 'user' && m._serverItemId === capturedId && !m.isCancelled; });
 									if (uIdx !== -1) { var ex = self.state.messages[uIdx]; self.state.messages[uIdx] = { role: 'user', content: ex.content, isCancelled: true, _serverItemId: ex._serverItemId }; }
 									self.cancelledServerIds.delete(capturedId); self.promoteNextQueuedToRunning();
+								} else if (uIdx !== -1) {
+									// Same carry-over every other rebuild does, so the pass stays
+									// a member of its file's row while reading as cancelled.
+									var bex = self.state.messages[uIdx];
+									var bcancelled: ChatMessage = { role: 'user', content: bex.content, isCancelled: true, isBackgroundTask: true, _serverItemId: bex._serverItemId };
+									if (bex._indexFile) bcancelled._indexFile = bex._indexFile;
+									if (bex._useBgQueue) bcancelled._useBgQueue = true;
+									self.state.messages[uIdx] = bcancelled;
+									self.promoteNextBgQueuedToRunning();
 								}
 								self.host.notify(); self.updateHistoryCache(); return;
 							}
@@ -1349,7 +1718,11 @@ export class ChatSession {
 				self.drainBgTaskQueue();
 			}
 
-			if (!fetchMore) return self.host.scrollToBottom();
+			// Sticky, NOT forcing: this runs after every first-page load, including
+			// the one resumePolling fires on visibilitychange. Forcing yanked a
+			// reader who had scrolled up back to the bottom. On a genuine mount the
+			// user is still pinned, so this behaves identically there.
+			if (!fetchMore) return self.host.scrollToBottomIfSticky();
 		}).catch(function (err: any) {
 			console.warn('[chat-engine] getChatHistory failed', err);
 		}).then(function () {
@@ -1358,6 +1731,12 @@ export class ChatSession {
 				self.state.loadingHistory = false; self.state.loadingOlderHistory = false;
 				if (wasLoading) self.host.notify();
 			}
+			// Every first-page load ends here — mount, resumePolling, a cache-restore
+			// refresh — and every one of them can leave a box too short to scroll,
+			// which is the only trigger there is for reaching page 2. The view (which
+			// alone can measure) pages its way out of it. Fired after the flags are
+			// cleared so the fill loop does not see a request still in flight.
+			if (self.host.onHistoryLoaded) self.host.onHistoryLoaded(!!fetchMore, token as number);
 		});
 	}