bunnyquery 1.6.0 → 1.6.2

package/package.json

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

package/src/engine/config.ts

@@ -33,6 +33,20 @@ export interface ChatEngineConfig {
      * `registerAttachmentParser()`. See attachment_parsers.ts.
      */
     attachmentParsers?: AttachmentParser[];
+    /**
+     * Opt in to SERVER-DRIVEN windowed indexing for text/grid files.
+     *
+     * Off by default, and deliberately so. When on, the client emits a
+     * `_skapi_window` directive and the WORKER reads the file one window at a time,
+     * continuing until the reader says it is exhausted. When off, the agent pages the
+     * file itself with readFileContent, exactly as before.
+     *
+     * The flag exists because the backend must ship FIRST: a client emitting the
+     * directive against a worker that does not strip it leaves an unknown field in the
+     * request body, and the provider rejects the whole call with no retry. Keep it off
+     * until the worker is deployed, then flip it per environment.
+     */
+    windowedIndexing?: boolean;
 }
 
 let _config: ChatEngineConfig | null = null;
@@ -53,6 +67,11 @@ export function chatEngineConfig(): ChatEngineConfig {
     return _config;
 }
 
+/** True when the consumer has opted in to server-driven windowed indexing. */
+export function windowedIndexingEnabled(): boolean {
+    return _config?.windowedIndexing === true;
+}
+
 /** Spread helper: `{ ...pollOpt() }` adds `poll` only when configured. */
 export function pollOpt(): { poll?: number } {
     const p = _config?.poll;

package/src/engine/host.ts

@@ -18,6 +18,18 @@ export interface ChatIdentity {
 	serviceDescription?: string;
 }
 
+/**
+ * Project context captured at the moment the user hit Send, so a turn whose
+ * dispatch is delayed (attachment uploads are awaited first) still reaches the
+ * project the question was asked of rather than whichever project the user has
+ * navigated to by then. Both fields are identity-derived and must be snapshotted
+ * together — the system prompt embeds the service name/description/id.
+ */
+export interface PinnedDispatchContext {
+	identity: ChatIdentity;
+	systemPrompt: string;
+}
+
 export interface ChatMessage {
 	role: 'user' | 'assistant';
 	content: string; // raw markdown — never HTML (the view parses for display)
@@ -34,6 +46,13 @@ export interface ChatMessage {
 	_localId?: string;
 	_cancelling?: boolean;
 	_cancelError?: string;
+	// History cache key (`serviceId#platform`) this bubble was created under.
+	// Stamped on LOCALLY-created bubbles only (the optimistic user message and
+	// its "Thinking..." placeholder); server-mapped bubbles are identified by
+	// _serverItemId instead. The dashboard renders every project through ONE
+	// ChatSession singleton, so without this a bubble is unattributable and an
+	// in-flight turn from project A gets rescued/cached into project B.
+	_ownerKey?: string;
 }
 
 export interface ChatState {

package/src/engine/index.ts

@@ -57,12 +57,13 @@ export {
 // Tier-2: the stateful chat orchestration (queue/poll/cancel, typewriter,
 // bg-task drain, resolution). DOM-free; the consumer implements ChatHost.
 export { ChatSession } from './session';
-export type { ChatHost, ChatIdentity, ChatState, ChatMessage } from './host';
+export type { ChatHost, ChatIdentity, ChatState, ChatMessage, PinnedDispatchContext } from './host';
 
 export {
 	// constants
 	POLL_INTERVAL,
 	BG_INDEXING_QUEUE_SUFFIX,
+	isBgIndexingQueue,
 	MCP_NAME,
 	DEFAULT_CLAUDE_MODEL,
 	DEFAULT_OPENAI_MODEL,

package/src/engine/office.ts

@@ -101,11 +101,32 @@ export function isServerExtractable(name?: string, mime?: string): boolean {
 /** @deprecated renamed to {@link isServerExtractable} (now also covers text files). */
 export const isOfficeFile = isServerExtractable;
 
-// Extensions that are best read WINDOW-BY-WINDOW via the readFileContent tool instead of
-// inlined once: spreadsheets (grid rows + embedded photos, and can be huge) and PDFs
-// (scanned page images). For these the indexing agent is told to page through the whole
-// file with readFileContent rather than reading a capped inline dump or web_fetching a URL.
-const PAGED_READ_EXTENSIONS = new Set(['xls', 'xlsx', 'xlsm', 'ods', 'pdf']);
+// Extensions read WINDOW-BY-WINDOW via the readFileContent tool instead of inlined once.
+//
+// Anything NOT in this set falls back to one-shot server extraction, which is capped at
+// MAX_EXTRACTED_CHARS (200k). Measured against real files, that cap was discarding the
+// overwhelming majority of every large non-spreadsheet upload:
+//   5MB .txt   -> 4.0% indexed (4.8M characters silently dropped)
+//   4.8MB .json-> 4.2%
+//   1.9M-char Korean .txt -> 10.5%
+//   .docx      -> 70.6%
+// The truncation was invisible: the agent received a plausible-looking document and had
+// no way to know most of it was missing. Windowing these types is what makes "index the
+// whole file" true rather than aspirational.
+//
+// CSV/TSV specifically must be here rather than in the inline path: the layer now gives
+// them ROW-bounded windows with absolute row numbers, where the character windower used
+// to split rows across boundaries and emit no row numbers at all.
+const PAGED_READ_EXTENSIONS = new Set([
+	// grids
+	'xls', 'xlsx', 'xlsm', 'ods',
+	// delimited text (row-windowed by the layer)
+	'csv', 'tsv', 'tab',
+	// documents
+	'pdf', 'docx', 'pptx',
+	// plain text / data / markup
+	'txt', 'md', 'markdown', 'log', 'json', 'jsonl', 'ndjson', 'xml', 'yaml', 'yml',
+]);
 
 /**
  * True when a file should be indexed by PAGING through readFileContent (spreadsheets and
@@ -160,6 +181,33 @@ export function makeRenderPlaceholder(seed: string): string {
 // resume window (from = pass * PAGES) lines up with what the worker renders.
 export const RENDER_PAGES_PER_WINDOW = 5;
 
+// Token the WORKER substitutes with a human description of the next window's position.
+// Shared with the render loop so one substitution path serves both.
+export const WINDOW_CURSOR_TOKEN = '{{RENDER_FROM}}';
+
+let _windowPlaceholderSeq = 0;
+
+/**
+ * Placeholder the worker replaces with ONE window of a file's text/grid content.
+ * Distinct token from the render (page-image) and extract (whole-file) placeholders so
+ * a stale token from either can never be mistaken for this one.
+ */
+export function makeWindowPlaceholder(seed: string): string {
+	_windowPlaceholderSeq += 1;
+	const slug = (seed || 'file').replace(/[^a-zA-Z0-9]+/g, '_').slice(-48);
+	return `{{SKAPI_WINDOW::${slug}-${_windowPlaceholderSeq}}}`;
+}
+
+/**
+ * True when a file should be read server-side, one window at a time, by the worker.
+ * PDFs are excluded: they go through the VISION path, where pages are rendered to
+ * images because their text layer is often absent or unreliable.
+ */
+export function isWindowedReadFile(name?: string, mime?: string): boolean {
+	if (isImageVisionFile(name, mime)) return false;
+	return isPagedReadFile(name, mime);
+}
+
 export interface ComposedUserMessage {
 	/** Clean display/history copy (attachment links, NO extraction placeholders). */
 	composed: string;

package/src/engine/prompts/index.ts

@@ -11,6 +11,9 @@ export {
 	buildIndexingUserMessage,
 	buildIndexingContinueMessage,
 	buildIndexingRenderMessage,
+	buildIndexingRenderContinueTemplate,
+	buildIndexingWindowMessage,
+	RENDER_FROM_TOKEN,
 	type IndexingAttachmentInfo,
 	type BuildIndexingUserMessageOptions,
 } from './indexing_user_message';

package/src/engine/prompts/indexing_user_message.ts

@@ -101,16 +101,29 @@ export function buildIndexingUserMessage(
 	return head + `- temporary URL (fetch this to read the file contents): ${attachment.url}`;
 }
 
+/**
+ * Token the WORKER substitutes with the 1-based first page of the window it is about to
+ * render, when it builds the next pass of a document from `RENDER_CONTINUE_TEMPLATE`.
+ * Must match the worker's RENDER_FROM_TOKEN.
+ */
+export const RENDER_FROM_TOKEN = '{{RENDER_FROM}}';
+const WINDOW_CURSOR_TOKEN = RENDER_FROM_TOKEN;
+
 /**
  * User message for a VISION file (PDF): its pages are delivered as RENDERED PAGE IMAGES that
  * the proxy worker injects into THIS message at the `placeholder` token (tool-result images
  * render on neither provider, so the pages must be image blocks in the message itself). Each
- * pass shows one WINDOW of pages starting at `renderFrom` (0-based); the resume loop advances
- * the window a pass at a time until the injected note says the last window was reached.
+ * pass shows one WINDOW of pages starting at `renderFrom` (0-based).
+ *
+ * The WORKER advances the window: when its renderer reports pages remaining it enqueues the
+ * next pass itself, off the true page count, so a document indexes end-to-end with no browser
+ * involved. This message therefore only ever describes ONE window, and the model is never
+ * asked to decide whether the document is finished.
  *
  * renderFrom === 0 is the FIRST pass (leads with "A new file has just been uploaded." so the
- * client builds the "Indexing: <name>" bubble); renderFrom > 0 is a RESUME pass (leads with
- * "CONTINUE indexing" like the paged continue message, so it is not a duplicate primary bubble).
+ * client builds the "Indexing: <name>" bubble); a continue pass (built by the worker from
+ * buildIndexingRenderContinueTemplate) leads with "CONTINUE indexing" so it is not a duplicate
+ * primary bubble.
  */
 export function buildIndexingRenderMessage(
 	attachment: IndexingAttachmentInfo,
@@ -118,44 +131,108 @@ export function buildIndexingRenderMessage(
 	renderFrom: number,
 ): string {
 	const from = Math.max(0, renderFrom || 0);
+	if (from > 0) return buildIndexingRenderContinueTemplate(attachment, placeholder, String(from + 1));
+
+	return (
+		`A new file has just been uploaded. Index it now.\n\n` +
+		buildRenderMeta(attachment) +
+		`\nThis is a PDF. Its pages are delivered to you as RENDERED PAGE IMAGES embedded directly in this ` +
+		`message (you do NOT need any tool, URL, or web_fetch to see them). You are shown a WINDOW of pages ` +
+		`at a time, starting at page ${from + 1}.\n` +
+		buildRenderDatafy(placeholder)
+	);
+}
+
+/**
+ * The CONTINUE pass, as a template the worker fills in. `pageLabel` defaults to the
+ * RENDER_FROM_TOKEN placeholder, which the worker replaces with the real 1-based start page
+ * of the window it is rendering; passing an explicit label produces a ready-to-send message.
+ */
+export function buildIndexingRenderContinueTemplate(
+	attachment: IndexingAttachmentInfo,
+	placeholder: string,
+	pageLabel: string = RENDER_FROM_TOKEN,
+): string {
 	const src = `src::${attachment.storagePath}`;
-	const meta =
+	return (
+		`CONTINUE indexing a PDF whose previous pass did not finish.\n\n` +
+		buildRenderMeta(attachment) +
+		`\nRecords for the earlier pages are ALREADY saved (they reference "${src}"). The NEXT window of ` +
+		`rendered page images (starting at page ${pageLabel}) is embedded in this message. Datafy each page as ` +
+		`before and do NOT re-save pages that are already saved.\n` +
+		buildRenderDatafy(placeholder)
+	);
+}
+
+function buildRenderMeta(attachment: IndexingAttachmentInfo): string {
+	return (
 		`File metadata:\n` +
 		`- name: ${attachment.name}\n` +
 		`- storage path: ${attachment.storagePath}\n` +
-		(attachment.mime ? `- mime type: ${attachment.mime}\n` : '');
+		(attachment.mime ? `- mime type: ${attachment.mime}\n` : '')
+	);
+}
 
-	// Shared datafy + completion guidance. The placeholder is where the worker splices the
-	// note + rendered page images; instructions reference "the page images in this message"
-	// so they read correctly whether the images land before or after this text.
-	const datafy =
+// Shared datafy guidance. The placeholder is where the worker splices the note + rendered
+// page images; instructions reference "the page images in this message" so they read
+// correctly whether the images land before or after this text.
+//
+// Deliberately says nothing about INDEXING_COMPLETE or about whether the document is
+// finished: the worker decides that from the renderer's page count. Asking the model was
+// what used to end an 88-page file at page 15.
+function buildRenderDatafy(placeholder: string): string {
+	return (
 		`\n${placeholder}\n\n` +
 		`LOOK at each rendered page image in this message and DATAFY what it shows: for EVERY page ` +
 		`call postRecords and save records - one record per row / table entry / line item visible on the page ` +
 		`(or one record for the page if it is prose), capturing every value you can read (OCR the text, read tables ` +
 		`cell by cell, describe any photos/diagrams). Use the storage path above for the "src::" unique_id.\n\n` +
-		`The note next to the images tells you whether MORE pages remain after this window. ` +
-		`If MORE remain: save this window's records and STOP - do NOT write INDEXING_COMPLETE; another pass shows the next window automatically. ` +
-		`Only when the note says this is the LAST window (you have seen the whole file) AND everything is saved, end your message with the token INDEXING_COMPLETE.`;
+		`Save records for THIS window of pages only, then stop and report what you saved. Do NOT try to read ` +
+		`the rest of the file and do NOT worry about the pages after this window: if any remain, the next window ` +
+		`is rendered and sent to you automatically. Report only the pages you were actually shown - never imply ` +
+		`you have seen the whole document.`
+	);
+}
 
-	if (from === 0) {
-		return (
-			`A new file has just been uploaded. Index it now.\n\n` +
-			meta +
-			`\nThis is a PDF. Its pages are delivered to you as RENDERED PAGE IMAGES embedded directly in this ` +
-			`message (you do NOT need any tool, URL, or web_fetch to see them). You are shown a WINDOW of pages ` +
-			`at a time, starting at page ${from + 1}.\n` +
-			datafy
-		);
-	}
+/**
+ * User message for a WINDOWED file: the worker splices ONE window of the file's rows or
+ * text into this message at `placeholder`, then continues from the reader's own cursor
+ * until the file is exhausted.
+ *
+ * The agent is deliberately NOT asked to page the file itself, and is NOT asked to judge
+ * whether it is finished. Both used to be its job, and both failed the same way: the
+ * traversal lived inside a single turn's budget, so a large file simply stopped partway
+ * with a confident summary of the part it had seen.
+ */
+export function buildIndexingWindowMessage(
+	attachment: IndexingAttachmentInfo,
+	placeholder: string,
+	isContinuation: boolean,
+	positionLabel?: string,
+): string {
+	const src = `src::${attachment.storagePath}`;
+	const head = isContinuation
+		? `CONTINUE indexing a file whose previous pass did not finish.\n\n`
+		: `A new file has just been uploaded. Index it now.\n\n`;
+	const where = isContinuation
+		? `\nRecords for the earlier windows are ALREADY saved (they reference "${src}"). The NEXT window ` +
+		  `(starting at ${positionLabel || WINDOW_CURSOR_TOKEN}) is embedded below. Do NOT re-save windows that are already saved.\n`
+		: `\nThis file is delivered to you ONE WINDOW at a time, embedded directly in this message. ` +
+		  `You do NOT need any tool, URL, or web_fetch to read it.\n`;
 
 	return (
-		`CONTINUE indexing a PDF whose previous pass did not finish.\n\n` +
-		meta +
-		`\nRecords for the earlier pages are ALREADY saved (they reference "${src}"). The NEXT window of ` +
-		`rendered page images (starting at page ${from + 1}) is embedded in this message. Datafy each page as ` +
-		`before and do NOT re-save pages that are already saved.\n` +
-		datafy
+		head +
+		buildRenderMeta(attachment) +
+		where +
+		`\n${placeholder}\n\n` +
+		`DATAFY this window: call postRecords and save records for everything in it - ONE RECORD PER ROW ` +
+		`for tabular data (keyed by the column headers), or one record per section for prose. Capture every ` +
+		`value you can read. Use the storage path above for the "src::" unique_id on the file-level record, ` +
+		`and link every row/section record to it by reference.\n\n` +
+		`Save records for THIS window only, then stop and report what you saved. Do NOT try to read the rest ` +
+		`of the file, and do NOT call readFileContent - if more remains, the next window is read and sent to ` +
+		`you automatically. Report only what you were actually shown, and never imply you have seen the whole ` +
+		`file when the note beside the window says more remains.`
 	);
 }
 

package/src/engine/requests.ts

@@ -10,9 +10,9 @@
  *                                    state that stays in the consumer, not here;
  *                                    only the BgTaskEntry TYPE lives here)
  */
-import { buildIndexingSystemPrompt, buildIndexingUserMessage, buildIndexingContinueMessage, buildIndexingRenderMessage } from './prompts';
-import { isServerExtractable, isPagedReadFile, isImageVisionFile, makeExtractPlaceholder, makeRenderPlaceholder, RENDER_PAGES_PER_WINDOW, type ExtractDirective, type FileUrlDirective } from './office';
-import { chatEngineConfig, pollOpt } from './config';
+import { buildIndexingSystemPrompt, buildIndexingUserMessage, buildIndexingContinueMessage, buildIndexingRenderMessage, buildIndexingRenderContinueTemplate, buildIndexingWindowMessage } from './prompts';
+import { isServerExtractable, isPagedReadFile, isImageVisionFile, isWindowedReadFile, makeExtractPlaceholder, makeRenderPlaceholder, makeWindowPlaceholder, RENDER_PAGES_PER_WINDOW, type ExtractDirective, type FileUrlDirective } from './office';
+import { chatEngineConfig, pollOpt, windowedIndexingEnabled } from './config';
 
 export const ANTHROPIC_MESSAGES_API_URL = 'https://api.anthropic.com/v1/messages';
 const ANTHROPIC_MODELS_API_URL = 'https://api.anthropic.com/v1/models';
@@ -38,25 +38,47 @@ export const DEFAULT_OPENAI_MODEL = 'gpt-5.4';
 const mcpUrl = () => chatEngineConfig().mcpBaseUrl;
 const clientSecretRequest = (opts: any) => chatEngineConfig().clientSecretRequest(opts);
 
+// Resolve the per-image `detail` for OpenAI. The version match tolerates a
+// trailing variant/date suffix (`gpt-5.4-nano`, `-mini`, `-2026-01-01`, …):
+// previously the pattern was anchored with no suffix allowed, so EVERY suffixed
+// model silently fell through to 'auto' — i.e. the cheap tiers that most need
+// resolution were the ones getting downsampled images.
+//
+// Base models keep their exact previous behavior ('original'). A suffixed
+// variant resolves to 'high' rather than 'original': 'high' is the universally
+// supported value, and we have no way to confirm a given variant accepts
+// 'original' — sending an unsupported value would fail the whole request, which
+// is far worse than a slightly less detailed image.
 const getOpenAIImageDetail = (model?: string) => {
 	const normalized = (model || DEFAULT_OPENAI_MODEL).trim().toLowerCase();
-	const match = normalized.match(/^gpt-(\d+)(?:\.(\d+))?$/);
+	const match = normalized.match(/^gpt-(\d+)(?:\.(\d+))?(-[a-z0-9.\-]+)?$/);
 	if (!match) {
 		return DEFAULT_OPENAI_IMAGE_DETAIL;
 	}
 
 	const major = Number(match[1]);
 	const minor = match[2] === undefined ? null : Number(match[2]);
+	const isVariant = !!match[3];
 
-	if (major > 5) {
-		return 'original';
+	const supportsOriginal = major > 5 || (major === 5 && minor !== null && minor >= 4);
+	if (!supportsOriginal) {
+		return DEFAULT_OPENAI_IMAGE_DETAIL;
 	}
 
-	if (major === 5 && minor !== null && minor >= 4) {
-		return 'original';
-	}
+	return isVariant ? 'high' : 'original';
+};
 
-	return DEFAULT_OPENAI_IMAGE_DETAIL;
+// Per-image `detail` for WORKER-RENDERED document pages (the `_skapi_render`
+// path). Same resolution as above with one difference: these are dense scans
+// whose entire purpose is to be read, so 'auto' is never acceptable — it lets
+// the API downsample exactly the pixels the model needs to OCR. Floor it at
+// 'high'; models that support full-resolution 'original' still get it.
+//
+// Without this the worker falls back to its own model-blind default ('high'),
+// which silently denies the strongest models the 'original' detail they support.
+const getRenderImageDetail = (model?: string) => {
+	const detail = getOpenAIImageDetail(model);
+	return detail === DEFAULT_OPENAI_IMAGE_DETAIL ? 'high' : detail;
 };
 
 export type ClaudeRole = 'user' | 'assistant';
@@ -478,20 +500,66 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 	const visionFile = !parsedContent && isImageVisionFile(attachment.name, attachment.mime);
 	const renderFrom = Math.max(0, info.renderFrom || 0);
 	const renderPlaceholder = visionFile ? makeRenderPlaceholder(attachment.storagePath) : undefined;
+	// Tell the worker what image `detail` to stamp on the injected page blocks.
+	// The worker is model-blind, so without this it applies a one-size default and
+	// the strongest models never get the 'original' detail they support. Only
+	// meaningful for OpenAI — Claude has no per-image detail knob and the worker
+	// ignores the field for it.
+	const renderDetail = platform === 'openai'
+		? getRenderImageDetail(info.model || DEFAULT_OPENAI_MODEL)
+		: undefined;
+	// `auto_continue` + `continue_text` hand the page loop to the WORKER: when its renderer
+	// reports pages left after this window, it builds the next pass from this template
+	// (substituting the window's 1-based start page for RENDER_FROM_TOKEN) and enqueues it
+	// itself. That is what makes a 500-page document index end-to-end — the loop no longer
+	// depends on the tab staying open, nor on the model correctly declaring itself unfinished.
 	const skapiRender = visionFile && renderPlaceholder
 		? {
 			_skapi_render: [
-				{ path: attachment.storagePath, from: renderFrom, count: RENDER_PAGES_PER_WINDOW, placeholder: renderPlaceholder, name: attachment.name, mime: attachment.mime },
+				{
+					path: attachment.storagePath, from: renderFrom, count: RENDER_PAGES_PER_WINDOW,
+					placeholder: renderPlaceholder, name: attachment.name, mime: attachment.mime, detail: renderDetail,
+					auto_continue: true,
+					continue_text: buildIndexingRenderContinueTemplate(attachment, renderPlaceholder),
+				},
+			],
+		}
+		: {};
+
+	// SERVER-DRIVEN windowed read. When enabled, the worker reads one window of the file
+	// per request and continues from the reader's own cursor until the file is exhausted,
+	// so the traversal no longer lives inside the model's turn budget.
+	//
+	// Flag-gated because the BACKEND MUST SHIP FIRST: against a worker that does not strip
+	// `_skapi_window`, the directive reaches the provider as an unknown body field and the
+	// call fails terminally with no retry.
+	const windowedRead =
+		!visionFile && !parsedContent && windowedIndexingEnabled() &&
+		isWindowedReadFile(attachment.name, attachment.mime);
+	const windowPlaceholder = windowedRead ? makeWindowPlaceholder(attachment.storagePath) : undefined;
+	const skapiWindow = windowedRead && windowPlaceholder
+		? {
+			_skapi_window: [
+				{
+					path: attachment.storagePath,
+					cursor: null,
+					placeholder: windowPlaceholder,
+					name: attachment.name,
+					mime: attachment.mime,
+					kind: 'window',
+					auto_continue: true,
+					continue_text: buildIndexingWindowMessage(attachment, windowPlaceholder, true),
+				},
 			],
 		}
 		: {};
 
 	// Spreadsheets are read by PAGING through readFileContent (grid rows), NOT inlined - so
 	// they skip the inline server-extract and the agent is told to page the whole file.
-	const pagedRead = !visionFile && (continuing || (!parsedContent && isPagedReadFile(attachment.name, attachment.mime)));
+	const pagedRead = !visionFile && !windowedRead && (continuing || (!parsedContent && isPagedReadFile(attachment.name, attachment.mime)));
 
 	// Client-parsed content wins over server-side extraction.
-	const serverExtract = !visionFile && !continuing && !parsedContent && !pagedRead && isServerExtractable(attachment.name, attachment.mime);
+	const serverExtract = !visionFile && !windowedRead && !continuing && !parsedContent && !pagedRead && isServerExtractable(attachment.name, attachment.mime);
 	const placeholder = serverExtract ? makeExtractPlaceholder(attachment.storagePath) : undefined;
 	const extractContent: ExtractDirective[] | undefined =
 		serverExtract && placeholder
@@ -502,6 +570,8 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 
 	const userMessage = (visionFile && renderPlaceholder)
 		? buildIndexingRenderMessage(attachment, renderPlaceholder, renderFrom)
+		: (windowedRead && windowPlaceholder)
+		? buildIndexingWindowMessage(attachment, windowPlaceholder, false)
 		: continuing
 			? buildIndexingContinueMessage(attachment)
 			: buildIndexingUserMessage(
@@ -541,6 +611,7 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 				max_output_tokens: MAX_TOKENS,
 				...skapiExtract,
 				...skapiRender,
+				...skapiWindow,
 				input: [
 					{ role: 'system', content: systemPrompt },
 					{
@@ -589,6 +660,7 @@ export async function notifyAgentSaveAttachment(info: AttachmentSaveInfo) {
 			max_tokens: MAX_TOKENS,
 			...skapiExtract,
 			...skapiRender,
+			...skapiWindow,
 			system: [
 				{
 					type: 'text',
@@ -713,6 +785,23 @@ export async function listOpenAIModels(service: string, owner: string) {
 // so the chat-history BETWEEN query never includes bg-queue items. '-' (45) works.
 export const BG_INDEXING_QUEUE_SUFFIX = '-bg';
 
+/**
+ * True when a request belongs to the background-indexing queue.
+ *
+ * Accepts BOTH shapes this value arrives in: the bare queue name the client sends
+ * ("<userId>-bg"), and the server qid that comes back on history/poll responses
+ * ("<service>:<queue>|<seq>"). Testing the tail of the raw value only works for the
+ * first: a qid ends in "|<seq>", so `endsWith('-bg')` is always false for it — which
+ * silently meant history items were NEVER recognised as background tasks.
+ */
+export function isBgIndexingQueue(queueName?: string): boolean {
+	if (typeof queueName !== 'string' || !queueName) return false;
+	const prefix = queueName.split('|')[0];
+	const idx = prefix.lastIndexOf(':');
+	const name = idx === -1 ? prefix : prefix.slice(idx + 1);
+	return name.slice(-BG_INDEXING_QUEUE_SUFFIX.length) === BG_INDEXING_QUEUE_SUFFIX;
+}
+
 // Pending background-indexing task descriptor. NOTE: the live mutable queue
 // (a Vue `reactive([])` in agent.vue, a plain array in bunnyquery) is app-level
 // state owned by the consumer — only the TYPE lives in the engine.
@@ -733,18 +822,16 @@ export type BgTaskEntry = {
 
 // Token the indexing agent appends to its final message ONLY when it has fully read and
 // saved the whole file. Its ABSENCE is what tells the client to run another CONTINUE pass.
+//
+// Applies to the TEXT/GRID paging path only. The vision path (rendered PDF pages) no longer
+// asks the model whether it is finished — the worker advances that loop off the renderer's
+// page count — so this marker has no say in whether a PDF keeps going.
 export const INDEXING_COMPLETE_MARKER = 'INDEXING_COMPLETE';
 // Cap on CONTINUE passes per file, so a file the agent can never mark complete (or a
 // pathological loop) stops instead of re-dispatching forever. The text/grid paging path
 // reads MANY windows within a single pass (the agent loops readFileContent in one turn), so
 // a small cap suffices.
 export const MAX_INDEXING_RESUME_PASSES = 6;
-// The VISION path (rendered PDF pages) can only advance ONE page-window per pass, because the
-// worker injects a single window of images into each request. A big scanned PDF therefore
-// needs one pass PER window (pages / RENDER_PAGES_PER_WINDOW), so it gets a much higher cap.
-// The loop still terminates naturally when the agent reaches the last window (it appends
-// INDEXING_COMPLETE); this cap is only the backstop for a doc larger than it covers.
-export const MAX_VISION_RESUME_PASSES = 40;
 
 export async function getChatHistory(
 	params: { service?: string; owner?: string; platform: 'claude' | 'openai'; queue?: string },