muonroi-cli 1.7.2 → 1.8.1

package/dist/src/orchestrator/orchestrator.js

@@ -14,29 +14,32 @@ 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 { ALL_PROVIDER_IDS } from "../providers/types.js";
-import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, logInteraction, markMessageCompleted, recordUsageEvent, SessionStore, } from "../storage/index.js";
+import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, logInteraction, markMessageCompleted, recordUsageEvent, SessionStore, } from "../storage/index.js";
 import { BashTool } from "../tools/bash.js";
 import { createBuiltinTools } from "../tools/registry.js";
 import { ScheduleManager } from "../tools/schedule.js";
+import { 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 } from "../usage/estimator.js";
-import { getAutoCompactThresholdPct, getCouncilRounds, getCurrentModel, getCurrentShellSettings, getModeSpecificModel, getRoleModel, getRoleModels, isAutoCompactAfterTurnEnabled, isCouncilMultiProviderPreferred, isProviderDisabled, } from "../utils/settings.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 { runSideQuestion } from "../utils/side-question.js";
 import { buildVerifyDetectPrompt, normalizeVerifyRecipe } from "../verify/entrypoint.js";
 import { runVerifyOrchestration } from "../verify/orchestrator.js";
 import { COUNCIL_COLOR_BG, COUNCIL_COLOR_RESET, COUNCIL_ROLE_COLORS, } from "./agent-options.js";
+import { 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, shouldCompactContext, } from "./compaction.js";
+import { createCompactionSummaryMessage, DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS, estimateConversationTokens, extractUserContent, generateCompactionSummary, 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 { MessageProcessor } from "./message-processor.js";
 import { lastPersistedSeq } from "./message-seq.js";
-import { buildSystemPrompt, MAX_TOOL_ROUNDS } from "./prompts.js";
+import { buildSystemPrompt, HARD_MAX_TOOL_ROUNDS, MAX_TOOL_ROUNDS } from "./prompts.js";
 import { getReadPathBudgetCap, ReadPathBudget } from "./read-path-budget.js";
 import { withStreamRetry } from "./retry-stream.js";
 import { StreamRunner } from "./stream-runner.js";
@@ -105,6 +108,7 @@ function createTools(_bash, _provider, _mode, _opts) {
         runDelegation: _opts?.runDelegation,
         readDelegation: _opts?.readDelegation,
         listDelegations: _opts?.listDelegations,
+        killDelegation: _opts?.killDelegation,
         modelId: _opts?.modelId,
     });
 }
@@ -133,6 +137,7 @@ export class Agent {
     /** UI-registered live-queue steer drain; see Agent.setSteerDrain. */
     steerDrain = null;
     maxToolRounds;
+    hardMaxToolRounds;
     mode = "agent";
     modelId;
     maxTokens;
@@ -237,7 +242,10 @@ export class Agent {
             this.setApiKey(apiKey, baseURL);
         }
         this.schedules = new ScheduleManager(() => this.bash.getCwd(), () => this.modelId);
-        this.maxToolRounds = maxToolRounds || MAX_TOOL_ROUNDS;
+        const settings = loadUserSettings();
+        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);
         const envMax = Number(process.env.MUONROI_MAX_TOKENS);
         this.maxTokens = Number.isFinite(envMax) && envMax > 0 ? envMax : 16_384;
         this.batchApi = options.batchApi ?? false;
@@ -264,7 +272,7 @@ export class Agent {
                 warmMcpClients(filterMcpServersByMessage(loadMcpServers(), ""));
             }
             catch (err) {
-                console.error(`[orchestrator] MCP pre-warm skipped: ${err?.message}`);
+                logger.error("orchestrator", "MCP pre-warm skipped", { error: err });
             }
         })();
         if (options.persistSession !== false) {
@@ -355,10 +363,12 @@ export class Agent {
         return this.mode;
     }
     getSandboxMode() {
+        // Sandbox has been removed; BashTool.getSandboxMode() always returns "off".
         return this.bash.getSandboxMode();
     }
-    setSandboxMode(mode) {
-        this.bash.setSandboxMode(mode);
+    setSandboxMode(_mode) {
+        // No-op: sandbox has been removed. BashTool no longer has a mutable sandbox mode.
+        // Will be re-implemented when the new sandbox is ready.
     }
     getSandboxSettings() {
         return this.bash.getSandboxSettings();
@@ -419,6 +429,10 @@ export class Agent {
     getMessages() {
         return this.messages;
     }
+    setMessages(messages) {
+        this.messages = messages;
+        this.messageSeqs = messages.map(() => null);
+    }
     async listSchedules() {
         return this.schedules.list();
     }
@@ -516,6 +530,15 @@ export class Agent {
     setToolLoopCapHandler(fn) {
         this._toolLoopCapHandler = fn;
     }
+    // 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
+    // surfaces an askcard ("Allow once / Allow session / Block") and resolves
+    // with the verdict. When unset, blocks pass through as normal errors.
+    _safetyOverrideHandler = null;
+    setSafetyOverrideHandler(fn) {
+        this._safetyOverrideHandler = fn;
+    }
     respondToToolApproval(approvalId, approved) {
         const toolApprovalResponse = {
             role: "tool",
@@ -640,6 +663,14 @@ export class Agent {
             return [];
         return buildChatEntries(this.session.id);
     }
+    getLastTodoSnapshot() {
+        if (!this.session)
+            return null;
+        const argsJson = getLastTodoWriteArgs(this.session.id);
+        if (!argsJson)
+            return null;
+        return snapshotFromTodoWriteArgs(argsJson);
+    }
     getSessionSnapshot() {
         if (!this.session || !this.workspace)
             return null;
@@ -765,6 +796,10 @@ 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
+        // 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);
         appendCostLog({
             ts: Date.now(),
             provider: this.providerId,
@@ -772,7 +807,7 @@ export class Agent {
             estimatedUsd: turnCostMicros / 1_000_000,
             callsite: `orchestrator.${source}`,
             phase: source,
-            actualInputTokens: totalInput,
+            actualInputTokens: actualInput,
             actualOutputTokens: output,
             cachedInputTokens: cacheRead,
             systemChars: breakdown?.systemChars,
@@ -1162,15 +1197,43 @@ export class Agent {
             };
         }
     }
+    async killDelegation(id) {
+        try {
+            return await this.delegations.kill(id);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Failed to terminate delegation: ${msg}`,
+            };
+        }
+    }
     getCompactionSettings(contextWindow) {
         let keepRecentTokens = DEFAULT_KEEP_RECENT_TOKENS;
         // For models with very large context windows, keep more recent tokens
         if (contextWindow && contextWindow > 200_000) {
             keepRecentTokens = Math.min(100_000, Math.max(20_000, Math.floor(contextWindow * 0.1)));
         }
-        // Compact more aggressively for long sessions to prevent runaway token growth
+        // For long sessions, reduce keepRecentTokens slightly to slow context growth
+        // (0.85 instead of old 0.75 — session bf58d0f46b51 showed 0.75 created a
+        // tight compact-loop: keep 15K → add 50K tool results → re-compact immediately).
         if (this._compactionStats.count >= 2) {
-            keepRecentTokens = Math.floor(keepRecentTokens * 0.75);
+            keepRecentTokens = Math.floor(keepRecentTokens * 0.85);
+        }
+        // For sub-sessions, reduce keepRecentTokens to 8000 to keep active history light
+        try {
+            if (this.session) {
+                const { getDatabase } = require("../storage/db.js");
+                const db = getDatabase();
+                const row = db.prepare("SELECT parent_session_id FROM sessions WHERE id = ?").get(this.session.id);
+                if (row?.parent_session_id) {
+                    keepRecentTokens = 8000;
+                }
+            }
+        }
+        catch {
+            // Ignored
         }
         return {
             reserveTokens: Math.max(this.maxTokens, DEFAULT_RESERVE_TOKENS),
@@ -1186,12 +1249,28 @@ export class Agent {
     async compactForContext(provider, system, contextWindow, signal, settings = this.getCompactionSettings(contextWindow), force = false) {
         if (!this.session)
             return false;
+        // 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);
+        if (proposal !== null) {
+            // Model decided — compact only if model says shouldCompact
+            if (force) {
+                // force always proceeds; the proposer's actions still guide what to keep/drop
+            }
+            else if (!proposal.shouldCompact) {
+                return false;
+            }
+        }
+        else {
+            // Proposer unavailable — fall back to heuristic token-threshold check
+            if (!force && !shouldCompactContext(estimateConversationTokens(system, this.messages), contextWindow, settings)) {
+                return false;
+            }
+        }
         const preparation = prepareCompaction(this.messages, system, settings);
         if (!preparation)
             return false;
-        if (!force && !shouldCompactContext(preparation.tokensBefore, contextWindow, settings)) {
-            return false;
-        }
         const trigger = force ? "manual" : "auto";
         // Fire-and-forget: notify EE of stale suggestions before compaction
         const { surfacedIds, timestamp } = getLastSurfacedState();
@@ -1219,9 +1298,24 @@ export class Agent {
         await this.fireHook(preCompactInput, signal).catch(() => { });
         const keptSeqs = this.messageSeqs.slice(preparation.firstKeptIndex);
         const firstKeptSeq = keptSeqs.find((seq) => seq !== null) ?? getNextMessageSequence(this.session.id);
-        const compactModelId = this._resolveCompactModel();
         const compactStartedAt = Date.now();
-        const { summary, usage: compactUsage } = await generateCompactionSummary(provider, compactModelId, preparation, undefined, signal);
+        const isSubSession = await (async () => {
+            try {
+                if (!this.session)
+                    return false;
+                const { getDatabase } = await import("../storage/db.js");
+                const db = getDatabase();
+                const row = db.prepare("SELECT parent_session_id FROM sessions WHERE id = ?").get(this.session.id);
+                return !!row?.parent_session_id;
+            }
+            catch {
+                return false;
+            }
+        })();
+        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);
         // 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).
@@ -1285,11 +1379,15 @@ export class Agent {
             .catch(() => { });
         // Mark as surfaced for prompt-stale reconciliation (per plan Phase 1).
         updateLastSurfacedState([`compact-checkpoint-${this._compactionStats.count + 1}`]);
-        // Track compaction stats — net of the tokens spent ON compaction itself.
+        // Track compaction stats — report the GROSS context reduction, NOT net-after-compact-cost.
+        // Rationale: the compaction call's own prompt/completion tokens ARE already counted in
+        // in_tokens/out_tokens/session_usd (updateStatusBar at line 986). Subtracting them here
+        // would double-penalize: the user sees the real cost in the token counter AND sees
+        // "0 saved" because compactCost >= grossSaved (the compact prompt is the full conversation).
+        // grossSaved tells the user how many context tokens were reclaimed — a real benefit that
+        // reduces subsequent turn costs.
         const tokensAfter = estimateConversationTokens(system, this.messages);
-        const grossSaved = Math.max(0, preparation.tokensBefore - tokensAfter);
-        const compactCost = compactUsage.promptTokens + compactUsage.completionTokens;
-        const saved = Math.max(0, grossSaved - compactCost);
+        const saved = Math.max(0, preparation.tokensBefore - tokensAfter);
         const pct = preparation.tokensBefore > 0 ? ((saved / preparation.tokensBefore) * 100).toFixed(1) : "0.0";
         this._compactionStats.count++;
         this._compactionStats.totalSaved += saved;
@@ -1317,8 +1415,6 @@ export class Agent {
                         tokensBefore: preparation.tokensBefore,
                         tokensAfter,
                         saved,
-                        grossSaved,
-                        compactCost,
                         pct,
                         isLongSession,
                     },
@@ -1357,7 +1453,7 @@ export class Agent {
             });
         }
         log(true, `over-threshold (${tokens} >= ${minMeaningfulTokens})`, { tokens, thresholdPct, minMeaningfulTokens });
-        await this.compactForContext(provider, system, contextWindow, signal, this.getCompactionSettings(contextWindow), true).catch((err) => console.warn("[compact] failed:", err?.message));
+        await this.compactForContext(provider, system, contextWindow, signal, this.getCompactionSettings(contextWindow), true).catch((err) => logger.warn("orchestrator", "compaction failed", { error: err }));
     }
     // ========================================================================
     // Council system — delegated to CouncilManager (Phase 12.1-02)
@@ -1383,23 +1479,67 @@ export class Agent {
         const councilStats = { calls: 0, startMs: Date.now(), phases: [] };
         const llm = createCouncilLLM(this.bash, this.mode, this.session?.id, councilStats);
         const processMessageFn = (message) => this.processMessage(message, options?.observer);
-        const gen = runCouncil(topic, this.modelId, this.messages, this.session?.id, llm, this.councilManager.createQuestionResponder(), this.councilManager.createPreflightResponder(), processMessageFn, {
-            skipClarification: options?.skipClarification,
-            userModelMessage: options?.userModelMessage,
-            cwd: this.bash.getCwd(),
-            councilStats, // NEW — share orchestrator's stats object with runCouncil (Phase 14 CQ-01)
-        });
-        let result;
-        do {
-            result = await gen.next();
-            if (!result.done && result.value) {
-                yield result.value;
+        // Ensure a turn-scoped AbortController exists so Esc → agent.abort() →
+        // this.abortController.abort() actually cancels the council. Two entry points
+        // reach here: the auto-council path runs INSIDE processMessage, which already
+        // set this.abortController; the /council SLASH path calls runCouncilV2
+        // directly with NONE set — so before this guard, pressing Esc during an
+        // explicit /council run was a no-op (abort() hit a null controller) and the
+        // multi-minute debate ran to completion regardless. Create one when absent
+        // so the user-abort signal threads into every council generate/debate/
+        // research call for BOTH entry points. Only tear down a controller we own.
+        const ownsController = !this.abortController;
+        if (ownsController) {
+            this.abortController = new AbortController();
+        }
+        const signal = this.abortController?.signal;
+        // B1: Resolve a run directory so runCouncil persists decisions.lock.md after
+        // synthesis. The auto-council/sprint paths get a runDir from their own flow
+        // wiring, but the explicit /council SLASH path never did — so its outcome was
+        // never written to disk (no audit trail, nothing for a later /ideal to read).
+        // Reuse the session's active flow run; create one if the session never booted
+        // a flow. Fail-open: a runDir-resolution error must not block the council.
+        let runDir;
+        try {
+            const nodePath = await import("node:path");
+            const flowDir = await ensureFlowDir(this.bash.getCwd());
+            let runId = this._activeRunId ?? (await getActiveRunId(flowDir));
+            if (!runId) {
+                runId = (await createRun(flowDir)).id;
+                await setActiveRunId(flowDir, runId);
+                this._activeRunId = runId;
+            }
+            runDir = nodePath.join(flowDir, "runs", runId);
+        }
+        catch (err) {
+            logger.error("router", "runDir resolution failed (decisions.lock will be skipped)", { error: err });
+        }
+        try {
+            const gen = runCouncil(topic, this.modelId, this.messages, this.session?.id, llm, this.councilManager.createQuestionResponder(), this.councilManager.createPreflightResponder(), processMessageFn, {
+                skipClarification: options?.skipClarification,
+                userModelMessage: options?.userModelMessage,
+                cwd: this.bash.getCwd(),
+                councilStats, // NEW — share orchestrator's stats object with runCouncil (Phase 14 CQ-01)
+                signal,
+                runDir, // B1 — persist decisions.lock.md for the /council slash path
+            });
+            let result;
+            do {
+                result = await gen.next();
+                if (!result.done && result.value) {
+                    yield result.value;
+                }
+            } while (!result.done);
+            const synthesis = result.value;
+            this.councilManager.setLastSynthesis(synthesis);
+            if (options?.userModelMessage && synthesis) {
+                this.appendCompletedTurn(options.userModelMessage, [{ role: "assistant", content: synthesis }]);
+            }
+        }
+        finally {
+            if (ownsController && this.abortController?.signal === signal) {
+                this.abortController = null;
             }
-        } while (!result.done);
-        const synthesis = result.value;
-        this.councilManager.setLastSynthesis(synthesis);
-        if (options?.userModelMessage && synthesis) {
-            this.appendCompletedTurn(options.userModelMessage, [{ role: "assistant", content: synthesis }]);
         }
     }
     // ========================================================================
@@ -1904,6 +2044,9 @@ export class Agent {
             get maxToolRounds() {
                 return self.maxToolRounds;
             },
+            get hardMaxToolRounds() {
+                return self.hardMaxToolRounds;
+            },
             get maxTokens() {
                 return self.maxTokens;
             },
@@ -1930,12 +2073,27 @@ export class Agent {
             runDelegation: (request, signal) => self.runDelegation(request, signal),
             readDelegation: (id) => self.readDelegation(id),
             listDelegations: () => self.listDelegations(),
+            killDelegation: (id) => self.killDelegation(id),
             executeBatchToolCall: (tools, toolCall, messages, signal) => self.executeBatchToolCall(tools, toolCall, messages, signal),
             appendCompletedTurn: (user, asst) => self.appendCompletedTurn(user, asst),
             discardAbortedTurn: (user) => self.discardAbortedTurn(user),
             recordUsage: (usage, source, model, shape) => self.recordUsage(usage, source, model, shape),
         };
     }
+    appendMidTurnMessages(newMessages) {
+        if (newMessages.length === 0)
+            return;
+        if (!this.sessionStore || !this.session) {
+            this.messages.push(...newMessages);
+            this.messageSeqs.push(...newMessages.map(() => null));
+            return;
+        }
+        const insertedSeqs = appendMessages(this.session.id, newMessages);
+        this.messages.push(...newMessages);
+        this.messageSeqs.push(...insertedSeqs);
+        this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
+        this.session = this.sessionStore.getRequiredSession(this.session.id);
+    }
     appendCompletedTurn(userMessage, newMessages) {
         if (newMessages.length === 0)
             return;
@@ -1981,13 +2139,257 @@ export class Agent {
     fireHook(input, signal) {
         return executeEventHooks(input, this.bash.getCwd(), signal);
     }
+    estimateConversationChars() {
+        let count = 0;
+        for (const m of this.messages) {
+            if (typeof m.content === "string") {
+                count += m.content.length;
+            }
+            else if (Array.isArray(m.content)) {
+                for (const p of m.content) {
+                    if (p.type === "text" && p.text) {
+                        count += p.text.length;
+                    }
+                }
+            }
+        }
+        return count;
+    }
     // ========================================================================
     // processMessage — main streaming turn loop (PIL enrichment, routing, LLM
     // stream, tool execution, compaction, hooks, observer notifications)
     // ========================================================================
     async *processMessage(userMessage, observer, images) {
-        const processor = new MessageProcessor(this._buildMessageProcessorDeps());
-        yield* processor.run(userMessage, observer, images);
+        const threshold = Number(process.env.MUONROI_SILENT_ROTATION_THRESHOLD) || 80000;
+        const currentChars = this.estimateConversationChars();
+        logger.debug("orchestrator", "Checking silent session rotation threshold", { currentChars, threshold });
+        // 1. Run classifier to decide execution route
+        let routeAction = "DIRECT_ANSWER";
+        try {
+            const { classifySubSessionAction } = await import("../pil/llm-classify.js");
+            const routeResult = await classifySubSessionAction(this.requireProvider(), this.modelId, userMessage);
+            if (routeResult) {
+                routeAction = routeResult.action;
+                logger.info("orchestrator", "Routing action selected for user message", {
+                    action: routeAction,
+                    confidence: routeResult.confidence,
+                    reason: routeResult.reason,
+                });
+            }
+        }
+        catch (err) {
+            logger.error("orchestrator", "Routing classification failed, falling back to DIRECT_ANSWER", { error: err });
+        }
+        const shouldRotate = currentChars > threshold || routeAction === "ROTATE_SESSION";
+        if (shouldRotate && this.session && this.sessionStore) {
+            logger.info("orchestrator", "Triggering silent session rotation", {
+                parentSessionId: this.session.id,
+                currentChars,
+            });
+            yield { type: "content", content: "\n⋯ Xoay vòng session ngầm để tối ưu hóa context (Anti-Mù active)...\n" };
+            const parentSessionId = this.session.id;
+            try {
+                const path = await import("node:path");
+                const flowDir = path.join(this.bash.getCwd(), ".muonroi-flow");
+                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 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);
+                const summaryMessage = createCompactionSummaryMessage(cr.summary);
+                const nextSeq = getNextMessageSequence(newSession.id);
+                appendCompaction(newSession.id, nextSeq, cr.summary, cr.tokensBeforeCompress);
+                this.session = this.sessionStore.getRequiredSession(newSession.id);
+                this.messages = [summaryMessage];
+                this.messageSeqs = [null];
+                this.sessionStore.touchSession(newSession.id, this.bash.getCwd());
+                logger.info("orchestrator", "Silent session rotation completed successfully", {
+                    parentSessionId,
+                    newSessionId: newSession.id,
+                    summaryLength: cr.summary.length,
+                    tokensBeforeCompress: cr.tokensBeforeCompress,
+                });
+            }
+            catch (err) {
+                logger.error("orchestrator", "silent session rotation failed", { error: err });
+            }
+        }
+        let isSubSessionForked = false;
+        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" };
+            parentSessionId = this.session.id;
+            try {
+                const { loadLatestCompaction, getNextMessageSequence, appendCompaction, loadTranscriptState } = 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
+                const activeSubSession = db
+                    .prepare("SELECT id, updated_at FROM sessions WHERE parent_session_id = ? AND status = 'active' ORDER BY updated_at DESC LIMIT 1")
+                    .get(parentSessionId);
+                let shouldResume = false;
+                if (activeSubSession) {
+                    const updatedAt = new Date(activeSubSession.updated_at).getTime();
+                    const now = Date.now();
+                    const diffMins = (now - updatedAt) / (60 * 1000);
+                    if (diffMins > 15) {
+                        // Stale: mark as abandoned
+                        db.prepare("UPDATE sessions SET status = 'abandoned', updated_at = ? WHERE id = ?").run(new Date().toISOString(), activeSubSession.id);
+                        logger.info("orchestrator", "Stale sub-session found, marked as abandoned", {
+                            parentSessionId,
+                            subSessionId: activeSubSession.id,
+                            diffMins,
+                        });
+                    }
+                    else {
+                        shouldResume = true;
+                        subSessionId = activeSubSession.id;
+                    }
+                }
+                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" };
+                    this.session = this.sessionStore.getRequiredSession(subSessionId);
+                    const childState = loadTranscriptState(subSessionId);
+                    this.messages = childState.messages;
+                    this.messageSeqs = childState.seqs;
+                    this.sessionStore.touchSession(subSessionId, this.bash.getCwd());
+                    isSubSessionForked = true;
+                    logger.info("orchestrator", "Resumed child sub-session successfully", {
+                        parentSessionId,
+                        subSessionId,
+                    });
+                }
+                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);
+                    subSessionId = newSession.id;
+                    let seedMessages = [];
+                    let seedSeqs = [];
+                    if (latest?.summary) {
+                        const summaryMsg = createCompactionSummaryMessage(latest.summary);
+                        seedMessages = [summaryMsg];
+                        seedSeqs = [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",
+                        content: `You are executing a sub-task delegated by the Main Session in an isolated, temporary Sub-Session.\n` +
+                            `Your goal is to satisfy the user's request: "${userMessage}"\n\n` +
+                            `Your Operating Boundaries & Rules:\n` +
+                            `1. You have full access to tools (bash, edit_file, read_file, grep, etc.). Execute them as needed to build, debug, and verify the work.\n` +
+                            `2. Stay strictly focused on completing the request. Do not engage in social chat or pleasantries.\n` +
+                            `3. Once the goal is achieved and verified, you MUST return your final response using the 'respond_general' (or final answer) tool.\n` +
+                            `4. Your final response MUST contain a structured summary (Key Changes, Verification Details, Result Summary).\n` +
+                            `5. All intermediate tool calls, raw tool outputs, and diagnostic traces will remain isolated inside this sub-session and will not bloat the parent session.`,
+                    };
+                    seedMessages.push(overlayMessage);
+                    seedSeqs.push(null);
+                    this.session = this.sessionStore.getRequiredSession(subSessionId);
+                    this.messages = seedMessages;
+                    this.messageSeqs = seedSeqs;
+                    this.sessionStore.touchSession(subSessionId, this.bash.getCwd());
+                    isSubSessionForked = true;
+                    logger.info("orchestrator", "Forked child sub-session successfully", {
+                        parentSessionId,
+                        subSessionId,
+                    });
+                }
+            }
+            catch (err) {
+                logger.error("orchestrator", "Forking child sub-session failed, falling back to main session", { error: err });
+            }
+        }
+        let processor = new MessageProcessor(this._buildMessageProcessorDeps());
+        const autoCommitOn = isAutoCommitEnabled();
+        const cwd = this.bash.getCwd();
+        const dirtyBefore = autoCommitOn ? await snapshotDirtyPaths(cwd) : new Set();
+        try {
+            let attempts = 0;
+            const maxAttempts = 3;
+            const messagesSnapshot = [...this.messages];
+            const seqsSnapshot = [...this.messageSeqs];
+            while (attempts < maxAttempts) {
+                try {
+                    attempts++;
+                    yield* processor.run(userMessage, observer, images);
+                    break;
+                }
+                catch (err) {
+                    if (isSubSessionForked && isTransientError(err) && attempts < maxAttempts && subSessionId) {
+                        logger.warn("orchestrator", "Transient error in sub-session, retrying", {
+                            attempt: attempts,
+                            error: err,
+                        });
+                        yield {
+                            type: "content",
+                            content: `\n⚠️ Có lỗi mạng hoặc rate limit xảy ra trong sub-session (lần thử ${attempts}/${maxAttempts}). Đang thử lại...\n`,
+                        };
+                        this.messages = [...messagesSnapshot];
+                        this.messageSeqs = [...seqsSnapshot];
+                        processor = new MessageProcessor(this._buildMessageProcessorDeps());
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            if (autoCommitOn) {
+                const auto = await maybeAutoCommitTurn({ cwd, dirtyBefore, userMessage }).catch((err) => {
+                    logger.error("orchestrator", "auto-commit unexpected failure", { error: err });
+                    return { committed: false };
+                });
+                if (auto.committed) {
+                    yield {
+                        type: "content",
+                        content: `\n✓ Auto-committed ${auto.fileCount} file(s) → ${auto.sha} (${AUTO_COMMIT_ATTRIBUTION})\n`,
+                    };
+                }
+            }
+        }
+        finally {
+            if (isSubSessionForked && parentSessionId && this.sessionStore) {
+                try {
+                    const finalMessages = salvageSubSessionOutput(this.messages);
+                    // Restore parent session
+                    this.session = this.sessionStore.getRequiredSession(parentSessionId);
+                    const { loadTranscriptState } = await import("../storage/transcript.js");
+                    const parentState = loadTranscriptState(parentSessionId);
+                    this.messages = parentState.messages;
+                    this.messageSeqs = parentState.seqs;
+                    const userModelMessage = {
+                        role: "user",
+                        content: userMessage,
+                    };
+                    if (finalMessages.length > 0) {
+                        this.appendCompletedTurn(userModelMessage, finalMessages);
+                        logger.info("orchestrator", "Absorbed sub-session outcome into parent session", {
+                            parentSessionId,
+                            subSessionId,
+                            absorbedMessagesCount: finalMessages.length,
+                        });
+                    }
+                    else {
+                        logger.warn("orchestrator", "No assistant messages found to absorb from sub-session", {
+                            parentSessionId,
+                            subSessionId,
+                        });
+                    }
+                }
+                catch (err) {
+                    logger.error("orchestrator", "Failed to absorb sub-session final summary", { error: err });
+                }
+            }
+        }
     }
     /**
      * Build the DI surface MessageProcessor (Phase 12.4) needs to reach back
@@ -2026,6 +2428,9 @@ export class Agent {
             get maxToolRounds() {
                 return self.maxToolRounds;
             },
+            get hardMaxToolRounds() {
+                return self.hardMaxToolRounds;
+            },
             get batchApi() {
                 return self.batchApi;
             },
@@ -2120,6 +2525,39 @@ export class Agent {
             },
             requireProvider: () => self.requireProvider(),
             emitSubagentStatus: (s) => self.emitSubagentStatus(s),
+            consultParentSession: async (question) => {
+                if (!self.session) {
+                    return "No active session found to consult.";
+                }
+                const { getDatabase } = await import("../storage/db.js");
+                const db = getDatabase();
+                const row = db.prepare("SELECT parent_session_id FROM sessions WHERE id = ?").get(self.session.id);
+                if (!row?.parent_session_id) {
+                    return "No parent session found to consult.";
+                }
+                const parentSessionId = row.parent_session_id;
+                const { loadTranscriptState } = await import("../storage/transcript.js");
+                const parentState = loadTranscriptState(parentSessionId);
+                const { serializeConversation } = await import("./compaction.js");
+                const serializedParent = serializeConversation(parentState.messages);
+                const systemPrompt = `You are the Main Session of an AI coding assistant.\n` +
+                    `A child sub-session has been spawned to execute a sub-task and is requesting your advice/guidance.\n` +
+                    `Below is your conversation history (Main Session Context):\n\n` +
+                    `${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 result = await generateText({
+                    model: runtime.model,
+                    system: systemPrompt,
+                    prompt: `Child Sub-session is stuck. Question:\n${question}`,
+                    temperature: 0.2,
+                    ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
+                });
+                return result.text;
+            },
             fireHook: (input, signal) => self.fireHook(input, signal),
             consumeBackgroundNotifications: () => self.consumeBackgroundNotifications(),
             initOAuthProvider: () => self._initOAuthProvider(),
@@ -2133,7 +2571,9 @@ export class Agent {
             runDelegation: (request, signal) => self.runDelegation(request, signal),
             readDelegation: (id) => self.readDelegation(id),
             listDelegations: () => self.listDelegations(),
+            killDelegation: (id) => self.killDelegation(id),
             drainSteerMessages: () => self.steerDrain?.() ?? [],
+            appendMidTurnMessages: (msgs) => self.appendMidTurnMessages(msgs),
             appendCompletedTurn: (user, asst) => self.appendCompletedTurn(user, asst),
             discardAbortedTurn: (user) => self.discardAbortedTurn(user),
             recordUsage: (usage, source, model, shape) => self.recordUsage(usage, source, model, shape),
@@ -2146,10 +2586,24 @@ export class Agent {
                     return await h(info);
                 }
                 catch (err) {
-                    console.error(`[Agent] askToolLoopContinue crashed: ${err?.message ?? err}`);
+                    logger.error("orchestrator", "askToolLoopContinue crashed", { error: err });
                     return "stop";
                 }
             },
+            askSafetyOverride: async (info) => {
+                const h = self._safetyOverrideHandler;
+                if (!h) {
+                    logger.warn("orchestrator", `askSafetyOverride called but no handler registered — blocking ${info.kind}: ${info.reason}`);
+                    return { action: "block" };
+                }
+                try {
+                    return await h(info);
+                }
+                catch (err) {
+                    logger.error("orchestrator", "askSafetyOverride crashed", { error: err });
+                    return { action: "block" };
+                }
+            },
             runCouncilV2: (msg, opts) => self.runCouncilV2(msg, opts),
             processMessage: (msg, obs, imgs) => self.processMessage(msg, obs, imgs),
             processMessageBatchTurn: (args) => self.processMessageBatchTurn(args),
@@ -2322,4 +2776,37 @@ export class Agent {
         }
     }
 }
+function isTransientError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const msg = err.message.toLowerCase();
+    return (msg.includes("fetch failed") ||
+        msg.includes("rate limit") ||
+        msg.includes("429") ||
+        msg.includes("503") ||
+        msg.includes("502") ||
+        msg.includes("network") ||
+        msg.includes("timeout") ||
+        msg.includes("econnreset") ||
+        msg.includes("econnrefused"));
+}
+function salvageSubSessionOutput(messages) {
+    let lastAsstIdx = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "assistant") {
+            lastAsstIdx = i;
+            break;
+        }
+    }
+    const finalMessages = [];
+    if (lastAsstIdx >= 0) {
+        finalMessages.push(messages[lastAsstIdx]);
+        for (let i = lastAsstIdx + 1; i < messages.length; i++) {
+            if (messages[i].role === "tool") {
+                finalMessages.push(messages[i]);
+            }
+        }
+    }
+    return finalMessages;
+}
 //# sourceMappingURL=orchestrator.js.map