muonroi-cli 1.8.4 → 1.8.5

package/dist/src/orchestrator/orchestrator.js

@@ -5,6 +5,7 @@ import { getTenantId } from "../ee/tenant.js";
 import { emitTranscriptToDisk } from "../ee/transcript-emit.js";
 import { createRun, getActiveRunId, setActiveRunId } from "../flow/run-manager.js";
 import { ensureFlowDir } from "../flow/scaffold.js";
+import { isContextRailEnabled } from "../gsd/flags.js";
 import { executeEventHooks } from "../hooks/index.js";
 import { shutdownWorkspaceLspManager } from "../lsp/runtime.js";
 import { ensureDefaultMcpServers } from "../mcp/auto-setup.js";
@@ -12,27 +13,27 @@ import { 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, requireRuntimeProvider, resolveModelRuntime as resolveRuntime, } from "../providers/runtime.js";
+import { createProviderFactory, createProviderFactoryAsync, detectProviderForModel, requireRuntimeProvider, resolveModelRuntime as resolveRuntime, resolveTemperatureParam, } from "../providers/runtime.js";
 import { ALL_PROVIDER_IDS } from "../providers/types.js";
-import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, logInteraction, markMessageCompleted, recordUsageEvent, SessionStore, } from "../storage/index.js";
+import { statusBarStore } from "../state/status-bar-store.js";
+import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionChainInfos, getSessionTotalTokens, loadSessionChainTranscriptState, logInteraction, markMessageCompleted, persistApprovedPlan, 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 { snapshotFromTodoWriteArgs } from "../tools/todo-write-snapshot.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, sanitizeInputTokens } from "../usage/estimator.js";
 import { logger } from "../utils/logger.js";
-import { getAutoCompactThresholdPct, getCouncilRounds, getCurrentModel, getCurrentShellSettings, getModeSpecificModel, getRoleModel, getRoleModels, isAutoCompactAfterTurnEnabled, isCouncilMultiProviderPreferred, isProviderDisabled, loadUserSettings, } from "../utils/settings.js";
+import { getAutoCompactMinNewTokens, getAutoCompactThresholdPct, getCouncilRounds, getCurrentModel, getCurrentShellSettings, getModeSpecificModel, getRoleModel, getRoleModels, getSubAgentCompactKeepLast, getSubAgentCompactThresholdChars, isAutoCompactAfterTurnEnabled, isCouncilMultiProviderPreferred, isProviderDisabled, loadUserSettings, } from "../utils/settings.js";
 import { runSideQuestion } from "../utils/side-question.js";
-import { buildVerifyDetectPrompt, normalizeVerifyRecipe } from "../verify/entrypoint.js";
+import { buildVerifyDetectPrompt, inferVerifyProjectProfile, normalizeVerifyRecipe, shouldTrustDeterministicRecipe, } 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 { AUTO_COMMIT_ATTRIBUTION, isAutoCommitEnabled, maybeAutoCommitTurn, snapshotDirtyPaths, } from "./auto-commit.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, proposeCompaction, shouldCompactContext, } from "./compaction.js";
+import { createCompactionSummaryMessage, DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS, estimateConversationTokens, extractUserContent, generateCompactionSummary, isCompactionSummaryMessage, isCompactionThrash, POST_TURN_MIN_TOKENS, prepareCompaction, proposeCompaction, shouldCompactContext, } from "./compaction.js";
 import { CouncilManager } from "./council-manager.js";
 import { CrossTurnDedup, isCrossTurnDedupEnabled } from "./cross-turn-dedup.js";
 import { DelegationManager } from "./delegations.js";
@@ -40,11 +41,14 @@ import { loadFlowResumeDigest } from "./flow-resume.js";
 import { MessageProcessor } from "./message-processor.js";
 import { lastPersistedSeq } from "./message-seq.js";
 import { buildSystemPrompt, HARD_MAX_TOOL_ROUNDS, MAX_TOOL_ROUNDS } from "./prompts.js";
+import { getReactiveDelegationThresholdChars, shouldReactivelyEscalate } from "./reactive-delegation.js";
 import { getReadPathBudgetCap, ReadPathBudget } from "./read-path-budget.js";
 import { withStreamRetry } from "./retry-stream.js";
 import { StreamRunner } from "./stream-runner.js";
 import { resolveModelForTask } from "./sub-agent-model-tier.js";
+import { compactSubAgentMessages } from "./subagent-compactor.js";
 import { setProviderHint } from "./token-counter.js";
+import { getToolLimitAutoRecoverCap } from "./tool-limit-auto-recover.js";
 import { firstLine, formatSubagentActivity, toToolResult } from "./tool-utils.js";
 // ---------------------------------------------------------------------------
 // Provider implementations
@@ -69,15 +73,65 @@ function isAnyProviderApiBase(url) {
     }
     return false;
 }
+const TITLE_SYSTEM_PROMPT = `You are a session-naming assistant. Given the first message a user sent to an AI coding assistant, produce a short session title.
+
+Rules:
+- 5-7 words that capture the essence of the request (the goal, not the phrasing).
+- Same language as the user's message (English request → English title, Vietnamese → Vietnamese, etc.).
+- Title Case for languages that use it; natural casing otherwise.
+- No surrounding quotes, no trailing punctuation, no emoji, no markdown.
+- Output ONLY the title text — nothing else.`;
+/** Deterministic fallback title: truncated first user message, or "" when the
+ *  message is empty or a JSON-ish payload (so the caller leaves title = NULL
+ *  and the picker renders a clean "(untitled)" instead of a literal "{}"). */
+export function fallbackTitle(userMessage) {
+    const trimmed = userMessage.trim();
+    if (!trimmed)
+        return "";
+    // JSON object/array payloads (programmatic first messages) make useless titles.
+    if (/^[{[]/.test(trimmed) && /[}\]]$/.test(trimmed))
+        return "";
+    return trimmed.slice(0, 60).trim();
+}
+/** Strip quotes/backticks, collapse whitespace, drop trailing punctuation, cap at ~60 chars. */
+function sanitizeTitle(raw) {
+    let t = raw.trim().split("\n")[0]?.trim() ?? "";
+    t = t.replace(/^["'`“”‘’]+|["'`“”‘’]+$/g, "");
+    t = t
+        .replace(/\s+/g, " ")
+        .replace(/[.,:;!?…]+$/g, "")
+        .trim();
+    if (t.length > 60)
+        t = t.slice(0, 60).trim();
+    return t;
+}
 /**
- * Generate a session title using the Anthropic provider.
- * Kept as a lightweight stub for Phase 0 — title generation ships in Phase 1.
+ * Generate a session title with a single lightweight LLM call on the current
+ * session model. Falls back to a truncated first-message title on any failure.
  */
-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: getCurrentModel() });
+async function genTitle(provider, userMessage, modelId) {
+    try {
+        const { generateText } = await import("ai");
+        const runtime = resolveModelRuntime(provider, modelId);
+        const snippet = userMessage.length > 1500 ? `${userMessage.slice(0, 1500)}…` : userMessage;
+        const { text, usage } = await generateText({
+            model: runtime.model,
+            system: TITLE_SYSTEM_PROMPT,
+            prompt: `User's first message:\n\n${snippet}\n\nTitle:`,
+            ...resolveTemperatureParam(runtime, 0.3),
+            ...(runtime.modelInfo?.supportsMaxOutputTokens === false ? {} : { maxOutputTokens: 64 }),
+            ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
+        });
+        const title = sanitizeTitle(text ?? "");
+        if (title) {
+            return { title, modelId, usage };
+        }
+        console.error(`[orchestrator/genTitle] title generation returned empty text (model=${modelId}); using fallback`);
+    }
+    catch (err) {
+        console.error(`[orchestrator/genTitle] title generation failed (model=${modelId}): ${err?.message}; using fallback`);
+    }
+    return { title: fallbackTitle(userMessage), modelId };
 }
 /**
  * Resolve a model ID to a runnable AI SDK LanguageModel.
@@ -110,6 +164,7 @@ function createTools(_bash, _provider, _mode, _opts) {
         listDelegations: _opts?.listDelegations,
         killDelegation: _opts?.killDelegation,
         modelId: _opts?.modelId,
+        sessionId: _opts?.sessionId,
     });
 }
 // ---------------------------------------------------------------------------
@@ -138,6 +193,8 @@ export class Agent {
     steerDrain = null;
     maxToolRounds;
     hardMaxToolRounds;
+    /** Original hard ceiling at construction — bounds auto-compaction extension. */
+    _initialHardMaxToolRounds = 0;
     mode = "agent";
     modelId;
     maxTokens;
@@ -196,6 +253,9 @@ export class Agent {
     _turnUserGoalExcerpt = "";
     /** Compaction statistics tracking count and total tokens saved. */
     _compactionStats = { count: 0, totalSaved: 0 };
+    /** Token count immediately after the last successful compaction (or null if none yet this
+     *  session). Used by the cross-turn anti-thrash guard in postTurnCompact. */
+    _lastCompactionTokensAfter = null;
     /**
      * Pinned message sequences. A pinned user message is preserved verbatim across
      * compaction — it is re-injected as a system note immediately after the
@@ -208,6 +268,15 @@ export class Agent {
     // 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;
+    // Reactive sub-session escalation: the PREVIOUS turn's cumulative tool-output
+    // chars (from the top-level cap), reported by the tool engine at turn end and
+    // read at the next turn's route decision. See reactive-delegation.ts.
+    _lastTurnToolChars = 0;
+    // Instrument (cold-first-turn measurement): ordinal of the top-level turn whose
+    // tool load was last reported. Lets telemetry distinguish a turn-1 blow-up
+    // (which reactive escalation CANNOT isolate) from a later one (which it can).
+    // Gates the decision to build an in-turn checkpoint. See CONTEXT-CONTROL-LAYERS.md.
+    _turnLoadOrdinal = 0;
     // 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.
@@ -246,6 +315,10 @@ export class Agent {
         this.maxToolRounds = maxToolRounds || settings.maxToolRounds || MAX_TOOL_ROUNDS;
         const baseHardMax = settings.hardMaxToolRounds || HARD_MAX_TOOL_ROUNDS;
         this.hardMaxToolRounds = Math.max(Math.floor(this.maxToolRounds * 1.5), baseHardMax);
+        // Baseline captured so auto-compaction ceiling extension (see
+        // extendHardCeilingForAutoCompaction) is bounded relative to the ORIGINAL
+        // hard cap and cannot grow without limit across a runaway turn.
+        this._initialHardMaxToolRounds = this.hardMaxToolRounds;
         const envMax = Number(process.env.MUONROI_MAX_TOKENS);
         this.maxTokens = Number.isFinite(envMax) && envMax > 0 ? envMax : 16_384;
         this.batchApi = options.batchApi ?? false;
@@ -280,7 +353,7 @@ export class Agent {
             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);
+            const transcript = loadSessionChainTranscriptState(this.session.id);
             this.messages = transcript.messages;
             this.messageSeqs = transcript.seqs;
             this.sessionStore.setModel(this.session.id, this.modelId);
@@ -333,26 +406,36 @@ export class Agent {
     setModel(model) {
         this.modelId = normalizeModelId(model);
         const newProviderId = detectProviderForModel(this.modelId);
-        if (newProviderId !== this.providerId && this.apiKey) {
+        if (newProviderId !== this.providerId) {
             this.providerId = newProviderId;
             setProviderHint(this.providerId);
             // Drop this.baseURL when it points at a DIFFERENT provider's default
             // apiBase — otherwise the rebuilt factory binds the new provider's
             // strategy to the OLD provider's URL, sending requests to the wrong
             // host. Evidence: session 2492d6579b1d — user switched defaultProvider
-            // siliconflow→ (via UI), this.baseURL was still api.deepseek.com from
-            // startup, SiliconflowStrategy.createFactory was created with that
-            // baseURL, requests landed at api.deepseek.com which rejected the SF-
-            // style model id ("deepseek-ai/DeepSeek-V4-Flash") with "supported API
-            // model names are deepseek-v4-pro or deepseek-v4-flash".
+            // (via UI), this.baseURL was still the old provider's apiBase from
+            // startup, the rebuilt strategy factory was created with that stale
+            // baseURL, and requests landed at the wrong host which rejected the
+            // model id.
             // A user-supplied custom baseURL is preserved only when it does NOT
             // match any known provider's apiBase (i.e. it's a real override, not
             // a stale default).
             const staleBaseURL = isAnyProviderApiBase(this.baseURL) && this.baseURL !== apiBaseFor(this.providerId);
-            const effectiveBaseURL = staleBaseURL ? undefined : (this.baseURL ?? undefined);
             if (staleBaseURL)
                 this.baseURL = null;
-            this.provider = createProvider(this.providerId, this.apiKey, effectiveBaseURL);
+            // Provider changed — DEFER factory construction. The current this.apiKey
+            // belongs to the PREVIOUS provider (or is the "oauth" OAuth sentinel) and
+            // is invalid for the new one. Rebuilding here with it sent provider A's
+            // key to provider B → 401 "Authentication Fails, your api key … is
+            // invalid" on the next chat, for EVERY TUI provider switch (evidence:
+            // routing log routed to "deepseek-v4-flash via deepseek" with a
+            // non-deepseek key; and the "oauth" leak in session ff932f8568e8). Clear
+            // the stale key, null the provider, and re-arm _initOAuthProvider, which
+            // resolves the NEW provider's own key (or OAuth tokens) before the next
+            // turn (message-processor calls initOAuthProvider at turn start).
+            this.apiKey = null;
+            this.provider = null;
+            this._oauthInitDone = false;
         }
         if (this.sessionStore && this.session) {
             this.sessionStore.setModel(this.session.id, this.modelId);
@@ -392,6 +475,17 @@ export class Agent {
     }
     setPlanContext(ctx) {
         this.planContext = ctx;
+        // Persist so that bare continuation phrases ("tiếp tục", "continue") after
+        // interrupt or cross-process resume can re-hydrate the APPROVED PLAN section
+        // instead of forgetting context and re-asking for details.
+        if (this.session && ctx) {
+            try {
+                persistApprovedPlan(this.session.id, ctx);
+            }
+            catch {
+                /* best-effort */
+            }
+        }
     }
     setSendTelegramFile(fn) {
         this.sendTelegramFile = fn;
@@ -403,7 +497,7 @@ export class Agent {
         this.apiKey = apiKey;
         // Drop baseURL when it points at a DIFFERENT provider's default apiBase
         // (e.g. caller passed the legacy anthropic URL while providerId is
-        // siliconflow — without this we'd send siliconflow requests to
+        // deepseek — without this we'd send deepseek requests to
         // api.anthropic.com or similar). User-supplied custom URLs that don't
         // match any known provider's apiBase are preserved as real overrides.
         const stale = isAnyProviderApiBase(baseURL) && baseURL !== apiBaseFor(this.providerId);
@@ -419,6 +513,14 @@ export class Agent {
     getProviderId() {
         return this.providerId;
     }
+    /**
+     * Expose the provider factory for external callers (e.g., /compact slash command,
+     * sub-agent spawning) that need to make LLM calls outside the normal processMessage flow.
+     * Throws if no provider is configured.
+     */
+    getProvider() {
+        return this.requireProvider();
+    }
     getCwd() {
         return this.bash.getCwd();
     }
@@ -432,6 +534,9 @@ export class Agent {
     setMessages(messages) {
         this.messages = messages;
         this.messageSeqs = messages.map(() => null);
+        // Manual compaction (/compact) or /clear replaces the conversation; reset
+        // the per-turn auto-compact latch so future tool loops can compact again.
+        this._compactedThisTurn = false;
     }
     async listSchedules() {
         return this.schedules.list();
@@ -460,7 +565,7 @@ export class Agent {
         if (!provider) {
             return "New session";
         }
-        const generated = await genTitle(provider, userMessage);
+        const generated = await genTitle(provider, userMessage, this.modelId);
         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);
@@ -530,6 +635,22 @@ export class Agent {
     setToolLoopCapHandler(fn) {
         this._toolLoopCapHandler = fn;
     }
+    /**
+     * Extend the absolute hard-cap ceiling when the turn is being sustained by
+     * AUTO-COMPACTION (a productive long task, not a runaway). Rationale: each
+     * auto-compacted round resets context to O(N) input, so it is cheap — the
+     * hard cap's cost-runaway purpose is already served by the compaction. We
+     * grant `maxToolRounds/2` more headroom per compaction, bounded to at most
+     * one extra auto-recover budget's worth above the ORIGINAL ceiling so a
+     * genuinely wedged turn (which trips the pattern guard, not this path) can
+     * never grow the cap without limit. Called from the tool-engine auto-recover
+     * branch after a successful compaction.
+     */
+    extendHardCeilingForAutoCompaction() {
+        const bump = Math.max(25, Math.floor(this.maxToolRounds / 2));
+        const absoluteMax = this._initialHardMaxToolRounds + bump * getToolLimitAutoRecoverCap();
+        this.hardMaxToolRounds = Math.min(this.hardMaxToolRounds + bump, absoluteMax);
+    }
     // Safety-override handler — set by the UI (app.tsx) at startup. Invoked
     // from the message-processor tool-result pipeline when a safety block
     // (catastrophic, dangerous, git-safety, empty-bash) is detected. The UI
@@ -585,6 +706,7 @@ export class Agent {
             compaction_summary: undefined,
         });
         this._compactionStats = { count: 0, totalSaved: 0 };
+        this._lastCompactionTokensAfter = null;
         this._pinnedSeqs.clear();
         if (!this.sessionStore) {
             this.messages = [];
@@ -663,9 +785,35 @@ export class Agent {
             return [];
         return buildChatEntries(this.session.id);
     }
+    /**
+     * The session tree this TUI currently hosts: the root conversation plus every
+     * rotation / sub-agent descendant, with per-session metadata. Content from
+     * these sessions is already merged into the transcript on resume; this exposes
+     * WHICH sessions produced it so the rail can show the multi-session structure.
+     */
+    getSessionTree() {
+        if (!this.session)
+            return [];
+        try {
+            return getSessionChainInfos(this.session.id);
+        }
+        catch (err) {
+            logger.error("orchestrator", "getSessionTree failed", { message: err?.message });
+            return [];
+        }
+    }
     getLastTodoSnapshot() {
         if (!this.session)
             return null;
+        try {
+            const { getTaskListSnapshotFromGsd } = require("../gsd/phase-sync.js");
+            const gsdSnap = getTaskListSnapshotFromGsd(this.bash?.getCwd() ?? process.cwd());
+            if (gsdSnap)
+                return gsdSnap;
+        }
+        catch (err) {
+            // fail-open to legacy todo_write args
+        }
         const argsJson = getLastTodoWriteArgs(this.session.id);
         if (!argsJson)
             return null;
@@ -677,7 +825,7 @@ export class Agent {
         return {
             workspace: this.workspace,
             session: this.session,
-            messages: loadTranscript(this.session.id),
+            messages: loadSessionChainTranscriptState(this.session.id).messages,
             entries: buildChatEntries(this.session.id),
             totalTokens: getSessionTotalTokens(this.session.id),
         };
@@ -796,7 +944,7 @@ export class Agent {
         // 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;
-        // Sanitize actualInputTokens for providers (e.g. SiliconFlow) that return
+        // Sanitize actualInputTokens for providers that return
         // implausibly low prompt_tokens (e.g. 10) regardless of prompt size.
         const estIn = breakdown ? Math.ceil(((breakdown.systemChars ?? 0) + (breakdown.messagesChars ?? 0)) / 4) : 0;
         const actualInput = sanitizeInputTokens(totalInput, estIn);
@@ -919,8 +1067,27 @@ export class Agent {
         const totalUsage = {};
         let assistantText = "";
         let lastActivity = initialDetail;
+        // Phase B3 parity: the streamText sub-agent path compacts older tool
+        // results in prepareStep, but this batch path historically concatenated
+        // `[...childMessages, ...turnMessages]` unbounded every round — on a long
+        // batch loop the re-sent history balloons exactly like the stream path did
+        // before B3. Apply the same compactor here (round >= 1, mirroring the
+        // stream path's `stepNumber >= 1` gate). High-value results stay verbatim.
+        const batchCompactThreshold = getSubAgentCompactThresholdChars();
+        const batchCompactKeepLast = getSubAgentCompactKeepLast();
+        const batchChildCtxWindow = childRuntime.modelInfo?.contextWindow ?? 0;
+        const batchIsReasoningModel = childRuntime.modelInfo?.reasoning === true;
         for (let round = 0; round < maxSteps; round++) {
             const batchRequestId = `task-${Date.now()}-${round + 1}`;
+            const roundMessages = round < 1
+                ? [...childMessages, ...turnMessages]
+                : compactSubAgentMessages([...childMessages, ...turnMessages], {
+                    thresholdChars: batchCompactThreshold,
+                    keepLastTurns: batchCompactKeepLast,
+                    contextWindowTokens: batchChildCtxWindow,
+                    contextFillRatio: batchIsReasoningModel ? 0.3 : undefined,
+                    stripOldReasoning: batchIsReasoningModel,
+                });
             await addBatchRequests({
                 ...this.getBatchClientOptions(signal),
                 batchId: batch.batch_id,
@@ -931,8 +1098,8 @@ export class Agent {
                             chat_get_completion: buildBatchChatCompletionRequest({
                                 modelId: childRuntime.modelId,
                                 system: childSystem,
-                                messages: [...childMessages, ...turnMessages],
-                                temperature: request.agent === "explore" ? 0.2 : 0.5,
+                                messages: roundMessages,
+                                temperature: childRuntime.modelInfo?.fixedTemperature ?? (request.agent === "explore" ? 0.2 : 0.5),
                                 maxOutputTokens: !childCaps.acceptsParam("maxOutputTokens", childRuntime.modelInfo)
                                     ? undefined
                                     : Math.min(this.maxTokens, 8_192),
@@ -1244,7 +1411,10 @@ export class Agent {
         return this._resolveModelForTask("compact");
     }
     _resolveModelForTask(task) {
-        return resolveModelForTask(task, this.providerId, this.modelId);
+        const parentTier = getModelInfo(this.modelId)?.tier;
+        return resolveModelForTask(task, this.providerId, this.modelId, undefined, {
+            parentTier,
+        });
     }
     async compactForContext(provider, system, contextWindow, signal, settings = this.getCompactionSettings(contextWindow), force = false) {
         if (!this.session)
@@ -1387,6 +1557,7 @@ export class Agent {
         // grossSaved tells the user how many context tokens were reclaimed — a real benefit that
         // reduces subsequent turn costs.
         const tokensAfter = estimateConversationTokens(system, this.messages);
+        this._lastCompactionTokensAfter = tokensAfter;
         const saved = Math.max(0, preparation.tokensBefore - tokensAfter);
         const pct = preparation.tokensBefore > 0 ? ((saved / preparation.tokensBefore) * 100).toFixed(1) : "0.0";
         this._compactionStats.count++;
@@ -1452,6 +1623,13 @@ export class Agent {
                 minMeaningfulTokens,
             });
         }
+        const minNew = getAutoCompactMinNewTokens();
+        if (isCompactionThrash(tokens, this._lastCompactionTokensAfter, minNew)) {
+            return log(false, `anti-thrash (only ${tokens - (this._lastCompactionTokensAfter ?? 0)} new < ${minNew})`, {
+                tokens,
+                lastAfter: this._lastCompactionTokensAfter,
+            });
+        }
         log(true, `over-threshold (${tokens} >= ${minMeaningfulTokens})`, { tokens, thresholdPct, minMeaningfulTokens });
         await this.compactForContext(provider, system, contextWindow, signal, this.getCompactionSettings(contextWindow), true).catch((err) => logger.warn("orchestrator", "compaction failed", { error: err }));
     }
@@ -1464,8 +1642,8 @@ export class Agent {
     // (respondToCouncilQuestion/Preflight + the internal _create*Responder
     // hooks used by orchestrator.agent.test.ts).
     // ========================================================================
-    respondToCouncilQuestion(questionId, answer) {
-        this.councilManager.respondToQuestion(questionId, answer);
+    respondToCouncilQuestion(questionId, answer, questionText) {
+        this.councilManager.respondToQuestion(questionId, answer, questionText);
     }
     respondToCouncilPreflight(preflightId, approved) {
         this.councilManager.respondToPreflight(preflightId, approved);
@@ -1474,7 +1652,7 @@ export class Agent {
     // Council v2 — Clarify → Confirm → Debate → Plan → Execute
     // ========================================================================
     async *runCouncilV2(topic, options) {
-        const { runCouncil } = await import("../council/index.js");
+        const { runCouncil, postDebateContinuation } = 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);
@@ -1514,6 +1692,9 @@ export class Agent {
         catch (err) {
             logger.error("router", "runDir resolution failed (decisions.lock will be skipped)", { error: err });
         }
+        // Captures the post-debate action so we can auto-continue on
+        // "continue_session" (user chose to keep working with the debate result).
+        let chosenAction;
         try {
             const gen = runCouncil(topic, this.modelId, this.messages, this.session?.id, llm, this.councilManager.createQuestionResponder(), this.councilManager.createPreflightResponder(), processMessageFn, {
                 skipClarification: options?.skipClarification,
@@ -1521,12 +1702,39 @@ export class Agent {
                 cwd: this.bash.getCwd(),
                 councilStats, // NEW — share orchestrator's stats object with runCouncil (Phase 14 CQ-01)
                 signal,
+                // When the Context Rail is active it carries leader/panel/cost as
+                // ambient sidebar rows, so suppress the duplicate inline summary.
+                suppressInlineMeta: isContextRailEnabled(),
                 runDir, // B1 — persist decisions.lock.md for the /council slash path
+                // #2 — isolated research bridge. Same StreamRunner sub-agent the /ideal
+                // sprint-runner uses (runTaskRequest): a budget-capped, near-empty
+                // explore child runs the debate's research phase so its multi-step tool
+                // clutter never accretes into the council thread/context. Threads the
+                // council abort signal so Esc cancels the research child too.
+                runIsolatedTask: (request) => this.runTaskRequest(request, undefined, signal),
+                onPostDebateAction: (action) => {
+                    chosenAction = action;
+                    // Relay to the auto-council caller (tool-engine) so nested runs honor
+                    // the user's choice instead of always continuing.
+                    this.councilManager.setLastPostDebateAction(action);
+                },
             });
             let result;
+            // Hold back runCouncil's terminal `done`. The /council slash consumer
+            // (use-app-logic.tsx) does `for await (chunk of gen) { if (chunk.type ===
+            // "done") break; }` — so forwarding runCouncil's end-of-debate `done`
+            // strands THIS generator before the continue_session auto-continue below
+            // ever runs (the generator is suspended at the yield and never resumes).
+            // Swallow it here and re-emit our own `done` after the optional
+            // continuation so the consumer terminates at the right boundary.
+            let innerDoneSeen = false;
             do {
                 result = await gen.next();
                 if (!result.done && result.value) {
+                    if (result.value.type === "done") {
+                        innerDoneSeen = true;
+                        continue;
+                    }
                     yield result.value;
                 }
             } while (!result.done);
@@ -1535,6 +1743,124 @@ export class Agent {
             if (options?.userModelMessage && synthesis) {
                 this.appendCompletedTurn(options.userModelMessage, [{ role: "assistant", content: synthesis }]);
             }
+            // Keep working in THIS session when the chosen action calls for it
+            // (continue_session → carry the conclusion; generate_plan/implement →
+            // execute action items). postDebateContinuation is the single source of
+            // truth shared with the auto-council caller (tool-engine). Re-entering
+            // processMessage also writes real message rows, which is what makes the
+            // session resumable (the /council slash path otherwise leaves no messages
+            // and is filtered from the resume picker). Guarded by ownsController so it
+            // fires ONLY on the top-level slash path, never when nested inside
+            // processMessage (auto-council) or drained by the runDebate tool — those
+            // callers manage their own continuation.
+            const continuationPrompt = ownsController && synthesis ? postDebateContinuation(chosenAction, synthesis) : null;
+            const isBuildContinuation = chosenAction === "implement" || chosenAction === "generate_plan";
+            if (continuationPrompt && isBuildContinuation && process.env.MUONROI_COUNCIL_ISOLATE_IMPL !== "0") {
+                // #1 — build the council decision in an ISOLATED sub-agent instead of
+                // re-entering the full processMessage turn. The flat turn inherited the
+                // entire multi-round debate history and could overflow the context window
+                // (the exact wedge 97bc9d12 fixed for the /ideal sprint-runner but that
+                // /council never got). runTaskRequest starts near-empty and returns a
+                // compact ToolResult. ANTI-MÙ: the child is NOT blind — it is seeded with
+                // (a) the approved synthesis-as-spec (already in continuationPrompt) and
+                // (b) councilManager.buildContext(), the same compaction-summary + Recent
+                // Conversation + [Council Decision]/[Council Memory] "Key Decisions"
+                // checkpoint the anti-mù layer surfaces — so it has the decision + its
+                // rationale without carrying the raw transcript. Opt out with
+                // MUONROI_COUNCIL_ISOLATE_IMPL=0 (falls back to the processMessage path).
+                yield { type: "content", content: "\n[Implementing the council decision in an isolated context…]\n" };
+                this.councilManager.setContinuation(true);
+                try {
+                    let councilCheckpoint = "";
+                    try {
+                        councilCheckpoint = this.councilManager.buildContext();
+                    }
+                    catch {
+                        /* anti-mù bundle is best-effort — the synthesis alone still grounds the build */
+                    }
+                    const seededPrompt = councilCheckpoint
+                        ? `${continuationPrompt}\n\n## Council context (decision + recent session — do NOT re-debate, just build)\n${councilCheckpoint}`
+                        : continuationPrompt;
+                    let result;
+                    try {
+                        result = await this.runTaskRequest({ agent: "general", description: "Council implementation", prompt: seededPrompt, modelId: this.modelId }, undefined, signal);
+                    }
+                    catch (err) {
+                        // A throw (vs a returned {success:false}) must not escape and take the
+                        // whole /council run down — surface it in-band like the processMessage
+                        // path's TurnStallError handling and end the turn cleanly.
+                        yield {
+                            type: "error",
+                            content: `Council implementation failed: ${err instanceof Error ? err.message : String(err)}`,
+                        };
+                        yield { type: "done" };
+                        return;
+                    }
+                    if (result.success && result.output?.trim()) {
+                        yield { type: "content", content: `\n${result.output.trim()}\n` };
+                    }
+                    else if (result.error) {
+                        yield { type: "error", content: `Council implementation failed: ${result.error}` };
+                    }
+                    // Persist a COMPACT record so the /council slash session stays resumable
+                    // (the processMessage path wrote rows for this) WITHOUT re-inheriting the
+                    // debate bloat the isolated child deliberately avoided.
+                    try {
+                        this.appendCompletedTurn({ role: "user", content: "[Council implementation of the debate decision]" }, [{ role: "assistant", content: (result.output ?? result.error ?? "(no output)").trim() }]);
+                    }
+                    catch {
+                        /* non-critical persistence */
+                    }
+                    yield { type: "done" };
+                }
+                finally {
+                    this.councilManager.setContinuation(false);
+                }
+            }
+            else if (continuationPrompt) {
+                yield { type: "content", content: "\n[Continuing with the debate conclusion…]\n" };
+                this.councilManager.setContinuation(true);
+                try {
+                    // processMessage emits its own terminal `done`, which becomes the
+                    // consumer's break boundary — so the UI stops AFTER the continuation
+                    // turn, not before it.
+                    //
+                    // Guard the continuation with an idle+total watchdog: the per-chunk
+                    // stall watchdog only covers streamText byte flow, NOT a turn that
+                    // wedges inside a tool call (a `task` sub-agent or long `bash`).
+                    // Session 578b2eae7099 hung exactly there — the UI froze at "Council
+                    // working… elapsed 0s" with no rescue. On fire we abort the turn and
+                    // surface a toast instead of hanging forever.
+                    const { withTurnWatchdog, TurnStallError } = await import("./turn-watchdog.js");
+                    const idleMs = Number(process.env.MUONROI_COUNCIL_CONTINUATION_IDLE_MS ?? 120_000);
+                    const totalMs = Number(process.env.MUONROI_COUNCIL_CONTINUATION_TOTAL_MS ?? 600_000);
+                    try {
+                        yield* withTurnWatchdog(this.processMessage(continuationPrompt, options?.observer), {
+                            idleMs,
+                            totalMs,
+                            label: "council continuation turn",
+                        });
+                    }
+                    catch (err) {
+                        if (err instanceof TurnStallError) {
+                            this.abortController?.abort(new DOMException(err.message, "TimeoutError"));
+                            yield { type: "error", content: `Council continuation stalled — ${err.message}` };
+                            yield { type: "done" };
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                }
+                finally {
+                    this.councilManager.setContinuation(false);
+                }
+            }
+            else if (innerDoneSeen) {
+                // Non-continuation paths (save_exit, nested auto-council, sprint drain)
+                // still need the terminal `done` the consumer expects.
+                yield { type: "done" };
+            }
         }
         finally {
             if (ownsController && this.abortController?.signal === signal) {
@@ -1556,25 +1882,67 @@ export class Agent {
         };
         const llm = createCouncilLLM(this.bash, this.mode, this.session?.id, productStats);
         const processMessageFn = (m) => this.processMessage(m, options?.observer);
+        // Isolated bounded task-runner bridge for the sprint implement stage: a fresh
+        // child context (getSubAgentBudgetChars cap, independent compaction) that does
+        // NOT inherit this turn's council-debate history — the root fix for the live
+        // ctx-overflow wedge. Returns a compact ToolResult (absorbed, no parent bloat).
+        const runIsolatedTask = (request) => this.runTaskRequest(request, undefined, this.abortController?.signal);
         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.
+        // P2.7 (LLM-first — no-regex routing): the work-depth tier that decides
+        // /ideal's route is judged by the MODEL (the same depthTier the PIL Layer-1
+        // classifier emits for chat turns), NOT by a keyword scorer. The old regex
+        // `scoreComplexity` mis-tiered plainly-phrased heavy work — a "merge / vendor
+        // / rename" refactor scored LOW because it lacked the FORCE_HIGH keywords —
+        // which hot-pathed genuinely heavy tasks with zero interview/council. Only
+        // meaningful for "start"; other subcommands ignore it.
         let complexity;
+        let needsClarification;
         let sufficiencyMissing;
+        let routeForceCouncil = payload.flags.forceCouncil;
         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;
+            let depth = "standard";
+            try {
+                const { createLlmClassifier } = await import("../pil/llm-classify.js");
+                const classify = createLlmClassifier(this.requireProvider(), this.modelId);
+                const res = await classify(payload.idea);
+                if (res?.depthTier) {
+                    depth = res.depthTier;
+                }
+                else {
+                    // Same convention as PIL Layer 1: a null/garbled depth defaults to the
+                    // safe middle. Logged so a persistently-null classifier is diagnosable.
+                    console.error(`[ideal/route] model depth classify returned no depthTier — defaulting to "standard". idea=${JSON.stringify(payload.idea.slice(0, 80))}`);
+                }
+                // LLM-first clarity signal — feeds the downstream interview as a hint.
+                if (res?.needsClarification === true)
+                    needsClarification = true;
+            }
+            catch (err) {
+                // Fail-open: never block /ideal on a classify hiccup (No-Silent-Catch).
+                console.error(`[ideal/route] depth classify failed, defaulting to "standard": ${err?.message}`);
+            }
+            // The cheap 8-word classify above is only a HINT for the downstream GSD
+            // depth pipeline — it is NOT a routing gate. It was too noisy to gate the
+            // council decision: the SAME architectural prompt scored `heavy` on one run
+            // and `standard` the next, so routing flip-flopped between full Council and
+            // a straight-to-Edit maint-edit that skipped the debate. /ideal is the
+            // DELIBERATE path — it must ALWAYS run the full Council/loop-driver
+            // pipeline, in this order:
+            //   1. scan the source (discovery/scoping) to understand what the user's
+            //      request actually touches,
+            //   2. interview the user (AskCard — adaptive: only asks what the source
+            //      can't answer, so an existing repo isn't dragged through 6 questions),
+            //   3. leader-tier complexity assessment + debate INSIDE that flow, AFTER
+            //      scope is understood — never a "no debate" verdict from a bare-prompt
+            //      guess.
+            // So we force Council for every /ideal start; the fast classify only
+            // seeds depth/clarity hints for that flow. Explicit `--maintain` still opts
+            // out of Council (handled at the top of runProductLoop dispatch).
+            complexity = depth === "heavy" ? "high" : depth === "quick" ? "low" : "medium";
+            sufficiencyMissing = undefined;
+            if (payload.flags.mode !== "maintain") {
+                routeForceCouncil = true;
+            }
         }
         const gen = runProductLoop({
             subcommand: payload.subcommand,
@@ -1589,16 +1957,18 @@ export class Agent {
                 doneThreshold: payload.flags.doneThreshold,
                 budgetTokens: payload.flags.budgetTokens,
                 stack: payload.flags.stack,
-                forceCouncil: payload.flags.forceCouncil,
+                forceCouncil: routeForceCouncil,
             },
             respondToQuestion: this.councilManager.createQuestionResponder(),
             respondToPreflight: this.councilManager.createPreflightResponder(),
             cwd: this.bash.getCwd(),
             processMessageFn,
+            runIsolatedTask,
             // Mode C — wire verify-recipe detector so runProductLoop auto-detect can probe cwd.
             detectVerifyRecipe: () => this.detectVerifyRecipe(),
             skipPriorContext: payload.flags.noPriorContext === true,
             complexity,
+            needsClarification,
             sufficiencyMissing,
             // Mode C explicit override + gh pr create opt-in (see .planning/MAINTAIN-MODE.md).
             mode: payload.flags.mode,
@@ -2064,9 +2434,11 @@ export class Agent {
             setLastProviderOptionsShape: (shape) => {
                 self._lastProviderOptionsShape = shape;
             },
+            getCompactionStats: () => self.getCompactionStats(),
             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),
+            extendHardCeilingForAutoCompaction: () => self.extendHardCeilingForAutoCompaction(),
             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),
@@ -2175,7 +2547,16 @@ export class Agent {
         else {
             try {
                 const { classifySubSessionAction } = await import("../pil/llm-classify.js");
-                const routeResult = await classifySubSessionAction(this.requireProvider(), this.modelId, userMessage);
+                // Feed the recent-conversation digest so the router can actually honour
+                // its "decide based on the conversation history" contract — otherwise a
+                // continuation ("ok làm phần đó đi") is judged in isolation and can be
+                // mis-routed as a fresh/unrelated task. Passing contextInfo also turns
+                // on the session-size metadata block the ROTATE_SESSION rule relies on.
+                const routeResult = await classifySubSessionAction(this.requireProvider(), this.modelId, userMessage, {
+                    currentChars,
+                    threshold,
+                    recentTurns: this._buildRecentTurnsSummary(),
+                });
                 if (routeResult) {
                     routeAction = routeResult.action;
                     logger.info("orchestrator", "Routing action selected for user message", {
@@ -2189,6 +2570,18 @@ export class Agent {
                 logger.error("orchestrator", "Routing classification failed, falling back to DIRECT_ANSWER", { error: err });
             }
         }
+        // Reactive escalation — override a DIRECT_ANSWER route (the router's blind
+        // spot on read-heavy analysis, and its silent-degrade to DIRECT on classify
+        // failure) when the PREVIOUS turn's observed tool load proves the session is
+        // doing heavy multi-tool work. Deterministic, based on real execution, not a
+        // prompt guess. Only rescues DIRECT_ANSWER — never hijacks a deliberate
+        // ROTATE_SESSION. See reactive-delegation.ts.
+        if (routeAction === "DIRECT_ANSWER" && shouldReactivelyEscalate(this._lastTurnToolChars)) {
+            logger.info("orchestrator", "Reactive escalation to sub-session (prior turn tool-heavy)", {
+                prevTurnToolChars: this._lastTurnToolChars,
+            });
+            routeAction = "SPAWN_SUB_SESSION";
+        }
         const shouldRotate = currentChars > threshold || routeAction === "ROTATE_SESSION";
         if (shouldRotate && this.session && this.sessionStore) {
             logger.info("orchestrator", "Triggering silent session rotation", {
@@ -2206,7 +2599,7 @@ export class Agent {
                 const cr = await deliberateCompact(flowDir, this.messages, "", 4096, this.requireProvider(), this.modelId);
                 const newSession = this.sessionStore.createSession(this.modelId, this.mode, this.bash.getCwd());
                 const db = getDatabase();
-                db.prepare("UPDATE sessions SET parent_session_id = ? WHERE id = ?").run(parentSessionId, newSession.id);
+                this.sessionStore.linkChild(newSession.id, parentSessionId, "rotation");
                 const summaryMessage = createCompactionSummaryMessage(cr.summary);
                 const nextSeq = getNextMessageSequence(newSession.id);
                 appendCompaction(newSession.id, nextSeq, cr.summary, cr.tokensBeforeCompress);
@@ -2229,10 +2622,10 @@ export class Agent {
         let parentSessionId = null;
         let subSessionId = null;
         if (routeAction === "SPAWN_SUB_SESSION" && this.session && this.sessionStore) {
-            yield { type: "content", content: "\n⋯ Đang khởi tạo sub-session ngầm để xử lý tác vụ...\n" };
+            yield { type: "toast", toastLevel: "info", content: "Đang khởi tạo sub-session ngầm để xử lý tác vụ..." };
             parentSessionId = this.session.id;
             try {
-                const { loadLatestCompaction, getNextMessageSequence, appendCompaction, loadTranscriptState } = await import("../storage/transcript.js");
+                const { loadLatestCompaction, getNextMessageSequence, appendCompaction } = await import("../storage/transcript.js");
                 const { getDatabase } = await import("../storage/db.js");
                 const db = getDatabase();
                 // Check if there is already an active child session for this parent session
@@ -2259,9 +2652,13 @@ export class Agent {
                     }
                 }
                 if (shouldResume && subSessionId) {
-                    yield { type: "content", content: "\n⋯ Phát hiện sub-session trước đó bị gián đoạn, đang khôi phục...\n" };
+                    yield {
+                        type: "toast",
+                        toastLevel: "info",
+                        content: "Phát hiện sub-session trước đó bị gián đoạn, đang khôi phục...",
+                    };
                     this.session = this.sessionStore.getRequiredSession(subSessionId);
-                    const childState = loadTranscriptState(subSessionId);
+                    const childState = loadSessionChainTranscriptState(subSessionId);
                     this.messages = childState.messages;
                     this.messageSeqs = childState.seqs;
                     this.sessionStore.touchSession(subSessionId, this.bash.getCwd());
@@ -2274,21 +2671,26 @@ export class Agent {
                 else {
                     const latest = loadLatestCompaction(parentSessionId);
                     const newSession = this.sessionStore.createSession(this.modelId, this.mode, this.bash.getCwd());
-                    db.prepare("UPDATE sessions SET parent_session_id = ? WHERE id = ?").run(parentSessionId, newSession.id);
+                    this.sessionStore.linkChild(newSession.id, parentSessionId, "subagent");
                     subSessionId = newSession.id;
-                    let seedMessages = [];
-                    let seedSeqs = [];
+                    // Seed the child with the parent's CURRENT working set — after a
+                    // compaction that is already [summary, ...kept raw tail] (see the
+                    // compactForContext assignment). Previously the compaction branch
+                    // reseeded ONLY [summary], discarding the kept raw tail — so a forked
+                    // council/debate saw a bare generic summary instead of the actual
+                    // recent discussion the user pointed at ("debate THESE parts"), and
+                    // drifted off-topic. Keep the tail; just guarantee the summary is
+                    // present and persist the compaction row for the child's continuity.
+                    const seedMessages = [...this.messages];
+                    const seedSeqs = [...this.messageSeqs];
                     if (latest?.summary) {
-                        const summaryMsg = createCompactionSummaryMessage(latest.summary);
-                        seedMessages = [summaryMsg];
-                        seedSeqs = [null];
+                        if (!isCompactionSummaryMessage(seedMessages[0])) {
+                            seedMessages.unshift(createCompactionSummaryMessage(latest.summary));
+                            seedSeqs.unshift(null);
+                        }
                         const nextSeq = getNextMessageSequence(subSessionId);
                         appendCompaction(subSessionId, nextSeq, latest.summary, latest.tokensBefore);
                     }
-                    else {
-                        seedMessages = [...this.messages];
-                        seedSeqs = [...this.messageSeqs];
-                    }
                     // Add sub-session overlay system message
                     const overlayMessage = {
                         role: "system",
@@ -2322,6 +2724,22 @@ export class Agent {
         const autoCommitOn = isAutoCommitEnabled();
         const cwd = this.bash.getCwd();
         const dirtyBefore = autoCommitOn ? await snapshotDirtyPaths(cwd) : new Set();
+        // Top-level turn watchdog. The per-chunk stall watchdog only covers
+        // streamText byte flow; it does NOT cover a turn generator that keeps the
+        // socket open but never RETURNS after the model is done. Observed live:
+        // xai/grok-composer-2.5-fast fires onFinish/llm-done (finishReason=stop) but
+        // its stream generator never terminates, so processor.run() hangs, the UI's
+        // `for await` never ends, finalizeActiveTurn never runs, and the TUI stays
+        // frozen in the "processing" state (partial/raw markdown) until the next
+        // message forces a new run. Mirrors the council-continuation guard (idle +
+        // hard total). On fire we abort the turn and emit a terminal `done` so the
+        // consumer finalizes cleanly instead of hanging forever. idleMs resets on
+        // every yielded chunk, so long legitimate tool calls are safe; totalMs is a
+        // hard ceiling (0 = disabled by default, since a big multi-tool turn is not a
+        // hang). Env-overridable.
+        const { withTurnWatchdog, TurnStallError } = await import("./turn-watchdog.js");
+        const turnIdleMs = Number(process.env.MUONROI_TURN_IDLE_MS ?? 120_000);
+        const turnTotalMs = Number(process.env.MUONROI_TURN_TOTAL_MS ?? 0);
         try {
             let attempts = 0;
             const maxAttempts = 3;
@@ -2330,7 +2748,29 @@ export class Agent {
             while (attempts < maxAttempts) {
                 try {
                     attempts++;
-                    yield* processor.run(userMessage, observer, images);
+                    try {
+                        yield* withTurnWatchdog(processor.run(userMessage, observer, images), {
+                            idleMs: turnIdleMs,
+                            totalMs: turnTotalMs,
+                            label: "assistant turn",
+                        });
+                    }
+                    catch (stallErr) {
+                        // A hung turn is NOT a transient error — retrying it (below) would
+                        // just hang again. Abort, surface a toast, and terminate the turn.
+                        if (stallErr instanceof TurnStallError) {
+                            logger.warn("orchestrator", "Top-level turn watchdog fired — finalizing turn", {
+                                kind: stallErr.kind,
+                                message: stallErr.message,
+                            });
+                            this.abortController?.abort(new DOMException(stallErr.message, "TimeoutError"));
+                            yield { type: "toast", toastLevel: "warn", content: `Turn ended by watchdog: ${stallErr.message}` };
+                            yield { type: "done" };
+                        }
+                        else {
+                            throw stallErr;
+                        }
+                    }
                     break;
                 }
                 catch (err) {
@@ -2516,6 +2956,42 @@ export class Agent {
                 self._compactedThisTurn = v;
             },
             getCompactedThisTurn: () => self._compactedThisTurn,
+            getCompactionStats: () => self.getCompactionStats(),
+            reportTurnToolLoad: (chars) => {
+                self._lastTurnToolChars = Number.isFinite(chars) && chars > 0 ? chars : 0;
+                self._turnLoadOrdinal += 1;
+                // Cold-first-turn instrument: record every turn whose load crosses the
+                // reactive threshold, tagged with its ordinal. A later query counts what
+                // fraction of threshold-crossing turns are ordinal 1 (the un-isolatable
+                // cold turn) — the evidence that gates building an in-turn checkpoint.
+                try {
+                    if (self.session && self._lastTurnToolChars >= getReactiveDelegationThresholdChars()) {
+                        // isolated = the heavy turn ran in a forked child (router SPAWN,
+                        // reactive escalation, or rotation), so the parent never held it.
+                        // The cold-first-turn HOLE is specifically coldFirstTurn && !isolated
+                        // — a turn-1 blow-up that landed in the parent because neither the
+                        // router nor reactive escalation caught it. Recording `isolated`
+                        // stops the metric from over-counting router-isolated heavy turns.
+                        const kind = self.sessionStore?.getSessionKind(self.session.id) ?? "conversation";
+                        const isolated = kind !== "conversation";
+                        logInteraction(self.session.id, "turn_tool_load", {
+                            data: {
+                                chars: self._lastTurnToolChars,
+                                ordinal: self._turnLoadOrdinal,
+                                coldFirstTurn: self._turnLoadOrdinal === 1,
+                                isolated,
+                                kind,
+                                threshold: getReactiveDelegationThresholdChars(),
+                            },
+                        });
+                    }
+                }
+                catch (err) {
+                    logger.debug("orchestrator", "turn_tool_load telemetry failed (best-effort)", {
+                        error: err?.message,
+                    });
+                }
+            },
             setTurnUserGoalExcerpt: (v) => {
                 self._turnUserGoalExcerpt = v;
             },
@@ -2562,7 +3038,7 @@ export class Agent {
                     model: runtime.model,
                     system: systemPrompt,
                     prompt: `Child Sub-session is stuck. Question:\n${question}`,
-                    temperature: 0.2,
+                    ...resolveTemperatureParam(runtime, 0.2),
                     ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
                 });
                 return result.text;
@@ -2575,6 +3051,7 @@ export class Agent {
             countFilesTouched: () => self._countFilesTouched(),
             getCompactionSettings: (cw) => self.getCompactionSettings(cw),
             compactForContext: (provider, system, cw, signal, settings, overflow) => self.compactForContext(provider, system, cw, signal, settings, overflow),
+            extendHardCeilingForAutoCompaction: () => self.extendHardCeilingForAutoCompaction(),
             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),
@@ -2633,20 +3110,31 @@ export class Agent {
         const recent = this.messages.slice(-6);
         const parts = [];
         for (const msg of recent) {
-            if (msg.role !== "user" && msg.role !== "assistant")
+            if (msg.role !== "user" && msg.role !== "assistant" && msg.role !== "tool")
                 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("")
-                    : "";
+            let text = "";
+            if (msg.role === "tool") {
+                text = Array.isArray(msg.content)
+                    ? msg.content.map((p) => (typeof p.result === "string" ? p.result : JSON.stringify(p.result))).join(" ")
+                    : typeof msg.content === "string"
+                        ? msg.content
+                        : JSON.stringify(msg.content);
+            }
+            else {
+                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}`);
+            const snippet = text.length > 300 ? `${text.slice(0, 297)}...` : text;
+            parts.push(`[${msg.role}]: ${snippet.replace(/\n/g, " ")}`);
         }
         return parts.length > 0 ? parts.join(" | ") : null;
     }
@@ -2716,48 +3204,109 @@ export class Agent {
         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")
+        // Re-resolve auth for the CURRENT provider. Runs when either:
+        //  (a) no explicit API key / the "oauth" sentinel is held — OAuth may
+        //      apply (the boot wizard in src/index.ts uses the literal "oauth" to
+        //      mean "no key but OAuth tokens exist"); OR
+        //  (b) setModel deferred provider construction on a provider switch
+        //      (this.provider === null) — the PREVIOUS provider's key was cleared
+        //      and must be re-resolved from the NEW provider's own credentials.
+        const providerDeferred = this.provider === null;
+        const keyIsSentinelOrEmpty = !this.apiKey || this.apiKey === "oauth";
+        if (!providerDeferred && !keyIsSentinelOrEmpty)
             return;
         try {
             const { listOAuthProviderIds } = await import("../providers/auth/registry.js");
             const ids = await listOAuthProviderIds();
-            if (!ids.includes(this.providerId))
+            // OAuth path: the provider supports OAuth AND we don't hold a real API
+            // key, so inject subscription tokens as Bearer headers.
+            if (ids.includes(this.providerId) && keyIsSentinelOrEmpty) {
+                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.apiKey = "oauth";
+                this.provider = result.factory;
                 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;
+            }
+            // API-key path: resolve THIS provider's own stored key. Reached when the
+            // provider isn't OAuth-capable, or when a provider switch deferred
+            // construction (we must swap in the NEW provider's key — never reuse the
+            // previous provider's, which 401'd on every TUI provider switch). If no
+            // key exists for a deferred switch, leave the provider null so
+            // requireProvider() surfaces a clear "API key required".
+            try {
+                const key = await loadKeyForProvider(this.providerId);
+                if (key) {
+                    this.apiKey = key;
+                    const staleBaseURL = isAnyProviderApiBase(this.baseURL) && this.baseURL !== apiBaseFor(this.providerId);
+                    if (staleBaseURL)
+                        this.baseURL = null;
+                    this.provider = createProvider(this.providerId, key, this.baseURL ?? undefined);
+                }
+                else if (providerDeferred) {
+                    this.provider = null;
+                }
+            }
+            catch (err) {
+                // ProviderKeyMissingError (or keychain failure) — no usable key. For a
+                // deferred provider switch, null the provider so the next turn fails
+                // loudly ("API key required") instead of 401-ing on a wrong/sentinel
+                // key. For a non-deferred empty-key case, leave the existing provider
+                // untouched (fail-open, as before).
+                if (providerDeferred) {
+                    console.error(`[orchestrator] no API key for provider '${this.providerId}' after model switch: ${err instanceof Error ? err.message : String(err)}`);
+                    this.provider = null;
+                }
+            }
         }
         catch {
-            // Fail-open — provider remains null; requireProvider() will surface the error
+            // Registry unavailable — fail-open; the existing provider (if any) is
+            // left untouched and requireProvider() will surface any error.
         }
     }
     async detectVerifyRecipe(settings, abortSignal) {
+        const cwd = this.bash.getCwd();
+        const effectiveSettings = settings ?? this.bash.getSandboxSettings();
+        // Primary: LLM verify-detect turn — a codebase-aware, richer recipe.
+        let llmRecipe = null;
         try {
             const result = await this.runTaskRequest({
                 agent: "verify-detect",
                 description: "Detect verification recipe",
-                prompt: buildVerifyDetectPrompt(this.bash.getCwd(), settings ?? this.bash.getSandboxSettings()),
+                prompt: buildVerifyDetectPrompt(cwd, effectiveSettings),
             }, undefined, abortSignal);
-            if (!result.success || !result.output)
-                return null;
-            const maybeJson = extractJsonObject(result.output);
-            if (!maybeJson)
-                return null;
-            return normalizeVerifyRecipe(JSON.parse(maybeJson));
+            if (result.success && result.output) {
+                const maybeJson = extractJsonObject(result.output);
+                if (maybeJson)
+                    llmRecipe = normalizeVerifyRecipe(JSON.parse(maybeJson));
+            }
         }
-        catch {
-            return null;
+        catch (err) {
+            console.error(`[orchestrator] verify-detect turn failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (llmRecipe)
+            return llmRecipe;
+        // Deterministic fallback: an existing repo with a recognizable manifest
+        // (package.json test script, *.sln, pyproject, …) yields a reliable recipe
+        // WITHOUT an LLM. This stops CB-3 from false-halting an in-place /ideal
+        // migration with the "Recovery options" card purely because the flaky
+        // verify-detect model returned no parseable JSON (root cause of the
+        // existing-repo implementation-reachability halt). Only trusted when the
+        // profiler recognizes the ecosystem AND found real test commands.
+        try {
+            const profile = inferVerifyProjectProfile(cwd, effectiveSettings);
+            if (shouldTrustDeterministicRecipe(profile.recipe)) {
+                return profile.recipe;
+            }
+        }
+        catch (err) {
+            console.error(`[orchestrator] deterministic verify-recipe fallback failed: ${err instanceof Error ? err.message : String(err)}`);
         }
+        return null;
     }
     async runVerify(onProgress, abortSignal) {
         this.abortController = new AbortController();