@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/query.js

@@ -0,0 +1,1330 @@
+import { feature } from './recovery/bunBundleShim.js';
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+import { FallbackTriggeredError } from './services/api/withRetry.js';
+import { calculateTokenWarningState, isAutoCompactEnabled, } from './services/compact/autoCompact.js';
+import { buildPostCompactMessages } from './services/compact/compact.js';
+/* eslint-disable @typescript-eslint/no-require-imports */
+const reactiveCompact = feature('REACTIVE_COMPACT')
+    ? require('./services/compact/reactiveCompact.js')
+    : null;
+const contextCollapse = feature('CONTEXT_COLLAPSE')
+    ? require('./services/contextCollapse/index.js')
+    : null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { logEvent, } from './services/analytics/index.js';
+import { ImageSizeError } from './utils/imageValidation.js';
+import { ImageResizeError } from './utils/imageResizer.js';
+import { findToolByName } from './Tool.js';
+import { asSystemPrompt } from './utils/systemPromptType.js';
+import { logError } from './utils/log.js';
+import { PROMPT_TOO_LONG_ERROR_MESSAGE, isPromptTooLongMessage, } from './services/api/errors.js';
+import { logAntError, logForDebugging } from './utils/debug.js';
+import { createUserMessage, createUserInterruptionMessage, normalizeMessagesForAPI, createSystemMessage, createAssistantAPIErrorMessage, getMessagesAfterCompactBoundary, createToolUseSummaryMessage, createMicrocompactBoundaryMessage, stripSignatureBlocks, } from './utils/messages.js';
+import { generateToolUseSummary } from './services/toolUseSummary/toolUseSummaryGenerator.js';
+import { prependUserContext, appendSystemContext } from './utils/api.js';
+import { createAttachmentMessage, filterDuplicateMemoryAttachments, getAttachmentMessages, startRelevantMemoryPrefetch, } from './utils/attachments.js';
+/* eslint-disable @typescript-eslint/no-require-imports */
+const skillPrefetch = feature('EXPERIMENTAL_SKILL_SEARCH')
+    ? require('./services/skillSearch/prefetch.js')
+    : null;
+const jobClassifier = feature('TEMPLATES')
+    ? require('./jobs/classifier.js')
+    : null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+import { remove as removeFromQueue, getCommandsByMaxPriority, isSlashCommand, } from './utils/messageQueueManager.js';
+import { notifyCommandLifecycle } from './utils/commandLifecycle.js';
+import { headlessProfilerCheckpoint } from './utils/headlessProfiler.js';
+import { getRuntimeMainLoopModel, renderModelName, } from './utils/model/model.js';
+import { doesMostRecentAssistantMessageExceed200k, finalContextTokensFromLastResponse, tokenCountWithEstimation, } from './utils/tokens.js';
+import { ESCALATED_MAX_TOKENS } from './utils/context.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from './services/analytics/growthbook.js';
+import { SLEEP_TOOL_NAME } from './tools/SleepTool/prompt.js';
+import { executePostSamplingHooks } from './utils/hooks/postSamplingHooks.js';
+import { executeStopFailureHooks } from './utils/hooks.js';
+import { createDumpPromptsFetch } from './services/api/dumpPrompts.js';
+import { StreamingToolExecutor } from './services/tools/StreamingToolExecutor.js';
+import { queryCheckpoint } from './utils/queryProfiler.js';
+import { runTools } from './services/tools/toolOrchestration.js';
+import { applyToolResultBudget } from './utils/toolResultStorage.js';
+import { recordContentReplacement } from './utils/sessionStorage.js';
+import { handleStopHooks } from './query/stopHooks.js';
+import { buildQueryConfig } from './query/config.js';
+import { productionDeps } from './query/deps.js';
+import { getCurrentTurnTokenBudget, getTurnOutputTokens, incrementBudgetContinuationCount, } from './bootstrap/state.js';
+import { createBudgetTracker, checkTokenBudget } from './query/tokenBudget.js';
+import { count } from './utils/array.js';
+/* eslint-disable @typescript-eslint/no-require-imports */
+const snipModule = feature('HISTORY_SNIP')
+    ? require('./services/compact/snipCompact.js')
+    : null;
+const taskSummaryModule = feature('BG_SESSIONS')
+    ? require('./utils/taskSummary.js')
+    : null;
+/* eslint-enable @typescript-eslint/no-require-imports */
+function* yieldMissingToolResultBlocks(assistantMessages, errorMessage) {
+    for (const assistantMessage of assistantMessages) {
+        // Extract all tool use blocks from this assistant message
+        const toolUseBlocks = assistantMessage.message.content.filter(content => content.type === 'tool_use');
+        // Emit an interruption message for each tool use
+        for (const toolUse of toolUseBlocks) {
+            yield createUserMessage({
+                content: [
+                    {
+                        type: 'tool_result',
+                        content: errorMessage,
+                        is_error: true,
+                        tool_use_id: toolUse.id,
+                    },
+                ],
+                toolUseResult: errorMessage,
+                sourceToolAssistantUUID: assistantMessage.uuid,
+            });
+        }
+    }
+}
+/**
+ * The rules of thinking are lengthy and fortuitous. They require plenty of thinking
+ * of most long duration and deep meditation for a wizard to wrap one's noggin around.
+ *
+ * The rules follow:
+ * 1. A message that contains a thinking or redacted_thinking block must be part of a query whose max_thinking_length > 0
+ * 2. A thinking block may not be the last message in a block
+ * 3. Thinking blocks must be preserved for the duration of an assistant trajectory (a single turn, or if that turn includes a tool_use block then also its subsequent tool_result and the following assistant message)
+ *
+ * Heed these rules well, young wizard. For they are the rules of thinking, and
+ * the rules of thinking are the rules of the universe. If ye does not heed these
+ * rules, ye will be punished with an entire day of debugging and hair pulling.
+ */
+const MAX_OUTPUT_TOKENS_RECOVERY_LIMIT = 3;
+/**
+ * Is this a max_output_tokens error message? If so, the streaming loop should
+ * withhold it from SDK callers until we know whether the recovery loop can
+ * continue. Yielding early leaks an intermediate error to SDK callers (e.g.
+ * cowork/desktop) that terminate the session on any `error` field — the
+ * recovery loop keeps running but nobody is listening.
+ *
+ * Mirrors reactiveCompact.isWithheldPromptTooLong.
+ */
+function isWithheldMaxOutputTokens(msg) {
+    return msg?.type === 'assistant' && msg.apiError === 'max_output_tokens';
+}
+export async function* query(params) {
+    const consumedCommandUuids = [];
+    const terminal = yield* queryLoop(params, consumedCommandUuids);
+    // Only reached if queryLoop returned normally. Skipped on throw (error
+    // propagates through yield*) and on .return() (Return completion closes
+    // both generators). This gives the same asymmetric started-without-completed
+    // signal as print.ts's drainCommandQueue when the turn fails.
+    for (const uuid of consumedCommandUuids) {
+        notifyCommandLifecycle(uuid, 'completed');
+    }
+    return terminal;
+}
+async function* queryLoop(params, consumedCommandUuids) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        // Immutable params — never reassigned during the query loop.
+        const { systemPrompt, userContext, systemContext, canUseTool, fallbackModel, querySource, maxTurns, skipCacheWrite, } = params;
+        const deps = params.deps ?? productionDeps();
+        // Mutable cross-iteration state. The loop body destructures this at the top
+        // of each iteration so reads stay bare-name (`messages`, `toolUseContext`).
+        // Continue sites write `state = { ... }` instead of 9 separate assignments.
+        let state = {
+            messages: params.messages,
+            toolUseContext: params.toolUseContext,
+            maxOutputTokensOverride: params.maxOutputTokensOverride,
+            autoCompactTracking: undefined,
+            stopHookActive: undefined,
+            maxOutputTokensRecoveryCount: 0,
+            hasAttemptedReactiveCompact: false,
+            turnCount: 1,
+            pendingToolUseSummary: undefined,
+            transition: undefined,
+        };
+        const budgetTracker = feature('TOKEN_BUDGET') ? createBudgetTracker() : null;
+        // task_budget.remaining tracking across compaction boundaries. Undefined
+        // until first compact fires — while context is uncompacted the server can
+        // see the full history and handles the countdown from {total} itself (see
+        // api/api/sampling/prompt/renderer.py:292). After a compact, the server sees
+        // only the summary and would under-count spend; remaining tells it the
+        // pre-compact final window that got summarized away. Cumulative across
+        // multiple compacts: each subtracts the final context at that compact's
+        // trigger point. Loop-local (not on State) to avoid touching the 7 continue
+        // sites.
+        let taskBudgetRemaining = undefined;
+        // Snapshot immutable env/statsig/session state once at entry. See QueryConfig
+        // for what's included and why feature() gates are intentionally excluded.
+        const config = buildQueryConfig();
+        // Fired once per user turn — the prompt is invariant across loop iterations,
+        // so per-iteration firing would ask sideQuery the same question N times.
+        // Consume point polls settledAt (never blocks). `using` disposes on all
+        // generator exit paths — see MemoryPrefetch for dispose/telemetry semantics.
+        const pendingMemoryPrefetch = __addDisposableResource(env_1, startRelevantMemoryPrefetch(state.messages, state.toolUseContext)
+        // eslint-disable-next-line no-constant-condition
+        , false);
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            // Destructure state at the top of each iteration. toolUseContext alone
+            // is reassigned within an iteration (queryTracking, messages updates);
+            // the rest are read-only between continue sites.
+            let { toolUseContext } = state;
+            const { messages, autoCompactTracking, maxOutputTokensRecoveryCount, hasAttemptedReactiveCompact, maxOutputTokensOverride, pendingToolUseSummary, stopHookActive, turnCount, } = state;
+            // Skill discovery prefetch — per-iteration (uses findWritePivot guard
+            // that returns early on non-write iterations). Discovery runs while the
+            // model streams and tools execute; awaited post-tools alongside the
+            // memory prefetch consume. Replaces the blocking assistant_turn path
+            // that ran inside getAttachmentMessages (97% of those calls found
+            // nothing in prod). Turn-0 user-input discovery still blocks in
+            // userInputAttachments — that's the one signal where there's no prior
+            // work to hide under.
+            const pendingSkillPrefetch = skillPrefetch?.startSkillDiscoveryPrefetch(null, messages, toolUseContext);
+            yield { type: 'stream_request_start' };
+            queryCheckpoint('query_fn_entry');
+            // Record query start for headless latency tracking (skip for subagents)
+            if (!toolUseContext.agentId) {
+                headlessProfilerCheckpoint('query_started');
+            }
+            // Initialize or increment query chain tracking
+            const queryTracking = toolUseContext.queryTracking
+                ? {
+                    chainId: toolUseContext.queryTracking.chainId,
+                    depth: toolUseContext.queryTracking.depth + 1,
+                }
+                : {
+                    chainId: deps.uuid(),
+                    depth: 0,
+                };
+            const queryChainIdForAnalytics = queryTracking.chainId;
+            toolUseContext = {
+                ...toolUseContext,
+                queryTracking,
+            };
+            let messagesForQuery = [...getMessagesAfterCompactBoundary(messages)];
+            let tracking = autoCompactTracking;
+            // Enforce per-message budget on aggregate tool result size. Runs BEFORE
+            // microcompact — cached MC operates purely by tool_use_id (never inspects
+            // content), so content replacement is invisible to it and the two compose
+            // cleanly. No-ops when contentReplacementState is undefined (feature off).
+            // Persist only for querySources that read records back on resume: agentId
+            // routes to sidechain file (AgentTool resume) or session file (/resume).
+            // Ephemeral runForkedAgent callers (agent_summary etc.) don't persist.
+            const persistReplacements = querySource.startsWith('agent:') ||
+                querySource.startsWith('repl_main_thread');
+            messagesForQuery = await applyToolResultBudget(messagesForQuery, toolUseContext.contentReplacementState, persistReplacements
+                ? records => void recordContentReplacement(records, toolUseContext.agentId).catch(logError)
+                : undefined, new Set(toolUseContext.options.tools
+                .filter(t => !Number.isFinite(t.maxResultSizeChars))
+                .map(t => t.name)));
+            // Apply snip before microcompact (both may run — they are not mutually exclusive).
+            // snipTokensFreed is plumbed to autocompact so its threshold check reflects
+            // what snip removed; tokenCountWithEstimation alone can't see it (reads usage
+            // from the protected-tail assistant, which survives snip unchanged).
+            let snipTokensFreed = 0;
+            if (feature('HISTORY_SNIP')) {
+                queryCheckpoint('query_snip_start');
+                const snipResult = snipModule.snipCompactIfNeeded(messagesForQuery);
+                messagesForQuery = snipResult.messages;
+                snipTokensFreed = snipResult.tokensFreed;
+                if (snipResult.boundaryMessage) {
+                    yield snipResult.boundaryMessage;
+                }
+                queryCheckpoint('query_snip_end');
+            }
+            // Apply microcompact before autocompact
+            queryCheckpoint('query_microcompact_start');
+            const microcompactResult = await deps.microcompact(messagesForQuery, toolUseContext, querySource);
+            messagesForQuery = microcompactResult.messages;
+            // For cached microcompact (cache editing), defer boundary message until after
+            // the API response so we can use actual cache_deleted_input_tokens.
+            // Gated behind feature() so the string is eliminated from external builds.
+            const pendingCacheEdits = feature('CACHED_MICROCOMPACT')
+                ? microcompactResult.compactionInfo?.pendingCacheEdits
+                : undefined;
+            queryCheckpoint('query_microcompact_end');
+            // Project the collapsed context view and maybe commit more collapses.
+            // Runs BEFORE autocompact so that if collapse gets us under the
+            // autocompact threshold, autocompact is a no-op and we keep granular
+            // context instead of a single summary.
+            //
+            // Nothing is yielded — the collapsed view is a read-time projection
+            // over the REPL's full history. Summary messages live in the collapse
+            // store, not the REPL array. This is what makes collapses persist
+            // across turns: projectView() replays the commit log on every entry.
+            // Within a turn, the view flows forward via state.messages at the
+            // continue site (query.ts:1192), and the next projectView() no-ops
+            // because the archived messages are already gone from its input.
+            if (feature('CONTEXT_COLLAPSE') && contextCollapse) {
+                const collapseResult = await contextCollapse.applyCollapsesIfNeeded(messagesForQuery, toolUseContext, querySource);
+                messagesForQuery = collapseResult.messages;
+            }
+            const fullSystemPrompt = asSystemPrompt(appendSystemContext(systemPrompt, systemContext));
+            queryCheckpoint('query_autocompact_start');
+            const { compactionResult, consecutiveFailures } = await deps.autocompact(messagesForQuery, toolUseContext, {
+                systemPrompt,
+                userContext,
+                systemContext,
+                toolUseContext,
+                forkContextMessages: messagesForQuery,
+            }, querySource, tracking, snipTokensFreed);
+            queryCheckpoint('query_autocompact_end');
+            if (compactionResult) {
+                const { preCompactTokenCount, postCompactTokenCount, truePostCompactTokenCount, compactionUsage, } = compactionResult;
+                logEvent('tengu_auto_compact_succeeded', {
+                    originalMessageCount: messages.length,
+                    compactedMessageCount: compactionResult.summaryMessages.length +
+                        compactionResult.attachments.length +
+                        compactionResult.hookResults.length,
+                    preCompactTokenCount,
+                    postCompactTokenCount,
+                    truePostCompactTokenCount,
+                    compactionInputTokens: compactionUsage?.input_tokens,
+                    compactionOutputTokens: compactionUsage?.output_tokens,
+                    compactionCacheReadTokens: compactionUsage?.cache_read_input_tokens ?? 0,
+                    compactionCacheCreationTokens: compactionUsage?.cache_creation_input_tokens ?? 0,
+                    compactionTotalTokens: compactionUsage
+                        ? compactionUsage.input_tokens +
+                            (compactionUsage.cache_creation_input_tokens ?? 0) +
+                            (compactionUsage.cache_read_input_tokens ?? 0) +
+                            compactionUsage.output_tokens
+                        : 0,
+                    queryChainId: queryChainIdForAnalytics,
+                    queryDepth: queryTracking.depth,
+                });
+                // task_budget: capture pre-compact final context window before
+                // messagesForQuery is replaced with postCompactMessages below.
+                // iterations[-1] is the authoritative final window (post server tool
+                // loops); see #304930.
+                if (params.taskBudget) {
+                    const preCompactContext = finalContextTokensFromLastResponse(messagesForQuery);
+                    taskBudgetRemaining = Math.max(0, (taskBudgetRemaining ?? params.taskBudget.total) - preCompactContext);
+                }
+                // Reset on every compact so turnCounter/turnId reflect the MOST RECENT
+                // compact. recompactionInfo (autoCompact.ts:190) already captured the
+                // old values for turnsSincePreviousCompact/previousCompactTurnId before
+                // the call, so this reset doesn't lose those.
+                tracking = {
+                    compacted: true,
+                    turnId: deps.uuid(),
+                    turnCounter: 0,
+                    consecutiveFailures: 0,
+                };
+                const postCompactMessages = buildPostCompactMessages(compactionResult);
+                for (const message of postCompactMessages) {
+                    yield message;
+                }
+                // Continue on with the current query call using the post compact messages
+                messagesForQuery = postCompactMessages;
+            }
+            else if (consecutiveFailures !== undefined) {
+                // Autocompact failed — propagate failure count so the circuit breaker
+                // can stop retrying on the next iteration.
+                tracking = {
+                    ...(tracking ?? { compacted: false, turnId: '', turnCounter: 0 }),
+                    consecutiveFailures,
+                };
+            }
+            //TODO: no need to set toolUseContext.messages during set-up since it is updated here
+            toolUseContext = {
+                ...toolUseContext,
+                messages: messagesForQuery,
+            };
+            const assistantMessages = [];
+            const toolResults = [];
+            // @see https://docs.claude.com/en/docs/build-with-claude/tool-use
+            // Note: stop_reason === 'tool_use' is unreliable -- it's not always set correctly.
+            // Set during streaming whenever a tool_use block arrives — the sole
+            // loop-exit signal. If false after streaming, we're done (modulo stop-hook retry).
+            const toolUseBlocks = [];
+            let needsFollowUp = false;
+            queryCheckpoint('query_setup_start');
+            const useStreamingToolExecution = config.gates.streamingToolExecution;
+            let streamingToolExecutor = useStreamingToolExecution
+                ? new StreamingToolExecutor(toolUseContext.options.tools, canUseTool, toolUseContext)
+                : null;
+            const appState = toolUseContext.getAppState();
+            const permissionMode = appState.toolPermissionContext.mode;
+            let currentModel = getRuntimeMainLoopModel({
+                permissionMode,
+                mainLoopModel: toolUseContext.options.mainLoopModel,
+                exceeds200kTokens: permissionMode === 'plan' &&
+                    doesMostRecentAssistantMessageExceed200k(messagesForQuery),
+            });
+            queryCheckpoint('query_setup_end');
+            // Create fetch wrapper once per query session to avoid memory retention.
+            // Each call to createDumpPromptsFetch creates a closure that captures the request body.
+            // Creating it once means only the latest request body is retained (~700KB),
+            // instead of all request bodies from the session (~500MB for long sessions).
+            // Note: agentId is effectively constant during a query() call - it only changes
+            // between queries (e.g., /clear command or session resume).
+            const dumpPromptsFetch = config.gates.isAnt
+                ? createDumpPromptsFetch(toolUseContext.agentId ?? config.sessionId)
+                : undefined;
+            // Block if we've hit the hard blocking limit (only applies when auto-compact is OFF)
+            // This reserves space so users can still run /compact manually
+            // Skip this check if compaction just happened - the compaction result is already
+            // validated to be under the threshold, and tokenCountWithEstimation would use
+            // stale input_tokens from kept messages that reflect pre-compaction context size.
+            // Same staleness applies to snip: subtract snipTokensFreed (otherwise we'd
+            // falsely block in the window where snip brought us under autocompact threshold
+            // but the stale usage is still above blocking limit — before this PR that
+            // window never existed because autocompact always fired on the stale count).
+            // Also skip for compact/session_memory queries — these are forked agents that
+            // inherit the full conversation and would deadlock if blocked here (the compact
+            // agent needs to run to REDUCE the token count).
+            // Also skip when reactive compact is enabled and automatic compaction is
+            // allowed — the preempt's synthetic error returns before the API call,
+            // so reactive compact would never see a prompt-too-long to react to.
+            // Widened to walrus so RC can act as fallback when proactive fails.
+            //
+            // Same skip for context-collapse: its recoverFromOverflow drains
+            // staged collapses on a REAL API 413, then falls through to
+            // reactiveCompact. A synthetic preempt here would return before the
+            // API call and starve both recovery paths. The isAutoCompactEnabled()
+            // conjunct preserves the user's explicit "no automatic anything"
+            // config — if they set DISABLE_AUTO_COMPACT, they get the preempt.
+            let collapseOwnsIt = false;
+            if (feature('CONTEXT_COLLAPSE')) {
+                collapseOwnsIt =
+                    (contextCollapse?.isContextCollapseEnabled() ?? false) &&
+                        isAutoCompactEnabled();
+            }
+            // Hoist media-recovery gate once per turn. Withholding (inside the
+            // stream loop) and recovery (after) must agree; CACHED_MAY_BE_STALE can
+            // flip during the 5-30s stream, and withhold-without-recover would eat
+            // the message. PTL doesn't hoist because its withholding is ungated —
+            // it predates the experiment and is already the control-arm baseline.
+            const mediaRecoveryEnabled = reactiveCompact?.isReactiveCompactEnabled() ?? false;
+            if (!compactionResult &&
+                querySource !== 'compact' &&
+                querySource !== 'session_memory' &&
+                !(reactiveCompact?.isReactiveCompactEnabled() && isAutoCompactEnabled()) &&
+                !collapseOwnsIt) {
+                const { isAtBlockingLimit } = calculateTokenWarningState(tokenCountWithEstimation(messagesForQuery) - snipTokensFreed, toolUseContext.options.mainLoopModel);
+                if (isAtBlockingLimit) {
+                    yield createAssistantAPIErrorMessage({
+                        content: PROMPT_TOO_LONG_ERROR_MESSAGE,
+                        error: 'invalid_request',
+                    });
+                    return { reason: 'blocking_limit' };
+                }
+            }
+            let attemptWithFallback = true;
+            queryCheckpoint('query_api_loop_start');
+            try {
+                while (attemptWithFallback) {
+                    attemptWithFallback = false;
+                    try {
+                        let streamingFallbackOccured = false;
+                        queryCheckpoint('query_api_streaming_start');
+                        for await (const message of deps.callModel({
+                            messages: prependUserContext(messagesForQuery, userContext),
+                            systemPrompt: fullSystemPrompt,
+                            thinkingConfig: toolUseContext.options.thinkingConfig,
+                            tools: toolUseContext.options.tools,
+                            signal: toolUseContext.abortController.signal,
+                            options: {
+                                async getToolPermissionContext() {
+                                    const appState = toolUseContext.getAppState();
+                                    return appState.toolPermissionContext;
+                                },
+                                model: currentModel,
+                                ...(config.gates.fastModeEnabled && {
+                                    fastMode: appState.fastMode,
+                                }),
+                                toolChoice: undefined,
+                                isNonInteractiveSession: toolUseContext.options.isNonInteractiveSession,
+                                fallbackModel,
+                                onStreamingFallback: () => {
+                                    streamingFallbackOccured = true;
+                                },
+                                querySource,
+                                agents: toolUseContext.options.agentDefinitions.activeAgents,
+                                allowedAgentTypes: toolUseContext.options.agentDefinitions.allowedAgentTypes,
+                                hasAppendSystemPrompt: !!toolUseContext.options.appendSystemPrompt,
+                                maxOutputTokensOverride,
+                                fetchOverride: dumpPromptsFetch,
+                                mcpTools: appState.mcp.tools,
+                                hasPendingMcpServers: appState.mcp.clients.some(c => c.type === 'pending'),
+                                queryTracking,
+                                effortValue: appState.effortValue,
+                                advisorModel: appState.advisorModel,
+                                skipCacheWrite,
+                                agentId: toolUseContext.agentId,
+                                addNotification: toolUseContext.addNotification,
+                                ...(params.taskBudget && {
+                                    taskBudget: {
+                                        total: params.taskBudget.total,
+                                        ...(taskBudgetRemaining !== undefined && {
+                                            remaining: taskBudgetRemaining,
+                                        }),
+                                    },
+                                }),
+                            },
+                        })) {
+                            // We won't use the tool_calls from the first attempt
+                            // We could.. but then we'd have to merge assistant messages
+                            // with different ids and double up on full the tool_results
+                            if (streamingFallbackOccured) {
+                                // Yield tombstones for orphaned messages so they're removed from UI and transcript.
+                                // These partial messages (especially thinking blocks) have invalid signatures
+                                // that would cause "thinking blocks cannot be modified" API errors.
+                                for (const msg of assistantMessages) {
+                                    yield { type: 'tombstone', message: msg };
+                                }
+                                logEvent('tengu_orphaned_messages_tombstoned', {
+                                    orphanedMessageCount: assistantMessages.length,
+                                    queryChainId: queryChainIdForAnalytics,
+                                    queryDepth: queryTracking.depth,
+                                });
+                                assistantMessages.length = 0;
+                                toolResults.length = 0;
+                                toolUseBlocks.length = 0;
+                                needsFollowUp = false;
+                                // Discard pending results from the failed streaming attempt and create
+                                // a fresh executor. This prevents orphan tool_results (with old tool_use_ids)
+                                // from being yielded after the fallback response arrives.
+                                if (streamingToolExecutor) {
+                                    streamingToolExecutor.discard();
+                                    streamingToolExecutor = new StreamingToolExecutor(toolUseContext.options.tools, canUseTool, toolUseContext);
+                                }
+                            }
+                            // Backfill tool_use inputs on a cloned message before yield so
+                            // SDK stream output and transcript serialization see legacy/derived
+                            // fields. The original `message` is left untouched for
+                            // assistantMessages.push below — it flows back to the API and
+                            // mutating it would break prompt caching (byte mismatch).
+                            let yieldMessage = message;
+                            if (message.type === 'assistant') {
+                                let clonedContent;
+                                for (let i = 0; i < message.message.content.length; i++) {
+                                    const block = message.message.content[i];
+                                    if (block.type === 'tool_use' &&
+                                        typeof block.input === 'object' &&
+                                        block.input !== null) {
+                                        const tool = findToolByName(toolUseContext.options.tools, block.name);
+                                        if (tool?.backfillObservableInput) {
+                                            const originalInput = block.input;
+                                            const inputCopy = { ...originalInput };
+                                            tool.backfillObservableInput(inputCopy);
+                                            // Only yield a clone when backfill ADDED fields; skip if
+                                            // it only OVERWROTE existing ones (e.g. file tools
+                                            // expanding file_path). Overwrites change the serialized
+                                            // transcript and break VCR fixture hashes on resume,
+                                            // while adding nothing the SDK stream needs — hooks get
+                                            // the expanded path via toolExecution.ts separately.
+                                            const addedFields = Object.keys(inputCopy).some(k => !(k in originalInput));
+                                            if (addedFields) {
+                                                clonedContent ??= [...message.message.content];
+                                                clonedContent[i] = { ...block, input: inputCopy };
+                                            }
+                                        }
+                                    }
+                                }
+                                if (clonedContent) {
+                                    yieldMessage = {
+                                        ...message,
+                                        message: { ...message.message, content: clonedContent },
+                                    };
+                                }
+                            }
+                            // Withhold recoverable errors (prompt-too-long, max-output-tokens)
+                            // until we know whether recovery (collapse drain / reactive
+                            // compact / truncation retry) can succeed. Still pushed to
+                            // assistantMessages so the recovery checks below find them.
+                            // Either subsystem's withhold is sufficient — they're
+                            // independent so turning one off doesn't break the other's
+                            // recovery path.
+                            //
+                            // feature() only works in if/ternary conditions (bun:bundle
+                            // tree-shaking constraint), so the collapse check is nested
+                            // rather than composed.
+                            let withheld = false;
+                            if (feature('CONTEXT_COLLAPSE')) {
+                                if (contextCollapse?.isWithheldPromptTooLong(message, isPromptTooLongMessage, querySource)) {
+                                    withheld = true;
+                                }
+                            }
+                            if (reactiveCompact?.isWithheldPromptTooLong(message)) {
+                                withheld = true;
+                            }
+                            if (mediaRecoveryEnabled &&
+                                reactiveCompact?.isWithheldMediaSizeError(message)) {
+                                withheld = true;
+                            }
+                            if (isWithheldMaxOutputTokens(message)) {
+                                withheld = true;
+                            }
+                            if (!withheld) {
+                                yield yieldMessage;
+                            }
+                            if (message.type === 'assistant') {
+                                assistantMessages.push(message);
+                                const msgToolUseBlocks = message.message.content.filter(content => content.type === 'tool_use');
+                                if (msgToolUseBlocks.length > 0) {
+                                    toolUseBlocks.push(...msgToolUseBlocks);
+                                    needsFollowUp = true;
+                                }
+                                if (streamingToolExecutor &&
+                                    !toolUseContext.abortController.signal.aborted) {
+                                    for (const toolBlock of msgToolUseBlocks) {
+                                        streamingToolExecutor.addTool(toolBlock, message);
+                                    }
+                                }
+                            }
+                            if (streamingToolExecutor &&
+                                !toolUseContext.abortController.signal.aborted) {
+                                for (const result of streamingToolExecutor.getCompletedResults()) {
+                                    if (result.message) {
+                                        yield result.message;
+                                        toolResults.push(...normalizeMessagesForAPI([result.message], toolUseContext.options.tools).filter(_ => _.type === 'user'));
+                                    }
+                                }
+                            }
+                        }
+                        queryCheckpoint('query_api_streaming_end');
+                        // Yield deferred microcompact boundary message using actual API-reported
+                        // token deletion count instead of client-side estimates.
+                        // Entire block gated behind feature() so the excluded string
+                        // is eliminated from external builds.
+                        if (feature('CACHED_MICROCOMPACT') && pendingCacheEdits) {
+                            const lastAssistant = assistantMessages.at(-1);
+                            // The API field is cumulative/sticky across requests, so we
+                            // subtract the baseline captured before this request to get the delta.
+                            const usage = lastAssistant?.message.usage;
+                            const cumulativeDeleted = usage
+                                ? (usage
+                                    .cache_deleted_input_tokens ?? 0)
+                                : 0;
+                            const deletedTokens = Math.max(0, cumulativeDeleted - pendingCacheEdits.baselineCacheDeletedTokens);
+                            if (deletedTokens > 0) {
+                                yield createMicrocompactBoundaryMessage(pendingCacheEdits.trigger, 0, deletedTokens, pendingCacheEdits.deletedToolIds, []);
+                            }
+                        }
+                    }
+                    catch (innerError) {
+                        if (innerError instanceof FallbackTriggeredError && fallbackModel) {
+                            // Fallback was triggered - switch model and retry
+                            currentModel = fallbackModel;
+                            attemptWithFallback = true;
+                            // Clear assistant messages since we'll retry the entire request
+                            yield* yieldMissingToolResultBlocks(assistantMessages, 'Model fallback triggered');
+                            assistantMessages.length = 0;
+                            toolResults.length = 0;
+                            toolUseBlocks.length = 0;
+                            needsFollowUp = false;
+                            // Discard pending results from the failed attempt and create a
+                            // fresh executor. This prevents orphan tool_results (with old
+                            // tool_use_ids) from leaking into the retry.
+                            if (streamingToolExecutor) {
+                                streamingToolExecutor.discard();
+                                streamingToolExecutor = new StreamingToolExecutor(toolUseContext.options.tools, canUseTool, toolUseContext);
+                            }
+                            // Update tool use context with new model
+                            toolUseContext.options.mainLoopModel = fallbackModel;
+                            // Thinking signatures are model-bound: replaying a protected-thinking
+                            // block (e.g. capybara) to an unprotected fallback (e.g. opus) 400s.
+                            // Strip before retry so the fallback model gets clean history.
+                            if (process.env.USER_TYPE === 'ant') {
+                                messagesForQuery = stripSignatureBlocks(messagesForQuery);
+                            }
+                            // Log the fallback event
+                            logEvent('tengu_model_fallback_triggered', {
+                                original_model: innerError.originalModel,
+                                fallback_model: fallbackModel,
+                                entrypoint: 'cli',
+                                queryChainId: queryChainIdForAnalytics,
+                                queryDepth: queryTracking.depth,
+                            });
+                            // Yield system message about fallback — use 'warning' level so
+                            // users see the notification without needing verbose mode
+                            yield createSystemMessage(`Switched to ${renderModelName(innerError.fallbackModel)} due to high demand for ${renderModelName(innerError.originalModel)}`, 'warning');
+                            continue;
+                        }
+                        throw innerError;
+                    }
+                }
+            }
+            catch (error) {
+                logError(error);
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logEvent('tengu_query_error', {
+                    assistantMessages: assistantMessages.length,
+                    toolUses: assistantMessages.flatMap(_ => _.message.content.filter(content => content.type === 'tool_use')).length,
+                    queryChainId: queryChainIdForAnalytics,
+                    queryDepth: queryTracking.depth,
+                });
+                // Handle image size/resize errors with user-friendly messages
+                if (error instanceof ImageSizeError ||
+                    error instanceof ImageResizeError) {
+                    yield createAssistantAPIErrorMessage({
+                        content: error.message,
+                    });
+                    return { reason: 'image_error' };
+                }
+                // Generally queryModelWithStreaming should not throw errors but instead
+                // yield them as synthetic assistant messages. However if it does throw
+                // due to a bug, we may end up in a state where we have already emitted
+                // a tool_use block but will stop before emitting the tool_result.
+                yield* yieldMissingToolResultBlocks(assistantMessages, errorMessage);
+                // Surface the real error instead of a misleading "[Request interrupted
+                // by user]" — this path is a model/runtime failure, not a user action.
+                // SDK consumers were seeing phantom interrupts on e.g. Node 18's missing
+                // Array.prototype.with(), masking the actual cause.
+                yield createAssistantAPIErrorMessage({
+                    content: errorMessage,
+                });
+                // To help track down bugs, log loudly for ants
+                logAntError('Query error', error);
+                return { reason: 'model_error', error };
+            }
+            // Execute post-sampling hooks after model response is complete
+            if (assistantMessages.length > 0) {
+                void executePostSamplingHooks([...messagesForQuery, ...assistantMessages], systemPrompt, userContext, systemContext, toolUseContext, querySource);
+            }
+            // We need to handle a streaming abort before anything else.
+            // When using streamingToolExecutor, we must consume getRemainingResults() so the
+            // executor can generate synthetic tool_result blocks for queued/in-progress tools.
+            // Without this, tool_use blocks would lack matching tool_result blocks.
+            if (toolUseContext.abortController.signal.aborted) {
+                if (streamingToolExecutor) {
+                    // Consume remaining results - executor generates synthetic tool_results for
+                    // aborted tools since it checks the abort signal in executeTool()
+                    for await (const update of streamingToolExecutor.getRemainingResults()) {
+                        if (update.message) {
+                            yield update.message;
+                        }
+                    }
+                }
+                else {
+                    yield* yieldMissingToolResultBlocks(assistantMessages, 'Interrupted by user');
+                }
+                // chicago MCP: auto-unhide + lock release on interrupt. Same cleanup
+                // as the natural turn-end path in stopHooks.ts. Main thread only —
+                // see stopHooks.ts for the subagent-releasing-main's-lock rationale.
+                if (feature('CHICAGO_MCP') && !toolUseContext.agentId) {
+                    try {
+                        const { cleanupComputerUseAfterTurn } = await import('./utils/computerUse/cleanup.js');
+                        await cleanupComputerUseAfterTurn(toolUseContext);
+                    }
+                    catch {
+                        // Failures are silent — this is dogfooding cleanup, not critical path
+                    }
+                }
+                // Skip the interruption message for submit-interrupts — the queued
+                // user message that follows provides sufficient context.
+                if (toolUseContext.abortController.signal.reason !== 'interrupt') {
+                    yield createUserInterruptionMessage({
+                        toolUse: false,
+                    });
+                }
+                return { reason: 'aborted_streaming' };
+            }
+            // Yield tool use summary from previous turn — haiku (~1s) resolved during model streaming (5-30s)
+            if (pendingToolUseSummary) {
+                const summary = await pendingToolUseSummary;
+                if (summary) {
+                    yield summary;
+                }
+            }
+            if (!needsFollowUp) {
+                const lastMessage = assistantMessages.at(-1);
+                // Prompt-too-long recovery: the streaming loop withheld the error
+                // (see withheldByCollapse / withheldByReactive above). Try collapse
+                // drain first (cheap, keeps granular context), then reactive compact
+                // (full summary). Single-shot on each — if a retry still 413's,
+                // the next stage handles it or the error surfaces.
+                const isWithheld413 = lastMessage?.type === 'assistant' &&
+                    lastMessage.isApiErrorMessage &&
+                    isPromptTooLongMessage(lastMessage);
+                // Media-size rejections (image/PDF/many-image) are recoverable via
+                // reactive compact's strip-retry. Unlike PTL, media errors skip the
+                // collapse drain — collapse doesn't strip images. mediaRecoveryEnabled
+                // is the hoisted gate from before the stream loop (same value as the
+                // withholding check — these two must agree or a withheld message is
+                // lost). If the oversized media is in the preserved tail, the
+                // post-compact turn will media-error again; hasAttemptedReactiveCompact
+                // prevents a spiral and the error surfaces.
+                const isWithheldMedia = mediaRecoveryEnabled &&
+                    reactiveCompact?.isWithheldMediaSizeError(lastMessage);
+                if (isWithheld413) {
+                    // First: drain all staged context-collapses. Gated on the PREVIOUS
+                    // transition not being collapse_drain_retry — if we already drained
+                    // and the retry still 413'd, fall through to reactive compact.
+                    if (feature('CONTEXT_COLLAPSE') &&
+                        contextCollapse &&
+                        state.transition?.reason !== 'collapse_drain_retry') {
+                        const drained = contextCollapse.recoverFromOverflow(messagesForQuery, querySource);
+                        if (drained.committed > 0) {
+                            const next = {
+                                messages: drained.messages,
+                                toolUseContext,
+                                autoCompactTracking: tracking,
+                                maxOutputTokensRecoveryCount,
+                                hasAttemptedReactiveCompact,
+                                maxOutputTokensOverride: undefined,
+                                pendingToolUseSummary: undefined,
+                                stopHookActive: undefined,
+                                turnCount,
+                                transition: {
+                                    reason: 'collapse_drain_retry',
+                                    committed: drained.committed,
+                                },
+                            };
+                            state = next;
+                            continue;
+                        }
+                    }
+                }
+                if ((isWithheld413 || isWithheldMedia) && reactiveCompact) {
+                    const compacted = await reactiveCompact.tryReactiveCompact({
+                        hasAttempted: hasAttemptedReactiveCompact,
+                        querySource,
+                        aborted: toolUseContext.abortController.signal.aborted,
+                        messages: messagesForQuery,
+                        cacheSafeParams: {
+                            systemPrompt,
+                            userContext,
+                            systemContext,
+                            toolUseContext,
+                            forkContextMessages: messagesForQuery,
+                        },
+                    });
+                    if (compacted) {
+                        // task_budget: same carryover as the proactive path above.
+                        // messagesForQuery still holds the pre-compact array here (the
+                        // 413-failed attempt's input).
+                        if (params.taskBudget) {
+                            const preCompactContext = finalContextTokensFromLastResponse(messagesForQuery);
+                            taskBudgetRemaining = Math.max(0, (taskBudgetRemaining ?? params.taskBudget.total) -
+                                preCompactContext);
+                        }
+                        const postCompactMessages = buildPostCompactMessages(compacted);
+                        for (const msg of postCompactMessages) {
+                            yield msg;
+                        }
+                        const next = {
+                            messages: postCompactMessages,
+                            toolUseContext,
+                            autoCompactTracking: undefined,
+                            maxOutputTokensRecoveryCount,
+                            hasAttemptedReactiveCompact: true,
+                            maxOutputTokensOverride: undefined,
+                            pendingToolUseSummary: undefined,
+                            stopHookActive: undefined,
+                            turnCount,
+                            transition: { reason: 'reactive_compact_retry' },
+                        };
+                        state = next;
+                        continue;
+                    }
+                    // No recovery — surface the withheld error and exit. Do NOT fall
+                    // through to stop hooks: the model never produced a valid response,
+                    // so hooks have nothing meaningful to evaluate. Running stop hooks
+                    // on prompt-too-long creates a death spiral: error → hook blocking
+                    // → retry → error → … (the hook injects more tokens each cycle).
+                    yield lastMessage;
+                    void executeStopFailureHooks(lastMessage, toolUseContext);
+                    return { reason: isWithheldMedia ? 'image_error' : 'prompt_too_long' };
+                }
+                else if (feature('CONTEXT_COLLAPSE') && isWithheld413) {
+                    // reactiveCompact compiled out but contextCollapse withheld and
+                    // couldn't recover (staged queue empty/stale). Surface. Same
+                    // early-return rationale — don't fall through to stop hooks.
+                    yield lastMessage;
+                    void executeStopFailureHooks(lastMessage, toolUseContext);
+                    return { reason: 'prompt_too_long' };
+                }
+                // Check for max_output_tokens and inject recovery message. The error
+                // was withheld from the stream above; only surface it if recovery
+                // exhausts.
+                if (isWithheldMaxOutputTokens(lastMessage)) {
+                    // Escalating retry: if we used the capped 8k default and hit the
+                    // limit, retry the SAME request at 64k — no meta message, no
+                    // multi-turn dance. This fires once per turn (guarded by the
+                    // override check), then falls through to multi-turn recovery if
+                    // 64k also hits the cap.
+                    // 3P default: false (not validated on Bedrock/Vertex)
+                    const capEnabled = getFeatureValue_CACHED_MAY_BE_STALE('tengu_otk_slot_v1', false);
+                    if (capEnabled &&
+                        maxOutputTokensOverride === undefined &&
+                        !process.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS) {
+                        logEvent('tengu_max_tokens_escalate', {
+                            escalatedTo: ESCALATED_MAX_TOKENS,
+                        });
+                        const next = {
+                            messages: messagesForQuery,
+                            toolUseContext,
+                            autoCompactTracking: tracking,
+                            maxOutputTokensRecoveryCount,
+                            hasAttemptedReactiveCompact,
+                            maxOutputTokensOverride: ESCALATED_MAX_TOKENS,
+                            pendingToolUseSummary: undefined,
+                            stopHookActive: undefined,
+                            turnCount,
+                            transition: { reason: 'max_output_tokens_escalate' },
+                        };
+                        state = next;
+                        continue;
+                    }
+                    if (maxOutputTokensRecoveryCount < MAX_OUTPUT_TOKENS_RECOVERY_LIMIT) {
+                        const recoveryMessage = createUserMessage({
+                            content: `Output token limit hit. Resume directly — no apology, no recap of what you were doing. ` +
+                                `Pick up mid-thought if that is where the cut happened. Break remaining work into smaller pieces.`,
+                            isMeta: true,
+                        });
+                        const next = {
+                            messages: [
+                                ...messagesForQuery,
+                                ...assistantMessages,
+                                recoveryMessage,
+                            ],
+                            toolUseContext,
+                            autoCompactTracking: tracking,
+                            maxOutputTokensRecoveryCount: maxOutputTokensRecoveryCount + 1,
+                            hasAttemptedReactiveCompact,
+                            maxOutputTokensOverride: undefined,
+                            pendingToolUseSummary: undefined,
+                            stopHookActive: undefined,
+                            turnCount,
+                            transition: {
+                                reason: 'max_output_tokens_recovery',
+                                attempt: maxOutputTokensRecoveryCount + 1,
+                            },
+                        };
+                        state = next;
+                        continue;
+                    }
+                    // Recovery exhausted — surface the withheld error now.
+                    yield lastMessage;
+                }
+                // Skip stop hooks when the last message is an API error (rate limit,
+                // prompt-too-long, auth failure, etc.). The model never produced a
+                // real response — hooks evaluating it create a death spiral:
+                // error → hook blocking → retry → error → …
+                if (lastMessage?.isApiErrorMessage) {
+                    void executeStopFailureHooks(lastMessage, toolUseContext);
+                    return { reason: 'completed' };
+                }
+                const stopHookResult = yield* handleStopHooks(messagesForQuery, assistantMessages, systemPrompt, userContext, systemContext, toolUseContext, querySource, stopHookActive);
+                if (stopHookResult.preventContinuation) {
+                    return { reason: 'stop_hook_prevented' };
+                }
+                if (stopHookResult.blockingErrors.length > 0) {
+                    const next = {
+                        messages: [
+                            ...messagesForQuery,
+                            ...assistantMessages,
+                            ...stopHookResult.blockingErrors,
+                        ],
+                        toolUseContext,
+                        autoCompactTracking: tracking,
+                        maxOutputTokensRecoveryCount: 0,
+                        // Preserve the reactive compact guard — if compact already ran and
+                        // couldn't recover from prompt-too-long, retrying after a stop-hook
+                        // blocking error will produce the same result. Resetting to false
+                        // here caused an infinite loop: compact → still too long → error →
+                        // stop hook blocking → compact → … burning thousands of API calls.
+                        hasAttemptedReactiveCompact,
+                        maxOutputTokensOverride: undefined,
+                        pendingToolUseSummary: undefined,
+                        stopHookActive: true,
+                        turnCount,
+                        transition: { reason: 'stop_hook_blocking' },
+                    };
+                    state = next;
+                    continue;
+                }
+                if (feature('TOKEN_BUDGET')) {
+                    const decision = checkTokenBudget(budgetTracker, toolUseContext.agentId, getCurrentTurnTokenBudget(), getTurnOutputTokens());
+                    if (decision.action === 'continue') {
+                        incrementBudgetContinuationCount();
+                        logForDebugging(`Token budget continuation #${decision.continuationCount}: ${decision.pct}% (${decision.turnTokens.toLocaleString()} / ${decision.budget.toLocaleString()})`);
+                        state = {
+                            messages: [
+                                ...messagesForQuery,
+                                ...assistantMessages,
+                                createUserMessage({
+                                    content: decision.nudgeMessage,
+                                    isMeta: true,
+                                }),
+                            ],
+                            toolUseContext,
+                            autoCompactTracking: tracking,
+                            maxOutputTokensRecoveryCount: 0,
+                            hasAttemptedReactiveCompact: false,
+                            maxOutputTokensOverride: undefined,
+                            pendingToolUseSummary: undefined,
+                            stopHookActive: undefined,
+                            turnCount,
+                            transition: { reason: 'token_budget_continuation' },
+                        };
+                        continue;
+                    }
+                    if (decision.completionEvent) {
+                        if (decision.completionEvent.diminishingReturns) {
+                            logForDebugging(`Token budget early stop: diminishing returns at ${decision.completionEvent.pct}%`);
+                        }
+                        logEvent('tengu_token_budget_completed', {
+                            ...decision.completionEvent,
+                            queryChainId: queryChainIdForAnalytics,
+                            queryDepth: queryTracking.depth,
+                        });
+                    }
+                }
+                return { reason: 'completed' };
+            }
+            let shouldPreventContinuation = false;
+            let updatedToolUseContext = toolUseContext;
+            queryCheckpoint('query_tool_execution_start');
+            if (streamingToolExecutor) {
+                logEvent('tengu_streaming_tool_execution_used', {
+                    tool_count: toolUseBlocks.length,
+                    queryChainId: queryChainIdForAnalytics,
+                    queryDepth: queryTracking.depth,
+                });
+            }
+            else {
+                logEvent('tengu_streaming_tool_execution_not_used', {
+                    tool_count: toolUseBlocks.length,
+                    queryChainId: queryChainIdForAnalytics,
+                    queryDepth: queryTracking.depth,
+                });
+            }
+            const toolUpdates = streamingToolExecutor
+                ? streamingToolExecutor.getRemainingResults()
+                : runTools(toolUseBlocks, assistantMessages, canUseTool, toolUseContext);
+            for await (const update of toolUpdates) {
+                if (update.message) {
+                    yield update.message;
+                    if (update.message.type === 'attachment' &&
+                        update.message.attachment.type === 'hook_stopped_continuation') {
+                        shouldPreventContinuation = true;
+                    }
+                    toolResults.push(...normalizeMessagesForAPI([update.message], toolUseContext.options.tools).filter(_ => _.type === 'user'));
+                }
+                if (update.newContext) {
+                    updatedToolUseContext = {
+                        ...update.newContext,
+                        queryTracking,
+                    };
+                }
+            }
+            queryCheckpoint('query_tool_execution_end');
+            // Generate tool use summary after tool batch completes — passed to next recursive call
+            let nextPendingToolUseSummary;
+            if (config.gates.emitToolUseSummaries &&
+                toolUseBlocks.length > 0 &&
+                !toolUseContext.abortController.signal.aborted &&
+                !toolUseContext.agentId // subagents don't surface in mobile UI — skip the Haiku call
+            ) {
+                // Extract the last assistant text block for context
+                const lastAssistantMessage = assistantMessages.at(-1);
+                let lastAssistantText;
+                if (lastAssistantMessage) {
+                    const textBlocks = lastAssistantMessage.message.content.filter(block => block.type === 'text');
+                    if (textBlocks.length > 0) {
+                        const lastTextBlock = textBlocks.at(-1);
+                        if (lastTextBlock && 'text' in lastTextBlock) {
+                            lastAssistantText = lastTextBlock.text;
+                        }
+                    }
+                }
+                // Collect tool info for summary generation
+                const toolUseIds = toolUseBlocks.map(block => block.id);
+                const toolInfoForSummary = toolUseBlocks.map(block => {
+                    // Find the corresponding tool result
+                    const toolResult = toolResults.find(result => result.type === 'user' &&
+                        Array.isArray(result.message.content) &&
+                        result.message.content.some(content => content.type === 'tool_result' &&
+                            content.tool_use_id === block.id));
+                    const resultContent = toolResult?.type === 'user' &&
+                        Array.isArray(toolResult.message.content)
+                        ? toolResult.message.content.find((c) => c.type === 'tool_result' && c.tool_use_id === block.id)
+                        : undefined;
+                    return {
+                        name: block.name,
+                        input: block.input,
+                        output: resultContent && 'content' in resultContent
+                            ? resultContent.content
+                            : null,
+                    };
+                });
+                // Fire off summary generation without blocking the next API call
+                nextPendingToolUseSummary = generateToolUseSummary({
+                    tools: toolInfoForSummary,
+                    signal: toolUseContext.abortController.signal,
+                    isNonInteractiveSession: toolUseContext.options.isNonInteractiveSession,
+                    lastAssistantText,
+                })
+                    .then(summary => {
+                    if (summary) {
+                        return createToolUseSummaryMessage(summary, toolUseIds);
+                    }
+                    return null;
+                })
+                    .catch(() => null);
+            }
+            // We were aborted during tool calls
+            if (toolUseContext.abortController.signal.aborted) {
+                // chicago MCP: auto-unhide + lock release when aborted mid-tool-call.
+                // This is the most likely Ctrl+C path for CU (e.g. slow screenshot).
+                // Main thread only — see stopHooks.ts for the subagent rationale.
+                if (feature('CHICAGO_MCP') && !toolUseContext.agentId) {
+                    try {
+                        const { cleanupComputerUseAfterTurn } = await import('./utils/computerUse/cleanup.js');
+                        await cleanupComputerUseAfterTurn(toolUseContext);
+                    }
+                    catch {
+                        // Failures are silent — this is dogfooding cleanup, not critical path
+                    }
+                }
+                // Skip the interruption message for submit-interrupts — the queued
+                // user message that follows provides sufficient context.
+                if (toolUseContext.abortController.signal.reason !== 'interrupt') {
+                    yield createUserInterruptionMessage({
+                        toolUse: true,
+                    });
+                }
+                // Check maxTurns before returning when aborted
+                const nextTurnCountOnAbort = turnCount + 1;
+                if (maxTurns && nextTurnCountOnAbort > maxTurns) {
+                    yield createAttachmentMessage({
+                        type: 'max_turns_reached',
+                        maxTurns,
+                        turnCount: nextTurnCountOnAbort,
+                    });
+                }
+                return { reason: 'aborted_tools' };
+            }
+            // If a hook indicated to prevent continuation, stop here
+            if (shouldPreventContinuation) {
+                return { reason: 'hook_stopped' };
+            }
+            if (tracking?.compacted) {
+                tracking.turnCounter++;
+                logEvent('tengu_post_autocompact_turn', {
+                    turnId: tracking.turnId,
+                    turnCounter: tracking.turnCounter,
+                    queryChainId: queryChainIdForAnalytics,
+                    queryDepth: queryTracking.depth,
+                });
+            }
+            // Be careful to do this after tool calls are done, because the API
+            // will error if we interleave tool_result messages with regular user messages.
+            // Instrumentation: Track message count before attachments
+            logEvent('tengu_query_before_attachments', {
+                messagesForQueryCount: messagesForQuery.length,
+                assistantMessagesCount: assistantMessages.length,
+                toolResultsCount: toolResults.length,
+                queryChainId: queryChainIdForAnalytics,
+                queryDepth: queryTracking.depth,
+            });
+            // Get queued commands snapshot before processing attachments.
+            // These will be sent as attachments so Claude can respond to them in the current turn.
+            //
+            // Drain pending notifications. LocalShellTask completions are 'next'
+            // (when MONITOR_TOOL is on) and drain without Sleep. Other task types
+            // (agent/workflow/framework) still default to 'later' — the Sleep flush
+            // covers those. If all task types move to 'next', this branch could go.
+            //
+            // Slash commands are excluded from mid-turn drain — they must go through
+            // processSlashCommand after the turn ends (via useQueueProcessor), not be
+            // sent to the model as text. Bash-mode commands are already excluded by
+            // INLINE_NOTIFICATION_MODES in getQueuedCommandAttachments.
+            //
+            // Agent scoping: the queue is a process-global singleton shared by the
+            // coordinator and all in-process subagents. Each loop drains only what's
+            // addressed to it — main thread drains agentId===undefined, subagents
+            // drain their own agentId. User prompts (mode:'prompt') still go to main
+            // only; subagents never see the prompt stream.
+            // eslint-disable-next-line custom-rules/require-tool-match-name -- ToolUseBlock.name has no aliases
+            const sleepRan = toolUseBlocks.some(b => b.name === SLEEP_TOOL_NAME);
+            const isMainThread = querySource.startsWith('repl_main_thread') || querySource === 'sdk';
+            const currentAgentId = toolUseContext.agentId;
+            const queuedCommandsSnapshot = getCommandsByMaxPriority(sleepRan ? 'later' : 'next').filter(cmd => {
+                if (isSlashCommand(cmd))
+                    return false;
+                if (isMainThread)
+                    return cmd.agentId === undefined;
+                // Subagents only drain task-notifications addressed to them — never
+                // user prompts, even if someone stamps an agentId on one.
+                return cmd.mode === 'task-notification' && cmd.agentId === currentAgentId;
+            });
+            for await (const attachment of getAttachmentMessages(null, updatedToolUseContext, null, queuedCommandsSnapshot, [...messagesForQuery, ...assistantMessages, ...toolResults], querySource)) {
+                yield attachment;
+                toolResults.push(attachment);
+            }
+            // Memory prefetch consume: only if settled and not already consumed on
+            // an earlier iteration. If not settled yet, skip (zero-wait) and retry
+            // next iteration — the prefetch gets as many chances as there are loop
+            // iterations before the turn ends. readFileState (cumulative across
+            // iterations) filters out memories the model already Read/Wrote/Edited
+            // — including in earlier iterations, which the per-iteration
+            // toolUseBlocks array would miss.
+            if (pendingMemoryPrefetch &&
+                pendingMemoryPrefetch.settledAt !== null &&
+                pendingMemoryPrefetch.consumedOnIteration === -1) {
+                const memoryAttachments = filterDuplicateMemoryAttachments(await pendingMemoryPrefetch.promise, toolUseContext.readFileState);
+                for (const memAttachment of memoryAttachments) {
+                    const msg = createAttachmentMessage(memAttachment);
+                    yield msg;
+                    toolResults.push(msg);
+                }
+                pendingMemoryPrefetch.consumedOnIteration = turnCount - 1;
+            }
+            // Inject prefetched skill discovery. collectSkillDiscoveryPrefetch emits
+            // hidden_by_main_turn — true when the prefetch resolved before this point
+            // (should be >98% at AKI@250ms / Haiku@573ms vs turn durations of 2-30s).
+            if (skillPrefetch && pendingSkillPrefetch) {
+                const skillAttachments = await skillPrefetch.collectSkillDiscoveryPrefetch(pendingSkillPrefetch);
+                for (const att of skillAttachments) {
+                    const msg = createAttachmentMessage(att);
+                    yield msg;
+                    toolResults.push(msg);
+                }
+            }
+            // Remove only commands that were actually consumed as attachments.
+            // Prompt and task-notification commands are converted to attachments above.
+            const consumedCommands = queuedCommandsSnapshot.filter(cmd => cmd.mode === 'prompt' || cmd.mode === 'task-notification');
+            if (consumedCommands.length > 0) {
+                for (const cmd of consumedCommands) {
+                    if (cmd.uuid) {
+                        consumedCommandUuids.push(cmd.uuid);
+                        notifyCommandLifecycle(cmd.uuid, 'started');
+                    }
+                }
+                removeFromQueue(consumedCommands);
+            }
+            // Instrumentation: Track file change attachments after they're added
+            const fileChangeAttachmentCount = count(toolResults, tr => tr.type === 'attachment' && tr.attachment.type === 'edited_text_file');
+            logEvent('tengu_query_after_attachments', {
+                totalToolResultsCount: toolResults.length,
+                fileChangeAttachmentCount,
+                queryChainId: queryChainIdForAnalytics,
+                queryDepth: queryTracking.depth,
+            });
+            // Refresh tools between turns so newly-connected MCP servers become available
+            if (updatedToolUseContext.options.refreshTools) {
+                const refreshedTools = updatedToolUseContext.options.refreshTools();
+                if (refreshedTools !== updatedToolUseContext.options.tools) {
+                    updatedToolUseContext = {
+                        ...updatedToolUseContext,
+                        options: {
+                            ...updatedToolUseContext.options,
+                            tools: refreshedTools,
+                        },
+                    };
+                }
+            }
+            const toolUseContextWithQueryTracking = {
+                ...updatedToolUseContext,
+                queryTracking,
+            };
+            // Each time we have tool results and are about to recurse, that's a turn
+            const nextTurnCount = turnCount + 1;
+            // Periodic task summary for `claude ps` — fires mid-turn so a
+            // long-running agent still refreshes what it's working on. Gated
+            // only on !agentId so every top-level conversation (REPL, SDK, HFI,
+            // remote) generates summaries; subagents/forks don't.
+            if (feature('BG_SESSIONS')) {
+                if (!toolUseContext.agentId &&
+                    taskSummaryModule.shouldGenerateTaskSummary()) {
+                    taskSummaryModule.maybeGenerateTaskSummary({
+                        systemPrompt,
+                        userContext,
+                        systemContext,
+                        toolUseContext,
+                        forkContextMessages: [
+                            ...messagesForQuery,
+                            ...assistantMessages,
+                            ...toolResults,
+                        ],
+                    });
+                }
+            }
+            // Check if we've reached the max turns limit
+            if (maxTurns && nextTurnCount > maxTurns) {
+                yield createAttachmentMessage({
+                    type: 'max_turns_reached',
+                    maxTurns,
+                    turnCount: nextTurnCount,
+                });
+                return { reason: 'max_turns', turnCount: nextTurnCount };
+            }
+            queryCheckpoint('query_recursive_call');
+            const next = {
+                messages: [...messagesForQuery, ...assistantMessages, ...toolResults],
+                toolUseContext: toolUseContextWithQueryTracking,
+                autoCompactTracking: tracking,
+                turnCount: nextTurnCount,
+                maxOutputTokensRecoveryCount: 0,
+                hasAttemptedReactiveCompact: false,
+                pendingToolUseSummary: nextPendingToolUseSummary,
+                maxOutputTokensOverride: undefined,
+                stopHookActive,
+                transition: { reason: 'next_turn' },
+            };
+            state = next;
+        } // while (true)
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}