muonroi-cli 1.2.3 → 1.3.1

package/dist/src/orchestrator/message-processor.js

@@ -0,0 +1,1675 @@
+// MessageProcessor — extracted from orchestrator.ts as part of Phase 12.4.
+//
+// Owns the main streaming turn loop that lives in `Agent.processMessage`:
+//   - Abort wiring (external AbortContext + per-turn AbortController)
+//   - Trajectory + phase tracker observations on user_turn / abort
+//   - PIL enrichment pipeline (layers 1/3/6 — fail-open with logging)
+//   - ROUTE-11 per-turn model routing (decide + fallback to non-disabled
+//     provider via CouncilManager)
+//   - Vision proxy (history + current turn)
+//   - Auto-council gate (PIL taskType + heavy tier + role count) — routes
+//     into runCouncilV2 and re-enters processMessage with synthesis
+//   - System prompt assembly (chitchat / playwright gating + PIL suffix +
+//     model constraints)
+//   - SAMR step-aware routing (phase1 reasoning → phase2 execution)
+//   - Tool roundtrip loop:
+//       - Compaction (relax on overflow recovery, B4 top-level prepareStep)
+//       - Tool set assembly: builtin + MCP (smart filter for chitchat /
+//         browser-vocab) + PIL response tools, all wrapped with top-level
+//         cumulative cap (F1), cross-turn dedup (C3), read-path budget
+//       - ProviderOptions composition (buildTurnProviderOptions +
+//         taskTypeToReasoningEffort budget + thinkingType adaptive override
+//         + O1 shape capture)
+//       - streamText({...}) with prepareStep (top-level compactor +
+//         capability sanitizeHistory), onStepStart/Finish, onFinish
+//         (correlation cleanup)
+//       - fullStream consumer (text-delta / reasoning-delta / tool-call
+//         with EE PreToolUse intercept / tool-result with EE PostToolUse
+//         and vision-bridge / tool-error / tool-approval-request /
+//         error / abort)
+//   - Write-ahead persistence (Phase A4 tool_calls, A5 message_seq)
+//   - Context-overflow recovery + transient retry with exponential backoff
+//   - Post-turn compact + Stop / StopFailure hooks
+//   - Debug pipeline trace
+//
+// Zero behavioral changes — every method body mirrors the original
+// `processMessage` (see commit history). The DI surface (`MessageProcessorDeps`)
+// is the minimum proxy onto Agent state needed to reach back into Agent
+// without holding a circular reference. Public `Agent.processMessage`
+// signature is unchanged and continues to be the entrypoint; internally it
+// constructs a `MessageProcessor` per call.
+//
+// Cost-leak code paths preserved here:
+//   - F1 (top-level cumulative cap)         — wrapToolSetWithCap (top-level)
+//   - F1 (openai.promptCacheKey)            — buildTurnProviderOptions
+//   - G1 (OAuth `maxOutputTokens` drop)     — shouldDropParam(runtime, ...)
+//   - B4 (top-level prepareStep compaction) — compactSubAgentMessages
+//   - C3 (cross-turn dedup wrap)            — wrapToolSetWithDedup
+//   - A4 (tool_call write-ahead)            — persistToolCallWriteAhead
+//   - A5 (message_seq write-ahead)          — persistMessageWriteAhead
+//   - O1 (providerOptions shape forensics)  — extractProviderOptionsShape
+//   - siliconflow reasoning-strip           — turnCaps.sanitizeHistory
+import { stepCountIs, streamText } from "ai";
+import { getCachedAuthToken, getCachedServerBaseUrl } from "../ee/auth.js";
+import { routeFeedback, routeModel } from "../ee/bridge.js";
+import { getMistakeDetector } from "../ee/mistake-detector.js";
+import { fireAndForgetPhaseOutcome } from "../ee/phase-outcome.js";
+import * as phaseTracker from "../ee/phase-tracker.js";
+import { buildScope as buildScopeForVeto } from "../ee/scope.js";
+import { fireTrajectoryEvent } from "../ee/session-trajectory.js";
+import { getTenantId as getTenantIdForVeto } from "../ee/tenant.js";
+import { buildMcpToolSet } from "../mcp/runtime.js";
+import { getModelInfo } from "../models/registry.js";
+import { applyPilSuffix, getResponseTaskType, getResponseToolSet, isResponseTool, runPipeline } from "../pil/index.js";
+import { taskTypeToMaxTokens, taskTypeToReasoningEffort, taskTypeToTier } from "../pil/task-tier-map.js";
+import { getProviderCapabilities } from "../providers/capabilities.js";
+import { loadKeyForProvider } from "../providers/keychain.js";
+import { bridgeMcpToolResult, getVisionGuidanceForTextOnly, scrubImagePayloadsInMessages, } from "../providers/mcp-vision-bridge.js";
+import { captureToolSchemas } from "../providers/patch-zod-schema.js";
+import { buildTurnProviderOptions, detectProviderForModel, resolveModelRuntime, shouldDropParam, } from "../providers/runtime.js";
+import { needsVisionProxy, proxyVision } from "../providers/vision-proxy.js";
+import { wireDebug } from "../providers/wire-debug.js";
+import { reportRouteOutcome } from "../router/decide.js";
+import { decideStepRouting, getStepRouterConfig } from "../router/step-router.js";
+import { routerStore } from "../router/store.js";
+import { getNextMessageSequence, logInteraction, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, } from "../storage/index.js";
+import { createBuiltinTools } from "../tools/registry.js";
+import { isDebugEnabled, recordTurnTrace } from "../ui/slash/debug.js";
+import { statusBarStore } from "../ui/status-bar/store.js";
+import { appendDecisionLog } from "../usage/decision-log.js";
+import { toolNeedsApproval } from "../utils/permission-mode.js";
+import { getAutoCouncilConfidence, getAutoCouncilMinRoles, getRoleModels, getTopLevelCompactKeepLast, getTopLevelCompactThresholdChars, getTopLevelToolBudgetChars, isAutoCouncilEnabled, isProviderDisabled, loadMcpServers, loadValidSubAgents, } from "../utils/settings.js";
+import { relaxCompactionSettings } from "./compaction.js";
+import { wrapToolSetWithDedup } from "./cross-turn-dedup.js";
+import { humanizeApiError, isAuthenticationError, isContextLimitError } from "./error-utils.js";
+import { stableCallId } from "./pending-calls.js";
+import { applyModelConstraints, buildSystemPromptParts } from "./prompts.js";
+import { extractProviderOptionsShape } from "./provider-options-shape.js";
+import { wrapToolSetWithReadBudget } from "./read-path-budget.js";
+import { containsEncryptedReasoning, sanitizeModelMessages } from "./reasoning.js";
+import { classifyStreamError } from "./retry-classifier.js";
+import { wrapToolSetWithCap } from "./sub-agent-cap.js";
+import { compactSubAgentMessages } from "./subagent-compactor.js";
+import { combineAbortSignals, getFinishReason, getStepNumber, getUsage, notifyObserver, toToolCall, toToolResult, } from "./tool-utils.js";
+/**
+ * MessageProcessor — extracted streaming turn loop.
+ *
+ * Lifecycle:
+ *   const processor = new MessageProcessor(deps);
+ *   yield* processor.run(userMessage, observer, images);
+ *
+ * Constructed per call (heap allocation is negligible against the streamText
+ * cost), matching the StreamRunner / CouncilManager pattern.
+ */
+export class MessageProcessor {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async *run(userMessage, observer, images) {
+        const deps = this.deps;
+        // TUI-04: prefer the external AbortContext (from SIGINT handler) so that
+        // Ctrl+C mid-tool-call triggers a single, unified abort across all I/O.
+        // If no external context, fall back to creating a local AbortController.
+        if (deps.externalAbortContext) {
+            // Wrap the external signal in a local controller so existing cleanup
+            // paths (setAbortController(null)) still work without side-effects.
+            const ctrl = new AbortController();
+            deps.setAbortController(ctrl);
+            // Forward external abort to the local controller.
+            deps.externalAbortContext.signal.addEventListener("abort", () => {
+                deps.getAbortController()?.abort(deps.externalAbortContext?.reason());
+            }, { once: true });
+        }
+        else {
+            deps.setAbortController(new AbortController());
+        }
+        const signal = deps.getAbortController().signal;
+        deps.emitSubagentStatus(null);
+        // Phase C3: advance the cross-turn dedup turn counter so stubs can point
+        // back to the correct prior turn.
+        deps.crossTurnDedup?.beginTurn();
+        // P0 native observation: turn boundary. Capture the prior batch via
+        // resetBatch — file-revert detection (in the hook layer) reads it on
+        // the first edit of the new turn. No language-based veto matching.
+        try {
+            getMistakeDetector().resetBatch();
+            if (deps.session?.id) {
+                fireTrajectoryEvent({
+                    ts: new Date().toISOString(),
+                    sessionId: deps.session.id,
+                    kind: "user_turn",
+                    excerpt: userMessage.slice(0, 200),
+                    vetoDetected: false,
+                });
+            }
+        }
+        catch {
+            /* fail-open: detector state must never block the turn */
+        }
+        // P0 native observation: AbortSignal → fire user-veto for any in-flight
+        // batch tools that had warnings. Listener attaches here and self-removes
+        // after fire so it can't double-fire on later aborts in the same turn.
+        {
+            const aborter = () => {
+                try {
+                    // P1 Item 3 wiring: mark current phase aborted so the next setPhase
+                    // call drains an "abandoned" outcome.
+                    phaseTracker.markAborted(deps.getAbortController()?.signal.reason ? String(deps.getAbortController().signal.reason) : undefined);
+                }
+                catch {
+                    /* fail-open */
+                }
+                try {
+                    const det = getMistakeDetector();
+                    const events = det.detectAbort(deps.getAbortController()?.signal.reason ? String(deps.getAbortController().signal.reason) : undefined);
+                    if (events.length === 0)
+                        return;
+                    const cwd = deps.bash.getCwd();
+                    const tenantId = getTenantIdForVeto();
+                    void buildScopeForVeto({ cwd })
+                        .then(async (scope) => {
+                        const { getDefaultEEClient } = await import("../ee/intercept.js");
+                        for (const ev of events) {
+                            void getDefaultEEClient()
+                                .posttool({
+                                toolName: ev.toolName,
+                                toolInput: ev.toolInput,
+                                outcome: { success: false, mistakeKind: ev.kind, evidence: ev.evidence },
+                                cwd,
+                                tenantId,
+                                scope,
+                            })
+                                .catch(() => {
+                                /* fire-and-forget */
+                            });
+                        }
+                    })
+                        .catch(() => {
+                        /* fire-and-forget */
+                    });
+                }
+                catch {
+                    /* fail-open */
+                }
+            };
+            signal.addEventListener("abort", aborter, { once: true });
+        }
+        // P0 native observation: cache turn-level intent fields for PreToolUse.
+        deps.setTurnUserGoalExcerpt(userMessage.slice(0, 200));
+        deps.setTurnAssistantReasoning("");
+        // Ensure flow run is ready before processing (fail-open).
+        await deps.flowReady?.catch(() => { });
+        // Upgrade to OAuth-backed provider on first turn if tokens are available.
+        await deps.initOAuthProvider().catch(() => { });
+        if (!deps.getSessionStartHookFired()) {
+            deps.setSessionStartHookFired(true);
+            const isResume = deps.messages.length > 0;
+            const sessionStartInput = {
+                hook_event_name: "SessionStart",
+                source: isResume ? "resume" : "startup",
+                session_id: deps.session?.id,
+                cwd: deps.bash.getCwd(),
+            };
+            await deps.fireHook(sessionStartInput, signal).catch(() => { });
+        }
+        const promptInput = {
+            hook_event_name: "UserPromptSubmit",
+            user_prompt: userMessage,
+            session_id: deps.session?.id,
+            cwd: deps.bash.getCwd(),
+        };
+        await deps.fireHook(promptInput, signal).catch(() => { });
+        await deps.consumeBackgroundNotifications();
+        const _debugOn = isDebugEnabled();
+        const _debugSteps = [];
+        const _debugTurnId = deps.messages.filter((m) => m.role === "user").length + 1;
+        // PIL: enrich prompt before pushing to messages (D-01, D-03, D-04)
+        // Promise.race timeout of 200ms is inside runPipeline — fail-open guaranteed
+        const _pilStart = Date.now();
+        const pilCtx = await runPipeline(userMessage, {
+            resumeDigest: deps.getResumeDigest(),
+            activeRunId: deps.getActiveRunId(),
+            sessionId: deps.session?.id ?? null,
+        }).catch((err) => ({
+            raw: userMessage,
+            enriched: userMessage,
+            taskType: null,
+            domain: null,
+            confidence: 0,
+            outputStyle: null,
+            tokenBudget: 500,
+            metrics: null,
+            layers: [],
+            gsdPhase: null,
+            activeRunId: null,
+            intentKind: null,
+            fallbackReason: err instanceof Error ? `orchestrator-catch:${err.name}` : "orchestrator-catch:unknown",
+        }));
+        // Cheap signal forwarded from PIL Layer 1 — true when input is greeting /
+        // small-talk (≤10 chars + ≤2 words OR brain-classified "none"). Used to
+        // skip the MCP tool catalog, which dominates input tokens (~20K) and is
+        // useless for "hi" / "ok" / "thanks".
+        const isChitchat = pilCtx.intentKind === "chitchat";
+        const enrichedMessage = pilCtx.enriched;
+        deps.setPilActive(pilCtx.taskType !== null);
+        deps.setPilEnrichmentDelta(pilCtx.metrics?.suffixInstructionTokens ?? Math.round((enrichedMessage.length - userMessage.length) / 4));
+        const _pilEnrichmentDeltaSnapshot = pilCtx.metrics?.suffixInstructionTokens ?? Math.round((enrichedMessage.length - userMessage.length) / 4);
+        // P1 Item 3 wiring: phase-boundary detection. setPhase returns a snapshot
+        // of the prior phase iff the phase NAME just changed. We classify the
+        // outcome (pass/fail/abandoned/null) and fire phase-outcome to the EE
+        // server when there is a high-SNR verdict. Endpoint is feature-flagged
+        // server-side; 404 is silently swallowed by the client wrapper.
+        try {
+            const drained = phaseTracker.setPhase(pilCtx.gsdPhase ?? null);
+            if (drained && drained.principleRefs.length > 0 && deps.session?.id) {
+                const outcome = phaseTracker.classifyOutcome(drained);
+                if (outcome) {
+                    fireAndForgetPhaseOutcome({
+                        sessionId: deps.session.id,
+                        phaseName: drained.phaseName,
+                        outcome,
+                        toolEventIds: drained.principleRefs,
+                        evidence: {
+                            durationMs: drained.endedAt - drained.startedAt,
+                            toolCount: drained.toolCount,
+                            cwd: deps.bash.getCwd(),
+                            ...(drained.verifyResult ? { verifyResult: drained.verifyResult } : {}),
+                            ...(drained.aborted ? { aborted: true } : {}),
+                            ...(drained.abortReason ? { abortReason: drained.abortReason } : {}),
+                        },
+                    }, {
+                        ...(getCachedServerBaseUrl() ? { baseUrl: getCachedServerBaseUrl() } : {}),
+                        ...(getCachedAuthToken() ? { authToken: getCachedAuthToken() } : {}),
+                    });
+                }
+            }
+        }
+        catch {
+            /* fail-open: phase-outcome must never block a turn */
+        }
+        if (_debugOn) {
+            const appliedLayers = pilCtx.layers?.filter((l) => l.applied).map((l) => l.name) ?? [];
+            _debugSteps.push({
+                name: "PIL Pipeline",
+                duration_ms: Date.now() - _pilStart,
+                input_summary: `"${userMessage.slice(0, 60)}${userMessage.length > 60 ? "..." : ""}"`,
+                output_summary: `task=${pilCtx.taskType ?? "none"} domain=${pilCtx.domain ?? "none"} layers=[${appliedLayers.join(",")}]`,
+                tokens_saved: _pilEnrichmentDeltaSnapshot > 0 ? _pilEnrichmentDeltaSnapshot : undefined,
+            });
+        }
+        // Interaction log: PIL classification
+        try {
+            if (deps.session) {
+                const pilDurationMs = Date.now() - _pilStart;
+                logInteraction(deps.session.id, "pil", {
+                    eventSubtype: pilCtx.taskType ?? "none",
+                    durationMs: pilDurationMs,
+                    data: {
+                        layers: pilCtx.layers?.filter((l) => l.applied).map((l) => l.name) ?? [],
+                        fullLayers: pilCtx.layers?.map((l) => ({ name: l.name, applied: l.applied, delta: l.delta })) ?? [],
+                        layerCount: pilCtx.layers?.length ?? 0,
+                        layerTimings: pilCtx.metrics?.layerTimings ?? null,
+                        domain: pilCtx.domain,
+                        confidence: pilCtx.confidence,
+                        outputStyle: pilCtx.outputStyle,
+                        intentKind: pilCtx.intentKind ?? null,
+                        mcpSkipped: isChitchat,
+                        fallbackReason: pilCtx.fallbackReason ?? null,
+                        eeMode: (await import("../ee/client-mode.js")).getCachedEEClientMode()?.mode ?? "unknown",
+                    },
+                });
+                logInteraction(deps.session.id, "user_message", {
+                    data: {
+                        raw_length: userMessage.length,
+                        enriched_length: enrichedMessage.length,
+                        taskType: pilCtx.taskType,
+                        intentKind: pilCtx.intentKind ?? null,
+                        confidence: pilCtx.confidence,
+                        pilActive: pilCtx.taskType !== null,
+                    },
+                });
+            }
+        }
+        catch {
+            /* fail-open */
+        }
+        // ROUTE-11: Per-turn model routing via decide() — picks cheapest capable model
+        const turnStartMs = Date.now();
+        let turnModelId = deps.modelId;
+        let taskHash = null;
+        const _routeStart = Date.now();
+        try {
+            const { decide } = await import("../router/decide.js");
+            const routeDecision = await decide(userMessage, {
+                tenantId: "local",
+                cwd: deps.bash.getCwd(),
+                defaultModel: deps.modelId,
+                defaultProvider: deps.providerId,
+                pil: {
+                    domain: pilCtx.domain,
+                    taskType: pilCtx.taskType,
+                    confidence: pilCtx.confidence,
+                    gsdPhase: pilCtx.gsdPhase ?? null,
+                    activeRunId: pilCtx.activeRunId ?? null,
+                    recentTurnsSummary: deps.buildRecentTurnsSummary(),
+                    projectSize: deps.estimateProjectSize(),
+                    filesTouched: deps.countFilesTouched(),
+                    mode: deps.mode,
+                },
+            });
+            if (routeDecision.model && routeDecision.model !== "HALT") {
+                // Respect user's default model when it has a vision proxy and the
+                // current turn (or history) has images — the proxy will convert
+                // images to text, so there's no need to switch to a vision-capable
+                // (and usually pricier / rate-limited) model.
+                const defaultHasVisionProxy = needsVisionProxy(deps.modelId);
+                const historyHasImages = deps.messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p.type === "image"));
+                const turnHasImages = (images?.length ?? 0) > 0;
+                const skipVisionRoute = defaultHasVisionProxy && (turnHasImages || historyHasImages);
+                if (!skipVisionRoute) {
+                    turnModelId = routeDecision.model;
+                }
+            }
+            taskHash = routeDecision.taskHash ?? null;
+            // Update status bar with router switch info. Also reset back to the
+            // session default when the router does NOT switch on this turn —
+            // otherwise the bar stays "stuck" showing the previously-routed model
+            // (e.g. claude-sonnet-4-6) on later turns that actually run on the
+            // user's chosen default (e.g. deepseek-v4-flash).
+            if (turnModelId !== deps.modelId) {
+                statusBarStore.setState({ routed_from: deps.modelId, model: turnModelId });
+            }
+            else {
+                const prev = statusBarStore.getState();
+                if (prev.routed_from || prev.model !== deps.modelId) {
+                    statusBarStore.setState({ routed_from: null, model: deps.modelId });
+                }
+            }
+            if (_debugOn) {
+                _debugSteps.push({
+                    name: "Router",
+                    duration_ms: Date.now() - _routeStart,
+                    input_summary: `default=${deps.modelId}`,
+                    output_summary: turnModelId !== deps.modelId ? `routed→${turnModelId}` : `kept ${turnModelId}`,
+                });
+            }
+        }
+        catch {
+            // Router unavailable — use session default model (skip if provider is disabled)
+            if (!isProviderDisabled(deps.providerId)) {
+                const eeRoute = await routeModel(userMessage, {}, deps.providerId).catch(() => null);
+                taskHash = eeRoute?.taskHash ?? null;
+            }
+        }
+        // Interaction log: model routing
+        try {
+            if (deps.session) {
+                logInteraction(deps.session.id, "routing", {
+                    model: turnModelId,
+                    data: { defaultModel: deps.modelId, routedModel: turnModelId, taskHash },
+                });
+            }
+        }
+        catch {
+            /* fail-open */
+        }
+        // Re-detect provider if router picked a model from a different provider
+        const turnProviderId = detectProviderForModel(turnModelId);
+        let turnProvider;
+        if (turnProviderId !== deps.providerId) {
+            // Even if the key is reachable, skip disabled providers
+            const turnKey = !isProviderDisabled(turnProviderId)
+                ? await loadKeyForProvider(turnProviderId).catch(() => null)
+                : null;
+            if (turnKey) {
+                const { createProviderFactory } = await import("../providers/runtime.js");
+                turnProvider = createProviderFactory(turnProviderId, { apiKey: turnKey }).factory;
+            }
+            else {
+                // Router's provider unreachable or disabled — fall back to a non-disabled provider
+                const fallback = await deps.councilManager.resolveNonDisabledFallback();
+                turnModelId = fallback.modelId;
+                turnProvider = deps.requireProvider();
+            }
+        }
+        else if (isProviderDisabled(deps.providerId)) {
+            // Session provider is disabled — find a non-disabled alternative
+            const fallback = await deps.councilManager.resolveNonDisabledFallback();
+            turnModelId = fallback.modelId;
+            turnProvider = deps.requireProvider();
+        }
+        else {
+            turnProvider = deps.requireProvider();
+        }
+        // E4: prepend one-shot cwd note when setCwd() changed the working directory
+        // mid-session. Clears after injection so only the first subsequent turn sees it.
+        const cwdNote = deps.getPendingCwdNote();
+        deps.setPendingCwdNote(null);
+        const messageForModel = cwdNote ? `${cwdNote}\n\n${enrichedMessage}` : enrichedMessage;
+        let userModelMessage;
+        if (images?.length) {
+            const parts = [
+                { type: "text", text: messageForModel },
+            ];
+            for (const img of images) {
+                parts.push({ type: "image", image: img.base64, mediaType: img.mediaType });
+            }
+            userModelMessage = { role: "user", content: parts };
+        }
+        else {
+            userModelMessage = { role: "user", content: messageForModel };
+        }
+        // Vision proxy: convert images to text for models that don't support vision.
+        // Process BOTH the current user message and any historical messages that
+        // still carry image parts — otherwise sending the conversation back to a
+        // text-only provider (e.g. DeepSeek) fails with "unknown variant
+        // `image_url`" once history contains an image from a prior turn.
+        if (needsVisionProxy(turnModelId)) {
+            const historyHasImages = deps.messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p.type === "image"));
+            const turnHasImages = (images?.length ?? 0) > 0;
+            if (turnHasImages || historyHasImages) {
+                try {
+                    if (historyHasImages) {
+                        const historyResult = await proxyVision(deps.messages, turnModelId, signal);
+                        if (historyResult.proxied) {
+                            deps.setMessages(historyResult.messages);
+                            yield {
+                                type: "content",
+                                content: `[Vision proxy: ${historyResult.imageCount} historical image(s) → text]\n`,
+                            };
+                        }
+                    }
+                    if (turnHasImages) {
+                        const proxyResult = await proxyVision([userModelMessage], turnModelId, signal);
+                        if (proxyResult.proxied) {
+                            userModelMessage = proxyResult.messages[0];
+                            yield {
+                                type: "content",
+                                content: `[Vision proxy: ${proxyResult.imageCount} image(s) → ${turnModelId} via SiliconFlow]\n`,
+                            };
+                        }
+                    }
+                }
+                catch {
+                    yield { type: "content", content: "[Vision proxy: failed, images dropped]\n" };
+                    if (turnHasImages) {
+                        userModelMessage = { role: "user", content: enrichedMessage };
+                    }
+                    // Strip image parts from history as a last-resort fallback so the
+                    // request doesn't blow up at the provider serialization layer.
+                    deps.setMessages(deps.messages.map((m) => {
+                        if (!Array.isArray(m.content))
+                            return m;
+                        const filtered = m.content.filter((p) => p.type !== "image");
+                        return { ...m, content: filtered };
+                    }));
+                }
+            }
+        }
+        deps.messages.push(userModelMessage);
+        // Phase A5 — write-ahead the user row so `recordUsage` mid-stream can
+        // attribute usage to a real `message_seq` instead of falling back to
+        // NULL (or to the previous turn's assistant seq for a session that has
+        // multi-turn history). The post-stream `appendCompletedTurn(...)` path
+        // upserts the same row to `status='completed'` via the
+        // `ON CONFLICT(session_id, seq) DO UPDATE` clause in `appendMessages`.
+        let userWriteAheadSeq = null;
+        if (deps.session) {
+            try {
+                userWriteAheadSeq = getNextMessageSequence(deps.session.id);
+                persistMessageWriteAhead(deps.session.id, userWriteAheadSeq, "user", JSON.stringify(userModelMessage));
+            }
+            catch {
+                // Fail-open: if seq lookup throws, fall back to the legacy NULL
+                // path. The forensics anomaly returns but the turn proceeds.
+                userWriteAheadSeq = null;
+            }
+        }
+        deps.messageSeqs.push(userWriteAheadSeq);
+        // Inject accumulated EE session guidance as a system message so the model
+        // is informed of past warnings before making tool decisions this turn.
+        if (deps.sessionEEGuidance.size > 0) {
+            const lines = Array.from(deps.sessionEEGuidance.entries()).map(([, g]) => {
+                const pct = Math.round(g.confidence * 100);
+                return `- [${g.toolName}] ${g.message} (Why: ${g.why}) [${pct}%]`;
+            });
+            deps.messages.push({
+                role: "system",
+                content: `[EE Session Guidance — avoid these patterns when using tools]\n${lines.join("\n")}`,
+            });
+            deps.messageSeqs.push(null);
+        }
+        const provider = turnProvider;
+        const subagents = loadValidSubAgents();
+        const _pilResponseTools = getResponseToolSet(pilCtx, deps.providerId);
+        const _hasResponseTools = Object.keys(_pilResponseTools).length > 0;
+        const systemParts = buildSystemPromptParts(deps.bash.getCwd(), deps.mode, deps.bash.getSandboxMode(), deps.getPlanContext(), subagents, deps.bash.getSandboxSettings(), deps.providerId, deps.getResumeDigest(), { chitchat: isChitchat });
+        if (deps.getResumeDigest())
+            deps.setResumeDigest(null);
+        // Skip vision/playwright guidance unless the user's message has a URL
+        // or browser/screenshot vocabulary. ~400 tokens of routing hints
+        // the model only needs when it might call a browser MCP.
+        const _browserGuidanceNeeded = /https?:\/\/\S+|\b(screenshot|browser|playwright|chrome|figma|canva|render|webpage|website|url|hyperlink|navigate|click|scrape)\b/i.test(userMessage);
+        const playwrightGuidance = isChitchat || !_browserGuidanceNeeded ? "" : getVisionGuidanceForTextOnly(turnModelId);
+        const system = applyModelConstraints(applyPilSuffix(`${systemParts.staticPrefix}${playwrightGuidance}${systemParts.dynamicSuffix}`, pilCtx, _hasResponseTools), turnModelId);
+        let runtime = resolveModelRuntime(provider, turnModelId);
+        let modelInfo = runtime.modelInfo;
+        // SAMR: Step-Aware Model Routing — downgrade to fast model for tool-execution
+        // steps after the initial reasoning step. The premium model decides WHAT to do;
+        // a cheaper model handles the mechanical "read results, call more tools" loop.
+        const stepRouterCfg = getStepRouterConfig();
+        const stepRouterDecision = decideStepRouting(turnModelId, deps.providerId, stepRouterCfg);
+        let stepRouterPhase = stepRouterDecision.phase2ModelId ? "phase1" : "done";
+        const phase2Runtime = stepRouterDecision.phase2ModelId
+            ? resolveModelRuntime(provider, stepRouterDecision.phase2ModelId)
+            : null;
+        if (stepRouterDecision.phase2ModelId && _debugOn) {
+            _debugSteps.push({
+                name: "StepRouter",
+                duration_ms: 0,
+                input_summary: `phase1=${turnModelId}`,
+                output_summary: stepRouterDecision.reason,
+            });
+        }
+        deps.setPlanContext(null);
+        let attemptedOverflowRecovery = false;
+        // Stream-retry state: track how many transient retries have been attempted
+        // for the current turn. Reset to 0 on each new user turn (we're in processMessage).
+        let streamRetryCount = 0;
+        const MAX_STREAM_RETRIES = 2; // 3 total attempts = 1 first try + 2 retries
+        // Auto-council: route to multi-model debate when EITHER
+        //   (a) PIL classified taskType=plan|analyze with high confidence, OR
+        //   (b) GSD-native tier === "heavy" (wholesale / multi-step / cross-repo work).
+        // After the debate finishes, runCouncilV2 records synthesis on
+        // councilManager.lastSynthesis; we then re-enter processMessage with the synthesis
+        // as the next user turn so the main loop continues with full debate context.
+        // Skip if this is already a council continuation turn (prevent infinite recursion).
+        const autoCouncilTypes = new Set(["plan", "analyze"]);
+        const councilRoles = getRoleModels();
+        const configuredRoleCount = Object.values(councilRoles).filter(Boolean).length;
+        const heavyTier = pilCtx.complexityTier === "heavy";
+        const autoCouncilConfidence = getAutoCouncilConfidence();
+        const autoCouncilMinRoles = getAutoCouncilMinRoles();
+        const taskTypeMatch = pilCtx.taskType && autoCouncilTypes.has(pilCtx.taskType) && pilCtx.confidence >= autoCouncilConfidence;
+        const shouldAutoCouncil = !deps.councilManager.isContinuation &&
+            isAutoCouncilEnabled() &&
+            configuredRoleCount >= autoCouncilMinRoles &&
+            (taskTypeMatch || heavyTier);
+        // Always log the auto-council decision (taken or skipped) with the gate
+        // values that decided it. Lets reports answer "why did this turn cost
+        // $0.30?" and "is the confidence floor tuned wrong for my prompts?".
+        const autoCouncilSkipReason = (() => {
+            if (deps.councilManager.isContinuation)
+                return "continuation-turn";
+            if (!isAutoCouncilEnabled())
+                return "feature-disabled";
+            if (configuredRoleCount < autoCouncilMinRoles)
+                return `role-count<${autoCouncilMinRoles} (have ${configuredRoleCount})`;
+            if (!taskTypeMatch && !heavyTier) {
+                if (!pilCtx.taskType || !autoCouncilTypes.has(pilCtx.taskType))
+                    return `taskType=${pilCtx.taskType ?? "null"} not in plan|analyze`;
+                if (pilCtx.confidence < autoCouncilConfidence)
+                    return `confidence<${autoCouncilConfidence} (got ${pilCtx.confidence.toFixed(2)})`;
+                return "no-trigger";
+            }
+            return "taken";
+        })();
+        appendDecisionLog({
+            ts: Date.now(),
+            sessionId: deps.session?.id ?? null,
+            kind: "auto-council",
+            taken: shouldAutoCouncil,
+            reason: autoCouncilSkipReason,
+            meta: {
+                taskType: pilCtx.taskType ?? null,
+                confidence: pilCtx.confidence,
+                complexityTier: pilCtx.complexityTier ?? null,
+                configuredRoleCount,
+                autoCouncilConfidence,
+                autoCouncilMinRoles,
+                heavyTier,
+                isContinuation: deps.councilManager.isContinuation,
+            },
+        }).catch(() => undefined);
+        if (shouldAutoCouncil) {
+            const reason = heavyTier
+                ? `complexity=heavy${pilCtx.taskType ? ` task=${pilCtx.taskType}` : ""}`
+                : `${pilCtx.taskType} task detected with ${(pilCtx.confidence * 100).toFixed(0)}% confidence`;
+            yield { type: "content", content: `\n[Auto-council triggered: ${reason}]\n` };
+            yield* deps.runCouncilV2(userMessage, { skipClarification: true, observer, userModelMessage });
+            const synthesis = deps.councilManager.lastSynthesis;
+            deps.councilManager.setLastSynthesis(null);
+            if (synthesis) {
+                yield { type: "content", content: "\n[Auto-continuing with council recommendations...]\n" };
+                deps.councilManager.setContinuation(true);
+                try {
+                    yield* deps.processMessage(`Council debate completed. Synthesis:\n\n${synthesis}\n\nProceed with the recommended action items.`, observer);
+                }
+                finally {
+                    deps.councilManager.setContinuation(false);
+                }
+            }
+            return;
+        }
+        if (deps.batchApi) {
+            try {
+                yield* deps.processMessageBatchTurn({
+                    userModelMessage,
+                    observer,
+                    provider,
+                    subagents,
+                    system,
+                    runtime,
+                    modelInfo,
+                    signal,
+                });
+            }
+            finally {
+                if (deps.getAbortController()?.signal === signal) {
+                    deps.setAbortController(null);
+                }
+            }
+            return;
+        }
+        try {
+            while (true) {
+                // SAMR Phase 2: switch to fast model for tool-execution steps
+                if (stepRouterPhase === "phase2" && phase2Runtime) {
+                    runtime = phase2Runtime;
+                    modelInfo = runtime.modelInfo;
+                }
+                deps.setCompactedThisTurn(false);
+                let assistantText = "";
+                let reasoningPreview = "";
+                let encryptedReasoningHidden = false;
+                let streamOk = false;
+                let closeMcp;
+                let stepNumber = -1;
+                const activeToolCalls = [];
+                // SAMR: track whether Phase 1 produced tool calls
+                let phase1HadToolCalls = false;
+                try {
+                    const settings = attemptedOverflowRecovery
+                        ? relaxCompactionSettings(deps.getCompactionSettings(modelInfo?.contextWindow))
+                        : deps.getCompactionSettings(modelInfo?.contextWindow);
+                    if (modelInfo?.contextWindow) {
+                        await deps.compactForContext(provider, system, modelInfo.contextWindow, signal, settings, attemptedOverflowRecovery);
+                    }
+                    const baseToolsRaw = createBuiltinTools(deps.bash, deps.mode, {
+                        runTask: (request, abortSignal) => deps.runTask(request, combineAbortSignals(signal, abortSignal)),
+                        runDelegation: (request, abortSignal) => deps.runDelegation(request, combineAbortSignals(signal, abortSignal)),
+                        readDelegation: (id) => deps.readDelegation(id),
+                        listDelegations: () => deps.listDelegations(),
+                        modelId: turnModelId,
+                    });
+                    // Top-level cumulative cap state. We accumulate the raw tool set
+                    // (base + MCP + PIL response tools) across the assembly below,
+                    // then apply the cap once. Tier ratios are looser than the
+                    // sub-agent cap (50%/80%) so casual single-tool turns are not
+                    // trimmed. See sub-agent-cap.ts.
+                    // Chitchat: drop builtin tools too (not just MCP). A 1-word greeting
+                    // never needs bash/read_file/edit_file/grep — those schemas alone
+                    // cost ~1.5K input tokens on this CLI. Falls back to baseTools for
+                    // every non-chitchat turn (PIL gates conservatively).
+                    const turnCaps = getProviderCapabilities(runtime.modelInfo?.provider ?? "anthropic");
+                    let rawToolSet = !turnCaps.supportsClientTools(runtime.modelInfo)
+                        ? {}
+                        : isChitchat
+                            ? {}
+                            : baseToolsRaw;
+                    // MCP skip: chitchat / greeting inputs don't need 7 MCP servers'
+                    // worth of tool schemas (~20K input tokens). PIL Layer 1 already
+                    // gates this conservatively (≤10 chars + ≤2 words OR brain "none").
+                    if (deps.mode === "agent" && !isChitchat && turnCaps.supportsClientTools(runtime.modelInfo)) {
+                        // Smart MCP filter: skip browser/vision MCP servers unless the
+                        // user's current message has a URL or explicitly invokes the
+                        // browser/screenshot/design vocabulary. Local code work — which
+                        // is the majority of turns — does not need Playwright/Figma/Canva
+                        // tool schemas (each MCP contributes 8-15 tools at ~150 tok each).
+                        // Override with MUONROI_DISABLE_SMART_MCP=1.
+                        const smartMcp = process.env.MUONROI_DISABLE_SMART_MCP !== "1";
+                        const browserSignal = /https?:\/\/\S+|\b(screenshot|browser|playwright|chrome|figma|canva|render|webpage|website|url|hyperlink|navigate|click|scrape)\b/i.test(userMessage);
+                        const SKIP_WHEN_NO_BROWSER = /playwright|chrome|browser|devtools|vision|figma|canva/i;
+                        const allServers = loadMcpServers();
+                        const filteredServers = smartMcp && !browserSignal ? allServers.filter((s) => !SKIP_WHEN_NO_BROWSER.test(s.id)) : allServers;
+                        const mcpBundle = await buildMcpToolSet(filteredServers, {
+                            onOAuthRequired: (_serverId, url) => {
+                                const urlStr = url.toString();
+                                import("child_process").then(({ exec }) => {
+                                    const cmd = process.platform === "win32"
+                                        ? `start "" "${urlStr}"`
+                                        : process.platform === "darwin"
+                                            ? `open "${urlStr}"`
+                                            : `xdg-open "${urlStr}"`;
+                                    exec(cmd);
+                                });
+                            },
+                        });
+                        closeMcp = mcpBundle.close;
+                        rawToolSet = { ...rawToolSet, ...mcpBundle.tools };
+                        if (mcpBundle.errors.length > 0) {
+                            yield { type: "content", content: `MCP unavailable: ${mcpBundle.errors.join(" | ")}\n\n` };
+                        }
+                    }
+                    // PIL response tools: inject structured output tool when taskType detected
+                    if (_hasResponseTools && turnCaps.supportsClientTools(runtime.modelInfo)) {
+                        rawToolSet = { ...rawToolSet, ..._pilResponseTools };
+                        captureToolSchemas(_pilResponseTools);
+                    }
+                    // Apply the top-level cumulative cap once over the fully-assembled
+                    // raw tool set. State is per-turn; each turn gets a fresh budget.
+                    const topLevelCap = wrapToolSetWithCap(rawToolSet, {
+                        maxCumulativeChars: getTopLevelToolBudgetChars(),
+                        midTierRatio: 0.5,
+                        highTierRatio: 0.8,
+                        label: "top-level",
+                    });
+                    // Phase C3: layer cross-turn dedup on top of the top-level cap.
+                    const tools = wrapToolSetWithReadBudget(wrapToolSetWithDedup(topLevelCap.tools, deps.crossTurnDedup), deps.readBudget);
+                    captureToolSchemas(tools);
+                    let responseToolCalled = false;
+                    // G3: providerOptions assembly is owned by the capability layer
+                    // (src/providers/capabilities.ts). buildTurnProviderOptions feeds
+                    // sessionId in so openai.promptCacheKey is derived per turn.
+                    // The task-type-driven anthropic.thinking budget override stays
+                    // here because it depends on PIL task context, not provider quirks.
+                    // biome-ignore lint/suspicious/noExplicitAny: matches RuntimeResult.providerOptions shape (any) used downstream
+                    const baseProviderOpts = buildTurnProviderOptions(runtime, { sessionId: deps.session?.id }) ?? {};
+                    const providerOpts = runtime.modelInfo?.reasoning
+                        ? {
+                            ...baseProviderOpts,
+                            anthropic: {
+                                ...(baseProviderOpts.anthropic ?? {}),
+                                thinking: {
+                                    type: "enabled",
+                                    budgetTokens: taskTypeToReasoningEffort(pilCtx.taskType) === "high"
+                                        ? 32_768
+                                        : taskTypeToReasoningEffort(pilCtx.taskType) === "medium"
+                                            ? 8_192
+                                            : 2_048,
+                                },
+                            },
+                        }
+                        : baseProviderOpts;
+                    // Use catalog's thinkingType field instead of regex matching.
+                    // providerOpts is loosely typed (Record<string, unknown>) after the
+                    // g1 capability refactor — narrow with a local typed view.
+                    const thinkingModelInfo = getModelInfo(runtime.modelId);
+                    const providerOptsAnyView = providerOpts;
+                    if (providerOptsAnyView.anthropic?.thinking?.type === "enabled" &&
+                        thinkingModelInfo?.thinkingType === "adaptive") {
+                        providerOptsAnyView.anthropic.thinking = { type: "adaptive" };
+                    }
+                    // OpenAI api-key path: `store: true` is seeded by OpenAIStrategy
+                    // via factory.defaultProviderOptions (Phase 12.2-G4 migration).
+                    // OAuth backend (ChatGPT Codex) overrides with `store: false` via
+                    // the auth registry. Both flow through resolveModelRuntime →
+                    // runtime.providerOptions → buildTurnProviderOptions and arrive
+                    // here merged into providerOpts.openai.
+                    // Top-level dropParam — shared with sub-agent path via shouldDropParam.
+                    // See src/providers/runtime.ts for the central rule.
+                    const dropParam = (p) => shouldDropParam(runtime, p);
+                    const systemForModel = runtime.modelId.startsWith("claude")
+                        ? [
+                            {
+                                role: "system",
+                                content: systemParts.staticPrefix,
+                                providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } },
+                            },
+                            { role: "system", content: system.slice(systemParts.staticPrefix.length) },
+                        ]
+                        : system;
+                    // Capture prompt-size breakdown so recordUsage can attach it to the
+                    // cost-log entry. Without this, "system prompt is huge" is unfalsifiable.
+                    // chars/4 ≈ tokens for English; reported as chars to keep math obvious.
+                    const messagesChars = deps.messages.reduce((s, m) => {
+                        const c = m.content;
+                        if (typeof c === "string")
+                            return s + c.length;
+                        if (Array.isArray(c)) {
+                            for (const part of c) {
+                                if (typeof part.text === "string") {
+                                    s += part.text.length;
+                                }
+                            }
+                        }
+                        return s;
+                    }, 0);
+                    let toolsChars = 0;
+                    let toolsCount = 0;
+                    for (const [name, t] of Object.entries(tools)) {
+                        toolsCount += 1;
+                        toolsChars += name.length;
+                        const desc = t.description;
+                        if (typeof desc === "string")
+                            toolsChars += desc.length;
+                        try {
+                            // Schemas often dominate tool size on non-Anthropic providers
+                            // (Zod-derived JSON schemas can be 2-5K chars per tool).
+                            const params = t.parameters ??
+                                t.inputSchema;
+                            if (params)
+                                toolsChars += JSON.stringify(params).length;
+                        }
+                        catch {
+                            /* best-effort */
+                        }
+                    }
+                    deps.setLastPromptBreakdown({
+                        systemChars: system.length,
+                        staticPrefixChars: systemParts.staticPrefix.length,
+                        dynamicSuffixChars: systemParts.dynamicSuffix.length,
+                        playwrightGuidanceChars: playwrightGuidance.length,
+                        messagesChars,
+                        messagesCount: deps.messages.length,
+                        toolsChars,
+                        toolsCount,
+                    });
+                    // Task 2.6a — assign a fresh correlation ID for this top-level streamText call.
+                    const _topCallId = crypto.randomUUID();
+                    deps.setCurrentCallId(_topCallId);
+                    // Phase B4: compact older tool_result parts before each top-level
+                    // step once cumulative message chars exceed the configured threshold.
+                    // The compactor preserves system + first user verbatim and keeps the
+                    // last N tool turns intact; older results are rewritten into short
+                    // stubs. Symmetric to the B3 sub-agent path; reuses the same module
+                    // with `label: "top-level"` so the stub text reflects which loop
+                    // elided the content.
+                    const topLevelCompactThreshold = getTopLevelCompactThresholdChars();
+                    const topLevelCompactKeepLast = getTopLevelCompactKeepLast();
+                    // Phase O1 — capture providerOptions SHAPE (types only) for forensics.
+                    deps.setLastProviderOptionsShape(Object.keys(providerOpts).length > 0 ? extractProviderOptionsShape(providerOpts) : null);
+                    if (wireDebug.enabled) {
+                        wireDebug.logRequest({
+                            providerId: runtime.modelInfo?.provider ?? "unknown",
+                            modelId: runtime.modelId,
+                            messages: deps.messages,
+                            systemChars: systemForModel?.length ?? 0,
+                            toolNames: tools ? Object.keys(tools) : undefined,
+                            providerOptions: providerOpts,
+                        });
+                    }
+                    // SiliconFlow DeepSeek thinking-mode reasoning_content workaround
+                    // (see siliconflow-history.ts). Sub-agent path applies the same strip
+                    // via the capability hook; identity for every other provider.
+                    const _topMessagesForCall = turnCaps.sanitizeHistory(deps.messages);
+                    const result = streamText({
+                        model: runtime.model,
+                        system: systemForModel,
+                        messages: _topMessagesForCall,
+                        tools,
+                        toolChoice: _hasResponseTools && turnCaps.supportsClientTools(runtime.modelInfo) ? "auto" : undefined,
+                        stopWhen: stepRouterPhase === "phase1"
+                            ? stepCountIs(1) // SAMR Phase 1: stop after reasoning step
+                            : stepCountIs(deps.maxToolRounds),
+                        maxRetries: 0,
+                        abortSignal: signal,
+                        prepareStep: ({ stepNumber: sn, messages: stepMessages }) => {
+                            if (sn < 1)
+                                return {};
+                            const stripped = turnCaps.sanitizeHistory(stepMessages);
+                            const compacted = compactSubAgentMessages(stripped, {
+                                thresholdChars: topLevelCompactThreshold,
+                                keepLastTurns: topLevelCompactKeepLast,
+                                label: "top-level",
+                            });
+                            if (compacted === stripped && stripped === stepMessages)
+                                return {};
+                            return { messages: compacted };
+                        },
+                        ...(dropParam("temperature") ? {} : { temperature: 0.7 }),
+                        ...(dropParam("maxOutputTokens") ? {} : { maxOutputTokens: taskTypeToMaxTokens(pilCtx.taskType) }),
+                        ...(Object.keys(providerOpts).length > 0 ? { providerOptions: providerOpts } : {}),
+                        experimental_onStepStart: (event) => {
+                            stepNumber = getStepNumber(event, stepNumber + 1);
+                            notifyObserver(observer?.onStepStart, {
+                                stepNumber,
+                                timestamp: Date.now(),
+                            });
+                        },
+                        onStepFinish: (event) => {
+                            const currentStep = getStepNumber(event, Math.max(stepNumber, 0));
+                            stepNumber = Math.max(stepNumber, currentStep);
+                            const stepUsage = getUsage(event);
+                            notifyObserver(observer?.onStepFinish, {
+                                stepNumber: currentStep,
+                                timestamp: Date.now(),
+                                finishReason: getFinishReason(event),
+                                usage: stepUsage,
+                            });
+                            // Realtime status bar update per step
+                            if (stepUsage.inputTokens || stepUsage.outputTokens) {
+                                deps.recordUsage(stepUsage, "message", runtime.modelId);
+                            }
+                        },
+                        onFinish: ({ finishReason }) => {
+                            // Task 2.6b — emit llm-done (agent-mode only).
+                            try {
+                                const _ar = globalThis.__muonroiAgentRuntime;
+                                _ar?.emitEvent({
+                                    t: "event",
+                                    kind: "llm-done",
+                                    correlationId: _topCallId,
+                                    totalChars: assistantText.length,
+                                    finishReason: finishReason ?? "stop",
+                                });
+                            }
+                            catch {
+                                /* best-effort */
+                            }
+                            deps.setCurrentCallId("");
+                        },
+                    });
+                    let _topTokenIndex = 0;
+                    const _wireProviderIdTop = runtime.modelInfo?.provider ?? "unknown";
+                    for await (const part of result.fullStream) {
+                        if (signal.aborted) {
+                            yield { type: "content", content: "\n\n[Cancelled]" };
+                            break;
+                        }
+                        if (wireDebug.enabled) {
+                            wireDebug.logChunk(_wireProviderIdTop, String(part.type ?? "unknown"), {
+                                hasText: typeof part.text === "string"
+                                    ? part.text.length
+                                    : undefined,
+                                hasReasoning: typeof part.reasoning === "string"
+                                    ? part.reasoning.length
+                                    : undefined,
+                            });
+                            if (part.type === "error") {
+                                wireDebug.logError(_wireProviderIdTop, part.error);
+                            }
+                        }
+                        switch (part.type) {
+                            case "text-delta":
+                                assistantText += part.text;
+                                // Task 2.6b — emit llm-token (agent-mode only; high-volume, default-off per Phase 4).
+                                try {
+                                    const _ar = globalThis.__muonroiAgentRuntime;
+                                    _ar?.emitEvent({
+                                        t: "event",
+                                        kind: "llm-token",
+                                        correlationId: _topCallId,
+                                        delta: part.text,
+                                        tokenIndex: _topTokenIndex++,
+                                    });
+                                }
+                                catch {
+                                    /* best-effort */
+                                }
+                                yield { type: "content", content: part.text };
+                                break;
+                            case "reasoning-delta":
+                                reasoningPreview = `${reasoningPreview}${part.text}`.slice(-256);
+                                if (containsEncryptedReasoning(reasoningPreview)) {
+                                    if (!encryptedReasoningHidden) {
+                                        encryptedReasoningHidden = true;
+                                        yield { type: "reasoning", content: "[Encrypted reasoning hidden]" };
+                                    }
+                                    break;
+                                }
+                                // P0 native observation: accumulate reasoning for intent context.
+                                deps.appendTurnAssistantReasoning(part.text);
+                                yield { type: "reasoning", content: part.text };
+                                break;
+                            case "tool-call": {
+                                const tc = toToolCall(part);
+                                activeToolCalls.push(tc);
+                                // SAMR: track that Phase 1 produced tool calls → transition to Phase 2
+                                if (stepRouterPhase === "phase1")
+                                    phase1HadToolCalls = true;
+                                // EE PreToolUse hook: fire intercept before tool execution.
+                                {
+                                    const turnAssistantReasoning = deps.getTurnAssistantReasoning();
+                                    const intentContext = {
+                                        ...(turnAssistantReasoning
+                                            ? { assistantReasoningExcerpt: turnAssistantReasoning.slice(-200) }
+                                            : {}),
+                                        ...(deps.priorWarningIdsInSession.size > 0
+                                            ? {
+                                                priorWarningIdsInSession: Array.from(deps.priorWarningIdsInSession).slice(-20),
+                                            }
+                                            : {}),
+                                        ...(pilCtx.gsdPhase ? { gsdPhase: pilCtx.gsdPhase } : {}),
+                                        ...(userMessage.slice(0, 200) ? { userGoalExcerpt: userMessage.slice(0, 200) } : {}),
+                                    };
+                                    const preInput = {
+                                        hook_event_name: "PreToolUse",
+                                        tool_name: tc.function.name,
+                                        tool_input: JSON.parse(tc.function.arguments || "{}"),
+                                        session_id: deps.session?.id,
+                                        cwd: deps.bash.getCwd(),
+                                        ...(Object.keys(intentContext).length > 0 ? { intent_context: intentContext } : {}),
+                                    };
+                                    const preResult = await deps.fireHook(preInput, signal).catch(() => ({
+                                        blocked: false,
+                                        blockingErrors: [],
+                                        preventContinuation: false,
+                                        additionalContexts: [],
+                                        results: [],
+                                        eeMatches: [],
+                                    }));
+                                    for (const ctx of preResult.additionalContexts ?? []) {
+                                        yield { type: "content", content: `${ctx}\n` };
+                                    }
+                                    // Store structured EE matches for session guidance injection on next turn.
+                                    for (const m of preResult.eeMatches ?? []) {
+                                        deps.sessionEEGuidance.set(m.id, {
+                                            toolName: m.toolName,
+                                            message: m.message,
+                                            why: m.why,
+                                            confidence: m.confidence,
+                                        });
+                                        // Cap at 30 entries — oldest first, trim when exceeded.
+                                        if (deps.sessionEEGuidance.size > 30) {
+                                            const firstKey = deps.sessionEEGuidance.keys().next().value;
+                                            if (firstKey !== undefined)
+                                                deps.sessionEEGuidance.delete(firstKey);
+                                        }
+                                    }
+                                    // P0 native observation: track which principle IDs surfaced
+                                    // this turn so the next intercept can dedup server-side.
+                                    try {
+                                        const { getLastSurfacedState } = await import("../ee/intercept.js");
+                                        const { surfacedIds } = getLastSurfacedState();
+                                        for (const id of surfacedIds)
+                                            deps.priorWarningIdsInSession.add(id);
+                                        // Cap memory: keep only most-recent 100 IDs.
+                                        if (deps.priorWarningIdsInSession.size > 100) {
+                                            const arr = Array.from(deps.priorWarningIdsInSession);
+                                            deps.setPriorWarningIdsInSession(new Set(arr.slice(-100)));
+                                        }
+                                    }
+                                    catch {
+                                        /* fail-open */
+                                    }
+                                }
+                                // Pitfall 9: log the pending call so reconcile() can recover any
+                                // staged .tmp files if the process is killed before tool-result.
+                                if (deps.pendingCalls) {
+                                    const turnId = deps.session?.id ?? "anon";
+                                    const callId = stableCallId(turnId, tc.function.name, tc.function.arguments);
+                                    // Phase 0: predictStagedPaths = [] for all tools (refined in Phase 1).
+                                    void deps.pendingCalls.begin({ call_id: callId, tool_name: tc.function.name }).catch(() => { });
+                                    // Attach callId to the ToolCall so tool-result can end it.
+                                    tc._pendingCallId = callId;
+                                }
+                                // Phase A4: write-ahead persistence — insert a pending row into
+                                // tool_calls BEFORE executing the tool. If the stream throws
+                                // mid-call (e.g. provider 5xx, abort, network drop), this row
+                                // remains as `pending` so `usage forensics` can show the args
+                                // the model passed. The post-stream appendMessages() path
+                                // (INSERT OR IGNORE + UPDATE) will finalize this row to
+                                // `completed` once the turn settles normally.
+                                if (deps.sessionStore && deps.session) {
+                                    // Predicted assistant seq: user message + assistant message
+                                    // are appended atomically by appendCompletedTurn().
+                                    // getNextMessageSequence() returns the seq the user message
+                                    // will get; the assistant message is the next one after.
+                                    let predictedSeq = -1;
+                                    try {
+                                        predictedSeq = getNextMessageSequence(deps.session.id) + 1;
+                                    }
+                                    catch {
+                                        /* fail-open — leave predictedSeq=-1; post-stream UPDATE corrects it */
+                                    }
+                                    persistToolCallWriteAhead(deps.session.id, predictedSeq, tc.id, tc.function.name, tc.function.arguments || "{}");
+                                }
+                                notifyObserver(observer?.onToolStart, {
+                                    toolCall: tc,
+                                    timestamp: Date.now(),
+                                });
+                                // Interaction log: tool call start
+                                try {
+                                    if (deps.session) {
+                                        logInteraction(deps.session.id, "tool_call", {
+                                            eventSubtype: tc.function.name,
+                                            data: {
+                                                toolCallId: tc.id,
+                                                argsPreview: tc.function.arguments.slice(0, 200),
+                                            },
+                                        });
+                                    }
+                                }
+                                catch {
+                                    /* fail-open */
+                                }
+                                yield { type: "tool_calls", toolCalls: [tc] };
+                                break;
+                            }
+                            case "tool-result": {
+                                const tc = {
+                                    id: part.toolCallId,
+                                    type: "function",
+                                    function: { name: part.toolName, arguments: JSON.stringify(part.input ?? {}) },
+                                };
+                                let tr = toToolResult(part.output);
+                                // Vision Bridge: proxy image-bearing tool results for text-only models (any tool, not just MCP)
+                                try {
+                                    const bridgeResult = await bridgeMcpToolResult(part.toolName, tr.output, turnModelId, signal, part.toolCallId);
+                                    if (bridgeResult.proxied) {
+                                        tr = {
+                                            ...tr,
+                                            output: typeof bridgeResult.output === "string"
+                                                ? bridgeResult.output
+                                                : JSON.stringify(bridgeResult.output),
+                                        };
+                                        yield { type: "content", content: `[Vision Bridge: image → text for ${turnModelId}]\n` };
+                                    }
+                                }
+                                catch {
+                                    /* fail-open */
+                                }
+                                // Pitfall 9: settle the pending call log entry.
+                                if (deps.pendingCalls) {
+                                    const pending = activeToolCalls.find((t) => t.id === part.toolCallId);
+                                    const callId = pending?._pendingCallId;
+                                    if (callId) {
+                                        const endStatus = signal.aborted ? "aborted" : "settled";
+                                        void deps.pendingCalls.end(callId, endStatus).catch(() => { });
+                                    }
+                                }
+                                // EE PostToolUse hook: fire-and-forget after tool execution.
+                                {
+                                    const postInput = {
+                                        hook_event_name: "PostToolUse",
+                                        tool_name: part.toolName,
+                                        tool_input: part.input ?? {},
+                                        tool_output: typeof tr.output === "string"
+                                            ? { text: tr.output }
+                                            : (tr.output ?? {}),
+                                        session_id: deps.session?.id,
+                                        cwd: deps.bash.getCwd(),
+                                    };
+                                    await deps.fireHook(postInput, signal).catch(() => { });
+                                }
+                                // Response tool: yield as structured_response instead of tool_result.
+                                // AI SDK v5 wraps tool outputs as `{type:"json", value:{...}}`; unwrap
+                                // to expose the schema-shaped payload to the UI renderer.
+                                if (isResponseTool(part.toolName)) {
+                                    responseToolCalled = true;
+                                    const taskType = getResponseTaskType(part.toolName);
+                                    const rawOutput = part.output;
+                                    const unwrapped = rawOutput && typeof rawOutput === "object" && rawOutput.type === "json"
+                                        ? (rawOutput.value ?? {})
+                                        : (rawOutput ?? {});
+                                    yield {
+                                        type: "structured_response",
+                                        structuredResponse: {
+                                            taskType: taskType ?? part.toolName,
+                                            data: unwrapped,
+                                        },
+                                    };
+                                    notifyObserver(observer?.onToolFinish, { toolCall: tc, toolResult: tr, timestamp: Date.now() });
+                                    break;
+                                }
+                                notifyObserver(observer?.onToolFinish, {
+                                    toolCall: tc,
+                                    toolResult: tr,
+                                    timestamp: Date.now(),
+                                });
+                                // Interaction log: tool result
+                                try {
+                                    if (deps.session) {
+                                        const outputPreview = typeof tr.output === "string" ? tr.output.slice(0, 200) : JSON.stringify(tr.output).slice(0, 200);
+                                        logInteraction(deps.session.id, "tool_result", {
+                                            eventSubtype: tc.function.name,
+                                            data: { success: tr.success, outputPreview },
+                                        });
+                                    }
+                                }
+                                catch {
+                                    /* fail-open */
+                                }
+                                yield { type: "tool_result", toolCall: tc, toolResult: tr };
+                                break;
+                            }
+                            case "tool-error": {
+                                // AI SDK emits this when tool execution throws/aborts before
+                                // producing a tool-result. Without this branch, the tool_call
+                                // log row has no matching tool_result and the EE judge never
+                                // sees the failure → silent ~1.6% pairing leak in prod DB.
+                                const errPart = part;
+                                const tc = {
+                                    id: errPart.toolCallId,
+                                    type: "function",
+                                    function: { name: errPart.toolName, arguments: JSON.stringify(errPart.input ?? {}) },
+                                };
+                                const errMsg = errPart.error instanceof Error
+                                    ? errPart.error.message
+                                    : typeof errPart.error === "string"
+                                        ? errPart.error
+                                        : JSON.stringify(errPart.error);
+                                const tr = { success: false, output: `[tool-error] ${errMsg}` };
+                                // Settle pending-call ledger so we don't leak stale .tmp files.
+                                if (deps.pendingCalls) {
+                                    const pending = activeToolCalls.find((t) => t.id === errPart.toolCallId);
+                                    const callId = pending?._pendingCallId;
+                                    if (callId)
+                                        void deps.pendingCalls.end(callId, "settled").catch(() => { });
+                                }
+                                // Phase A4: mark the write-ahead tool_calls row as `errored`.
+                                // The post-stream appendMessages() path does NOT see tool-error
+                                // parts in the assistant message content (the SDK doesn't emit
+                                // them there), so without this explicit update the row would
+                                // remain `pending` after a clean tool failure.
+                                if (deps.session) {
+                                    markToolCallErrored(deps.session.id, errPart.toolCallId, errMsg);
+                                }
+                                // Fire PostToolUseFailure so EE judge can record IGNORED outcome.
+                                {
+                                    const failInput = {
+                                        hook_event_name: "PostToolUseFailure",
+                                        tool_name: errPart.toolName,
+                                        tool_input: errPart.input ?? {},
+                                        error: errMsg,
+                                        session_id: deps.session?.id,
+                                        cwd: deps.bash.getCwd(),
+                                    };
+                                    await deps.fireHook(failInput, signal).catch(() => { });
+                                }
+                                try {
+                                    if (deps.session) {
+                                        logInteraction(deps.session.id, "tool_result", {
+                                            eventSubtype: errPart.toolName,
+                                            data: { success: false, error: errMsg.slice(0, 500), reason: "tool-error" },
+                                        });
+                                    }
+                                }
+                                catch {
+                                    /* fail-open */
+                                }
+                                notifyObserver(observer?.onToolFinish, { toolCall: tc, toolResult: tr, timestamp: Date.now() });
+                                yield { type: "tool_result", toolCall: tc, toolResult: tr };
+                                break;
+                            }
+                            case "tool-approval-request": {
+                                const approvalPart = part;
+                                const toolCallId = approvalPart.toolCall?.toolCallId ?? "";
+                                const pendingTc = activeToolCalls.find((tc) => tc.id === toolCallId);
+                                const tcForChunk = pendingTc ?? {
+                                    id: toolCallId,
+                                    type: "function",
+                                    function: {
+                                        name: approvalPart.toolCall?.toolName ?? "paid_request",
+                                        arguments: JSON.stringify(approvalPart.toolCall?.input ?? {}),
+                                    },
+                                };
+                                // Payment pre-check disabled — Stripe billing pending.
+                                const paymentPrecheck = undefined;
+                                // Plan 03-01: check permission mode before yielding approval request to UI.
+                                // auto-edit auto-approves file ops; yolo auto-approves everything.
+                                const toolName = approvalPart.toolCall?.toolName ?? "";
+                                if (!toolNeedsApproval(toolName, deps.permissionMode)) {
+                                    // Auto-approve: respond directly without surfacing to UI.
+                                    deps.respondToToolApproval(approvalPart.approvalId, true);
+                                    break;
+                                }
+                                yield {
+                                    type: "tool_approval_request",
+                                    approvalId: approvalPart.approvalId,
+                                    toolCall: tcForChunk,
+                                    paymentPrecheck,
+                                };
+                                break;
+                            }
+                            case "error": {
+                                const authError = isAuthenticationError(part.error);
+                                const friendly = humanizeApiError(part.error);
+                                notifyObserver(observer?.onError, {
+                                    message: friendly,
+                                    timestamp: Date.now(),
+                                });
+                                // Interaction log: error
+                                try {
+                                    if (deps.session) {
+                                        logInteraction(deps.session.id, "error", {
+                                            eventSubtype: authError ? "auth" : "api",
+                                            data: { message: friendly.slice(0, 200) },
+                                        });
+                                    }
+                                }
+                                catch {
+                                    /* fail-open */
+                                }
+                                yield {
+                                    type: "error",
+                                    content: friendly,
+                                    isAuthError: authError,
+                                };
+                                break;
+                            }
+                            case "abort":
+                                yield { type: "content", content: "\n\n[Cancelled]" };
+                                break;
+                        }
+                    }
+                    // ─── SAMR Phase 1 → Phase 2 transition ─────────────────────────
+                    // Phase 1 (premium model) produced tool calls but the SDK stopped
+                    // before executing them (stopWhen: stepCountIs(1)). Append the
+                    // assistant message to deps.messages and restart the loop with
+                    // the fast execution model. Phase 2's streamText call will see
+                    // the pending tool calls and execute them automatically.
+                    if (stepRouterPhase === "phase1" && phase1HadToolCalls) {
+                        try {
+                            const phase1Response = await result.response;
+                            // Append only new messages (assistant message with tool calls)
+                            const newMsgs = phase1Response.messages.slice(deps.messages.length);
+                            for (const msg of newMsgs) {
+                                if (msg.role === "assistant") {
+                                    deps.messages.push(msg);
+                                }
+                            }
+                        }
+                        catch {
+                            // If response extraction fails, fall through to normal completion
+                        }
+                        stepRouterPhase = "phase2";
+                        continue; // Re-enter while loop with Phase 2 (fast) model
+                    }
+                    if (signal.aborted) {
+                        deps.discardAbortedTurn(userModelMessage);
+                        yield { type: "done" };
+                        return;
+                    }
+                    try {
+                        const response = await result.response;
+                        if (!signal.aborted) {
+                            // Scrub oversized base64 image payloads from tool-result parts
+                            // BEFORE persisting. The vision bridge above only modified the
+                            // transient `tr` shown to the user — `response.messages` from
+                            // the AI SDK still carries the full base64 (e.g. Playwright
+                            // screenshot, ~1.5MB). Persisting that lets it accumulate and
+                            // overflow the model's context on subsequent turns.
+                            const scrubbed = scrubImagePayloadsInMessages(response.messages);
+                            deps.appendCompletedTurn(userModelMessage, sanitizeModelMessages(scrubbed));
+                            streamOk = true;
+                        }
+                    }
+                    catch (responseError) {
+                        if (!attemptedOverflowRecovery &&
+                            !assistantText.trim() &&
+                            modelInfo &&
+                            isContextLimitError(responseError)) {
+                            attemptedOverflowRecovery = true;
+                            continue;
+                        }
+                    }
+                    if (signal.aborted) {
+                        deps.discardAbortedTurn(userModelMessage);
+                        yield { type: "done" };
+                        return;
+                    }
+                    if (!streamOk && assistantText.trim()) {
+                        deps.appendCompletedTurn(userModelMessage, [{ role: "assistant", content: assistantText }]);
+                    }
+                    // Fallback: model responded in text despite tool_choice=required
+                    // Attempt JSON extraction from assistant text → yield as structured_response
+                    if (_hasResponseTools && !responseToolCalled && pilCtx.taskType && assistantText.trim()) {
+                        try {
+                            const jsonMatch = assistantText.match(/\{[\s\S]*\}/);
+                            if (jsonMatch) {
+                                const parsed = JSON.parse(jsonMatch[0]);
+                                if (Object.keys(parsed).length > 0) {
+                                    responseToolCalled = true;
+                                    yield {
+                                        type: "structured_response",
+                                        structuredResponse: {
+                                            taskType: pilCtx.taskType,
+                                            data: parsed,
+                                        },
+                                    };
+                                }
+                            }
+                        }
+                        catch {
+                            // JSON parse failed — leave as text-fallback
+                        }
+                    }
+                    // Track PIL output mode for /optimize metrics
+                    {
+                        const { setLastOutputMode } = await import("../pil/store.js");
+                        if (!_hasResponseTools)
+                            setLastOutputMode("conversational");
+                        else if (responseToolCalled)
+                            setLastOutputMode("structured");
+                        else
+                            setLastOutputMode("text-fallback");
+                    }
+                    // ROUTE-11: Fire routeFeedback after turn completes (success path).
+                    // Must come AFTER posttool calls (posttool fires during tool-result processing above).
+                    // Fire-and-forget — no await. Skipped when taskHash is null (bridge absent).
+                    {
+                        const turnDuration = Date.now() - turnStartMs;
+                        if (taskHash) {
+                            const tier = taskTypeToTier(pilCtx.taskType);
+                            void routeFeedback(taskHash, tier, runtime.modelId, "success", // Phase 6: all normal completions = 'success'
+                            0, // retryCount: 0 for first attempt
+                            turnDuration);
+                        }
+                        // HTTP path: also report via router store taskHash (covers warm/cold EE routes)
+                        const storeHash = routerStore.getState().taskHash;
+                        if (storeHash) {
+                            reportRouteOutcome(storeHash, "success", turnDuration);
+                        }
+                    }
+                    // Interaction log: agent response complete
+                    try {
+                        if (deps.session) {
+                            const sb = statusBarStore.getState();
+                            const turnDurationMs = Date.now() - turnStartMs;
+                            logInteraction(deps.session.id, "agent_response", {
+                                model: turnModelId,
+                                inputTokens: sb.in_tokens,
+                                outputTokens: sb.out_tokens,
+                                durationMs: turnDurationMs,
+                                data: {
+                                    textLength: assistantText.length,
+                                    toolCallCount: activeToolCalls.length,
+                                    compacted: deps.getCompactedThisTurn(),
+                                },
+                            });
+                        }
+                    }
+                    catch {
+                        /* fail-open */
+                    }
+                    const stopInput = {
+                        hook_event_name: "Stop",
+                        session_id: deps.session?.id,
+                        cwd: deps.bash.getCwd(),
+                    };
+                    await deps.fireHook(stopInput, signal).catch(() => { });
+                    // Debug trace: emit pipeline summary
+                    if (_debugOn) {
+                        const sb = statusBarStore.getState();
+                        const defaultInfo = getModelInfo(deps.modelId);
+                        const usedInfo = getModelInfo(turnModelId);
+                        const routerSaved = defaultInfo && usedInfo && defaultInfo.outputPrice > usedInfo.outputPrice
+                            ? (sb.out_tokens * (defaultInfo.outputPrice - usedInfo.outputPrice)) / 1_000_000
+                            : 0;
+                        const cacheSaved = sb.cache_read_tokens > 0 && defaultInfo
+                            ? (sb.cache_read_tokens *
+                                (defaultInfo.inputPrice - (defaultInfo.cachedInputPrice ?? defaultInfo.inputPrice * 0.1))) /
+                                1_000_000
+                            : 0;
+                        const trace = {
+                            turn_id: _debugTurnId,
+                            timestamp: turnStartMs,
+                            raw_prompt: userMessage,
+                            steps: _debugSteps,
+                            model_requested: deps.modelId,
+                            model_used: turnModelId,
+                            routed: turnModelId !== deps.modelId,
+                            input_tokens: sb.in_tokens,
+                            output_tokens: sb.out_tokens,
+                            cache_read_tokens: sb.cache_read_tokens,
+                            cost_usd: sb.session_usd,
+                            estimated_savings: {
+                                pil_tokens_saved: _pilEnrichmentDeltaSnapshot > 0 ? _pilEnrichmentDeltaSnapshot : 0,
+                                cache_tokens_saved: sb.cache_read_tokens,
+                                router_cost_saved_usd: routerSaved,
+                                total_tokens_saved: (_pilEnrichmentDeltaSnapshot > 0 ? _pilEnrichmentDeltaSnapshot : 0) + sb.cache_read_tokens,
+                                total_cost_saved_usd: routerSaved + cacheSaved,
+                            },
+                        };
+                        recordTurnTrace(trace);
+                        const traceLines = [];
+                        traceLines.push("\n┌─ Pipeline Trace ─────────────────────────");
+                        for (const step of _debugSteps) {
+                            const dur = step.duration_ms < 1 ? "<1ms" : `${step.duration_ms}ms`;
+                            const saved = step.tokens_saved ? ` (saved ~${step.tokens_saved} tok)` : "";
+                            traceLines.push(`│ ▸ ${step.name} [${dur}]${saved}`);
+                            traceLines.push(`│   ${step.output_summary}`);
+                        }
+                        const routeLabel = trace.routed ? `${trace.model_requested}→${trace.model_used}` : trace.model_used;
+                        traceLines.push(`│ Model: ${routeLabel} | ↑${sb.in_tokens} ↓${sb.out_tokens} | $${sb.session_usd.toFixed(4)}`);
+                        if (trace.estimated_savings.total_cost_saved_usd > 0) {
+                            traceLines.push(`│ Savings: ~${trace.estimated_savings.total_tokens_saved} tok, ~$${trace.estimated_savings.total_cost_saved_usd.toFixed(4)}`);
+                        }
+                        traceLines.push("└──────────────────────────────────────────\n");
+                        yield { type: "content", content: traceLines.join("\n") };
+                    }
+                    if (modelInfo?.contextWindow) {
+                        await deps.postTurnCompact(provider, system, modelInfo.contextWindow, signal);
+                    }
+                    yield { type: "done" };
+                    return;
+                }
+                catch (err) {
+                    if (signal.aborted) {
+                        deps.discardAbortedTurn(userModelMessage);
+                        // ROUTE-11: Fire routeFeedback for cancelled turns (abort path).
+                        // Fire-and-forget — no await. Skipped when taskHash is null.
+                        {
+                            const turnDuration = Date.now() - turnStartMs;
+                            if (taskHash) {
+                                const tier = taskTypeToTier(pilCtx.taskType);
+                                void routeFeedback(taskHash, tier, runtime.modelId, "cancelled", 0, turnDuration);
+                            }
+                            const storeHash = routerStore.getState().taskHash;
+                            if (storeHash) {
+                                reportRouteOutcome(storeHash, "cancelled", turnDuration);
+                            }
+                        }
+                        yield { type: "content", content: "\n\n[Cancelled]" };
+                        yield { type: "done" };
+                        return;
+                    }
+                    if (!attemptedOverflowRecovery && !assistantText.trim() && modelInfo && isContextLimitError(err)) {
+                        attemptedOverflowRecovery = true;
+                        continue;
+                    }
+                    // Transient network/server error retry — up to MAX_STREAM_RETRIES extra attempts.
+                    // Only retry when no content has flowed yet (assistantText empty) to avoid
+                    // partial-output corruption. Honour the abort signal between retries.
+                    if (!assistantText.trim() && streamRetryCount < MAX_STREAM_RETRIES && !signal.aborted) {
+                        const { transient } = classifyStreamError(err);
+                        if (transient) {
+                            streamRetryCount++;
+                            // Exponential backoff: 500 → 2000 ms with ±25% jitter
+                            const baseMs = 500;
+                            const expMs = Math.min(baseMs * 4 ** (streamRetryCount - 1), 8_000);
+                            const spread = expMs * 0.25;
+                            const nextDelayMs = Math.round(expMs + (Math.random() * 2 - 1) * spread);
+                            const errorName = err instanceof Error ? err.name : "Error";
+                            const errorMessage = err instanceof Error ? err.message : String(err);
+                            // Emit harness telemetry event
+                            try {
+                                const _ar = globalThis.__muonroiAgentRuntime;
+                                _ar?.emitEvent({
+                                    t: "event",
+                                    kind: "stream-retry",
+                                    attempt: streamRetryCount,
+                                    maxAttempts: MAX_STREAM_RETRIES + 1,
+                                    errorName,
+                                    errorMessage,
+                                    nextDelayMs,
+                                });
+                            }
+                            catch {
+                                /* best-effort */
+                            }
+                            try {
+                                if (deps.session) {
+                                    logInteraction(deps.session.id, "stream_retry", {
+                                        data: {
+                                            attempt: streamRetryCount,
+                                            maxAttempts: MAX_STREAM_RETRIES + 1,
+                                            errorName,
+                                            errorMessage: errorMessage.slice(0, 200),
+                                            nextDelayMs,
+                                        },
+                                    });
+                                }
+                            }
+                            catch {
+                                /* fail-open */
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, nextDelayMs));
+                            if (!signal.aborted) {
+                                continue;
+                            }
+                        }
+                    }
+                    const authError = isAuthenticationError(err);
+                    const friendly = humanizeApiError(err);
+                    notifyObserver(observer?.onError, {
+                        message: friendly,
+                        timestamp: Date.now(),
+                    });
+                    yield {
+                        type: "error",
+                        content: friendly,
+                        isAuthError: authError,
+                    };
+                    if (assistantText.trim()) {
+                        deps.appendCompletedTurn(userModelMessage, [{ role: "assistant", content: assistantText }]);
+                    }
+                    else if (deps.session && userWriteAheadSeq != null) {
+                        // Phase A5 — Stream threw before producing assistant text. The
+                        // write-ahead user row is stuck at `status='pending'`. Mark it
+                        // errored so forensics + recovery can distinguish "in-flight"
+                        // from "crashed mid-flight".
+                        markMessageErrored(deps.session.id, userWriteAheadSeq);
+                    }
+                    // ROUTE-11: Fire routeFeedback for failed turns (error path).
+                    // Must come AFTER posttool calls. Fire-and-forget — no await.
+                    {
+                        const turnDuration = Date.now() - turnStartMs;
+                        if (taskHash) {
+                            const tier = taskTypeToTier(pilCtx.taskType);
+                            void routeFeedback(taskHash, tier, runtime.modelId, "fail", 0, turnDuration);
+                        }
+                        const storeHash = routerStore.getState().taskHash;
+                        if (storeHash) {
+                            reportRouteOutcome(storeHash, "fail", turnDuration);
+                        }
+                    }
+                    const stopFailureInput = {
+                        hook_event_name: "StopFailure",
+                        error: friendly,
+                        session_id: deps.session?.id,
+                        cwd: deps.bash.getCwd(),
+                    };
+                    await deps.fireHook(stopFailureInput, signal).catch(() => { });
+                    if (modelInfo?.contextWindow) {
+                        await deps.postTurnCompact(provider, system, modelInfo.contextWindow, signal);
+                    }
+                    yield { type: "done" };
+                    return;
+                }
+                finally {
+                    await closeMcp?.().catch(() => { });
+                }
+            }
+        }
+        finally {
+            if (deps.getAbortController()?.signal === signal) {
+                deps.setAbortController(null);
+            }
+        }
+    }
+}
+//# sourceMappingURL=message-processor.js.map