@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/services/PromptSuggestion/speculation.js

@@ -0,0 +1,643 @@
+import { randomUUID } from 'crypto';
+import { rm } from 'fs';
+import { appendFile, copyFile, mkdir } from 'fs/promises';
+import { dirname, isAbsolute, join, relative } from 'path';
+import { getCwdState } from '../../bootstrap/state.js';
+import { IDLE_SPECULATION_STATE, } from '../../state/AppStateStore.js';
+import { commandHasAnyCd } from '../../tools/BashTool/bashPermissions.js';
+import { checkReadOnlyConstraints } from '../../tools/BashTool/readOnlyValidation.js';
+import { createChildAbortController } from '../../utils/abortController.js';
+import { count } from '../../utils/array.js';
+import { getGlobalConfig } from '../../utils/config.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { errorMessage } from '../../utils/errors.js';
+import { mergeFileStateCaches, READ_FILE_STATE_CACHE_SIZE, } from '../../utils/fileStateCache.js';
+import { createCacheSafeParams, runForkedAgent, } from '../../utils/forkedAgent.js';
+import { formatDuration, formatNumber } from '../../utils/format.js';
+import { logError } from '../../utils/log.js';
+import { createSystemMessage, createUserMessage, INTERRUPT_MESSAGE, INTERRUPT_MESSAGE_FOR_TOOL_USE, } from '../../utils/messages.js';
+import { getClaudeTempDir } from '../../utils/permissions/filesystem.js';
+import { extractReadFilesFromMessages } from '../../utils/queryHelpers.js';
+import { getTranscriptPath } from '../../utils/sessionStorage.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+import { logEvent, } from '../analytics/index.js';
+import { generateSuggestion, getPromptVariant, getSuggestionSuppressReason, logSuggestionSuppressed, shouldFilterSuggestion, } from './promptSuggestion.js';
+const MAX_SPECULATION_TURNS = 20;
+const MAX_SPECULATION_MESSAGES = 100;
+const WRITE_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit']);
+const SAFE_READ_ONLY_TOOLS = new Set([
+    'Read',
+    'Glob',
+    'Grep',
+    'ToolSearch',
+    'LSP',
+    'TaskGet',
+    'TaskList',
+]);
+function safeRemoveOverlay(overlayPath) {
+    rm(overlayPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }, () => { });
+}
+function getOverlayPath(id) {
+    return join(getClaudeTempDir(), 'speculation', String(process.pid), id);
+}
+function denySpeculation(message, reason) {
+    return {
+        behavior: 'deny',
+        message,
+        decisionReason: { type: 'other', reason },
+    };
+}
+async function copyOverlayToMain(overlayPath, writtenPaths, cwd) {
+    let allCopied = true;
+    for (const rel of writtenPaths) {
+        const src = join(overlayPath, rel);
+        const dest = join(cwd, rel);
+        try {
+            await mkdir(dirname(dest), { recursive: true });
+            await copyFile(src, dest);
+        }
+        catch {
+            allCopied = false;
+            logForDebugging(`[Speculation] Failed to copy ${rel} to main`);
+        }
+    }
+    return allCopied;
+}
+function logSpeculation(id, outcome, startTime, suggestionLength, messages, boundary, extras) {
+    logEvent('tengu_speculation', {
+        speculation_id: id,
+        outcome: outcome,
+        duration_ms: Date.now() - startTime,
+        suggestion_length: suggestionLength,
+        tools_executed: countToolsInMessages(messages),
+        completed: boundary !== null,
+        boundary_type: boundary?.type,
+        boundary_tool: getBoundaryTool(boundary),
+        boundary_detail: getBoundaryDetail(boundary),
+        ...extras,
+    });
+}
+function countToolsInMessages(messages) {
+    const blocks = messages
+        .filter(isUserMessageWithArrayContent)
+        .flatMap(m => m.message.content)
+        .filter((b) => typeof b === 'object' && b !== null && 'type' in b);
+    return count(blocks, b => b.type === 'tool_result' && !b.is_error);
+}
+function getBoundaryTool(boundary) {
+    if (!boundary)
+        return undefined;
+    switch (boundary.type) {
+        case 'bash':
+            return 'Bash';
+        case 'edit':
+        case 'denied_tool':
+            return boundary.toolName;
+        case 'complete':
+            return undefined;
+    }
+}
+function getBoundaryDetail(boundary) {
+    if (!boundary)
+        return undefined;
+    switch (boundary.type) {
+        case 'bash':
+            return boundary.command.slice(0, 200);
+        case 'edit':
+            return boundary.filePath;
+        case 'denied_tool':
+            return boundary.detail;
+        case 'complete':
+            return undefined;
+    }
+}
+function isUserMessageWithArrayContent(m) {
+    return m.type === 'user' && 'message' in m && Array.isArray(m.message.content);
+}
+export function prepareMessagesForInjection(messages) {
+    const isToolResult = (b) => typeof b === 'object' &&
+        b !== null &&
+        b.type === 'tool_result' &&
+        typeof b.tool_use_id === 'string';
+    const isSuccessful = (b) => !b.is_error &&
+        !(typeof b.content === 'string' &&
+            b.content.includes(INTERRUPT_MESSAGE_FOR_TOOL_USE));
+    const toolIdsWithSuccessfulResults = new Set(messages
+        .filter(isUserMessageWithArrayContent)
+        .flatMap(m => m.message.content)
+        .filter(isToolResult)
+        .filter(isSuccessful)
+        .map(b => b.tool_use_id));
+    const keep = (b) => b.type !== 'thinking' &&
+        b.type !== 'redacted_thinking' &&
+        !(b.type === 'tool_use' && !toolIdsWithSuccessfulResults.has(b.id)) &&
+        !(b.type === 'tool_result' &&
+            !toolIdsWithSuccessfulResults.has(b.tool_use_id)) &&
+        // Abort during speculation yields a standalone interrupt user message
+        // (query.ts createUserInterruptionMessage). Strip it so it isn't surfaced
+        // to the model as real user input.
+        !(b.type === 'text' &&
+            (b.text === INTERRUPT_MESSAGE ||
+                b.text === INTERRUPT_MESSAGE_FOR_TOOL_USE));
+    return messages
+        .map(msg => {
+        if (!('message' in msg) || !Array.isArray(msg.message.content))
+            return msg;
+        const content = msg.message.content.filter(keep);
+        if (content.length === msg.message.content.length)
+            return msg;
+        if (content.length === 0)
+            return null;
+        // Drop messages where all remaining blocks are whitespace-only text
+        // (API rejects these with 400: "text content blocks must contain non-whitespace text")
+        const hasNonWhitespaceContent = content.some((b) => b.type !== 'text' || (b.text !== undefined && b.text.trim() !== ''));
+        if (!hasNonWhitespaceContent)
+            return null;
+        return { ...msg, message: { ...msg.message, content } };
+    })
+        .filter((m) => m !== null);
+}
+function createSpeculationFeedbackMessage(messages, boundary, timeSavedMs, sessionTotalMs) {
+    if (process.env.USER_TYPE !== 'ant')
+        return null;
+    if (messages.length === 0 || timeSavedMs === 0)
+        return null;
+    const toolUses = countToolsInMessages(messages);
+    const tokens = boundary?.type === 'complete' ? boundary.outputTokens : null;
+    const parts = [];
+    if (toolUses > 0) {
+        parts.push(`Speculated ${toolUses} tool ${toolUses === 1 ? 'use' : 'uses'}`);
+    }
+    else {
+        const turns = messages.length;
+        parts.push(`Speculated ${turns} ${turns === 1 ? 'turn' : 'turns'}`);
+    }
+    if (tokens !== null) {
+        parts.push(`${formatNumber(tokens)} tokens`);
+    }
+    const savedText = `+${formatDuration(timeSavedMs)} saved`;
+    const sessionSuffix = sessionTotalMs !== timeSavedMs
+        ? ` (${formatDuration(sessionTotalMs)} this session)`
+        : '';
+    return createSystemMessage(`[ANT-ONLY] ${parts.join(' · ')} · ${savedText}${sessionSuffix}`, 'warning');
+}
+function updateActiveSpeculationState(setAppState, updater) {
+    setAppState(prev => {
+        if (prev.speculation.status !== 'active')
+            return prev;
+        const current = prev.speculation;
+        const updates = updater(current);
+        // Check if any values actually changed to avoid unnecessary re-renders
+        const hasChanges = Object.entries(updates).some(([key, value]) => current[key] !== value);
+        if (!hasChanges)
+            return prev;
+        return {
+            ...prev,
+            speculation: { ...current, ...updates },
+        };
+    });
+}
+function resetSpeculationState(setAppState) {
+    setAppState(prev => {
+        if (prev.speculation.status === 'idle')
+            return prev;
+        return { ...prev, speculation: IDLE_SPECULATION_STATE };
+    });
+}
+export function isSpeculationEnabled() {
+    const enabled = process.env.USER_TYPE === 'ant' &&
+        (getGlobalConfig().speculationEnabled ?? true);
+    logForDebugging(`[Speculation] enabled=${enabled}`);
+    return enabled;
+}
+async function generatePipelinedSuggestion(context, suggestionText, speculatedMessages, setAppState, parentAbortController) {
+    try {
+        const appState = context.toolUseContext.getAppState();
+        const suppressReason = getSuggestionSuppressReason(appState);
+        if (suppressReason) {
+            logSuggestionSuppressed(`pipeline_${suppressReason}`);
+            return;
+        }
+        const augmentedContext = {
+            ...context,
+            messages: [
+                ...context.messages,
+                createUserMessage({ content: suggestionText }),
+                ...speculatedMessages,
+            ],
+        };
+        const pipelineAbortController = createChildAbortController(parentAbortController);
+        if (pipelineAbortController.signal.aborted)
+            return;
+        const promptId = getPromptVariant();
+        const { suggestion, generationRequestId } = await generateSuggestion(pipelineAbortController, promptId, createCacheSafeParams(augmentedContext));
+        if (pipelineAbortController.signal.aborted)
+            return;
+        if (shouldFilterSuggestion(suggestion, promptId))
+            return;
+        logForDebugging(`[Speculation] Pipelined suggestion: "${suggestion.slice(0, 50)}..."`);
+        updateActiveSpeculationState(setAppState, () => ({
+            pipelinedSuggestion: {
+                text: suggestion,
+                promptId,
+                generationRequestId,
+            },
+        }));
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError')
+            return;
+        logForDebugging(`[Speculation] Pipelined suggestion failed: ${errorMessage(error)}`);
+    }
+}
+export async function startSpeculation(suggestionText, context, setAppState, isPipelined = false, cacheSafeParams) {
+    if (!isSpeculationEnabled())
+        return;
+    // Abort any existing speculation before starting a new one
+    abortSpeculation(setAppState);
+    const id = randomUUID().slice(0, 8);
+    const abortController = createChildAbortController(context.toolUseContext.abortController);
+    if (abortController.signal.aborted)
+        return;
+    const startTime = Date.now();
+    const messagesRef = { current: [] };
+    const writtenPathsRef = { current: new Set() };
+    const overlayPath = getOverlayPath(id);
+    const cwd = getCwdState();
+    try {
+        await mkdir(overlayPath, { recursive: true });
+    }
+    catch {
+        logForDebugging('[Speculation] Failed to create overlay directory');
+        return;
+    }
+    const contextRef = { current: context };
+    setAppState(prev => ({
+        ...prev,
+        speculation: {
+            status: 'active',
+            id,
+            abort: () => abortController.abort(),
+            startTime,
+            messagesRef,
+            writtenPathsRef,
+            boundary: null,
+            suggestionLength: suggestionText.length,
+            toolUseCount: 0,
+            isPipelined,
+            contextRef,
+        },
+    }));
+    logForDebugging(`[Speculation] Starting speculation ${id}`);
+    try {
+        const result = await runForkedAgent({
+            promptMessages: [createUserMessage({ content: suggestionText })],
+            cacheSafeParams: cacheSafeParams ?? createCacheSafeParams(context),
+            skipTranscript: true,
+            canUseTool: async (tool, input) => {
+                const isWriteTool = WRITE_TOOLS.has(tool.name);
+                const isSafeReadOnlyTool = SAFE_READ_ONLY_TOOLS.has(tool.name);
+                // Check permission mode BEFORE allowing file edits
+                if (isWriteTool) {
+                    const appState = context.toolUseContext.getAppState();
+                    const { mode, isBypassPermissionsModeAvailable } = appState.toolPermissionContext;
+                    const canAutoAcceptEdits = mode === 'acceptEdits' ||
+                        mode === 'bypassPermissions' ||
+                        (mode === 'plan' && isBypassPermissionsModeAvailable);
+                    if (!canAutoAcceptEdits) {
+                        logForDebugging(`[Speculation] Stopping at file edit: ${tool.name}`);
+                        const editPath = ('file_path' in input ? input.file_path : undefined);
+                        updateActiveSpeculationState(setAppState, () => ({
+                            boundary: {
+                                type: 'edit',
+                                toolName: tool.name,
+                                filePath: editPath ?? '',
+                                completedAt: Date.now(),
+                            },
+                        }));
+                        abortController.abort();
+                        return denySpeculation('Speculation paused: file edit requires permission', 'speculation_edit_boundary');
+                    }
+                }
+                // Handle file path rewriting for overlay isolation
+                if (isWriteTool || isSafeReadOnlyTool) {
+                    const pathKey = 'notebook_path' in input
+                        ? 'notebook_path'
+                        : 'path' in input
+                            ? 'path'
+                            : 'file_path';
+                    const filePath = input[pathKey];
+                    if (filePath) {
+                        const rel = relative(cwd, filePath);
+                        if (isAbsolute(rel) || rel.startsWith('..')) {
+                            if (isWriteTool) {
+                                logForDebugging(`[Speculation] Denied ${tool.name}: path outside cwd: ${filePath}`);
+                                return denySpeculation('Write outside cwd not allowed during speculation', 'speculation_write_outside_root');
+                            }
+                            return {
+                                behavior: 'allow',
+                                updatedInput: input,
+                                decisionReason: {
+                                    type: 'other',
+                                    reason: 'speculation_read_outside_root',
+                                },
+                            };
+                        }
+                        if (isWriteTool) {
+                            // Copy-on-write: copy original to overlay if not yet there
+                            if (!writtenPathsRef.current.has(rel)) {
+                                const overlayFile = join(overlayPath, rel);
+                                await mkdir(dirname(overlayFile), { recursive: true });
+                                try {
+                                    await copyFile(join(cwd, rel), overlayFile);
+                                }
+                                catch {
+                                    // Original may not exist (new file creation) - that's fine
+                                }
+                                writtenPathsRef.current.add(rel);
+                            }
+                            input = { ...input, [pathKey]: join(overlayPath, rel) };
+                        }
+                        else {
+                            // Read: redirect to overlay if file was previously written
+                            if (writtenPathsRef.current.has(rel)) {
+                                input = { ...input, [pathKey]: join(overlayPath, rel) };
+                            }
+                            // Otherwise read from main (no rewrite)
+                        }
+                        logForDebugging(`[Speculation] ${isWriteTool ? 'Write' : 'Read'} ${filePath} -> ${input[pathKey]}`);
+                        return {
+                            behavior: 'allow',
+                            updatedInput: input,
+                            decisionReason: {
+                                type: 'other',
+                                reason: 'speculation_file_access',
+                            },
+                        };
+                    }
+                    // Read tools without explicit path (e.g. Glob/Grep defaulting to CWD) are safe
+                    if (isSafeReadOnlyTool) {
+                        return {
+                            behavior: 'allow',
+                            updatedInput: input,
+                            decisionReason: {
+                                type: 'other',
+                                reason: 'speculation_read_default_cwd',
+                            },
+                        };
+                    }
+                    // Write tools with undefined path → fall through to default deny
+                }
+                // Stop at non-read-only bash commands
+                if (tool.name === 'Bash') {
+                    const command = 'command' in input && typeof input.command === 'string'
+                        ? input.command
+                        : '';
+                    if (!command ||
+                        checkReadOnlyConstraints({ command }, commandHasAnyCd(command))
+                            .behavior !== 'allow') {
+                        logForDebugging(`[Speculation] Stopping at bash: ${command.slice(0, 50) || 'missing command'}`);
+                        updateActiveSpeculationState(setAppState, () => ({
+                            boundary: { type: 'bash', command, completedAt: Date.now() },
+                        }));
+                        abortController.abort();
+                        return denySpeculation('Speculation paused: bash boundary', 'speculation_bash_boundary');
+                    }
+                    // Read-only bash command — allow during speculation
+                    return {
+                        behavior: 'allow',
+                        updatedInput: input,
+                        decisionReason: {
+                            type: 'other',
+                            reason: 'speculation_readonly_bash',
+                        },
+                    };
+                }
+                // Deny all other tools by default
+                logForDebugging(`[Speculation] Stopping at denied tool: ${tool.name}`);
+                const detail = String(('url' in input && input.url) ||
+                    ('file_path' in input && input.file_path) ||
+                    ('path' in input && input.path) ||
+                    ('command' in input && input.command) ||
+                    '').slice(0, 200);
+                updateActiveSpeculationState(setAppState, () => ({
+                    boundary: {
+                        type: 'denied_tool',
+                        toolName: tool.name,
+                        detail,
+                        completedAt: Date.now(),
+                    },
+                }));
+                abortController.abort();
+                return denySpeculation(`Tool ${tool.name} not allowed during speculation`, 'speculation_unknown_tool');
+            },
+            querySource: 'speculation',
+            forkLabel: 'speculation',
+            maxTurns: MAX_SPECULATION_TURNS,
+            overrides: { abortController, requireCanUseTool: true },
+            onMessage: msg => {
+                if (msg.type === 'assistant' || msg.type === 'user') {
+                    messagesRef.current.push(msg);
+                    if (messagesRef.current.length >= MAX_SPECULATION_MESSAGES) {
+                        abortController.abort();
+                    }
+                    if (isUserMessageWithArrayContent(msg)) {
+                        const newTools = count(msg.message.content, b => b.type === 'tool_result' && !b.is_error);
+                        if (newTools > 0) {
+                            updateActiveSpeculationState(setAppState, prev => ({
+                                toolUseCount: prev.toolUseCount + newTools,
+                            }));
+                        }
+                    }
+                }
+            },
+        });
+        if (abortController.signal.aborted)
+            return;
+        updateActiveSpeculationState(setAppState, () => ({
+            boundary: {
+                type: 'complete',
+                completedAt: Date.now(),
+                outputTokens: result.totalUsage.output_tokens,
+            },
+        }));
+        logForDebugging(`[Speculation] Complete: ${countToolsInMessages(messagesRef.current)} tools`);
+        // Pipeline: generate the next suggestion while we wait for the user to accept
+        void generatePipelinedSuggestion(contextRef.current, suggestionText, messagesRef.current, setAppState, abortController);
+    }
+    catch (error) {
+        abortController.abort();
+        if (error instanceof Error && error.name === 'AbortError') {
+            safeRemoveOverlay(overlayPath);
+            resetSpeculationState(setAppState);
+            return;
+        }
+        safeRemoveOverlay(overlayPath);
+        // eslint-disable-next-line no-restricted-syntax -- custom fallback message, not toError(e)
+        logError(error instanceof Error ? error : new Error('Speculation failed'));
+        logSpeculation(id, 'error', startTime, suggestionText.length, messagesRef.current, null, {
+            error_type: error instanceof Error ? error.name : 'Unknown',
+            error_message: errorMessage(error).slice(0, 200),
+            error_phase: 'start',
+            is_pipelined: isPipelined,
+        });
+        resetSpeculationState(setAppState);
+    }
+}
+export async function acceptSpeculation(state, setAppState, cleanMessageCount) {
+    if (state.status !== 'active')
+        return null;
+    const { id, messagesRef, writtenPathsRef, abort, startTime, suggestionLength, isPipelined, } = state;
+    const messages = messagesRef.current;
+    const overlayPath = getOverlayPath(id);
+    const acceptedAt = Date.now();
+    abort();
+    if (cleanMessageCount > 0) {
+        await copyOverlayToMain(overlayPath, writtenPathsRef.current, getCwdState());
+    }
+    safeRemoveOverlay(overlayPath);
+    // Use snapshot boundary as default (available since state.status === 'active' was checked above)
+    let boundary = state.boundary;
+    let timeSavedMs = Math.min(acceptedAt, boundary?.completedAt ?? Infinity) - startTime;
+    setAppState(prev => {
+        // Refine with latest React state if speculation is still active
+        if (prev.speculation.status === 'active' && prev.speculation.boundary) {
+            boundary = prev.speculation.boundary;
+            const endTime = Math.min(acceptedAt, boundary.completedAt ?? Infinity);
+            timeSavedMs = endTime - startTime;
+        }
+        return {
+            ...prev,
+            speculation: IDLE_SPECULATION_STATE,
+            speculationSessionTimeSavedMs: prev.speculationSessionTimeSavedMs + timeSavedMs,
+        };
+    });
+    logForDebugging(boundary === null
+        ? `[Speculation] Accept ${id}: still running, using ${messages.length} messages`
+        : `[Speculation] Accept ${id}: already complete`);
+    logSpeculation(id, 'accepted', startTime, suggestionLength, messages, boundary, {
+        message_count: messages.length,
+        time_saved_ms: timeSavedMs,
+        is_pipelined: isPipelined,
+    });
+    if (timeSavedMs > 0) {
+        const entry = {
+            type: 'speculation-accept',
+            timestamp: new Date().toISOString(),
+            timeSavedMs,
+        };
+        void appendFile(getTranscriptPath(), jsonStringify(entry) + '\n', {
+            mode: 0o600,
+        }).catch(() => {
+            logForDebugging('[Speculation] Failed to write speculation-accept to transcript');
+        });
+    }
+    return { messages, boundary, timeSavedMs };
+}
+export function abortSpeculation(setAppState) {
+    setAppState(prev => {
+        if (prev.speculation.status !== 'active')
+            return prev;
+        const { id, abort, startTime, boundary, suggestionLength, messagesRef, isPipelined, } = prev.speculation;
+        logForDebugging(`[Speculation] Aborting ${id}`);
+        logSpeculation(id, 'aborted', startTime, suggestionLength, messagesRef.current, boundary, { abort_reason: 'user_typed', is_pipelined: isPipelined });
+        abort();
+        safeRemoveOverlay(getOverlayPath(id));
+        return { ...prev, speculation: IDLE_SPECULATION_STATE };
+    });
+}
+export async function handleSpeculationAccept(speculationState, speculationSessionTimeSavedMs, setAppState, input, deps) {
+    try {
+        const { setMessages, readFileState, cwd } = deps;
+        // Clear prompt suggestion state. logOutcomeAtSubmission logged the accept
+        // but was called with skipReset to avoid aborting speculation before we use it.
+        setAppState(prev => {
+            if (prev.promptSuggestion.text === null &&
+                prev.promptSuggestion.promptId === null) {
+                return prev;
+            }
+            return {
+                ...prev,
+                promptSuggestion: {
+                    text: null,
+                    promptId: null,
+                    shownAt: 0,
+                    acceptedAt: 0,
+                    generationRequestId: null,
+                },
+            };
+        });
+        // Capture speculation messages before any state updates - must be stable reference
+        const speculationMessages = speculationState.messagesRef.current;
+        let cleanMessages = prepareMessagesForInjection(speculationMessages);
+        // Inject user message first for instant visual feedback before any async work
+        const userMessage = createUserMessage({ content: input });
+        setMessages(prev => [...prev, userMessage]);
+        const result = await acceptSpeculation(speculationState, setAppState, cleanMessages.length);
+        const isComplete = result?.boundary?.type === 'complete';
+        // When speculation didn't complete, the follow-up query needs the
+        // conversation to end with a user message. Drop trailing assistant
+        // messages — models that don't support prefill
+        // reject conversations ending with an assistant turn. The model will
+        // regenerate this content in the follow-up query.
+        if (!isComplete) {
+            const lastNonAssistant = cleanMessages.findLastIndex(m => m.type !== 'assistant');
+            cleanMessages = cleanMessages.slice(0, lastNonAssistant + 1);
+        }
+        const timeSavedMs = result?.timeSavedMs ?? 0;
+        const newSessionTotal = speculationSessionTimeSavedMs + timeSavedMs;
+        const feedbackMessage = createSpeculationFeedbackMessage(cleanMessages, result?.boundary ?? null, timeSavedMs, newSessionTotal);
+        // Inject speculated messages
+        setMessages(prev => [...prev, ...cleanMessages]);
+        const extracted = extractReadFilesFromMessages(cleanMessages, cwd, READ_FILE_STATE_CACHE_SIZE);
+        readFileState.current = mergeFileStateCaches(readFileState.current, extracted);
+        if (feedbackMessage) {
+            setMessages(prev => [...prev, feedbackMessage]);
+        }
+        logForDebugging(`[Speculation] ${result?.boundary?.type ?? 'incomplete'}, injected ${cleanMessages.length} messages`);
+        // Promote pipelined suggestion if speculation completed fully
+        if (isComplete && speculationState.pipelinedSuggestion) {
+            const { text, promptId, generationRequestId } = speculationState.pipelinedSuggestion;
+            logForDebugging(`[Speculation] Promoting pipelined suggestion: "${text.slice(0, 50)}..."`);
+            setAppState(prev => ({
+                ...prev,
+                promptSuggestion: {
+                    text,
+                    promptId,
+                    shownAt: Date.now(),
+                    acceptedAt: 0,
+                    generationRequestId,
+                },
+            }));
+            // Start speculation on the pipelined suggestion
+            const augmentedContext = {
+                ...speculationState.contextRef.current,
+                messages: [
+                    ...speculationState.contextRef.current.messages,
+                    createUserMessage({ content: input }),
+                    ...cleanMessages,
+                ],
+            };
+            void startSpeculation(text, augmentedContext, setAppState, true);
+        }
+        return { queryRequired: !isComplete };
+    }
+    catch (error) {
+        // Fail open: log error and fall back to normal query flow
+        /* eslint-disable no-restricted-syntax -- custom fallback message, not toError(e) */
+        logError(error instanceof Error
+            ? error
+            : new Error('handleSpeculationAccept failed'));
+        /* eslint-enable no-restricted-syntax */
+        logSpeculation(speculationState.id, 'error', speculationState.startTime, speculationState.suggestionLength, speculationState.messagesRef.current, speculationState.boundary, {
+            error_type: error instanceof Error ? error.name : 'Unknown',
+            error_message: errorMessage(error).slice(0, 200),
+            error_phase: 'accept',
+            is_pipelined: speculationState.isPipelined,
+        });
+        safeRemoveOverlay(getOverlayPath(speculationState.id));
+        resetSpeculationState(setAppState);
+        // Query required so user's message is processed normally (without speculated work)
+        return { queryRequired: true };
+    }
+}