muonroi-cli 1.8.0 → 1.8.1

package/dist/src/orchestrator/prompts.js

@@ -4,22 +4,67 @@ import { buildContractSection } from "../pil/agent-operating-contract.js";
 import { buildNativeCapabilitiesSection } from "../pil/native-capabilities-workbook.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { loadCustomInstructions } from "../utils/instructions.js";
-import { loadValidSubAgents, } from "../utils/settings.js";
+import { logger } from "../utils/logger.js";
+import { loadUserSettings, loadValidSubAgents, } from "../utils/settings.js";
 import { resolveShell } from "../utils/shell.js";
 import { discoverSkills, formatSkillsForPrompt } from "../utils/skills.js";
-// F3 — hard cap on tool rounds per user turn. Default reduced 400 → 100
-// after session bca83bcbaad1 logged 178 tool calls in a single turn while
-// monotonically growing billed input. Env override allowed range 10..400.
+// F3a — hard cap on tool rounds per user turn. Reduced 100 → 40
+// after session 526a83cf22df logged 2.44M input tokens over 46 LLM calls
+// with 3 turns (seq 33/81/1) consuming 82% of tokens.
+// Env override allowed range 10..400.
+// Env override allowed range 10..400 (or up to 2000 in agent-first).
 function readMaxToolRoundsFromEnv() {
-    const raw = process.env.MUONROI_MAX_TOOL_ROUNDS;
+    const settings = loadUserSettings();
+    const agentFirst = settings.agentFirst !== false &&
+        process.env.MUONROI_AGENT_FIRST !== "0" &&
+        process.env.MUONROI_AGENT_FIRST !== "false";
+    const raw = process.env.MUONROI_MAX_TOOL_ROUNDS || settings.maxToolRounds;
     if (!raw)
-        return 100;
+        return agentFirst ? 200 : 40;
     const n = Number(raw);
     if (!Number.isFinite(n))
-        return 100;
-    return Math.max(10, Math.min(400, Math.floor(n)));
+        return agentFirst ? 200 : 40;
+    const maxLimit = agentFirst ? 2000 : 400;
+    return Math.max(10, Math.min(maxLimit, Math.floor(n)));
 }
 export const MAX_TOOL_ROUNDS = readMaxToolRoundsFromEnv();
+// F3b — HARD cap: absolute non-bumpable ceiling per user turn.
+// Fires AFTER the soft cap has been bumped by the user.
+// Env override allowed range 20..400 (or up to 3000 in agent-first).
+function readHardMaxToolRoundsFromEnv() {
+    const settings = loadUserSettings();
+    const agentFirst = settings.agentFirst !== false &&
+        process.env.MUONROI_AGENT_FIRST !== "0" &&
+        process.env.MUONROI_AGENT_FIRST !== "false";
+    const raw = process.env.MUONROI_HARD_MAX_TOOL_ROUNDS || settings.hardMaxToolRounds;
+    if (!raw)
+        return agentFirst ? 300 : 60;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return agentFirst ? 300 : 60;
+    const maxLimit = agentFirst ? 3000 : 400;
+    return Math.max(20, Math.min(maxLimit, Math.floor(n)));
+}
+export const HARD_MAX_TOOL_ROUNDS = readHardMaxToolRoundsFromEnv();
+// F3c — per-turn LLM call cap: how many streamText() invocations are
+// allowed per user turn.
+// Default 12 (or 100 in agent-first).
+// Env override MUONROI_MAX_LLM_CALLS_PER_TURN, range 3..100 (or up to 500 in agent-first).
+function readMaxLlmCallsPerTurn() {
+    const settings = loadUserSettings();
+    const agentFirst = settings.agentFirst !== false &&
+        process.env.MUONROI_AGENT_FIRST !== "0" &&
+        process.env.MUONROI_AGENT_FIRST !== "false";
+    const raw = process.env.MUONROI_MAX_LLM_CALLS_PER_TURN || settings.maxLlmCallsPerTurn;
+    if (!raw)
+        return agentFirst ? 100 : 12;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return agentFirst ? 100 : 12;
+    const maxLimit = agentFirst ? 500 : 100;
+    return Math.max(3, Math.min(maxLimit, Math.floor(n)));
+}
+export const MAX_LLM_CALLS_PER_TURN = readMaxLlmCallsPerTurn();
 export const VISION_MODEL = "grok-4-1-fast-reasoning";
 export const COMPUTER_MODEL = "grok-4.20-0309-reasoning";
 /**
@@ -62,9 +107,7 @@ export function detectProjectStack(cwd) {
         // Best-effort enrichment: a missing/unreadable cwd simply omits the stack
         // line (the ENVIRONMENT cwd line already surfaces "<unknown>"). Debug-gated
         // so prompt assembly never corrupts the TUI at startup.
-        if (process.env.MUONROI_DEBUG === "1") {
-            console.error(`[orchestrator/prompts] detectProjectStack failed for ${cwd}: ${err?.message}`);
-        }
+        logger.error("orchestrator", `detectProjectStack failed for ${cwd}`, { error: err });
         return "";
     }
     const has = (name) => entries.includes(name);
@@ -406,15 +449,18 @@ export function buildMcpCapabilityBlock(toolNames) {
 }
 const _staticPrefixCache = new Map();
 const STATIC_PREFIX_CACHE_TTL_MS = 300_000; // 5 min — ample; inputs are session-stable
-function staticPrefixCacheKey(cwd, mode, providerId, isChitchat, subagentsHash, subAgent = false) {
-    return `${cwd}|${mode}|${providerId}|${isChitchat}|${subagentsHash}|${subAgent}`;
+function staticPrefixCacheKey(cwd, mode, providerId, isChitchat, subagentsHash, subAgent = false, toolTurn = false) {
+    return `${cwd}|${mode}|${providerId}|${isChitchat}|${subagentsHash}|${subAgent}|${toolTurn}`;
 }
-function computeStaticPrefix(cwd, mode, subagents, providerId, chitchat, subAgent = false) {
+function computeStaticPrefix(cwd, mode, subagents, providerId, chitchat, subAgent = false, toolTurn = false) {
     const custom = loadCustomInstructions(cwd);
     const customSection = subAgent || !custom
         ? ""
         : `\n\nCUSTOM INSTRUCTIONS:\n${custom}\n\nFollow the above alongside standard instructions.\n`;
-    const skillsText = chitchat || subAgent ? "" : formatSkillsForPrompt(discoverSkills(cwd));
+    // Tool-turn: skip agent-skills catalog (~2K tokens) and native-capabilities block (~2K tokens).
+    // The agent was already shown these in the first call of this turn and does not need
+    // to re-read them on every tool round-trip.
+    const skillsText = chitchat || subAgent || toolTurn ? "" : formatSkillsForPrompt(discoverSkills(cwd));
     const skillsSection = skillsText ? `\n\n${skillsText}\n` : "";
     const subagentsSection = chitchat ? "" : formatCustomSubagentsPromptSection(subagents ?? loadValidSubAgents());
     let modePrompt = MODE_PROMPTS[mode];
@@ -430,19 +476,20 @@ function computeStaticPrefix(cwd, mode, subagents, providerId, chitchat, subAgen
         modePrompt = modePrompt.replace(/\n- (wallet_|paid_|fetch_payment|schedule_|generate_|computer_|search_x).*/g, "");
     }
     const contractSection = buildContractSection({ chitchat });
-    const nativeCapabilitiesSection = buildNativeCapabilitiesSection({ mode, chitchat });
+    const nativeCapabilitiesSection = toolTurn ? "" : buildNativeCapabilitiesSection({ mode, chitchat });
     const prefix = `${contractSection}${nativeCapabilitiesSection}${modePrompt}${customSection}${skillsSection}${subagentsSection}`;
     return { prefix };
 }
 export function buildSystemPromptParts(cwd, mode, sandboxMode, planContext, subagents, sandboxSettings, providerId, resumeDigest, options) {
     const chitchat = options?.chitchat === true;
     const subAgent = options?.subAgent ?? false;
+    const toolTurn = options?.toolTurn === true;
     const pid = providerId ?? "default";
     // Subagents rarely change mid-session, but when they do we need a cache miss.
     // JSON-stable stringify is fast for typical configs (< 10 entries, no circular refs).
     const subagentsHash = subagents ? JSON.stringify(subagents) : "none";
     // Try cache for the static prefix
-    const key = staticPrefixCacheKey(cwd, mode, pid, chitchat, subagentsHash, subAgent);
+    const key = staticPrefixCacheKey(cwd, mode, pid, chitchat, subagentsHash, subAgent, toolTurn);
     const now = Date.now();
     const cached = _staticPrefixCache.get(key);
     let staticPrefix;
@@ -451,7 +498,7 @@ export function buildSystemPromptParts(cwd, mode, sandboxMode, planContext, suba
     }
     else {
         // Cache miss — compute and store
-        const result = computeStaticPrefix(cwd, mode, subagents, pid, chitchat, subAgent);
+        const result = computeStaticPrefix(cwd, mode, subagents, pid, chitchat, subAgent, toolTurn);
         staticPrefix = result.prefix;
         _staticPrefixCache.set(key, {
             prefix: staticPrefix,

package/dist/src/orchestrator/sub-agent-cap.d.ts

@@ -64,6 +64,8 @@ export interface SubAgentCapState {
     cumulative: number;
     /** Configured ceiling. */
     max: number;
+    /** Hard cap ceiling (e.g. max * 2). */
+    hardMax?: number;
     /** True once `cumulative >= max` (sub-agent should wrap up). */
     exhausted: boolean;
     /** Number of duplicate-output detections (telemetry / tests). */

package/dist/src/orchestrator/sub-agent-cap.js

@@ -46,7 +46,9 @@ function shortHash(text) {
     return createHash("sha1").update(text).digest("hex").slice(0, 12);
 }
 export function compressForCap(state, raw) {
-    if (state.exhausted) {
+    const hardCeiling = state.hardMax ?? state.max;
+    if (state.exhausted || state.cumulative >= hardCeiling) {
+        state.exhausted = true;
         return `[${state.label} tool budget exhausted (${state.cumulative}/${state.max} chars). Further tool calls will return this stub. Summarize findings now and return.]`;
     }
     state.callIndex += 1;
@@ -68,7 +70,11 @@ export function compressForCap(state, raw) {
     }
     const ratio = state.cumulative / state.max;
     let out;
-    if (ratio >= state.highTierRatio) {
+    if (state.cumulative >= state.max) {
+        const trimmed = trimHead(raw, state.highTierChars, state.label);
+        out = `${trimmed}\n\n[Warning: ${state.label} tool budget exceeded (${state.cumulative}/${state.max} chars). Please finalize your work and summarize findings now.]`;
+    }
+    else if (ratio >= state.highTierRatio) {
         out = trimHead(raw, state.highTierChars, state.label);
     }
     else if (ratio >= state.midTierRatio) {
@@ -78,7 +84,7 @@ export function compressForCap(state, raw) {
         out = raw;
     }
     state.cumulative += out.length;
-    if (state.cumulative >= state.max)
+    if (state.cumulative >= hardCeiling)
         state.exhausted = true;
     return out;
 }
@@ -141,9 +147,11 @@ function wrapInternal(tools, state) {
  * cumulative state.
  */
 export function wrapToolSetWithCap(tools, opts = {}) {
+    const max = Math.max(20_000, opts.maxCumulativeChars ?? DEFAULT_MAX_CUMULATIVE_CHARS);
     const state = {
         cumulative: 0,
-        max: Math.max(20_000, opts.maxCumulativeChars ?? DEFAULT_MAX_CUMULATIVE_CHARS),
+        max,
+        hardMax: max * 2,
         exhausted: false,
         dedupHits: 0,
         seenHashes: new Map(),

package/dist/src/orchestrator/subagent-compactor.d.ts

@@ -154,3 +154,10 @@ export declare function compactSubAgentMessages(messages: ReadonlyArray<ModelMes
  * Creates a copy of the messages array and the last message to avoid mutating in-place.
  */
 export declare function applyAnthropicPromptCaching(messages: readonly ModelMessage[], modelId: string): ModelMessage[];
+/**
+ * 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 declare function sliceMessageHistory(messages: ReadonlyArray<ModelMessage>, maxMessages?: number): ModelMessage[];

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/subagent-compactor.spec.js

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it } from "vitest";
-import { compactSubAgentMessages, cumulativeMessageChars } from "./subagent-compactor.js";
+import { compactSubAgentMessages, cumulativeMessageChars, sliceMessageHistory } from "./subagent-compactor.js";
 function bigText(label, kb) {
     const block = `${label}:${"x".repeat(kb * 1000)}`;
     return block;
@@ -400,7 +400,14 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
             },
             {
                 role: "tool",
-                content: [{ type: "tool-result", toolCallId: "call_low", toolName: "read_file", output: { type: "text", value: lowValueOutput } }],
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: "call_low",
+                        toolName: "read_file",
+                        output: { type: "text", value: lowValueOutput },
+                    },
+                ],
             },
             {
                 role: "assistant",
@@ -408,7 +415,14 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
             },
             {
                 role: "tool",
-                content: [{ type: "tool-result", toolCallId: "call_err", toolName: "read_file", output: { type: "text", value: highValueOutputWithError } }],
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: "call_err",
+                        toolName: "read_file",
+                        output: { type: "text", value: highValueOutputWithError },
+                    },
+                ],
             },
             {
                 role: "assistant",
@@ -416,7 +430,14 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
             },
             {
                 role: "tool",
-                content: [{ type: "tool-result", toolCallId: "call_src", toolName: "read_file", output: { type: "text", value: highValueSourceOutput } }],
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: "call_src",
+                        toolName: "read_file",
+                        output: { type: "text", value: highValueSourceOutput },
+                    },
+                ],
             },
             // Add a couple of low-value turns to push past threshold and keepLast turns (keepLast=1)
             ...toolTurn(9, 10),
@@ -425,13 +446,13 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
         msgs[msgs.length - 1].content[0].toolName = "other_tool";
         const out = compactSubAgentMessages(msgs, { thresholdChars: 10_000, keepLastTurns: 1 });
         // low-value large read_file MUST be elided
-        const lowValMsg = out.find(m => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_low");
+        const lowValMsg = out.find((m) => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_low");
         expect((lowValMsg?.content)[0].output.value).toMatch(/elided by sub-agent compactor/);
         // high-value large error read_file MUST NOT be elided
-        const errValMsg = out.find(m => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_err");
+        const errValMsg = out.find((m) => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_err");
         expect((errValMsg?.content)[0].output.value).toBe(highValueOutputWithError);
         // high-value small source read_file MUST NOT be elided
-        const srcValMsg = out.find(m => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_src");
+        const srcValMsg = out.find((m) => m.role === "tool" && Array.isArray(m.content) && m.content[0]?.toolCallId === "call_src");
         expect((srcValMsg?.content)[0].output.value).toBe(highValueSourceOutput);
     });
     it("T1.1 — strips reasoning parts from old assistant turns when stripOldReasoning is enabled", () => {
@@ -453,7 +474,12 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
             msgs.push({
                 role: "tool",
                 content: [
-                    { type: "tool-result", toolCallId: `call_${i}`, toolName: "bash", output: { type: "text", value: bigText(`R${i}`, 2) } },
+                    {
+                        type: "tool-result",
+                        toolCallId: `call_${i}`,
+                        toolName: "bash",
+                        output: { type: "text", value: bigText(`R${i}`, 2) },
+                    },
                 ],
             });
         }
@@ -497,7 +523,12 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
             msgs.push({
                 role: "tool",
                 content: [
-                    { type: "tool-result", toolCallId: `call_${i}`, toolName: "bash", output: { type: "text", value: bigText(`R${i}`, 2) } },
+                    {
+                        type: "tool-result",
+                        toolCallId: `call_${i}`,
+                        toolName: "bash",
+                        output: { type: "text", value: bigText(`R${i}`, 2) },
+                    },
                 ],
             });
         }
@@ -516,5 +547,90 @@ describe("subagent-compactor: compactSubAgentMessages", () => {
             expect(hasReasoning).toBe(true);
         }
     });
+    describe("sliceMessageHistory & Step 4 truncation", () => {
+        it("preserves system prompt and user start while slicing excess messages", () => {
+            const msgs = [
+                { role: "system", content: "system prompt" },
+                { role: "user", content: "first prompt" },
+                { role: "assistant", content: "first answer" },
+                { role: "user", content: "second prompt" },
+                {
+                    role: "assistant",
+                    content: [{ type: "tool-call", toolCallId: "call-1", toolName: "bash", input: "ls" }],
+                },
+                {
+                    role: "tool",
+                    content: [{ type: "tool-result", toolCallId: "call-1", toolName: "bash", output: "file1" }],
+                },
+                { role: "assistant", content: "second answer" },
+                { role: "user", content: "third prompt" },
+                {
+                    role: "assistant",
+                    content: [{ type: "tool-call", toolCallId: "call-2", toolName: "bash", input: "pwd" }],
+                },
+                {
+                    role: "tool",
+                    content: [{ type: "tool-result", toolCallId: "call-2", toolName: "bash", output: "/dir" }],
+                },
+                { role: "assistant", content: "third answer" },
+            ];
+            // Slicing to max 5 messages should start cleanly at a user message
+            const sliced = sliceMessageHistory(msgs, 5);
+            expect(sliced[0].role).toBe("system");
+            expect(sliced[1].role).toBe("user");
+            // Slicing walked backward to find a user message start that satisfies max 5.
+            // Last messages:
+            // assistant: third answer (idx 10) -> tool result 2 (idx 9) -> assistant call 2 (idx 8) -> user third prompt (idx 7).
+            // That is 4 messages. Since kept must start with user, it stops at idx 7.
+            // So kept messages are from idx 7 onwards: [user third prompt, assistant call 2, tool result 2, assistant third answer]
+            expect(sliced).toHaveLength(5); // 1 system + 4 kept messages
+            expect(sliced[1].content).toBe("third prompt");
+        });
+        it("does not orphaned tool-calls and tool-results", () => {
+            const msgs = [
+                { role: "system", content: "system prompt" },
+                { role: "user", content: "prompt" },
+                {
+                    role: "assistant",
+                    content: [{ type: "tool-call", toolCallId: "call-99", toolName: "bash", input: "whoami" }],
+                },
+                {
+                    role: "tool",
+                    content: [{ type: "tool-result", toolCallId: "call-99", toolName: "bash", output: "root" }],
+                },
+                { role: "assistant", content: "hello" },
+            ];
+            // Even if maxMessages is 2, it shouldn't split assistant call-99 and tool result-99.
+            // Walking backward:
+            // - assistant: hello (count 1)
+            // - tool: result-99 (count 2, pendingToolCalls = {call-99})
+            // - assistant: call-99 (count 3, pendingToolCalls = {})
+            // - user: prompt (count 4, clean user start)
+            // So it must keep 4 messages + 1 system = 5 messages.
+            const sliced = sliceMessageHistory(msgs, 2);
+            expect(sliced).toHaveLength(5);
+            expect(sliced[1].role).toBe("user");
+        });
+        it("triggers slicing in compactSubAgentMessages when total exceeds 50K and messages count is > 30", () => {
+            const msgs = [
+                { role: "system", content: "system" },
+                { role: "user", content: "start" },
+            ];
+            // Push 40 messages to exceed 30 messages limit
+            for (let i = 0; i < 20; i++) {
+                msgs.push({ role: "assistant", content: `helper ${i}` });
+                msgs.push({ role: "user", content: `next question ${i}` });
+            }
+            // Generate a massive envelope size or message content to exceed 50K total chars
+            const out = compactSubAgentMessages(msgs, {
+                envelopeChars: 60_000, // force exceeds 50K
+                thresholdChars: 200_000, // high threshold to prevent compaction from running on top
+            });
+            // The message history should have been sliced (will be much fewer than 42 messages)
+            expect(out.length).toBeLessThan(msgs.length);
+            expect(out[0].role).toBe("system");
+            expect(out[1].role).toBe("user");
+        });
+    });
 });
 //# sourceMappingURL=subagent-compactor.spec.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<{