bunnyquery 1.8.0 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunnyquery",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Embeddable BunnyQuery AI chat widget + its framework-agnostic chat engine",
   "main": "bunnyquery.js",
   "exports": {

package/src/engine/ai_agent.ts

@@ -0,0 +1,80 @@
+/**
+ * The `ai_agent` service option, parsed and serialized in ONE place.
+ *
+ * Stored on the skapi service record as up to three '#'-delimited segments:
+ *
+ *   none                                  AI chat disabled
+ *   claude                                platform chosen, no model saved yet
+ *   claude#claude-sonnet-4-6              platform + model
+ *   claude#claude-sonnet-4-6#400000       platform + model + context-window override
+ *
+ * The third segment is new and optional, so every value written before it
+ * existed parses unchanged with `contextWindow: null`. Nothing writes a third
+ * segment without a model, because the window is meaningless without one.
+ *
+ * This lived as four separate copies (agent.vue, dbfile.vue, service.vue, and
+ * the widget's index.js), which is how the format drifts. New callers should
+ * import from here rather than re-deriving the split.
+ */
+
+export type AiAgentPlatform = 'claude' | 'openai' | null;
+
+export type ParsedAiAgent = {
+	/** null when unset or explicitly 'none'. */
+	platform: AiAgentPlatform;
+	/** '' when no model has been saved. */
+	model: string;
+	/** Per-project context-window override in tokens, or null to use the model's. */
+	contextWindow: number | null;
+	/** True when a real platform is configured (i.e. not unset and not 'none'). */
+	hasPlatform: boolean;
+};
+
+function normalizePlatform(raw: string): AiAgentPlatform {
+	var p = (raw || '').trim().toLowerCase();
+	return p === 'claude' || p === 'openai' ? p : null;
+}
+
+export function parseAiAgentValue(value: string | null | undefined): ParsedAiAgent {
+	var raw = (value || '').trim();
+	if (!raw || raw.toLowerCase() === 'none') {
+		return { platform: null, model: '', contextWindow: null, hasPlatform: false };
+	}
+
+	// Split into at most three parts so a '#' inside a model id (none today, but
+	// the delimiter should not be load-bearing on the tail) cannot shift fields.
+	var firstHash = raw.indexOf('#');
+	if (firstHash === -1) {
+		var only = normalizePlatform(raw);
+		return { platform: only, model: '', contextWindow: null, hasPlatform: !!only };
+	}
+
+	var platform = normalizePlatform(raw.slice(0, firstHash));
+	var rest = raw.slice(firstHash + 1);
+	var secondHash = rest.indexOf('#');
+	var model = (secondHash === -1 ? rest : rest.slice(0, secondHash)).trim();
+	var windowRaw = secondHash === -1 ? '' : rest.slice(secondHash + 1).trim();
+
+	var parsedWindow = windowRaw ? Number(windowRaw) : NaN;
+	var contextWindow = Number.isFinite(parsedWindow) && parsedWindow > 0
+		? Math.floor(parsedWindow)
+		: null;
+
+	return { platform: platform, model: model, contextWindow: contextWindow, hasPlatform: !!platform };
+}
+
+export function buildAiAgentValue(
+	platform: string | null | undefined,
+	model?: string | null,
+	contextWindow?: number | null,
+): string {
+	var p = (platform || '').trim().toLowerCase();
+	if (!p || p === 'none') return 'none';
+
+	var m = (model || '').trim();
+	if (!m) return p;
+
+	var n = Number(contextWindow);
+	if (!Number.isFinite(n) || n <= 0) return p + '#' + m;
+	return p + '#' + m + '#' + Math.floor(n);
+}

package/src/engine/budget.ts

@@ -7,15 +7,76 @@
 import { sanitizeAttachmentLinksForHistory } from './links';
 
 export var CONTEXT_WINDOW_DEFAULT: Record<string, number> = { claude: 200000, openai: 128000 };
+// Exact model ids first, then family keys (see getContextWindow: a suffixed id
+// falls back to its family rather than to the platform default). Claude figures
+// come from Anthropic's published model table; `max_input_tokens` from
+// /v1/models overrides all of this at runtime when a listing has been seen.
+// 'claude-opus-4-7' read 200000 here, which was wrong by 5x, and the default
+// Claude model 'claude-sonnet-4-6' was absent entirely so it fell through to
+// CONTEXT_WINDOW_DEFAULT.claude. Neither was observable, because the history
+// budget and the Claude per-request cap below bind long before the window does.
 export var CONTEXT_WINDOW_BY_MODEL: Record<string, number> = {
-	'claude-opus-4-7': 200000, 'claude-sonnet-4': 200000, 'gpt-5.4': 128000,
+	// exact ids
+	'claude-opus-5': 1000000, 'claude-opus-4-8': 1000000, 'claude-opus-4-7': 1000000,
+	'claude-sonnet-5': 1000000, 'claude-sonnet-4-6': 1000000, 'claude-sonnet-4': 200000,
+	'claude-haiku-4-5': 200000, 'gpt-5.4': 128000, 'gpt-5.6-luna': 128000,
+	// family keys
+	'claude-opus': 1000000, 'claude-sonnet': 1000000, 'claude-haiku': 200000,
+	'gpt-5.6': 128000, 'gpt-5': 128000,
 };
+
+// Context windows reported by a provider's own models listing, keyed by model id.
+// Anthropic's GET /v1/models returns `max_input_tokens` per model, which is the
+// authoritative context window; OpenAI's listing carries no equivalent field, so
+// OpenAI models resolve from the table above. Populated by
+// registerModelContextWindows() when a client fetches its model list.
+var apiReportedContextWindows: Record<string, number> = {};
+
+/**
+ * Record context windows from a provider models listing. Accepts the raw list
+ * items and reads `max_input_tokens` (Anthropic); items without it are skipped,
+ * so passing an OpenAI listing is a no-op rather than an error.
+ */
+export function registerModelContextWindows(models: Array<{ id?: string; max_input_tokens?: number }> | null | undefined): void {
+	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();
+		var reported = m ? Number(m.max_input_tokens) : NaN;
+		if (id && Number.isFinite(reported) && reported > 0) {
+			apiReportedContextWindows[id] = Math.floor(reported);
+		}
+	}
+}
+
+/** Per-project override, keyed by service id. Set from the project settings. */
+var projectContextWindows: Record<string, number> = {};
+
+export function setProjectContextWindow(serviceId: string, tokens: number | null | undefined): void {
+	var key = (serviceId || '').trim();
+	if (!key) return;
+	var n = Number(tokens);
+	if (Number.isFinite(n) && n > 0) projectContextWindows[key] = Math.floor(n);
+	else delete projectContextWindows[key];
+}
+
+export function getProjectContextWindow(serviceId: string): number | null {
+	var key = (serviceId || '').trim();
+	return key && projectContextWindows[key] ? projectContextWindows[key] : null;
+}
 export var OUTPUT_TOKEN_RESERVE = 22000;
 export var TOOL_AND_RESPONSE_BUFFER = 4000;
 export var MIN_INPUT_TOKEN_BUDGET = 8000;
 export var CLAUDE_PER_REQUEST_INPUT_CAP = 28000;
 export var MAX_HISTORY_MESSAGES = 20;
 export var HISTORY_TOKEN_BUDGET = 8000;
+// Ratios that scale the two ceilings above off the resolved context window.
+// Calibrated to reproduce the previous fixed values at the default windows:
+// claude 200000 -> cap 27840 (was 28000, so the 28000 floor holds), and
+// openai 128000 -> history 8160 (~the previous 8000). Both are floored at the
+// old constants, so these can only ever raise a budget, never lower one.
+export var CLAUDE_INPUT_CAP_RATIO = 0.16;
+export var HISTORY_BUDGET_RATIO = 0.08;
 
 export function estimateTextTokens(text: string): number {
 	return Math.ceil((text || '').length / 3);
@@ -25,9 +86,34 @@ export function estimateMessageTokens(msg: { role: string; content: string }): n
 	return estimateTextTokens(msg.content) + estimateTextTokens(msg.role) + 6;
 }
 
-export function getContextWindow(platform: string, model?: string): number {
+/**
+ * Resolve a model's context window, most specific source first:
+ *   1. per-project override (project settings)
+ *   2. the provider's own models listing (Anthropic `max_input_tokens`)
+ *   3. an exact entry in CONTEXT_WINDOW_BY_MODEL
+ *   4. a family entry, by dropping trailing '-' segments off the id
+ *   5. the platform default
+ *
+ * Step 4 is why a new or suffixed id no longer drops straight to the platform
+ * default: 'gpt-5.6-luna' resolves via 'gpt-5.6', and a dated Claude snapshot
+ * such as 'claude-opus-4-7-20260101' resolves via 'claude-opus-4-7'. The walk
+ * stops at the first hit, so a more specific entry always wins over its family.
+ */
+export function getContextWindow(platform: string, model?: string, serviceId?: string): number {
+	var override = serviceId ? getProjectContextWindow(serviceId) : null;
+	if (override) return override;
+
 	var normalized = (model || '').trim().toLowerCase();
-	if (normalized && CONTEXT_WINDOW_BY_MODEL[normalized]) return CONTEXT_WINDOW_BY_MODEL[normalized];
+	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];
 }
 
@@ -46,14 +132,34 @@ export type BoundedChatOptions = {
 };
 
 export function buildBoundedChatMessages(options: BoundedChatOptions) {
-	var contextWindow = getContextWindow(options.platform, options.model);
+	var contextWindow = getContextWindow(options.platform, options.model, options.serviceId);
 	var contextBasedBudget = Math.max(MIN_INPUT_TOKEN_BUDGET,
 		contextWindow - OUTPUT_TOKEN_RESERVE - TOOL_AND_RESPONSE_BUFFER);
+	// Scaling is gated on an EXPLICIT per-project window set from project
+	// settings. Without one, the fixed ceilings apply exactly as before, so every
+	// existing project keeps byte-identical behavior and nobody's token spend
+	// moves because a table value was corrected. With one, the Claude per-request
+	// cap and the history budget scale off the window, so raising it genuinely
+	// sends more history instead of being absorbed by a hardcoded ceiling.
+	// Both derive from contextBasedBudget (pre-Claude-cap) so the two platforms
+	// scale symmetrically rather than the Claude cap compounding the ratio down.
+	var scaled = !!(options.serviceId && getProjectContextWindow(options.serviceId));
+	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, CLAUDE_PER_REQUEST_INPUT_CAP) : contextBasedBudget;
+		? Math.min(contextBasedBudget, claudeInputCap) : contextBasedBudget;
 	var systemCost = estimateTextTokens(options.systemPrompt) + 12;
-	var budgetForHistory = Math.max(1000, Math.min(HISTORY_TOKEN_BUDGET, availableInputBudget - systemCost));
-	var windowed = options.history.slice(-MAX_HISTORY_MESSAGES);
+	var historyAllowance = scaled
+		? Math.max(HISTORY_TOKEN_BUDGET, Math.round(contextBasedBudget * HISTORY_BUDGET_RATIO))
+		: HISTORY_TOKEN_BUDGET;
+	var budgetForHistory = Math.max(1000, Math.min(historyAllowance, availableInputBudget - systemCost));
+	// The message count scales alongside the token budget; otherwise 20 messages
+	// is a second ceiling that swallows the extra budget on a raised window.
+	var maxHistoryMessages = scaled
+		? Math.max(MAX_HISTORY_MESSAGES, Math.round(MAX_HISTORY_MESSAGES * (budgetForHistory / HISTORY_TOKEN_BUDGET)))
+		: MAX_HISTORY_MESSAGES;
+	var windowed = options.history.slice(-maxHistoryMessages);
 	var latestIndex = windowed.length - 1;
 	var trimmed = windowed.map(function (m, i) {
 		if (i === latestIndex) return m;

package/src/engine/history.ts

@@ -40,6 +40,46 @@ export function extractLastUserTextFromRequest(requestBody: any): string {
 	return '';
 }
 
+/** The two openings an indexing prompt can have. A bg-queue item that starts with
+ *  neither is an ordinary chat that happened to be routed onto that queue. */
+export function isIndexingRequestText(userText: any): boolean {
+	if (typeof userText !== 'string') return false;
+	return userText.indexOf('A new file has just been uploaded') === 0 || userText.indexOf('CONTINUE indexing') === 0;
+}
+
+export type IndexingRequestRef = {
+	name: string;
+	path?: string;
+	mime?: string;
+	size?: number;
+	/** A CONTINUE pass rather than the run's first. */
+	continued: boolean;
+};
+
+/**
+ * The file an indexing prompt is about, read back out of the prompt itself.
+ *
+ * The prompt is the only description of the pass that survives on the server, so
+ * this is how BOTH a history rebuild and a worker-minted pass the client never
+ * dispatched (ChatSession._adoptWorkerIndexingPasses) recover the file. Shared so
+ * the two produce the same `_indexFile`, which is what makes them group together.
+ */
+export function parseIndexingRequestText(userText: any): IndexingRequestRef | null {
+	if (typeof userText !== 'string' || !userText) return null;
+	var nameMatch = userText.match(/^- name: (.+)$/m);
+	if (!nameMatch) return null;
+	var mimeMatch = userText.match(/^- mime type: (.+)$/m);
+	var sizeMatch = userText.match(/^- size \(bytes\): (\d+)$/m);
+	var pathMatch = userText.match(/^- storage path: (.+)$/m);
+	return {
+		name: nameMatch[1].trim(),
+		path: pathMatch ? pathMatch[1].trim() : undefined,
+		mime: mimeMatch ? mimeMatch[1].trim() : undefined,
+		size: sizeMatch ? Number(sizeMatch[1]) : undefined,
+		continued: userText.indexOf('CONTINUE indexing') === 0,
+	};
+}
+
 export type MapHistoryOptions = {
 	clearedAt: number;
 	serviceId: string;
@@ -78,31 +118,21 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 			// alongside the formatted label so grouping never has to parse it back.
 			var indexFile: any = undefined;
 			if (item._isBgTask) {
-				var nameMatch = userText.match(/^- name: (.+)$/m);
-				if (nameMatch) {
-					var mimeMatch = userText.match(/^- mime type: (.+)$/m);
-					var sizeMatch = userText.match(/^- size \(bytes\): (\d+)$/m);
-					var pathMatch = userText.match(/^- storage path: (.+)$/m);
+				var ref = parseIndexingRequestText(userText);
+				if (ref) {
 					// A CONTINUE pass ("CONTINUE indexing …") gets the compact
 					// continuation label; a first pass ("A new file …") gets the full
 					// one. Mirrors agent.vue's mapHistoryListToMessages so a big file's
 					// windows read as progress, not the same task repeating.
-					var isContinuePass = userText.indexOf('CONTINUE indexing') === 0;
 					displayContent = opts.formatIndexingLabel(
-						nameMatch[1].trim(),
-						mimeMatch ? mimeMatch[1].trim() : '',
-						sizeMatch ? Number(sizeMatch[1]) : null,
-						pathMatch ? pathMatch[1].trim() : undefined,
+						ref.name,
+						ref.mime || '',
+						typeof ref.size === 'number' ? ref.size : null,
+						ref.path,
 						false,
-						isContinuePass
+						ref.continued
 					);
-					indexFile = {
-						name: nameMatch[1].trim(),
-						path: pathMatch ? pathMatch[1].trim() : undefined,
-						mime: mimeMatch ? mimeMatch[1].trim() : undefined,
-						size: sizeMatch ? Number(sizeMatch[1]) : undefined,
-						continued: isContinuePass,
-					};
+					indexFile = ref;
 				} else {
 					displayContent = userText;
 				}

package/src/engine/index.ts

@@ -47,11 +47,19 @@ export { getErrorMessage, isErrorResponseBody, isAuthExpiredError, isNonRetryabl
 export * from './budget';
 export * from './links';
 export * from './time';
+export * from './ai_agent';
 export {
 	filterListByClearHorizon,
 	normalizeTextContent,
 	extractLastUserTextFromRequest,
 	mapHistoryListToMessages,
+	// The indexing-prompt reader. Exported because the prompt is the only record
+	// of what a pass is about, so anything that meets a pass without a bubble
+	// (a history rebuild, an adopted worker pass, agent.vue's own mapper) has to
+	// read it the same way or the two will not group together.
+	isIndexingRequestText,
+	parseIndexingRequestText,
+	type IndexingRequestRef,
 	type MapHistoryOptions,
 } from './history';
 

package/src/engine/requests.ts

@@ -833,8 +833,16 @@ export const INDEXING_COMPLETE_MARKER = 'INDEXING_COMPLETE';
 // a small cap suffices.
 export const MAX_INDEXING_RESUME_PASSES = 6;
 
+/**
+ * `queue` narrows the fetch to one processing chain; `status` narrows it to items
+ * in one state. Passing both is how the client asks "is there still unresolved
+ * work on the background-indexing queue?" without pulling a page of chat history
+ * (see ChatSession._adoptWorkerIndexingPasses) — the server answers that from a
+ * status-keyed index, so the reply carries only the live items, not the bodies of
+ * everything already finished.
+ */
 export async function getChatHistory(
-	params: { service?: string; owner?: string; platform: 'claude' | 'openai'; queue?: string },
+	params: { service?: string; owner?: string; platform: 'claude' | 'openai'; queue?: string; status?: 'pending' | 'running' | 'resolved' | 'failed' },
 	fetchOptions: Record<string, any>,
 ) {
 	const url =
@@ -848,10 +856,11 @@ export async function getChatHistory(
 		},
 		{ service: params.service, owner: params.owner },
 		params.queue ? { queue: params.queue } : {},
+		params.status ? { status: params.status } : {},
 	);
 
 	return chatEngineConfig().clientSecretRequestHistory(
-		p as { url: string; method: 'POST'; queue?: string },
+		p as { url: string; method: 'POST'; queue?: string; status?: string },
 		Object.assign({ ascending: false }, fetchOptions),
 	);
 }

package/src/engine/session.ts

@@ -39,7 +39,7 @@ 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 { mapHistoryListToMessages, extractLastUserTextFromRequest, isIndexingRequestText, parseIndexingRequestText } from './history';
 import { wallClockNow } from './time';
 import { parseAttachmentContent } from './attachment_parsers';
 import type { ChatHost, ChatState, ChatMessage, PinnedDispatchContext } from './host';
@@ -49,6 +49,16 @@ function sleep(ms: number): Promise<void> {
 	return new Promise(function (r) { setTimeout(r, ms); });
 }
 
+// How many live items one look at the background-indexing queue asks for. The
+// queue is FIFO per user, so a healthy chain has one running plus at most a
+// couple queued; the cap only bounds a pathological backlog.
+const WORKER_PASS_ADOPT_LIMIT = 20;
+// Delays before each look (the first is immediate). More than one because the
+// worker writes the next pass's row a few milliseconds AFTER it resolves the
+// current one, so a look that wins that race sees an empty queue for a chain
+// that is still alive. Fixed and finite: this must never become a poll.
+const WORKER_PASS_ADOPT_ATTEMPTS = [0, 2000, 6000];
+
 // requestAnimationFrame / high-res clock, reached through globalThis so the
 // engine stays DOM-free at the type level (and degrades gracefully in non-DOM
 // / test environments where these globals are absent).
@@ -1111,8 +1121,29 @@ export class ChatSession {
 
 	// --- background-task resolution + drain -------------------------------
 	handleHistoryItemResolution(itemId: string, response: any, platform: string): void {
+		// Which file this turn was indexing, read BEFORE the resolution rewrites the
+		// bubbles. Every settling turn funnels through here — the bg drain's own
+		// poll, the history poll, and agent.vue's forked history poll, which calls
+		// straight into this method — so hooking the chain follow-up here is what
+		// makes it work in both clients without either of them forking a call site.
+		var indexRef = this._indexRefOfItem(itemId);
 		this.applyHistoryItemResolution(itemId, response, platform);
 		this.promoteNextBgQueuedToRunning();
+		// A worker-driven chain has no client-side record of its next pass, so a
+		// settling pass is the only moment there is to go looking for one.
+		if (indexRef) this._followWorkerIndexingChain(indexRef.name, indexRef.mime);
+	}
+
+	/** The file an already-rendered background pass is about, off its request
+	 *  bubble. Null for an ordinary turn, which is most of them. */
+	private _indexRefOfItem(itemId: string): { name?: string; mime?: string } | null {
+		if (!itemId) return null;
+		for (var i = 0; i < this.state.messages.length; i++) {
+			var m = this.state.messages[i];
+			if (m._serverItemId !== itemId || m.role !== 'user' || !m.isBackgroundTask) continue;
+			return m._indexFile || null;
+		}
+		return null;
 	}
 
 	applyHistoryItemResolution(itemId: string, response: any, platform: string): void {
@@ -1261,6 +1292,175 @@ export class ChatSession {
 		});
 	}
 
+	/**
+	 * True when the WORKER, not this client, drives the rest of this file's chain.
+	 * The mirror image of the early returns in maybeResumeIndexing: whatever that
+	 * refuses to continue is exactly what nothing client-side is tracking.
+	 */
+	private _isWorkerDrivenIndexing(filename?: string, mime?: string): boolean {
+		if (!isPagedReadFile(filename, mime)) return false;
+		if (isImageVisionFile(filename, mime)) return true;
+		return windowedIndexingEnabled() && isWindowedReadFile(filename, mime);
+	}
+
+	/**
+	 * Pick up indexing passes the WORKER minted, which no client ever dispatched.
+	 *
+	 * For a PDF (and for text/grid when windowed indexing is on) the worker writes
+	 * pass N+1's row itself, inside pass N's invocation, right after saving pass
+	 * N's result. That row reaches this client through nothing at all: it is not in
+	 * bgTaskQueue (the client never asked for it) and it is not in state.messages
+	 * (only a first-page history load maps it in, which happens on mount, project
+	 * switch or tab return). So between two worker passes every pass the client
+	 * knows about is settled, and the collapsed row renders "Indexed  N passes"
+	 * with no spinner and no Stop, for a file that is still being read. A user who
+	 * believes that then asks questions against a half-indexed file — which is what
+	 * this exists to prevent.
+	 *
+	 * So when a background indexing pass settles, ask the bg queue what is still
+	 * unresolved on it and adopt anything unknown as an ordinary BgTaskEntry.
+	 * drainBgTaskQueue then treats it exactly like a pass this client dispatched:
+	 * same bubble, same `_indexFile` (so it joins the file's collapsed row), same
+	 * poll — and that poll settling runs this again, so the chain is followed to
+	 * its end. `status`-scoped so the reply carries the live items only, never a
+	 * page of finished ones with their bodies.
+	 *
+	 * Termination: the only trigger is a pass SETTLING, which happens once per
+	 * pass. An adopted item that is still running is not re-adopted (its id is
+	 * already polled), and when the queue holds nothing unknown the chain stops on
+	 * its own. Nothing here is periodic — a timer that re-reads history is the
+	 * shape that previously looped fetchHistoryPage after an already-DONE index.
+	 */
+	private _adoptingWorkerPasses = false;
+	private _adoptWorkerIndexingPasses(attempt: number): 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.
+		if (this._adoptingWorkerPasses) return;
+		var id = this.host.getIdentity();
+		var platform = id.platform;
+		if (!id.serviceId || (platform !== 'claude' && platform !== 'openai')) return;
+		if (this.isPollingPaused() || !this.host.isViewMounted()) return;
+		var svcId = id.serviceId, owner = id.owner;
+		var queue = (id.userId || id.serviceId) + BG_INDEXING_QUEUE_SUFFIX;
+		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; });
+		};
+		this._adoptingWorkerPasses = true;
+		Promise.all([ask('running'), ask('pending')]).then(function (results: any[]) {
+			self._adoptingWorkerPasses = false;
+			// The chat may have changed under the query; adopting into another
+			// project's session is the cross-project bubble leak all over again.
+			var now = self.host.getIdentity();
+			if (now.serviceId !== svcId || now.platform !== platform) return;
+			if (!self.host.isViewMounted()) return;
+			var adoptedIds: string[] = [];
+			for (var ri = 0; ri < results.length; ri++) {
+				var list = results[ri] && Array.isArray(results[ri].list) ? results[ri].list : [];
+				for (var i = 0; i < list.length; i++) {
+					if (self._adoptWorkerIndexingItem(list[i], svcId, platform as 'claude' | 'openai')) adoptedIds.push(list[i].id);
+				}
+			}
+			if (adoptedIds.length) {
+				self.drainBgTaskQueue();
+				// Only an item the drain KEPT means the chain is still going. One it
+				// threw straight back out is not progress and must not end the ladder:
+				// the status index is eventually consistent, so a look taken the
+				// instant a pass settles can still report that pass as running, and a
+				// pass belonging to a file the user stopped is dropped on sight. Both
+				// used to read as "found the next pass", which ended the search for a
+				// pass that had not been written yet.
+				if (self._isTrackingAny(adoptedIds)) return;
+			}
+			// Nothing yet. The worker writes pass N+1 a few milliseconds AFTER it
+			// flips pass N to resolved, so a poll that lands in that gap sees an
+			// 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.
+			if (attempt + 1 >= WORKER_PASS_ADOPT_ATTEMPTS.length) return;
+			setTimeout(function () {
+				var later = self.host.getIdentity();
+				if (later.serviceId !== svcId || later.platform !== platform) return;
+				if (self.isPollingPaused() || !self.host.isViewMounted()) return;
+				self._adoptWorkerIndexingPasses(attempt + 1);
+			}, WORKER_PASS_ADOPT_ATTEMPTS[attempt + 1]);
+		}, function () { self._adoptingWorkerPasses = false; });
+	}
+
+	/** 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++) {
+			if (this.historyItemPolls.has(ids[i])) return true;
+			for (var q = 0; q < this.bgTaskQueue.length; q++) {
+				if (this.bgTaskQueue[q].id === ids[i]) return true;
+			}
+		}
+		return false;
+	}
+
+	/** One live bg-queue item -> a BgTaskEntry, if it is an indexing pass this
+	 *  client is not already tracking. Returns whether it was adopted. */
+	private _adoptWorkerIndexingItem(item: any, svcId: string, platform: 'claude' | 'openai'): boolean {
+		if (!item || typeof item.id !== 'string' || !item.id) return false;
+		if (item.status !== 'pending' && item.status !== 'running') return false;
+		if (typeof item.poll !== 'function') return false;
+		// Already known: a pass this client dispatched, or one adopted earlier that
+		// has not settled yet. Adopting twice would stack a second poll on one item.
+		if (this.historyItemPolls.has(item.id)) return false;
+		for (var q = 0; q < this.bgTaskQueue.length; q++) {
+			if (this.bgTaskQueue[q].id === item.id) return false;
+		}
+		// Already SETTLED here. The status index is eventually consistent, so the
+		// pass that just finished can still come back as running; re-adopting it
+		// would re-poll a dead item and, worse, read as the chain continuing.
+		for (var m = 0; m < this.state.messages.length; m++) {
+			var msg = this.state.messages[m];
+			if (msg._serverItemId !== item.id) continue;
+			if (!(msg.isPending || msg.isPendingInProcess || msg.isPendingQueued)) return false;
+		}
+		// The bg queue also carries ordinary chats routed onto it (_isOnBgQueue), and
+		// both platforms share one queue name, so check the shape as well: a claude
+		// request body has `messages`, an openai one has `input`. Adopting the other
+		// platform's item would poll it against this platform's url.
+		var body = item.request_body;
+		if (!body || typeof body !== 'object') return false;
+		if (platform === 'claude' ? !Array.isArray((body as any).messages) : !Array.isArray((body as any).input)) return false;
+		var userText = extractLastUserTextFromRequest(body);
+		if (!isIndexingRequestText(userText)) return false;
+		var ref = parseIndexingRequestText(userText);
+		if (!ref || !ref.name) return false;
+		// Only chains the worker drives. A client-driven file is already tracked by
+		// the entry that dispatched it, and adopting a copy of it would hand
+		// maybeResumeIndexing an entry whose resumePass no longer counts that
+		// chain's passes — which is the cap that stops it running forever.
+		if (!this._isWorkerDrivenIndexing(ref.name, ref.mime)) return false;
+		this.bgTaskQueue.push({
+			serviceId: svcId,
+			platform: platform,
+			id: item.id,
+			filename: ref.name,
+			storagePath: ref.path,
+			mime: ref.mime,
+			size: ref.size,
+			status: item.status === 'running' ? 'running' : 'pending',
+			poll: item.poll,
+			// Drives the "(continuing)" label and marks this as a continuation for
+			// _applyIndexCancellations, which must not read a CONTINUE pass as the
+			// fresh first pass that lifts a stop.
+			resumePass: ref.continued ? 1 : 0,
+		});
+		return true;
+	}
+
+	/** Follow the chain on from a background indexing pass that just settled. */
+	private _followWorkerIndexingChain(filename?: string, mime?: string): void {
+		if (!this._isWorkerDrivenIndexing(filename, mime)) return;
+		this._adoptWorkerIndexingPasses(0);
+	}
+
 	/** 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 {
@@ -1485,8 +1685,7 @@ export class ChatSession {
 			var chatList = history && Array.isArray(history.list) ? history.list : [];
 			chatList.forEach(function (item: any) {
 				if (isBgIndexingQueue(item.queue_name)) {
-					var userText = extractLastUserTextFromRequest(item.request_body);
-					if (typeof userText === 'string' && (userText.indexOf('A new file has just been uploaded') === 0 || userText.indexOf('CONTINUE indexing') === 0)) item._isBgTask = true;
+					if (isIndexingRequestText(extractLastUserTextFromRequest(item.request_body))) item._isBgTask = true;
 					else item._isOnBgQueue = true;
 				}
 			});