muonroi-cli 1.7.1 → 1.8.0

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

@@ -1,10 +1,11 @@
 import type { ModelMessage } from "ai";
 import { type ProviderId } from "../providers/types.js";
 import { type ScheduleDaemonStatus, type StoredSchedule } from "../tools/schedule.js";
-import type { AgentMode, ChatEntry, SessionInfo, SessionSnapshot, StreamChunk, SubagentStatus, TaskRequest, ToolResult, VerifyRecipe } from "../types/index.js";
+import type { AgentMode, ChatEntry, SessionInfo, SessionSnapshot, StreamChunk, SubagentStatus, TaskListSnapshot, TaskRequest, ToolResult, VerifyRecipe } from "../types/index.js";
 import { type SandboxMode, type SandboxSettings } from "../utils/settings.js";
 import { type SideQuestionResult } from "../utils/side-question.js";
 import { type AgentOptions, type ProcessMessageObserver } from "./agent-options.js";
+import type { SafetyOverrideAskInfo, SafetyOverrideVerdict } from "./safety-askcard.js";
 import type { ToolLoopCapAsk } from "./tool-loop-cap.js";
 export declare class Agent {
     private provider;
@@ -111,7 +112,7 @@ export declare class Agent {
     setModel(model: string): void;
     getMode(): AgentMode;
     getSandboxMode(): SandboxMode;
-    setSandboxMode(mode: SandboxMode): void;
+    setSandboxMode(_mode: SandboxMode): void;
     getSandboxSettings(): SandboxSettings;
     setSandboxSettings(settings: SandboxSettings): void;
     setMode(mode: AgentMode): void;
@@ -140,6 +141,8 @@ export declare class Agent {
     cleanup(): Promise<void>;
     private _toolLoopCapHandler;
     setToolLoopCapHandler(fn: ToolLoopCapAsk | null): void;
+    private _safetyOverrideHandler;
+    setSafetyOverrideHandler(fn: ((block: SafetyOverrideAskInfo) => Promise<SafetyOverrideVerdict>) | null): void;
     respondToToolApproval(approvalId: string, approved: boolean): void;
     clearHistory(): Promise<void>;
     startNewSession(): SessionSnapshot | null;
@@ -161,6 +164,7 @@ export declare class Agent {
     unpinMessageBySeq(seq: number): boolean;
     getPinnedSeqs(): number[];
     getChatEntries(): ChatEntry[];
+    getLastTodoSnapshot(): TaskListSnapshot | null;
     getSessionSnapshot(): SessionSnapshot | null;
     onSubagentStatus(listener: (status: SubagentStatus | null) => void): () => void;
     private emitSubagentStatus;
@@ -183,6 +187,7 @@ export declare class Agent {
     private runDelegation;
     private readDelegation;
     private listDelegations;
+    private killDelegation;
     private getCompactionSettings;
     private _resolveCompactModel;
     private _resolveModelForTask;
@@ -225,6 +230,7 @@ export declare class Agent {
      * allocation cost is negligible against the batch polling spend.
      */
     private _buildBatchTurnRunnerDeps;
+    private appendMidTurnMessages;
     private appendCompletedTurn;
     private fireHook;
     processMessage(userMessage: string, observer?: ProcessMessageObserver, images?: Array<{

package/dist/src/orchestrator/orchestrator.js

@@ -14,22 +14,24 @@ import { apiBaseFor } from "../providers/endpoints.js";
 import { loadKeyForProvider } from "../providers/keychain.js";
 import { createProviderFactory, createProviderFactoryAsync, detectProviderForModel, requireRuntimeProvider, resolveModelRuntime as resolveRuntime, } from "../providers/runtime.js";
 import { ALL_PROVIDER_IDS } from "../providers/types.js";
-import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, logInteraction, markMessageCompleted, recordUsageEvent, SessionStore, } from "../storage/index.js";
+import { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionTotalTokens, loadTranscript, loadTranscriptState, logInteraction, markMessageCompleted, recordUsageEvent, SessionStore, } from "../storage/index.js";
 import { BashTool } from "../tools/bash.js";
 import { createBuiltinTools } from "../tools/registry.js";
 import { ScheduleManager } from "../tools/schedule.js";
+import { snapshotFromTodoWriteArgs } from "../tools/todo-write-snapshot.js";
 import { statusBarStore } from "../ui/status-bar/store.js";
 import { appendCostLog } from "../usage/cost-log.js";
 import { appendDecisionLog } from "../usage/decision-log.js";
-import { projectCostUSD } from "../usage/estimator.js";
+import { projectCostUSD, sanitizeInputTokens } from "../usage/estimator.js";
 import { getAutoCompactThresholdPct, getCouncilRounds, getCurrentModel, getCurrentShellSettings, getModeSpecificModel, getRoleModel, getRoleModels, isAutoCompactAfterTurnEnabled, isCouncilMultiProviderPreferred, isProviderDisabled, } from "../utils/settings.js";
 import { runSideQuestion } from "../utils/side-question.js";
 import { buildVerifyDetectPrompt, normalizeVerifyRecipe } from "../verify/entrypoint.js";
 import { runVerifyOrchestration } from "../verify/orchestrator.js";
 import { COUNCIL_COLOR_BG, COUNCIL_COLOR_RESET, COUNCIL_ROLE_COLORS, } from "./agent-options.js";
+import { AUTO_COMMIT_ATTRIBUTION, isAutoCommitEnabled, maybeAutoCommitTurn, snapshotDirtyPaths, } from "./auto-commit.js";
 import { BatchTurnRunner } from "./batch-turn-runner.js";
 import { accumulateUsage, buildAssistantBatchMessage, buildBatchChatCompletionRequest, buildBatchName, buildToolBatchMessage, extractJsonObject, getBatchUsage, hasUsage, parseToolArgumentsOrRaw, toLocalToolCall, } from "./batch-utils.js";
-import { createCompactionSummaryMessage, DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS, estimateConversationTokens, extractUserContent, generateCompactionSummary, POST_TURN_MIN_TOKENS, prepareCompaction, shouldCompactContext, } from "./compaction.js";
+import { createCompactionSummaryMessage, DEFAULT_KEEP_RECENT_TOKENS, DEFAULT_RESERVE_TOKENS, estimateConversationTokens, extractUserContent, generateCompactionSummary, POST_TURN_MIN_TOKENS, prepareCompaction, proposeCompaction, shouldCompactContext, } from "./compaction.js";
 import { CouncilManager } from "./council-manager.js";
 import { CrossTurnDedup, isCrossTurnDedupEnabled } from "./cross-turn-dedup.js";
 import { DelegationManager } from "./delegations.js";
@@ -105,6 +107,7 @@ function createTools(_bash, _provider, _mode, _opts) {
         runDelegation: _opts?.runDelegation,
         readDelegation: _opts?.readDelegation,
         listDelegations: _opts?.listDelegations,
+        killDelegation: _opts?.killDelegation,
         modelId: _opts?.modelId,
     });
 }
@@ -355,10 +358,12 @@ export class Agent {
         return this.mode;
     }
     getSandboxMode() {
+        // Sandbox has been removed; BashTool.getSandboxMode() always returns "off".
         return this.bash.getSandboxMode();
     }
-    setSandboxMode(mode) {
-        this.bash.setSandboxMode(mode);
+    setSandboxMode(_mode) {
+        // No-op: sandbox has been removed. BashTool no longer has a mutable sandbox mode.
+        // Will be re-implemented when the new sandbox is ready.
     }
     getSandboxSettings() {
         return this.bash.getSandboxSettings();
@@ -516,6 +521,15 @@ export class Agent {
     setToolLoopCapHandler(fn) {
         this._toolLoopCapHandler = fn;
     }
+    // Safety-override handler — set by the UI (app.tsx) at startup. Invoked
+    // from the message-processor tool-result pipeline when a safety block
+    // (catastrophic, dangerous, git-safety, empty-bash) is detected. The UI
+    // surfaces an askcard ("Allow once / Allow session / Block") and resolves
+    // with the verdict. When unset, blocks pass through as normal errors.
+    _safetyOverrideHandler = null;
+    setSafetyOverrideHandler(fn) {
+        this._safetyOverrideHandler = fn;
+    }
     respondToToolApproval(approvalId, approved) {
         const toolApprovalResponse = {
             role: "tool",
@@ -640,6 +654,14 @@ export class Agent {
             return [];
         return buildChatEntries(this.session.id);
     }
+    getLastTodoSnapshot() {
+        if (!this.session)
+            return null;
+        const argsJson = getLastTodoWriteArgs(this.session.id);
+        if (!argsJson)
+            return null;
+        return snapshotFromTodoWriteArgs(argsJson);
+    }
     getSessionSnapshot() {
         if (!this.session || !this.workspace)
             return null;
@@ -765,6 +787,10 @@ export class Agent {
         // where orchestrator/task/title traffic is actually spending.
         // Best-effort: failures inside appendCostLog are swallowed (see cost-log.ts).
         const breakdown = source === "message" ? (this._lastPromptBreakdown ?? undefined) : undefined;
+        // Sanitize actualInputTokens for providers (e.g. SiliconFlow) that return
+        // implausibly low prompt_tokens (e.g. 10) regardless of prompt size.
+        const estIn = breakdown ? Math.ceil(((breakdown.systemChars ?? 0) + (breakdown.messagesChars ?? 0)) / 4) : 0;
+        const actualInput = sanitizeInputTokens(totalInput, estIn);
         appendCostLog({
             ts: Date.now(),
             provider: this.providerId,
@@ -772,7 +798,7 @@ export class Agent {
             estimatedUsd: turnCostMicros / 1_000_000,
             callsite: `orchestrator.${source}`,
             phase: source,
-            actualInputTokens: totalInput,
+            actualInputTokens: actualInput,
             actualOutputTokens: output,
             cachedInputTokens: cacheRead,
             systemChars: breakdown?.systemChars,
@@ -1162,15 +1188,29 @@ export class Agent {
             };
         }
     }
+    async killDelegation(id) {
+        try {
+            return await this.delegations.kill(id);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                output: `Failed to terminate delegation: ${msg}`,
+            };
+        }
+    }
     getCompactionSettings(contextWindow) {
         let keepRecentTokens = DEFAULT_KEEP_RECENT_TOKENS;
         // For models with very large context windows, keep more recent tokens
         if (contextWindow && contextWindow > 200_000) {
             keepRecentTokens = Math.min(100_000, Math.max(20_000, Math.floor(contextWindow * 0.1)));
         }
-        // Compact more aggressively for long sessions to prevent runaway token growth
+        // For long sessions, reduce keepRecentTokens slightly to slow context growth
+        // (0.85 instead of old 0.75 — session bf58d0f46b51 showed 0.75 created a
+        // tight compact-loop: keep 15K → add 50K tool results → re-compact immediately).
         if (this._compactionStats.count >= 2) {
-            keepRecentTokens = Math.floor(keepRecentTokens * 0.75);
+            keepRecentTokens = Math.floor(keepRecentTokens * 0.85);
         }
         return {
             reserveTokens: Math.max(this.maxTokens, DEFAULT_RESERVE_TOKENS),
@@ -1186,12 +1226,28 @@ export class Agent {
     async compactForContext(provider, system, contextWindow, signal, settings = this.getCompactionSettings(contextWindow), force = false) {
         if (!this.session)
             return false;
+        // Phase 1: ask the compaction proposer model whether to compact and what to keep/drop.
+        // Only compact if the model says yes. On error/skip, fall back to heuristic.
+        const compactModelId = this._resolveCompactModel();
+        const proposal = await proposeCompaction(provider, compactModelId, this.messages, signal);
+        if (proposal !== null) {
+            // Model decided — compact only if model says shouldCompact
+            if (force) {
+                // force always proceeds; the proposer's actions still guide what to keep/drop
+            }
+            else if (!proposal.shouldCompact) {
+                return false;
+            }
+        }
+        else {
+            // Proposer unavailable — fall back to heuristic token-threshold check
+            if (!force && !shouldCompactContext(estimateConversationTokens(system, this.messages), contextWindow, settings)) {
+                return false;
+            }
+        }
         const preparation = prepareCompaction(this.messages, system, settings);
         if (!preparation)
             return false;
-        if (!force && !shouldCompactContext(preparation.tokensBefore, contextWindow, settings)) {
-            return false;
-        }
         const trigger = force ? "manual" : "auto";
         // Fire-and-forget: notify EE of stale suggestions before compaction
         const { surfacedIds, timestamp } = getLastSurfacedState();
@@ -1219,7 +1275,6 @@ export class Agent {
         await this.fireHook(preCompactInput, signal).catch(() => { });
         const keptSeqs = this.messageSeqs.slice(preparation.firstKeptIndex);
         const firstKeptSeq = keptSeqs.find((seq) => seq !== null) ?? getNextMessageSequence(this.session.id);
-        const compactModelId = this._resolveCompactModel();
         const compactStartedAt = Date.now();
         const { summary, usage: compactUsage } = await generateCompactionSummary(provider, compactModelId, preparation, undefined, signal);
         // Record compaction call in cost-log — bypasses recordUsage because
@@ -1285,11 +1340,15 @@ export class Agent {
             .catch(() => { });
         // Mark as surfaced for prompt-stale reconciliation (per plan Phase 1).
         updateLastSurfacedState([`compact-checkpoint-${this._compactionStats.count + 1}`]);
-        // Track compaction stats — net of the tokens spent ON compaction itself.
+        // Track compaction stats — report the GROSS context reduction, NOT net-after-compact-cost.
+        // Rationale: the compaction call's own prompt/completion tokens ARE already counted in
+        // in_tokens/out_tokens/session_usd (updateStatusBar at line 986). Subtracting them here
+        // would double-penalize: the user sees the real cost in the token counter AND sees
+        // "0 saved" because compactCost >= grossSaved (the compact prompt is the full conversation).
+        // grossSaved tells the user how many context tokens were reclaimed — a real benefit that
+        // reduces subsequent turn costs.
         const tokensAfter = estimateConversationTokens(system, this.messages);
-        const grossSaved = Math.max(0, preparation.tokensBefore - tokensAfter);
-        const compactCost = compactUsage.promptTokens + compactUsage.completionTokens;
-        const saved = Math.max(0, grossSaved - compactCost);
+        const saved = Math.max(0, preparation.tokensBefore - tokensAfter);
         const pct = preparation.tokensBefore > 0 ? ((saved / preparation.tokensBefore) * 100).toFixed(1) : "0.0";
         this._compactionStats.count++;
         this._compactionStats.totalSaved += saved;
@@ -1317,8 +1376,6 @@ export class Agent {
                         tokensBefore: preparation.tokensBefore,
                         tokensAfter,
                         saved,
-                        grossSaved,
-                        compactCost,
                         pct,
                         isLongSession,
                     },
@@ -1383,23 +1440,67 @@ export class Agent {
         const councilStats = { calls: 0, startMs: Date.now(), phases: [] };
         const llm = createCouncilLLM(this.bash, this.mode, this.session?.id, councilStats);
         const processMessageFn = (message) => this.processMessage(message, options?.observer);
-        const gen = runCouncil(topic, this.modelId, this.messages, this.session?.id, llm, this.councilManager.createQuestionResponder(), this.councilManager.createPreflightResponder(), processMessageFn, {
-            skipClarification: options?.skipClarification,
-            userModelMessage: options?.userModelMessage,
-            cwd: this.bash.getCwd(),
-            councilStats, // NEW — share orchestrator's stats object with runCouncil (Phase 14 CQ-01)
-        });
-        let result;
-        do {
-            result = await gen.next();
-            if (!result.done && result.value) {
-                yield result.value;
+        // Ensure a turn-scoped AbortController exists so Esc → agent.abort() →
+        // this.abortController.abort() actually cancels the council. Two entry points
+        // reach here: the auto-council path runs INSIDE processMessage, which already
+        // set this.abortController; the /council SLASH path calls runCouncilV2
+        // directly with NONE set — so before this guard, pressing Esc during an
+        // explicit /council run was a no-op (abort() hit a null controller) and the
+        // multi-minute debate ran to completion regardless. Create one when absent
+        // so the user-abort signal threads into every council generate/debate/
+        // research call for BOTH entry points. Only tear down a controller we own.
+        const ownsController = !this.abortController;
+        if (ownsController) {
+            this.abortController = new AbortController();
+        }
+        const signal = this.abortController?.signal;
+        // B1: Resolve a run directory so runCouncil persists decisions.lock.md after
+        // synthesis. The auto-council/sprint paths get a runDir from their own flow
+        // wiring, but the explicit /council SLASH path never did — so its outcome was
+        // never written to disk (no audit trail, nothing for a later /ideal to read).
+        // Reuse the session's active flow run; create one if the session never booted
+        // a flow. Fail-open: a runDir-resolution error must not block the council.
+        let runDir;
+        try {
+            const nodePath = await import("node:path");
+            const flowDir = await ensureFlowDir(this.bash.getCwd());
+            let runId = this._activeRunId ?? (await getActiveRunId(flowDir));
+            if (!runId) {
+                runId = (await createRun(flowDir)).id;
+                await setActiveRunId(flowDir, runId);
+                this._activeRunId = runId;
+            }
+            runDir = nodePath.join(flowDir, "runs", runId);
+        }
+        catch (err) {
+            console.error(`[council] runDir resolution failed (decisions.lock will be skipped): ${err?.message}`);
+        }
+        try {
+            const gen = runCouncil(topic, this.modelId, this.messages, this.session?.id, llm, this.councilManager.createQuestionResponder(), this.councilManager.createPreflightResponder(), processMessageFn, {
+                skipClarification: options?.skipClarification,
+                userModelMessage: options?.userModelMessage,
+                cwd: this.bash.getCwd(),
+                councilStats, // NEW — share orchestrator's stats object with runCouncil (Phase 14 CQ-01)
+                signal,
+                runDir, // B1 — persist decisions.lock.md for the /council slash path
+            });
+            let result;
+            do {
+                result = await gen.next();
+                if (!result.done && result.value) {
+                    yield result.value;
+                }
+            } while (!result.done);
+            const synthesis = result.value;
+            this.councilManager.setLastSynthesis(synthesis);
+            if (options?.userModelMessage && synthesis) {
+                this.appendCompletedTurn(options.userModelMessage, [{ role: "assistant", content: synthesis }]);
+            }
+        }
+        finally {
+            if (ownsController && this.abortController?.signal === signal) {
+                this.abortController = null;
             }
-        } while (!result.done);
-        const synthesis = result.value;
-        this.councilManager.setLastSynthesis(synthesis);
-        if (options?.userModelMessage && synthesis) {
-            this.appendCompletedTurn(options.userModelMessage, [{ role: "assistant", content: synthesis }]);
         }
     }
     // ========================================================================
@@ -1930,12 +2031,27 @@ export class Agent {
             runDelegation: (request, signal) => self.runDelegation(request, signal),
             readDelegation: (id) => self.readDelegation(id),
             listDelegations: () => self.listDelegations(),
+            killDelegation: (id) => self.killDelegation(id),
             executeBatchToolCall: (tools, toolCall, messages, signal) => self.executeBatchToolCall(tools, toolCall, messages, signal),
             appendCompletedTurn: (user, asst) => self.appendCompletedTurn(user, asst),
             discardAbortedTurn: (user) => self.discardAbortedTurn(user),
             recordUsage: (usage, source, model, shape) => self.recordUsage(usage, source, model, shape),
         };
     }
+    appendMidTurnMessages(newMessages) {
+        if (newMessages.length === 0)
+            return;
+        if (!this.sessionStore || !this.session) {
+            this.messages.push(...newMessages);
+            this.messageSeqs.push(...newMessages.map(() => null));
+            return;
+        }
+        const insertedSeqs = appendMessages(this.session.id, newMessages);
+        this.messages.push(...newMessages);
+        this.messageSeqs.push(...insertedSeqs);
+        this.sessionStore.touchSession(this.session.id, this.bash.getCwd());
+        this.session = this.sessionStore.getRequiredSession(this.session.id);
+    }
     appendCompletedTurn(userMessage, newMessages) {
         if (newMessages.length === 0)
             return;
@@ -1987,7 +2103,28 @@ export class Agent {
     // ========================================================================
     async *processMessage(userMessage, observer, images) {
         const processor = new MessageProcessor(this._buildMessageProcessorDeps());
+        // Deterministic "task done -> commit" (auto-commit): snapshot the dirty set
+        // before the turn so we can commit ONLY the files the agent changes during it
+        // (and never the user's pre-existing work-in-progress). Gated off under tests
+        // and via MUONROI_AUTO_COMMIT=0.
+        const autoCommitOn = isAutoCommitEnabled();
+        const cwd = this.bash.getCwd();
+        const dirtyBefore = autoCommitOn ? await snapshotDirtyPaths(cwd) : new Set();
         yield* processor.run(userMessage, observer, images);
+        // Reached only when the turn completed normally (an abort/throw propagates
+        // through yield* and skips this) — exactly when committing is appropriate.
+        if (autoCommitOn) {
+            const auto = await maybeAutoCommitTurn({ cwd, dirtyBefore, userMessage }).catch((err) => {
+                console.error(`[auto-commit] unexpected failure: ${err?.message}`);
+                return { committed: false };
+            });
+            if (auto.committed) {
+                yield {
+                    type: "content",
+                    content: `\n✓ Auto-committed ${auto.fileCount} file(s) → ${auto.sha} (${AUTO_COMMIT_ATTRIBUTION})\n`,
+                };
+            }
+        }
     }
     /**
      * Build the DI surface MessageProcessor (Phase 12.4) needs to reach back
@@ -2133,7 +2270,9 @@ export class Agent {
             runDelegation: (request, signal) => self.runDelegation(request, signal),
             readDelegation: (id) => self.readDelegation(id),
             listDelegations: () => self.listDelegations(),
+            killDelegation: (id) => self.killDelegation(id),
             drainSteerMessages: () => self.steerDrain?.() ?? [],
+            appendMidTurnMessages: (msgs) => self.appendMidTurnMessages(msgs),
             appendCompletedTurn: (user, asst) => self.appendCompletedTurn(user, asst),
             discardAbortedTurn: (user) => self.discardAbortedTurn(user),
             recordUsage: (usage, source, model, shape) => self.recordUsage(usage, source, model, shape),
@@ -2150,6 +2289,20 @@ export class Agent {
                     return "stop";
                 }
             },
+            askSafetyOverride: async (info) => {
+                const h = self._safetyOverrideHandler;
+                if (!h) {
+                    console.warn(`[Agent] askSafetyOverride called but no handler registered — blocking ${info.kind}: ${info.reason}`);
+                    return { action: "block" };
+                }
+                try {
+                    return await h(info);
+                }
+                catch (err) {
+                    console.error(`[Agent] askSafetyOverride crashed: ${err?.message ?? err}`);
+                    return { action: "block" };
+                }
+            },
             runCouncilV2: (msg, opts) => self.runCouncilV2(msg, opts),
             processMessage: (msg, obs, imgs) => self.processMessage(msg, obs, imgs),
             processMessageBatchTurn: (args) => self.processMessageBatchTurn(args),

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

@@ -0,0 +1,13 @@
+import { runPipeline } from "../pil/pipeline.js";
+import type { StreamChunk } from "../types/index.js";
+import type { MessageProcessorDeps } from "./message-processor.js";
+import { type ComplexitySize } from "./scope-ceiling.js";
+export interface PreprocessorResult {
+    pilCtx: Awaited<ReturnType<typeof runPipeline>>;
+    _stepCeiling: number;
+    _pilStart: number;
+    _naturalCeiling: number;
+    _ceilingTaskType: string;
+    _ceilingSize: ComplexitySize;
+}
+export declare function prepareTurnContext(deps: MessageProcessorDeps, userMessage: string, _budgetOverride: any): AsyncGenerator<StreamChunk, PreprocessorResult, unknown>;

package/dist/src/orchestrator/preprocessor.js

@@ -0,0 +1,145 @@
+import { runPipeline } from "../pil/pipeline.js";
+import { getSessionLastTask, recordSessionLastTask, resolveCeiling } from "./scope-ceiling.js";
+export async function* prepareTurnContext(deps, userMessage, _budgetOverride) {
+    // PIL: enrich prompt before pushing to messages (D-01, D-03, D-04)
+    // Promise.race timeout of 200ms is inside runPipeline — fail-open guaranteed
+    // --- PIL with discovery (interactive path) ---
+    const pilChunkQueue = [];
+    const pilResponder = deps.councilManager.createQuestionResponder();
+    const discoveryHandler = {
+        askQuestion: async (question) => {
+            pilChunkQueue.push({
+                type: "council_question",
+                content: question.question,
+                councilQuestion: question,
+            });
+            const text = await pilResponder(question.questionId);
+            return { questionId: question.questionId, text, kind: "choice" };
+        },
+    };
+    const _pilStart = Date.now();
+    let pilCtxResolved = null;
+    let pilDone = false;
+    const pilTask = (async () => {
+        try {
+            // Build Pass 4 LLM fallback closure using the orchestrator's already-
+            // constructed provider factory + current model. PIL stays ignorant of
+            // provider wiring — it just receives a `classify(prompt)` callback.
+            let llmFallback;
+            try {
+                const { createLlmClassifier } = await import("../pil/llm-classify.js");
+                llmFallback = createLlmClassifier(deps.requireProvider(), deps.modelId);
+            }
+            catch (err) {
+                console.error(`[pil] LLM fallback wiring failed: ${err?.message}`);
+            }
+            // Model-driven clarification proposer (for discovery interview).
+            // The actual task model (via the same provider + modelId) generates the
+            // questions based on raw + CLI enrichment. Then discovery asks user.
+            let clarificationProposer;
+            try {
+                const { createModelClarificationProposer } = await import("../pil/discovery.js");
+                clarificationProposer = createModelClarificationProposer(deps.requireProvider(), deps.modelId);
+            }
+            catch (err) {
+                console.error(`[pil] clarification proposer wiring failed: ${err?.message}`);
+            }
+            pilCtxResolved = await runPipeline(userMessage, {
+                resumeDigest: deps.getResumeDigest(),
+                activeRunId: deps.getActiveRunId(),
+                sessionId: deps.session?.id ?? null,
+                interactionHandler: discoveryHandler,
+                llmFallback,
+                clarificationProposer,
+                recentTurnsSummary: deps.buildRecentTurnsSummary(),
+            });
+        }
+        catch (err) {
+            pilCtxResolved = {
+                raw: userMessage,
+                enriched: userMessage,
+                taskType: null,
+                domain: null,
+                confidence: 0,
+                outputStyle: null,
+                tokenBudget: 500,
+                metrics: null,
+                layers: [],
+                gsdPhase: null,
+                activeRunId: null,
+                intentKind: null,
+                fallbackReason: err instanceof Error ? `orchestrator-catch:${err.name}` : "orchestrator-catch:unknown",
+            };
+        }
+        finally {
+            pilDone = true;
+        }
+    })();
+    while (!pilDone) {
+        while (pilChunkQueue.length > 0) {
+            yield pilChunkQueue.shift();
+        }
+        if (!pilDone) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+    }
+    while (pilChunkQueue.length > 0) {
+        yield pilChunkQueue.shift();
+    }
+    await pilTask;
+    const pilCtx = pilCtxResolved;
+    // Phase 4 Plan 04 (4B) — resolve per-session step ceiling using
+    // (task_type × complexitySize) matrix. Override (from --budget-rounds N
+    // parsed earlier) wins. When the override differs from the natural
+    // ceiling, emit info toast so the user sees the explicit cap.
+    //
+    // Phase 5 Fix 2 — continuation phrases ("tiếp tục" / "continue") are
+    // classified `general/chitchat` by PIL Layer 1 Pass 0. Resolving the
+    // ceiling from that label collapses the budget to general × small = 5,
+    // which is wrong: the user wants the agent to RESUME the prior task,
+    // not start a generic chitchat. When this session has a recorded
+    // non-chitchat task row, inherit it for ceiling resolution. The Pass 0
+    // classification itself stays general so downstream code (style /
+    // chitchat skip / tools-empty optimization in `BUG-A guard`) reads the
+    // correct intent; only the ceiling row is borrowed.
+    const _pilTaskType = pilCtx.taskType ?? "general";
+    const _pilSize = pilCtx.complexitySize?.size ?? "medium";
+    const _sessionIdForLastTask = deps.session?.id ?? "";
+    const _isContinuationChitchat = _pilTaskType === "general" && pilCtx.intentKind === "chitchat" && _sessionIdForLastTask !== "";
+    const _lastTask = _isContinuationChitchat ? getSessionLastTask(_sessionIdForLastTask) : null;
+    const _ceilingTaskType = _lastTask?.taskType ?? _pilTaskType;
+    const _ceilingSize = _lastTask?.size ?? _pilSize;
+    const _naturalCeiling = resolveCeiling(_ceilingTaskType, _ceilingSize);
+    // Phase 5 Fix 4 (Option A) — make ceiling mutable so the stopWhen
+    // closure can bump it on auto-continue checkpoints. See checkpoint
+    // logic at dynamicStopWhen below for the bump policy.
+    const _stepCeiling = _budgetOverride.override ?? _naturalCeiling;
+    // Record this turn's task row for future continuation inheritance.
+    // Only non-chitchat task turns update the slot.
+    if (_sessionIdForLastTask && _pilTaskType !== "general" && pilCtx.intentKind === "task") {
+        recordSessionLastTask(_sessionIdForLastTask, _pilTaskType, _pilSize);
+    }
+    if (_budgetOverride.override !== undefined && _budgetOverride.override !== _naturalCeiling) {
+        try {
+            const _ar = globalThis.__muonroiAgentRuntime;
+            _ar?.emitEvent({
+                t: "event",
+                kind: "toast",
+                level: "info",
+                text: `override active: ceiling ${_budgetOverride.override}, default was ${_naturalCeiling} (task=${_ceilingTaskType}/size=${_ceilingSize})`,
+            });
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    return {
+        pilCtx,
+        _stepCeiling,
+        _pilStart,
+        _naturalCeiling,
+        _ceilingTaskType,
+        _ceilingSize: _ceilingSize,
+    };
+}
+//# sourceMappingURL=preprocessor.js.map

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

@@ -55,6 +55,12 @@ export interface SystemPromptOptions {
      * PIL Layer 1 (intentKind === "chitchat").
      */
     chitchat?: boolean;
+    /**
+     * When true (sub-agent), skip CUSTOM INSTRUCTIONS, skills catalog, and
+     * native capabilities — sub-agents don't need project-level instructions
+     * and can't run the full toolset anyway. Cuts ~6K tokens per sub-agent turn.
+     */
+    subAgent?: boolean;
 }
 /**
  * Render the LIVE per-turn MCP tool roster as a system-prompt block.
@@ -76,6 +82,8 @@ export interface SystemPromptOptions {
  */
 export declare function buildMcpCapabilityBlock(toolNames: readonly string[]): string;
 export declare function buildSystemPromptParts(cwd: string, mode: AgentMode, sandboxMode: SandboxMode, planContext?: string | null, subagents?: CustomSubagentConfig[], sandboxSettings?: SandboxSettings, providerId?: string, resumeDigest?: string | null, options?: SystemPromptOptions): SystemPromptParts;
+/** Reset the static prefix cache (for tests). */
+export declare function resetStaticPrefixCache(): void;
 export declare function buildSystemPrompt(cwd: string, mode: AgentMode, sandboxMode: SandboxMode, planContext?: string | null, subagents?: CustomSubagentConfig[], sandboxSettings?: SandboxSettings, providerId?: string, resumeDigest?: string | null, options?: SystemPromptOptions): string;
 export declare function buildSubagentPrompt(request: TaskRequest, cwd: string, custom: CustomSubagentConfig | null, sandboxMode: SandboxMode, subagents?: CustomSubagentConfig[], sandboxSettings?: SandboxSettings, providerId?: string): string;
 export declare function formatSandboxPromptSection(sandboxMode: SandboxMode, settings?: SandboxSettings): string;