muonroi-cli 1.8.0 → 1.8.3

package/dist/src/orchestrator/subagent-compactor.js

@@ -326,22 +326,25 @@ function rewriteOlderToolMessage(msg, previewChars, label, keepToolIds, persistA
 export function compactSubAgentMessages(messages, opts = {}) {
     const resolved = resolveOpts(opts);
     const { outputPreviewChars, label, envelopeChars } = resolved;
-    // F2 — threshold check uses TRUE prompt size (messages + system + tools).
-    // The envelope (system prompt + JSON-schema for every tool) is re-sent on
-    // every step and was previously invisible to the compactor, so a session
-    // with 20-50K of fixed overhead would never trip the messages-only check.
+    // Step 4: Hard-limit message history sent to the model to prevent token bloating
+    // When input (messages + envelope) exceeds 50K characters and messages array is > 30,
+    // we slice the history to keep at most 30 messages (preserving system and user start).
+    let processedMessages = messages;
     const messagesTotal = cumulativeMessageChars(messages);
     const total = messagesTotal + envelopeChars;
-    // G1 + G2 — derive effective threshold and keepLastTurns from context
-    // window utilization. Falls back to static char threshold + keepLast
-    // when no contextWindowTokens supplied (preserves old behaviour).
-    const { effectiveThresholdChars, effectiveKeepLastTurns } = computeDynamicParams(total, resolved);
+    if (total > 50_000 && messages.length > 30) {
+        processedMessages = sliceMessageHistory(messages, 30);
+    }
+    // Calculate effective thresholds and keep last turns using the processed messages
+    const processedMessagesTotal = cumulativeMessageChars(processedMessages);
+    const processedTotal = processedMessagesTotal + envelopeChars;
+    const { effectiveThresholdChars, effectiveKeepLastTurns } = computeDynamicParams(processedTotal, resolved);
     // No-op: return the input BY REFERENCE (contract above) so `compacted === input`.
-    if (total < effectiveThresholdChars)
-        return messages;
-    const keepFrom = findKeepFromIndex(messages, effectiveKeepLastTurns);
+    if (processedTotal < effectiveThresholdChars)
+        return processedMessages;
+    const keepFrom = findKeepFromIndex(processedMessages, effectiveKeepLastTurns);
     if (keepFrom <= 0)
-        return messages;
+        return processedMessages;
     // Walk older messages; rewrite fresh tool results into stubs, super-shrink
     // already-stubbed results (F1), and strip args off older assistant
     // tool-call shells (F1). The 1:1 assistant↔tool pairing required by the AI
@@ -349,8 +352,8 @@ export function compactSubAgentMessages(messages, opts = {}) {
     // structure or count.
     let firstUserSeen = false;
     const out = [];
-    for (let i = 0; i < messages.length; i++) {
-        const msg = messages[i];
+    for (let i = 0; i < processedMessages.length; i++) {
+        const msg = processedMessages[i];
         if (i >= keepFrom) {
             out.push(msg);
             continue;
@@ -497,4 +500,52 @@ export function applyAnthropicPromptCaching(messages, modelId) {
     newMessages[lastIndex] = lastMsg;
     return newMessages;
 }
+/**
+ * Safely slice message history to keep at most `maxMessages` messages.
+ * Preserves the system message(s) at the front and ensures that the slice
+ * starts with a "user" message and does not split assistant tool calls and
+ * corresponding tool results.
+ */
+export function sliceMessageHistory(messages, maxMessages = 30) {
+    if (messages.length <= maxMessages)
+        return messages;
+    // Find all user message indices (excluding system messages)
+    const userIndices = [];
+    for (let idx = 0; idx < messages.length; idx++) {
+        if (messages[idx]?.role === "user") {
+            userIndices.push(idx);
+        }
+    }
+    if (userIndices.length === 0) {
+        return messages;
+    }
+    // Group messages into turns.
+    // Each turn is a range [start, end] inclusive.
+    const turns = [];
+    for (let idx = 0; idx < userIndices.length; idx++) {
+        const start = userIndices[idx];
+        const end = idx + 1 < userIndices.length ? userIndices[idx + 1] - 1 : messages.length - 1;
+        turns.push({ start, end });
+    }
+    // Accumulate turns from the end, up to maxMessages
+    let keptMessagesCount = 0;
+    let keepFromIndex = -1;
+    for (let idx = turns.length - 1; idx >= 0; idx--) {
+        const turn = turns[idx];
+        const turnLength = turn.end - turn.start + 1;
+        if (keptMessagesCount === 0 || keptMessagesCount + turnLength <= maxMessages) {
+            keptMessagesCount += turnLength;
+            keepFromIndex = turn.start;
+        }
+        else {
+            break;
+        }
+    }
+    if (keepFromIndex === -1) {
+        return messages;
+    }
+    const kept = messages.slice(keepFromIndex);
+    const systemMessages = messages.filter((m) => m.role === "system");
+    return [...systemMessages, ...kept];
+}
 //# sourceMappingURL=subagent-compactor.js.map

package/dist/src/orchestrator/tool-engine.d.ts

@@ -21,6 +21,7 @@ import type { TurnRunnerDepsBase } from "./turn-runner-deps.js";
  * subsequent turns). Method callbacks delegate to Agent private methods.
  */
 export interface MessageProcessorDeps extends TurnRunnerDepsBase {
+    readonly isSubSession?: boolean;
     /** Live messageSeqs array (mutated by push; parallel to messages). */
     readonly messageSeqs: Array<number | null>;
     /** Session bookkeeping. */
@@ -75,6 +76,7 @@ export interface MessageProcessorDeps extends TurnRunnerDepsBase {
     setMessages(messages: ModelMessage[]): void;
     requireProvider(): LegacyProvider;
     emitSubagentStatus(status: SubagentStatus | null): void;
+    consultParentSession?: (question: string) => Promise<string>;
     fireHook(input: unknown, signal?: AbortSignal): Promise<{
         blocked: boolean;
         blockingErrors: Array<{

package/dist/src/orchestrator/tool-engine.js

@@ -76,6 +76,7 @@ import { visionToolsNeeded } from "../tools/vision-gate.js";
 import { recordTurnTrace } from "../ui/slash/debug.js";
 import { statusBarStore } from "../ui/status-bar/store.js";
 import { appendDecisionLog } from "../usage/decision-log.js";
+import { logger } from "../utils/logger.js";
 import { openUrl } from "../utils/open-url.js";
 import { appendAudit, toolNeedsApproval } from "../utils/permission-mode.js";
 import { getAutoCouncilConfidence, getAutoCouncilMinRoles, getProviderStallRetries, getProviderStallTimeoutMs, getRoleModels, getSteerInjectionEnabled, getTopLevelCompactKeepLast, getTopLevelCompactThresholdChars, getTopLevelToolBudgetChars, isAutoCouncilEnabled, loadMcpServers, } from "../utils/settings.js";
@@ -86,7 +87,7 @@ import { humanizeApiError, isAuthenticationError, isContextLimitError, summarize
 import { buildGroundingFootnote, findUnverifiedClaims } from "./grounding-check.js";
 import { buildInterruptedTurnNote } from "./interrupted-turn.js";
 import { stableCallId } from "./pending-calls.js";
-import { buildMcpCapabilityBlock } from "./prompts.js";
+import { buildMcpCapabilityBlock, MAX_LLM_CALLS_PER_TURN, } from "./prompts.js";
 import { extractProviderOptionsShape } from "./provider-options-shape.js";
 import { wrapToolSetWithReadBudget } from "./read-path-budget.js";
 import { containsEncryptedReasoning, sanitizeModelMessages } from "./reasoning.js";
@@ -194,7 +195,7 @@ export function rewriteSafetyApprovedToolResults(messages) {
 }
 import { stripDsmlMarkup } from "./message-processor.js";
 export async function* executeToolEngine(args) {
-    let { deps, stepRouterPhase, phase2Runtime, runtime, modelInfo, _debugSteps, _ceilingHit, userMessage, pilCtx, turnModelId, turnProvider, _stepCeiling, userModelMessage, userEnrichedMessage, signal, observer, taskHash, provider, system, routerStore, attemptedOverflowRecovery, patternLoopForceHalt, userWriteAheadSeq, streamRetryCount, MAX_STREAM_RETRIES, subagents, systemParts, playwrightGuidance, _hasResponseTools, _pilResponseTools, patternLoopInjectCount, agentLoopDecisionCount, MAX_AGENT_LOOP_DECISIONS, _naturalCeiling, _ceilingTaskType, _ceilingSize, textToolReSteerCount, MAX_TEXT_TOOL_RESTEER, turnStartMs, _debugOn, _debugTurnId, _pilEnrichmentDeltaSnapshot, isChitchat, } = args;
+    let { deps, stepRouterPhase, phase2Runtime, runtime, modelInfo, _debugSteps, _ceilingHit, userMessage, pilCtx, turnModelId, turnProvider, _stepCeiling, userModelMessage, userEnrichedMessage, signal, observer, taskHash, provider, system, routerStore, attemptedOverflowRecovery, patternLoopForceHalt, userWriteAheadSeq, streamRetryCount, MAX_STREAM_RETRIES, subagents, systemParts, toolTurnSystem, playwrightGuidance, _hasResponseTools, _pilResponseTools, patternLoopInjectCount, agentLoopDecisionCount, MAX_AGENT_LOOP_DECISIONS, _naturalCeiling, _ceilingTaskType, _ceilingSize, textToolReSteerCount, MAX_TEXT_TOOL_RESTEER, turnStartMs, _debugOn, _debugTurnId, _pilEnrichmentDeltaSnapshot, isChitchat, } = args;
     // Put all extracted code here:
     let stallTriggered = false;
     // Time-to-first-byte stall RE-PROMPT: some providers (observed:
@@ -219,6 +220,11 @@ export async function* executeToolEngine(args) {
     // Bounded by the same maxStallRetries cap so a persistently-dead provider
     // still falls through to the partial-answer rescue.
     let midLoopStallRetryCount = 0;
+    // F3c — per-turn LLM call cap: counts every streamText() invocation
+    // (tool round-trip, stall re-prompt, stream retry) and hard-aborts
+    // the turn when exceeded.  Prevents the session 526a83cf22df pattern
+    // where 3 user messages burnt 82% of 2.44M tokens in 36 LLM calls.
+    let llmCallsThisTurn = 0;
     // Live-queue steering: messages the user typed mid-turn are drained at a
     // prepareStep boundary and accumulated here, then re-appended (deduped) to
     // the messages returned for each subsequent step. Loop-persistent so they
@@ -395,7 +401,7 @@ export async function* executeToolEngine(args) {
                     });
                 }
                 catch (emitErr) {
-                    console.error(`[message-processor] stall-reprompt telemetry failed: ${emitErr?.message}`);
+                    logger.error("orchestrator", "stall-reprompt telemetry failed", { error: emitErr });
                 }
                 try {
                     if (deps.session) {
@@ -411,7 +417,7 @@ export async function* executeToolEngine(args) {
                     }
                 }
                 catch (logErr) {
-                    console.error(`[message-processor] stall-reprompt log failed: ${logErr?.message}`);
+                    logger.error("orchestrator", "stall-reprompt log failed", { error: logErr });
                 }
                 return backoffMs;
             };
@@ -434,11 +440,19 @@ export async function* executeToolEngine(args) {
             let _pendingStructuredResponse = null;
             let _pendingStructuredResponseLen = -1;
             try {
+                const { getDatabase } = await import("../storage/db.js");
+                const db = getDatabase();
+                const row = db.prepare("SELECT parent_session_id FROM sessions WHERE id = ?").get(deps.session.id);
+                const isSubSession = !!row?.parent_session_id;
+                let contextWindow = modelInfo?.contextWindow || 0;
+                if (isSubSession && contextWindow > 0) {
+                    contextWindow = Math.min(45000, contextWindow);
+                }
                 const settings = attemptedOverflowRecovery
-                    ? relaxCompactionSettings(deps.getCompactionSettings(modelInfo?.contextWindow))
-                    : deps.getCompactionSettings(modelInfo?.contextWindow);
-                if (modelInfo?.contextWindow) {
-                    await deps.compactForContext(provider, system, modelInfo.contextWindow, signal, settings, attemptedOverflowRecovery);
+                    ? relaxCompactionSettings(deps.getCompactionSettings(contextWindow))
+                    : deps.getCompactionSettings(contextWindow);
+                if (contextWindow) {
+                    await deps.compactForContext(provider, system, contextWindow, signal, settings, attemptedOverflowRecovery);
                 }
                 // Vision-tool gate: for vision-proxy (text-only) models the registry
                 // adds 3 image tools (~500-700 tok) on every turn. Drop them when the
@@ -457,6 +471,7 @@ export async function* executeToolEngine(args) {
                     listDelegations: () => deps.listDelegations(),
                     modelId: turnModelId,
                     includeVisionTools,
+                    consultParentSession: deps.consultParentSession,
                 });
                 // Top-level cumulative cap state. We accumulate the raw tool set
                 // (base + MCP + PIL response tools) across the assembly below,
@@ -532,7 +547,7 @@ export async function* executeToolEngine(args) {
                         });
                     }
                     catch (err) {
-                        console.error("[MCP] buildMcpToolSet failed, proceeding with builtins only", err);
+                        logger.error("mcp", "buildMcpToolSet failed, proceeding with builtins only", { error: err });
                     }
                     if (mcpBundle) {
                         closeMcp = mcpBundle.close;
@@ -596,7 +611,7 @@ export async function* executeToolEngine(args) {
                 // Apply the top-level cumulative cap once over the fully-assembled
                 // raw tool set. State is per-turn; each turn gets a fresh budget.
                 const topLevelCap = wrapToolSetWithCap(rawToolSet, {
-                    maxCumulativeChars: getTopLevelToolBudgetChars(),
+                    maxCumulativeChars: getTopLevelToolBudgetChars(deps.maxToolRounds),
                     midTierRatio: 0.5,
                     highTierRatio: 0.8,
                     label: "top-level",
@@ -669,9 +684,12 @@ export async function* executeToolEngine(args) {
                 // cheap-model cost) layered UNDER the tool-use playbook so the
                 // CRITICAL tool rules stay at the very front. Both fixed per turn, so
                 // they stay inside the cached prefix.
+                // F3c — tool-turn: use reduced system prompt (skip
+                // native-capabilities + skills already shown in first call).
+                const activeSystem = llmCallsThisTurn > 0 && toolTurnSystem ? toolTurnSystem : system;
                 const systemWithWorkbook = shouldInjectCheapModelWorkbook(runtime.modelInfo)
-                    ? injectCheapModelWorkbook(system, pilCtx.taskType)
-                    : system;
+                    ? injectCheapModelWorkbook(activeSystem, pilCtx.taskType)
+                    : activeSystem;
                 const systemWithPlaybook = shouldInjectCheapModelPlaybook(runtime.modelInfo)
                     ? injectCheapModelPlaybook(systemWithWorkbook)
                     : systemWithWorkbook;
@@ -761,6 +779,8 @@ export async function* executeToolEngine(args) {
                 // stepCountIs(maxToolRounds) fires and the user sees the TUI freeze
                 // (session 7dcf8fd7d6a4 hit exactly 100 rounds → looked like a crash).
                 let _lastFinishReason = null;
+                // F3b — track hard cap hit for visible toast after stream ends.
+                let _hardCapHit = false;
                 // Phase B4: compact older tool_result parts before each top-level
                 // step once cumulative message chars exceed the configured threshold.
                 // The compactor preserves system + first user verbatim and keeps the
@@ -864,7 +884,7 @@ export async function* executeToolEngine(args) {
                                 }
                             }
                             catch (err) {
-                                console.error(`[Agent] loop auto-decision failed: ${err?.message ?? err}`);
+                                logger.error("orchestrator", "loop auto-decision failed", { error: err });
                             }
                         }
                         return deps.askToolLoopContinue ? await deps.askToolLoopContinue(info) : "stop";
@@ -910,6 +930,14 @@ export async function* executeToolEngine(args) {
                 // _ceilingHit and _ceilingHitAtStep are kept for telemetry: a
                 // crossing event is logged for forensics, but no action is taken.
                 const dynamicStopWhen = (async (state) => {
+                    // F3b — HARD cap: absolute non-bumpable ceiling per user turn.
+                    // Fires AFTER the soft cap (maxToolRounds) has been bumped by the
+                    // user. Prevents runaway sessions (session 526a83cf22df: 16 LLM
+                    // calls for a single user message, 2.44M total input tokens).
+                    if (state.steps.length > deps.hardMaxToolRounds) {
+                        _hardCapHit = true;
+                        return true;
+                    }
                     // Terminal response tool: a `respond_*` call IS the model's final
                     // structured answer (its `execute` is identity — the payload lives
                     // in the tool-call args). `shouldHaltOnResponseTool` decides if the
@@ -1007,6 +1035,17 @@ export async function* executeToolEngine(args) {
                 const stall = createStallWatchdog(getProviderStallTimeoutMs(), () => {
                     stallTriggered = true;
                 });
+                // F3c — hard-cap LLM calls per turn before this streamText()
+                if (++llmCallsThisTurn > MAX_LLM_CALLS_PER_TURN) {
+                    stall.dispose();
+                    yield {
+                        type: "error",
+                        content: `Turn aborted: reached the limit of ${MAX_LLM_CALLS_PER_TURN} LLM calls for this message. Try a narrower request or break your task into smaller steps.`,
+                        isAuthError: false,
+                    };
+                    yield { type: "done" };
+                    return;
+                }
                 const result = streamText({
                     model: runtime.model,
                     system: systemForModel,
@@ -1022,12 +1061,18 @@ export async function* executeToolEngine(args) {
                     // See src/orchestrator/tool-args-repair.ts for the transforms.
                     experimental_repairToolCall: repairToolCallHook,
                     prepareStep: ({ stepNumber: sn, messages: stepMessages }) => {
-                        // A new step's provider request is about to go out — reset the
-                        // per-step chunk counter. Fires after the previous step's chunks
-                        // were counted (prepareStep runs post tool-execution), so if THIS
-                        // step's request wedges before any byte, chunksThisStep stays 0 and
-                        // the mid-loop dead-socket continuation can safely resume from here.
                         chunksThisStep = 0;
+                        if (deps.isSubSession) {
+                            logger.info("orchestrator", "Sub-session executing tool round", {
+                                stepNumber: sn,
+                                maxToolRounds: deps.maxToolRounds,
+                            });
+                            deps.emitSubagentStatus({
+                                agent: "sub-session",
+                                description: `Running sub-session task...`,
+                                detail: `[Sub-Session] Executing tool round ${sn + 1} of ${deps.maxToolRounds}...`,
+                            });
+                        }
                         // --- Live-queue steering injection ---------------------------
                         // Drain the UI steer queue ONCE per prepareStep call (sn >= 1),
                         // accumulate into pendingSteers, and graft pendingSteers onto the
@@ -1058,7 +1103,7 @@ export async function* executeToolEngine(args) {
                                     });
                                 }
                                 catch (emitErr) {
-                                    console.error(`[message-processor] steer-inject telemetry failed: ${emitErr?.message}`);
+                                    logger.error("orchestrator", "steer-inject telemetry failed", { error: emitErr });
                                 }
                             }
                             const baseRes = (() => {
@@ -1338,7 +1383,7 @@ export async function* executeToolEngine(args) {
                             });
                         }
                         catch (err) {
-                            console.error("[Agent:onFinish] failed to emit llm-done", err);
+                            logger.error("orchestrator", "failed to emit llm-done", { error: err });
                         }
                         deps.setCurrentCallId("");
                         // Rec #1 persisted forensics: onFinish fires once per top-level turn,
@@ -1349,7 +1394,7 @@ export async function* executeToolEngine(args) {
                             persistSessionExperience(deps.session?.id ?? null, getSessionExperienceCounts());
                         }
                         catch (err) {
-                            console.error("[Agent:onFinish] persistSessionExperience failed", err);
+                            logger.error("orchestrator", "persistSessionExperience failed", { error: err });
                         }
                     },
                 });
@@ -2749,6 +2794,15 @@ export async function* executeToolEngine(args) {
                 catch {
                     /* fail-open */
                 }
+                // F3b — surface hard-cap stop (absolute ceiling, cannot be bumped).
+                if (_hardCapHit) {
+                    yield {
+                        type: "content",
+                        content: `\n\n[Hard limit reached: Agent hit the absolute step ceiling of ${deps.hardMaxToolRounds} steps. ` +
+                            `This turn cannot continue — too many LLM round-trips. ` +
+                            `Start a new turn or break your task into smaller steps.]\n`,
+                    };
+                }
                 // Surface the round-cap stop so the user knows why the agent halted
                 // (session 7dcf8fd7d6a4 hit stepCountIs(100) silently, looked like a
                 // crash). AI SDK reports finishReason='tool-calls' when the step cap
@@ -3075,5 +3129,10 @@ export async function* executeToolEngine(args) {
     catch (err) {
         throw err;
     }
+    finally {
+        if (deps.isSubSession) {
+            deps.emitSubagentStatus(null);
+        }
+    }
 }
 //# sourceMappingURL=tool-engine.js.map

package/dist/src/orchestrator/turn-runner-deps.d.ts

@@ -23,6 +23,8 @@ export interface TurnRunnerDepsBase {
     readonly bash: BashTool;
     readonly mode: AgentMode;
     readonly maxToolRounds: number;
+    /** Absolute non-bumpable ceiling per turn — fires after the user bumps past maxToolRounds. */
+    readonly hardMaxToolRounds: number;
     readonly schedules: import("../tools/schedule.js").ScheduleManager;
     readonly sendTelegramFile: ((filePath: string) => Promise<ToolResult>) | null;
     getCompactedThisTurn(): boolean;

package/dist/src/pil/llm-classify.d.ts

@@ -76,3 +76,14 @@ export type LlmClassifyFn = (prompt: string, signal?: AbortSignal) => Promise<Ll
  * fail-open (keep prior taskType, do not block the turn).
  */
 export declare function createLlmClassifier(factory: ProviderFactory, modelId: string): LlmClassifyFn;
+export type SubSessionAction = "DIRECT_ANSWER" | "ROTATE_SESSION" | "SPAWN_SUB_SESSION";
+export interface SubSessionRouteResult {
+    action: SubSessionAction;
+    confidence: number;
+    reason: string;
+}
+export declare function classifySubSessionActionHeuristic(prompt: string): SubSessionRouteResult | null;
+export declare function classifySubSessionAction(factory: ProviderFactory, modelId: string, prompt: string, contextInfo?: {
+    currentChars: number;
+    threshold: number;
+}, signal?: AbortSignal): Promise<SubSessionRouteResult | null>;

package/dist/src/pil/llm-classify.js

@@ -13,6 +13,7 @@
  * DeepSeek Flash). Timeout 2500ms — bails fast if the model stalls.
  */
 import { streamText } from "ai";
+import { getModelByTier, getModelInfo } from "../models/registry.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { resolveModelRuntime } from "../providers/runtime.js";
 const LLM_CLASSIFY_TIMEOUT_MS = 2500;
@@ -271,4 +272,196 @@ export function createLlmClassifier(factory, modelId) {
         }
     };
 }
+export function classifySubSessionActionHeuristic(prompt) {
+    const trimmed = prompt.trim().toLowerCase();
+    if (!trimmed)
+        return null;
+    // Strip trailing punctuation for list-based matching so "hello!" and "cảm ơn!"
+    // still hit the static lists instead of falling through to the LLM classifier.
+    const stripped = trimmed.replace(/[!?.…,;:]+$/g, "").trim();
+    // 1. Simple math equations (exact matches like "2+2", "1 + 1")
+    if (/^\d+\s*[+\-*/]\s*\d+$/.test(trimmed)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (simple math)",
+        };
+    }
+    // 2. Greetings (exact matches only, trailing punctuation stripped)
+    const greetings = [
+        "hi",
+        "hello",
+        "hey",
+        "chào",
+        "xin chào",
+        "hi there",
+        "hello there",
+        "chào bạn",
+        "halo",
+        "hola",
+        "bạn ơi",
+    ];
+    if (greetings.includes(stripped)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (greeting)",
+        };
+    }
+    // 3. Thanks (exact matches only, trailing punctuation stripped)
+    const thanks = [
+        "thanks",
+        "thank you",
+        "cảm ơn",
+        "cám ơn",
+        "thank",
+        "thx",
+        "ty",
+        "cảm ơn bạn",
+        "cám ơn bạn",
+        "cảm ơn nhé",
+        "cám ơn nhé",
+    ];
+    if (thanks.includes(stripped)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (thanks)",
+        };
+    }
+    // 4. Help (exact matches only, trailing punctuation stripped)
+    const help = ["help", "hướng dẫn", "cứu", "help me"];
+    if (help.includes(stripped)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (help)",
+        };
+    }
+    // 5. Short conversational words / acknowledgements (exact matches only, trailing punctuation stripped)
+    const conversation = [
+        "ok",
+        "okay",
+        "yes",
+        "no",
+        "vâng",
+        "dạ",
+        "ừ",
+        "chắc thế",
+        "ừm",
+        "umm",
+        "cool",
+        "nice",
+        "perfect",
+        "done",
+        "xong",
+        "yep",
+        "yup",
+        "nah",
+        "fine",
+        "tốt",
+        "được",
+        "okie",
+    ];
+    if (conversation.includes(stripped)) {
+        return {
+            action: "DIRECT_ANSWER",
+            confidence: 0.99,
+            reason: "Obvious input classified via heuristic (acknowledgement)",
+        };
+    }
+    return null;
+}
+const ROUTER_SYSTEM_PROMPT = "You are a routing controller for an AI coding agent. Your goal is to decide the execution strategy for the user's prompt based on the conversation history and metadata.\n\n" +
+    "Analyze the user's prompt and select one of the following ACTIONS:\n" +
+    '- "DIRECT_ANSWER": The prompt is informational, a quick question, a code review, an explanation, greeting, or thanks. No file creation/modification, test execution, or multi-turn tool runs are needed.\n' +
+    '- "ROTATE_SESSION": The user is starting a completely new topic or task unrelated to the active discussion (e.g. "let\'s switch to writing a python script", "forget the previous bug, show me how to..."). OR, if the session size (metadata) exceeds the rotation threshold and the active task is completed or the prompt starts a new focus, choose ROTATE_SESSION to prune/summarize the context.\n' +
+    '- "SPAWN_SUB_SESSION": The user wants to execute a multi-step task (e.g. "write tests for X and debug it", "refactor the storage layer", "implement feature Y", "fix all compile errors"). This requires running multiple tools (file edits, bash commands, searches).\n\n' +
+    "Response format: Reply with exactly one comma-separated line containing:\n" +
+    "<ACTION>,<CONFIDENCE>,<REASON>\n\n" +
+    "Examples:\n" +
+    '- "DIRECT_ANSWER,0.95,Simple explanation of how the DB migration works."\n' +
+    '- "ROTATE_SESSION,0.90,Complete shift to a different project/language."\n' +
+    '- "ROTATE_SESSION,0.95,Session size exceeds threshold and current request starts a new task."\n' +
+    '- "SPAWN_SUB_SESSION,0.98,Requires writing a test suite and fixing multiple files to get it green."\n' +
+    "No other text, only the comma-separated line.";
+export async function classifySubSessionAction(factory, modelId, prompt, contextInfo, signal) {
+    if (process.env.MUONROI_DISABLE_HEURISTIC_ROUTING !== "1") {
+        const heuristic = classifySubSessionActionHeuristic(prompt);
+        if (heuristic)
+            return heuristic;
+    }
+    const controller = new AbortController();
+    let timer;
+    try {
+        // Zero-hardcode: query models catalog for a cheap fast-tier model under the same provider.
+        const info = getModelInfo(modelId);
+        const provider = info?.provider;
+        const fastModel = provider ? getModelByTier("fast", provider) || getModelByTier("balanced", provider) : undefined;
+        const classificationModelId = fastModel?.id ?? modelId;
+        const runtime = resolveModelRuntime(factory, classificationModelId);
+        const isReasoning = runtime.modelInfo?.reasoning === true;
+        timer = setTimeout(() => controller.abort(), isReasoning ? REASONING_CLASSIFY_TIMEOUT_MS : LLM_CLASSIFY_TIMEOUT_MS);
+        const combinedSignal = signal
+            ? (AbortSignal.any?.([signal, controller.signal]) ?? controller.signal)
+            : controller.signal;
+        const dropMaxTokens = runtime.unsupportedParams?.includes("maxOutputTokens") === true;
+        const maxOut = isReasoning ? REASONING_MAX_OUTPUT_TOKENS : NONREASONING_MAX_OUTPUT_TOKENS;
+        let providerOptions = runtime.providerOptions;
+        if (isReasoning && runtime.modelInfo?.supportsReasoningEffort && runtime.modelInfo.provider) {
+            const lowEffort = getProviderCapabilities(runtime.modelInfo.provider).buildProviderOptions({
+                model: runtime.model,
+                reasoningEffort: "low",
+            });
+            providerOptions = mergeProviderOptions(runtime.providerOptions, lowEffort);
+        }
+        let promptWithContext = prompt.slice(0, 1000);
+        if (contextInfo) {
+            promptWithContext =
+                `[SESSION METADATA]\n` +
+                    `Current session size: ${contextInfo.currentChars} characters.\n` +
+                    `Rotation threshold: ${contextInfo.threshold} characters.\n\n` +
+                    `[USER PROMPT]\n${promptWithContext}`;
+        }
+        const result = streamText({
+            model: runtime.model,
+            abortSignal: combinedSignal,
+            system: ROUTER_SYSTEM_PROMPT,
+            prompt: promptWithContext,
+            ...(dropMaxTokens ? {} : { maxOutputTokens: maxOut }),
+            ...(providerOptions ? { providerOptions } : {}),
+        });
+        let text = "";
+        let reasoningText = "";
+        for await (const part of result.fullStream) {
+            if (part.type === "text-delta")
+                text += part.textDelta ?? part.text ?? "";
+            else if (part.type === "reasoning-delta")
+                reasoningText += part.textDelta ?? part.text ?? "";
+        }
+        const rawResult = text.trim() || reasoningText.trim();
+        if (!rawResult)
+            return null;
+        const clean = rawResult.replace(/[`*"]/g, "").trim();
+        const firstLine = clean.split(/\r?\n/)[0] ?? "";
+        const parts = firstLine.split(",");
+        if (parts.length < 2)
+            return null;
+        const action = parts[0].trim().toUpperCase();
+        const confidence = Number(parts[1].trim()) || 0.8;
+        const reason = parts.slice(2).join(",").trim() || "No reason given";
+        if (action === "DIRECT_ANSWER" || action === "ROTATE_SESSION" || action === "SPAWN_SUB_SESSION") {
+            return { action, confidence, reason };
+        }
+        return null;
+    }
+    catch (err) {
+        console.error(`[pil.llm-classify] classifySubSessionAction failed: ${err?.message}`);
+        return null;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
 //# sourceMappingURL=llm-classify.js.map