muonroi-cli 1.8.4 → 1.9.0

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

@@ -48,7 +48,7 @@
 //   - A4 (tool_call write-ahead)            — persistToolCallWriteAhead
 //   - A5 (message_seq write-ahead)          — persistMessageWriteAhead
 //   - O1 (providerOptions shape forensics)  — extractProviderOptionsShape
-//   - siliconflow reasoning-strip           — turnCaps.sanitizeHistory
+//   - reasoning-strip (provider quirk)       — turnCaps.sanitizeHistory
 import { getCachedAuthToken, getCachedServerBaseUrl } from "../ee/auth.js";
 import { routeModel } from "../ee/bridge.js";
 import { getMistakeDetector } from "../ee/mistake-detector.js";
@@ -57,20 +57,26 @@ import * as phaseTracker from "../ee/phase-tracker.js";
 import { buildScope as buildScopeForVeto } from "../ee/scope.js";
 import { fireTrajectoryEvent } from "../ee/session-trajectory.js";
 import { getTenantId as getTenantIdForVeto } from "../ee/tenant.js";
+import { assessComplexity } from "../gsd/complexity-assessor.js";
+import { isComplexityAssessorEnabled, isGsdNativeEnabled, isPilGateEnrichEnabled } from "../gsd/flags.js";
+import { getGsdLoopHost } from "../gsd/loop-host.js";
+import { readState, syncWorkflowContext } from "../gsd/workflow-engine.js";
 import { applyPilSuffix, getResponseToolSet, } from "../pil/index.js";
+import { isContinuationPhrase } from "../pil/layer1-intent.js";
 import { loadKeyForProvider } from "../providers/keychain.js";
 import { getVisionGuidanceForTextOnly, } from "../providers/mcp-vision-bridge.js";
 import { detectProviderForModel, resolveModelRuntime, } from "../providers/runtime.js";
-import { needsVisionProxy, proxyVision } from "../providers/vision-proxy.js";
+import { canHandleImagesForTextOnlyModel, needsVisionProxy, planImageHandlingForTextOnlyModel, proxyVision, } from "../providers/vision-proxy.js";
 import { decideStepRouting, eeSamrGuidance, getStepRouterConfig } from "../router/step-router.js";
 import { routerStore } from "../router/store.js";
-import { getNextMessageSequence, logInteraction, persistMessageWriteAhead, } from "../storage/index.js";
-import { isDebugEnabled } from "../ui/slash/debug.js";
-import { statusBarStore } from "../ui/status-bar/store.js";
+import { statusBarStore } from "../state/status-bar-store.js";
+import { isDebugEnabled } from "../state/turn-trace.js";
+import { getLastApprovedPlan, getNextMessageSequence, logInteraction, persistMessageWriteAhead, } from "../storage/index.js";
 import { isProviderDisabled, loadValidSubAgents, } from "../utils/settings.js";
 import { prepareTurnContext } from "./preprocessor.js";
 import { applyModelConstraints, buildSystemPromptParts } from "./prompts.js";
 import { parseBudgetOverride, resetSessionStep, } from "./scope-ceiling.js";
+import { shouldRunGate } from "./should-run-gate.js";
 import { executeToolEngine } from "./tool-engine.js";
 /**
  * F2 — approximate the char cost of the FIXED prompt envelope (system +
@@ -107,6 +113,50 @@ function computeEnvelopeChars(system, tools) {
  * guidance entries it stays informed until new entries arrive.
  */
 const _injectedGuidanceSha = new Map();
+/**
+ * Single-shot leader-tier LLM runner for the GSD complexity assessor
+ * (Task 4 `assessComplexity`). Mirrors the orchestrator's own council LLM
+ * construction (`createCouncilLLM` — see `runCouncil` / `runProductLoop` in
+ * orchestrator.ts) so the assessor call auto-records usage as
+ * `source=council` (no cost-leak) instead of a bespoke unaccounted call.
+ * Leader model resolution goes ONLY through `resolvePlanCouncilLeader` —
+ * Zero Hardcode Rule, no literal model/provider IDs here.
+ */
+function buildLeaderAssessorRunner(deps, sessionModel) {
+    return async (prompt) => {
+        const { createCouncilLLM } = await import("../council/llm.js");
+        const { resolvePlanCouncilLeader } = await import("../council/leader.js");
+        const leader = await resolvePlanCouncilLeader(sessionModel);
+        const stats = { calls: 0, startMs: Date.now(), phases: [] };
+        const llm = createCouncilLLM(deps.bash, deps.mode, deps.session?.id, stats);
+        // Small budget — this is a single classification, not a synthesis.
+        return llm.generate(leader.modelId, "You are a task complexity assessor.", prompt, 512, undefined, AbortSignal.timeout(PIL_GATE_DEADLINE_MS));
+    };
+}
+/**
+ * Turn-start PIL gate budget: the assessor + heavy-tier critics run BEFORE the
+ * model message is assembled, so they must be short — a slow gate call would
+ * delay every turn, not just heavy ones. `createCouncilLLM.generate` has no
+ * per-call timeout of its own (`llm.ts:331` defaults to 5 minutes), so this
+ * deadline is threaded explicitly as the `signal` arg on every gate call.
+ */
+const PIL_GATE_DEADLINE_MS = 2500;
+/**
+ * Heavy-tier gate critic runner (Task 4 `runGateCritics`). Reuses the council
+ * LLM (billed `source=council`, no cost leak) with the same tight deadline as
+ * the assessor — three critics run in parallel via `Promise.all` inside
+ * `runGateCritics`, each individually bounded by this signal.
+ */
+function buildGateCriticRunner(deps, sessionModel) {
+    return async (prompt) => {
+        const { createCouncilLLM } = await import("../council/llm.js");
+        const { resolvePlanCouncilLeader } = await import("../council/leader.js");
+        const leader = await resolvePlanCouncilLeader(sessionModel);
+        const stats = { calls: 0, startMs: Date.now(), phases: [] };
+        const llm = createCouncilLLM(deps.bash, deps.mode, deps.session?.id, stats);
+        return llm.generate(leader.modelId, "You are a prompt-enrichment critic.", prompt, 512, undefined, AbortSignal.timeout(PIL_GATE_DEADLINE_MS));
+    };
+}
 /**
  * MessageProcessor — extracted streaming turn loop.
  *
@@ -316,6 +366,89 @@ export class MessageProcessor {
             yield res.value;
         }
         const { pilCtx, _stepCeiling, _pilStart, _naturalCeiling, _ceilingTaskType, _ceilingSize } = prepResult;
+        const cwd = deps.bash.getCwd();
+        if (isGsdNativeEnabled() &&
+            shouldRunGate(pilCtx, () => {
+                try {
+                    return readState(cwd).phase;
+                }
+                catch (err) {
+                    // Missing/corrupt .planning state is the normal "no active run" case, not an error.
+                    console.error(`[pil-gate] readState failed while checking resume phase (treating as no active run): ${err.message}`);
+                    return null;
+                }
+            })) {
+            try {
+                const sessionModel = deps.session?.model ?? "unknown";
+                let depth = pilCtx.modelDepthTier ?? pilCtx.complexityTier ?? "standard";
+                // Leader-tier assessor enrichment: OVERRIDES the fast-classifier depth
+                // before it's written to SDK STATE.md. `assessComplexity` itself never
+                // throws (every internal step is caught, degrading to `priorDepth`),
+                // but this inner try/catch is defensive fail-open insurance so even an
+                // unexpected throw here keeps `depth` at its fast-classifier value —
+                // syncWorkflowContext below is never skipped because of the assessor.
+                let brief = "";
+                if (isComplexityAssessorEnabled()) {
+                    try {
+                        const { buildGateContextBundle } = await import("../gsd/pil-gate-context.js");
+                        const bundle = buildGateContextBundle({
+                            cwd,
+                            conversationDigest: deps.buildRecentTurnsSummary(),
+                            brainData: pilCtx._brainData,
+                        });
+                        const assessed = await assessComplexity({
+                            cwd,
+                            raw: pilCtx.raw,
+                            priorDepth: depth,
+                            confidence: pilCtx.confidence,
+                            bundle,
+                            sessionModelId: sessionModel,
+                            runAssessor: buildLeaderAssessorRunner(deps, sessionModel), // single-shot leader call
+                        });
+                        depth = assessed.depth;
+                        // Keep the native depth slot authoritative: write the assessed depth
+                        // back to pilCtx.modelDepthTier so every downstream consumer that reads
+                        // it (tool-engine depthTier -> gsd tool registration + gsd_verify depth
+                        // + layer-derived tiering) sees the SAME value the mutation gate reads
+                        // from STATE.md. Without this, the gate (readState().depth) and gsd_verify
+                        // (pilCtx.modelDepthTier) diverge on any assessor override. Same pilCtx
+                        // ref, and this block runs before executeToolEngine in the same turn.
+                        pilCtx.modelDepthTier = depth;
+                        if (assessed.assessed)
+                            pilCtx.gsdAutoCouncil = assessed.autoCouncil;
+                        if (isPilGateEnrichEnabled() && assessed.enrichedPrompt) {
+                            let verdict = assessed.quality?.verdict ?? "enriched";
+                            brief = assessed.enrichedPrompt;
+                            if (depth === "heavy") {
+                                const { runGateCritics } = await import("../gsd/pil-gate-critic.js");
+                                const critiqued = await runGateCritics({
+                                    draftBrief: brief,
+                                    draftVerdict: verdict,
+                                    bundle,
+                                    runCritic: buildGateCriticRunner(deps, sessionModel),
+                                });
+                                verdict = critiqued.verdict;
+                                brief = critiqued.brief;
+                            }
+                            if (verdict === "adequate")
+                                brief = "";
+                        }
+                    }
+                    catch (assessErr) {
+                        brief = "";
+                        console.error(`[pil-gate] enrichment failed, using raw prompt: ${assessErr.message}`);
+                    }
+                }
+                if (brief) {
+                    pilCtx.enriched = `[PIL Gate brief]\n${brief.slice(0, 1500)}\n\n${pilCtx.enriched}`;
+                }
+                getGsdLoopHost().ensureHost(cwd, sessionModel);
+                syncWorkflowContext(cwd, sessionModel, depth);
+            }
+            catch (err) {
+                console.error(`[gsd-loop-host] turn sync failed: ${err.message}`);
+            }
+        }
         // Track whether forced-finalize is needed (set by stopWhen when the
         // ceiling fires). Read AFTER the streamText fullStream finishes.
         const _ceilingHit = false;
@@ -332,8 +465,8 @@ export class MessageProcessor {
             enrichedMessage = `[PIL fallback: ${pilCtx.fallbackReason} — classification/routing may be inaccurate or layers skipped; using raw input.]\n\n${enrichedMessage}`;
         }
         deps.setPilActive(pilCtx.taskType !== null);
-        deps.setPilEnrichmentDelta(pilCtx.metrics?.suffixInstructionTokens ?? Math.round((enrichedMessage.length - userMessage.length) / 4));
-        const _pilEnrichmentDeltaSnapshot = pilCtx.metrics?.suffixInstructionTokens ?? Math.round((enrichedMessage.length - userMessage.length) / 4);
+        deps.setPilEnrichmentDelta(pilCtx.metrics?.suffixInstructionTokens ?? Math.round(((enrichedMessage ?? "").length - userMessage.length) / 4));
+        const _pilEnrichmentDeltaSnapshot = pilCtx.metrics?.suffixInstructionTokens ?? Math.round(((enrichedMessage ?? "").length - userMessage.length) / 4);
         // P1 Item 3 wiring: phase-boundary detection. setPhase returns a snapshot
         // of the prior phase iff the phase NAME just changed. We classify the
         // outcome (pass/fail/abandoned/null) and fire phase-outcome to the EE
@@ -423,9 +556,17 @@ export class MessageProcessor {
         const turnStartMs = Date.now();
         let turnModelId = deps.modelId;
         let taskHash = null;
+        let routeReason = null;
+        const historyHasImages = deps.messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p.type === "image"));
+        const turnHasImages = (images?.length ?? 0) > 0;
+        let visionUnavailableNotice = null;
         const _routeStart = Date.now();
         try {
             const { decide } = await import("../router/decide.js");
+            const compactionMsg = deps.messages.find((m) => typeof m.content === "string" && m.content.startsWith("[Context checkpoint summary]"));
+            const compactionSummary = compactionMsg && typeof compactionMsg.content === "string"
+                ? compactionMsg.content.slice("[Context checkpoint summary]".length).trim()
+                : null;
             const routeDecision = await decide(userMessage, {
                 tenantId: "local",
                 cwd: deps.bash.getCwd(),
@@ -441,6 +582,11 @@ export class MessageProcessor {
                     projectSize: deps.estimateProjectSize(),
                     filesTouched: deps.countFilesTouched(),
                     mode: deps.mode,
+                    turnIndex: deps.messages.filter((m) => m.role === "user").length,
+                    messageCount: deps.messages.length,
+                    compactionCount: deps.getCompactionStats().count,
+                    totalSavedTokens: deps.getCompactionStats().totalSaved,
+                    compactionSummary,
                 },
             });
             if (routeDecision.model && routeDecision.model !== "HALT") {
@@ -449,14 +595,15 @@ export class MessageProcessor {
                 // images to text, so there's no need to switch to a vision-capable
                 // (and usually pricier / rate-limited) model.
                 const defaultHasVisionProxy = needsVisionProxy(deps.modelId);
-                const historyHasImages = deps.messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p.type === "image"));
-                const turnHasImages = (images?.length ?? 0) > 0;
-                const skipVisionRoute = defaultHasVisionProxy && (turnHasImages || historyHasImages);
+                const imagesOnTurn = turnHasImages || historyHasImages;
+                const canHandleImages = !defaultHasVisionProxy || !imagesOnTurn || (await canHandleImagesForTextOnlyModel(deps.modelId));
+                const skipVisionRoute = defaultHasVisionProxy && imagesOnTurn && canHandleImages;
                 if (!skipVisionRoute) {
                     turnModelId = routeDecision.model;
                 }
             }
             taskHash = routeDecision.taskHash ?? null;
+            routeReason = routeDecision.reason ?? null;
             // Update status bar with router switch info. Also reset back to the
             // session default when the router does NOT switch on this turn —
             // otherwise the bar stays "stuck" showing the previously-routed model
@@ -487,14 +634,39 @@ export class MessageProcessor {
                 taskHash = eeRoute?.taskHash ?? null;
             }
         }
+        if (needsVisionProxy(turnModelId) && (turnHasImages || historyHasImages)) {
+            const imageCount = turnHasImages ? images.length : 1;
+            const plan = await planImageHandlingForTextOnlyModel({
+                primaryModelId: turnModelId,
+                imageCount,
+            });
+            if (plan.strategy === "native_model") {
+                turnModelId = plan.fallback.modelId;
+                routeReason = routeReason ? `${routeReason}; vision-native-fallback` : "vision-native-fallback";
+                yield {
+                    type: "content",
+                    content: `[Vision: routed to ${plan.fallback.modelId} — no proxy backend; using native image support]\n`,
+                };
+            }
+            else if (plan.strategy === "unavailable") {
+                visionUnavailableNotice = plan.notice;
+            }
+        }
         // Interaction log: model routing
         try {
             if (deps.session) {
+                const promoted = turnModelId !== deps.modelId;
                 logInteraction(deps.session.id, "routing", {
                     model: turnModelId,
+                    eventSubtype: promoted ? "promoted" : "default",
                     data: {
                         defaultModel: deps.modelId,
                         routedModel: turnModelId,
+                        promoted,
+                        // promo-cap(...) tag appears here when the promotion ceiling clamped
+                        // an EE premium pick down to balanced — queryable via event_subtype +
+                        // data.reason to audit cost-leak prevention (session 89b34ce9a4e8 class).
+                        reason: routeReason,
                         taskHash,
                         pilTaskType: pilCtx.taskType ?? null,
                         pilIntentKind: pilCtx.intentKind ?? null,
@@ -509,13 +681,31 @@ export class MessageProcessor {
         const turnProviderId = detectProviderForModel(turnModelId);
         let turnProvider;
         if (turnProviderId !== deps.providerId) {
+            const disabled = isProviderDisabled(turnProviderId);
             // Even if the key is reachable, skip disabled providers
-            const turnKey = !isProviderDisabled(turnProviderId)
-                ? await loadKeyForProvider(turnProviderId).catch(() => null)
-                : null;
-            if (turnKey) {
-                const { createProviderFactory } = await import("../providers/runtime.js");
-                turnProvider = createProviderFactory(turnProviderId, { apiKey: turnKey }).factory;
+            const turnKey = !disabled ? await loadKeyForProvider(turnProviderId).catch(() => null) : null;
+            // An OAuth-capable provider may be authenticated by subscription tokens
+            // (no env API key). Detect that so the turn can still run over OAuth.
+            let hasOAuth = false;
+            if (!disabled) {
+                try {
+                    const { getOAuthProviderConfig } = await import("../providers/auth/registry.js");
+                    const cfg = await getOAuthProviderConfig(turnProviderId);
+                    const tokens = cfg ? await cfg.loadTokensWithRefresh().catch(() => null) : null;
+                    hasOAuth = !!tokens?.accessToken;
+                }
+                catch {
+                    hasOAuth = false;
+                }
+            }
+            if (turnKey || hasOAuth) {
+                // OAuth XOR API key: the ASYNC factory injects OAuth (codex baseURL +
+                // Bearer headers) when tokens exist for this provider, otherwise it
+                // uses the env key. Using the sync factory here was the cross-provider
+                // shadowing bug (it shipped a stale sk-proj key to api.openai.com).
+                const { createProviderFactoryAsync } = await import("../providers/runtime.js");
+                const built = await createProviderFactoryAsync(turnProviderId, turnKey ? { apiKey: turnKey } : {});
+                turnProvider = built.factory;
             }
             else {
                 // Router's provider unreachable or disabled — fall back to a non-disabled provider
@@ -566,10 +756,38 @@ export class MessageProcessor {
         // still carry image parts — otherwise sending the conversation back to a
         // text-only provider (e.g. DeepSeek) fails with "unknown variant
         // `image_url`" once history contains an image from a prior turn.
-        if (needsVisionProxy(turnModelId)) {
-            const historyHasImages = deps.messages.some((m) => Array.isArray(m.content) && m.content.some((p) => p.type === "image"));
-            const turnHasImages = (images?.length ?? 0) > 0;
-            if (turnHasImages || historyHasImages) {
+        if (needsVisionProxy(turnModelId) && (turnHasImages || historyHasImages)) {
+            const stripImagesFromMessages = (msgs) => msgs.map((m) => {
+                if (!Array.isArray(m.content))
+                    return m;
+                const textParts = m.content.filter((p) => p.type === "text");
+                const joined = textParts.map((p) => p.text ?? "").join("\n");
+                return { ...m, content: joined || "[image removed — vision unavailable]" };
+            });
+            if (visionUnavailableNotice) {
+                yield {
+                    type: "content",
+                    content: "[Vision: cannot analyze images — no vision API key or vision model available]\n",
+                };
+                if (historyHasImages) {
+                    deps.setMessages(stripImagesFromMessages(deps.messages).map((m) => {
+                        if (m.role !== "user" || typeof m.content !== "string")
+                            return m;
+                        return { ...m, content: `${m.content}\n\n${visionUnavailableNotice}` };
+                    }));
+                }
+                if (turnHasImages) {
+                    userModelMessage = {
+                        role: "user",
+                        content: `${messageForDb}\n\n${visionUnavailableNotice}`,
+                    };
+                    userEnrichedMessage = {
+                        role: "user",
+                        content: `${messageForModel}\n\n${visionUnavailableNotice}`,
+                    };
+                }
+            }
+            else {
                 try {
                     if (historyHasImages) {
                         const historyResult = await proxyVision(deps.messages, turnModelId, signal);
@@ -588,25 +806,23 @@ export class MessageProcessor {
                             userEnrichedMessage = proxyResult.messages[1];
                             yield {
                                 type: "content",
-                                content: `[Vision proxy: ${proxyResult.imageCount} image(s) → ${turnModelId} via SiliconFlow]\n`,
+                                content: `[Vision proxy: ${proxyResult.imageCount} image(s) analyzed for ${turnModelId}]\n`,
                             };
                         }
                     }
                 }
-                catch {
-                    yield { type: "content", content: "[Vision proxy: failed, images dropped]\n" };
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    console.warn(`[vision-proxy] message path failed: ${errMsg}`);
+                    const notice = visionUnavailableNotice ?? `[vision unavailable: ${errMsg}]`;
+                    yield { type: "content", content: "[Vision proxy: failed — images not sent to model]\n" };
+                    if (historyHasImages) {
+                        deps.setMessages(stripImagesFromMessages(deps.messages));
+                    }
                     if (turnHasImages) {
-                        userModelMessage = { role: "user", content: messageForDb };
-                        userEnrichedMessage = { role: "user", content: messageForModel };
+                        userModelMessage = { role: "user", content: `${messageForDb}\n\n${notice}` };
+                        userEnrichedMessage = { role: "user", content: `${messageForModel}\n\n${notice}` };
                     }
-                    // Strip image parts from history as a last-resort fallback so the
-                    // request doesn't blow up at the provider serialization layer.
-                    deps.setMessages(deps.messages.map((m) => {
-                        if (!Array.isArray(m.content))
-                            return m;
-                        const filtered = m.content.filter((p) => p.type !== "image");
-                        return { ...m, content: filtered };
-                    }));
                 }
             }
         }
@@ -666,12 +882,13 @@ export class MessageProcessor {
                         .slice(0, 10)
                         .map((p) => `  - ee_feedback(id="${p.id}", collection="${p.collection ?? "?"}", verdict=followed|ignored|noise)`);
                     const more = pending.length > 10 ? `\n  ...and ${pending.length - 10} more` : "";
-                    const recallContent = `⚠️ MANDATORY: Rate ${pending.length} unrated EE hint(s) before proceeding.\n` +
-                        `You MUST call ee_feedback for each hint below BEFORE doing anything else this turn.\n` +
-                        `This is not optional — the Experience Engine brain learns from these ratings.\n` +
-                        `Verdict: followed (you used the hint) | ignored (not relevant) | noise (wrong/stale).\n` +
+                    const recallContent = `↳ ${pending.length} earlier EE hint(s) still unrated. Rate the one(s) you actually ` +
+                        `acted on so the brain keeps what helped — this does NOT block the task; batch the ` +
+                        `ee_feedback call(s) alongside your work, don't stall the user's request on it.\n` +
+                        `Verdict: followed (you used it) | ignored (topical, didn't apply) | noise (wrong — needs reason).\n` +
                         `${hintLines.join("\n")}${more}\n` +
-                        `First output MUST be the ee_feedback call(s) — then proceed with the task.`;
+                        `Rate once and move on — a hint you can't judge yet, leave for later; re-rating the same ` +
+                        `id does not help. If the brain is unreachable the verdict is queued, so never retry-loop on it.`;
                     const sid = deps.session?.id ?? "_anon";
                     const { createHash: _recallHash } = await import("node:crypto");
                     const recallSha = _recallHash("sha256").update(recallContent).digest("hex").slice(0, 16);
@@ -706,7 +923,7 @@ export class MessageProcessor {
         const system = applyModelConstraints(applyPilSuffix(`${systemParts.staticPrefix}${playwrightGuidance}${systemParts.dynamicSuffix}`, pilCtx, _hasResponseTools), turnModelId);
         // Tool-turn system: same template as system but with toolTurn-prefix
         const toolTurnSystem = applyModelConstraints(applyPilSuffix(`${toolTurnParts.staticPrefix}${playwrightGuidance}${toolTurnParts.dynamicSuffix}`, pilCtx, _hasResponseTools), turnModelId);
-        const runtime = resolveModelRuntime(provider, turnModelId);
+        const runtime = resolveModelRuntime(turnModelId);
         const modelInfo = runtime.modelInfo;
         // SAMR: Step-Aware Model Routing — downgrade to fast model for tool-execution
         // steps after the initial reasoning step. The premium model decides WHAT to do;
@@ -739,7 +956,7 @@ export class MessageProcessor {
         const stepRouterDecision = decideStepRouting(turnModelId, deps.providerId, stepRouterCfg);
         const stepRouterPhase = stepRouterDecision.phase2ModelId ? "phase1" : "done";
         const phase2Runtime = stepRouterDecision.phase2ModelId
-            ? resolveModelRuntime(provider, stepRouterDecision.phase2ModelId)
+            ? resolveModelRuntime(stepRouterDecision.phase2ModelId)
             : null;
         if (stepRouterDecision.phase2ModelId && _debugOn) {
             _debugSteps.push({
@@ -749,7 +966,17 @@ export class MessageProcessor {
                 output_summary: stepRouterDecision.reason,
             });
         }
-        deps.setPlanContext(null);
+        // Phase 5 continuation fix: do not clear planContext on bare "tiếp tục"/"continue".
+        // Re-hydrate from persisted approved plan if needed (cross-process or after abort).
+        const _isCont = isContinuationPhrase(userMessage);
+        if (!_isCont) {
+            deps.setPlanContext(null);
+        }
+        else if (!deps.getPlanContext()) {
+            const _p = getLastApprovedPlan(deps.session?.id ?? "");
+            if (_p)
+                deps.setPlanContext(_p);
+        }
         const attemptedOverflowRecovery = false;
         // Stream-retry state: track how many transient retries have been attempted
         // for the current turn. Reset to 0 on each new user turn (we're in processMessage).

package/dist/src/orchestrator/orchestrator.d.ts

@@ -4,9 +4,14 @@ import { type ScheduleDaemonStatus, type StoredSchedule } from "../tools/schedul
 import type { AgentMode, ChatEntry, SessionInfo, SessionSnapshot, StreamChunk, SubagentStatus, TaskListSnapshot, TaskRequest, ToolResult, VerifyRecipe } from "../types/index.js";
 import { type SandboxMode, type SandboxSettings } from "../utils/settings.js";
 import { type SideQuestionResult } from "../utils/side-question.js";
-import { type AgentOptions, type ProcessMessageObserver } from "./agent-options.js";
+import { type AgentOptions, type LegacyProvider, type ProcessMessageObserver } from "./agent-options.js";
+import type { AskUserAskInfo } from "./ask-user.js";
 import type { SafetyOverrideAskInfo, SafetyOverrideVerdict } from "./safety-askcard.js";
 import type { ToolLoopCapAsk } from "./tool-loop-cap.js";
+/** 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 declare function fallbackTitle(userMessage: string): string;
 export declare class Agent {
     private provider;
     private providerId;
@@ -25,6 +30,8 @@ export declare class Agent {
     private steerDrain;
     private maxToolRounds;
     private hardMaxToolRounds;
+    /** Original hard ceiling at construction — bounds auto-compaction extension. */
+    private _initialHardMaxToolRounds;
     private mode;
     private modelId;
     private maxTokens;
@@ -83,6 +90,9 @@ export declare class Agent {
     private _turnUserGoalExcerpt;
     /** Compaction statistics tracking count and total tokens saved. */
     private _compactionStats;
+    /** 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. */
+    private _lastCompactionTokensAfter;
     /**
      * Pinned message sequences. A pinned user message is preserved verbatim across
      * compaction — it is re-injected as a system note immediately after the
@@ -93,6 +103,8 @@ export declare class Agent {
     /** One-shot cwd note injected at the start of the next processMessage turn after setCwd(). Cleared after injection. */
     private _pendingCwdNote;
     private _crossTurnDedup;
+    private _lastTurnToolChars;
+    private _turnLoadOrdinal;
     private _readBudget;
     constructor(apiKey: string | undefined, baseURL?: string, model?: string, maxToolRounds?: number, options?: AgentOptions);
     /**
@@ -110,6 +122,22 @@ export declare class Agent {
         text: string;
     }[]) | null): void;
     getActiveRunId(): string | null;
+    /**
+     * 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.
+     */
+    private _applyModelId;
     setModel(model: string): void;
     getMode(): AgentMode;
     getSandboxMode(): SandboxMode;
@@ -123,6 +151,12 @@ export declare class Agent {
     setApiKey(apiKey: string, baseURL?: string): void;
     setProviderAndKey(providerId: ProviderId, apiKey: string, baseURL?: string): void;
     getProviderId(): 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(): LegacyProvider;
     getCwd(): string;
     setCwd(dir: string): void;
     getMessages(): ModelMessage[];
@@ -143,8 +177,22 @@ export declare class Agent {
     cleanup(): Promise<void>;
     private _toolLoopCapHandler;
     setToolLoopCapHandler(fn: ToolLoopCapAsk | null): void;
+    /**
+     * 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(): void;
     private _safetyOverrideHandler;
     setSafetyOverrideHandler(fn: ((block: SafetyOverrideAskInfo) => Promise<SafetyOverrideVerdict>) | null): void;
+    private _askUserHandler;
+    setAskUserHandler(fn: ((info: AskUserAskInfo) => Promise<string>) | null): void;
     respondToToolApproval(approvalId: string, approved: boolean): void;
     clearHistory(): Promise<void>;
     startNewSession(): SessionSnapshot | null;
@@ -166,6 +214,13 @@ export declare class Agent {
     unpinMessageBySeq(seq: number): boolean;
     getPinnedSeqs(): number[];
     getChatEntries(): ChatEntry[];
+    /**
+     * 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(): import("../storage/transcript.js").SessionChainNode[];
     getLastTodoSnapshot(): TaskListSnapshot | null;
     getSessionSnapshot(): SessionSnapshot | null;
     onSubagentStatus(listener: (status: SubagentStatus | null) => void): () => void;
@@ -195,15 +250,21 @@ export declare class Agent {
     private _resolveModelForTask;
     private compactForContext;
     private postTurnCompact;
-    respondToCouncilQuestion(questionId: string, answer: string): void;
+    respondToCouncilQuestion(questionId: string, answer: string, questionText?: string): void;
     respondToCouncilPreflight(preflightId: string, approved: boolean): void;
     runCouncilV2(topic: string, options?: {
         skipClarification?: boolean;
         observer?: ProcessMessageObserver;
         userModelMessage?: ModelMessage;
+        /**
+         * convene_council path — forwarded into runCouncil so the post-debate
+         * decision surface is suppressed and the synthesis is returned to the
+         * calling agent (no CLI-hardcoded post-council branch).
+         */
+        convenePath?: boolean;
     }): AsyncGenerator<StreamChunk, void, unknown>;
     runProductLoopV1(payload: {
-        subcommand: "start" | "status" | "resume" | "abort" | "ship";
+        subcommand: "start" | "status" | "resume" | "abort" | "ship" | "review";
         idea?: string;
         runId?: string;
         flags: {