muonroi-cli 1.2.3 → 1.3.1

package/dist/src/orchestrator/orchestrator.js

@@ -0,0 +1,2173 @@
+// Multi-provider wired — runtime dispatch via providers/runtime.ts.
+import { extractSession } from "../ee/extract-session.js";
+import { bootstrapEEClient, getDefaultEEClient, getLastSurfacedState } from "../ee/intercept.js";
+import { getTenantId } from "../ee/tenant.js";
+import { createRun, getActiveRunId, setActiveRunId } from "../flow/run-manager.js";
+import { ensureFlowDir } from "../flow/scaffold.js";
+import { executeEventHooks } from "../hooks/index.js";
+import { shutdownWorkspaceLspManager } from "../lsp/runtime.js";
+import { ensureDefaultMcpServers } from "../mcp/auto-setup.js";
+import { getModelByTier, getModelInfo, normalizeModelId } from "../models/registry.js";
+import { getProviderCapabilities } from "../providers/capabilities.js";
+import { apiBaseFor } from "../providers/endpoints.js";
+import { loadKeyForProvider } from "../providers/keychain.js";
+import { createProviderFactory, createProviderFactoryAsync, detectProviderForModel, resolveModelRuntime as resolveRuntime, } from "../providers/runtime.js";
+import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, logInteraction, markMessageCompleted, recordUsageEvent, SessionStore, } from "../storage/index.js";
+import { BashTool } from "../tools/bash.js";
+import { createBuiltinTools } from "../tools/registry.js";
+import { ScheduleManager } from "../tools/schedule.js";
+import { statusBarStore } from "../ui/status-bar/store.js";
+import { appendCostLog } from "../usage/cost-log.js";
+import { appendDecisionLog } from "../usage/decision-log.js";
+import { projectCostUSD } from "../usage/estimator.js";
+import { getAutoCompactThresholdPct, getCouncilRounds, getCurrentModel, getCurrentShellSettings, getModeSpecificModel, getRoleModel, getRoleModels, isAutoCompactAfterTurnEnabled, isCouncilMultiProviderPreferred, isProviderDisabled, } from "../utils/settings.js";
+import { runSideQuestion } from "../utils/side-question.js";
+import { buildVerifyDetectPrompt, normalizeVerifyRecipe } from "../verify/entrypoint.js";
+import { runVerifyOrchestration } from "../verify/orchestrator.js";
+import { COUNCIL_COLOR_BG, COUNCIL_COLOR_RESET, COUNCIL_ROLE_COLORS, } from "./agent-options.js";
+import { BatchTurnRunner } from "./batch-turn-runner.js";
+import { accumulateUsage, buildAssistantBatchMessage, buildBatchChatCompletionRequest, buildBatchName, buildToolBatchMessage, extractJsonObject, getBatchUsage, hasUsage, parseToolArgumentsOrRaw, toLocalToolCall, } from "./batch-utils.js";
+import { createCompactionSummaryMessage, DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS, estimateConversationTokens, extractUserContent, generateCompactionSummary, POST_TURN_MIN_TOKENS, prepareCompaction, shouldCompactContext, } from "./compaction.js";
+import { CouncilManager } from "./council-manager.js";
+import { CrossTurnDedup, isCrossTurnDedupEnabled } from "./cross-turn-dedup.js";
+import { DelegationManager } from "./delegations.js";
+import { loadFlowResumeDigest } from "./flow-resume.js";
+import { MessageProcessor } from "./message-processor.js";
+import { lastPersistedSeq } from "./message-seq.js";
+import { buildSystemPrompt, MAX_TOOL_ROUNDS } from "./prompts.js";
+import { getReadPathBudgetCap, ReadPathBudget } from "./read-path-budget.js";
+import { withStreamRetry } from "./retry-stream.js";
+import { StreamRunner } from "./stream-runner.js";
+import { setProviderHint } from "./token-counter.js";
+import { firstLine, formatSubagentActivity, toToolResult } from "./tool-utils.js";
+// ---------------------------------------------------------------------------
+// Provider implementations
+// ---------------------------------------------------------------------------
+/**
+ * Create a provider factory for the given provider ID using the shared runtime module.
+ */
+function createProvider(providerId, apiKey, baseURL) {
+    return createProviderFactory(providerId, { apiKey, baseURL }).factory;
+}
+/**
+ * Generate a session title using the Anthropic provider.
+ * Kept as a lightweight stub for Phase 0 — title generation ships in Phase 1.
+ */
+function genTitle(_provider, userMessage) {
+    // Phase 0 stub: return a truncated version of the first user message as title.
+    // Phase 1 will replace this with a real LLM-based title generation call.
+    const title = userMessage.slice(0, 60).trim() || "New session";
+    return Promise.resolve({ title, modelId: DEFAULT_MODEL });
+}
+/**
+ * Resolve a model ID to a runnable AI SDK LanguageModel.
+ * Uses the Anthropic provider factory created by createProvider().
+ */
+function resolveModelRuntime(provider, modelId) {
+    return resolveRuntime(provider, modelId);
+}
+const DEFAULT_MODEL = "claude-sonnet-4-6";
+async function toolSetToBatchTools(_tools) {
+    // Batch API not supported with Anthropic in Phase 0. Phase 1 may add this.
+    throw new Error("Batch API not available in Phase 0. Use standard streaming mode.");
+}
+async function createBatch(_opts) {
+    throw new Error("Batch API not available in Phase 0. Use standard streaming mode.");
+}
+async function addBatchRequests(_opts) {
+    throw new Error("Batch API not available in Phase 0. Use standard streaming mode.");
+}
+async function pollBatchRequestResult(_opts) {
+    throw new Error("Batch API not available in Phase 0. Use standard streaming mode.");
+}
+function getBatchChatCompletion(_result) {
+    throw new Error("Batch API not available in Phase 0. Use standard streaming mode.");
+}
+function createTools(_bash, _provider, _mode, _opts) {
+    return createBuiltinTools(_bash, (_mode ?? "agent"), {
+        runTask: _opts?.runTask,
+        runDelegation: _opts?.runDelegation,
+        readDelegation: _opts?.readDelegation,
+        listDelegations: _opts?.listDelegations,
+        modelId: _opts?.modelId,
+    });
+}
+// ---------------------------------------------------------------------------
+// END Plan 00-05 provider implementations
+// (Phase 12.3 — `buildVisionUserMessages` was inlined into StreamRunner;
+// vision is an anti-feature per PROJECT.md Out-of-Scope so the helper is gone.)
+// ---------------------------------------------------------------------------
+// ============================================================================
+// Agent class — fields, constructor, session management, core processing loop
+// ============================================================================
+export class Agent {
+    provider = null;
+    providerId = "anthropic";
+    apiKey = null;
+    baseURL = null;
+    bash;
+    delegations;
+    schedules;
+    sessionStore = null;
+    workspace = null;
+    session = null;
+    messages = [];
+    messageSeqs = [];
+    abortController = null;
+    maxToolRounds;
+    mode = "agent";
+    modelId;
+    maxTokens;
+    planContext = null;
+    subagentStatusListeners = new Set();
+    sendTelegramFile = null;
+    batchApi = false;
+    sessionStartHookFired = false;
+    /** PIL context for current turn — set after runPipeline, cleared after recordUsage. */
+    _pilActive = false;
+    _pilEnrichmentDelta = 0;
+    /**
+     * Breakdown of the system prompt + messages + tools sent on the last call.
+     * Captured immediately before streamText and consumed by recordUsage to
+     * attach to the cost-log entry. Cleared after recordUsage so subsequent
+     * non-message calls don't reuse stale data.
+     */
+    _lastPromptBreakdown = null;
+    /**
+     * Phase O1 — JSON-shape of the providerOptions object on the most
+     * recent streamText call. Captured immediately before streamText and
+     * consumed by recordUsage; cleared after. Cost-leak forensics surfaces
+     * this so we can answer "did this billed call carry store=true?" etc.
+     */
+    _lastProviderOptionsShape = null;
+    /** External abort context from src/index.ts SIGINT handler (TUI-04). */
+    externalAbortContext = null;
+    /** Pending calls log for Pitfall 9 staged-write tracking. */
+    pendingCalls = null;
+    /** Active permission mode — controls which tool calls auto-approve vs require user confirmation. */
+    permissionMode = "safe";
+    /** Flow run init promise — awaited before first message turn. */
+    _flowReady = null;
+    /** Active .muonroi-flow/ run ID for this session. */
+    _activeRunId = null;
+    /** Resume digest loaded from active flow run state.md. */
+    _resumeDigest = null;
+    /**
+     * Phase 12.1-02: All council state (synthesis/continuation flags, resolver
+     * + buffer maps, stats) lives inside CouncilManager. Agent holds one ref.
+     */
+    councilManager;
+    /** Whether compaction already ran during the current turn (prevents double-compact). */
+    _compactedThisTurn = false;
+    /** Guard: OAuth provider init runs at most once per Agent instance. */
+    _oauthInitDone = false;
+    /** P0 native observation: warning IDs surfaced earlier in this session — sent as intent_context.priorWarningIdsInSession. */
+    _priorWarningIdsInSession = new Set();
+    /** EE session guidance: structured warnings accumulated across turns — injected into model context at turn start. Keyed by principle_uuid to deduplicate. */
+    _sessionEEGuidance = new Map();
+    /** P0 native observation: rolling buffer of assistant reasoning text in current turn — last 200 chars sent as intent_context.assistantReasoningExcerpt. */
+    _turnAssistantReasoning = "";
+    /** Per-call correlation id for top-level streamText; set in MessageProcessor, consumed by recordUsage / onFinish llm-done. */
+    _currentCallId = "";
+    /** P0 native observation: first 200 chars of the user's current turn — sent as intent_context.userGoalExcerpt to PreToolUse. */
+    _turnUserGoalExcerpt = "";
+    /** Compaction statistics tracking count and total tokens saved. */
+    _compactionStats = { count: 0, totalSaved: 0 };
+    /**
+     * Pinned message sequences. A pinned user message is preserved verbatim across
+     * compaction — it is re-injected as a system note immediately after the
+     * compaction summary, so the model still sees the original wording.
+     * V1 only supports user messages (avoids splitting tool-call/result pairs).
+     */
+    _pinnedSeqs = new Set();
+    /** One-shot cwd note injected at the start of the next processMessage turn after setCwd(). Cleared after injection. */
+    _pendingCwdNote = null;
+    // Phase C3: cross-turn tool-output dedup. One instance per session; bumped
+    // on each user turn. Lazily initialized so disabled-via-env path stays cheap.
+    _crossTurnDedup = isCrossTurnDedupEnabled() ? new CrossTurnDedup() : null;
+    // Phase C4 — input-keyed read-path budget. Complements C3 (output hash) by
+    // catching re-reads of files the agent edited between rounds. Disabled
+    // when MUONROI_MAX_READS_PER_PATH=0.
+    _readBudget = (() => {
+        const cap = getReadPathBudgetCap();
+        return cap > 0 ? new ReadPathBudget(cap) : null;
+    })();
+    constructor(apiKey, baseURL, model, maxToolRounds, options = {}) {
+        this.baseURL = baseURL || null;
+        this.bash = new BashTool(process.cwd(), {
+            sandboxMode: options.sandboxMode ?? "off",
+            sandboxSettings: options.sandboxSettings,
+            shellSettings: options.shellSettings ?? getCurrentShellSettings(),
+        });
+        this.delegations = new DelegationManager(() => this.bash.getCwd());
+        // Phase 12.1-02: council state + helpers live in CouncilManager. DI via
+        // getter callbacks so the manager reads live Agent state without holding
+        // a circular reference to the Agent instance.
+        this.councilManager = new CouncilManager({
+            getModelId: () => this.modelId,
+            getSessionId: () => this.session?.id ?? null,
+            hasSessionStore: () => this.sessionStore !== null,
+            getMessages: () => this.messages,
+            getBash: () => this.bash,
+            getMode: () => this.mode,
+        });
+        const initialMode = "agent";
+        this.modelId = normalizeModelId(model || getCurrentModel(initialMode));
+        this.providerId = detectProviderForModel(this.modelId);
+        setProviderHint(this.providerId);
+        if (apiKey) {
+            this.setApiKey(apiKey, baseURL);
+        }
+        this.schedules = new ScheduleManager(() => this.bash.getCwd(), () => this.modelId);
+        this.maxToolRounds = maxToolRounds || MAX_TOOL_ROUNDS;
+        const envMax = Number(process.env.MUONROI_MAX_TOKENS);
+        this.maxTokens = Number.isFinite(envMax) && envMax > 0 ? envMax : 16_384;
+        this.batchApi = options.batchApi ?? false;
+        // TUI-04: wire external abort context and pending calls log if provided.
+        this.externalAbortContext = options.abortContext ?? null;
+        this.pendingCalls = options.pendingCalls ?? null;
+        this.permissionMode = options.permissionMode ?? "safe";
+        ensureDefaultMcpServers();
+        if (options.persistSession !== false) {
+            this.sessionStore = new SessionStore(this.bash.getCwd());
+            this.workspace = this.sessionStore.getWorkspace();
+            this.session = this.sessionStore.openSession(options.session, this.modelId, this.mode, this.bash.getCwd());
+            this.mode = this.session.mode;
+            const transcript = loadTranscriptState(this.session.id);
+            this.messages = transcript.messages;
+            this.messageSeqs = transcript.seqs;
+            this.sessionStore.setModel(this.session.id, this.modelId);
+            // Flow run setup — fire-and-forget, awaited before first message turn.
+            this._flowReady = this._initFlow();
+        }
+    }
+    /**
+     * Initialize .muonroi-flow/ run for this session.
+     * Fail-open: any error sets _activeRunId = null silently.
+     */
+    async _initFlow() {
+        await bootstrapEEClient().catch(() => { });
+        try {
+            const flowDir = await ensureFlowDir(this.bash.getCwd());
+            const existing = await getActiveRunId(flowDir);
+            if (existing) {
+                this._activeRunId = existing;
+                return;
+            }
+            const run = await createRun(flowDir);
+            await setActiveRunId(flowDir, run.id);
+            this._activeRunId = run.id;
+        }
+        catch {
+            this._activeRunId = null;
+        }
+        // Load resume digest for PIL context injection (fail-open).
+        try {
+            this._resumeDigest = await loadFlowResumeDigest(this.bash.getCwd());
+        }
+        catch {
+            this._resumeDigest = null;
+        }
+    }
+    getModel() {
+        return this.modelId;
+    }
+    getActiveRunId() {
+        return this._activeRunId;
+    }
+    setModel(model) {
+        this.modelId = normalizeModelId(model);
+        const newProviderId = detectProviderForModel(this.modelId);
+        if (newProviderId !== this.providerId && this.apiKey) {
+            this.providerId = newProviderId;
+            setProviderHint(this.providerId);
+            const effectiveBaseURL = this.providerId !== "anthropic" && this.baseURL === apiBaseFor("anthropic")
+                ? undefined
+                : (this.baseURL ?? undefined);
+            this.provider = createProvider(this.providerId, this.apiKey, effectiveBaseURL);
+        }
+        if (this.sessionStore && this.session) {
+            this.sessionStore.setModel(this.session.id, this.modelId);
+            this.session = this.sessionStore.getRequiredSession(this.session.id);
+        }
+    }
+    getMode() {
+        return this.mode;
+    }
+    getSandboxMode() {
+        return this.bash.getSandboxMode();
+    }
+    setSandboxMode(mode) {
+        this.bash.setSandboxMode(mode);
+    }
+    getSandboxSettings() {
+        return this.bash.getSandboxSettings();
+    }
+    setSandboxSettings(settings) {
+        this.bash.setSandboxSettings(settings);
+    }
+    setMode(mode) {
+        if (mode !== this.mode) {
+            this.mode = mode;
+            const modeModel = getModeSpecificModel(mode);
+            if (modeModel) {
+                this.modelId = normalizeModelId(modeModel);
+            }
+            if (this.sessionStore && this.session) {
+                this.sessionStore.setMode(this.session.id, mode);
+                this.sessionStore.setModel(this.session.id, this.modelId);
+                this.session = this.sessionStore.getRequiredSession(this.session.id);
+            }
+        }
+    }
+    setPlanContext(ctx) {
+        this.planContext = ctx;
+    }
+    setSendTelegramFile(fn) {
+        this.sendTelegramFile = fn;
+    }
+    hasApiKey() {
+        return !!this.apiKey;
+    }
+    setApiKey(apiKey, baseURL) {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL || null;
+        // Only pass baseURL to provider factory if it's an explicit override,
+        // not the default Anthropic URL (which would break non-Anthropic providers).
+        const effectiveBaseURL = this.providerId !== "anthropic" && baseURL === apiBaseFor("anthropic") ? undefined : baseURL;
+        this.provider = createProvider(this.providerId, apiKey, effectiveBaseURL);
+    }
+    setProviderAndKey(providerId, apiKey, baseURL) {
+        this.providerId = providerId;
+        setProviderHint(this.providerId);
+        this.setApiKey(apiKey, baseURL);
+    }
+    getProviderId() {
+        return this.providerId;
+    }
+    getCwd() {
+        return this.bash.getCwd();
+    }
+    setCwd(dir) {
+        this.bash.setCwd(dir);
+        this._pendingCwdNote = `(system: working directory has been changed to ${dir} — subsequent shell commands run from there; do NOT cd to that path again)`;
+    }
+    getMessages() {
+        return this.messages;
+    }
+    async listSchedules() {
+        return this.schedules.list();
+    }
+    async removeSchedule(id) {
+        const removed = await this.schedules.remove(id);
+        return removed ? `Removed schedule "${removed.name}".` : `Schedule "${id}" not found.`;
+    }
+    async getScheduleDaemonStatus() {
+        return this.schedules.getDaemonStatus();
+    }
+    getContextStats(contextWindow, inFlightText = "") {
+        const system = buildSystemPrompt(this.bash.getCwd(), this.mode, this.bash.getSandboxMode(), this.planContext, undefined, this.bash.getSandboxSettings(), this.providerId);
+        const usedTokens = Math.min(contextWindow, estimateConversationTokens(system, this.messages, inFlightText));
+        const remainingTokens = Math.max(0, contextWindow - usedTokens);
+        return {
+            contextWindow,
+            usedTokens,
+            remainingTokens,
+            ratioUsed: usedTokens / contextWindow,
+            ratioRemaining: remainingTokens / contextWindow,
+        };
+    }
+    async generateTitle(userMessage) {
+        const provider = this.provider;
+        if (!provider) {
+            return "New session";
+        }
+        const generated = await genTitle(provider, userMessage);
+        this.recordUsage(generated.usage, "title", generated.modelId);
+        if (this.sessionStore && this.session && !this.session.title && generated.title) {
+            this.sessionStore.setTitle(this.session.id, generated.title);
+            this.session = this.sessionStore.getRequiredSession(this.session.id);
+        }
+        return generated.title;
+    }
+    async askSideQuestion(question, signal) {
+        if (!this.provider) {
+            return { response: "No API key configured." };
+        }
+        const contextParts = [];
+        let charBudget = 2000;
+        for (let i = this.messages.length - 1; i >= 0 && charBudget > 0; i--) {
+            const msg = this.messages[i];
+            if (msg.role !== "user" && msg.role !== "assistant")
+                continue;
+            const text = typeof msg.content === "string"
+                ? msg.content
+                : Array.isArray(msg.content)
+                    ? msg.content
+                        .filter((p) => p.type === "text")
+                        .map((p) => p.text ?? "")
+                        .join("")
+                    : "";
+            if (!text)
+                continue;
+            const snippet = text.length > 400 ? `${text.slice(0, 400)}…` : text;
+            contextParts.unshift(`[${msg.role}]: ${snippet}`);
+            charBudget -= snippet.length;
+        }
+        const conversationContext = contextParts.join("\n\n");
+        const result = await runSideQuestion(question, this.provider, this.modelId, conversationContext, signal);
+        this.recordUsage(result.usage, "other");
+        return result;
+    }
+    abort() {
+        this.abortController?.abort();
+        this.emitSubagentStatus(null);
+    }
+    async cleanup() {
+        await Promise.allSettled([
+            this.bash.cleanup(),
+            shutdownWorkspaceLspManager(this.bash.getCwd()),
+            extractSession(this.messages, this.bash.getCwd(), "cli-exit", this.getSessionId()),
+        ]);
+    }
+    respondToToolApproval(approvalId, approved) {
+        const toolApprovalResponse = {
+            role: "tool",
+            content: [
+                {
+                    type: "tool-approval-response",
+                    approvalId,
+                    approved,
+                },
+            ],
+        };
+        this.messages.push(toolApprovalResponse);
+        this.messageSeqs.push(null);
+    }
+    async clearHistory() {
+        // D-09: Extract messages accumulated since last clear BEFORE reset
+        await extractSession(this.messages, this.bash.getCwd(), "cli-clear", this.getSessionId()).catch(() => { }); // D-05: redundant safety — extractSession already swallows
+        this.startNewSession();
+    }
+    startNewSession() {
+        if (this.sessionStartHookFired) {
+            const endInput = {
+                hook_event_name: "SessionEnd",
+                session_id: this.session?.id,
+                cwd: this.bash.getCwd(),
+            };
+            this.fireHook(endInput).catch(() => { });
+            this.sessionStartHookFired = false;
+        }
+        // Reset token counters, cost, and compaction state for the new session
+        statusBarStore.setState({
+            in_tokens: 0,
+            out_tokens: 0,
+            cache_read_tokens: 0,
+            cache_creation_tokens: 0,
+            session_usd: 0,
+            ctx_tokens: 0,
+            compaction_summary: undefined,
+        });
+        this._compactionStats = { count: 0, totalSaved: 0 };
+        this._pinnedSeqs.clear();
+        if (!this.sessionStore) {
+            this.messages = [];
+            this.messageSeqs = [];
+            return null;
+        }
+        this.sessionStore = new SessionStore(this.bash.getCwd());
+        this.workspace = this.sessionStore.getWorkspace();
+        this.session = this.sessionStore.createSession(this.modelId, this.mode, this.bash.getCwd());
+        this.messages = [];
+        this.messageSeqs = [];
+        return this.getSessionSnapshot();
+    }
+    getSessionInfo() {
+        return this.session;
+    }
+    getSessionId() {
+        return this.session?.id || null;
+    }
+    getSessionTitle() {
+        return this.session?.title || null;
+    }
+    getCompactionStats() {
+        return { ...this._compactionStats };
+    }
+    /**
+     * Pin a user message by its sequence number. Pinned messages survive
+     * compaction verbatim — re-injected as a system note after the summary.
+     * Returns true if the message was found, is a user message, and got pinned.
+     */
+    pinMessageBySeq(seq) {
+        const idx = this.messageSeqs.indexOf(seq);
+        if (idx < 0)
+            return false;
+        if (this.messages[idx]?.role !== "user")
+            return false;
+        this._pinnedSeqs.add(seq);
+        return true;
+    }
+    /** Pin the most recent user message in the live conversation. Returns its seq, or null. */
+    pinLastUserMessage() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            if (this.messages[i]?.role !== "user")
+                continue;
+            const seq = this.messageSeqs[i];
+            if (typeof seq === "number") {
+                this._pinnedSeqs.add(seq);
+                return seq;
+            }
+        }
+        return null;
+    }
+    unpinMessageBySeq(seq) {
+        return this._pinnedSeqs.delete(seq);
+    }
+    getPinnedSeqs() {
+        return [...this._pinnedSeqs].sort((a, b) => a - b);
+    }
+    getChatEntries() {
+        if (!this.session)
+            return [];
+        return buildChatEntries(this.session.id);
+    }
+    getSessionSnapshot() {
+        if (!this.session || !this.workspace)
+            return null;
+        return {
+            workspace: this.workspace,
+            session: this.session,
+            messages: loadTranscript(this.session.id),
+            entries: buildChatEntries(this.session.id),
+            totalTokens: getSessionTotalTokens(this.session.id),
+        };
+    }
+    onSubagentStatus(listener) {
+        this.subagentStatusListeners.add(listener);
+        return () => {
+            this.subagentStatusListeners.delete(listener);
+        };
+    }
+    emitSubagentStatus(status) {
+        for (const listener of this.subagentStatusListeners) {
+            listener(status);
+        }
+    }
+    discardAbortedTurn(userMessage) {
+        const idx = this.messages.lastIndexOf(userMessage);
+        if (idx >= 0) {
+            // Keep the user message but add a stub assistant response so the
+            // conversation remains valid for follow-up messages after ESC.
+            const alreadyHasResponse = idx < this.messages.length - 1 && this.messages[idx + 1]?.role === "assistant";
+            if (!alreadyHasResponse) {
+                this.messages.splice(idx + 1, 0, { role: "assistant", content: "[Interrupted]" });
+                this.messageSeqs.splice(idx + 1, 0, null);
+            }
+        }
+    }
+    recordUsage(usage, source = "message", model = this.modelId) {
+        if (!usage)
+            return;
+        if (this.session) {
+            const pilActive = source === "message" ? this._pilActive : false;
+            const enrichmentDelta = source === "message" ? this._pilEnrichmentDelta : 0;
+            // Attribute usage to the most recent persisted message — this lets
+            // per-prompt cost analysis work (was null hardcoded → impossible).
+            const lastSeq = lastPersistedSeq(this.messageSeqs);
+            // Phase O1 — providerOptions shape (types only, no values) attached
+            // to every usage event so post-mortem can answer "what provider
+            // options did this billed call carry?". Cleared below for "message"
+            // sources so non-message calls don't reuse stale data.
+            const providerOptionsShape = this._lastProviderOptionsShape;
+            recordUsageEvent(this.session.id, source, model, usage, lastSeq, pilActive, enrichmentDelta, providerOptionsShape);
+            if (source === "message") {
+                this._pilActive = false;
+                this._pilEnrichmentDelta = 0;
+                this._lastProviderOptionsShape = null;
+            }
+        }
+        // Phase D — surfaced for harness E2E verification. Mirror the recorded usage
+        // event onto the agent-mode sidechannel so spec processes can assert on
+        // cacheReadTokens / cacheCreationTokens normalization without poking at the
+        // child's sqlite. Best-effort, only fires when agent-mode runtime is set.
+        try {
+            const rt = globalThis.__muonroiAgentRuntime;
+            if (rt?.emitEvent) {
+                const lastSeqForEvent = this.session ? lastPersistedSeq(this.messageSeqs) : null;
+                rt.emitEvent({
+                    t: "event",
+                    kind: "usage",
+                    source,
+                    model,
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    cacheReadTokens: usage.cacheReadTokens,
+                    cacheCreationTokens: usage.cacheCreationTokens,
+                    messageSeq: lastSeqForEvent,
+                });
+            }
+        }
+        catch {
+            // best-effort: do not let sidechannel failures interrupt usage recording
+        }
+        // Update status bar token counters + provider/model + cache metrics + cost
+        const prev = statusBarStore.getState();
+        const info = getModelInfo(model);
+        const totalInput = usage.inputTokens ?? 0;
+        const cacheRead = usage.cacheReadTokens ?? 0;
+        const cacheCreate = usage.cacheCreationTokens ?? 0;
+        const output = usage.outputTokens ?? 0;
+        const priceIn = info?.inputPrice ?? 0;
+        const priceCached = info?.cachedInputPrice ?? priceIn * 0.1;
+        const priceOut = info?.outputPrice ?? 0;
+        // API inputTokens includes cacheRead — subtract to get non-cached portion
+        const nonCachedInput = Math.max(0, totalInput - cacheRead - cacheCreate);
+        const turnCostMicros = nonCachedInput * priceIn + cacheRead * priceCached + cacheCreate * priceIn + output * priceOut;
+        statusBarStore.setState({
+            in_tokens: prev.in_tokens + totalInput,
+            out_tokens: prev.out_tokens + output,
+            cache_read_tokens: (prev.cache_read_tokens ?? 0) + cacheRead,
+            cache_creation_tokens: (prev.cache_creation_tokens ?? 0) + cacheCreate,
+            session_usd: prev.session_usd + turnCostMicros / 1_000_000,
+            provider: this.providerId,
+            model,
+        });
+        // Append to cost-log JSONL so `usage report --by callsite` can surface
+        // where orchestrator/task/title traffic is actually spending.
+        // Best-effort: failures inside appendCostLog are swallowed (see cost-log.ts).
+        const breakdown = source === "message" ? (this._lastPromptBreakdown ?? undefined) : undefined;
+        appendCostLog({
+            ts: Date.now(),
+            provider: this.providerId,
+            model,
+            estimatedUsd: turnCostMicros / 1_000_000,
+            callsite: `orchestrator.${source}`,
+            phase: source,
+            actualInputTokens: totalInput,
+            actualOutputTokens: output,
+            cachedInputTokens: cacheRead,
+            systemChars: breakdown?.systemChars,
+            promptChars: breakdown?.messagesChars,
+            breakdown,
+        }).catch(() => undefined);
+        // Don't clear breakdown — onStepFinish fires recordUsage per step within
+        // the same streamText call, and they all share the same prompt structure.
+        // It is overwritten on the next streamText setup, which is the right scope.
+    }
+    async consumeBackgroundNotifications() {
+        try {
+            const notifications = await this.delegations.consumeNotifications();
+            for (const notification of notifications) {
+                this.messages.push({ role: "system", content: notification.message });
+                let seq = null;
+                if (this.session) {
+                    seq = appendSystemMessage(this.session.id, notification.message);
+                }
+                this.messageSeqs.push(seq);
+                const notifInput = {
+                    hook_event_name: "Notification",
+                    message: notification.message,
+                    session_id: this.session?.id,
+                    cwd: this.bash.getCwd(),
+                };
+                this.fireHook(notifInput).catch(() => { });
+            }
+            return notifications.map((notification) => notification.message);
+        }
+        catch {
+            return [];
+        }
+    }
+    getBatchClientOptions(signal) {
+        if (!this.apiKey) {
+            throw new Error("API key required. Add an API key to continue.");
+        }
+        return {
+            apiKey: this.apiKey,
+            baseURL: this.baseURL ?? undefined,
+            signal,
+        };
+    }
+    async executeBatchToolCall(tools, toolCall, messages, signal) {
+        const tool = tools[toolCall.function.name];
+        if (!tool || tool.type === "provider" || typeof tool.execute !== "function") {
+            return {
+                input: parseToolArgumentsOrRaw(toolCall.function.arguments),
+                result: {
+                    success: false,
+                    output: `Tool "${toolCall.function.name}" is unavailable in batch mode.`,
+                },
+            };
+        }
+        let parsedInput;
+        try {
+            parsedInput = toolCall.function.arguments.trim() ? JSON.parse(toolCall.function.arguments) : {};
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                input: toolCall.function.arguments,
+                result: {
+                    success: false,
+                    output: `Tool "${toolCall.function.name}" received invalid JSON arguments: ${message}`,
+                },
+            };
+        }
+        try {
+            const output = await tool.execute(parsedInput, {
+                toolCallId: toolCall.id,
+                messages,
+                abortSignal: signal,
+            });
+            return {
+                input: parsedInput,
+                result: toToolResult(output),
+            };
+        }
+        catch (error) {
+            if (signal?.aborted) {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                input: parsedInput,
+                result: {
+                    success: false,
+                    output: `Tool "${toolCall.function.name}" failed: ${message}`,
+                },
+            };
+        }
+    }
+    async runTaskRequestBatch(args) {
+        const { request, childMessages, childSystem, childRuntime, childTools, maxSteps, initialDetail, onActivity, signal, } = args;
+        const childCaps = getProviderCapabilities(childRuntime.modelInfo?.provider ?? "anthropic");
+        if (childCaps.usesResponsesAPI(childRuntime.modelInfo)) {
+            throw new Error("Batch mode currently supports chat-completions models only.");
+        }
+        const batchTools = !childCaps.supportsClientTools(childRuntime.modelInfo)
+            ? []
+            : await toolSetToBatchTools(childTools);
+        const batch = await createBatch({
+            ...this.getBatchClientOptions(signal),
+            name: buildBatchName(`task-${request.agent}`, request.description),
+        });
+        const turnMessages = [];
+        const totalUsage = {};
+        let assistantText = "";
+        let lastActivity = initialDetail;
+        for (let round = 0; round < maxSteps; round++) {
+            const batchRequestId = `task-${Date.now()}-${round + 1}`;
+            await addBatchRequests({
+                ...this.getBatchClientOptions(signal),
+                batchId: batch.batch_id,
+                batchRequests: [
+                    {
+                        batch_request_id: batchRequestId,
+                        batch_request: {
+                            chat_get_completion: buildBatchChatCompletionRequest({
+                                modelId: childRuntime.modelId,
+                                system: childSystem,
+                                messages: [...childMessages, ...turnMessages],
+                                temperature: request.agent === "explore" ? 0.2 : 0.5,
+                                maxOutputTokens: !childCaps.acceptsParam("maxOutputTokens", childRuntime.modelInfo)
+                                    ? undefined
+                                    : Math.min(this.maxTokens, 8_192),
+                                reasoningEffort: childRuntime.providerOptions?.xai.reasoningEffort,
+                                tools: batchTools,
+                            }),
+                        },
+                    },
+                ],
+            });
+            const result = await pollBatchRequestResult({
+                ...this.getBatchClientOptions(signal),
+                batchId: batch.batch_id,
+                batchRequestId,
+            });
+            const response = getBatchChatCompletion(result);
+            accumulateUsage(totalUsage, getBatchUsage(response));
+            const choice = response.choices[0];
+            if (!choice) {
+                throw new Error("Batch response did not contain any choices.");
+            }
+            const content = choice?.message.content ?? "";
+            if (content) {
+                assistantText += content;
+            }
+            const requestMessages = [...childMessages, ...turnMessages];
+            const toolCalls = (choice?.message.tool_calls ?? []).map(toLocalToolCall);
+            const assistantMessage = buildAssistantBatchMessage(content, toolCalls);
+            if (assistantMessage) {
+                turnMessages.push(assistantMessage);
+            }
+            if (toolCalls.length === 0) {
+                if (hasUsage(totalUsage)) {
+                    this.recordUsage(totalUsage, "task", childRuntime.modelId);
+                }
+                const output = assistantText.trim() || `Task completed. Last action: ${lastActivity}`;
+                return {
+                    success: true,
+                    output,
+                    task: {
+                        agent: request.agent,
+                        description: request.description,
+                        summary: firstLine(output),
+                        activity: lastActivity,
+                    },
+                };
+            }
+            const toolParts = [];
+            for (const toolCall of toolCalls) {
+                const nextActivity = formatSubagentActivity(toolCall.function.name, parseToolArgumentsOrRaw(toolCall.function.arguments));
+                lastActivity = nextActivity;
+                onActivity?.(nextActivity);
+                const executed = await this.executeBatchToolCall(childTools, toolCall, requestMessages, signal);
+                toolParts.push({
+                    toolCall,
+                    input: executed.input,
+                    toolResult: executed.result,
+                });
+            }
+            const toolMessage = buildToolBatchMessage(toolParts);
+            if (toolMessage) {
+                turnMessages.push(toolMessage);
+            }
+        }
+        if (hasUsage(totalUsage)) {
+            this.recordUsage(totalUsage, "task", childRuntime.modelId);
+        }
+        const output = assistantText.trim() || `Task stopped after ${maxSteps} batch rounds. Last action: ${lastActivity}`;
+        return {
+            success: false,
+            output,
+            task: {
+                agent: request.agent,
+                description: request.description,
+                summary: output,
+                activity: lastActivity,
+            },
+        };
+    }
+    /**
+     * Run a sub-agent task by spawning a child `streamText` session.
+     *
+     * Phase 12.3 — body extracted to `StreamRunner` (`./stream-runner.ts`).
+     * This method now builds the DI dep set and delegates to
+     * `StreamRunner.run()`. Public signature is unchanged so all callers
+     * (`runTask`, `tools/registry`, batch path, council path) work as before.
+     */
+    async runTaskRequest(request, onActivity, abortSignal) {
+        const provider = this.requireProvider();
+        const deps = {
+            getProvider: () => provider,
+            resolveModelForTask: (task) => this._resolveModelForTask(task),
+            getModelId: () => this.modelId,
+            getProviderId: () => this.providerId,
+            getBash: () => this.bash,
+            getMaxToolRounds: () => this.maxToolRounds,
+            getMaxTokens: () => this.maxTokens,
+            isBatchApiEnabled: () => this.batchApi,
+            getCrossTurnDedup: () => this._crossTurnDedup,
+            getReadBudget: () => this._readBudget,
+            recordUsage: (usage, source, model) => this.recordUsage(usage, source, model),
+            setCurrentCallId: (id) => {
+                this._currentCallId = id;
+            },
+            setLastProviderOptionsShape: (shape) => {
+                this._lastProviderOptionsShape = shape;
+            },
+            runTaskRequestBatch: (args) => this.runTaskRequestBatch(args),
+        };
+        const runner = new StreamRunner(deps);
+        return runner.run(request, onActivity, abortSignal);
+    }
+    async runTask(request, abortSignal) {
+        const startInput = {
+            hook_event_name: "SubagentStart",
+            agent_type: request.agent,
+            description: request.description,
+            session_id: this.session?.id,
+            cwd: this.bash.getCwd(),
+        };
+        await this.fireHook(startInput, abortSignal).catch(() => { });
+        let result;
+        try {
+            result = await withStreamRetry(() => this.runTaskRequest(request, (detail) => {
+                if (abortSignal?.aborted)
+                    return;
+                this.emitSubagentStatus({
+                    agent: request.agent,
+                    description: request.description,
+                    detail,
+                });
+            }, abortSignal), {
+                signal: abortSignal,
+                onRetry: (info) => {
+                    // Emit harness telemetry
+                    try {
+                        const _ar = globalThis.__muonroiAgentRuntime;
+                        _ar?.emitEvent({
+                            t: "event",
+                            kind: "stream-retry",
+                            ...info,
+                        });
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                    try {
+                        if (this.session) {
+                            logInteraction(this.session.id, "stream_retry", {
+                                data: {
+                                    attempt: info.attempt,
+                                    maxAttempts: info.maxAttempts,
+                                    errorName: info.errorName,
+                                    errorMessage: info.errorMessage.slice(0, 200),
+                                    nextDelayMs: info.nextDelayMs,
+                                },
+                            });
+                        }
+                    }
+                    catch {
+                        /* fail-open */
+                    }
+                },
+            });
+        }
+        finally {
+            this.emitSubagentStatus(null);
+        }
+        const stopInput = {
+            hook_event_name: "SubagentStop",
+            agent_type: request.agent,
+            description: request.description,
+            success: result.success,
+            session_id: this.session?.id,
+            cwd: this.bash.getCwd(),
+        };
+        await this.fireHook(stopInput, abortSignal).catch(() => { });
+        return result;
+    }
+    async runDelegation(request, abortSignal) {
+        const taskCreatedInput = {
+            hook_event_name: "TaskCreated",
+            agent_type: request.agent,
+            description: request.description,
+            session_id: this.session?.id,
+            cwd: this.bash.getCwd(),
+        };
+        await this.fireHook(taskCreatedInput, abortSignal).catch(() => { });
+        let result;
+        try {
+            if (abortSignal?.aborted) {
+                return { success: false, output: "[Cancelled]" };
+            }
+            result = await this.delegations.start(request, {
+                model: this.modelId,
+                sandboxMode: this.bash.getSandboxMode(),
+                sandboxSettings: this.bash.getSandboxSettings(),
+                maxToolRounds: this.maxToolRounds,
+                maxTokens: this.maxTokens,
+                batchApi: this.batchApi,
+            });
+        }
+        catch (err) {
+            if (abortSignal?.aborted)
+                throw err;
+            const msg = err instanceof Error ? err.message : String(err);
+            result = {
+                success: false,
+                output: `Delegation failed: ${msg}`,
+            };
+        }
+        const taskCompletedInput = {
+            hook_event_name: "TaskCompleted",
+            agent_type: request.agent,
+            description: request.description,
+            success: result.success,
+            session_id: this.session?.id,
+            cwd: this.bash.getCwd(),
+        };
+        await this.fireHook(taskCompletedInput, abortSignal).catch(() => { });
+        return result;
+    }
+    async readDelegation(id) {
+        try {
+            return {
+                success: true,
+                output: await this.delegations.read(id),
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Failed to read delegation: ${msg}`,
+            };
+        }
+    }
+    async listDelegations() {
+        try {
+            const delegations = await this.delegations.list();
+            if (delegations.length === 0) {
+                return {
+                    success: true,
+                    output: "No delegations found for this project.",
+                };
+            }
+            const lines = delegations.map((delegation) => {
+                const title = delegation.description || delegation.id;
+                return `- \`${delegation.id}\` [${delegation.status}] ${title}\n  ${delegation.summary}`;
+            });
+            return {
+                success: true,
+                output: `## Delegations\n\n${lines.join("\n")}`,
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Failed to list delegations: ${msg}`,
+            };
+        }
+    }
+    getCompactionSettings(contextWindow) {
+        let keepRecentTokens = DEFAULT_KEEP_RECENT_TOKENS;
+        // For models with very large context windows, keep more recent tokens
+        if (contextWindow && contextWindow > 200_000) {
+            keepRecentTokens = Math.min(100_000, Math.max(20_000, Math.floor(contextWindow * 0.1)));
+        }
+        // Compact more aggressively for long sessions to prevent runaway token growth
+        if (this._compactionStats.count >= 2) {
+            keepRecentTokens = Math.floor(keepRecentTokens * 0.75);
+        }
+        return {
+            reserveTokens: Math.max(this.maxTokens, DEFAULT_RESERVE_TOKENS),
+            keepRecentTokens,
+        };
+    }
+    _resolveCompactModel() {
+        return this._resolveModelForTask("compact");
+    }
+    _resolveModelForTask(task) {
+        const tierPrefs = {
+            compact: ["fast", "balanced"],
+            title: ["fast", "balanced"],
+            explore: ["balanced", "fast"],
+            general: ["premium", "balanced"],
+        };
+        for (const tier of tierPrefs[task] ?? ["balanced"]) {
+            const m = getModelByTier(tier, this.providerId);
+            if (m?.provider === this.providerId)
+                return m.id;
+        }
+        return this.modelId;
+    }
+    async compactForContext(provider, system, contextWindow, signal, settings = this.getCompactionSettings(contextWindow), force = false) {
+        if (!this.session)
+            return false;
+        const preparation = prepareCompaction(this.messages, system, settings);
+        if (!preparation)
+            return false;
+        if (!force && !shouldCompactContext(preparation.tokensBefore, contextWindow, settings)) {
+            return false;
+        }
+        const trigger = force ? "manual" : "auto";
+        // Fire-and-forget: notify EE of stale suggestions before compaction
+        const { surfacedIds, timestamp } = getLastSurfacedState();
+        if (surfacedIds.length > 0) {
+            getDefaultEEClient()
+                .promptStale({
+                state: { surfacedIds, timestamp },
+                nextPromptMeta: { trigger: "auto-compact", cwd: this.bash.getCwd(), tenantId: getTenantId() },
+            })
+                .catch(() => { });
+        }
+        const preCompactInput = {
+            hook_event_name: "PreCompact",
+            trigger,
+            session_id: this.session?.id,
+            cwd: this.bash.getCwd(),
+        };
+        await this.fireHook(preCompactInput, signal).catch(() => { });
+        const keptSeqs = this.messageSeqs.slice(preparation.firstKeptIndex);
+        const firstKeptSeq = keptSeqs.find((seq) => seq !== null) ?? getNextMessageSequence(this.session.id);
+        const compactModelId = this._resolveCompactModel();
+        const compactStartedAt = Date.now();
+        const { summary, usage: compactUsage } = await generateCompactionSummary(provider, compactModelId, preparation, undefined, signal);
+        // Record compaction call in cost-log — bypasses recordUsage because
+        // compaction returns usage separately and isn't routed through the
+        // status-bar / usage event pipeline (intentional: it's overhead, not user spend).
+        const compactProvider = detectProviderForModel(compactModelId);
+        appendCostLog({
+            ts: compactStartedAt,
+            provider: compactProvider,
+            model: compactModelId,
+            estimatedUsd: projectCostUSD(compactProvider, compactModelId, compactUsage.promptTokens, compactUsage.completionTokens),
+            callsite: "orchestrator.compaction",
+            phase: "compaction",
+            iteration: this._compactionStats.count + 1,
+            actualInputTokens: compactUsage.promptTokens,
+            actualOutputTokens: compactUsage.completionTokens,
+            durationMs: Date.now() - compactStartedAt,
+        }).catch(() => undefined);
+        appendCompaction(this.session.id, firstKeptSeq, summary, preparation.tokensBefore);
+        // Re-inject pinned user messages that were about to be summarized away.
+        // Pinned seqs that are still inside keptMessages don't need re-injection.
+        const keptSeqSet = new Set(keptSeqs.filter((s) => s !== null));
+        const pinnedReinjections = [];
+        const pinnedReinjectionSeqs = [];
+        for (const seq of [...this._pinnedSeqs].sort((a, b) => a - b)) {
+            if (keptSeqSet.has(seq))
+                continue;
+            const idx = this.messageSeqs.indexOf(seq);
+            if (idx < 0) {
+                // Pinned seq no longer present (shouldn't happen, but stay defensive).
+                this._pinnedSeqs.delete(seq);
+                continue;
+            }
+            const original = this.messages[idx];
+            if (!original || original.role !== "user")
+                continue;
+            const text = extractUserContent(original.content).trim();
+            if (!text)
+                continue;
+            pinnedReinjections.push({
+                role: "system",
+                content: `[Pinned user message — kept verbatim across compaction]\n${text}`,
+            });
+            pinnedReinjectionSeqs.push(null);
+        }
+        this.messages = [createCompactionSummaryMessage(summary), ...pinnedReinjections, ...preparation.keptMessages];
+        this.messageSeqs = [null, ...pinnedReinjectionSeqs, ...keptSeqs];
+        // Track compaction stats — net of the tokens spent ON compaction itself.
+        const tokensAfter = estimateConversationTokens(system, this.messages);
+        const grossSaved = Math.max(0, preparation.tokensBefore - tokensAfter);
+        const compactCost = compactUsage.promptTokens + compactUsage.completionTokens;
+        const saved = Math.max(0, grossSaved - compactCost);
+        const pct = preparation.tokensBefore > 0 ? ((saved / preparation.tokensBefore) * 100).toFixed(1) : "0.0";
+        this._compactionStats.count++;
+        this._compactionStats.totalSaved += saved;
+        // Update status bar with current context size and compaction summary
+        const fmtCompact = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}K` : String(n));
+        const modelSuffix = compactModelId !== this.modelId ? ` via ${compactModelId}` : "";
+        const userMsgCount = this.messages.filter((m) => m.role === "user").length;
+        const isLongSession = this._compactionStats.count >= 3 || userMsgCount >= 200;
+        const sessionHint = isLongSession ? " ⚠ long session — consider /clear" : "";
+        const compactLabel = `${this._compactionStats.count} cmp, ${fmtCompact(this._compactionStats.totalSaved)} saved${modelSuffix}${sessionHint}`;
+        statusBarStore.setState({ ctx_tokens: tokensAfter, compaction_summary: compactLabel });
+        const postCompactInput = {
+            hook_event_name: "PostCompact",
+            trigger,
+            session_id: this.session?.id,
+            cwd: this.bash.getCwd(),
+        };
+        await this.fireHook(postCompactInput, signal).catch(() => { });
+        // Interaction log: compaction
+        try {
+            if (this.session) {
+                logInteraction(this.session.id, "compaction", {
+                    data: {
+                        count: this._compactionStats.count,
+                        tokensBefore: preparation.tokensBefore,
+                        tokensAfter,
+                        saved,
+                        grossSaved,
+                        compactCost,
+                        pct,
+                        isLongSession,
+                    },
+                });
+            }
+        }
+        catch {
+            /* fail-open */
+        }
+        this._compactedThisTurn = true;
+        return true;
+    }
+    async postTurnCompact(provider, system, contextWindow, signal) {
+        const log = (taken, reason, extra) => {
+            appendDecisionLog({
+                ts: Date.now(),
+                sessionId: this.session?.id ?? null,
+                kind: "post-turn-compact",
+                taken,
+                reason,
+                meta: { contextWindow, ...extra },
+            }).catch(() => undefined);
+        };
+        if (this._compactedThisTurn)
+            return log(false, "already-compacted-this-turn");
+        if (!isAutoCompactAfterTurnEnabled())
+            return log(false, "feature-disabled");
+        const tokens = estimateConversationTokens(system, this.messages);
+        const thresholdPct = getAutoCompactThresholdPct();
+        const minMeaningfulTokens = Math.max(POST_TURN_MIN_TOKENS, Math.floor(contextWindow * thresholdPct));
+        if (tokens < minMeaningfulTokens) {
+            return log(false, `under-threshold (${tokens} < ${minMeaningfulTokens})`, {
+                tokens,
+                thresholdPct,
+                minMeaningfulTokens,
+            });
+        }
+        log(true, `over-threshold (${tokens} >= ${minMeaningfulTokens})`, { tokens, thresholdPct, minMeaningfulTokens });
+        await this.compactForContext(provider, system, contextWindow, signal, this.getCompactionSettings(contextWindow), true).catch((err) => console.warn("[compact] failed:", err?.message));
+    }
+    // ========================================================================
+    // Council system — delegated to CouncilManager (Phase 12.1-02)
+    //
+    // All council state + sub-call helpers (generate/research/prompt builders/
+    // outcome parser/executor/candidate resolution) live in CouncilManager.
+    // The thin facade below preserves the public API the UI + tests rely on
+    // (respondToCouncilQuestion/Preflight + the internal _create*Responder
+    // hooks used by orchestrator.agent.test.ts).
+    // ========================================================================
+    respondToCouncilQuestion(questionId, answer) {
+        this.councilManager.respondToQuestion(questionId, answer);
+    }
+    respondToCouncilPreflight(preflightId, approved) {
+        this.councilManager.respondToPreflight(preflightId, approved);
+    }
+    // Internal hooks used by orchestrator.agent.test.ts to exercise buffered
+    // question / preflight delivery through CouncilManager. They are reached
+    // through `as unknown as` casts in the test; keep them private but stable.
+    _createQuestionResponder() {
+        return this.councilManager.createQuestionResponder();
+    }
+    _createPreflightResponder() {
+        return this.councilManager.createPreflightResponder();
+    }
+    // ========================================================================
+    // Council v2 — Clarify → Confirm → Debate → Plan → Execute
+    // ========================================================================
+    async *runCouncilV2(topic, options) {
+        const { runCouncil } = await import("../council/index.js");
+        const { createCouncilLLM } = await import("../council/llm.js");
+        const councilStats = { calls: 0, startMs: Date.now(), phases: [] };
+        const llm = createCouncilLLM(this.bash, this.mode, this.session?.id, councilStats);
+        const processMessageFn = (message) => this.processMessage(message, options?.observer);
+        const gen = runCouncil(topic, this.modelId, this.messages, this.session?.id, llm, this.councilManager.createQuestionResponder(), this.councilManager.createPreflightResponder(), processMessageFn, {
+            skipClarification: options?.skipClarification,
+            userModelMessage: options?.userModelMessage,
+            cwd: this.bash.getCwd(),
+            councilStats, // NEW — share orchestrator's stats object with runCouncil (Phase 14 CQ-01)
+        });
+        let result;
+        do {
+            result = await gen.next();
+            if (!result.done && result.value) {
+                yield result.value;
+            }
+        } while (!result.done);
+        const synthesis = result.value;
+        this.councilManager.setLastSynthesis(synthesis);
+        if (options?.userModelMessage && synthesis) {
+            this.appendCompletedTurn(options.userModelMessage, [{ role: "assistant", content: synthesis }]);
+        }
+    }
+    // ========================================================================
+    // Product Ideal Loop (Phase 13) — mirror of runCouncilV2 wiring.
+    // ========================================================================
+    async *runProductLoopV1(payload, options) {
+        const { runProductLoop } = await import("../product-loop/index.js");
+        const { createCouncilLLM } = await import("../council/llm.js");
+        const nodePath = await import("node:path");
+        const productStats = {
+            calls: 0,
+            startMs: Date.now(),
+            phases: [],
+        };
+        const llm = createCouncilLLM(this.bash, this.mode, this.session?.id, productStats);
+        const processMessageFn = (m) => this.processMessage(m, options?.observer);
+        const flowDir = nodePath.join(this.bash.getCwd(), ".muonroi-flow");
+        // P2.7: compute complexity from the idea using PIL Layer 1 heuristics (cheap,
+        // no LLM calls). Only meaningful for "start"; other subcommands ignore it.
+        let complexity;
+        let sufficiencyMissing;
+        if (payload.subcommand === "start" && payload.idea) {
+            const { scoreComplexity, scoreSufficiency } = await import("../pil/layer1-intent.js");
+            const result = scoreComplexity({
+                rawText: payload.idea,
+                taskType: null,
+                t0HitCount: 0,
+                hasMaxSprintsOne: payload.flags.maxSprints === 1,
+            });
+            complexity = result.complexity;
+            // Sufficiency gate — vague briefs ("todo app") force Council so the
+            // discovery AskCard can fill in persona/MVP/architecture/verify before
+            // any code is scaffolded.
+            const suff = scoreSufficiency({ rawText: payload.idea });
+            sufficiencyMissing = suff.sufficient ? undefined : suff.missing;
+        }
+        const gen = runProductLoop({
+            subcommand: payload.subcommand,
+            idea: payload.idea ?? "",
+            runId: payload.runId,
+            flowDir,
+            sessionModelId: this.modelId,
+            llm,
+            flags: {
+                maxCost: payload.flags.maxCost,
+                maxSprints: payload.flags.maxSprints,
+                doneThreshold: payload.flags.doneThreshold,
+                stack: payload.flags.stack,
+                forceCouncil: payload.flags.forceCouncil,
+            },
+            respondToQuestion: this.councilManager.createQuestionResponder(),
+            respondToPreflight: this.councilManager.createPreflightResponder(),
+            cwd: this.bash.getCwd(),
+            processMessageFn,
+            skipPriorContext: payload.flags.noPriorContext === true,
+            complexity,
+            sufficiencyMissing,
+            // Chat session id — used as the FK key for interaction_logs telemetry.
+            // The /ideal runId is NOT a sessions.id and would silently fail FK insert.
+            sessionId: this.session?.id,
+        });
+        for await (const chunk of gen) {
+            yield chunk;
+        }
+    }
+    // ========================================================================
+    // Legacy council — kept for backward compatibility, will be removed
+    // ========================================================================
+    async *runCouncilRound(topic, _observer, rounds, userModelMessage) {
+        const maxRounds = rounds ?? getCouncilRounds();
+        const ALL_ROLES = ["implement", "verify", "research"];
+        this.councilManager.resetStats(Date.now());
+        // Resolve council participants: same-provider by default, multi-provider only when configured
+        const candidates = [];
+        const configuredRoleModels = getRoleModels();
+        const hasExplicitMultiProvider = this.councilManager.hasMultiProviderConfig(configuredRoleModels);
+        if (hasExplicitMultiProvider && isCouncilMultiProviderPreferred()) {
+            // Multi-provider path: use explicitly configured role models across providers
+            for (const role of ALL_ROLES) {
+                const modelId = getRoleModel(role);
+                if (!modelId)
+                    continue;
+                const provider = detectProviderForModel(modelId);
+                if (isProviderDisabled(provider))
+                    continue;
+                const canReach = await loadKeyForProvider(provider)
+                    .then(() => true)
+                    .catch(() => false);
+                if (canReach)
+                    candidates.push({ role, model: modelId });
+            }
+            if (candidates.length >= 2) {
+                const providers = new Set(candidates.map((c) => detectProviderForModel(c.model)));
+                yield {
+                    type: "content",
+                    content: `\n[Multi-provider mode: ${candidates.length} roles across ${providers.size} provider(s)]\n`,
+                };
+            }
+        }
+        // Default: same-provider mode — pick diverse models from the session's provider
+        if (candidates.length < 2) {
+            const mainProviderId = detectProviderForModel(this.modelId);
+            // Skip same-provider resolution if the session's provider is disabled
+            if (!isProviderDisabled(mainProviderId)) {
+                const sameCandidates = await this.councilManager.resolveSameProviderCandidates(mainProviderId, ALL_ROLES);
+                if (sameCandidates.length >= 2) {
+                    candidates.length = 0;
+                    candidates.push(...sameCandidates);
+                    const uniqueModels = new Set(sameCandidates.map((c) => c.model));
+                    yield {
+                        type: "content",
+                        content: `\n[Same-provider mode: ${uniqueModels.size} ${mainProviderId} model(s) for ${sameCandidates.length} roles]\n`,
+                    };
+                }
+            }
+        }
+        // Final fallback: use main model for all roles
+        if (candidates.length < 2) {
+            const mainProviderId = detectProviderForModel(this.modelId);
+            const mainDisabled = isProviderDisabled(mainProviderId);
+            const mainCanReach = !mainDisabled &&
+                (await loadKeyForProvider(mainProviderId)
+                    .then(() => true)
+                    .catch(() => false));
+            if (mainCanReach) {
+                candidates.length = 0;
+                for (const role of ALL_ROLES) {
+                    candidates.push({ role, model: this.modelId });
+                }
+                yield {
+                    type: "content",
+                    content: `\n[Fallback: using \x1b[36m${this.modelId}\x1b[0m for all roles]\n`,
+                };
+            }
+        }
+        if (candidates.length < 2) {
+            yield {
+                type: "content",
+                content: "\nNo reachable provider. Check API keys in user-settings.json or environment.\n",
+            };
+            yield { type: "done" };
+            return;
+        }
+        // Build conversation context for all participants
+        const conversationContext = this.councilManager.buildContext();
+        // ── Phase 0: Research — gather facts from codebase before discussion ──
+        const p0Start = Date.now();
+        yield { type: "content", content: `\n## Phase 0 — Codebase Research\n` };
+        // Find the research candidate (prefer configured research role, fallback to first available)
+        const researchCandidate = candidates.find((c) => c.role === "research") ?? candidates[0];
+        yield { type: "content", content: `\n### \x1b[35m[research]\x1b[0m ${researchCandidate.model}\n` };
+        const researchFindings = await this.councilManager.research(researchCandidate.model, topic, conversationContext);
+        yield { type: "content", content: `${researchFindings}\n` };
+        yield { type: "content", content: `\n> Phase 0: ${((Date.now() - p0Start) / 1000).toFixed(1)}s\n` };
+        // Inject research findings into conversation context for subsequent phases
+        const enrichedContext = conversationContext
+            ? `${conversationContext}\n\n---\n\n## Research Findings (Phase 0)\n${researchFindings}`
+            : `## Research Findings (Phase 0)\n${researchFindings}`;
+        // ── Phase 1: Parallel opening statements ──
+        const p1Start = Date.now();
+        yield { type: "content", content: "\n## Phase 1 — Opening Analysis\n" };
+        const openingPromises = candidates.map(({ role, model }) => {
+            const { system, prompt } = this.councilManager.buildDiscussPrompt("open", {
+                speakerRole: role,
+                partnerRole: candidates.find((c) => c.role !== role)?.role ?? "colleague",
+                topic,
+                conversationContext: enrichedContext,
+            });
+            return this.councilManager
+                .generate(model, system, prompt)
+                .then((text) => ({ role, model, position: text, error: null }))
+                .catch((err) => ({
+                role,
+                model,
+                position: "",
+                error: err instanceof Error ? err.message : String(err),
+            }));
+        });
+        const openings = await Promise.all(openingPromises);
+        const active = [];
+        for (const o of openings) {
+            const roleColor = COUNCIL_ROLE_COLORS[o.role] ?? "";
+            yield { type: "content", content: `\n### ${roleColor}[${o.role}]${COUNCIL_COLOR_RESET} ${o.model}\n` };
+            if (o.error) {
+                yield { type: "content", content: `[Error: ${o.error}]\n` };
+            }
+            else {
+                active.push({ role: o.role, model: o.model, position: o.position });
+                const bgColor = COUNCIL_COLOR_BG[o.role] ?? "";
+                yield { type: "content", content: `${bgColor} ${o.role.toUpperCase()} ${COUNCIL_COLOR_RESET} ${o.position}\n` };
+            }
+        }
+        yield {
+            type: "content",
+            content: `\n> Phase 1: ${active.length} participants, ${((Date.now() - p1Start) / 1000).toFixed(1)}s (parallel)\n`,
+        };
+        if (active.length < 2) {
+            yield { type: "content", content: "\nNot enough successful openings for discussion.\n" };
+            yield { type: "done" };
+            return;
+        }
+        // ── Phase 2: Discussion rounds with parallel pair debates ──
+        const exchangeLogs = new Map();
+        const pairConverged = new Map();
+        let runningSummary = "";
+        for (let round = 1; round <= maxRounds; round++) {
+            const p2Start = Date.now();
+            yield { type: "content", content: `\n## Phase 2 — Discussion Round ${round}/${maxRounds}\n` };
+            // Build independent pairs
+            const pairs = [];
+            for (let i = 0; i < active.length; i++) {
+                const a = active[i];
+                const b = active[(i + 1) % active.length];
+                const key = `${a.role}<>${b.role}`;
+                if (pairConverged.get(key))
+                    continue;
+                if (!exchangeLogs.has(key))
+                    exchangeLogs.set(key, []);
+                pairs.push({ a, b, key });
+            }
+            if (pairs.length === 0)
+                break;
+            // Run pair debates in parallel
+            const pairResults = await Promise.all(pairs.map(async ({ a, b, key }) => {
+                const log = exchangeLogs.get(key);
+                const chunks = [];
+                try {
+                    let aResponse;
+                    let bResponse;
+                    if (round === 1) {
+                        const aPrompt = this.councilManager.buildDiscussPrompt("respond", {
+                            speakerRole: a.role,
+                            partnerRole: b.role,
+                            topic,
+                            speakerPosition: a.position,
+                            partnerPosition: b.position,
+                            conversationContext: enrichedContext,
+                        });
+                        aResponse = await this.councilManager.generate(a.model, aPrompt.system, aPrompt.prompt);
+                        log.push(`[${a.role}]: ${aResponse}`);
+                        chunks.push({ label: `[${a.role}] → [${b.role}]`, text: aResponse });
+                        const bPrompt = this.councilManager.buildDiscussPrompt("respond", {
+                            speakerRole: b.role,
+                            partnerRole: a.role,
+                            topic,
+                            speakerPosition: b.position,
+                            partnerPosition: aResponse,
+                            conversationContext: enrichedContext,
+                        });
+                        bResponse = await this.councilManager.generate(b.model, bPrompt.system, bPrompt.prompt);
+                        log.push(`[${b.role}]: ${bResponse}`);
+                        chunks.push({ label: `[${b.role}] → [${a.role}]`, text: bResponse });
+                    }
+                    else {
+                        const historyText = log.join("\n\n");
+                        const aPrompt = this.councilManager.buildDiscussPrompt("followup", {
+                            speakerRole: a.role,
+                            partnerRole: b.role,
+                            topic,
+                            partnerPosition: b.position,
+                            exchangeHistory: historyText,
+                            round,
+                            conversationContext: enrichedContext,
+                            runningSummary,
+                        });
+                        aResponse = await this.councilManager.generate(a.model, aPrompt.system, aPrompt.prompt, 1024);
+                        log.push(`[${a.role}] (round ${round}): ${aResponse}`);
+                        chunks.push({ label: `[${a.role}] → [${b.role}]`, text: aResponse });
+                        const bPrompt = this.councilManager.buildDiscussPrompt("followup", {
+                            speakerRole: b.role,
+                            partnerRole: a.role,
+                            topic,
+                            partnerPosition: aResponse,
+                            exchangeHistory: historyText,
+                            round,
+                            conversationContext: enrichedContext,
+                            runningSummary,
+                        });
+                        bResponse = await this.councilManager.generate(b.model, bPrompt.system, bPrompt.prompt, 1024);
+                        log.push(`[${b.role}] (round ${round}): ${bResponse}`);
+                        chunks.push({ label: `[${b.role}] → [${a.role}]`, text: bResponse });
+                    }
+                    b.position = bResponse;
+                    a.position = aResponse;
+                    // Convergence check
+                    const convPrompt = this.councilManager.buildDiscussPrompt("convergence-check", {
+                        speakerRole: a.role,
+                        partnerRole: b.role,
+                        topic,
+                        exchangeHistory: log.slice(-4).join("\n\n"),
+                        conversationContext: enrichedContext,
+                    });
+                    let converged = false;
+                    let convReason = "";
+                    try {
+                        const raw = await this.councilManager.generate(a.model, convPrompt.system, convPrompt.prompt, 256);
+                        const match = raw.match(/\{[\s\S]*\}/);
+                        if (match) {
+                            const parsed = JSON.parse(match[0]);
+                            converged = parsed.converged === true;
+                            convReason = parsed.reason ?? "";
+                        }
+                    }
+                    catch {
+                        /* not converged */
+                    }
+                    return { key, chunks, converged, convReason, error: null };
+                }
+                catch (err) {
+                    return {
+                        key,
+                        chunks,
+                        converged: false,
+                        convReason: "",
+                        error: err instanceof Error ? err.message : String(err),
+                    };
+                }
+            }));
+            // Emit results (sequential yield — maintains readable order)
+            let allConverged = true;
+            for (const pr of pairResults) {
+                for (const chunk of pr.chunks) {
+                    const labelParts = chunk.label.match(/\[(\w+)\] → \[(\w+)\]/);
+                    let coloredLabel = chunk.label;
+                    if (labelParts) {
+                        const fromColor = COUNCIL_ROLE_COLORS[labelParts[1]] ?? "";
+                        const toColor = COUNCIL_ROLE_COLORS[labelParts[2]] ?? "";
+                        coloredLabel = `${fromColor}[${labelParts[1]}]${COUNCIL_COLOR_RESET} → ${toColor}[${labelParts[2]}]${COUNCIL_COLOR_RESET}`;
+                    }
+                    yield { type: "content", content: `\n### ${coloredLabel}\n${chunk.text}\n` };
+                }
+                if (pr.error) {
+                    yield { type: "content", content: `[Discussion error: ${pr.error}]\n` };
+                    allConverged = false;
+                }
+                else if (pr.converged) {
+                    pairConverged.set(pr.key, true);
+                    yield { type: "content", content: `\n> ✓ ${pr.key.replace("<>", " ↔ ")} converged: ${pr.convReason}\n` };
+                }
+                else {
+                    allConverged = false;
+                }
+            }
+            yield {
+                type: "content",
+                content: `\n> Round ${round}: ${((Date.now() - p2Start) / 1000).toFixed(1)}s (${pairs.length} pairs parallel)\n`,
+            };
+            if (allConverged) {
+                yield { type: "content", content: `\n> All pairs converged at round ${round}. Moving to synthesis.\n` };
+                break;
+            }
+            // Generate inter-round summary for next round's focus
+            if (round < maxRounds) {
+                try {
+                    runningSummary = await this.councilManager.generateRoundSummary(exchangeLogs, topic, round, active[0].model);
+                    yield {
+                        type: "content",
+                        content: `\n> **Discussion state:** ${runningSummary
+                            .split("\n")
+                            .filter((l) => l.trim())
+                            .slice(0, 3)
+                            .join(" | ")}\n`,
+                    };
+                }
+                catch {
+                    // Non-critical — continue without summary
+                }
+            }
+        }
+        // ── Phase 3: Leader synthesis ──
+        const p3Start = Date.now();
+        yield { type: "content", content: "\n## Phase 3 — Leader Synthesis\n" };
+        const leaderModelId = getRoleModel("leader") ?? this.modelId;
+        yield { type: "content", content: `\n### \x1b[32m[leader]\x1b[0m ${leaderModelId}\n` };
+        const allExchanges = [...exchangeLogs.entries()]
+            .map(([pair, log]) => `### Discussion: ${pair}\n${log.join("\n\n")}`)
+            .join("\n\n---\n\n");
+        const finalPositions = active.map((p) => `**${p.role}** (${p.model}): ${p.position.slice(0, 500)}...`).join("\n\n");
+        let synthesisText = "";
+        try {
+            synthesisText = await this.councilManager.generate(leaderModelId, "You are the team lead. Multiple specialists just had a structured discussion about a topic.\n\n" +
+                "Output TWO parts separated by the exact line `---READABLE---`:\n\n" +
+                "**Part 1: JSON** — a single JSON object:\n" +
+                "```\n" +
+                '{ "type": "decision"|"action_items"|"plan_update"|"resolve_question",\n' +
+                '  "summary": "1-2 sentence executive summary",\n' +
+                '  "agreed": ["point 1", "point 2"],\n' +
+                '  "tradeoffs": ["trade-off 1"],\n' +
+                '  "recommendation": "Your decisive recommendation",\n' +
+                '  "actionItems": ["step 1", "step 2"],\n' +
+                '  "planUpdate": "paragraph for plan update (only if type=plan_update)",\n' +
+                '  "resolvedQuestion": {"question": "...", "answer": "..."} }\n' +
+                "```\n" +
+                "Choose type: decision (general), action_items (concrete steps), plan_update (modify active plan), resolve_question (answer a specific question).\n\n" +
+                "**Part 2: Human-readable** — after `---READABLE---`, write the synthesis in markdown:\n" +
+                "## AGREED\n## TRADE-OFFS\n## RECOMMENDATION\n## NEXT STEPS\n\n" +
+                "Be decisive. Output Part 1 JSON first, then ---READABLE---, then Part 2.", `Topic: ${topic}\n\nFinal positions:\n${finalPositions}\n\nFull discussion:\n${allExchanges}`, 4096);
+            // Display human-readable part
+            const readablePart = synthesisText.includes("---READABLE---")
+                ? synthesisText.split("---READABLE---")[1]?.trim()
+                : synthesisText;
+            yield { type: "content", content: `${readablePart || synthesisText}\n` };
+            // Parse structured outcome and execute actions
+            const structuredOutcome = this.councilManager.parseOutcome(synthesisText, topic);
+            if (structuredOutcome) {
+                yield* this.councilManager.executeOutcome(structuredOutcome, topic);
+                if (this.session) {
+                    try {
+                        appendSystemMessage(this.session.id, `[Council Outcome]\n${JSON.stringify(structuredOutcome)}`);
+                    }
+                    catch {
+                        /* non-critical */
+                    }
+                }
+            }
+            else {
+                // Fallback: store text-only outcome (backward compatible)
+                if (this.session) {
+                    try {
+                        appendSystemMessage(this.session.id, `[Council Outcome]\nTopic: ${topic}\n${synthesisText.slice(0, 2000)}`);
+                    }
+                    catch {
+                        /* non-critical */
+                    }
+                }
+            }
+        }
+        catch (err) {
+            yield { type: "content", content: `[Synthesis error: ${err instanceof Error ? err.message : err}]\n` };
+        }
+        // ── Stats + Memory ──
+        const councilStats = this.councilManager.stats;
+        const totalMs = Date.now() - councilStats.startMs;
+        yield {
+            type: "content",
+            content: `\n---\n` +
+                `> Council stats: ${councilStats.calls} API calls, ${(totalMs / 1000).toFixed(1)}s total, ` +
+                `${active.length} participants, synthesis ${((Date.now() - p3Start) / 1000).toFixed(1)}s\n`,
+        };
+        // Save council result to session for memory across conversations
+        if (this.session && this.sessionStore) {
+            const councilRecord = {
+                topic,
+                participants: active.map((a) => ({ role: a.role, model: a.model })),
+                finalPositions: active.map((a) => ({ role: a.role, position: a.position.slice(0, 1000) })),
+                synthesis: synthesisText.slice(0, 2000),
+                convergedPairs: [...pairConverged.entries()].filter(([, v]) => v).map(([k]) => k),
+                stats: { calls: councilStats.calls, durationMs: totalMs },
+                timestamp: new Date().toISOString(),
+            };
+            try {
+                appendSystemMessage(this.session.id, `[Council Memory] ${JSON.stringify(councilRecord)}`);
+            }
+            catch {
+                /* non-critical */
+            }
+        }
+        // Store council output as assistant message so the conversation history
+        // stays valid (user→assistant alternation required by most APIs).
+        const councilResponse = synthesisText || "[Council completed — see discussion above]";
+        if (userModelMessage) {
+            this.appendCompletedTurn(userModelMessage, [{ role: "assistant", content: councilResponse }]);
+        }
+        this.councilManager.setLastSynthesis(councilResponse);
+        yield { type: "done" };
+    }
+    // ========================================================================
+    // processMessageBatchTurn — batch API message processing loop.
+    // Body extracted into BatchTurnRunner (Phase 12.5). Thin wrapper preserved
+    // so MessageProcessorDeps' `processMessageBatchTurn` callback continues to
+    // dispatch through `Agent.processMessageBatchTurn` unchanged.
+    // ========================================================================
+    async *processMessageBatchTurn(args) {
+        const runner = new BatchTurnRunner(this._buildBatchTurnRunnerDeps());
+        yield* runner.run(args);
+    }
+    /**
+     * Build the DI surface BatchTurnRunner (Phase 12.5) needs to reach back
+     * into Agent state without holding a circular reference. Callback names
+     * align with `MessageProcessorDeps` where the signature matches so a
+     * future `TurnRunnerDepsBase` hoist is mechanical. Built per call —
+     * allocation cost is negligible against the batch polling spend.
+     */
+    _buildBatchTurnRunnerDeps() {
+        const self = this;
+        return {
+            get messages() {
+                return self.messages;
+            },
+            get bash() {
+                return self.bash;
+            },
+            get mode() {
+                return self.mode;
+            },
+            get maxToolRounds() {
+                return self.maxToolRounds;
+            },
+            get maxTokens() {
+                return self.maxTokens;
+            },
+            get schedules() {
+                return self.schedules;
+            },
+            get sendTelegramFile() {
+                return self.sendTelegramFile;
+            },
+            getSessionId: () => self.session?.id ?? null,
+            getCompactedThisTurn: () => self._compactedThisTurn,
+            setCompactedThisTurn: (v) => {
+                self._compactedThisTurn = v;
+            },
+            setLastProviderOptionsShape: (shape) => {
+                self._lastProviderOptionsShape = shape;
+            },
+            getBatchClientOptions: (signal) => self.getBatchClientOptions(signal),
+            getCompactionSettings: (cw) => self.getCompactionSettings(cw),
+            compactForContext: (provider, system, cw, signal, settings, overflow) => self.compactForContext(provider, system, cw, signal, settings, overflow),
+            postTurnCompact: (provider, system, cw, signal) => self.postTurnCompact(provider, system, cw, signal),
+            createTools: (bash, provider, mode, opts) => createTools(bash, provider, mode, opts),
+            runTask: (request, signal) => self.runTask(request, signal),
+            runDelegation: (request, signal) => self.runDelegation(request, signal),
+            readDelegation: (id) => self.readDelegation(id),
+            listDelegations: () => self.listDelegations(),
+            executeBatchToolCall: (tools, toolCall, messages, signal) => self.executeBatchToolCall(tools, toolCall, messages, signal),
+            appendCompletedTurn: (user, asst) => self.appendCompletedTurn(user, asst),
+            discardAbortedTurn: (user) => self.discardAbortedTurn(user),
+            recordUsage: (usage, source, model) => self.recordUsage(usage, source, model),
+        };
+    }
+    appendCompletedTurn(userMessage, newMessages) {
+        if (newMessages.length === 0)
+            return;
+        const userIndex = this.messages.lastIndexOf(userMessage);
+        if (!this.sessionStore || !this.session) {
+            if (userIndex >= 0 && this.messageSeqs[userIndex] == null) {
+                this.messageSeqs[userIndex] = null;
+            }
+            this.messages.push(...newMessages);
+            this.messageSeqs.push(...newMessages.map(() => null));
+            return;
+        }
+        // Phase A5 — if the user message already has a persisted seq (set by
+        // the write-ahead path), skip re-inserting it. The write-ahead row
+        // will be upserted to status='completed' on the next `appendMessages`
+        // call that sees it via ON CONFLICT, but here we only need to insert
+        // the *new* assistant/tool messages so they get fresh sequence
+        // numbers contiguous with the user row.
+        const existingUserSeq = userIndex >= 0 ? this.messageSeqs[userIndex] : null;
+        if (typeof existingUserSeq === "number") {
+            // User row is already persisted (write-ahead). Insert only the new
+            // assistant/tool messages so they get fresh sequence numbers
+            // contiguous with the user row. Then flip the user row's status
+            // from 'pending' to 'completed' so forensics + replay tooling can
+            // tell the turn settled cleanly.
+            const insertedSeqs = appendMessages(this.session.id, newMessages);
+            markMessageCompleted(this.session.id, existingUserSeq);
+            this.messages.push(...newMessages);
+            this.messageSeqs.push(...insertedSeqs);
+            this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
+            this.session = this.sessionStore.getRequiredSession(this.session.id);
+            return;
+        }
+        const insertedSeqs = appendMessages(this.session.id, [userMessage, ...newMessages]);
+        if (userIndex >= 0) {
+            this.messageSeqs[userIndex] = insertedSeqs[0] ?? this.messageSeqs[userIndex];
+        }
+        this.messages.push(...newMessages);
+        this.messageSeqs.push(...insertedSeqs.slice(1));
+        this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
+        this.session = this.sessionStore.getRequiredSession(this.session.id);
+    }
+    fireHook(input, signal) {
+        return executeEventHooks(input, this.bash.getCwd(), signal);
+    }
+    // ========================================================================
+    // processMessage — main streaming turn loop (PIL enrichment, routing, LLM
+    // stream, tool execution, compaction, hooks, observer notifications)
+    // ========================================================================
+    async *processMessage(userMessage, observer, images) {
+        const processor = new MessageProcessor(this._buildMessageProcessorDeps());
+        yield* processor.run(userMessage, observer, images);
+    }
+    /**
+     * Build the DI surface MessageProcessor (Phase 12.4) needs to reach back
+     * into Agent state without holding a circular reference. Exposes array
+     * references for in-place mutation (messages/messageSeqs) and bound
+     * callbacks for behavior. Built per call — allocation cost is negligible
+     * against the streamText spend.
+     */
+    _buildMessageProcessorDeps() {
+        const self = this;
+        return {
+            get messages() {
+                return self.messages;
+            },
+            get messageSeqs() {
+                return self.messageSeqs;
+            },
+            get session() {
+                return self.session;
+            },
+            get sessionStore() {
+                return self.sessionStore;
+            },
+            get bash() {
+                return self.bash;
+            },
+            get mode() {
+                return self.mode;
+            },
+            get modelId() {
+                return self.modelId;
+            },
+            get providerId() {
+                return self.providerId;
+            },
+            get maxToolRounds() {
+                return self.maxToolRounds;
+            },
+            get batchApi() {
+                return self.batchApi;
+            },
+            get permissionMode() {
+                return self.permissionMode;
+            },
+            get schedules() {
+                return self.schedules;
+            },
+            get sendTelegramFile() {
+                return self.sendTelegramFile;
+            },
+            get externalAbortContext() {
+                return self.externalAbortContext;
+            },
+            get pendingCalls() {
+                return self.pendingCalls;
+            },
+            get councilManager() {
+                return self.councilManager;
+            },
+            get crossTurnDedup() {
+                return self._crossTurnDedup;
+            },
+            get readBudget() {
+                return self._readBudget;
+            },
+            get priorWarningIdsInSession() {
+                return self._priorWarningIdsInSession;
+            },
+            get sessionEEGuidance() {
+                return self._sessionEEGuidance;
+            },
+            get flowReady() {
+                return self._flowReady;
+            },
+            getAbortController: () => self.abortController,
+            setAbortController: (c) => {
+                self.abortController = c;
+            },
+            getSessionStartHookFired: () => self.sessionStartHookFired,
+            setSessionStartHookFired: (v) => {
+                self.sessionStartHookFired = v;
+            },
+            getPlanContext: () => self.planContext,
+            setPlanContext: (v) => {
+                self.planContext = v;
+            },
+            getResumeDigest: () => self._resumeDigest,
+            setResumeDigest: (v) => {
+                self._resumeDigest = v;
+            },
+            getActiveRunId: () => self._activeRunId,
+            getPendingCwdNote: () => self._pendingCwdNote,
+            setPendingCwdNote: (v) => {
+                self._pendingCwdNote = v;
+            },
+            setPilActive: (v) => {
+                self._pilActive = v;
+            },
+            setPilEnrichmentDelta: (n) => {
+                self._pilEnrichmentDelta = n;
+            },
+            setCurrentCallId: (id) => {
+                self._currentCallId = id;
+            },
+            setLastProviderOptionsShape: (shape) => {
+                self._lastProviderOptionsShape = shape;
+            },
+            setLastPromptBreakdown: (b) => {
+                self._lastPromptBreakdown = b;
+            },
+            setCompactedThisTurn: (v) => {
+                self._compactedThisTurn = v;
+            },
+            getCompactedThisTurn: () => self._compactedThisTurn,
+            setTurnUserGoalExcerpt: (v) => {
+                self._turnUserGoalExcerpt = v;
+            },
+            setTurnAssistantReasoning: (v) => {
+                self._turnAssistantReasoning = v;
+            },
+            appendTurnAssistantReasoning: (delta) => {
+                self._turnAssistantReasoning = (self._turnAssistantReasoning + delta).slice(-400);
+            },
+            getTurnAssistantReasoning: () => self._turnAssistantReasoning,
+            setPriorWarningIdsInSession: (s) => {
+                self._priorWarningIdsInSession = s;
+            },
+            setMessages: (m) => {
+                self.messages = m;
+            },
+            requireProvider: () => self.requireProvider(),
+            emitSubagentStatus: (s) => self.emitSubagentStatus(s),
+            fireHook: (input, signal) => self.fireHook(input, signal),
+            consumeBackgroundNotifications: () => self.consumeBackgroundNotifications(),
+            initOAuthProvider: () => self._initOAuthProvider(),
+            buildRecentTurnsSummary: () => self._buildRecentTurnsSummary(),
+            estimateProjectSize: () => self._estimateProjectSize(),
+            countFilesTouched: () => self._countFilesTouched(),
+            getCompactionSettings: (cw) => self.getCompactionSettings(cw),
+            compactForContext: (provider, system, cw, signal, settings, overflow) => self.compactForContext(provider, system, cw, signal, settings, overflow),
+            postTurnCompact: (provider, system, cw, signal) => self.postTurnCompact(provider, system, cw, signal),
+            runTask: (request, signal) => self.runTask(request, signal),
+            runDelegation: (request, signal) => self.runDelegation(request, signal),
+            readDelegation: (id) => self.readDelegation(id),
+            listDelegations: () => self.listDelegations(),
+            appendCompletedTurn: (user, asst) => self.appendCompletedTurn(user, asst),
+            discardAbortedTurn: (user) => self.discardAbortedTurn(user),
+            recordUsage: (usage, source, model) => self.recordUsage(usage, source, model),
+            respondToToolApproval: (id, ok) => self.respondToToolApproval(id, ok),
+            runCouncilV2: (msg, opts) => self.runCouncilV2(msg, opts),
+            processMessage: (msg, obs, imgs) => self.processMessage(msg, obs, imgs),
+            processMessageBatchTurn: (args) => self.processMessageBatchTurn(args),
+        };
+    }
+    // ========================================================================
+    // processMessage body extracted into MessageProcessor (Phase 12.4).
+    // The single original implementation now lives in
+    // `src/orchestrator/message-processor.ts`. The thin wrapper above is the
+    // only entry point.
+    // ========================================================================
+    // ========================================================================
+    // Private helper methods — summary, estimation, verify
+    // ========================================================================
+    _buildRecentTurnsSummary() {
+        if (this.messages.length < 2)
+            return null;
+        const recent = this.messages.slice(-6);
+        const parts = [];
+        for (const msg of recent) {
+            if (msg.role !== "user" && msg.role !== "assistant")
+                continue;
+            const text = typeof msg.content === "string"
+                ? msg.content
+                : Array.isArray(msg.content)
+                    ? msg.content
+                        .filter((p) => p.type === "text")
+                        .map((p) => p.text ?? "")
+                        .join("")
+                    : "";
+            if (!text)
+                continue;
+            const snippet = text.length > 80 ? `${text.slice(0, 77)}...` : text;
+            parts.push(`[${msg.role}]: ${snippet}`);
+        }
+        return parts.length > 0 ? parts.join(" | ") : null;
+    }
+    _estimateProjectSize() {
+        try {
+            const fs = require("fs");
+            const path = require("path");
+            const cwd = this.bash.getCwd();
+            const srcDir = path.join(cwd, "src");
+            if (!fs.existsSync(srcDir))
+                return null;
+            let count = 0;
+            const walk = (dir) => {
+                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                    if (entry.name === "node_modules" || entry.name === ".git")
+                        continue;
+                    if (entry.isDirectory())
+                        walk(path.join(dir, entry.name));
+                    else if (/\.(ts|tsx|js|jsx|py|go|rs)$/.test(entry.name))
+                        count++;
+                    if (count > 200)
+                        return;
+                }
+            };
+            walk(srcDir);
+            if (count <= 20)
+                return "small";
+            if (count <= 100)
+                return "medium";
+            return "large";
+        }
+        catch {
+            return null;
+        }
+    }
+    _countFilesTouched() {
+        let count = 0;
+        for (const msg of this.messages) {
+            if (msg.role !== "assistant" || !Array.isArray(msg.content))
+                continue;
+            for (const part of msg.content) {
+                if (part.type === "tool-call") {
+                    const tc = part;
+                    if (tc.toolName === "write_file" || tc.toolName === "edit_file" || tc.toolName === "bash")
+                        count++;
+                }
+            }
+        }
+        return count;
+    }
+    requireProvider() {
+        if (!this.provider) {
+            throw new Error("API key required. Add an API key to continue.");
+        }
+        return this.provider;
+    }
+    /**
+     * One-shot async init: upgrades the OpenAI provider to use OAuth tokens when
+     * stored tokens are available and no explicit API key was supplied by the user.
+     * Called at the start of processMessage so the first real LLM call benefits
+     * from OAuth without requiring a sync constructor change.
+     *
+     * Idempotent: skips on second call and for non-OpenAI providers.
+     * Fail-open: any error leaves the existing provider untouched.
+     */
+    async _initOAuthProvider() {
+        if (this._oauthInitDone)
+            return;
+        this._oauthInitDone = true;
+        // Only upgrade when there is no explicit API key — OAuth is an alternative
+        // auth path, not an override when the user deliberately passed a key.
+        // The boot wizard in src/index.ts uses the literal "oauth" as a sentinel
+        // to signal "no API key but OAuth tokens exist", so treat that as "no
+        // key" here.
+        if (this.apiKey && this.apiKey !== "oauth")
+            return;
+        try {
+            const { listOAuthProviderIds } = await import("../providers/auth/registry.js");
+            const ids = await listOAuthProviderIds();
+            if (!ids.includes(this.providerId))
+                return;
+            const effectiveBaseURL = this.baseURL &&
+                this.baseURL !== (await import("../providers/endpoints.js").then((m) => m.apiBaseFor("anthropic")))
+                ? this.baseURL
+                : undefined;
+            const result = await createProviderFactoryAsync(this.providerId, {
+                baseURL: effectiveBaseURL ?? undefined,
+            });
+            this.provider = result.factory;
+        }
+        catch {
+            // Fail-open — provider remains null; requireProvider() will surface the error
+        }
+    }
+    async detectVerifyRecipe(settings, abortSignal) {
+        try {
+            const result = await this.runTaskRequest({
+                agent: "verify-detect",
+                description: "Detect verification recipe",
+                prompt: buildVerifyDetectPrompt(this.bash.getCwd(), settings ?? this.bash.getSandboxSettings()),
+            }, undefined, abortSignal);
+            if (!result.success || !result.output)
+                return null;
+            const maybeJson = extractJsonObject(result.output);
+            if (!maybeJson)
+                return null;
+            return normalizeVerifyRecipe(JSON.parse(maybeJson));
+        }
+        catch {
+            return null;
+        }
+    }
+    async runVerify(onProgress, abortSignal) {
+        this.abortController = new AbortController();
+        const signal = abortSignal ?? this.abortController.signal;
+        const userModelMessage = { role: "user", content: "/verify" };
+        this.messages.push(userModelMessage);
+        this.messageSeqs.push(null);
+        try {
+            await this.consumeBackgroundNotifications();
+            const result = await runVerifyOrchestration(this, { onProgress, abortSignal: signal });
+            const assistantText = result.output || result.error || "Verification completed.";
+            this.appendCompletedTurn(userModelMessage, [{ role: "assistant", content: assistantText }]);
+            return result;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const failureText = signal.aborted ? "Verification aborted." : `Verification failed: ${msg}`;
+            this.appendCompletedTurn(userModelMessage, [{ role: "assistant", content: failureText }]);
+            return { success: false, output: failureText };
+        }
+        finally {
+            if (this.abortController?.signal === signal) {
+                this.abortController = null;
+            }
+        }
+    }
+}
+//# sourceMappingURL=orchestrator.js.map