@calliopelabs/cli 2.3.0 → 3.0.0

package/dist/ui/agent.js

@@ -15,16 +15,21 @@ import { formatError, classifyError } from '../errors.js';
 import { getAvailableProviders } from '../providers/index.js';
 import * as storage from '../storage.js';
 import * as hooks from '../hooks.js';
-import * as modelRouter from '../model-router.js';
+import * as router from '../router.js';
+import { fleetActive, fleetMirrorAssistant } from '../fleet.js';
 import * as summarization from '../summarization.js';
+import { autoCompress } from '../auto-compressor.js';
+import { createStreamFlusher } from '../streaming.js';
 import { executeParallel, getParallelizationStats } from '../parallel-tools.js';
-import { setMood } from '../companions.js';
 import { checkAndWarnContextLimit } from './context.js';
-import { smartRoute } from '../smart-router.js';
-import { shouldCheckpoint, createCheckpoint } from '../auto-checkpoint.js';
-import { recordEvent } from '../terminal-recording.js';
+import { smartRoute } from '../router.js';
+import { isLocalBackend, detectMalformedToolCall, buildRepairMessage, buildToolCallEnvelopeSchema, extractRepairedToolCall, getLocalModelProfile, } from '../local-model.js';
+import { shouldCheckpoint, createCheckpoint } from '../checkpoint.js';
 import { startPreventSleep, stopPreventSleep } from '../prevent-sleep.js';
 import { resolveIterationLimit, formatIterationProgress, isFiniteIterationLimit, } from '../iteration-limit.js';
+import { RunLog } from '../runlog.js';
+import { getBudgetCaps, evaluateBudget, hasBudgetCaps, recordProjectSpend, loadProjectSpend, formatBudgetHalt, } from '../budget.js';
+import { evaluatePolicy, isPolicyEnabled } from '../policy.js';
 // ============================================================================
 // Tool Result Truncation
 // ============================================================================
@@ -99,15 +104,116 @@ export function validateAndRepairMessagesImpl(ctx) {
     return repaired;
 }
 // ============================================================================
+// Local-model tool-call repair (features 2 & 3)
+// ============================================================================
+/**
+ * When a LOCAL backend returns a malformed tool call, spend ONE corrective
+ * round-trip trying to fix it before the error surfaces naturally through
+ * executeTool. At most one call is repaired per response (cost control on
+ * self-hosted hardware); each call id gets at most one repair (`repairedCallIds`).
+ *
+ * On Ollama we grammar-constrain the repair reply with the tool-call envelope
+ * schema (the `format` param) — but only here, never on normal prose turns.
+ *
+ * Cloud backends and well-formed responses pass straight through unchanged.
+ */
+async function maybeRepairLocalToolCalls(ctx, baseMessages, response, effectiveModel, repairedCallIds) {
+    if (!response.toolCalls?.length)
+        return response;
+    const provider = ctx.actualProvider;
+    if (!isLocalBackend(provider))
+        return response;
+    const tools = getTools();
+    let target;
+    for (const call of response.toolCalls) {
+        if (repairedCallIds.has(call.id))
+            continue;
+        const fault = detectMalformedToolCall(call, tools);
+        if (fault) {
+            target = { call, reason: fault.reason };
+            break;
+        }
+    }
+    if (!target)
+        return response;
+    const { call, reason } = target;
+    repairedCallIds.add(call.id); // one repair per tool call, whatever the outcome
+    ctx.debugLog('repair', 'malformed local tool call', call.name, reason);
+    ctx.addMessage('system', `🔧 Malformed tool call from local model (${reason}); attempting one repair…`);
+    // Grammar-constrain the reply when the backend supports JSON-schema format.
+    let format;
+    try {
+        const profile = await getLocalModelProfile(provider, effectiveModel || ctx.actualModel);
+        if (profile.supportsJsonSchemaFormat) {
+            format = buildToolCallEnvelopeSchema(tools.map(t => t.name));
+        }
+    }
+    catch {
+        // No format constraint — the corrective message alone still helps.
+    }
+    const repairMessages = [
+        ...baseMessages,
+        { role: 'assistant', content: typeof response.content === 'string' ? response.content : '', toolCalls: response.toolCalls },
+        { role: 'user', content: buildRepairMessage(call, { reason }) },
+    ];
+    let repaired;
+    try {
+        repaired = await chat(ctx.provider, repairMessages, tools, effectiveModel, undefined, undefined, format ? { format } : undefined);
+    }
+    catch (err) {
+        ctx.ledger?.recordAction('repair', { tool: call.name }, 'error', reason);
+        ctx.debugLog('repair', 'repair round-trip threw', err instanceof Error ? err.message : String(err));
+        return response; // let the original error surface through executeTool
+    }
+    const corrected = extractRepairedToolCall(typeof repaired.content === 'string' ? repaired.content : '', repaired.toolCalls, call.id);
+    if (!corrected) {
+        ctx.ledger?.recordAction('repair', { tool: call.name }, 'error', reason);
+        ctx.addMessage('system', '🔧 Repair produced no usable tool call; surfacing the original error.');
+        return response;
+    }
+    const stillBad = detectMalformedToolCall(corrected, tools);
+    ctx.ledger?.recordAction('repair', { tool: call.name, to: corrected.name }, stillBad ? 'error' : 'ok', stillBad?.reason);
+    ctx.addMessage('system', stillBad
+        ? '🔧 Repair did not resolve the malformed call; surfacing the error.'
+        : `🔧 Repaired tool call → ${corrected.name}`);
+    return { ...response, toolCalls: response.toolCalls.map(tc => (tc.id === call.id ? corrected : tc)) };
+}
+// ============================================================================
+// Provider warnings
+// ============================================================================
+// Provider warnings already surfaced this process, keyed by sessionId::warning,
+// so a repeated model substitution across turns/iterations isn't shown twice
+// (#217). Non-fatal notices must be surfaced, never swallowed.
+const surfacedWarnings = new Set();
+function surfaceResponseWarnings(ctx, response) {
+    if (!response.warnings?.length)
+        return;
+    const sessionId = ctx.sessionRef.current?.id ?? 'session_adhoc';
+    for (const warning of response.warnings) {
+        const key = `${sessionId}::${warning}`;
+        if (surfacedWarnings.has(key))
+            continue;
+        surfacedWarnings.add(key);
+        ctx.addMessage('system', warning);
+    }
+}
+// ============================================================================
 // Run Agent
 // ============================================================================
 /**
  * Run agent with user prompt. Core execution loop that handles LLM calls,
  * tool execution (parallel + sequential), auto-compaction, and queued messages.
  */
+// #231: remember the previous turn's mode so the first work-mode turn after
+// a plan-mode turn can carry an explicit execution directive. Module scope is
+// intentional — mode itself outlives session resets.
+let previousTurnMode = null;
+/** Test seam: clear the plan-to-work transition tracking. */
+export function _resetModeTracking() {
+    previousTurnMode = null;
+}
 export async function runAgentImpl(ctx, content) {
     ctx.debugLog('runAgent', 'ENTER', typeof content === 'string' ? content.substring(0, 50) : '[complex]');
-    setMood('thinking');
     // Validate message history before adding new content
     ctx.validateAndRepairMessages();
     ctx.llmMessages.current.push({ role: 'user', content });
@@ -128,7 +234,7 @@ export async function runAgentImpl(ctx, content) {
         }
     }
     else if (ctx.autoRoute && typeof content === 'string') {
-        const routeDecision = modelRouter.routeRequest(content, ctx.provider, {
+        const routeDecision = router.routeRequest(content, ctx.provider, {
             messageCount: ctx.stats.messageCount,
             hasCode: content.includes('```') || /\.(ts|js|py|go|rs|java)/.test(content),
         });
@@ -150,6 +256,57 @@ export async function runAgentImpl(ctx, content) {
         : undefined;
     let runStatus;
     let runErrorSummary;
+    // Local-backend behaviours (features 2 & 4): whether to append anchor hashes
+    // to read_file output, and which tool-call ids have already spent their one
+    // repair round-trip.
+    const localBackend = isLocalBackend(ctx.actualProvider);
+    const executeOptions = { appendAnchorHash: localBackend };
+    const repairedCallIds = new Set();
+    // Governance (#189): audit run log, budget caps, policy hook. The run log is a
+    // per-session append-only JSONL trace; each agent turn is one run within it.
+    const sessionId = ctx.sessionRef.current?.id ?? 'session_adhoc';
+    const projectDir = ctx.sessionRef.current?.projectPath ?? process.cwd();
+    const runlog = RunLog.open(sessionId);
+    const budgetCaps = getBudgetCaps();
+    // Only maintain the cross-run project ledger when a project cap is active.
+    const trackProjectBudget = typeof budgetCaps.maxCostPerProject === 'number';
+    const runStartedAt = Date.now();
+    let runInputTokens = 0;
+    let runOutputTokens = 0;
+    let runCostUsd = 0;
+    let runToolCalls = 0;
+    let runEnded = false;
+    let runExitReason;
+    let budgetVerdict;
+    runlog.runStart({
+        session: sessionId,
+        cwd: projectDir,
+        provider: effectiveProvider,
+        model: effectiveModel || ctx.actualModel,
+        config: config.getConfig(),
+    });
+    runlog.userPrompt(summarizeMessageContent(content));
+    // #231: a terse reply right after leaving plan mode is an approval, not a
+    // conversation — bind it to execution explicitly or weak models answer
+    // "done" without doing anything.
+    const justLeftPlanMode = previousTurnMode === 'plan' && ctx.mode !== 'plan';
+    previousTurnMode = ctx.mode;
+    const finalizeRun = (exitReason) => {
+        if (runEnded)
+            return;
+        runEnded = true;
+        runlog.runEnd({
+            totals: {
+                inputTokens: runInputTokens,
+                outputTokens: runOutputTokens,
+                cost: runCostUsd,
+                toolCalls: runToolCalls,
+                durationMs: Date.now() - runStartedAt,
+            },
+            exitReason,
+        });
+        void runlog.flush();
+    };
     // Check context limit and warn if approaching capacity
     // Uses model's actual context length from API when available
     let currentContextTokens = ctx.estimateContextTokens();
@@ -157,36 +314,18 @@ export async function runAgentImpl(ctx, content) {
     let contextPercentage = (currentContextTokens / modelLimit) * 100;
     // Adaptive preserveRecent: small models keep fewer messages to leave room for output
     const preserveRecent = modelLimit < 8000 ? 2 : modelLimit < 16000 ? 4 : modelLimit < 32000 ? 6 : modelLimit < 64000 ? 10 : 15;
-    // Auto-compact if we're over 75% capacity to prevent API errors
-    if (contextPercentage > 75) {
-        ctx.addMessage('system', `🔄 Context at ${Math.round(contextPercentage)}% - auto-compacting to prevent errors...`);
-        const result = summarization.summarizeConversation(ctx.llmMessages.current, {
-            maxTokens: Math.floor(modelLimit * 0.7), // Target 70% of limit after compaction
-            preserveRecent,
-        });
-        if (result.summarizedCount > 0) {
-            ctx.llmMessages.current = result.messages;
-            currentContextTokens = ctx.estimateContextTokens();
-            contextPercentage = (currentContextTokens / modelLimit) * 100;
-            ctx.setContextTokens(currentContextTokens);
-            ctx.addMessage('system', `✓ Compacted ${result.summarizedCount} messages. Now at ${Math.round(contextPercentage)}% (${Math.round(currentContextTokens / 1000)}K/${Math.round(modelLimit / 1000)}K)`);
-        }
-        else {
-            // If compaction didn't help enough, force-trim old messages
-            if (contextPercentage > 98) {
-                const systemMsgs = ctx.llmMessages.current.filter(m => m.role === 'system');
-                const recentMsgs = ctx.llmMessages.current.filter(m => m.role !== 'system').slice(-5);
-                ctx.llmMessages.current = [...systemMsgs, ...recentMsgs];
-                currentContextTokens = ctx.estimateContextTokens();
-                contextPercentage = (currentContextTokens / modelLimit) * 100;
-                ctx.setContextTokens(currentContextTokens);
-                ctx.addMessage('system', `⚠️  Force-trimmed to last 5 messages (${Math.round(contextPercentage)}%). Use /clear for a full reset.`);
-            }
-        }
+    // Auto-compact using the new auto-compressor
+    const autoCompressResult = await autoCompress(ctx.llmMessages.current, modelLimit, ctx.provider, effectiveModel);
+    if (autoCompressResult.compressed) {
+        ctx.llmMessages.current = autoCompressResult.messages;
+        currentContextTokens = ctx.estimateContextTokens();
+        contextPercentage = (currentContextTokens / modelLimit) * 100;
+        ctx.setContextTokens(currentContextTokens);
+        ctx.addMessage('system', `🔄 Auto-compressed ${autoCompressResult.summarizedCount} messages using ${autoCompressResult.method} (${Math.round(autoCompressResult.originalTokens / 1000)}K → ${Math.round(autoCompressResult.compressedTokens / 1000)}K tokens)`);
     }
     else if (contextPercentage > 65) {
         ctx.addMessage('system', `⚠️  Context at ${Math.round(contextPercentage)}% capacity (${Math.round(currentContextTokens / 1000)}K/${Math.round(modelLimit / 1000)}K tokens)
-   Consider: /summarize compact | /clear | shorter messages`);
+   Consider: /compact | /clear | shorter messages`);
     }
     // Inject failed approaches into context so the agent avoids repeating mistakes
     if (ctx.ledger) {
@@ -203,20 +342,21 @@ export async function runAgentImpl(ctx, content) {
         // Safety check at start of each iteration - context may have grown from tool results
         if (i > 0) {
             const iterContextTokens = ctx.estimateContextTokens();
-            const iterContextPercentage = (iterContextTokens / modelLimit) * 100;
-            if (iterContextPercentage > 75) {
-                ctx.addMessage('system', `🔄 Context grew to ${Math.round(iterContextPercentage)}% - auto-compacting...`);
-                const result = summarization.summarizeConversation(ctx.llmMessages.current, {
-                    maxTokens: Math.floor(modelLimit * 0.7),
-                    preserveRecent,
-                });
-                if (result.summarizedCount > 0) {
-                    ctx.llmMessages.current = result.messages;
-                    ctx.setContextTokens(ctx.estimateContextTokens());
-                    ctx.addMessage('system', `✓ Compacted ${result.summarizedCount} messages during iteration ${i + 1}`);
-                }
+            const iterAutoCompressResult = await autoCompress(ctx.llmMessages.current, modelLimit, ctx.provider, effectiveModel);
+            if (iterAutoCompressResult.compressed) {
+                ctx.llmMessages.current = iterAutoCompressResult.messages;
+                ctx.setContextTokens(ctx.estimateContextTokens());
+                ctx.addMessage('system', `🔄 Auto-compressed ${iterAutoCompressResult.summarizedCount} messages during iteration ${i + 1} (${iterAutoCompressResult.method})`);
             }
         }
+        // Frame-bounded streaming: coalesce provider tokens so setStreamingResponse
+        // fires at most ~30fps instead of once per token (which re-rendered the
+        // transcript region on every token). The flusher is per-iteration; its
+        // pending timer is drained by flush() on success and cleared by destroy()
+        // on the error/cancel path below.
+        const streamFlusher = createStreamFlusher((delta) => {
+            ctx.setStreamingResponse(prev => prev + delta);
+        });
         try {
             // Update thinking state for LLM call
             ctx.setThinkingState({
@@ -230,10 +370,15 @@ export async function runAgentImpl(ctx, content) {
                 target: `iteration ${i + 1}`,
                 startTime: Date.now(),
             });
-            // Streaming callback for final response
+            // Streaming callback for final response. Clear the thinking indicator on
+            // the first token, then hand the token to the frame-bounded flusher.
+            let streamStarted = false;
             const onToken = (token) => {
-                ctx.setThinkingState(null); // Clear thinking when streaming starts
-                ctx.setStreamingResponse(prev => prev + token);
+                if (!streamStarted) {
+                    ctx.setThinkingState(null); // Clear thinking when streaming starts
+                    streamStarted = true;
+                }
+                streamFlusher.push(token);
             };
             // Retry callback for error recovery
             const onRetry = (attempt, error, delayMs) => {
@@ -251,8 +396,36 @@ export async function runAgentImpl(ctx, content) {
                 ctx.debugLog('chat', 'CLEANED orphaned tool results', `removed=${ctx.llmMessages.current.length - validatedMessages.length}`);
                 ctx.llmMessages.current = validatedMessages;
             }
+            // Plan mode: tell the model it is planning and that plans need receipts.
+            // Injected per-request (not persisted) so mode switches take effect
+            // immediately and history stays clean.
+            if (ctx.mode === 'plan') {
+                validatedMessages = [
+                    ...validatedMessages,
+                    {
+                        role: 'system',
+                        content: 'You are in PLAN mode: no mutating tools will execute. '
+                            + 'Read-only tools (read_file, list_files, think, create_plan, ask_question) ARE available — use them. '
+                            + 'Before proposing any plan, read the files you intend to change and cite file:line for every claim. '
+                            + 'State explicitly what you verified versus what you assume. '
+                            + 'A plan produced without reading anything will be marked unverified.',
+                    },
+                ];
+            }
+            if (justLeftPlanMode && i === 0) {
+                validatedMessages = [
+                    ...validatedMessages,
+                    {
+                        role: 'system',
+                        content: 'The user has just switched from plan mode to work mode and replied. '
+                            + 'Treat their message as approval to execute the plan discussed above. '
+                            + 'Carry it out now using tools, step by step. '
+                            + 'Never state that work is done unless you performed it with tool calls in this turn.',
+                    },
+                ];
+            }
             // Pre-request summarization check - summarize BEFORE sending if context is too large
-            const tools = getTools(ctx.agtermEnabled);
+            const tools = getTools();
             const contextCheck = estimateContextUsage(ctx.provider, effectiveModel || DEFAULT_MODELS[ctx.provider], validatedMessages, tools);
             ctx.debugLog('chat', 'CONTEXT CHECK', `estimated=${contextCheck.estimated}, limit=${contextCheck.limit}, percent=${contextCheck.percent}%`);
             if (contextCheck.needsSummarization) {
@@ -264,8 +437,16 @@ export async function runAgentImpl(ctx, content) {
                     ctx.debugLog('chat', 'PRE-SUMMARIZED', `removed=${result.summarizedCount} messages, reduced from ${result.originalTokens} to ${result.reducedTokens}`);
                 }
             }
-            const response = await chat(ctx.provider, validatedMessages, tools, effectiveModel, onToken, onRetry);
+            let response = await chat(ctx.provider, validatedMessages, tools, effectiveModel, onToken, onRetry);
+            streamFlusher.flush(); // drain any batched tail before we swap to history
             ctx.debugLog('chat', 'GOT response', `toolCalls=${response.toolCalls?.length ?? 0}`);
+            // Local backends: give a malformed tool call ONE corrective round-trip
+            // before it surfaces as an execution error (features 2 & 3). No-op for
+            // cloud providers and well-formed responses.
+            response = await maybeRepairLocalToolCalls(ctx, validatedMessages, response, effectiveModel, repairedCallIds);
+            // Surface provider warnings (e.g. Ollama model substitution) once per
+            // unique message per session — never swallow them (#217).
+            surfaceResponseWarnings(ctx, response);
             // Update token stats and cost
             if (response.usage) {
                 const usageCost = calculateCost(ctx.model || DEFAULT_MODELS[ctx.provider], response.usage.inputTokens, response.usage.outputTokens);
@@ -290,6 +471,33 @@ export async function runAgentImpl(ctx, content) {
                     }
                 }
             }
+            // Governance: accrue run spend, audit the assistant turn, evaluate budget.
+            {
+                const turnCost = response.usage
+                    ? calculateCost(ctx.model || DEFAULT_MODELS[ctx.provider], response.usage.inputTokens, response.usage.outputTokens)
+                    : 0;
+                if (response.usage) {
+                    runInputTokens += response.usage.inputTokens;
+                    runOutputTokens += response.usage.outputTokens;
+                    runCostUsd += turnCost;
+                    if (trackProjectBudget)
+                        recordProjectSpend(projectDir, turnCost);
+                }
+                runlog.assistantMessage({
+                    content: response.content,
+                    tokens: { input: response.usage?.inputTokens ?? 0, output: response.usage?.outputTokens ?? 0 },
+                    cost: turnCost,
+                });
+                if (hasBudgetCaps(budgetCaps)) {
+                    const verdict = evaluateBudget(budgetCaps, {
+                        runCostUsd,
+                        runTokens: runInputTokens + runOutputTokens,
+                        projectCostUsd: loadProjectSpend(projectDir).spentUsd,
+                    });
+                    if (verdict.exceeded)
+                        budgetVerdict = verdict;
+                }
+            }
             // Circuit breaker check after each iteration
             if (ctx.circuitBreaker) {
                 const iterData = {
@@ -318,10 +526,16 @@ export async function runAgentImpl(ctx, content) {
                     content: response.content,
                     toolCalls: response.toolCalls,
                 });
+                // Mirror any text the assistant produced alongside the tool calls
+                if (fleetActive() && response.content) {
+                    fleetMirrorAssistant(response.content);
+                }
                 const preChecks = [];
                 const executableTools = [];
                 for (const toolCall of response.toolCalls) {
                     const args = toolCall.arguments;
+                    runlog.toolCall({ id: toolCall.id, name: toolCall.name, args });
+                    runToolCalls++;
                     const toolPreview = String(args.command || args.path || '...');
                     const risk = assessToolRisk(toolCall);
                     const riskConfig = RISK_CONFIG[risk.level];
@@ -363,15 +577,38 @@ export async function runAgentImpl(ctx, content) {
                             ctx.addMessage('tool', `🛑 Blocked by hook: ${preHookResult.reason}`);
                         }
                         else {
-                            // Tool can be executed
-                            executableTools.push(toolCall);
-                            ctx.addMessage('tool', `⚡ ${toolCall.name}: ${toolPreview}${riskDisplay}`);
+                            // Pre-tool policy gate (fail closed). Distinct from the hook above:
+                            // the policy engine receives the tool-call JSON on stdin and denies
+                            // via a non-zero exit code (see policy.ts / docs/governance.md).
+                            const policyResult = isPolicyEnabled() ? await evaluatePolicy(toolCall) : undefined;
+                            if (policyResult) {
+                                runlog.policyEvent({
+                                    tool: toolCall.name,
+                                    decision: policyResult.decision,
+                                    source: policyResult.source,
+                                    reason: policyResult.reason,
+                                    durationMs: policyResult.durationMs,
+                                });
+                            }
+                            if (policyResult && policyResult.decision === 'deny') {
+                                preCheck.blocked = true;
+                                preCheck.blockReason = 'denied by policy';
+                                preCheck.blockContent = `[Denied by policy: ${policyResult.reason || 'no reason given'}]`;
+                                ctx.addMessage('tool', `⚡ ${toolCall.name}: ${toolPreview}${riskDisplay}`);
+                                ctx.addMessage('tool', `⛨ Denied by policy: ${policyResult.reason || 'no reason given'}`);
+                            }
+                            else {
+                                // Tool can be executed
+                                executableTools.push(toolCall);
+                                ctx.addMessage('tool', `⚡ ${toolCall.name}: ${toolPreview}${riskDisplay}`);
+                            }
                         }
                     }
                     preChecks.push(preCheck);
                     // Record blocked tools in ledger and add to LLM messages
                     if (preCheck.blocked) {
                         ctx.ledger?.recordAction(toolCall.name, args, 'blocked', preCheck.blockReason);
+                        runlog.toolResult({ id: toolCall.id, result: preCheck.blockContent, isError: true, durationMs: 0 });
                         ctx.llmMessages.current.push({
                             role: 'tool',
                             content: preCheck.blockContent,
@@ -401,8 +638,8 @@ export async function runAgentImpl(ctx, content) {
                         // Execute in parallel using dependency-aware staging
                         ctx.debugLog('tools', 'PARALLEL exec start', `count=${executableTools.length}`);
                         const results = await executeParallel(executableTools, async (call) => {
-                            const result = await executeTool(call, ctx.sessionRef.current?.projectPath ?? process.cwd());
-                            return result.result;
+                            const result = await executeTool(call, ctx.sessionRef.current?.projectPath ?? process.cwd(), 60000, undefined, executeOptions);
+                            return { result: result.result, isError: result.isError };
                         }, (completed, total, current) => {
                             const args = current.arguments;
                             const target = args.path || args.command?.substring(0, 30) || current.name;
@@ -423,10 +660,14 @@ export async function runAgentImpl(ctx, content) {
                         for (const result of results) {
                             const toolCall = result.toolCall;
                             const args = toolCall.arguments;
-                            recordEvent('tool_call', toolCall.name, { name: toolCall.name, arguments: args });
-                            recordEvent('tool_result', (result.result || result.error || '').slice(0, 1000), { name: toolCall.name, isError: !!result.error });
+                            // A tool-level failure (result.isError) or a thrown exception (result.error)
+                            // both count as a failure — mirror the sequential branch.
+                            const failed = result.isError || !!result.error;
+                            const failureText = result.error || result.result;
                             // Record in iteration ledger
-                            ctx.ledger?.recordAction(toolCall.name, args, result.error ? 'error' : 'ok', result.error || undefined);
+                            ctx.ledger?.recordAction(toolCall.name, args, failed ? 'error' : 'ok', failed ? failureText : undefined);
+                            // Audit the tool result (parallel exec has no per-call duration).
+                            runlog.toolResult({ id: toolCall.id, result: failed ? failureText : result.result, isError: failed, durationMs: 0 });
                             // Execute post-tool hooks
                             hooks.executeHooks('post-tool', {
                                 tool: toolCall.name,
@@ -441,11 +682,11 @@ export async function runAgentImpl(ctx, content) {
                                 ctx.addMessage('tool', thought);
                             }
                             else if (result.error) {
-                                ctx.addMessage('tool', `Error: ${result.error}`);
+                                ctx.addMessage('tool', `Error: ${result.error}`, true);
                             }
                             else {
                                 const preview = result.result.split('\n').slice(0, 3).join('\n');
-                                ctx.addMessage('tool', preview + (result.result.split('\n').length > 3 ? '\n...' : ''));
+                                ctx.addMessage('tool', preview + (result.result.split('\n').length > 3 ? '\n...' : ''), failed);
                             }
                             ctx.llmMessages.current.push({
                                 role: 'tool',
@@ -498,12 +739,11 @@ export async function runAgentImpl(ctx, content) {
                                 });
                             }
                             ctx.debugLog('tools', 'EXEC', toolCall.name, toolPreview.substring(0, 30));
-                            recordEvent('tool_call', toolCall.name, { name: toolCall.name, arguments: args });
                             // Auto-checkpoint before destructive operations
                             if (shouldCheckpoint(toolCall.name, args)) {
                                 const hash = createCheckpoint(toolCall.name, args);
                                 if (hash) {
-                                    ctx.debugLog('checkpoint', `auto-checkpoint ${hash} before ${toolCall.name}`);
+                                    ctx.debugLog('checkpoint', `checkpoint ${hash} before ${toolCall.name}`);
                                 }
                             }
                             // Stream shell output in real-time (#15)
@@ -515,11 +755,13 @@ export async function runAgentImpl(ctx, content) {
                                     detail: chunk.trimEnd().split('\n').pop()?.substring(0, 60),
                                 });
                             } : undefined;
-                            const result = await executeTool(toolCall, ctx.sessionRef.current?.projectPath ?? process.cwd(), 60000, shellStreamCallback);
+                            const seqStart = Date.now();
+                            const result = await executeTool(toolCall, ctx.sessionRef.current?.projectPath ?? process.cwd(), 60000, shellStreamCallback, executeOptions);
                             ctx.debugLog('tools', 'DONE', toolCall.name);
-                            recordEvent('tool_result', result.result.slice(0, 1000), { name: toolCall.name, isError: result.isError });
                             // Record in iteration ledger
                             ctx.ledger?.recordAction(toolCall.name, args, result.isError ? 'error' : 'ok', result.isError ? result.result : undefined);
+                            // Audit the tool result.
+                            runlog.toolResult({ id: toolCall.id, result: result.result, isError: result.isError || false, durationMs: Date.now() - seqStart });
                             // Execute post-tool hooks
                             hooks.executeHooks('post-tool', {
                                 tool: toolCall.name,
@@ -562,12 +804,12 @@ export async function runAgentImpl(ctx, content) {
                                 if (planReasoning)
                                     planMsg += `\n   ${planReasoning}\n`;
                                 planMsg += '\n' + planSteps.map((s, idx) => `   ${idx + 1}. [ ] ${s}`).join('\n');
-                                planMsg += '\n\n   Type /approve to execute, or provide feedback to revise.';
+                                planMsg += '\n\n   Switch to work mode (Shift+Tab) and reply to execute, or give feedback to revise.';
                                 ctx.addMessage('assistant', planMsg);
                                 // Tell the LLM to wait for user approval
                                 ctx.llmMessages.current.push({
                                     role: 'tool',
-                                    content: '[Plan displayed to user. Waiting for approval. The user will either type /approve to execute the plan, or provide feedback to revise it. Do NOT proceed with execution until the user approves.]',
+                                    content: '[Plan displayed to user. Waiting for approval. The user will reply to approve and execute the plan (they may switch to work mode first), or provide feedback to revise it. Do NOT proceed with execution until the user approves.]',
                                     toolCallId: toolCall.id,
                                 });
                                 // Break out of tool loop - wait for user approval
@@ -576,7 +818,7 @@ export async function runAgentImpl(ctx, content) {
                             else {
                                 const display = result.displayResult || result.result;
                                 const preview = display.split('\n').slice(0, 5).join('\n');
-                                ctx.addMessage('tool', preview + (display.split('\n').length > 5 ? '\n...' : ''));
+                                ctx.addMessage('tool', preview + (display.split('\n').length > 5 ? '\n...' : ''), result.isError);
                             }
                             if (toolCall.name !== 'ask_question') {
                                 ctx.llmMessages.current.push({
@@ -589,6 +831,24 @@ export async function runAgentImpl(ctx, content) {
                     }
                 }
                 ctx.ledger?.endIteration();
+                // Budget halt: the current tool result is finished; stop before the next
+                // provider call. Record a budget_event and summarize spend vs cap.
+                if (budgetVerdict?.exceeded) {
+                    const summary = formatBudgetHalt(budgetVerdict);
+                    runlog.budgetEvent({
+                        scope: budgetVerdict.scope ?? 'run',
+                        kind: budgetVerdict.kind ?? 'cost',
+                        spent: budgetVerdict.spent ?? 0,
+                        cap: budgetVerdict.cap ?? 0,
+                        message: budgetVerdict.message ?? summary,
+                    });
+                    ctx.addMessage('system', `‖ ${summary}`);
+                    runStatus = 'stopped';
+                    runErrorSummary = summary;
+                    runExitReason = 'budget';
+                    completedNaturally = true;
+                    break;
+                }
                 if (completedNaturally)
                     break; // ask_question pauses for user input (#42)
                 continue;
@@ -597,11 +857,13 @@ export async function runAgentImpl(ctx, content) {
             ctx.setThinkingState(null);
             ctx.llmMessages.current.push({ role: 'assistant', content: response.content });
             ctx.addMessage('assistant', response.content);
-            recordEvent('output', response.content.slice(0, 5000));
+            // Mirror assistant message to the fleet channel
+            if (fleetActive()) {
+                fleetMirrorAssistant(response.content);
+            }
             ctx.setStreamingResponse('');
             ctx.setContextTokens(ctx.estimateContextTokens());
             checkAndWarnContextLimit(ctx.actualProvider, ctx.actualModel, ctx.estimateContextTokens(), ctx.addMessage);
-            setMood('success');
             // Auto-continue if response was truncated due to length
             if (response.finishReason === 'length') {
                 ctx.addMessage('system', '(auto-continuing...)');
@@ -610,6 +872,20 @@ export async function runAgentImpl(ctx, content) {
             }
             completedNaturally = true;
             runStatus = 'completed';
+            // The answer is already shown; if this final turn crossed a budget cap,
+            // still record it so the audit trail reflects why spend stopped here.
+            if (budgetVerdict?.exceeded) {
+                const summary = formatBudgetHalt(budgetVerdict);
+                runlog.budgetEvent({
+                    scope: budgetVerdict.scope ?? 'run',
+                    kind: budgetVerdict.kind ?? 'cost',
+                    spent: budgetVerdict.spent ?? 0,
+                    cap: budgetVerdict.cap ?? 0,
+                    message: budgetVerdict.message ?? summary,
+                });
+                ctx.addMessage('system', `‖ ${summary}`);
+                runExitReason = 'budget';
+            }
             // End iteration ledger entry
             ctx.ledger?.endIteration('success');
             // Auto-save full message history for session persistence
@@ -617,13 +893,13 @@ export async function runAgentImpl(ctx, content) {
             break;
         }
         catch (error) {
+            streamFlusher.destroy(); // stop any pending flush timer on error/cancel
             ctx.setThinkingState(null);
             ctx.setActivityState(null);
             ctx.setStreamingResponse('');
             // End iteration ledger entry with error
             ctx.ledger?.endIteration('error');
             // Format error with provider context for better suggestions
-            setMood('error');
             const errorMsg = formatError(error, { provider: ctx.actualProvider });
             ctx.addMessage('error', errorMsg);
             // Classify error to provide additional recovery suggestions
@@ -652,7 +928,7 @@ export async function runAgentImpl(ctx, content) {
             // Suggest alternatives based on error type
             if (classified.category === 'rate_limit' || classified.category === 'server') {
                 if (otherProviders.length > 0) {
-                    ctx.addMessage('system', `\u{1f4a1} Try switching providers: /provider ${otherProviders[0]} or /models to see alternatives`);
+                    ctx.addMessage('system', `\u{1f4a1} Try switching providers: /provider ${otherProviders[0]} or /model to see alternatives`);
                 }
             }
             else if (classified.category === 'timeout' || classified.category === 'network') {
@@ -680,6 +956,7 @@ export async function runAgentImpl(ctx, content) {
             if (runId && runStatus) {
                 ctx.ledger?.finishRun(runId, runStatus, { errorSummary: runErrorSummary });
             }
+            finalizeRun(runExitReason ?? runStatus ?? 'error');
             return; // Exit early on error - don't process queued messages
         }
     }
@@ -694,10 +971,15 @@ export async function runAgentImpl(ctx, content) {
     if (runId) {
         ctx.ledger?.finishRun(runId, runStatus || 'completed', { errorSummary: runErrorSummary });
     }
+    finalizeRun(runExitReason ?? runStatus ?? 'completed');
     // Update context tokens after agent run
     ctx.setContextTokens(ctx.estimateContextTokens());
     // Process any queued messages (human-in-the-loop feedback)
     // CRITICAL: Use ref to get current value, not stale closure
+    // #224: a plan produced with zero tool calls carries no evidence — say so.
+    if (ctx.mode === 'plan' && runToolCalls === 0) {
+        ctx.addMessage('system', '⚠ Unverified plan — the agent read nothing to produce this. Ask it to verify (it can read files in plan mode), or treat claims as assumptions.');
+    }
     const currentQueued = ctx.queuedMessagesRef.current;
     ctx.debugLog('runAgent', 'EXIT loop', `queued=${currentQueued.length}`);
     if (currentQueued.length > 0) {
@@ -735,7 +1017,6 @@ export async function runAgentImpl(ctx, content) {
  */
 export async function runLoopImpl(ctx, prompt, maxIter, completionPromise) {
     ctx.setIsProcessing(true);
-    setMood('focused');
     // Prevent system sleep during long agent loops (macOS)
     startPreventSleep();
     let completedIterations = 0;