muonroi-cli 1.3.4 → 1.4.1

package/dist/src/orchestrator/stream-runner.js

@@ -29,24 +29,32 @@
 import { stepCountIs, streamText } from "ai";
 import { buildMcpToolSet } from "../mcp/runtime.js";
 import { normalizeModelId } from "../models/registry.js";
+import { cheapModelShellLine, injectCheapModelPlaybook, injectCheapModelShellDirective, shouldInjectCheapModelPlaybook, } from "../pil/cheap-model-playbook.js";
+import { injectCheapModelWorkbook, shouldInjectCheapModelWorkbook, subagentTaskType, } from "../pil/cheap-model-workbooks.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { captureToolSchemas } from "../providers/patch-zod-schema.js";
-import { resolveModelRuntime, shouldDropParam } from "../providers/runtime.js";
+import { buildTurnProviderOptions, requireRuntimeProvider, resolveModelRuntime, shouldDropParam, } from "../providers/runtime.js";
 import { wireDebug } from "../providers/wire-debug.js";
 import { BashTool } from "../tools/bash.js";
 import { createBuiltinTools } from "../tools/registry.js";
 import { statusBarStore } from "../ui/status-bar/store.js";
-import { getCurrentShellSettings, getSubAgentBudgetChars, getSubAgentCompactKeepLast, getSubAgentCompactThresholdChars, loadMcpServers, loadValidSubAgents, } from "../utils/settings.js";
+import { getCurrentShellSettings, getProviderStallTimeoutMs, getSubAgentBudgetChars, getSubAgentCompactKeepLast, getSubAgentCompactThresholdChars, loadMcpServers, loadValidSubAgents, } from "../utils/settings.js";
+import { resolveShell } from "../utils/shell.js";
 import { prepareVerifySandbox } from "../verify/entrypoint.js";
 import { asNumber } from "./batch-utils.js";
 import { wrapToolSetWithDedup } from "./cross-turn-dedup.js";
 import { applyModelConstraints, buildSubagentPrompt, COMPUTER_MODEL, findCustomSubagent, VISION_MODEL, } from "./prompts.js";
 import { extractProviderOptionsShape } from "./provider-options-shape.js";
 import { wrapToolSetWithReadBudget } from "./read-path-budget.js";
+import { repairToolCallHook } from "./repair-tool-call.js";
 import { classifyStreamError } from "./retry-classifier.js";
+import { incSessionStep, resolveCeiling } from "./scope-ceiling.js";
+import { attachReminderToMessages, buildScopeReminder, cadenceForSize, shouldInjectReminder, shouldInjectSoftWarn, } from "./scope-reminder.js";
+import { getDefaultEEClient } from "../ee/intercept.js";
+import { createStallWatchdog, STALL_ERROR_MESSAGE } from "./stall-watchdog.js";
 import { wrapToolSetWithCap } from "./sub-agent-cap.js";
 import { compactSubAgentMessages } from "./subagent-compactor.js";
-import { firstLine, formatSubagentActivity } from "./tool-utils.js";
+import { combineAbortSignals, firstLine, formatSubagentActivity } from "./tool-utils.js";
 /**
  * StreamRunner — extracted sub-agent stream lifecycle.
  *
@@ -116,7 +124,7 @@ export class StreamRunner {
             verifyPreparedRecipe = prepared.profile.recipe;
         }
         const childBash = new BashTool(topBash.getCwd(), {
-            sandboxMode: isVerify ? "shuru" : topBash.getSandboxMode(),
+            sandboxMode: isVerify ? topBash.getSandboxMode() : topBash.getSandboxMode(),
             sandboxSettings: isVerify
                 ? (verifyPreparedSettings ?? { ...topBash.getSandboxSettings(), ...verifySandboxOverrides })
                 : topBash.getSandboxSettings(),
@@ -156,7 +164,7 @@ export class StreamRunner {
                 ? COMPUTER_MODEL
                 : custom
                     ? custom.model
-                    : this.deps.resolveModelForTask(isExplore ? "explore" : "general"));
+                    : this.deps.resolveModelForTask(isExplore ? "explore" : isVerify || isVerifyDetect || isVerifyManifest ? "verify" : "general"));
         const topModelId = this.deps.getModelId();
         if (childModelId !== topModelId) {
             statusBarStore.setState({ routed_from: topModelId, model: childModelId });
@@ -167,7 +175,7 @@ export class StreamRunner {
                 model: provider.responses?.(childModelId) ?? provider(childModelId),
             }
             : resolveModelRuntime(provider, childModelId);
-        const taskCaps = getProviderCapabilities(childRuntime.modelInfo?.provider ?? "anthropic");
+        const taskCaps = getProviderCapabilities(requireRuntimeProvider(childRuntime));
         if (isComputer && !taskCaps.supportsClientTools(childRuntime.modelInfo)) {
             return {
                 kind: "short-circuit",
@@ -182,7 +190,25 @@ export class StreamRunner {
                 },
             };
         }
-        const childSystem = applyModelConstraints(buildSubagentPrompt(request, childBash.getCwd(), custom ?? null, childBash.getSandboxMode(), subagents, childBash.getSandboxSettings(), childRuntime.modelInfo?.provider ?? this.deps.getProviderId()), childRuntime.modelId);
+        const childSystemBase = applyModelConstraints(buildSubagentPrompt(request, childBash.getCwd(), custom ?? null, childBash.getSandboxMode(), subagents, childBash.getSandboxSettings(), childRuntime.modelInfo?.provider ?? this.deps.getProviderId()), childRuntime.modelId);
+        // Tier-aware behavioural steering — same front-loaded stack as the
+        // top-level turn (see message-processor.ts), gated on the SUB-AGENT's
+        // runtime (a top-level claude turn can still spawn a deepseek sub-agent
+        // via SAMR/cost optimisation, and the sub-agent needs the steering even
+        // though the parent does not). Layered so the final prompt OPENS with
+        // [ENV] → [CRITICAL playbook] → [CONVERGENCE workbook] → base, matching
+        // the cached-prefix order used at the top level. The sub-agent has no PIL
+        // classifier of its own, so its workbook task type is derived from its
+        // role via subagentTaskType (explore→analyze, verify*→debug, else null).
+        const childWithWorkbook = shouldInjectCheapModelWorkbook(childRuntime.modelInfo)
+            ? injectCheapModelWorkbook(childSystemBase, subagentTaskType(agentKey))
+            : childSystemBase;
+        const childWithPlaybook = shouldInjectCheapModelPlaybook(childRuntime.modelInfo)
+            ? injectCheapModelPlaybook(childWithWorkbook)
+            : childWithWorkbook;
+        const childSystem = shouldInjectCheapModelPlaybook(childRuntime.modelInfo)
+            ? injectCheapModelShellDirective(childWithPlaybook, cheapModelShellLine(resolveShell({}).kind, process.platform))
+            : childWithPlaybook;
         onActivity?.(initialDetail);
         if (childMode === "agent" && taskCaps.supportsClientTools(childRuntime.modelInfo)) {
             const mcpBundle = await buildMcpToolSet(loadMcpServers(), {
@@ -222,6 +248,17 @@ export class StreamRunner {
         void signal;
         const childMessages = [{ role: "user", content: childPrompt }];
         const maxSteps = Math.min(this.deps.getMaxToolRounds(), isExplore ? 60 : 120);
+        // F1 parity — derive per-turn providerOptions so the sub-agent OpenAI calls
+        // carry a stable session-derived promptCacheKey (every tool round routes to
+        // the same cache node, keeping the unchanging prefix cached). The top-level
+        // turn does this in message-processor.ts; the sub-agent path previously used
+        // only resolve-time childRuntime.providerOptions (no cache key). Guard on a
+        // resolvable provider so a runtime without catalog modelInfo (vision/computer
+        // constants) falls back to the resolve-time options instead of throwing.
+        const childProviderOptions = childRuntime.modelInfo?.provider
+            ? (buildTurnProviderOptions(childRuntime, { sessionId: this.deps.getSessionId() }) ??
+                childRuntime.providerOptions)
+            : childRuntime.providerOptions;
         return {
             kind: "prepared",
             prepared: {
@@ -233,6 +270,7 @@ export class StreamRunner {
                 childSystem,
                 childMessages,
                 childTools,
+                childProviderOptions,
                 initialDetail,
                 lastActivity,
                 maxSteps,
@@ -248,7 +286,10 @@ export class StreamRunner {
      */
     async runStream(prepared, onActivity, signal) {
         const { childRuntime, childSystem, childMessages, childTools, maxSteps } = prepared;
-        const taskCaps = getProviderCapabilities(childRuntime.modelInfo?.provider ?? "anthropic");
+        // F1 — per-turn options (with promptCacheKey) built in setup(); falls back
+        // to resolve-time options when no provider/session was available.
+        const childProviderOptions = prepared.childProviderOptions ?? childRuntime.providerOptions;
+        const taskCaps = getProviderCapabilities(requireRuntimeProvider(childRuntime));
         let assistantText = "";
         let lastActivity = prepared.lastActivity;
         const isExplore = prepared.agentKey === "explore";
@@ -267,7 +308,7 @@ export class StreamRunner {
             const mi = childRuntime.modelInfo;
             debugLog(`start: model=${childRuntime.modelId} provider=${mi?.provider} reasoning=${mi?.reasoning} thinkingType=${mi?.thinkingType} supportsClientTools=${mi?.supportsClientTools} supportsMaxOutputTokens=${mi?.supportsMaxOutputTokens} agent=${prepared.request.agent}`);
             try {
-                debugLog(`providerOptions=${JSON.stringify(childRuntime.providerOptions ?? {})}`);
+                debugLog(`providerOptions=${JSON.stringify(childProviderOptions ?? {})}`);
             }
             catch {
                 /* providerOptions may contain non-serializable refs */
@@ -286,7 +327,7 @@ export class StreamRunner {
         const compactThreshold = getSubAgentCompactThresholdChars();
         const compactKeepLast = getSubAgentCompactKeepLast();
         // Phase O1 — capture providerOptions SHAPE (types only) for forensics.
-        this.deps.setLastProviderOptionsShape(extractProviderOptionsShape(childRuntime.providerOptions));
+        this.deps.setLastProviderOptionsShape(extractProviderOptionsShape(childProviderOptions));
         if (wireDebug.enabled) {
             wireDebug.logRequest({
                 providerId: childRuntime.modelInfo?.provider ?? "unknown",
@@ -294,21 +335,50 @@ export class StreamRunner {
                 messages: childMessages,
                 systemChars: childSystem?.length ?? 0,
                 toolNames: childTools ? Object.keys(childTools) : undefined,
-                providerOptions: childRuntime.providerOptions,
+                providerOptions: childProviderOptions,
             });
         }
         // SiliconFlow DeepSeek thinking-mode rejects assistant history with
         // `reasoning` parts (HTTP 400 code 20015). The siliconflow capability
         // override strips them; every other provider's capability is identity.
         const subMessagesForCall = taskCaps.sanitizeHistory(childMessages);
+        // Phase 4 Plan 04 (4B) — mirror top-level scope-ceiling integration.
+        // Sub-agent ceiling resolves against ("general", "medium") because the
+        // sub-agent has no PIL ctx of its own; the caller already bounded the
+        // work via maxSteps. We compose alongside that hard step cap so a
+        // wandering sub-agent loop trips whichever fires first (logical OR).
+        const _subCeiling = resolveCeiling("general", "medium");
+        const _subCounterKey = `subagent:${subCallId}`;
+        const _subStopWhen = (async (state) => {
+            if (state.steps.length >= maxSteps)
+                return true;
+            const next = incSessionStep(_subCounterKey);
+            return next >= _subCeiling;
+        });
+        // Silent-hang guard — mirror the top-level loop (message-processor.ts).
+        // A sub-agent provider connection can accept the request but never send a
+        // chunk (overloaded/stalled backend); `streamText` has no time-to-first-
+        // byte timeout, so the drain loop below would block forever with ZERO user
+        // feedback. The watchdog aborts after getProviderStallTimeoutMs of silence
+        // and is re-armed by stall.pet() on every chunk. Cheap models (which run
+        // mostly as sub-agents via SAMR) hit this most.
+        let stallTriggered = false;
+        const stall = createStallWatchdog(getProviderStallTimeoutMs(), () => {
+            stallTriggered = true;
+        });
         const result = streamText({
             model: childRuntime.model,
             system: childSystem,
             messages: subMessagesForCall,
             tools: !taskCaps.supportsClientTools(childRuntime.modelInfo) ? {} : childTools,
-            stopWhen: stepCountIs(maxSteps),
+            stopWhen: _subStopWhen ?? stepCountIs(maxSteps),
             maxRetries: 0,
-            abortSignal: signal,
+            abortSignal: combineAbortSignals(signal, stall.signal),
+            // Repair malformed tool-call JSON args — same wiring as the top-level
+            // loop in message-processor.ts. Without this, sub-agents on models
+            // with broken tool-arg emission (Qwen3-30B-Instruct observed) loop on
+            // tool-error until the repetition detector aborts the whole run.
+            experimental_repairToolCall: repairToolCallHook,
             prepareStep: ({ messages, stepNumber }) => {
                 if (stepNumber < 1)
                     return undefined;
@@ -318,17 +388,75 @@ export class StreamRunner {
                 // level strip at call setup never sees this. Strip per step too via
                 // the capability hook (identity for non-siliconflow providers).
                 const stripped = taskCaps.sanitizeHistory(messages);
+                // G1 + G2 — pass the sub-agent's model context window so the
+                // compactor can use a token-aware threshold and shrink the keep
+                // window when the prompt is near the ceiling.
+                const childCtxWindow = childRuntime.modelInfo?.contextWindow ?? 0;
+                // Idea 3: support KEEP_TOOL_IDS even in sub-agent loops (if the token
+                // reached the child history via injected reminder or prior context).
+                let subKeepToolIds = [];
+                for (const m of stripped) {
+                    const c = m?.content;
+                    const texts = [];
+                    if (typeof c === "string")
+                        texts.push(c);
+                    if (Array.isArray(c))
+                        for (const p of c)
+                            if (typeof p?.text === "string")
+                                texts.push(p.text);
+                    const joined = texts.join(" ");
+                    const mKeep = joined.match(/KEEP_TOOL_IDS\s*[:=]\s*([a-z0-9_, -]+)/i);
+                    if (mKeep) {
+                        subKeepToolIds = mKeep[1].split(/[,\s]+/).map((s) => s.trim()).filter(Boolean);
+                        break;
+                    }
+                }
+                // Idea 4 persist for sub-agent elisions (best-effort; may lack full session but EE can still index the artifact content).
+                const persistSubArtifact = (toolCallId, toolName, fullContent, reason) => {
+                    try {
+                        getDefaultEEClient()
+                            .extract({ transcript: fullContent.slice(0, 4000), projectPath: process.cwd(), meta: { source: "tool-artifact", toolCallId, toolName, reason } }, AbortSignal.timeout(600))
+                            .catch(() => { });
+                    }
+                    catch { /* fail-open */ }
+                };
                 const compacted = compactSubAgentMessages(stripped, {
                     thresholdChars: compactThreshold,
                     keepLastTurns: compactKeepLast,
+                    contextWindowTokens: childCtxWindow,
+                    keepToolIds: subKeepToolIds.length ? subKeepToolIds : undefined,
+                    persistArtifact: persistSubArtifact,
                 });
+                // Phase 4A — scope reminder injection for the sub-agent loop.
+                // Mirror of the top-level wiring in message-processor.ts:
+                // K = cadenceForSize(size) where size defaults to "medium" because
+                // the sub-agent has no PIL ctx of its own (matches 4B sub-agent
+                // ceiling that uses ("general", "medium") above). Original prompt
+                // is `prepared.request.prompt`. Session id reuses the sub-agent
+                // counter key so soft-warn fires at most once per sub-agent call.
+                const _subSize = "medium";
+                const _subK = cadenceForSize(_subSize);
+                const _subShouldRemind = shouldInjectReminder(stepNumber, _subK);
+                const _subShouldWarn = shouldInjectSoftWarn(stepNumber, _subCeiling, _subCounterKey);
+                if (_subShouldRemind || _subShouldWarn) {
+                    const _baseReminder = buildScopeReminder({
+                        step: stepNumber,
+                        ceiling: _subCeiling,
+                        taskType: "general",
+                        size: _subSize,
+                        originalPrompt: prepared.request.prompt,
+                    });
+                    const _reminder = _subShouldWarn ? `[approaching ceiling] ${_baseReminder}` : _baseReminder;
+                    const withReminder = attachReminderToMessages(compacted, _reminder);
+                    return { messages: withReminder };
+                }
                 if (compacted === stripped && stripped === messages)
                     return undefined;
                 return { messages: compacted };
             },
             ...(childDropTemperature ? {} : { temperature: isExplore ? 0.2 : 0.5 }),
             ...(childDropMaxOutput ? {} : { maxOutputTokens: Math.min(this.deps.getMaxTokens(), 8_192) }),
-            ...(childRuntime.providerOptions ? { providerOptions: childRuntime.providerOptions } : {}),
+            ...(childProviderOptions ? { providerOptions: childProviderOptions } : {}),
             onFinish: ({ totalUsage, finishReason }) => {
                 const tu = totalUsage;
                 const details = tu.inputTokenDetails;
@@ -338,7 +466,10 @@ export class StreamRunner {
                     asNumber(raw?.prompt_cache_hit_tokens) ??
                     0;
                 const cacheCreationTokens = asNumber(details?.cacheWriteTokens) ?? asNumber(raw?.cache_creation_input_tokens) ?? 0;
-                this.deps.recordUsage({ ...totalUsage, cacheReadTokens, cacheCreationTokens }, "task", childRuntime.modelId);
+                this.deps.recordUsage({ ...totalUsage, cacheReadTokens, cacheCreationTokens }, "task", childRuntime.modelId, 
+                // O1 — thread THIS sub-agent's providerOptions shape so the task event
+                // records its own shape, not whatever the mutable field last held.
+                extractProviderOptionsShape(childProviderOptions));
                 // Task 2.6b — emit llm-done (agent-mode only).
                 try {
                     const _ar = globalThis.__muonroiAgentRuntime;
@@ -361,80 +492,105 @@ export class StreamRunner {
         let toolCallCount = 0;
         let textDeltaCount = 0;
         const wireProviderIdSub = childRuntime.modelInfo?.provider ?? "unknown";
-        for await (const part of result.fullStream) {
+        try {
+            for await (const part of result.fullStream) {
+                stall.pet(); // chunk arrived — reset the stall watchdog
+                if (signal?.aborted) {
+                    break;
+                }
+                if (debugSubagent) {
+                    partCounts[part.type] = (partCounts[part.type] ?? 0) + 1;
+                }
+                if (wireDebug.enabled) {
+                    wireDebug.logChunk(wireProviderIdSub, String(part.type ?? "unknown"), {
+                        hasText: typeof part.text === "string" ? part.text.length : undefined,
+                        hasReasoning: typeof part.reasoning === "string"
+                            ? part.reasoning.length
+                            : undefined,
+                        errorMsg: part.type === "error"
+                            ? (() => {
+                                const e = part.error;
+                                wireDebug.logError(wireProviderIdSub, e);
+                                return typeof e?.message === "string" ? e.message : String(e);
+                            })()
+                            : undefined,
+                    });
+                }
+                if (part.type === "text-delta") {
+                    textDeltaCount++;
+                    assistantText += part.text;
+                    // Task 2.6b — emit llm-token (agent-mode only; high-volume, default-off per Phase 4).
+                    try {
+                        const _ar = globalThis.__muonroiAgentRuntime;
+                        _ar?.emitEvent({
+                            t: "event",
+                            kind: "llm-token",
+                            correlationId: subCallId,
+                            delta: part.text,
+                            tokenIndex: subTokenIndex++,
+                        });
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                    continue;
+                }
+                if (part.type === "tool-call") {
+                    toolCallCount++;
+                    lastActivity = formatSubagentActivity(part.toolName, part.input);
+                    onActivity?.(lastActivity);
+                    continue;
+                }
+                if (debugSubagent) {
+                    // Capture finish reasons + error parts that we'd otherwise swallow.
+                    if (part.type === "error") {
+                        const errPart = part.error ?? part;
+                        const errStr = (() => {
+                            try {
+                                return JSON.stringify(errPart, Object.getOwnPropertyNames(errPart));
+                            }
+                            catch {
+                                return String(errPart);
+                            }
+                        })();
+                        debugLog(`stream-error-part: ${errStr.slice(0, 500)}`);
+                    }
+                    if (part.type === "finish") {
+                        const reason = part.finishReason ?? null;
+                        debugLog(`stream-finish: reason=${reason}`);
+                    }
+                }
+            }
             if (signal?.aborted) {
-                break;
+                return { output: "[Cancelled]", lastActivity, cancelled: true, assistantText };
             }
             if (debugSubagent) {
-                partCounts[part.type] = (partCounts[part.type] ?? 0) + 1;
+                debugLog(`stream-end: textDeltas=${textDeltaCount} toolCalls=${toolCallCount} assistantTextLen=${assistantText.length} parts=${JSON.stringify(partCounts)}`);
             }
-            if (wireDebug.enabled) {
-                wireDebug.logChunk(wireProviderIdSub, String(part.type ?? "unknown"), {
-                    hasText: typeof part.text === "string" ? part.text.length : undefined,
-                    hasReasoning: typeof part.reasoning === "string"
-                        ? part.reasoning.length
-                        : undefined,
-                    errorMsg: part.type === "error"
-                        ? (() => {
-                            const e = part.error;
-                            wireDebug.logError(wireProviderIdSub, e);
-                            return typeof e?.message === "string" ? e.message : String(e);
-                        })()
-                        : undefined,
-                });
-            }
-            if (part.type === "text-delta") {
-                textDeltaCount++;
-                assistantText += part.text;
-                // Task 2.6b — emit llm-token (agent-mode only; high-volume, default-off per Phase 4).
+            await result.response;
+        }
+        catch (err) {
+            // Provider stalled (no chunk within the stall timeout): surface a clear
+            // error toast + a failed ToolResult instead of an opaque hang/throw.
+            // Returning (not throwing) means run()'s transient-retry path is skipped
+            // — a stalled provider would just stall again for another full timeout.
+            // (retry-classifier also marks provider-stall non-transient as defence.)
+            if (stallTriggered) {
                 try {
                     const _ar = globalThis.__muonroiAgentRuntime;
-                    _ar?.emitEvent({
-                        t: "event",
-                        kind: "llm-token",
-                        correlationId: subCallId,
-                        delta: part.text,
-                        tokenIndex: subTokenIndex++,
-                    });
+                    _ar?.emitEvent({ t: "event", kind: "toast", level: "error", text: STALL_ERROR_MESSAGE });
                 }
                 catch {
-                    /* best-effort */
-                }
-                continue;
-            }
-            if (part.type === "tool-call") {
-                toolCallCount++;
-                lastActivity = formatSubagentActivity(part.toolName, part.input);
-                onActivity?.(lastActivity);
-                continue;
-            }
-            if (debugSubagent) {
-                // Capture finish reasons + error parts that we'd otherwise swallow.
-                if (part.type === "error") {
-                    const errPart = part.error ?? part;
-                    const errStr = (() => {
-                        try {
-                            return JSON.stringify(errPart, Object.getOwnPropertyNames(errPart));
-                        }
-                        catch {
-                            return String(errPart);
-                        }
-                    })();
-                    debugLog(`stream-error-part: ${errStr.slice(0, 500)}`);
-                }
-                if (part.type === "finish") {
-                    const reason = part.finishReason ?? null;
-                    debugLog(`stream-finish: reason=${reason}`);
+                    /* best-effort toast */
                 }
+                onActivity?.(STALL_ERROR_MESSAGE);
+                return { output: STALL_ERROR_MESSAGE, lastActivity, cancelled: false, assistantText, stalled: true };
             }
+            throw err;
         }
-        if (signal?.aborted) {
-            return { output: "[Cancelled]", lastActivity, cancelled: true, assistantText };
-        }
-        if (debugSubagent) {
-            debugLog(`stream-end: textDeltas=${textDeltaCount} toolCalls=${toolCallCount} assistantTextLen=${assistantText.length} parts=${JSON.stringify(partCounts)}`);
+        finally {
+            stall.dispose();
         }
-        await result.response;
         const output = assistantText.trim() || `Task completed. Last action: ${lastActivity}`;
         return { output, lastActivity, cancelled: false, assistantText };
     }
@@ -475,6 +631,21 @@ export class StreamRunner {
             if (streamResult.cancelled) {
                 return { success: false, output: "[Cancelled]" };
             }
+            if (streamResult.stalled) {
+                // Provider stalled — surface as a failed task so the parent agent (and
+                // the user via the toast emitted in runStream) sees it, instead of a
+                // success carrying the stall message as "output".
+                return {
+                    success: false,
+                    output: streamResult.output,
+                    task: {
+                        agent: request.agent,
+                        description: request.description,
+                        summary: firstLine(streamResult.output),
+                        activity: lastActivity,
+                    },
+                };
+            }
             return {
                 success: true,
                 output: streamResult.output,

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

@@ -58,7 +58,9 @@ export function compressForCap(state, raw) {
         const firstSeen = state.seenHashes.get(hash);
         if (firstSeen !== undefined) {
             state.dedupHits += 1;
-            const stub = `[duplicate tool output detected — identical to result of call #${firstSeen} in this ${state.label} (sha1:${hash}, ${raw.length} chars). Reuse the earlier result instead of re-running.]`;
+            // F4 — short marker (~50 chars vs ~150). Hash and length are nice-to-
+            // have but the LLM only needs "this is a known duplicate of call #N".
+            const stub = `[dup of call #${firstSeen} — reuse it]`;
             state.cumulative += stub.length;
             return stub;
         }
@@ -89,6 +91,24 @@ function compressResult(state, raw) {
         if (typeof obj.output === "string") {
             return { ...obj, output: compressForCap(state, obj.output) };
         }
+        // MCP tool result shape: { type: "content", value: [{type:"text", text}, ...] }.
+        // Without this branch the whole payload escaped the cumulative tracker —
+        // its text never counted toward the budget and was never compressed, so
+        // many MCP calls could blow past the cap. Thread each text part through
+        // compressForCap (counts + compresses + dedups); leave non-text parts
+        // (images/media) intact so base64 isn't corrupted.
+        if (obj.type === "content" && Array.isArray(obj.value)) {
+            const value = obj.value.map((part) => {
+                if (part &&
+                    typeof part === "object" &&
+                    part.type === "text" &&
+                    typeof part.text === "string") {
+                    return { ...part, text: compressForCap(state, part.text) };
+                }
+                return part;
+            });
+            return { ...obj, value };
+        }
     }
     return raw;
 }

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

@@ -54,8 +54,8 @@ describe("compressForCap", () => {
         expect(first).toBe(payload);
         expect(state.dedupHits).toBe(0);
         const second = compressForCap(state, payload);
-        expect(second).toContain("duplicate tool output detected");
-        expect(second).toContain("call #1");
+        expect(second).toContain("dup of call");
+        expect(second).toContain("#1");
         expect(state.dedupHits).toBe(1);
         // Cumulative should grow by stub length, NOT full payload length again.
         expect(state.cumulative).toBeLessThan(payload.length * 2);
@@ -114,7 +114,7 @@ describe("wrapToolSetWithCap", () => {
         let counter = 0;
         const innerExec = async () => {
             counter++;
-            return `${counter}-` + "Z".repeat(20_000);
+            return `${counter}-${"Z".repeat(20_000)}`;
         };
         const tools = {
             sample: {
@@ -166,5 +166,43 @@ describe("wrapToolSetWithCap", () => {
         expect(out.output.length).toBeLessThan(50_000);
         expect(out.output).toContain("trimmed");
     });
+    it("counts MCP content-array text toward the cumulative budget", async () => {
+        // MCP tools return { type: "content", value: [{type:"text", text}, ...] },
+        // not a string or {output}. Previously this shape escaped the cumulative
+        // tracker entirely (cumulative stayed 0), letting many MCP calls blow past
+        // the budget even with the per-call cap in place.
+        const innerExec = async () => ({ type: "content", value: [{ type: "text", text: "M".repeat(5_000) }] });
+        const tools = {
+            mcp_demo__q: { description: "mcp", inputSchema: {}, execute: innerExec },
+        };
+        const { tools: wrapped, state } = wrapToolSetWithCap(tools, { maxCumulativeChars: 20_000 });
+        const execute = wrapped.mcp_demo__q.execute;
+        await execute({});
+        expect(state.cumulative).toBe(5_000);
+    });
+    it("compresses MCP content-array text parts when the budget is in the trim tier", async () => {
+        const innerExec = async () => ({ type: "content", value: [{ type: "text", text: "N".repeat(50_000) }] });
+        const tools = {
+            mcp_demo__big: { description: "mcp", inputSchema: {}, execute: innerExec },
+        };
+        const { tools: wrapped, state } = wrapToolSetWithCap(tools, { maxCumulativeChars: 20_000 });
+        state.cumulative = 7_000; // trim tier
+        const execute = wrapped.mcp_demo__big.execute;
+        const out = (await execute({}));
+        expect(out.type).toBe("content");
+        expect(out.value[0].text.length).toBeLessThan(50_000);
+        expect(out.value[0].text).toContain("trimmed");
+    });
+    it("leaves non-text MCP content parts (images) untouched", async () => {
+        const image = { type: "image", data: "BASE64", mediaType: "image/png" };
+        const innerExec = async () => ({ type: "content", value: [image] });
+        const tools = {
+            mcp_demo__img: { description: "mcp", inputSchema: {}, execute: innerExec },
+        };
+        const { tools: wrapped } = wrapToolSetWithCap(tools, { maxCumulativeChars: 20_000 });
+        const execute = wrapped.mcp_demo__img.execute;
+        const out = (await execute({}));
+        expect(out.value[0]).toEqual(image);
+    });
 });
 //# sourceMappingURL=sub-agent-cap.test.js.map

package/dist/src/orchestrator/sub-agent-model-tier.d.ts

@@ -0,0 +1,13 @@
+export type ModelTaskKind = "compact" | "explore" | "general" | "title" | "verify";
+export declare const TASK_TIER_PREFS: Record<ModelTaskKind, Array<"fast" | "balanced" | "premium">>;
+/** getModelByTier signature, injectable for testing. */
+export type TierLookup = (tier: "fast" | "balanced" | "premium", preferProvider?: string) => {
+    id: string;
+    provider: string;
+} | undefined;
+/**
+ * Resolve the model id for a task kind on a given provider. Walks the tier
+ * preference list, accepting only same-provider matches, and falls back to
+ * `fallbackModelId` (the parent model) when nothing matches.
+ */
+export declare function resolveModelForTask(task: ModelTaskKind, providerId: string, fallbackModelId: string, lookup?: TierLookup): string;

package/dist/src/orchestrator/sub-agent-model-tier.js

@@ -0,0 +1,45 @@
+/**
+ * Tier policy for picking the model of a mechanical/delegated task within a turn.
+ *
+ * The parent (top) model decides WHAT to do; the focused sub-task that follows
+ * rarely needs the top premium model. Each task kind declares a tier preference,
+ * resolved against the CURRENT provider only — we never cross providers here to
+ * avoid billing surprises (a stray key) and keychain complexity. If no model at
+ * a preferred tier exists on the provider, we fall through to the next tier and
+ * finally to the parent model, so a premium-only provider sees no change.
+ *
+ * Kinds:
+ *  - compact / title : pure mechanical text ops → cheapest first.
+ *  - explore         : read-only research → balanced is plenty.
+ *  - general         : delegated multi-step execution → balanced (the parent
+ *                      already did the hard thinking); falls back to premium.
+ *  - verify          : validation/verification → premium first; rigor matters
+ *                      more than cost here, so we do NOT downgrade by default.
+ */
+import { getModelByTier } from "../models/registry.js";
+export const TASK_TIER_PREFS = {
+    compact: ["fast", "balanced"],
+    title: ["fast", "balanced"],
+    explore: ["balanced", "fast"],
+    // general sub-agents downgrade to balanced (was premium-first) — the top
+    // model already planned the delegation; the focused execution doesn't need
+    // premium. Premium remains the fallback so premium-only providers are unaffected.
+    general: ["balanced", "premium"],
+    // verify keeps premium-first: a downgrade here would weaken the very check it
+    // exists to perform. Mirrors council `verify` role preference.
+    verify: ["premium", "balanced"],
+};
+/**
+ * Resolve the model id for a task kind on a given provider. Walks the tier
+ * preference list, accepting only same-provider matches, and falls back to
+ * `fallbackModelId` (the parent model) when nothing matches.
+ */
+export function resolveModelForTask(task, providerId, fallbackModelId, lookup = getModelByTier) {
+    for (const tier of TASK_TIER_PREFS[task] ?? ["balanced"]) {
+        const m = lookup(tier, providerId);
+        if (m?.provider === providerId)
+            return m.id;
+    }
+    return fallbackModelId;
+}
+//# sourceMappingURL=sub-agent-model-tier.js.map