muonroi-cli 1.8.0 → 1.8.3

package/dist/src/orchestrator/orchestrator.js

@@ -23,7 +23,8 @@ 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 { getAutoCompactThresholdPct, getCouncilRounds, getCurrentModel, getCurrentShellSettings, getModeSpecificModel, getRoleModel, getRoleModels, isAutoCompactAfterTurnEnabled, isCouncilMultiProviderPreferred, isProviderDisabled, } from "../utils/settings.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";
@@ -38,7 +39,7 @@ 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";
@@ -136,6 +137,7 @@ export class Agent {
     /** UI-registered live-queue steer drain; see Agent.setSteerDrain. */
     steerDrain = null;
     maxToolRounds;
+    hardMaxToolRounds;
     mode = "agent";
     modelId;
     maxTokens;
@@ -240,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;
@@ -267,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) {
@@ -424,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();
     }
@@ -1212,6 +1221,20 @@ export class Agent {
         if (this._compactionStats.count >= 2) {
             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),
             keepRecentTokens,
@@ -1276,7 +1299,23 @@ export class Agent {
         const keptSeqs = this.messageSeqs.slice(preparation.firstKeptIndex);
         const firstKeptSeq = keptSeqs.find((seq) => seq !== null) ?? getNextMessageSequence(this.session.id);
         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).
@@ -1414,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)
@@ -1473,7 +1512,7 @@ export class Agent {
             runDir = nodePath.join(flowDir, "runs", runId);
         }
         catch (err) {
-            console.error(`[council] runDir resolution failed (decisions.lock will be skipped): ${err?.message}`);
+            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, {
@@ -2005,6 +2044,9 @@ export class Agent {
             get maxToolRounds() {
                 return self.maxToolRounds;
             },
+            get hardMaxToolRounds() {
+                return self.hardMaxToolRounds;
+            },
             get maxTokens() {
                 return self.maxTokens;
             },
@@ -2097,32 +2139,264 @@ 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());
-        // Deterministic "task done -> commit" (auto-commit): snapshot the dirty set
-        // before the turn so we can commit ONLY the files the agent changes during it
-        // (and never the user's pre-existing work-in-progress). Gated off under tests
-        // and via MUONROI_AUTO_COMMIT=0.
+        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";
+        const isMockMode = process.argv.includes("--mock-llm") ||
+            !!globalThis.__muonroiMockModel ||
+            process.env.NODE_ENV === "test";
+        const forceClassify = process.env.MUONROI_FORCE_ROUTING_CLASSIFY === "1";
+        if (isMockMode && !forceClassify) {
+            logger.debug("orchestrator", "Skipping sub-session routing classification in mock/test mode");
+        }
+        else {
+            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();
-        yield* processor.run(userMessage, observer, images);
-        // Reached only when the turn completed normally (an abort/throw propagates
-        // through yield* and skips this) — exactly when committing is appropriate.
-        if (autoCommitOn) {
-            const auto = await maybeAutoCommitTurn({ cwd, dirtyBefore, userMessage }).catch((err) => {
-                console.error(`[auto-commit] unexpected failure: ${err?.message}`);
-                return { committed: false };
-            });
-            if (auto.committed) {
-                yield {
-                    type: "content",
-                    content: `\n✓ Auto-committed ${auto.fileCount} file(s) → ${auto.sha} (${AUTO_COMMIT_ATTRIBUTION})\n`,
-                };
+        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 });
+                }
             }
         }
     }
@@ -2163,6 +2437,9 @@ export class Agent {
             get maxToolRounds() {
                 return self.maxToolRounds;
             },
+            get hardMaxToolRounds() {
+                return self.hardMaxToolRounds;
+            },
             get batchApi() {
                 return self.batchApi;
             },
@@ -2257,6 +2534,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(),
@@ -2285,21 +2595,21 @@ 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) {
-                    console.warn(`[Agent] askSafetyOverride called but no handler registered — blocking ${info.kind}: ${info.reason}`);
+                    logger.warn("orchestrator", `askSafetyOverride called but no handler registered — blocking ${info.kind}: ${info.reason}`);
                     return { action: "block" };
                 }
                 try {
                     return await h(info);
                 }
                 catch (err) {
-                    console.error(`[Agent] askSafetyOverride crashed: ${err?.message ?? err}`);
+                    logger.error("orchestrator", "askSafetyOverride crashed", { error: err });
                     return { action: "block" };
                 }
             },
@@ -2475,4 +2785,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

package/dist/src/orchestrator/pending-calls.js

@@ -22,6 +22,7 @@ import * as crypto from "node:crypto";
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import { getSessionDir } from "../storage/session-dir.js";
+import { logger } from "../utils/logger.js";
 // ─── stableCallId ─────────────────────────────────────────────────────────────
 /**
  * Derives a deterministic call_id from (turnId, toolName, input).
@@ -160,7 +161,7 @@ export function createPendingCallsLog(sessionId) {
                         void finalExists;
                     }
                     catch (err) {
-                        console.warn(`[muonroi-cli] reconcile: could not clean staged path ${tmp}: ${err.message}`);
+                        logger.warn("orchestrator", `reconcile: could not clean staged path ${tmp}`, { error: err });
                     }
                 }
                 // Mark the entry as abandoned in the log.

package/dist/src/orchestrator/preprocessor.js

@@ -1,5 +1,6 @@
 import { runPipeline } from "../pil/pipeline.js";
 import { getSessionLastTask, recordSessionLastTask, resolveCeiling } from "./scope-ceiling.js";
+import { logger } from "../utils/logger.js";
 export async function* prepareTurnContext(deps, userMessage, _budgetOverride) {
     // PIL: enrich prompt before pushing to messages (D-01, D-03, D-04)
     // Promise.race timeout of 200ms is inside runPipeline — fail-open guaranteed
@@ -31,7 +32,7 @@ export async function* prepareTurnContext(deps, userMessage, _budgetOverride) {
                 llmFallback = createLlmClassifier(deps.requireProvider(), deps.modelId);
             }
             catch (err) {
-                console.error(`[pil] LLM fallback wiring failed: ${err?.message}`);
+                logger.error("pil", "LLM fallback wiring failed", { error: err });
             }
             // Model-driven clarification proposer (for discovery interview).
             // The actual task model (via the same provider + modelId) generates the
@@ -42,7 +43,7 @@ export async function* prepareTurnContext(deps, userMessage, _budgetOverride) {
                 clarificationProposer = createModelClarificationProposer(deps.requireProvider(), deps.modelId);
             }
             catch (err) {
-                console.error(`[pil] clarification proposer wiring failed: ${err?.message}`);
+                logger.error("pil", "clarification proposer wiring failed", { error: err });
             }
             pilCtxResolved = await runPipeline(userMessage, {
                 resumeDigest: deps.getResumeDigest(),

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

@@ -1,6 +1,8 @@
 import type { AgentMode, TaskRequest } from "../types/index.js";
 import { type CustomSubagentConfig, type SandboxMode, type SandboxSettings } from "../utils/settings.js";
 export declare const MAX_TOOL_ROUNDS: number;
+export declare const HARD_MAX_TOOL_ROUNDS: number;
+export declare const MAX_LLM_CALLS_PER_TURN: number;
 export declare const VISION_MODEL = "grok-4-1-fast-reasoning";
 export declare const COMPUTER_MODEL = "grok-4.20-0309-reasoning";
 /**
@@ -61,6 +63,12 @@ export interface SystemPromptOptions {
      * and can't run the full toolset anyway. Cuts ~6K tokens per sub-agent turn.
      */
     subAgent?: boolean;
+    /**
+     * When true (tool-turn, i.e. second+ LLM call in the same user-turn tool
+     * loop), skip native-capabilities and skills sections that were already
+     * shown in the first call. Cuts ~4K tokens per tool round-trip.
+     */
+    toolTurn?: boolean;
 }
 /**
  * Render the LIVE per-turn MCP tool roster as a system-prompt block.