muonroi-cli 1.3.4 → 1.4.1

package/src/orchestrator/message-processor.ts

@@ -1,1985 +0,0 @@
-// 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 { type ModelMessage, stepCountIs, streamText, type ToolSet } 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 type {
-  PostToolUseFailureHookInput,
-  PostToolUseHookInput,
-  PreToolUseHookInput,
-  SessionStartHookInput,
-  StopFailureHookInput,
-  StopHookInput,
-  UserPromptSubmitHookInput,
-} from "../hooks/types";
-import { buildMcpToolSet } from "../mcp/runtime";
-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,
-  type ResolvedModelRuntime,
-  resolveModelRuntime,
-  shouldDropParam,
-} from "../providers/runtime.js";
-import type { ProviderId } from "../providers/types.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,
-  type SessionStore,
-} from "../storage/index";
-import type { BashTool } from "../tools/bash";
-import { createBuiltinTools } from "../tools/registry.js";
-import type { AgentMode, SessionInfo, StreamChunk, SubagentStatus, ToolCall, ToolResult } from "../types/index";
-import { isDebugEnabled, type PipelineStep, recordTurnTrace, type TurnTrace } from "../ui/slash/debug.js";
-import { statusBarStore } from "../ui/status-bar/store.js";
-import { appendDecisionLog } from "../usage/decision-log.js";
-import { type PermissionMode, toolNeedsApproval } from "../utils/permission-mode.js";
-import {
-  getAutoCouncilConfidence,
-  getAutoCouncilMinRoles,
-  getRoleModels,
-  getTopLevelCompactKeepLast,
-  getTopLevelCompactThresholdChars,
-  getTopLevelToolBudgetChars,
-  isAutoCouncilEnabled,
-  isProviderDisabled,
-  loadMcpServers,
-  loadValidSubAgents,
-} from "../utils/settings";
-import type { AbortContext } from "./abort.js";
-import type { LegacyProvider, ProcessMessageObserver } from "./agent-options";
-import { relaxCompactionSettings } from "./compaction";
-import type { CouncilManager } from "./council-manager.js";
-import type { CrossTurnDedup } from "./cross-turn-dedup.js";
-import { wrapToolSetWithDedup } from "./cross-turn-dedup.js";
-import { humanizeApiError, isAuthenticationError, isContextLimitError } from "./error-utils";
-import { lastPersistedSeq } from "./message-seq.js";
-import type { PendingCallsLog } from "./pending-calls.js";
-import { stableCallId } from "./pending-calls.js";
-import { applyModelConstraints, buildSystemPromptParts } from "./prompts";
-import { extractProviderOptionsShape } from "./provider-options-shape.js";
-import type { ReadPathBudget } from "./read-path-budget.js";
-import { wrapToolSetWithReadBudget } from "./read-path-budget.js";
-import { containsEncryptedReasoning, sanitizeModelMessages } from "./reasoning";
-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";
-import type { TurnRunnerDepsBase } from "./turn-runner-deps.js";
-
-/**
- * Dependency surface the MessageProcessor needs to reach back into Agent
- * state without holding a circular reference. Properties expose array
- * references (mutating push() must affect the same array the Agent reads on
- * subsequent turns). Method callbacks delegate to Agent private methods.
- */
-export interface MessageProcessorDeps extends TurnRunnerDepsBase {
-  // ---- Read/write state references --------------------------------------
-  // (messages, bash, mode, maxToolRounds, schedules, sendTelegramFile inherited)
-  /** Live messageSeqs array (mutated by push; parallel to messages). */
-  readonly messageSeqs: Array<number | null>;
-  /** Session bookkeeping. */
-  readonly session: SessionInfo | null;
-  readonly sessionStore: SessionStore | null;
-  readonly modelId: string;
-  readonly providerId: ProviderId;
-  readonly batchApi: boolean;
-  readonly permissionMode: PermissionMode;
-  readonly externalAbortContext: AbortContext | null;
-  readonly pendingCalls: PendingCallsLog | null;
-  readonly councilManager: CouncilManager;
-  readonly crossTurnDedup: CrossTurnDedup | null;
-  readonly readBudget: ReadPathBudget | null;
-  readonly priorWarningIdsInSession: Set<string>;
-  readonly sessionEEGuidance: Map<string, { toolName: string; message: string; why: string; confidence: number }>;
-  readonly flowReady: Promise<void> | null;
-
-  // ---- Scalar getters / setters -----------------------------------------
-  getAbortController(): AbortController | null;
-  setAbortController(ctrl: AbortController | null): void;
-  getSessionStartHookFired(): boolean;
-  setSessionStartHookFired(v: boolean): void;
-  getPlanContext(): string | null;
-  setPlanContext(v: string | null): void;
-  getResumeDigest(): string | null;
-  setResumeDigest(v: string | null): void;
-  getActiveRunId(): string | null;
-  getPendingCwdNote(): string | null;
-  setPendingCwdNote(v: string | null): void;
-  setPilActive(v: boolean): void;
-  setPilEnrichmentDelta(n: number): void;
-  setCurrentCallId(id: string): void;
-  setLastPromptBreakdown(
-    b: {
-      systemChars: number;
-      staticPrefixChars: number;
-      dynamicSuffixChars: number;
-      playwrightGuidanceChars: number;
-      messagesChars: number;
-      messagesCount: number;
-      toolsChars: number;
-      toolsCount: number;
-    } | null,
-  ): void;
-  setTurnUserGoalExcerpt(v: string): void;
-  setTurnAssistantReasoning(v: string): void;
-  appendTurnAssistantReasoning(delta: string): void;
-  getTurnAssistantReasoning(): string;
-  setPriorWarningIdsInSession(s: Set<string>): void;
-  setMessages(messages: ModelMessage[]): void;
-
-  // ---- Behavior delegators ----------------------------------------------
-  requireProvider(): LegacyProvider;
-  emitSubagentStatus(status: SubagentStatus | null): void;
-  fireHook(
-    input: unknown,
-    signal?: AbortSignal,
-  ): Promise<{
-    blocked: boolean;
-    blockingErrors: Array<{ command: string; stderr: string }>;
-    preventContinuation: boolean;
-    additionalContexts: string[];
-    results: import("../hooks/types.js").HookResult[];
-    eeMatches: import("../hooks/types.js").EEMatchEntry[];
-  }>;
-  consumeBackgroundNotifications(): Promise<string[]>;
-  initOAuthProvider(): Promise<void>;
-  buildRecentTurnsSummary(): string | null;
-  estimateProjectSize(): "small" | "medium" | "large" | null;
-  countFilesTouched(): number;
-  respondToToolApproval(approvalId: string, approved: boolean): void;
-  runCouncilV2(
-    userMessage: string,
-    opts: { skipClarification: boolean; observer?: ProcessMessageObserver; userModelMessage: ModelMessage },
-  ): AsyncGenerator<StreamChunk, void, unknown>;
-  processMessage(
-    userMessage: string,
-    observer?: ProcessMessageObserver,
-    images?: Array<{ path: string; mediaType: string; base64: string }>,
-  ): AsyncGenerator<StreamChunk, void, unknown>;
-  processMessageBatchTurn(args: {
-    userModelMessage: ModelMessage;
-    observer?: ProcessMessageObserver;
-    provider: LegacyProvider;
-    subagents: ReturnType<typeof loadValidSubAgents>;
-    system: string;
-    runtime: ResolvedModelRuntime;
-    modelInfo: ResolvedModelRuntime["modelInfo"];
-    signal: AbortSignal;
-  }): AsyncGenerator<StreamChunk, void, unknown>;
-}
-
-/**
- * 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 {
-  constructor(private deps: MessageProcessorDeps) {}
-
-  async *run(
-    userMessage: string,
-    observer?: ProcessMessageObserver,
-    images?: Array<{ path: string; mediaType: string; base64: string }>,
-  ): AsyncGenerator<StreamChunk, void, unknown> {
-    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: SessionStartHookInput = {
-        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: UserPromptSubmitHookInput = {
-      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: PipelineStep[] = [];
-    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 as "task" | "chitchat" | 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: string | null = 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 as Array<{ type: string }>).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 as 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: LegacyProvider;
-    if (turnProviderId !== deps.providerId) {
-      // Even if the key is reachable, skip disabled providers
-      const turnKey = !isProviderDisabled(turnProviderId as ProviderId)
-        ? 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 as 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: ModelMessage;
-    if (images?.length) {
-      const parts: Array<{ type: "text"; text: string } | { type: "image"; image: string; mediaType: string }> = [
-        { 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 as Array<{ type: string }>).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 as Array<{ type: string }>).filter((p) => p.type !== "image");
-              return { ...m, content: filtered } as typeof m;
-            }),
-          );
-        }
-      }
-    }
-
-    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: number | null = 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: "phase1" | "phase2" | "done" = 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 as { complexityTier?: string | null }).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 as { complexityTier?: string | null }).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: (() => Promise<void>) | undefined;
-        let stepNumber = -1;
-        const activeToolCalls: ToolCall[] = [];
-        // 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: ToolSet = !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: ToolSet = 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: any = buildTurnProviderOptions(runtime, { sessionId: deps.session?.id }) ?? {};
-          const providerOpts = runtime.modelInfo?.reasoning
-            ? {
-                ...baseProviderOpts,
-                anthropic: {
-                  ...(baseProviderOpts.anthropic ?? {}),
-                  thinking: {
-                    type: "enabled" as const,
-                    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 as {
-            anthropic?: { thinking?: { type?: string } };
-          };
-          if (
-            providerOptsAnyView.anthropic?.thinking?.type === "enabled" &&
-            thinkingModelInfo?.thinkingType === "adaptive"
-          ) {
-            providerOptsAnyView.anthropic.thinking = { type: "adaptive" as unknown as "enabled" };
-          }
-
-          // 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: "maxOutputTokens" | "temperature" | "topP"): boolean => shouldDropParam(runtime, p);
-
-          const systemForModel = runtime.modelId.startsWith("claude")
-            ? [
-                {
-                  role: "system" as const,
-                  content: systemParts.staticPrefix,
-                  providerOptions: { anthropic: { cacheControl: { type: "ephemeral" as const } } },
-                },
-                { role: "system" as const, 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 as { text?: unknown }).text === "string") {
-                  s += (part as { text: string }).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 as { description?: string }).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 as { parameters?: unknown; inputSchema?: unknown }).parameters ??
-                (t as { inputSchema?: unknown }).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 as readonly unknown[],
-              systemChars: (systemForModel as unknown as { length?: number })?.length ?? 0,
-              toolNames: tools ? Object.keys(tools as Record<string, unknown>) : 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) as typeof 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) as typeof 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: unknown) => {
-              stepNumber = getStepNumber(event, stepNumber + 1);
-              notifyObserver(observer?.onStepStart, {
-                stepNumber,
-                timestamp: Date.now(),
-              });
-            },
-            onStepFinish: (event: unknown) => {
-              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 as Record<string, unknown>).__muonroiAgentRuntime as
-                  | { emitEvent: (e: unknown) => void }
-                  | undefined;
-                _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 as { text?: string }).text === "string"
-                    ? (part as { text: string }).text.length
-                    : undefined,
-                hasReasoning:
-                  typeof (part as unknown as { reasoning?: string }).reasoning === "string"
-                    ? (part as unknown as { reasoning: string }).reasoning.length
-                    : undefined,
-              });
-              if (part.type === "error") {
-                wireDebug.logError(_wireProviderIdTop, (part as { error?: unknown }).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 as Record<string, unknown>).__muonroiAgentRuntime as
-                    | { emitEvent: (e: unknown) => void }
-                    | undefined;
-                  _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: import("../hooks/types.js").PreToolIntentContext = {
-                    ...(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: PreToolUseHookInput = {
-                    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: [] as Array<{ command: string; stderr: string }>,
-                    preventContinuation: false,
-                    additionalContexts: [] as string[],
-                    results: [] as import("../hooks/types.js").HookResult[],
-                    eeMatches: [] as import("../hooks/types.js").EEMatchEntry[],
-                  }));
-                  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 as ToolCall & { _pendingCallId?: string })._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: ToolCall = {
-                  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 as ToolCall & { _pendingCallId?: string })?._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: PostToolUseHookInput = {
-                    hook_event_name: "PostToolUse",
-                    tool_name: part.toolName,
-                    tool_input: (part.input as Record<string, unknown>) ?? {},
-                    tool_output:
-                      typeof tr.output === "string"
-                        ? { text: tr.output }
-                        : ((tr.output as unknown as Record<string, unknown>) ?? {}),
-                    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 as unknown;
-                  const unwrapped =
-                    rawOutput && typeof rawOutput === "object" && (rawOutput as { type?: string }).type === "json"
-                      ? ((rawOutput as { value?: unknown }).value ?? {})
-                      : (rawOutput ?? {});
-                  yield {
-                    type: "structured_response" as StreamChunk["type"],
-                    structuredResponse: {
-                      taskType: taskType ?? part.toolName,
-                      data: unwrapped as Record<string, unknown>,
-                    },
-                  };
-                  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 as {
-                  type: "tool-error";
-                  toolCallId: string;
-                  toolName: string;
-                  input?: unknown;
-                  error: unknown;
-                };
-                const tc: ToolCall = {
-                  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 as ToolCall & { _pendingCallId?: string })?._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: PostToolUseFailureHookInput = {
-                    hook_event_name: "PostToolUseFailure",
-                    tool_name: errPart.toolName,
-                    tool_input: (errPart.input as Record<string, unknown>) ?? {},
-                    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 as unknown as {
-                  approvalId: string;
-                  toolCall: { toolCallId: string; toolName: string; input: unknown };
-                };
-                const toolCallId = approvalPart.toolCall?.toolCallId ?? "";
-                const pendingTc = activeToolCalls.find((tc) => tc.id === toolCallId);
-                const tcForChunk = pendingTc ?? {
-                  id: toolCallId,
-                  type: "function" as const,
-                  function: {
-                    name: approvalPart.toolCall?.toolName ?? "paid_request",
-                    arguments: JSON.stringify(approvalPart.toolCall?.input ?? {}),
-                  },
-                };
-
-                // Payment pre-check disabled — Stripe billing pending.
-                const paymentPrecheck: import("../types/index").PaymentPrecheck | undefined = 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: unknown) {
-            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]) as Record<string, unknown>;
-                if (Object.keys(parsed).length > 0) {
-                  responseToolCalled = true;
-                  yield {
-                    type: "structured_response" as StreamChunk["type"],
-                    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: StopHookInput = {
-            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: TurnTrace = {
-              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: string[] = [];
-            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: unknown) {
-          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 as Record<string, unknown>).__muonroiAgentRuntime as
-                  | { emitEvent: (e: unknown) => void }
-                  | undefined;
-                _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<void>((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: StopFailureHookInput = {
-            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);
-      }
-    }
-  }
-}