muonroi-cli 1.8.0 → 1.8.1

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/__tests__/llm-classify.test.js

@@ -1,7 +1,7 @@
 import { afterEach, beforeAll, describe, expect, it } from "vitest";
 import { installMockModel, textOnlyStream } from "../../agent-harness/mock-model.js";
 import { loadCatalog } from "../../models/registry.js";
-import { createLlmClassifier } from "../llm-classify.js";
+import { classifySubSessionAction, createLlmClassifier } from "../llm-classify.js";
 describe("createLlmClassifier (PIL Layer 1 Pass 4)", () => {
     beforeAll(async () => {
         await loadCatalog();
@@ -194,4 +194,82 @@ describe("createLlmClassifier (PIL Layer 1 Pass 4)", () => {
         expect((await bareClassify("fix it"))?.deliverableKind).toBeNull();
     });
 });
+describe("classifySubSessionAction", () => {
+    let cleanup = null;
+    afterEach(() => {
+        cleanup?.();
+        cleanup = null;
+    });
+    it("correctly parses SPAWN_SUB_SESSION from model response", async () => {
+        const handle = installMockModel({
+            fixture: { stream: textOnlyStream("SPAWN_SUB_SESSION,0.98,Requires writing a test suite") },
+        });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "fix all compile errors");
+        expect(result).not.toBeNull();
+        expect(result?.action).toBe("SPAWN_SUB_SESSION");
+        expect(result?.confidence).toBe(0.98);
+        expect(result?.reason).toBe("Requires writing a test suite");
+    });
+    it("correctly parses DIRECT_ANSWER from model response", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("DIRECT_ANSWER,0.95,Simple query") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "explain database index");
+        expect(result?.action).toBe("DIRECT_ANSWER");
+        expect(result?.confidence).toBe(0.95);
+    });
+    it("correctly routes greetings, thanks, or simple math via heuristic without calling LLM", async () => {
+        const factory = (() => {
+            throw new Error("Should not be called because of heuristic short-circuit");
+        });
+        const resultMath = await classifySubSessionAction(factory, "deepseek-v4-flash", "2+2");
+        expect(resultMath?.action).toBe("DIRECT_ANSWER");
+        expect(resultMath?.confidence).toBe(0.99);
+        expect(resultMath?.reason).toContain("heuristic (simple math)");
+        const resultGreeting = await classifySubSessionAction(factory, "deepseek-v4-flash", "hello");
+        expect(resultGreeting?.action).toBe("DIRECT_ANSWER");
+        expect(resultGreeting?.confidence).toBe(0.99);
+        expect(resultGreeting?.reason).toContain("heuristic (greeting)");
+        const resultThanks = await classifySubSessionAction(factory, "deepseek-v4-flash", "thank you");
+        expect(resultThanks?.action).toBe("DIRECT_ANSWER");
+        expect(resultThanks?.confidence).toBe(0.99);
+        expect(resultThanks?.reason).toContain("heuristic (thanks)");
+    });
+    it("does not route greetings/thanks via heuristic if they contain other text (fuzzy bypass prevention)", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("SPAWN_SUB_SESSION,0.95,Delete file task") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "hello, delete file X");
+        expect(result?.action).toBe("SPAWN_SUB_SESSION");
+    });
+    it("bypasses heuristic when MUONROI_DISABLE_HEURISTIC_ROUTING is set to 1", async () => {
+        process.env.MUONROI_DISABLE_HEURISTIC_ROUTING = "1";
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("SPAWN_SUB_SESSION,0.95,Forced class") } });
+        cleanup = handle.uninstall;
+        try {
+            const factory = (() => handle.model);
+            const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "hello");
+            expect(result?.action).toBe("SPAWN_SUB_SESSION");
+        }
+        finally {
+            delete process.env.MUONROI_DISABLE_HEURISTIC_ROUTING;
+        }
+    });
+    it("correctly parses ROTATE_SESSION from model response", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("ROTATE_SESSION,0.90,New topic") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "switch topic");
+        expect(result?.action).toBe("ROTATE_SESSION");
+    });
+    it("returns null when the reply cannot be parsed", async () => {
+        const handle = installMockModel({ fixture: { stream: textOnlyStream("bad response") } });
+        cleanup = handle.uninstall;
+        const factory = (() => handle.model);
+        const result = await classifySubSessionAction(factory, "deepseek-v4-flash", "test");
+        expect(result).toBeNull();
+    });
+});
 //# sourceMappingURL=llm-classify.test.js.map

package/dist/src/pil/layer1-intent.js

@@ -1243,40 +1243,40 @@ export async function layer1Intent(ctx, opts = {}) {
                 //     touch existing files.
                 // 0.7 confidence threshold for Pass 2 keyword override remains
                 // unchanged (HIGH_CONF_THRESHOLD_PASS2 above).
-                const brainRaw = await classifyViaBrain(`You are a multilingual prompt classifier. The user's prompt may be in English, Vietnamese, or a mix of both.
-Classify the prompt's INTENT (not its language). Reply with TWO lowercase words separated by a comma: <category>,<style>
-
-Category — pick ONE (listed in neutral order, no precedence):
-  analyze       — explain / inspect / review existing code (giải thích, phân tích, review)
-  debug         — fix a bug or investigate failure (sửa lỗi, fix bug, lỗi, traceback)
-  generate      — create new code/file or add new behavior (tạo, sinh code, viết function mới, thêm)
-  refactor      — restructure existing code (tái cấu trúc, refactor)
-  plan          — design / roadmap / architecture (kế hoạch, thiết kế, kiến trúc)
-  documentation — write docs/comments (viết docs, comment, jsdoc)
-  general       — chitchat OR unclear / ambiguous coding intent
-
-Rules (Phase 4 4P-2 disambiguation):
-- Only return refactor when the user EXPLICITLY uses one of: rename, restructure, reorganize, extract, inline, move, migrate, reshape — applied to EXISTING code WITHOUT adding new behavior.
-- Feature additions ('add flag', 'thêm', 'create endpoint', 'thêm option'), changing a DEFAULT value, adding tests, or improving coverage are 'generate' — NOT refactor.
-- 'improve', 'change', 'update', 'modify', 'đổi', 'cải thiện' alone do NOT imply refactor — pick the specific category by what the change actually does.
-- When the request is ambiguous, prefer 'general' over guessing refactor.
-
-Negative examples (NOT refactor):
-- "đổi default --max-tool-rounds 8 sang 12" → generate
-- "improve test coverage" → generate
-- "tại sao X trả empty" → analyze
-- "fix CI failing" → debug
-
-Style — pick ONE:
-  concise (ngắn gọn) | balanced (cân bằng) | detailed (chi tiết)
-
-Examples:
-  "Refactor this function" → refactor,balanced
-  "tại sao test fail" → debug,balanced
-  "thiết kế hệ thống auth" → plan,detailed
-  "thêm flag --foo" → generate,concise
-  "hi" → general,concise
-
+                const brainRaw = await classifyViaBrain(`You are a multilingual prompt classifier. The user's prompt may be in English, Vietnamese, or a mix of both.
+Classify the prompt's INTENT (not its language). Reply with TWO lowercase words separated by a comma: <category>,<style>
+
+Category — pick ONE (listed in neutral order, no precedence):
+  analyze       — explain / inspect / review existing code (giải thích, phân tích, review)
+  debug         — fix a bug or investigate failure (sửa lỗi, fix bug, lỗi, traceback)
+  generate      — create new code/file or add new behavior (tạo, sinh code, viết function mới, thêm)
+  refactor      — restructure existing code (tái cấu trúc, refactor)
+  plan          — design / roadmap / architecture (kế hoạch, thiết kế, kiến trúc)
+  documentation — write docs/comments (viết docs, comment, jsdoc)
+  general       — chitchat OR unclear / ambiguous coding intent
+
+Rules (Phase 4 4P-2 disambiguation):
+- Only return refactor when the user EXPLICITLY uses one of: rename, restructure, reorganize, extract, inline, move, migrate, reshape — applied to EXISTING code WITHOUT adding new behavior.
+- Feature additions ('add flag', 'thêm', 'create endpoint', 'thêm option'), changing a DEFAULT value, adding tests, or improving coverage are 'generate' — NOT refactor.
+- 'improve', 'change', 'update', 'modify', 'đổi', 'cải thiện' alone do NOT imply refactor — pick the specific category by what the change actually does.
+- When the request is ambiguous, prefer 'general' over guessing refactor.
+
+Negative examples (NOT refactor):
+- "đổi default --max-tool-rounds 8 sang 12" → generate
+- "improve test coverage" → generate
+- "tại sao X trả empty" → analyze
+- "fix CI failing" → debug
+
+Style — pick ONE:
+  concise (ngắn gọn) | balanced (cân bằng) | detailed (chi tiết)
+
+Examples:
+  "Refactor this function" → refactor,balanced
+  "tại sao test fail" → debug,balanced
+  "thiết kế hệ thống auth" → plan,detailed
+  "thêm flag --foo" → generate,concise
+  "hi" → general,concise
+
 Prompt: "${ctx.raw.slice(0, 500)}"`, 1500);
                 if (brainRaw) {
                     pass3LegacyTaskSucceeded = true;
@@ -1327,9 +1327,9 @@ Prompt: "${ctx.raw.slice(0, 500)}"`, 1500);
                 if (pass3LegacyTaskAttempted) {
                     legacyBrainAttempted = true;
                     pass3LegacyStyleAttempted = true;
-                    const brainRawStyle = await classifyViaBrain(`Detect the user's preferred output style. The prompt may be EN or VN.
-Reply with ONE word: concise (ngắn gọn) | balanced (bình thường) | detailed (chi tiết).
-
+                    const brainRawStyle = await classifyViaBrain(`Detect the user's preferred output style. The prompt may be EN or VN.
+Reply with ONE word: concise (ngắn gọn) | balanced (bình thường) | detailed (chi tiết).
+
 Prompt: "${ctx.raw.slice(0, 300)}"`, 800);
                     if (brainRawStyle) {
                         pass3LegacyStyleSucceeded = true;

package/dist/src/pil/layer2_5-ponytail.js

@@ -1,13 +1,13 @@
 import { truncateToBudget } from "./budget.js";
 import { isPonytailModeEnabled } from "./config.js";
-const PONYTAIL_INSTRUCTION = `[LAZY SENIOR / PONYTAIL MODE ACTIVE]
-"The best code is the code you never wrote." You MUST adhere to the following Decision Ladder:
-1. Standard Library first.
-2. Native platform features next.
-3. 1-line solution next.
-4. YAGNI: Do not write it if not strictly necessary.
-5. Smallest correct change.
-
+const PONYTAIL_INSTRUCTION = `[LAZY SENIOR / PONYTAIL MODE ACTIVE]
+"The best code is the code you never wrote." You MUST adhere to the following Decision Ladder:
+1. Standard Library first.
+2. Native platform features next.
+3. 1-line solution next.
+4. YAGNI: Do not write it if not strictly necessary.
+5. Smallest correct change.
+
 DOCUMENTATION RULE: If you bypass a complex/scalable pattern in favor of a simple one to adhere to this rule, you MUST add a comment in the code starting exactly with "// Intentional simplification: [Reason]".`;
 export async function layer2_5Ponytail(ctx) {
     // If task is not coding/action-related (e.g., chitchat), we might not need it, but pipeline.ts already skips layers if taskType is null.

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>;