@phuetz/code-buddy 0.3.0 → 1.0.0-rc.8

package/dist/agent/execution/agent-executor.js

@@ -10,12 +10,77 @@
 import { logger } from "../../utils/logger.js";
 import { getErrorMessage } from "../../errors/index.js";
 import { sanitizeToolResult } from "../../utils/sanitize.js";
+import { prepareTurnMessages, injectInitialContext, injectNextRoundContext, runJitContextDiscovery, sanitizeAssistantOutput, } from "./context-pipeline.js";
+import { extractYieldChildId, processYieldSignal } from "./yield-coordinator.js";
+import { runPreToolUseHook, pushBlockedToolMessage, runPostToolUseHook, recordToolMetric, emitFleetToolStarted, emitFleetToolCompleted, } from "./tool-hooks.js";
+import { extractTerminateMessage, extractSignalMessage, INTERACTIVE_SHELL_SIGNAL, PLAN_APPROVAL_SIGNAL, } from "./turn-signals.js";
+import { persistToolResult, applyObservationVariator, logYoloCostIfEnabled, } from "./post-tool-handlers.js";
 import { semanticTruncate } from "../../utils/head-tail-truncation.js";
-import { getTodoTracker } from "../todo-tracker.js";
-import { getLessonsTracker } from "../lessons-tracker.js";
-import { getObservationVariator } from "../../context/observation-variator.js";
 import { getRestorableCompressor } from "../../context/restorable-compression.js";
-import { getResponseConstraintStack, resolveToolChoice } from "../response-constraint.js";
+import { recordCompactionFork } from "../../context/compaction-fork.js";
+import { getActiveRunStore } from "../../observability/run-store.js";
+import { shouldCompactBeforeToolExec, estimateToolResultTokens } from "../../context/proactive-compaction.js";
+import { formatTokenUsage, estimateCost } from "../../utils/token-display.js";
+import { classifyQuery } from "./query-classifier.js";
+/**
+ * Race a promise against a timeout, returning the fallback value if the
+ * promise doesn't settle within `ms` milliseconds.
+ */
+function withTimeout(promise, ms, fallback) {
+    return Promise.race([
+        promise,
+        new Promise(resolve => setTimeout(() => resolve(fallback), ms)),
+    ]);
+}
+// Lazy-loaded workspace context to avoid blocking tests.
+// Includes a 3s hard timeout so git commands never stall the agent loop.
+let _getWorkspaceContext = null;
+async function lazyGetWorkspaceContext(cwd) {
+    try {
+        if (!_getWorkspaceContext) {
+            const mod = await import("../../context/workspace-context.js");
+            _getWorkspaceContext = mod.getWorkspaceContext;
+        }
+        const result = await Promise.race([
+            _getWorkspaceContext(cwd),
+            new Promise((resolve) => setTimeout(() => resolve(''), 3000)),
+        ]);
+        return result;
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Register an ICM bridge provider for cross-session memory.
+ * Called by CodeBuddyAgent to wire up ICM without tight coupling.
+ */
+let _icmBridgeProvider = null;
+export function setICMBridgeProvider(provider) {
+    _icmBridgeProvider = provider;
+}
+/**
+ * Register a code graph context provider for per-turn injection.
+ * Called by CodeBuddyAgent to wire up code graph without tight coupling.
+ */
+let _codeGraphContextProvider = null;
+export function setCodeGraphContextProvider(provider) {
+    _codeGraphContextProvider = provider;
+}
+/** Register a docs context provider for per-turn injection. */
+let _docsContextProvider = null;
+export function setDocsContextProvider(provider) {
+    _docsContextProvider = provider;
+}
+/**
+ * Register a decision-context provider for the executor.
+ * Called externally (e.g., by CodeBuddyAgent) to wire up decision memory
+ * without incurring dynamic import cost in the hot loop.
+ */
+let _decisionContextProvider = null;
+export function setDecisionContextProvider(provider) {
+    _decisionContextProvider = provider;
+}
 /**
  * AgentExecutor implements the core agentic loop
  *
@@ -32,10 +97,35 @@ import { getResponseConstraintStack, resolveToolChoice } from "../response-const
 export class AgentExecutor {
     deps;
     config;
+    static parseTimeoutEnv(varName, fallbackMs) {
+        const value = Number(process.env[varName]);
+        return Number.isFinite(value) && value >= 1000 ? value : fallbackMs;
+    }
+    getLaneTaskTimeoutMs(isParallel) {
+        const readTimeoutMs = AgentExecutor.parseTimeoutEnv('CODEBUDDY_LANE_READ_TIMEOUT_MS', 120000);
+        const toolTimeoutMs = AgentExecutor.parseTimeoutEnv('CODEBUDDY_LANE_TOOL_TIMEOUT_MS', 300000);
+        return isParallel ? readTimeoutMs : toolTimeoutMs;
+    }
     constructor(deps, config) {
         this.deps = deps;
         this.config = config;
     }
+    /** Get ICM bridge provider (DI first, then global fallback) */
+    getICMBridgeProvider() {
+        return this.deps.icmBridgeProvider ?? _icmBridgeProvider;
+    }
+    /** Get code graph context provider (DI first, then global fallback) */
+    getCodeGraphContextProvider() {
+        return this.deps.codeGraphContextProvider ?? _codeGraphContextProvider;
+    }
+    /** Get docs context provider (DI first, then global fallback) */
+    getDocsContextProvider() {
+        return this.deps.docsContextProvider ?? _docsContextProvider;
+    }
+    /** Get decision context provider (DI first, then global fallback) */
+    getDecisionContextProvider() {
+        return this.deps.decisionContextProvider ?? _decisionContextProvider;
+    }
     /**
      * Get or set the middleware pipeline.
      * Used by CodeBuddyAgent.enableAutoObservation() to inject middleware.
@@ -63,9 +153,29 @@ export class AgentExecutor {
             abortController,
         };
     }
+    /**
+     * Determine if a tool call can run in parallel.
+     * Uses `wait_for_previous` from tool args (Gemini CLI pattern) with fallback to static set.
+     */
+    isToolParallelizable(toolCall) {
+        // Check explicit wait_for_previous flag in args (LLM-controlled parallelism)
+        try {
+            const args = JSON.parse(toolCall.function.arguments || '{}');
+            if (typeof args.wait_for_previous === 'boolean') {
+                return !args.wait_for_previous;
+            }
+        }
+        catch { /* parse failure — use fallback */ }
+        // Fallback: read-only tools are parallel-safe
+        const readOnlyTools = new Set([
+            'grep', 'glob', 'read_file', 'list_files', 'search_files',
+            'get_file_info', 'tree', 'find_references',
+        ]);
+        return readOnlyTools.has(toolCall.function.name);
+    }
     /**
      * Execute a tool call, optionally through the LaneQueue for serialization.
-     * Read-only tools (grep, glob, read_file) run in parallel; mutating tools run serially.
+     * Supports LLM-controlled parallelism via `wait_for_previous` parameter.
      */
     executeToolViaLane(toolCall) {
         const laneQueue = this.deps.laneQueue;
@@ -73,29 +183,45 @@ export class AgentExecutor {
             return this.deps.toolHandler.executeTool(toolCall);
         }
         const laneId = this.deps.laneId ?? 'default';
-        const readOnlyTools = new Set([
-            'grep', 'glob', 'read_file', 'list_files', 'search_files',
-            'get_file_info', 'tree', 'find_references',
-        ]);
-        const isParallel = readOnlyTools.has(toolCall.function.name);
+        const isParallel = this.isToolParallelizable(toolCall);
+        const timeoutMs = this.getLaneTaskTimeoutMs(isParallel);
         return laneQueue.enqueue(laneId, () => this.deps.toolHandler.executeTool(toolCall), {
             parallel: isParallel,
             category: toolCall.function.name,
-            timeout: 120000,
+            timeout: timeoutMs,
         });
     }
     /**
-     * Tool Result Compaction Guard (OpenClaw / Manus AI #13)
+     * Compute adaptive compaction threshold based on the model's context window.
+     * Reserves ~30% of context for tool results; rest for system prompt + history.
+     * Falls back to 70K chars if model info unavailable.
+     */
+    getAdaptiveCompactionThreshold() {
+        try {
+            const modelName = this.deps.client.getCurrentModel();
+            const { getModelToolConfig } = require('../../config/model-tools.js');
+            const config = getModelToolConfig(modelName);
+            const contextChars = (config.contextWindow ?? 128_000) * 4; // ~4 chars/token
+            // Allocate 30% of context window for tool results
+            return Math.max(40_000, Math.floor(contextChars * 0.3));
+        }
+        catch {
+            return 70_000; // Fallback
+        }
+    }
+    /**
+     * Tool Result Compaction Guard (Native Engine / Manus AI #13)
      *
      * Before each model call, scan accumulated tool result messages.
-     * If their total size exceeds the threshold (default 70K chars ≈ ~17K tokens),
+     * If their total size exceeds an adaptive threshold (scaled to model context),
      * compress the oldest ones using RestorableCompressor — replacing full content
      * with a compact stub referencing the callId. The content remains restorable
      * via the `restore_context` tool.
      *
      * This prevents deep agent chains from silently overflowing the context window.
      */
-    compactLargeToolResults(preparedMessages, maxToolResultChars = 70_000) {
+    compactLargeToolResults(preparedMessages, maxToolResultChars) {
+        const threshold = maxToolResultChars ?? this.getAdaptiveCompactionThreshold();
         // Sum characters from tool result messages
         let totalToolChars = 0;
         for (const m of preparedMessages) {
@@ -103,14 +229,16 @@ export class AgentExecutor {
                 totalToolChars += m.content.length;
             }
         }
-        if (totalToolChars <= maxToolResultChars)
+        if (totalToolChars <= threshold)
             return preparedMessages;
         const compressor = getRestorableCompressor();
         // Compress oldest tool results first (front of the list)
         const result = [...preparedMessages];
-        let charsToFree = totalToolChars - maxToolResultChars;
+        let charsToFree = totalToolChars - threshold;
         for (let i = 0; i < result.length && charsToFree > 0; i++) {
             const m = result[i];
+            if (m === undefined)
+                continue;
             if (m.role === 'tool' && typeof m.content === 'string' && m.content.length > 500) {
                 const callId = m.tool_call_id || `tool_${i}`;
                 const compressed = compressor.compress([{
@@ -138,221 +266,112 @@ export class AgentExecutor {
      * @param messages - LLM message array (modified in place)
      * @returns Array of new chat entries created during this turn
      */
-    async processUserMessage(message, history, messages) {
-        const newEntries = [];
-        const maxToolRounds = this.config.maxToolRounds;
-        let toolRounds = 0;
-        // Track token usage for cost calculation
-        const inputTokens = this.deps.tokenCounter.countMessageTokens(messages);
-        let totalOutputTokens = 0;
+    /**
+     * Shared pre-processing for user messages across the sequential and
+     * streaming agentic loops.
+     *
+     * Extracted from previously-duplicated code in processUserMessage and
+     * processUserMessageStream (F10): handles @mention expansion, fires
+     * persona auto-selection, and feeds the knowledge graph in the
+     * background. Returns the cleaned message (with `@web` / `@git` /
+     * `@terminal` markers removed). Both paths must call this before
+     * entering their respective main loops so the loops stay parity.
+     *
+     * All sub-steps are best-effort: any individual failure is swallowed at
+     * debug level so a broken plugin cannot break the main loop.
+     */
+    async preprocessUserMessage(message, messages) {
+        // 1. Process @mentions and inject context blocks
         try {
-            // Use RAG-based tool selection for initial query
-            const selectionResult = await this.deps.toolSelectionStrategy.selectToolsForQuery(message);
-            const tools = selectionResult.tools;
-            this.deps.toolSelectionStrategy.cacheTools(tools);
-            // Auto-discovery hint: if confidence is low, nudge agent to discover skills
-            const enableAutoDiscovery = this.config.enableAutoDiscovery ?? true;
-            const threshold = this.config.skillDiscoveryThreshold ?? 0.3;
-            if (enableAutoDiscovery && selectionResult.confidence !== undefined && selectionResult.confidence < threshold) {
-                const lastMsg = messages[messages.length - 1];
-                if (lastMsg && lastMsg.role === 'user' && typeof lastMsg.content === 'string') {
-                    messages.push({
-                        role: 'system',
-                        content: 'Low tool confidence for this query. Consider using the `skill_discover` tool to search the Skills Hub for relevant capabilities.',
-                    });
-                }
-            }
-            // Apply context management
-            const preparedMessages = this.deps.contextManager.prepareMessages(messages);
-            // --- Lessons context: inject BEFORE todo suffix (stable rules, higher priority) ---
-            const lessonsBlock = getLessonsTracker(process.cwd()).buildContextBlock();
-            if (lessonsBlock) {
-                preparedMessages.push({ role: 'system', content: lessonsBlock });
-            }
-            // --- Manus AI attention bias: append todo.md context at END of messages ---
-            const todoSuffix = getTodoTracker(process.cwd()).buildContextSuffix();
-            if (todoSuffix) {
-                preparedMessages.push({ role: 'system', content: todoSuffix });
-            }
-            // Check for context warnings
-            const contextWarning = this.deps.contextManager.shouldWarn(preparedMessages);
-            if (contextWarning.warn) {
-                logger.warn(contextWarning.message);
-                // --- OpenClaw pre-compaction memory flush (NO_REPLY pattern) ---
-                // Run a silent background turn to extract facts to MEMORY.md before context is compacted.
-                try {
-                    const { getPrecompactionFlusher } = await import('../../context/precompaction-flush.js');
-                    const flusher = getPrecompactionFlusher();
-                    const flushResult = await flusher.flush(preparedMessages.filter(m => m.role !== 'system').map(m => ({
-                        role: m.role,
-                        content: typeof m.content === 'string' ? m.content : '',
-                    })), async (flushMsgs) => {
-                        const r = await this.deps.client.chat(flushMsgs.map(m => ({ role: m.role, content: m.content })), []);
-                        return r.choices[0]?.message?.content ?? 'NO_REPLY';
-                    });
-                    if (flushResult.flushed) {
-                        logger.info(`Pre-compaction flush: saved ${flushResult.factsCount} facts to ${flushResult.writtenTo}`);
-                    }
-                }
-                catch (flushErr) {
-                    logger.debug('Pre-compaction flush failed (non-critical)', { flushErr });
-                }
-            }
-            // Apply response constraint (Manus AI response prefill / tool_choice control)
-            const activeConstraint = getResponseConstraintStack().current();
-            const toolNames = tools.map(t => t.function.name);
-            const toolChoiceOverride = resolveToolChoice(activeConstraint, toolNames);
-            let currentResponse = await this.deps.client.chat(preparedMessages, tools, { tool_choice: toolChoiceOverride !== 'auto' ? toolChoiceOverride : undefined }, this.config.isGrokModel() && this.deps.toolSelectionStrategy.shouldUseSearchFor(message)
-                ? { search_parameters: { mode: "auto" } }
-                : { search_parameters: { mode: "off" } });
-            // Agent loop
-            while (toolRounds < maxToolRounds) {
-                const assistantMessage = currentResponse.choices[0]?.message;
-                if (!assistantMessage) {
-                    throw new Error("No response received from AI. The API may be unavailable or the request was incomplete. Please try again.");
+            const { processMentions } = await import('../../input/context-mentions.js');
+            const mentionResult = await processMentions(message);
+            if (mentionResult.contextBlocks.length > 0) {
+                message = mentionResult.cleanedMessage;
+                // Update the last user message in the messages array to match
+                const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
+                if (lastUserMsg && typeof lastUserMsg.content === 'string') {
+                    lastUserMsg.content = message;
                 }
-                // Track output tokens
-                if (currentResponse.usage) {
-                    totalOutputTokens += currentResponse.usage.completion_tokens || 0;
-                }
-                else if (assistantMessage.content) {
-                    totalOutputTokens += this.deps.tokenCounter.countTokens(assistantMessage.content);
-                }
-                // Handle tool calls
-                if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
-                    toolRounds++;
-                    // Add assistant message with tool calls
-                    const assistantEntry = {
-                        type: "assistant",
-                        content: assistantMessage.content || "Using tools to help you...",
-                        timestamp: new Date(),
-                        toolCalls: assistantMessage.tool_calls,
-                    };
-                    history.push(assistantEntry);
-                    newEntries.push(assistantEntry);
-                    // Add assistant message to conversation
+                for (const block of mentionResult.contextBlocks) {
                     messages.push({
-                        role: "assistant",
-                        content: assistantMessage.content || "",
-                        tool_calls: assistantMessage.tool_calls,
-                    });
-                    // Pre-check cost limit before executing tools
-                    this.config.recordSessionCost(inputTokens, totalOutputTokens);
-                    if (this.config.isSessionCostLimitReached()) {
-                        const sessionCost = this.config.getSessionCost();
-                        const sessionCostLimit = this.config.getSessionCostLimit();
-                        const costEntry = {
-                            type: "assistant",
-                            content: `Session cost limit reached ($${sessionCost.toFixed(2)} / $${sessionCostLimit.toFixed(2)}). Stopping before tool execution.`,
-                            timestamp: new Date(),
-                        };
-                        history.push(costEntry);
-                        messages.push({ role: "assistant", content: costEntry.content });
-                        newEntries.push(costEntry);
-                        break;
-                    }
-                    // Execute tool calls
-                    for (const toolCall of assistantMessage.tool_calls) {
-                        const toolCallEntry = {
-                            type: "tool_call",
-                            content: "Executing...",
-                            timestamp: new Date(),
-                            toolCall: toolCall,
-                        };
-                        const histIdx = history.length;
-                        history.push(toolCallEntry);
-                        const newIdx = newEntries.length;
-                        newEntries.push(toolCallEntry);
-                        const result = await this.executeToolViaLane(toolCall);
-                        // --- Disk-backed tool result (Manus AI #19) ---
-                        // Persist full result to .codebuddy/tool-results/<callId>.txt for durable restoration.
-                        const rawToolContent = sanitizeToolResult(result.success ? result.output || "Success" : result.error || "Error");
-                        if (toolCall.id) {
-                            getRestorableCompressor().writeToolResult(toolCall.id, rawToolContent);
-                        }
-                        // --- Observation Variator (Manus AI #17) ---
-                        // Rotate the presentation wrapper for this tool result to prevent repetition drift.
-                        const variator = getObservationVariator();
-                        variator.nextTurn();
-                        const variedContent = variator.wrapToolResult(toolCall.function.name, rawToolContent);
-                        // Update entry with result
-                        const updatedEntry = {
-                            ...toolCallEntry,
-                            type: "tool_result",
-                            content: result.success ? result.output || "Success" : result.error || "Error occurred",
-                            toolResult: result,
-                        };
-                        // Replace in history and newEntries using tracked indices (O(1))
-                        history[histIdx] = updatedEntry;
-                        newEntries[newIdx] = updatedEntry;
-                        // Add tool result to messages (with observation variation applied)
-                        // Note: 'name' is required for Gemini API to match functionResponse with functionCall
-                        messages.push({
-                            role: "tool",
-                            content: variedContent,
-                            tool_call_id: toolCall.id,
-                            name: toolCall.function.name,
-                        });
-                    }
-                    // Get next response (with tool result compaction guard)
-                    const nextPreparedMessages = this.compactLargeToolResults(this.deps.contextManager.prepareMessages(messages));
-                    currentResponse = await this.deps.client.chat(nextPreparedMessages, tools, undefined, this.config.isGrokModel() && this.deps.toolSelectionStrategy.shouldUseSearchFor(message)
-                        ? { search_parameters: { mode: "auto" } }
-                        : { search_parameters: { mode: "off" } });
-                }
-                else {
-                    // No more tool calls
-                    const finalEntry = {
-                        type: "assistant",
-                        content: assistantMessage.content || "I understand, but I don't have a specific response.",
-                        timestamp: new Date(),
-                    };
-                    history.push(finalEntry);
-                    messages.push({
-                        role: "assistant",
-                        content: assistantMessage.content || "",
+                        role: 'system',
+                        content: `<context type="${block.type}" source="${block.source}">\n${block.content}\n</context>`,
                     });
-                    newEntries.push(finalEntry);
-                    break;
                 }
             }
-            if (toolRounds >= maxToolRounds) {
-                const warningEntry = {
-                    type: "assistant",
-                    content: "Maximum tool execution rounds reached. Stopping to prevent infinite loops.",
-                    timestamp: new Date(),
-                };
-                history.push(warningEntry);
-                messages.push({ role: "assistant", content: warningEntry.content });
-                newEntries.push(warningEntry);
-            }
-            // Record session cost
-            this.config.recordSessionCost(inputTokens, totalOutputTokens);
-            if (this.config.isSessionCostLimitReached()) {
-                const sessionCost = this.config.getSessionCost();
-                const sessionCostLimit = this.config.getSessionCostLimit();
-                const costEntry = {
-                    type: "assistant",
-                    content: `💸 Session cost limit reached ($${sessionCost.toFixed(2)} / $${sessionCostLimit.toFixed(2)}). Please start a new session.`,
-                    timestamp: new Date(),
-                };
-                history.push(costEntry);
-                messages.push({ role: "assistant", content: costEntry.content });
-                newEntries.push(costEntry);
+        }
+        catch { /* mention processing optional */ }
+        // 2. Auto-select persona (fire-and-forget, no await needed)
+        try {
+            const { getPersonaManager } = await import('../../personas/persona-manager.js');
+            getPersonaManager().autoSelectPersona({ message });
+        }
+        catch { /* persona auto-select optional */ }
+        // 3. Auto-extract entities into the knowledge graph (background)
+        try {
+            const { getKnowledgeGraph, isTrivialMessage } = await import('../../memory/knowledge-graph.js');
+            if (!isTrivialMessage(message)) {
+                const kg = getKnowledgeGraph();
+                await kg.load();
+                kg.extractFromMessageDeduped(message);
             }
-            return newEntries;
         }
-        catch (error) {
-            const errorMessage = getErrorMessage(error);
-            const errorEntry = {
-                type: "assistant",
-                content: `Sorry, I encountered an error: ${errorMessage}`,
-                timestamp: new Date(),
-            };
-            history.push(errorEntry);
-            messages.push({ role: "assistant", content: errorEntry.content });
-            return [errorEntry];
+        catch { /* non-critical */ }
+        return message;
+    }
+    /**
+     * Process a user message — sequential adapter (Phase D of task #5 fusion).
+     *
+     * Thin collector that consumes `runTurnLoop`. The unified loop already
+     * pushes the right ChatEntries (assistant, tool_result, error, cost, etc.)
+     * into `history` and the right messages into `messages` — we just slice
+     * the new entries out of `history`.
+     *
+     * Streaming-only events (`ask_user`, `tool_stream`, `token_count`,
+     * `reasoning`, `steer`) are silently dropped per décision #3 of the plan
+     * `~/.claude/plans/vague1-task5-design-decisions.md` — the sequential
+     * caller cannot suspend, so these have no meaningful sync representation.
+     *
+     * The sequential path has no abortController support (signature-bound) —
+     * we pass null to runTurnLoop and rely on its internal handling.
+     */
+    async processUserMessage(message, history, messages) {
+        const initialHistoryLength = history.length;
+        for await (const _event of this.runTurnLoop(message, history, messages, null)) {
+            // Events dropped. runTurnLoop pushes ChatEntries to history directly.
+        }
+        return history.slice(initialHistoryLength);
+    }
+    /**
+     * Like `processUserMessage`, but ALSO collects every event yielded by
+     * `runTurnLoop` (incl. streaming-only events that the sequential path
+     * normally drops: `ask_user`, `tool_stream`, `token_count`, `reasoning`,
+     * `steer`). Returns both the new history entries AND the captured events
+     * so callers in batch / test / audit contexts can introspect what
+     * happened during the turn without paying the cost of the full streaming
+     * path.
+     *
+     * Derived from the comparative audit Gemini CLI vs Code Buddy
+     * (claude-et-patrice/propositions/AUDIT-GEMINI-CLI-AGENTIC-LOOP-2026-05-04.md,
+     * recommendation #2 — fix défensif S scope). Backward compat preserved:
+     * existing `processUserMessage` callers see no change.
+     *
+     * @param message - The user's input message
+     * @param history - Chat history array (modified in place)
+     * @param messages - LLM message array (modified in place)
+     * @returns `{ entries }` — new ChatEntries pushed during this turn
+     *   PLUS `{ streamingEvents }` — every event the loop yielded, in order
+     */
+    async processUserMessageWithStreamingEvents(message, history, messages) {
+        const initialHistoryLength = history.length;
+        const streamingEvents = [];
+        for await (const event of this.runTurnLoop(message, history, messages, null)) {
+            streamingEvents.push(event);
         }
+        return {
+            entries: history.slice(initialHistoryLength),
+            streamingEvents,
+        };
     }
     /**
      * Process a user message with streaming response
@@ -366,7 +385,30 @@ export class AgentExecutor {
      * @param abortController - Controller to cancel the operation
      * @yields Streaming chunks for UI consumption
      */
+    /**
+     * Stream user-message processing — thin adapter over `runTurnLoop`.
+     * Forwards each `ExecutorEvent` as a `StreamingChunk` (alias-compatible).
+     */
     async *processUserMessageStream(message, history, messages, abortController) {
+        yield* this.runTurnLoop(message, history, messages, abortController);
+    }
+    /**
+     * Unified turn loop — Phase C of the task #5 fusion. Single source of
+     * truth for the agentic loop, consumed by both `processUserMessageStream`
+     * (forward as-is) and (eventually) `processUserMessage` (Phase D collector).
+     *
+     * Yield surface : `ExecutorEvent` (currently alias to `StreamingChunk`).
+     * Streaming-only events (`ask_user`, `tool_stream`, etc.) are yielded
+     * unconditionally; the sequential collector silently drops them per
+     * décision #3.
+     *
+     * Plan : ~/.claude/plans/vague1-task5-design-decisions.md
+     */
+    async *runTurnLoop(message, history, messages, abortController) {
+        // Shared pre-processing with the sequential path (@mentions, persona
+        // auto-select, knowledge graph extraction). Single source of truth in
+        // preprocessUserMessage (F10).
+        message = await this.preprocessUserMessage(message, messages);
         // Calculate input tokens
         let inputTokens = this.deps.tokenCounter.countMessageTokens(messages);
         yield {
@@ -376,8 +418,17 @@ export class AgentExecutor {
         const maxToolRounds = this.config.maxToolRounds;
         let toolRounds = 0;
         let totalOutputTokens = 0;
+        // Phase (d).21 ship 4 — start a progress session for this turn.
+        // The default sink (boot-wired) logs at 25/50/75/100. Lazy-import to
+        // avoid circular load at module init time.
+        try {
+            const { getProgressTracker } = await import('../planner/progress-default-sink.js');
+            getProgressTracker().start(maxToolRounds);
+        }
+        catch { /* progress tracker optional */ }
         try {
             const pipeline = this.deps.middlewarePipeline;
+            let terminateDetectedStreaming = false;
             while (toolRounds < maxToolRounds) {
                 if (abortController?.signal.aborted) {
                     yield { type: "content", content: "\n\n[Operation cancelled by user]" };
@@ -397,32 +448,115 @@ export class AgentExecutor {
                     if (mwResult.action === 'compact') {
                         // Trigger context compaction
                         this.deps.contextManager.prepareMessages(messages);
+                        // S7: record a fork run at the compaction boundary for lineage.
+                        // No-op unless this session is linked to an observability run.
+                        const forkId = recordCompactionFork(getActiveRunStore(), this.deps.toolHandler.getRunId());
+                        if (forkId)
+                            this.deps.toolHandler.setRunId(forkId);
                     }
                     if (mwResult.action === 'warn' && mwResult.message) {
                         yield { type: "content", content: `\n${mwResult.message}\n` };
+                        messages.push({
+                            role: 'system',
+                            content: `<context type="middleware-hint">\n${mwResult.message}\n</context>`,
+                        });
                     }
                 }
-                const selectionResult = await this.deps.toolSelectionStrategy.selectToolsForQuery(message);
-                const tools = selectionResult.tools;
+                // Rebuild the system prompt query-aware on the first round only.
+                // Per-turn rebuild costs are dominated by manager .load() calls
+                // (~50ms); doing it only on toolRounds === 0 amortizes the cost
+                // over the whole turn loop. Sub-turn tool follow-ups reuse the
+                // SP picked at turn start.
+                const rebuildSystemPromptForQuery = this.deps.rebuildSystemPromptForQuery;
+                if (toolRounds === 0 && rebuildSystemPromptForQuery) {
+                    try {
+                        const rebuiltSP = await rebuildSystemPromptForQuery(message);
+                        const firstMessage = messages[0];
+                        if (rebuiltSP && firstMessage && firstMessage.role === 'system') {
+                            firstMessage.content = rebuiltSP;
+                            logger.debug(`[agent-executor] system prompt rebuilt query-aware (${rebuiltSP.length} chars)`);
+                        }
+                    }
+                    catch (err) {
+                        logger.warn('[agent-executor] query-aware SP rebuild failed', { error: String(err) });
+                    }
+                }
+                // Profile-aware tool selection. For `lite` (small Ollama models),
+                // shrink the tool set to ~5 with a minimal alwaysInclude — we
+                // don't want to dangle `remember`/`lessons_*` in front of a model
+                // that can't actually call tools and would inline-hallucinate them.
+                let selectionOpts = {};
+                try {
+                    const { getModelToolConfig } = await import('../../config/model-tools.js');
+                    const cfg = getModelToolConfig(this.deps.client.getCurrentModel() ?? '');
+                    if (cfg.promptProfile === 'lite') {
+                        selectionOpts = {
+                            maxTools: 5,
+                            alwaysInclude: ['view_file', 'bash', 'search'],
+                        };
+                    }
+                }
+                catch { /* model-tools optional, never block */ }
+                const selectionResult = await this.deps.toolSelectionStrategy.selectToolsForQuery(message, selectionOpts);
+                let tools = selectionResult.tools;
                 if (toolRounds === 0)
                     this.deps.toolSelectionStrategy.cacheTools(tools);
-                const preparedMessages = this.deps.contextManager.prepareMessages(messages);
-                // --- Lessons context: inject BEFORE todo suffix (stable rules, higher priority) ---
-                const lessonsBlockStream = getLessonsTracker(process.cwd()).buildContextBlock();
-                if (lessonsBlockStream) {
-                    preparedMessages.push({ role: 'system', content: lessonsBlockStream });
+                // If the active model is flagged `supportsToolCalls: false` in
+                // model-tools.ts (typical of small Ollama / LM Studio models that
+                // can't reliably emit OpenAI-style tool_call frames), drop the
+                // tool list entirely. Without this, the LLM still sees tool
+                // descriptors in the API contract and tries to "call" them by
+                // generating raw JSON in the assistant content — which we can't
+                // dispatch, so the user gets back the JSON literal instead of an
+                // executed tool result. Honest fallback: tool-less chat.
+                try {
+                    const { getModelToolConfig } = await import('../../config/model-tools.js');
+                    // CodeBuddyClient exposes `getCurrentModel()`; the previous
+                    // `(client as { defaultModel? }).defaultModel` access always
+                    // resolved to undefined because that field doesn't exist on
+                    // the dispatcher class — left the guard latent for ages.
+                    const modelName = this.deps.client.getCurrentModel() ?? '';
+                    if (modelName) {
+                        const cfg = getModelToolConfig(modelName);
+                        if (cfg.supportsToolCalls === false && tools.length > 0) {
+                            logger.debug(`[agent-executor] supportsToolCalls=false for ${modelName} — dropping ${tools.length} tools from chat call`);
+                            tools = [];
+                        }
+                    }
                 }
-                // --- Manus AI attention bias: append todo.md context at END of messages ---
-                const todoSuffixStream = getTodoTracker(process.cwd()).buildContextSuffix();
-                if (todoSuffixStream) {
-                    preparedMessages.push({ role: 'system', content: todoSuffixStream });
+                catch { /* model-tools is optional, never block the loop */ }
+                const preparedMessages = prepareTurnMessages(this.deps.contextManager, messages);
+                // --- Query-aware context injection (saves ~15-20K tokens for trivial messages) ---
+                const { injection: ctxLevel, complexity: queryComplexity } = classifyQuery(message);
+                logger.debug(`Query classified as '${queryComplexity}' — context injection level: ${JSON.stringify(ctxLevel)}`);
+                await injectInitialContext(preparedMessages, {
+                    message,
+                    cwd: process.cwd(),
+                    ctxLevel,
+                    loadWorkspaceContext: lazyGetWorkspaceContext,
+                    decisionContextProvider: this.getDecisionContextProvider(),
+                    icmBridgeProvider: this.getICMBridgeProvider(),
+                    codeGraphContextProvider: this.getCodeGraphContextProvider(),
+                    docsContextProvider: this.getDocsContextProvider(),
+                });
+                // Décision #4 du plan task #5 — injection between-rounds promue depuis
+                // le sequential path. Lessons + KG (si complex) + todo réinjectés à
+                // chaque round > 0 pour préserver la qualité des conversations
+                // multi-round dans le streaming. Sentinel `TODO #4` couvre cet invariant.
+                if (toolRounds > 0) {
+                    await injectNextRoundContext(preparedMessages, {
+                        message,
+                        cwd: process.cwd(),
+                        queryComplexity,
+                    });
                 }
                 // Context warning — always check regardless of pipeline state
                 {
                     const contextWarning = this.deps.contextManager.shouldWarn(preparedMessages);
                     if (contextWarning.warn) {
+                        logger.warn(contextWarning.message);
                         yield { type: "content", content: `\n${contextWarning.message}\n` };
-                        // --- OpenClaw pre-compaction memory flush (streaming path) ---
+                        // --- Native Engine pre-compaction memory flush (streaming path) ---
                         try {
                             const { getPrecompactionFlusher } = await import('../../context/precompaction-flush.js');
                             const flusher = getPrecompactionFlusher();
@@ -463,12 +597,16 @@ export class AgentExecutor {
                         yield { type: "token_count", tokenCount: inputTokens + result.tokenCount };
                     }
                 }
-                const extracted = this.deps.streamingHandler.extractToolCalls();
-                if (extracted.toolCalls.length > 0) {
-                    yield { type: "tool_calls", toolCalls: extracted.toolCalls };
+                if (!this.deps.streamingHandler.hasYieldedToolCalls()) {
+                    const extracted = this.deps.streamingHandler.extractToolCalls();
+                    if (extracted.toolCalls.length > 0) {
+                        yield { type: "tool_calls", toolCalls: extracted.toolCalls };
+                    }
                 }
                 const accumulatedMessage = this.deps.streamingHandler.getAccumulatedMessage();
-                const content = accumulatedMessage.content || "Using tools to help you...";
+                // Sanitize streamed assistant content: strip model control tokens and invisible chars
+                const rawStreamedContent = accumulatedMessage.content || "Using tools to help you...";
+                const content = sanitizeAssistantOutput(rawStreamedContent);
                 const toolCalls = accumulatedMessage.tool_calls;
                 const assistantEntry = {
                     type: "assistant",
@@ -480,9 +618,8 @@ export class AgentExecutor {
                 messages.push({ role: "assistant", content: content, tool_calls: toolCalls });
                 if (toolCalls && toolCalls.length > 0) {
                     toolRounds++;
-                    // Pre-check cost limit before executing tools
-                    this.config.recordSessionCost(inputTokens, totalOutputTokens);
-                    if (this.config.isSessionCostLimitReached()) {
+                    // Pre-check cost limit before executing tools (estimate only — no side effects)
+                    if (this.config.estimateSessionCostLimitReached(inputTokens, totalOutputTokens)) {
                         const sessionCost = this.config.getSessionCost();
                         const sessionCostLimit = this.config.getSessionCostLimit();
                         yield { type: "content", content: `\n\nSession cost limit reached ($${sessionCost.toFixed(2)} / $${sessionCostLimit.toFixed(2)}). Stopping before tool execution.` };
@@ -502,21 +639,72 @@ export class AgentExecutor {
                                 content: steering.content,
                                 timestamp: new Date(),
                             });
+                            // Rollback toolRounds since we didn't actually execute any tools
+                            toolRounds--;
                             continue; // Re-enter loop to get new LLM response
                         }
                     }
+                    // Single-tool mode: only execute first tool call, re-enqueue rest
+                    const streamToolCallsToExecute = this.config.singleToolMode
+                        ? toolCalls.slice(0, 1)
+                        : toolCalls;
+                    if (this.config.singleToolMode && toolCalls.length > 1) {
+                        const deferred = toolCalls.slice(1);
+                        preparedMessages.push({
+                            role: 'assistant',
+                            content: null,
+                            tool_calls: deferred,
+                        });
+                        logger.debug(`Single-tool mode (stream): deferred ${deferred.length} tool calls`);
+                    }
                     if (!this.deps.streamingHandler.hasYieldedToolCalls()) {
-                        yield { type: "tool_calls", toolCalls: toolCalls };
+                        yield { type: "tool_calls", toolCalls: streamToolCallsToExecute };
                     }
-                    for (const toolCall of toolCalls) {
+                    // Buffer for streaming adapter chunks (cannot yield from inside a callback)
+                    const streamChunkBuffer = [];
+                    for (const toolCall of streamToolCallsToExecute) {
                         if (abortController?.signal.aborted) {
                             yield { type: "content", content: "\n\n[Operation cancelled by user]" };
                             yield { type: "done" };
                             return;
                         }
-                        // Use streaming execution for bash tools
+                        // --- Proactive context compaction (streaming path) ---
+                        try {
+                            const toolArgs = JSON.parse(toolCall.function.arguments || '{}');
+                            const estimatedTokens = estimateToolResultTokens(toolCall.function.name, toolArgs);
+                            const modelName = this.deps.client.getCurrentModel();
+                            const { getModelToolConfig } = await import('../../config/model-tools.js');
+                            const modelConfig = getModelToolConfig(modelName);
+                            const contextWindow = modelConfig.contextWindow ?? 128_000;
+                            if (shouldCompactBeforeToolExec(inputTokens, estimatedTokens, contextWindow)) {
+                                logger.debug('Proactive compaction (stream): compacting before tool execution', {
+                                    toolName: toolCall.function.name,
+                                    inputTokens,
+                                    estimatedTokens,
+                                    contextWindow,
+                                });
+                                this.deps.contextManager.prepareMessages(messages);
+                                inputTokens = this.deps.tokenCounter.countMessageTokens(messages);
+                            }
+                        }
+                        catch { /* proactive compaction is non-critical */ }
+                        // --- User hooks: PreToolUse (streaming path) ---
+                        const streamPreHook = await runPreToolUseHook(process.cwd(), toolCall);
+                        if (!streamPreHook.allowed) {
+                            const blockedContent = streamPreHook.feedback ?? 'Action blocked by PreToolUse hook';
+                            yield { type: "content", content: `\n[Hook blocked: ${blockedContent}]\n` };
+                            pushBlockedToolMessage(messages, toolCall, blockedContent);
+                            continue;
+                        }
+                        // Phase (d).2 — broadcast tool_started to the fleet (opt-in via
+                        // CODEBUDDY_FLEET_STREAM=1). Best-effort, no-op when disabled
+                        // or when the WS server isn't running.
+                        emitFleetToolStarted(toolCall);
+                        // Use streaming execution for tools that support it (bash, reason, + adapter-based)
                         let result;
-                        if (toolCall.function.name === 'bash') {
+                        const _streamToolStartMs = Date.now();
+                        const STREAMING_TOOLS = ['bash', 'reason'];
+                        if (STREAMING_TOOLS.includes(toolCall.function.name)) {
                             const gen = this.deps.toolHandler.executeToolStreaming(toolCall);
                             let genResult = await gen.next();
                             while (!genResult.done) {
@@ -540,7 +728,89 @@ export class AgentExecutor {
                             result = genResult.value ?? { success: false, error: 'Tool returned no result' };
                         }
                         else {
-                            result = await this.executeToolViaLane(toolCall);
+                            // Check if the streaming adapter supports this tool
+                            const { getStreamingAdapter } = await import('../../tools/streaming-adapter.js');
+                            const streamingAdapter = getStreamingAdapter();
+                            if (streamingAdapter.supportsStreaming(toolCall.function.name)) {
+                                const tc = toolCall; // capture for closure
+                                result = await streamingAdapter.wrapWithStreaming(tc.function.name, () => this.executeToolViaLane(tc), (chunk) => {
+                                    // We cannot yield from inside a callback, so we accumulate
+                                    // chunks and emit them after. Instead, use a buffer approach.
+                                    streamChunkBuffer.push({
+                                        type: "tool_stream",
+                                        toolStreamData: {
+                                            toolCallId: tc.id,
+                                            toolName: tc.function.name,
+                                            delta: chunk,
+                                        },
+                                    });
+                                });
+                                // Flush buffered streaming chunks
+                                for (const chunk of streamChunkBuffer) {
+                                    yield chunk;
+                                }
+                                streamChunkBuffer.length = 0;
+                            }
+                            else {
+                                result = await this.executeToolViaLane(toolCall);
+                            }
+                        }
+                        // --- User hooks: PostToolUse / PostToolUseFailure (streaming path) ---
+                        await runPostToolUseHook(process.cwd(), toolCall, result);
+                        // --- Per-tool metrics (streaming path, DeepWiki gap #3) ---
+                        await recordToolMetric(toolCall.function.name, result.success, Date.now() - _streamToolStartMs);
+                        // Phase (d).2 — fleet broadcast on completion (opt-in).
+                        emitFleetToolCompleted(toolCall, result, Date.now() - _streamToolStartMs);
+                        // Phase (d).21 ship 3 — proactive notification on tool completion.
+                        // Default sink logs at info (success) / warn (failure). Gated by
+                        // quiet hours + rate limit in NotificationManager.
+                        try {
+                            const { notify } = await import('../proactive/notification-default-sink.js');
+                            const _toolDurationStream = Date.now() - _streamToolStartMs;
+                            notify({
+                                channelType: 'cli',
+                                channelId: 'tool-completion',
+                                message: result.success
+                                    ? `${toolCall.function.name} completed in ${_toolDurationStream}ms`
+                                    : `${toolCall.function.name} failed: ${result.error ?? 'unknown error'}`,
+                                priority: result.success ? 'low' : 'high',
+                            });
+                        }
+                        catch { /* notification optional */ }
+                        // Phase (d).21 ship 4 — progress update.
+                        try {
+                            const { getProgressTracker } = await import('../planner/progress-default-sink.js');
+                            getProgressTracker().update(toolCall.id, result.success ? 'completed' : 'failed', toolCall.function.name);
+                        }
+                        catch { /* progress optional */ }
+                        // --- Track file access for code graph context (streaming, incremental update) ---
+                        try {
+                            const fileToolsStream = new Set(['view_file', 'create_file', 'str_replace_editor', 'file_read', 'file_write']);
+                            if (fileToolsStream.has(toolCall.function.name)) {
+                                const args = JSON.parse(toolCall.function.arguments || '{}');
+                                const filePath = args.path || args.file_path || args.target_file || '';
+                                if (filePath) {
+                                    const { trackRecentFile } = await import('../../knowledge/code-graph-context-provider.js');
+                                    trackRecentFile(filePath);
+                                    if (['create_file', 'str_replace_editor', 'file_write'].includes(toolCall.function.name)) {
+                                        const { getKnowledgeGraph } = await import('../../knowledge/knowledge-graph.js');
+                                        const kg = getKnowledgeGraph();
+                                        if (kg.getStats().tripleCount > 0) {
+                                            const { updateGraphForFile } = await import('../../knowledge/graph-updater.js');
+                                            const pathMod = await import('path');
+                                            const absPath = pathMod.default.resolve(process.cwd(), filePath);
+                                            updateGraphForFile(kg, absPath, process.cwd());
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch { /* file tracking is optional */ }
+                        // --- JIT context discovery: load subdirectory context files ---
+                        // Décision #2 du plan task #5 — promu du sequential vers streaming
+                        // pour parité d'enrichissement après chaque tool qui touche un path.
+                        for (const msg of await runJitContextDiscovery(toolCall)) {
+                            preparedMessages.push(msg);
                         }
                         // Check abort after tool execution completes
                         if (abortController?.signal.aborted) {
@@ -561,13 +831,9 @@ export class AgentExecutor {
                         }
                         // --- Disk-backed tool result (Manus AI #19) ---
                         const rawStreamContent = sanitizeToolResult(result?.success ? result.output || "Success" : result?.error || "Error");
-                        if (toolCall.id) {
-                            getRestorableCompressor().writeToolResult(toolCall.id, rawStreamContent);
-                        }
+                        persistToolResult(toolCall.id, rawStreamContent);
                         // --- Observation Variator (Manus AI #17) ---
-                        const streamVariator = getObservationVariator();
-                        streamVariator.nextTurn();
-                        const variedStreamContent = streamVariator.wrapToolResult(toolCall.function.name, rawStreamContent);
+                        const variedStreamContent = applyObservationVariator(toolCall.function.name, rawStreamContent);
                         const toolResultEntry = {
                             type: "tool_result",
                             content: result?.success ? result.output || "Success" : result?.error || "Error occurred",
@@ -581,10 +847,72 @@ export class AgentExecutor {
                         messages.push({
                             role: "tool",
                             content: variedStreamContent,
-                            tool_call_id: toolCall.id,
+                            tool_call_id: toolCall.id || `tool_${Date.now()}`,
                             name: toolCall.function.name,
                         });
+                        // --- Auto-commit after file-modifying tools (streaming path) ---
+                        if (result?.success) {
+                            try {
+                                const { maybeAutoCommit } = await import('../../tools/auto-commit.js');
+                                const acResult = await maybeAutoCommit(toolCall.function.name, toolCall.function.arguments || '{}', rawStreamContent.substring(0, 120));
+                                if (acResult?.success) {
+                                    logger.debug('Auto-commit (stream):', { hash: acResult.commitHash });
+                                }
+                                else if (acResult && acResult.message && /failed/i.test(acResult.message)) {
+                                    // Real commit failure — surface to the user (see sequential path above).
+                                    logger.warn(`Auto-commit failed: ${acResult.message}`);
+                                }
+                            }
+                            catch (err) {
+                                logger.debug('Auto-commit threw (stream)', { err: err instanceof Error ? err.message : String(err) });
+                            }
+                        }
+                        // --- Fix 11: YOLO cost display after each tool (streaming path) ---
+                        await logYoloCostIfEnabled(this.config);
+                        // --- Terminate signal detection (OpenManus #5, streaming path) ---
+                        const streamTerminateMsg = extractTerminateMessage(rawStreamContent);
+                        if (streamTerminateMsg !== null) {
+                            yield { type: "content", content: `\n\n${streamTerminateMsg}` };
+                            terminateDetectedStreaming = true;
+                            break;
+                        }
+                        // --- Interactive Shell Handoff detection (streaming path) ---
+                        const shellRequestMsg = extractSignalMessage(rawStreamContent, INTERACTIVE_SHELL_SIGNAL);
+                        if (shellRequestMsg !== null) {
+                            yield { type: "content", content: `\n\n⚠️ **INTERACTIVE SHELL HANDOFF REQUESTED**\n\n${shellRequestMsg}` };
+                            yield {
+                                type: "ask_user",
+                                askUser: {
+                                    question: "Do you want to open an interactive terminal to perform this action? (Type 'exit' in the terminal when done to return control to the AI)",
+                                    options: ["Yes, open interactive shell", "No, cancel tool"]
+                                }
+                            };
+                            terminateDetectedStreaming = true;
+                            break;
+                        }
+                        // --- Plan Approval detection (streaming path) ---
+                        const planMsg = extractSignalMessage(rawStreamContent, PLAN_APPROVAL_SIGNAL);
+                        if (planMsg !== null) {
+                            yield { type: "content", content: `\n\n⚠️ **PLAN APPROVAL REQUIRED**\n\n${planMsg}` };
+                            yield {
+                                type: "ask_user",
+                                askUser: {
+                                    question: "Do you approve this plan? (Yes to execute, No to cancel, or provide feedback)",
+                                    options: ["Approve", "Reject"]
+                                }
+                            };
+                            terminateDetectedStreaming = true;
+                            break;
+                        }
+                        // --- Yield signal detection (Native Engine v2026.3.14, streaming path) ---
+                        const streamYieldChildId = extractYieldChildId(rawStreamContent);
+                        if (streamYieldChildId) {
+                            yield { type: "content", content: `\n[Waiting for sub-agent to complete...]` };
+                            await processYieldSignal(streamYieldChildId, messages);
+                        }
                     }
+                    if (terminateDetectedStreaming)
+                        break;
                     inputTokens = this.deps.tokenCounter.countMessageTokens(messages);
                     const currentOutputTokens = this.deps.streamingHandler.getTokenCount() || 0;
                     totalOutputTokens += currentOutputTokens;
@@ -603,22 +931,49 @@ export class AgentExecutor {
                             yield { type: "content", content: `\n${mwResult.message}\n` };
                         }
                     }
-                    else {
-                        // Legacy inline cost check when no pipeline
-                        this.config.recordSessionCost(inputTokens, totalOutputTokens);
-                        if (this.config.isSessionCostLimitReached()) {
-                            const sessionCost = this.config.getSessionCost();
-                            const sessionCostLimit = this.config.getSessionCostLimit();
-                            yield {
-                                type: "content",
-                                content: `\n\n💸 Session cost limit reached ($${sessionCost.toFixed(2)} / $${sessionCostLimit.toFixed(2)}).`,
-                            };
-                            yield { type: "done" };
-                            return;
-                        }
+                    // Note: cost is recorded once at end-of-loop, not here (avoids double-counting)
+                    // Apply TTL-based tool result expiry + image pruning + backward-scanned FIFO masking (streaming path)
+                    try {
+                        const { applyToolOutputMasking, expireOldToolResults, pruneImageContent } = await import('../../context/tool-output-masking.js');
+                        expireOldToolResults(messages, toolRounds);
+                        pruneImageContent(messages);
+                        applyToolOutputMasking(messages);
                     }
+                    catch { /* masking is optional */ }
                 }
                 else {
+                    // Fire-and-forget auto-capture on final assistant response (streaming)
+                    try {
+                        const { getAutoCaptureManager } = await import('../../memory/auto-capture.js');
+                        const acm = getAutoCaptureManager();
+                        if (acm) {
+                            acm.processMessage('assistant', content || '').catch(err => logger.debug('Auto-capture failed', { error: String(err) }));
+                        }
+                    }
+                    catch { /* auto-capture optional */ }
+                    // Fire-and-forget ICM episode storage (streaming path)
+                    if (this.getICMBridgeProvider()) {
+                        try {
+                            const icm = this.getICMBridgeProvider()();
+                            if (icm?.isAvailable()) {
+                                const episode = `User: ${message}\nAssistant: ${(content || '').substring(0, 500)}`;
+                                icm.storeEpisode(episode, {
+                                    source: 'agent-executor-stream',
+                                    sessionId: process.env.CODEBUDDY_SESSION_ID,
+                                    turnNumber: toolRounds,
+                                }).catch(err => logger.debug('ICM episode store failed', { error: String(err) }));
+                            }
+                        }
+                        catch { /* ICM store optional */ }
+                    }
+                    // Context engine afterTurn hook (Native Engine v2026.3.7 — streaming path)
+                    try {
+                        const engine = this.deps.contextManager.getContextEngine?.();
+                        if (engine) {
+                            engine.afterTurn(messages, { role: 'assistant', content: content || '' });
+                        }
+                    }
+                    catch { /* afterTurn hook optional */ }
                     break;
                 }
             }
@@ -626,6 +981,17 @@ export class AgentExecutor {
                 yield { type: "content", content: "\n\nMaximum tool execution rounds reached." };
             }
             this.config.recordSessionCost(inputTokens, totalOutputTokens);
+            // Display per-turn token usage (streaming path). Pass the model
+            // name so estimateCost can zero out subscription-billed models
+            // (e.g. gpt-5.5 via ChatGPT Codex backend) — flat-fee, not per token.
+            // Optional call: the real client always implements this, but test doubles
+            // may be partial mocks — fall through to estimateCost when it's absent.
+            const streamTurnCost = this.deps.client.isSubscriptionAuth?.()
+                ? 0
+                : estimateCost(inputTokens, totalOutputTokens, undefined, undefined, this.deps.client.getCurrentModel());
+            const streamUsageDisplay = formatTokenUsage({ inputTokens, outputTokens: totalOutputTokens, cost: streamTurnCost });
+            logger.info(`Token usage: ${streamUsageDisplay}`);
+            yield { type: "content", content: `\n${streamUsageDisplay}` };
             if (this.config.isSessionCostLimitReached()) {
                 const sessionCost = this.config.getSessionCost();
                 const sessionCostLimit = this.config.getSessionCostLimit();