@iaforged/context-code 1.2.9 → 1.2.10

package/dist/src/QueryEngine.js

@@ -36,6 +36,7 @@ import { flushSessionStorage, recordTranscript, } from './utils/sessionStorage.j
 import { asSystemPrompt } from './utils/systemPromptType.js';
 import { resolveThemeSetting } from './utils/systemTheme.js';
 import { shouldEnableThinkingByDefault, } from './utils/thinking.js';
+import { CoreQueryRuntimeEmitter } from './core/query/runtime.js';
 // Lazy: MessageSelector.tsx pulls React/ink; only needed for message filtering at query time
 /* eslint-disable @typescript-eslint/no-require-imports */
 const messageSelector = () => require('./components/MessageSelector.js');
@@ -44,6 +45,7 @@ import { buildSystemInitMessage, sdkCompatToolName, } from './utils/messages/sys
 import { getScratchpadDir, isScratchpadEnabled, } from './utils/permissions/filesystem.js';
 /* eslint-enable @typescript-eslint/no-require-imports */
 import { handleOrphanedPermission, isResultSuccessful, normalizeMessage, } from './utils/queryHelpers.js';
+import { isAbortError } from './utils/errors.js';
 // Dead code elimination: conditional import for coordinator mode
 /* eslint-disable @typescript-eslint/no-require-imports */
 const getCoordinatorUserContext = feature('COORDINATOR_MODE')
@@ -443,154 +445,321 @@ export class QueryEngine {
         const initialStructuredOutputCalls = jsonSchema
             ? countToolCalls(this.mutableMessages, SYNTHETIC_OUTPUT_TOOL_NAME)
             : 0;
-        for await (const message of query({
-            messages,
-            systemPrompt,
-            userContext,
-            systemContext,
-            canUseTool: wrappedCanUseTool,
-            toolUseContext: processUserInputContext,
-            fallbackModel,
-            querySource: 'sdk',
-            maxTurns,
-            taskBudget,
-        })) {
-            // Record assistant, user, and compact boundary messages
-            if (message.type === 'assistant' ||
-                message.type === 'user' ||
-                (message.type === 'system' && message.subtype === 'compact_boundary')) {
-                // Before writing a compact boundary, flush any in-memory-only
-                // messages up through the preservedSegment tail. Attachments and
-                // progress are now recorded inline (their switch cases below), but
-                // this flush still matters for the preservedSegment tail walk.
-                // If the SDK subprocess restarts before then (claude-desktop kills
-                // between turns), tailUuid points to a never-written message →
-                // applyPreservedSegmentRelinks fails its tail→head walk → returns
-                // without pruning → resume loads full pre-compact history.
-                if (persistSession &&
-                    message.type === 'system' &&
-                    message.subtype === 'compact_boundary') {
-                    const tailUuid = message.compactMetadata?.preservedSegment?.tailUuid;
-                    if (tailUuid) {
-                        const tailIdx = this.mutableMessages.findLastIndex(m => m.uuid === tailUuid);
-                        if (tailIdx !== -1) {
-                            await recordTranscript(this.mutableMessages.slice(0, tailIdx + 1));
+        const coreQueryEnabled = process.env.CORE_QUERY_ENABLED === '1';
+        const coreEmitter = coreQueryEnabled
+            ? new CoreQueryRuntimeEmitter(this.config.onCoreQueryEvent)
+            : null;
+        coreEmitter?.emitSessionState('started');
+        const emitCoreTerminalFailure = (reason) => {
+            coreEmitter?.emitResult(true, lastStopReason);
+            coreEmitter?.emitSessionState(reason === 'cancelled' || reason === 'canceled' ? 'cancelled' : 'failed', reason);
+        };
+        const emitCoreTerminalSuccess = (isError, result) => {
+            coreEmitter?.emitResult(isError, lastStopReason, result);
+            coreEmitter?.emitSessionState(isError ? 'failed' : 'completed');
+        };
+        let queryLoopError = null;
+        try {
+            for await (const message of query({
+                messages,
+                systemPrompt,
+                userContext,
+                systemContext,
+                canUseTool: wrappedCanUseTool,
+                toolUseContext: processUserInputContext,
+                fallbackModel,
+                querySource: 'sdk',
+                maxTurns,
+                taskBudget,
+            })) {
+                coreEmitter?.emitRunning();
+                // Record assistant, user, and compact boundary messages
+                if (message.type === 'assistant' ||
+                    message.type === 'user' ||
+                    (message.type === 'system' && message.subtype === 'compact_boundary')) {
+                    // Before writing a compact boundary, flush any in-memory-only
+                    // messages up through the preservedSegment tail. Attachments and
+                    // progress are now recorded inline (their switch cases below), but
+                    // this flush still matters for the preservedSegment tail walk.
+                    // If the SDK subprocess restarts before then (claude-desktop kills
+                    // between turns), tailUuid points to a never-written message →
+                    // applyPreservedSegmentRelinks fails its tail→head walk → returns
+                    // without pruning → resume loads full pre-compact history.
+                    if (persistSession &&
+                        message.type === 'system' &&
+                        message.subtype === 'compact_boundary') {
+                        const tailUuid = message.compactMetadata?.preservedSegment?.tailUuid;
+                        if (tailUuid) {
+                            const tailIdx = this.mutableMessages.findLastIndex(m => m.uuid === tailUuid);
+                            if (tailIdx !== -1) {
+                                await recordTranscript(this.mutableMessages.slice(0, tailIdx + 1));
+                            }
                         }
                     }
-                }
-                messages.push(message);
-                if (persistSession) {
-                    // Fire-and-forget for assistant messages. claude.ts yields one
-                    // assistant message per content block, then mutates the last
-                    // one's message.usage/stop_reason on message_delta — relying on
-                    // the write queue's 100ms lazy jsonStringify. Awaiting here
-                    // blocks ask()'s generator, so message_delta can't run until
-                    // every block is consumed; the drain timer (started at block 1)
-                    // elapses first. Interactive CC doesn't hit this because
-                    // useLogMessages.ts fire-and-forgets. enqueueWrite is
-                    // order-preserving so fire-and-forget here is safe.
-                    if (message.type === 'assistant') {
-                        void recordTranscript(messages);
+                    messages.push(message);
+                    if (persistSession) {
+                        // Fire-and-forget for assistant messages. claude.ts yields one
+                        // assistant message per content block, then mutates the last
+                        // one's message.usage/stop_reason on message_delta — relying on
+                        // the write queue's 100ms lazy jsonStringify. Awaiting here
+                        // blocks ask()'s generator, so message_delta can't run until
+                        // every block is consumed; the drain timer (started at block 1)
+                        // elapses first. Interactive CC doesn't hit this because
+                        // useLogMessages.ts fire-and-forgets. enqueueWrite is
+                        // order-preserving so fire-and-forget here is safe.
+                        if (message.type === 'assistant') {
+                            void recordTranscript(messages);
+                        }
+                        else {
+                            await recordTranscript(messages);
+                        }
                     }
-                    else {
-                        await recordTranscript(messages);
+                    // Acknowledge initial user messages after first transcript recording
+                    if (!hasAcknowledgedInitialMessages && messagesToAck.length > 0) {
+                        hasAcknowledgedInitialMessages = true;
+                        for (const msgToAck of messagesToAck) {
+                            if (msgToAck.type === 'user') {
+                                yield {
+                                    type: 'user',
+                                    message: msgToAck.message,
+                                    session_id: getSessionId(),
+                                    parent_tool_use_id: null,
+                                    uuid: msgToAck.uuid,
+                                    timestamp: msgToAck.timestamp,
+                                    isReplay: true,
+                                };
+                            }
+                        }
                     }
                 }
-                // Acknowledge initial user messages after first transcript recording
-                if (!hasAcknowledgedInitialMessages && messagesToAck.length > 0) {
-                    hasAcknowledgedInitialMessages = true;
-                    for (const msgToAck of messagesToAck) {
-                        if (msgToAck.type === 'user') {
+                if (message.type === 'user') {
+                    turnCount++;
+                    coreEmitter?.setTurn(turnCount);
+                }
+                coreEmitter?.emitFromQueryMessage(message);
+                switch (message.type) {
+                    case 'tombstone':
+                        // Tombstone messages are control signals for removing messages, skip them
+                        break;
+                    case 'assistant':
+                        // Capture stop_reason if already set (synthetic messages). For
+                        // streamed responses, this is null at content_block_stop time;
+                        // the real value arrives via message_delta (handled below).
+                        if (message.message.stop_reason != null) {
+                            lastStopReason = message.message.stop_reason;
+                        }
+                        this.mutableMessages.push(message);
+                        yield* normalizeMessage(message);
+                        break;
+                    case 'progress':
+                        this.mutableMessages.push(message);
+                        // Record inline so the dedup loop in the next ask() call sees it
+                        // as already-recorded. Without this, deferred progress interleaves
+                        // with already-recorded tool_results in mutableMessages, and the
+                        // dedup walk freezes startingParentUuid at the wrong message —
+                        // forking the chain and orphaning the conversation on resume.
+                        if (persistSession) {
+                            messages.push(message);
+                            void recordTranscript(messages);
+                        }
+                        yield* normalizeMessage(message);
+                        break;
+                    case 'user':
+                        this.mutableMessages.push(message);
+                        yield* normalizeMessage(message);
+                        break;
+                    case 'stream_event':
+                        if (message.event.type === 'message_start') {
+                            // Reset current message usage for new message
+                            currentMessageUsage = EMPTY_USAGE;
+                            currentMessageUsage = updateUsage(currentMessageUsage, message.event.message.usage);
+                        }
+                        if (message.event.type === 'message_delta') {
+                            currentMessageUsage = updateUsage(currentMessageUsage, message.event.usage);
+                            // Capture stop_reason from message_delta. The assistant message
+                            // is yielded at content_block_stop with stop_reason=null; the
+                            // real value only arrives here (see claude.ts message_delta
+                            // handler). Without this, result.stop_reason is always null.
+                            if (message.event.delta.stop_reason != null) {
+                                lastStopReason = message.event.delta.stop_reason;
+                            }
+                        }
+                        if (message.event.type === 'message_stop') {
+                            // Accumulate current message usage into total
+                            this.totalUsage = accumulateUsage(this.totalUsage, currentMessageUsage);
+                        }
+                        if (includePartialMessages) {
+                            yield {
+                                type: 'stream_event',
+                                event: message.event,
+                                session_id: getSessionId(),
+                                parent_tool_use_id: null,
+                                uuid: randomUUID(),
+                            };
+                        }
+                        break;
+                    case 'attachment':
+                        this.mutableMessages.push(message);
+                        // Record inline (same reason as progress above).
+                        if (persistSession) {
+                            messages.push(message);
+                            void recordTranscript(messages);
+                        }
+                        // Extract structured output from StructuredOutput tool calls
+                        if (message.attachment.type === 'structured_output') {
+                            structuredOutputFromTool = message.attachment.data;
+                        }
+                        // Handle max turns reached signal from query.ts
+                        else if (message.attachment.type === 'max_turns_reached') {
+                            if (persistSession) {
+                                if (isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||
+                                    isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)) {
+                                    await flushSessionStorage();
+                                }
+                            }
+                            yield {
+                                type: 'result',
+                                subtype: 'error_max_turns',
+                                duration_ms: Date.now() - startTime,
+                                duration_api_ms: getTotalAPIDuration(),
+                                is_error: true,
+                                num_turns: message.attachment.turnCount,
+                                stop_reason: lastStopReason,
+                                session_id: getSessionId(),
+                                total_cost_usd: getTotalCost(),
+                                usage: this.totalUsage,
+                                modelUsage: getModelUsage(),
+                                permission_denials: this.permissionDenials,
+                                fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
+                                uuid: randomUUID(),
+                                errors: [
+                                    `Reached maximum number of turns (${message.attachment.maxTurns})`,
+                                ],
+                            };
+                            emitCoreTerminalFailure('error_max_turns');
+                            return;
+                        }
+                        // Yield queued_command attachments as SDK user message replays
+                        else if (replayUserMessages &&
+                            message.attachment.type === 'queued_command') {
                             yield {
                                 type: 'user',
-                                message: msgToAck.message,
+                                message: {
+                                    role: 'user',
+                                    content: message.attachment.prompt,
+                                },
                                 session_id: getSessionId(),
                                 parent_tool_use_id: null,
-                                uuid: msgToAck.uuid,
-                                timestamp: msgToAck.timestamp,
+                                uuid: message.attachment.source_uuid || message.uuid,
+                                timestamp: message.timestamp,
                                 isReplay: true,
                             };
                         }
-                    }
-                }
-            }
-            if (message.type === 'user') {
-                turnCount++;
-            }
-            switch (message.type) {
-                case 'tombstone':
-                    // Tombstone messages are control signals for removing messages, skip them
-                    break;
-                case 'assistant':
-                    // Capture stop_reason if already set (synthetic messages). For
-                    // streamed responses, this is null at content_block_stop time;
-                    // the real value arrives via message_delta (handled below).
-                    if (message.message.stop_reason != null) {
-                        lastStopReason = message.message.stop_reason;
-                    }
-                    this.mutableMessages.push(message);
-                    yield* normalizeMessage(message);
-                    break;
-                case 'progress':
-                    this.mutableMessages.push(message);
-                    // Record inline so the dedup loop in the next ask() call sees it
-                    // as already-recorded. Without this, deferred progress interleaves
-                    // with already-recorded tool_results in mutableMessages, and the
-                    // dedup walk freezes startingParentUuid at the wrong message —
-                    // forking the chain and orphaning the conversation on resume.
-                    if (persistSession) {
-                        messages.push(message);
-                        void recordTranscript(messages);
-                    }
-                    yield* normalizeMessage(message);
-                    break;
-                case 'user':
-                    this.mutableMessages.push(message);
-                    yield* normalizeMessage(message);
-                    break;
-                case 'stream_event':
-                    if (message.event.type === 'message_start') {
-                        // Reset current message usage for new message
-                        currentMessageUsage = EMPTY_USAGE;
-                        currentMessageUsage = updateUsage(currentMessageUsage, message.event.message.usage);
-                    }
-                    if (message.event.type === 'message_delta') {
-                        currentMessageUsage = updateUsage(currentMessageUsage, message.event.usage);
-                        // Capture stop_reason from message_delta. The assistant message
-                        // is yielded at content_block_stop with stop_reason=null; the
-                        // real value only arrives here (see claude.ts message_delta
-                        // handler). Without this, result.stop_reason is always null.
-                        if (message.event.delta.stop_reason != null) {
-                            lastStopReason = message.event.delta.stop_reason;
+                        break;
+                    case 'stream_request_start':
+                        // Don't yield stream request start messages
+                        break;
+                    case 'system': {
+                        // Snip boundary: replay on our store to remove zombie messages and
+                        // stale markers. The yielded boundary is a signal, not data to push —
+                        // the replay produces its own equivalent boundary. Without this,
+                        // markers persist and re-trigger on every turn, and mutableMessages
+                        // never shrinks (memory leak in long SDK sessions). The subtype
+                        // check lives inside the injected callback so feature-gated strings
+                        // stay out of this file (excluded-strings check).
+                        const snipResult = this.config.snipReplay?.(message, this.mutableMessages);
+                        if (snipResult !== undefined) {
+                            if (snipResult.executed) {
+                                this.mutableMessages.length = 0;
+                                this.mutableMessages.push(...snipResult.messages);
+                            }
+                            break;
                         }
+                        this.mutableMessages.push(message);
+                        // Yield compact boundary messages to SDK
+                        if (message.subtype === 'compact_boundary' &&
+                            message.compactMetadata) {
+                            // Release pre-compaction messages for GC. The boundary was just
+                            // pushed so it's the last element. query.ts already uses
+                            // getMessagesAfterCompactBoundary() internally, so only
+                            // post-boundary messages are needed going forward.
+                            const mutableBoundaryIdx = this.mutableMessages.length - 1;
+                            if (mutableBoundaryIdx > 0) {
+                                this.mutableMessages.splice(0, mutableBoundaryIdx);
+                            }
+                            const localBoundaryIdx = messages.length - 1;
+                            if (localBoundaryIdx > 0) {
+                                messages.splice(0, localBoundaryIdx);
+                            }
+                            yield {
+                                type: 'system',
+                                subtype: 'compact_boundary',
+                                session_id: getSessionId(),
+                                uuid: message.uuid,
+                                compact_metadata: toSDKCompactMetadata(message.compactMetadata),
+                            };
+                        }
+                        if (message.subtype === 'api_error') {
+                            yield {
+                                type: 'system',
+                                subtype: 'api_retry',
+                                attempt: message.retryAttempt,
+                                max_retries: message.maxRetries,
+                                retry_delay_ms: message.retryInMs,
+                                error_status: message.error.status ?? null,
+                                error: categorizeRetryableAPIError(message.error),
+                                session_id: getSessionId(),
+                                uuid: message.uuid,
+                            };
+                        }
+                        // Don't yield other system messages in headless mode
+                        break;
                     }
-                    if (message.event.type === 'message_stop') {
-                        // Accumulate current message usage into total
-                        this.totalUsage = accumulateUsage(this.totalUsage, currentMessageUsage);
-                    }
-                    if (includePartialMessages) {
+                    case 'tool_use_summary':
+                        // Yield tool use summary messages to SDK
                         yield {
-                            type: 'stream_event',
-                            event: message.event,
+                            type: 'tool_use_summary',
+                            summary: message.summary,
+                            preceding_tool_use_ids: message.precedingToolUseIds,
                             session_id: getSessionId(),
-                            parent_tool_use_id: null,
-                            uuid: randomUUID(),
+                            uuid: message.uuid,
                         };
-                    }
-                    break;
-                case 'attachment':
-                    this.mutableMessages.push(message);
-                    // Record inline (same reason as progress above).
+                        break;
+                }
+                // Check if USD budget has been exceeded
+                if (maxBudgetUsd !== undefined && getTotalCost() >= maxBudgetUsd) {
                     if (persistSession) {
-                        messages.push(message);
-                        void recordTranscript(messages);
-                    }
-                    // Extract structured output from StructuredOutput tool calls
-                    if (message.attachment.type === 'structured_output') {
-                        structuredOutputFromTool = message.attachment.data;
+                        if (isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||
+                            isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)) {
+                            await flushSessionStorage();
+                        }
                     }
-                    // Handle max turns reached signal from query.ts
-                    else if (message.attachment.type === 'max_turns_reached') {
+                    yield {
+                        type: 'result',
+                        subtype: 'error_max_budget_usd',
+                        duration_ms: Date.now() - startTime,
+                        duration_api_ms: getTotalAPIDuration(),
+                        is_error: true,
+                        num_turns: turnCount,
+                        stop_reason: lastStopReason,
+                        session_id: getSessionId(),
+                        total_cost_usd: getTotalCost(),
+                        usage: this.totalUsage,
+                        modelUsage: getModelUsage(),
+                        permission_denials: this.permissionDenials,
+                        fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
+                        uuid: randomUUID(),
+                        errors: [`Reached maximum budget ($${maxBudgetUsd})`],
+                    };
+                    emitCoreTerminalFailure('error_max_budget_usd');
+                    return;
+                }
+                // Check if structured output retry limit exceeded (only on user messages)
+                if (message.type === 'user' && jsonSchema) {
+                    const currentCalls = countToolCalls(this.mutableMessages, SYNTHETIC_OUTPUT_TOOL_NAME);
+                    const callsThisQuery = currentCalls - initialStructuredOutputCalls;
+                    const maxRetries = parseInt(process.env.MAX_STRUCTURED_OUTPUT_RETRIES || '5', 10);
+                    if (callsThisQuery >= maxRetries) {
                         if (persistSession) {
                             if (isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||
                                 isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)) {
@@ -599,11 +768,11 @@ export class QueryEngine {
                         }
                         yield {
                             type: 'result',
-                            subtype: 'error_max_turns',
+                            subtype: 'error_max_structured_output_retries',
                             duration_ms: Date.now() - startTime,
                             duration_api_ms: getTotalAPIDuration(),
                             is_error: true,
-                            num_turns: message.attachment.turnCount,
+                            num_turns: turnCount,
                             stop_reason: lastStopReason,
                             session_id: getSessionId(),
                             total_cost_usd: getTotalCost(),
@@ -613,109 +782,42 @@ export class QueryEngine {
                             fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
                             uuid: randomUUID(),
                             errors: [
-                                `Reached maximum number of turns (${message.attachment.maxTurns})`,
+                                `Failed to provide valid structured output after ${maxRetries} attempts`,
                             ],
                         };
+                        emitCoreTerminalFailure('error_max_structured_output_retries');
                         return;
                     }
-                    // Yield queued_command attachments as SDK user message replays
-                    else if (replayUserMessages &&
-                        message.attachment.type === 'queued_command') {
-                        yield {
-                            type: 'user',
-                            message: {
-                                role: 'user',
-                                content: message.attachment.prompt,
-                            },
-                            session_id: getSessionId(),
-                            parent_tool_use_id: null,
-                            uuid: message.attachment.source_uuid || message.uuid,
-                            timestamp: message.timestamp,
-                            isReplay: true,
-                        };
-                    }
-                    break;
-                case 'stream_request_start':
-                    // Don't yield stream request start messages
-                    break;
-                case 'system': {
-                    // Snip boundary: replay on our store to remove zombie messages and
-                    // stale markers. The yielded boundary is a signal, not data to push —
-                    // the replay produces its own equivalent boundary. Without this,
-                    // markers persist and re-trigger on every turn, and mutableMessages
-                    // never shrinks (memory leak in long SDK sessions). The subtype
-                    // check lives inside the injected callback so feature-gated strings
-                    // stay out of this file (excluded-strings check).
-                    const snipResult = this.config.snipReplay?.(message, this.mutableMessages);
-                    if (snipResult !== undefined) {
-                        if (snipResult.executed) {
-                            this.mutableMessages.length = 0;
-                            this.mutableMessages.push(...snipResult.messages);
-                        }
-                        break;
-                    }
-                    this.mutableMessages.push(message);
-                    // Yield compact boundary messages to SDK
-                    if (message.subtype === 'compact_boundary' &&
-                        message.compactMetadata) {
-                        // Release pre-compaction messages for GC. The boundary was just
-                        // pushed so it's the last element. query.ts already uses
-                        // getMessagesAfterCompactBoundary() internally, so only
-                        // post-boundary messages are needed going forward.
-                        const mutableBoundaryIdx = this.mutableMessages.length - 1;
-                        if (mutableBoundaryIdx > 0) {
-                            this.mutableMessages.splice(0, mutableBoundaryIdx);
-                        }
-                        const localBoundaryIdx = messages.length - 1;
-                        if (localBoundaryIdx > 0) {
-                            messages.splice(0, localBoundaryIdx);
-                        }
-                        yield {
-                            type: 'system',
-                            subtype: 'compact_boundary',
-                            session_id: getSessionId(),
-                            uuid: message.uuid,
-                            compact_metadata: toSDKCompactMetadata(message.compactMetadata),
-                        };
-                    }
-                    if (message.subtype === 'api_error') {
-                        yield {
-                            type: 'system',
-                            subtype: 'api_retry',
-                            attempt: message.retryAttempt,
-                            max_retries: message.maxRetries,
-                            retry_delay_ms: message.retryInMs,
-                            error_status: message.error.status ?? null,
-                            error: categorizeRetryableAPIError(message.error),
-                            session_id: getSessionId(),
-                            uuid: message.uuid,
-                        };
-                    }
-                    // Don't yield other system messages in headless mode
-                    break;
                 }
-                case 'tool_use_summary':
-                    // Yield tool use summary messages to SDK
-                    yield {
-                        type: 'tool_use_summary',
-                        summary: message.summary,
-                        preceding_tool_use_ids: message.precedingToolUseIds,
-                        session_id: getSessionId(),
-                        uuid: message.uuid,
-                    };
-                    break;
             }
-            // Check if USD budget has been exceeded
-            if (maxBudgetUsd !== undefined && getTotalCost() >= maxBudgetUsd) {
-                if (persistSession) {
-                    if (isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||
-                        isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)) {
-                        await flushSessionStorage();
-                    }
+            // Stop hooks yield progress/attachment messages AFTER the assistant
+            // response (via yield* handleStopHooks in query.ts). Since #23537 pushes
+            // those to `messages` inline, last(messages) can be a progress/attachment
+            // instead of the assistant — which makes textResult extraction below
+            // return '' and -p mode emit a blank line. Allowlist to assistant|user:
+            // isResultSuccessful handles both (user with all tool_result blocks is a
+            // valid successful terminal state).
+            const result = messages.findLast(m => m.type === 'assistant' || m.type === 'user');
+            // Capture for the error_during_execution diagnostic — isResultSuccessful
+            // is a type predicate (message is Message), so inside the false branch
+            // `result` narrows to never and these accesses don't typecheck.
+            const edeResultType = result?.type ?? 'undefined';
+            const edeLastContentType = result?.type === 'assistant'
+                ? (last(result.message.content)?.type ?? 'none')
+                : 'n/a';
+            // Flush buffered transcript writes before yielding result.
+            // The desktop app kills the CLI process immediately after receiving the
+            // result message, so any unflushed writes would be lost.
+            if (persistSession) {
+                if (isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||
+                    isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)) {
+                    await flushSessionStorage();
                 }
+            }
+            if (!isResultSuccessful(result, lastStopReason)) {
                 yield {
                     type: 'result',
-                    subtype: 'error_max_budget_usd',
+                    subtype: 'error_during_execution',
                     duration_ms: Date.now() - startTime,
                     duration_api_ms: getTotalAPIDuration(),
                     is_error: true,
@@ -728,70 +830,76 @@ export class QueryEngine {
                     permission_denials: this.permissionDenials,
                     fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
                     uuid: randomUUID(),
-                    errors: [`Reached maximum budget ($${maxBudgetUsd})`],
+                    // Diagnostic prefix: these are what isResultSuccessful() checks — if
+                    // the result type isn't assistant-with-text/thinking or user-with-
+                    // tool_result, and stop_reason isn't end_turn, that's why this fired.
+                    // errors[] is turn-scoped via the watermark; previously it dumped the
+                    // entire process's logError buffer (ripgrep timeouts, ENOENT, etc).
+                    errors: (() => {
+                        const all = getInMemoryErrors();
+                        const start = errorLogWatermark
+                            ? all.lastIndexOf(errorLogWatermark) + 1
+                            : 0;
+                        return [
+                            `[ede_diagnostic] result_type=${edeResultType} last_content_type=${edeLastContentType} stop_reason=${lastStopReason}`,
+                            ...all.slice(start).map(_ => _.error),
+                        ];
+                    })(),
                 };
+                emitCoreTerminalFailure('error_during_execution');
                 return;
             }
-            // Check if structured output retry limit exceeded (only on user messages)
-            if (message.type === 'user' && jsonSchema) {
-                const currentCalls = countToolCalls(this.mutableMessages, SYNTHETIC_OUTPUT_TOOL_NAME);
-                const callsThisQuery = currentCalls - initialStructuredOutputCalls;
-                const maxRetries = parseInt(process.env.MAX_STRUCTURED_OUTPUT_RETRIES || '5', 10);
-                if (callsThisQuery >= maxRetries) {
-                    if (persistSession) {
-                        if (isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||
-                            isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)) {
-                            await flushSessionStorage();
-                        }
-                    }
-                    yield {
-                        type: 'result',
-                        subtype: 'error_max_structured_output_retries',
-                        duration_ms: Date.now() - startTime,
-                        duration_api_ms: getTotalAPIDuration(),
-                        is_error: true,
-                        num_turns: turnCount,
-                        stop_reason: lastStopReason,
-                        session_id: getSessionId(),
-                        total_cost_usd: getTotalCost(),
-                        usage: this.totalUsage,
-                        modelUsage: getModelUsage(),
-                        permission_denials: this.permissionDenials,
-                        fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
-                        uuid: randomUUID(),
-                        errors: [
-                            `Failed to provide valid structured output after ${maxRetries} attempts`,
-                        ],
-                    };
-                    return;
+            // Extract the text result based on message type
+            let textResult = '';
+            let isApiError = false;
+            if (result.type === 'assistant') {
+                const lastContent = last(result.message.content);
+                if (lastContent?.type === 'text' &&
+                    !SYNTHETIC_MESSAGES.has(lastContent.text)) {
+                    textResult = lastContent.text;
                 }
+                isApiError = Boolean(result.isApiErrorMessage);
             }
+            yield {
+                type: 'result',
+                subtype: 'success',
+                is_error: isApiError,
+                duration_ms: Date.now() - startTime,
+                duration_api_ms: getTotalAPIDuration(),
+                num_turns: turnCount,
+                result: textResult,
+                stop_reason: lastStopReason,
+                session_id: getSessionId(),
+                total_cost_usd: getTotalCost(),
+                usage: this.totalUsage,
+                modelUsage: getModelUsage(),
+                permission_denials: this.permissionDenials,
+                structured_output: structuredOutputFromTool,
+                fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
+                uuid: randomUUID(),
+            };
         }
-        // Stop hooks yield progress/attachment messages AFTER the assistant
-        // response (via yield* handleStopHooks in query.ts). Since #23537 pushes
-        // those to `messages` inline, last(messages) can be a progress/attachment
-        // instead of the assistant — which makes textResult extraction below
-        // return '' and -p mode emit a blank line. Allowlist to assistant|user:
-        // isResultSuccessful handles both (user with all tool_result blocks is a
-        // valid successful terminal state).
-        const result = messages.findLast(m => m.type === 'assistant' || m.type === 'user');
-        // Capture for the error_during_execution diagnostic — isResultSuccessful
-        // is a type predicate (message is Message), so inside the false branch
-        // `result` narrows to never and these accesses don't typecheck.
-        const edeResultType = result?.type ?? 'undefined';
-        const edeLastContentType = result?.type === 'assistant'
-            ? (last(result.message.content)?.type ?? 'none')
-            : 'n/a';
-        // Flush buffered transcript writes before yielding result.
-        // The desktop app kills the CLI process immediately after receiving the
-        // result message, so any unflushed writes would be lost.
-        if (persistSession) {
-            if (isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||
-                isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)) {
-                await flushSessionStorage();
-            }
+        catch (error) {
+            queryLoopError = error;
         }
-        if (!isResultSuccessful(result, lastStopReason)) {
+        if (queryLoopError !== null) {
+            const error = queryLoopError;
+            const isTimeout = error?.name === 'TimeoutError' ||
+                error?.message?.toLowerCase().includes('timeout') ||
+                error?.message?.toLowerCase().includes('timed out');
+            const failureReason = isAbortError(error)
+                ? 'cancelled'
+                : isTimeout
+                    ? 'timeout'
+                    : 'error';
+            coreEmitter?.emitError(error?.message || String(error), failureReason);
+            emitCoreTerminalFailure(failureReason);
+            if (persistSession) {
+                if (isEnvTruthy(process.env.CLAUDE_CODE_EAGER_FLUSH) ||
+                    isEnvTruthy(process.env.CLAUDE_CODE_IS_COWORK)) {
+                    await flushSessionStorage();
+                }
+            }
             yield {
                 type: 'result',
                 subtype: 'error_during_execution',
@@ -807,53 +915,11 @@ export class QueryEngine {
                 permission_denials: this.permissionDenials,
                 fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
                 uuid: randomUUID(),
-                // Diagnostic prefix: these are what isResultSuccessful() checks — if
-                // the result type isn't assistant-with-text/thinking or user-with-
-                // tool_result, and stop_reason isn't end_turn, that's why this fired.
-                // errors[] is turn-scoped via the watermark; previously it dumped the
-                // entire process's logError buffer (ripgrep timeouts, ENOENT, etc).
-                errors: (() => {
-                    const all = getInMemoryErrors();
-                    const start = errorLogWatermark
-                        ? all.lastIndexOf(errorLogWatermark) + 1
-                        : 0;
-                    return [
-                        `[ede_diagnostic] result_type=${edeResultType} last_content_type=${edeLastContentType} stop_reason=${lastStopReason}`,
-                        ...all.slice(start).map(_ => _.error),
-                    ];
-                })(),
+                errors: [error?.message || String(error)],
             };
             return;
         }
-        // Extract the text result based on message type
-        let textResult = '';
-        let isApiError = false;
-        if (result.type === 'assistant') {
-            const lastContent = last(result.message.content);
-            if (lastContent?.type === 'text' &&
-                !SYNTHETIC_MESSAGES.has(lastContent.text)) {
-                textResult = lastContent.text;
-            }
-            isApiError = Boolean(result.isApiErrorMessage);
-        }
-        yield {
-            type: 'result',
-            subtype: 'success',
-            is_error: isApiError,
-            duration_ms: Date.now() - startTime,
-            duration_api_ms: getTotalAPIDuration(),
-            num_turns: turnCount,
-            result: textResult,
-            stop_reason: lastStopReason,
-            session_id: getSessionId(),
-            total_cost_usd: getTotalCost(),
-            usage: this.totalUsage,
-            modelUsage: getModelUsage(),
-            permission_denials: this.permissionDenials,
-            structured_output: structuredOutputFromTool,
-            fast_mode_state: getFastModeState(mainLoopModel, initialAppState.fastMode),
-            uuid: randomUUID(),
-        };
+        emitCoreTerminalSuccess(isApiError, textResult);
     }
     interrupt() {
         this.abortController.abort();
@@ -878,7 +944,7 @@ export class QueryEngine {
  *
  * Convenience wrapper around QueryEngine for one-shot usage.
  */
-export async function* ask({ commands, prompt, promptUuid, isMeta, cwd, tools, mcpClients, verbose = false, thinkingConfig, maxTurns, maxBudgetUsd, taskBudget, canUseTool, mutableMessages = [], getReadFileCache, setReadFileCache, customSystemPrompt, appendSystemPrompt, userSpecifiedModel, fallbackModel, jsonSchema, getAppState, setAppState, abortController, replayUserMessages = false, includePartialMessages = false, handleElicitation, agents = [], setSDKStatus, orphanedPermission, }) {
+export async function* ask({ commands, prompt, promptUuid, isMeta, cwd, tools, mcpClients, verbose = false, thinkingConfig, maxTurns, maxBudgetUsd, taskBudget, canUseTool, mutableMessages = [], getReadFileCache, setReadFileCache, customSystemPrompt, appendSystemPrompt, userSpecifiedModel, fallbackModel, jsonSchema, getAppState, setAppState, abortController, replayUserMessages = false, includePartialMessages = false, handleElicitation, agents = [], setSDKStatus, orphanedPermission, onCoreQueryEvent, }) {
     const engine = new QueryEngine({
         cwd,
         tools,
@@ -906,6 +972,7 @@ export async function* ask({ commands, prompt, promptUuid, isMeta, cwd, tools, m
         setSDKStatus,
         abortController,
         orphanedPermission,
+        onCoreQueryEvent,
         ...(feature('HISTORY_SNIP')
             ? {
                 snipReplay: (yielded, store) => {