muonroi-cli 1.8.4 → 1.9.0

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,39 +13,44 @@ 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, 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 { ASK_USER_DISMISSED } from "./ask-user.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";
 import { loadFlowResumeDigest } from "./flow-resume.js";
+import { beginInteractivePause, endInteractivePause, isInteractivePaused } from "./interactive-pause.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,22 +75,65 @@ function isAnyProviderApiBase(url) {
     }
     return false;
 }
-/**
- * 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: getCurrentModel() });
+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;
 }
 /**
- * Resolve a model ID to a runnable AI SDK LanguageModel.
- * Uses the Anthropic provider factory created by createProvider().
+ * 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 resolveModelRuntime(provider, modelId) {
-    return resolveRuntime(provider, modelId);
+async function genTitle(userMessage, modelId) {
+    try {
+        const { generateText } = await import("ai");
+        const runtime = resolveModelRuntime(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 };
 }
 async function toolSetToBatchTools(_tools) {
     // Batch API not supported with Anthropic in Phase 0. Phase 1 may add this.
@@ -110,6 +159,7 @@ function createTools(_bash, _provider, _mode, _opts) {
         listDelegations: _opts?.listDelegations,
         killDelegation: _opts?.killDelegation,
         modelId: _opts?.modelId,
+        sessionId: _opts?.sessionId,
     });
 }
 // ---------------------------------------------------------------------------
@@ -138,6 +188,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 +248,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 +263,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 +310,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 +348,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);
@@ -330,30 +398,58 @@ export class Agent {
     getActiveRunId() {
         return this._activeRunId;
     }
-    setModel(model) {
+    /**
+     * Point the agent at `model`, re-resolving the provider when the new model
+     * belongs to a different one.
+     *
+     * EVERY path that changes `this.modelId` must go through here. Changing the
+     * id alone leaves `providerId` / `provider` / `baseURL` / `apiKey` describing
+     * the PREVIOUS provider, so the next turn POSTs the new model to the old
+     * provider's endpoint — which rejects it as unknown (session 0c6728ba1a25:
+     * `gpt-5.4` sent to api.x.ai → 404 "The model gpt-5.4 does not exist", a
+     * wiring bug that reads like a bad model name). `setMode` used to do exactly
+     * that; it now calls this too.
+     *
+     * Session persistence is NOT done here — callers own that, because setMode
+     * writes mode+model together.
+     */
+    _applyModelId(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;
         }
+    }
+    setModel(model) {
+        this._applyModelId(model);
         if (this.sessionStore && this.session) {
             this.sessionStore.setModel(this.session.id, this.modelId);
             this.session = this.sessionStore.getRequiredSession(this.session.id);
@@ -381,7 +477,11 @@ export class Agent {
             this.mode = mode;
             const modeModel = getModeSpecificModel(mode);
             if (modeModel) {
-                this.modelId = normalizeModelId(modeModel);
+                // Via _applyModelId, NOT a bare `this.modelId = ...`: a mode-specific
+                // model can belong to a different provider than the session's, and
+                // assigning the id alone would leave provider/baseURL/apiKey pointing at
+                // the old one — the cross-wire class in _applyModelId's docstring.
+                this._applyModelId(modeModel);
             }
             if (this.sessionStore && this.session) {
                 this.sessionStore.setMode(this.session.id, mode);
@@ -392,6 +492,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 +514,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 +530,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 +551,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 +582,7 @@ export class Agent {
         if (!provider) {
             return "New session";
         }
-        const generated = await genTitle(provider, userMessage);
+        const generated = await genTitle(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);
@@ -493,7 +615,7 @@ export class Agent {
             charBudget -= snippet.length;
         }
         const conversationContext = contextParts.join("\n\n");
-        const result = await runSideQuestion(question, this.provider, this.modelId, conversationContext, signal);
+        const result = await runSideQuestion(question, this.modelId, conversationContext, signal);
         this.recordUsage(result.usage, "other");
         return result;
     }
@@ -530,6 +652,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
@@ -539,6 +677,15 @@ export class Agent {
     setSafetyOverrideHandler(fn) {
         this._safetyOverrideHandler = fn;
     }
+    // ask_user handler — set by the UI (app.tsx). Invoked when the model calls the
+    // `ask_user` tool: the UI surfaces an agent-authored card and resolves with the
+    // human's answer string, which becomes the tool result. When unset (headless
+    // without an answerer), the tool returns the dismissed sentinel so the agent
+    // still continues from its own judgment.
+    _askUserHandler = null;
+    setAskUserHandler(fn) {
+        this._askUserHandler = fn;
+    }
     respondToToolApproval(approvalId, approved) {
         const toolApprovalResponse = {
             role: "tool",
@@ -585,6 +732,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 +811,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 +851,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 +970,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 +1093,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 +1124,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),
@@ -1023,7 +1216,6 @@ export class Agent {
     async runTaskRequest(request, onActivity, abortSignal) {
         const provider = this.requireProvider();
         const deps = {
-            getProvider: () => provider,
             resolveModelForTask: (task) => this._resolveModelForTask(task),
             getModelId: () => this.modelId,
             getProviderId: () => this.providerId,
@@ -1244,7 +1436,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)
@@ -1252,7 +1447,7 @@ export class Agent {
         // Phase 1: ask the compaction proposer model whether to compact and what to keep/drop.
         // Only compact if the model says yes. On error/skip, fall back to heuristic.
         const compactModelId = this._resolveCompactModel();
-        const proposal = await proposeCompaction(provider, compactModelId, this.messages, signal);
+        const proposal = await proposeCompaction(compactModelId, this.messages, signal);
         if (proposal !== null) {
             // Model decided — compact only if model says shouldCompact
             if (force) {
@@ -1315,7 +1510,7 @@ export class Agent {
         const customInstructions = isSubSession
             ? "This is a temporary sub-session. Under sub-sessions, it is CRITICAL to preserve active files being worked on, compiler/linter error states, and exact line coordinates in the summary. Do not omit details of files edited, tests run, or compiler diagnostics, as the model needs this specific context to continue working without re-reading the files."
             : undefined;
-        const { summary, usage: compactUsage } = await generateCompactionSummary(provider, compactModelId, preparation, customInstructions, signal);
+        const { summary, usage: compactUsage } = await generateCompactionSummary(compactModelId, preparation, customInstructions, 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).
@@ -1387,6 +1582,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 +1648,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 +1667,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 +1677,7 @@ export class Agent {
     // Council v2 — Clarify → Confirm → Debate → Plan → Execute
     // ========================================================================
     async *runCouncilV2(topic, options) {
-        const { runCouncil } = await import("../council/index.js");
+        const { runCouncil, buildNeutralPostCouncilContinuation } = 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 +1717,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 +1727,42 @@ export class Agent {
                 cwd: this.bash.getCwd(),
                 councilStats, // NEW — share orchestrator's stats object with runCouncil (Phase 14 CQ-01)
                 signal,
+                // convene_council path — suppress ALL hardcoded post-debate decision
+                // surface; the agent decides what happens after the synthesis.
+                convenePath: options?.convenePath,
+                // 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 +1771,130 @@ 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.
+            // convenePath suppresses the hardcoded card (chosenAction stays undefined),
+            // so always hand the synthesis to a normal agent turn via the neutral
+            // continuation and let the agent decide. ownsController scopes this to the
+            // top-level /council slash path (auto-council nests with ownsController
+            // false and continues in tool-engine instead).
+            const continuationPrompt = ownsController && synthesis ? buildNeutralPostCouncilContinuation(synthesis) || null : 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",
+                            shouldSuppressFire: isInteractivePaused,
+                        });
+                    }
+                    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) {
@@ -1555,26 +1915,149 @@ export class Agent {
             phases: [],
         };
         const llm = createCouncilLLM(this.bash, this.mode, this.session?.id, productStats);
-        const processMessageFn = (m) => this.processMessage(m, options?.observer);
+        // Autonomous-execution permission for the product loop. /ideal's consent
+        // boundary is the preflight plan-approval askcard; once the PO approves the
+        // plan, the sprint IMPLEMENT turn must apply its own file-op mutations without
+        // a per-tool approval prompt. In `safe` mode a Write/Edit surfaces a
+        // tool_approval_request and awaits respondToToolApproval — but in the driven
+        // product-loop context nothing answers it and no approval askcard renders, so
+        // the impl turn wedges forever right after finishReason:tool-calls (observed
+        // live 2026-07-14: 0 files written across grok/opencode/deepseek + isolated &
+        // streamed paths — tool-engine.ts:2997). Elevating safe→auto-edit for the turn
+        // auto-approves file ops (yolo stays yolo); catastrophic bash stays hard-blocked
+        // by permission-mode's CATASTROPHIC_PATTERNS regardless of mode.
+        const self = this;
+        const processMessageFn = (m) => (async function* () {
+            const prev = self.permissionMode;
+            if (self.permissionMode === "safe")
+                self.permissionMode = "auto-edit";
+            try {
+                yield* self.processMessage(m, options?.observer);
+            }
+            finally {
+                self.permissionMode = prev;
+            }
+        })();
+        // 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).
+        // Same autonomous-permission elevation as the streamed path above.
+        const runIsolatedTask = async (request) => {
+            const prev = self.permissionMode;
+            if (self.permissionMode === "safe")
+                self.permissionMode = "auto-edit";
+            try {
+                return await this.runTaskRequest(request, undefined, this.abortController?.signal);
+            }
+            finally {
+                self.permissionMode = prev;
+            }
+        };
         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 { probeRepoGrounding } = await import("../pil/repo-grounding-probe.js");
+                const { getRepoStructureHints } = await import("../pil/repo-structure-hints.js");
+                const classify = createLlmClassifier(this.modelId, {
+                    routeFastTier: true,
+                    // /ideal routing needs a reliable depth verdict; allow cross-provider
+                    // fallback so an agentic/no-fast-tier session model (e.g. xai) doesn't
+                    // strand the classify at fail-open. Bounded by CLASSIFY_TOTAL_BUDGET_MS.
+                    crossProviderFallback: true,
+                });
+                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;
+                // Design B — deterministic repo-grounding probe. Trigger on Layer-1
+                // OUTPUT (ambiguity), NOT a prompt regex: run only when the verdict is
+                // non-trivial (depth !== "quick") OR low-confidence, so a well-specified
+                // trivial task still hot-paths on one cheap call. The probe itself is
+                // deterministic (REPO_DEEP_MAP index + bounded on-disk reads, no LLM).
+                // Once it runs its MEASURED facts drive routing — confidence is
+                // trigger-only and can no longer override grounding.
+                const lowConfidence = (res?.confidence ?? 1) < 0.7;
+                if (depth !== "quick" || lowConfidence) {
+                    try {
+                        const hints = getRepoStructureHints(process.cwd());
+                        const probe = probeRepoGrounding(payload.idea, hints, { cwd: process.cwd() });
+                        if (probe.ran) {
+                            // Invariant: probe ran AND zero matched files, or a symbol
+                            // collision → route INTO Council (the arbiter). Never direct-
+                            // dispatch from weak grounding.
+                            if (probe.groundingUncertainty) {
+                                needsClarification = true;
+                                depth = depth === "quick" ? "standard" : depth;
+                            }
+                            // Measured size escalation: a large grounded surface routes heavy
+                            // regardless of the sentence-level classify verdict.
+                            if (probe.bucket === "large")
+                                depth = "heavy";
+                            console.error(`[ideal/route] grounding probe: files=${probe.matchedFiles} loc=${probe.totalLoc} ` +
+                                `dirs=${probe.matchedDirs} collision=${probe.collision} bucket=${probe.bucket} ` +
+                                `uncertainty=${probe.groundingUncertainty} → depth=${depth}`);
+                        }
+                    }
+                    catch (err) {
+                        // Fail-open: a probe hiccup must never block /ideal (No-Silent-Catch).
+                        console.error(`[ideal/route] grounding probe failed, ignoring: ${err?.message}`);
+                    }
+                }
+            }
+            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}`);
+            }
+            // Council routing gate (model-signal, no hardcoded depth→council table).
+            //
+            // History: /ideal used to force Council UNCONDITIONALLY because the cheap
+            // classify was too noisy to gate on — the SAME architectural prompt scored
+            // `heavy` on one run and `standard` the next, so routing flip-flopped. That
+            // noise was root-caused (2026-07-15, harness-measured): the session model
+            // could be an agentic model (e.g. grok-composer) that ignores the terse
+            // 8-word classify contract and emits task-planning prose → null → fail-open
+            // "standard"; and stream errors were swallowed into the same null. Both are
+            // now fixed in llm-classify.ts (cross-provider route to a keyed instruction-
+            // follower + No-Silent-Catch error surfacing), so the depth/clarity signal
+            // is reliable enough to gate on.
+            //
+            // Gate: only a genuinely TRIVIAL /ideal — the model says depth=quick AND
+            // not-underspecified — skips Council and takes the product-loop hot-path
+            // (single sprint, no debate; index.ts complexity==="low" branch). Anything
+            // else (standard, heavy, or any underspecified request) still runs the full
+            // Council/loop-driver pipeline: scan source → adaptive interview → leader-
+            // tier assessment + debate AFTER scope is understood. When the model is
+            // uncertain (null depth → "medium") it routes INTO Council, the arbiter —
+            // never a hardcoded default. Explicit `--maintain` still opts out entirely.
+            complexity = depth === "heavy" ? "high" : depth === "quick" ? "low" : "medium";
+            sufficiencyMissing = undefined;
+            if (payload.flags.mode !== "maintain") {
+                const trivial = depth === "quick" && needsClarification !== true;
+                if (!trivial)
+                    routeForceCouncil = true;
+            }
         }
         const gen = runProductLoop({
             subcommand: payload.subcommand,
@@ -1589,16 +2072,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 +2549,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 +2662,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.modelId, userMessage, {
+                    currentChars,
+                    threshold,
+                    recentTurns: this._buildRecentTurnsSummary(),
+                });
                 if (routeResult) {
                     routeAction = routeResult.action;
                     logger.info("orchestrator", "Routing action selected for user message", {
@@ -2189,6 +2685,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", {
@@ -2203,10 +2711,10 @@ export class Agent {
                 const { deliberateCompact } = await import("../flow/compaction/index.js");
                 const { getDatabase } = await import("../storage/db.js");
                 const { appendCompaction, getNextMessageSequence } = await import("../storage/transcript.js");
-                const cr = await deliberateCompact(flowDir, this.messages, "", 4096, this.requireProvider(), this.modelId);
+                const cr = await deliberateCompact(flowDir, this.messages, "", 4096, 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 +2737,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 +2767,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 +2786,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 +2839,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 +2863,30 @@ 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",
+                            shouldSuppressFire: isInteractivePaused,
+                        });
+                    }
+                    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 +3072,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;
             },
@@ -2555,14 +3147,13 @@ export class Agent {
                     `${serializedParent}\n\n` +
                     `Provide clear, actionable guidance to resolve the child's query.`;
                 const { generateText } = await import("ai");
-                const provider = self.requireProvider();
                 const modelId = self.modelId;
-                const runtime = resolveModelRuntime(provider, modelId);
+                const runtime = resolveModelRuntime(modelId);
                 const result = await generateText({
                     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 +3166,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),
@@ -2613,6 +3205,25 @@ export class Agent {
                     return { action: "block" };
                 }
             },
+            askUser: async (info) => {
+                const h = self._askUserHandler;
+                if (!h) {
+                    logger.warn("orchestrator", "askUser called but no handler registered — returning dismissed sentinel");
+                    return ASK_USER_DISMISSED;
+                }
+                // Hold both watchdogs open while the human answers (see interactive-pause.ts).
+                beginInteractivePause();
+                try {
+                    return await h(info);
+                }
+                catch (err) {
+                    logger.error("orchestrator", "askUser crashed", { error: err });
+                    return ASK_USER_DISMISSED;
+                }
+                finally {
+                    endInteractivePause();
+                }
+            },
             runCouncilV2: (msg, opts) => self.runCouncilV2(msg, opts),
             processMessage: (msg, obs, imgs) => self.processMessage(msg, obs, imgs),
             processMessageBatchTurn: (args) => self.processMessageBatchTurn(args),
@@ -2633,20 +3244,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 +3338,129 @@ 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")
-            return;
+        // 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";
         try {
-            const { listOAuthProviderIds } = await import("../providers/auth/registry.js");
+            const { listOAuthProviderIds, getOAuthProviderConfig } = await import("../providers/auth/registry.js");
             const ids = await listOAuthProviderIds();
-            if (!ids.includes(this.providerId))
+            const oauthCapable = ids.includes(this.providerId);
+            // One auth mode per provider (OAuth XOR API key): if this OAuth-capable
+            // provider has a live token, OAuth wins OUTRIGHT — even over a real held
+            // API key. This is the shadowing-bug fix: a stale sk-proj key must not
+            // beat a valid ChatGPT OAuth login. Check token presence BEFORE the
+            // early-out so a held key can no longer suppress OAuth.
+            let hasOAuthTokens = false;
+            if (oauthCapable) {
+                try {
+                    const cfg = await getOAuthProviderConfig(this.providerId);
+                    const tokens = cfg ? await cfg.loadTokensWithRefresh().catch(() => null) : null;
+                    hasOAuthTokens = !!tokens?.accessToken;
+                }
+                catch {
+                    hasOAuthTokens = false;
+                }
+            }
+            // Nothing to do only when: no OAuth token, a real key is held, and the
+            // provider was not deferred by a model switch.
+            if (!hasOAuthTokens && !providerDeferred && !keyIsSentinelOrEmpty)
                 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;
+            // OAuth path: inject subscription tokens as Bearer headers. Taken when a
+            // token exists (override a held key), OR when no real key is held for an
+            // OAuth-capable provider.
+            if (oauthCapable && (hasOAuthTokens || 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;
+            }
+            // 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();