@phuetz/code-buddy 1.6.0 → 2.0.0

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

@@ -7,31 +7,273 @@
  *
  * @module agent/execution
  */
+import { resolveFirstTokenStallTimeoutMs, resolveStallTimeoutMs, withStallGuard } from "../../utils/stream-stall-guard.js";
+import { startHeadlessPromptProgress } from "../../cli/headless-prompt-progress.js";
+import { HEADLESS_LOCAL_COMPACT_ALWAYS_INCLUDE, HEADLESS_LOCAL_COMPACT_MAX_TOOLS, isHeadlessLocalPromptCompact, } from "../../config/headless-local-prompt.js";
 import { normalizeHallucinatedLocalToolCall } from "../tool-handler.js";
+import { ContextCompactionError } from "../../context/context-manager-v2.js";
 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 { prepareTurnMessages, compactTurnMessagesInPlace, 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 { applyObservationVariator, logYoloCostIfEnabled, } from "./post-tool-handlers.js";
+import { extractEditedFilesFromHistory } from "../middleware/changed-files.js";
 import { semanticTruncate } from "../../utils/head-tail-truncation.js";
-import { getRestorableCompressor } from "../../context/restorable-compression.js";
+import { optimizeToolObservation } from '../../context/tool-observation-optimizer.js';
+import { compress as tokenJuice, isTokenJuiceEnabled, JUICE_MIN_CHARS } from "../../context/token-juice.js";
+import { formatToolResultForRecovery, getRestorableCompressor, } from "../../context/restorable-compression.js";
 import { recordCompactionFork } from "../../context/compaction-fork.js";
 import { getActiveRunStore } from "../../observability/run-store.js";
+import { getTurnMetricsRecorder } from '../../observability/turn-metrics.js';
 import { shouldCompactBeforeToolExec, estimateToolResultTokens } from "../../context/proactive-compaction.js";
 import { formatTokenUsage, estimateCost } from "../../utils/token-display.js";
 import { classifyQuery } from "./query-classifier.js";
+import { getModelToolConfig } from "../../config/model-tools.js";
+import { getLatencyOptimizer, getStreamingOptimizer } from "../../optimization/latency-optimizer.js";
+import { buildTextEmotionalPresenceContext } from "../../companion/reply-augment.js";
+import { guardRelationshipReply, SAFE_RELATIONSHIP_REPAIR, } from "../../conversation/relationship-safety.js";
+import { classifyLisaIntrospection, guardLisaOperationalSelfInspectionReply, isLisaEvolutionRequest, renderLisaOperationalSelfResponse, } from '../../identity/lisa-introspection.js';
+import { withLlmStreamRetry } from '../../codebuddy/llm-retry.js';
+import { getStreamingAdapter } from '../../tools/streaming-adapter.js';
+import { notify } from '../proactive/notification-default-sink.js';
+import { getProgressTracker } from '../planner/progress-default-sink.js';
+import { trackRecentFile } from '../../knowledge/code-graph-context-provider.js';
+import { getKnowledgeGraph } from '../../knowledge/knowledge-graph.js';
+import { updateGraphForFile } from '../../knowledge/graph-updater.js';
+import { resolve as resolvePath } from 'node:path';
+import { maybeAutoCommit } from '../../tools/auto-commit.js';
+import { applyToolOutputMasking, expireOldToolResults, pruneImageContent, } from '../../context/tool-output-masking.js';
+import { IncrementalMessageTokenCounter } from './incremental-token-counter.js';
+import { createOrderedToolBatches, executeBoundedInOrder, } from './ordered-tool-executor.js';
 /**
- * Race a promise against a timeout, returning the fallback value if the
- * promise doesn't settle within `ms` milliseconds.
+ * Tools whose (verbose, prose/HTML) output TokenJuice may losslessly compress before it
+ * enters message history. Scoped to web tools on purpose — never structured output the
+ * agent parses. See `context/token-juice.ts`.
  */
-function withTimeout(promise, ms, fallback) {
-    return Promise.race([
-        promise,
-        new Promise(resolve => setTimeout(() => resolve(fallback), ms)),
-    ]);
+const JUICE_WEB_TOOLS = new Set(['web_fetch', 'web_search', 'fetch', 'browser_fetch']);
+const CONTEXT_MENTION_PATTERN = /@(?:file:|url:|image:|git(?::|\s)|symbol:|search:|web\s|terminal\b)/i;
+const FILE_MENTION_CANDIDATE_PATTERN = /(?:^|\s)@[^\s@]+/;
+const RELATIONSHIP_OUTBOUND_TOOLS = new Set([
+    'send_message',
+    'reply',
+    'broadcast',
+    'slack_send',
+    'discord_send',
+    'telegram_send',
+    'email_send',
+    'notification',
+    'notify',
+    'send_notification',
+    'yb_send_dm',
+    'feishu_drive_reply_comment',
+    'feishu_drive_add_comment',
+    'sessions_send',
+]);
+const RELATIONSHIP_INTERACTIVE_TOOLS = new Set(['ask_human', 'ask_user_question']);
+const RELATIONSHIP_BLOCK_MARKER = '__codebuddyRelationshipSafetyBlocked';
+const SAFE_INTERACTIVE_QUESTION = 'Peux-tu préciser ce que tu souhaites faire ensuite ?';
+const SAFE_TOOL_RESULT = 'Résultat traité en interne par Lisa.';
+const MAX_PARALLEL_TOOL_CALLS = 5;
+function abortedToolResult(startedAt) {
+    const elapsedSeconds = Math.max(0, Date.now() - startedAt) / 1000;
+    return {
+        success: false,
+        error: `aborted by user after ${elapsedSeconds.toFixed(1)}s`,
+    };
+}
+function configuredSensoryRuntime(surface, env = process.env) {
+    const voiceConfigured = surface === 'voice' || env.CODEBUDDY_SENSORY_SPEAK === 'true';
+    const configuredTtsEngine = env.CODEBUDDY_TTS_ENGINE?.trim().toLowerCase();
+    const ttsProvider = env.CODEBUDDY_TTS_VOICE?.trim().toLowerCase().startsWith('elevenlabs:')
+        ? 'elevenlabs'
+        : configuredTtsEngine === 'piper' || configuredTtsEngine === 'voicebox'
+            ? configuredTtsEngine
+            : 'pocket';
+    const ttsConfigured = voiceConfigured || Boolean(env.CODEBUDDY_TTS_ENGINE ||
+        env.CODEBUDDY_TTS_VOICE ||
+        env.CODEBUDDY_TTS_PIPER_MODEL ||
+        env.CODEBUDDY_POCKET_VOICE ||
+        env.CODEBUDDY_VOICEBOX_PROFILE);
+    return {
+        voice: {
+            configured: voiceConfigured,
+            ...(voiceConfigured ? { provider: 'resident voice loop' } : {}),
+        },
+        tts: {
+            configured: ttsConfigured,
+            ...(ttsConfigured ? { provider: ttsProvider } : {}),
+        },
+        camera: {
+            configured: env.CODEBUDDY_SENSORY_CAMERA === 'true',
+        },
+    };
+}
+function isUnknownRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function guardInteractiveText(value, fallback) {
+    if (typeof value !== 'string' || !value.trim())
+        return { value: fallback, intervened: true };
+    const guarded = guardRelationshipReply(value);
+    return {
+        value: guarded.intervened || !guarded.response.trim() ? fallback : guarded.response,
+        intervened: guarded.intervened,
+    };
+}
+function blockedRelationshipInteractiveToolCall(toolCall) {
+    return {
+        ...toolCall,
+        function: {
+            ...toolCall.function,
+            arguments: JSON.stringify({ [RELATIONSHIP_BLOCK_MARKER]: true }),
+        },
+    };
+}
+/**
+ * Guard every string an interactive tool can render before the tool gets a
+ * chance to touch readline, Ink, Cowork, or another UI provider. Malformed
+ * calls fail closed instead of being handed to a side-effecting renderer.
+ */
+function prepareRelationshipSafeInteractiveToolCall(toolCall) {
+    const name = toolCall.function.name.trim().toLowerCase();
+    if (!RELATIONSHIP_INTERACTIVE_TOOLS.has(name))
+        return toolCall;
+    let parsed;
+    try {
+        parsed = JSON.parse(toolCall.function.arguments || '{}');
+    }
+    catch {
+        return blockedRelationshipInteractiveToolCall(toolCall);
+    }
+    if (!isUnknownRecord(parsed))
+        return blockedRelationshipInteractiveToolCall(toolCall);
+    if (name === 'ask_human') {
+        if (typeof parsed.question !== 'string')
+            return blockedRelationshipInteractiveToolCall(toolCall);
+        const question = guardInteractiveText(parsed.question, SAFE_INTERACTIVE_QUESTION);
+        const prepared = { ...parsed, question: question.value };
+        if (Array.isArray(parsed.options)) {
+            prepared.options = parsed.options.map((option, index) => guardInteractiveText(option, `Option ${index + 1}`).value);
+        }
+        if (typeof parsed.default === 'string') {
+            prepared.default = guardInteractiveText(parsed.default, 'No answer provided – use your best judgement and continue.').value;
+        }
+        return {
+            ...toolCall,
+            function: { ...toolCall.function, arguments: JSON.stringify(prepared) },
+        };
+    }
+    if (!Array.isArray(parsed.questions))
+        return blockedRelationshipInteractiveToolCall(toolCall);
+    const questions = [];
+    for (let questionIndex = 0; questionIndex < parsed.questions.length; questionIndex += 1) {
+        const rawQuestion = parsed.questions[questionIndex];
+        if (!isUnknownRecord(rawQuestion) || !Array.isArray(rawQuestion.options)) {
+            return blockedRelationshipInteractiveToolCall(toolCall);
+        }
+        const question = guardInteractiveText(rawQuestion.question, SAFE_INTERACTIVE_QUESTION);
+        const header = guardInteractiveText(rawQuestion.header, `Question ${questionIndex + 1}`);
+        const options = [];
+        for (let optionIndex = 0; optionIndex < rawQuestion.options.length; optionIndex += 1) {
+            const rawOption = rawQuestion.options[optionIndex];
+            if (!isUnknownRecord(rawOption))
+                return blockedRelationshipInteractiveToolCall(toolCall);
+            const label = guardInteractiveText(rawOption.label, `Option ${optionIndex + 1}`);
+            const description = guardInteractiveText(rawOption.description, 'Choix proposé sans pression relationnelle.');
+            const preview = typeof rawOption.preview === 'string'
+                ? guardInteractiveText(rawOption.preview, 'Aperçu masqué par la sécurité relationnelle.')
+                : null;
+            const optionIntervened = label.intervened || description.intervened || preview?.intervened;
+            const preparedOption = {
+                ...rawOption,
+                label: optionIntervened ? `Option ${optionIndex + 1}` : label.value,
+                description: optionIntervened
+                    ? 'Choix proposé sans pression relationnelle.'
+                    : description.value,
+            };
+            if (preview) {
+                preparedOption.preview = optionIntervened
+                    ? 'Aperçu masqué par la sécurité relationnelle.'
+                    : preview.value;
+            }
+            options.push(preparedOption);
+        }
+        questions.push({
+            ...rawQuestion,
+            question: question.value,
+            header: question.intervened || header.intervened
+                ? `Question ${questionIndex + 1}`
+                : header.value,
+            options,
+        });
+    }
+    return {
+        ...toolCall,
+        function: {
+            ...toolCall.function,
+            arguments: JSON.stringify({ ...parsed, questions }),
+        },
+    };
+}
+function isBlockedRelationshipInteractiveToolCall(toolCall) {
+    const name = toolCall.function.name.trim().toLowerCase();
+    if (!RELATIONSHIP_INTERACTIVE_TOOLS.has(name))
+        return false;
+    try {
+        const parsed = JSON.parse(toolCall.function.arguments || '{}');
+        return parsed[RELATIONSHIP_BLOCK_MARKER] === true;
+    }
+    catch {
+        return true;
+    }
+}
+function relationshipSafeToolResultForDisplay(result) {
+    return result.success
+        ? { success: true, output: SAFE_TOOL_RESULT }
+        : { success: false, error: "L'outil a échoué ; aucun contenu brut n'est affiché." };
+}
+function relationshipSafeToolCallsForDisplay(toolCalls) {
+    return toolCalls.map((toolCall) => ({
+        ...toolCall,
+        function: {
+            ...toolCall.function,
+            arguments: JSON.stringify({ redacted: 'companion-safety' }),
+        },
+    }));
+}
+function unsafeRelationshipOutboundToolCall(toolCall) {
+    const name = toolCall.function.name.trim().toLowerCase();
+    if (!RELATIONSHIP_OUTBOUND_TOOLS.has(name))
+        return false;
+    let parsed;
+    try {
+        parsed = JSON.parse(toolCall.function.arguments || '{}');
+    }
+    catch {
+        // Malformed outbound arguments are not safe to reinterpret or deliver.
+        return true;
+    }
+    const strings = [];
+    const visit = (value) => {
+        if (typeof value === 'string') {
+            strings.push(value);
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value)
+                visit(item);
+            return;
+        }
+        if (value && typeof value === 'object') {
+            for (const item of Object.values(value))
+                visit(item);
+        }
+    };
+    visit(parsed);
+    return strings.some((value) => guardRelationshipReply(value).intervened);
 }
 function isIgnorableControlToolCall(toolCall) {
     const name = toolCall.function?.name?.trim();
@@ -143,6 +385,17 @@ export class AgentExecutor {
     getDecisionContextProvider() {
         return this.deps.decisionContextProvider ?? _decisionContextProvider;
     }
+    async getOperationalRobotName() {
+        const configured = process.env.CODEBUDDY_ROBOT_NAME?.trim();
+        if (configured)
+            return configured;
+        try {
+            return (await this.deps.operationalRobotNameProvider?.())?.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * Get or set the middleware pipeline.
      * Used by CodeBuddyAgent.enableAutoObservation() to inject middleware.
@@ -168,6 +421,9 @@ export class AgentExecutor {
             messages,
             isStreaming,
             abortController,
+            // Authoritative edit set from editor tool CALLS — editors emit diffs in
+            // their RESULTS, which the quality gate's text scrape can't parse (V3).
+            changedFiles: extractEditedFilesFromHistory(history),
         };
     }
     /**
@@ -194,86 +450,84 @@ export class AgentExecutor {
      * Execute a tool call, optionally through the LaneQueue for serialization.
      * Supports LLM-controlled parallelism via `wait_for_previous` parameter.
      */
-    executeToolViaLane(toolCall) {
+    executeToolViaLane(toolCall, executionExtra) {
         const laneQueue = this.deps.laneQueue;
         if (!laneQueue) {
-            return this.deps.toolHandler.executeTool(toolCall);
+            return this.deps.toolHandler.executeTool(toolCall, executionExtra);
         }
         const laneId = this.deps.laneId ?? 'default';
         const isParallel = this.isToolParallelizable(toolCall);
         const timeoutMs = this.getLaneTaskTimeoutMs(isParallel);
-        return laneQueue.enqueue(laneId, () => this.deps.toolHandler.executeTool(toolCall), {
+        return laneQueue.enqueue(laneId, () => this.deps.toolHandler.executeTool(toolCall, executionExtra), {
             parallel: isParallel,
             category: toolCall.function.name,
             timeout: timeoutMs,
         });
     }
-    /**
-     * 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 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) {
-        const threshold = maxToolResultChars ?? this.getAdaptiveCompactionThreshold();
-        // Sum characters from tool result messages
-        let totalToolChars = 0;
-        for (const m of preparedMessages) {
-            if (m.role === 'tool' && typeof m.content === 'string') {
-                totalToolChars += m.content.length;
-            }
-        }
-        if (totalToolChars <= threshold)
-            return preparedMessages;
-        const compressor = getRestorableCompressor();
-        // Compress oldest tool results first (front of the list)
-        const result = [...preparedMessages];
-        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([{
-                        role: m.role,
-                        content: m.content,
-                        tool_call_id: callId,
-                    }]);
-                if (compressed.messages[0]) {
-                    charsToFree -= (m.content.length - (compressed.messages[0].content?.length ?? 0));
-                    result[i] = { ...m, content: compressed.messages[0].content ?? m.content };
+    /** Execute one tool and buffer optional streaming-adapter output. */
+    async executeToolForBatch(toolCall, executionExtra, signal, startedAt = Date.now()) {
+        const streamChunks = [];
+        const extraWithSignal = signal
+            ? { ...(executionExtra ?? {}), abortSignal: signal }
+            : executionExtra;
+        const execute = async () => {
+            const streamingTools = new Set(['bash', 'reason', 'generate_document']);
+            if (streamingTools.has(toolCall.function.name)) {
+                const generator = this.deps.toolHandler.executeToolStreaming(toolCall, extraWithSignal);
+                let generated = await generator.next();
+                while (!generated.done) {
+                    streamChunks.push(generated.value);
+                    generated = await generator.next();
                 }
+                return {
+                    result: generated.value ?? { success: false, error: 'Tool returned no result' },
+                    streamChunks,
+                };
+            }
+            const streamingAdapter = getStreamingAdapter();
+            if (streamingAdapter.supportsStreaming(toolCall.function.name)) {
+                const result = await streamingAdapter.wrapWithStreaming(toolCall.function.name, () => this.executeToolViaLane(toolCall, extraWithSignal), (chunk) => streamChunks.push(chunk));
+                return { result, streamChunks };
+            }
+            return {
+                result: await this.executeToolViaLane(toolCall, extraWithSignal),
+                streamChunks,
+            };
+        };
+        if (!signal) {
+            try {
+                return await execute();
+            }
+            catch (error) {
+                return {
+                    result: { success: false, error: `Tool execution failed: ${getErrorMessage(error)}` },
+                    streamChunks,
+                };
             }
         }
-        logger.debug(`ToolResultCompactionGuard: compacted tool results`, {
-            before: totalToolChars,
-            freed: totalToolChars - charsToFree,
+        return await new Promise((resolve) => {
+            let settled = false;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                signal.removeEventListener('abort', onAbort);
+                resolve(value);
+            };
+            const onAbort = () => finish({
+                result: abortedToolResult(startedAt),
+                streamChunks,
+            });
+            signal.addEventListener('abort', onAbort, { once: true });
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+            void execute().then(finish, (error) => finish({
+                result: { success: false, error: `Tool execution failed: ${getErrorMessage(error)}` },
+                streamChunks,
+            }));
         });
-        return result;
     }
     /**
      * Process a user message sequentially (non-streaming)
@@ -291,50 +545,115 @@ export class AgentExecutor {
      * 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.
+     * `@terminal` markers removed) and ephemeral context for bare `@path`
+     * mentions. 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 {
-            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;
-                }
-                for (const block of mentionResult.contextBlocks) {
-                    messages.push({
+    async preprocessUserMessage(message, messages, projectRoot, readOnlySelfInspection = false, isolatedSharedHost = false) {
+        // Mentions can read explicit workspace files, persona selection can alter
+        // identity, and KG extraction persists project entities. None belongs in a
+        // core-only technical self-inspection turn.
+        if (readOnlySelfInspection) {
+            return { message, fileMentionContextBlocks: [], fileMentionUserNotices: [] };
+        }
+        // Avoid loading the sizeable mention parser (fs-extra, axios, child_process)
+        // for the overwhelmingly common case where the message contains no mention.
+        const mentionPromise = CONTEXT_MENTION_PATTERN.test(message)
+            ? import('../../input/context-mentions.js')
+                .then(({ processMentions }) => processMentions(message, { projectRoot }))
+                .catch(() => null)
+            : Promise.resolve(null);
+        // Bare @path mentions are resolved independently from the heavier legacy
+        // mention parser. They are turn-scoped context: the user's message remains
+        // readable in history, while file contents do not persist into later turns.
+        const fileMentionPromise = FILE_MENTION_CANDIDATE_PATTERN.test(message)
+            ? import('../../context/file-mentions.js')
+                .then(async ({ formatFileMentionContext, resolveFileMentions }) => {
+                const resolution = await resolveFileMentions(message, { projectRoot });
+                const blocks = resolution.files.map((file) => ({
+                    role: 'system',
+                    content: `<context type="file_mention" ephemeral="true">\n${formatFileMentionContext(file)}\n</context>`,
+                }));
+                const notices = [];
+                for (const ignored of resolution.issues) {
+                    logger.debug('File mention content was not injected', {
+                        path: ignored.path,
+                        reason: ignored.reason,
+                    });
+                    blocks.push({
                         role: 'system',
-                        content: `<context type="${block.type}" source="${block.source}">\n${block.content}\n</context>`,
+                        content: [
+                            '<context type="file_mention_notice" ephemeral="true">',
+                            `Mention ${JSON.stringify(ignored.mention)} was not included: ${ignored.message}`,
+                            '</context>',
+                        ].join('\n'),
                     });
+                    if (ignored.reason === 'not-found') {
+                        notices.push(`Fichier ${ignored.path} introuvable, ignoré.`);
+                    }
                 }
+                return { blocks, notices };
+            })
+                .catch((error) => {
+                const errorMessage = getErrorMessage(error);
+                logger.debug('File mention resolution failed closed', {
+                    error: errorMessage,
+                });
+                return {
+                    blocks: [{
+                            role: 'system',
+                            content: [
+                                '<context type="file_mention_notice" ephemeral="true">',
+                                `File mention resolution failed: ${errorMessage}`,
+                                '</context>',
+                            ].join('\n'),
+                        }],
+                    notices: [`Mention de fichier ignorée : ${errorMessage}`],
+                };
+            })
+            : Promise.resolve({ blocks: [], notices: [] });
+        // Persona selection affects this turn's system prompt, so keep it on the
+        // critical path, but load it concurrently with explicit mention expansion.
+        const personaPromise = isolatedSharedHost
+            ? Promise.resolve(null)
+            : import('../../personas/persona-manager.js')
+                .then(({ getPersonaManager }) => getPersonaManager().autoSelectPersona({ message }))
+                .catch(() => null);
+        const [mentionResult, , fileMentionResolution] = await Promise.all([
+            mentionPromise,
+            personaPromise,
+            fileMentionPromise,
+        ]);
+        const fileMentionContextBlocks = fileMentionResolution.blocks;
+        const fileMentionUserNotices = fileMentionResolution.notices;
+        if (mentionResult && mentionResult.contextBlocks.length > 0) {
+            message = mentionResult.cleanedMessage;
+            const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
+            if (lastUserMsg && typeof lastUserMsg.content === 'string') {
+                lastUserMsg.content = message;
             }
-        }
-        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);
+            for (const block of mentionResult.contextBlocks) {
+                messages.push({
+                    role: 'system',
+                    content: `<context type="${block.type}" source="${block.source}">\n${block.content}\n</context>`,
+                });
             }
         }
-        catch { /* non-critical */ }
-        return message;
+        // Entity extraction is persistence work. Defer even the module evaluation
+        // until the current call stack has started response preparation.
+        if (!isolatedSharedHost && classifyQuery(message).complexity !== 'trivial') {
+            setImmediate(() => {
+                void import('../../memory/knowledge-graph.js').then(async ({ getKnowledgeGraph }) => {
+                    const kg = getKnowledgeGraph();
+                    await kg.load();
+                    kg.extractFromMessageDeduped(message);
+                }).catch(() => { });
+            });
+        }
+        return { message, fileMentionContextBlocks, fileMentionUserNotices };
     }
     /**
      * Process a user message — sequential adapter (Phase D of task #5 fusion).
@@ -344,18 +663,25 @@ export class AgentExecutor {
      * 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.
+     * Progress-only events (`tool_stream`, `token_count`, `reasoning`, `steer`)
+     * are dropped per décision #3 of the fusion plan. `ask_user` is different:
+     * the sequential caller cannot suspend, but it can surface the question and
+     * accept the answer as a later turn, so the collector persists it as an
+     * assistant entry in both history projections.
      *
      * 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) {
+    async processUserMessage(message, history, messages, turnStartedAt = Date.now(), transientContext, relationshipSafety = false, surface, introspectionText) {
         const initialHistoryLength = history.length;
-        for await (const _event of this.runTurnLoop(message, history, messages, null)) {
-            // Events dropped. runTurnLoop pushes ChatEntries to history directly.
+        for await (const event of this.runMeasuredTurn(message, history, messages, null, turnStartedAt, transientContext, relationshipSafety, surface, introspectionText)) {
+            if (event.type === 'ask_user' && event.askUser?.question.trim()) {
+                const content = sanitizeAssistantOutput(event.askUser.question.trim());
+                history.push({ type: 'assistant', content, timestamp: new Date() });
+                messages.push({ role: 'assistant', content });
+            }
+            // Other entries are pushed by runTurnLoop itself. Progress-only events
+            // have no durable sequential representation and are intentionally dropped.
         }
         return history.slice(initialHistoryLength);
     }
@@ -369,7 +695,7 @@ export class AgentExecutor {
      * path.
      *
      * Derived from the comparative audit Gemini CLI vs Code Buddy
-     * (claude-et-patrice/propositions/AUDIT-GEMINI-CLI-AGENTIC-LOOP-2026-05-04.md,
+     * (le dépôt privé de passation, 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.
      *
@@ -379,10 +705,10 @@ export class AgentExecutor {
      * @returns `{ entries }` — new ChatEntries pushed during this turn
      *   PLUS `{ streamingEvents }` — every event the loop yielded, in order
      */
-    async processUserMessageWithStreamingEvents(message, history, messages) {
+    async processUserMessageWithStreamingEvents(message, history, messages, turnStartedAt = Date.now()) {
         const initialHistoryLength = history.length;
         const streamingEvents = [];
-        for await (const event of this.runTurnLoop(message, history, messages, null)) {
+        for await (const event of this.runMeasuredTurn(message, history, messages, null, turnStartedAt)) {
             streamingEvents.push(event);
         }
         return {
@@ -406,8 +732,27 @@ export class AgentExecutor {
      * 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);
+    async *processUserMessageStream(message, history, messages, abortController, turnStartedAt = Date.now(), transientContext, relationshipSafety = false, surface, introspectionText) {
+        yield* this.runMeasuredTurn(message, history, messages, abortController, turnStartedAt, transientContext, relationshipSafety, surface, introspectionText);
+    }
+    /** Measure end-to-end perceived latency around the single authoritative loop. */
+    async *runMeasuredTurn(message, history, messages, abortController, startedAt, transientContext, relationshipSafety = false, surface, introspectionText) {
+        const operationId = getLatencyOptimizer().startOperation('assistant_turn', startedAt);
+        let recordedFirstVisibleResponse = false;
+        try {
+            for await (const event of this.runTurnLoop(message, history, messages, abortController, transientContext, relationshipSafety, surface, introspectionText)) {
+                if (!recordedFirstVisibleResponse &&
+                    (event.type === 'content' || event.type === 'reasoning' || event.type === 'tool_calls')) {
+                    recordedFirstVisibleResponse = true;
+                    getStreamingOptimizer().recordFirstToken(Date.now() - startedAt);
+                }
+                yield event;
+            }
+        }
+        finally {
+            getLatencyOptimizer().endOperation(operationId);
+            getStreamingOptimizer().recordTotalTime(Date.now() - startedAt);
+        }
     }
     /**
      * Unified turn loop — Phase C of the task #5 fusion. Single source of
@@ -421,13 +766,134 @@ export class AgentExecutor {
      *
      * Plan : ~/.claude/plans/vague1-task5-design-decisions.md
      */
-    async *runTurnLoop(message, history, messages, abortController) {
+    async *runTurnLoop(message, history, messages, abortController, transientContext, relationshipSafety = false, surface, introspectionText) {
+        const timelineEnabled = process.env.CODEBUDDY_TIMELINE === 'true' && this.deps.recordTimelineTurn !== undefined;
+        const timelineHistoryStart = timelineEnabled ? history.length : 0;
+        const timelineTurn = timelineEnabled
+            ? Math.max(1, history.reduce((count, entry) => count + (entry.type === 'user' ? 1 : 0), 0))
+            : 0;
         // 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);
+        // Voice and other transports may wrap the current utterance in recent
+        // history. Intent must be derived from the explicit current text only: an
+        // earlier "es-tu consciente ?" must never turn a later write request into
+        // a read-only introspection turn.
+        const introspectionTextForTurn = introspectionText ?? message;
+        const introspectionIntent = classifyLisaIntrospection(introspectionTextForTurn);
+        const readOnlySelfInspection = introspectionIntent === 'describe' || introspectionIntent === 'inspect';
+        const guardGenerativeSelfInspection = introspectionIntent === 'improve';
+        const isolatedSharedHost = surface === 'http';
+        const turnCwd = typeof this.deps.toolHandler.getWorkingDirectory === 'function'
+            ? this.deps.toolHandler.getWorkingDirectory()
+            : process.cwd();
+        // A stateful `cd` changes the tool cwd, not the TUI project boundary.
+        // Keep @file confinement anchored to the process launch directory there;
+        // embedded hosts continue to provide their explicit workspace directory.
+        const fileMentionProjectRoot = surface === 'cli' ? process.cwd() : turnCwd;
+        const preprocessed = await this.preprocessUserMessage(message, messages, fileMentionProjectRoot, readOnlySelfInspection, isolatedSharedHost);
+        message = preprocessed.message;
+        const fileMentionContextBlocks = preprocessed.fileMentionContextBlocks;
+        for (const notice of preprocessed.fileMentionUserNotices) {
+            history.push({ type: 'assistant', content: notice, timestamp: new Date() });
+            yield { type: 'content', content: `\n${notice}\n` };
+        }
+        const jitContextBlocks = [];
+        // Query ranking should also follow the current utterance on transports that
+        // embed history in `message`; keep the full composite only as user context
+        // for the provider. Normal CLI turns retain the preprocessed query.
+        const turnQueryText = introspectionText ?? message;
+        let permissionMode;
+        let providerName;
+        let operationalRobotName;
+        if (introspectionIntent !== null) {
+            operationalRobotName = await this.getOperationalRobotName();
+            try {
+                const { getPermissionModeManager } = await import('../../security/permission-modes.js');
+                permissionMode = getPermissionModeManager().getMode();
+            }
+            catch {
+                // Runtime permission evidence is optional. Never invent a value.
+            }
+            try {
+                providerName = this.deps.client.getProviderName();
+            }
+            catch {
+                // Legacy/test clients may not expose provider metadata.
+            }
+        }
+        if (readOnlySelfInspection) {
+            if (isLisaEvolutionRequest(introspectionTextForTurn)) {
+                const { formatEvolutionNotesForVoice, queryEvolutionNotes, readEvolutionNotes, } = await import('../../self-model/evolution-notes.js');
+                const since = introspectionTextForTurn.match(/\b20\d{2}-\d{2}-\d{2}\b/)?.[0];
+                const notes = queryEvolutionNotes(await readEvolutionNotes({ workDir: turnCwd }), {
+                    ...(since ? { since } : {}),
+                    limit: 3,
+                });
+                const content = sanitizeAssistantOutput(formatEvolutionNotesForVoice(notes));
+                history.push({ type: 'assistant', content, timestamp: new Date() });
+                messages.push({ role: 'assistant', content });
+                yield { type: 'content', content };
+                yield {
+                    type: 'token_count',
+                    tokenCount: this.deps.tokenCounter.countTokens(content),
+                };
+                if (timelineEnabled) {
+                    await this.recordCompletedTimelineTurn(timelineHistoryStart, timelineTurn, history, message);
+                }
+                yield { type: 'done' };
+                return;
+            }
+            // A provider can ignore an optional tool schema, and free-form prose
+            // cannot provide a hard postcondition against invented inner experience.
+            // Build the complete report locally from the attested, curated core on
+            // every strict describe/inspect turn. No provider, plugin or generic
+            // workspace tool participates in this path.
+            const { buildOperationalSelfModel } = await import('../../identity/operational-self-model.js');
+            const selfModel = buildOperationalSelfModel({
+                cwd: turnCwd,
+                focus: introspectionTextForTurn,
+                depth: introspectionIntent === 'describe' ? 'summary' : 'deep',
+                ...(operationalRobotName
+                    ? { robotName: operationalRobotName }
+                    : {}),
+                runtime: {
+                    providerInvoked: false,
+                    ...(this.deps.client.getCurrentModel()
+                        ? { model: this.deps.client.getCurrentModel() }
+                        : {}),
+                    provider: providerName,
+                    ...(surface ? { surface } : {}),
+                    ...(permissionMode ? { permissionMode } : {}),
+                    ...configuredSensoryRuntime(surface),
+                },
+            });
+            const content = sanitizeAssistantOutput(guardLisaOperationalSelfInspectionReply(renderLisaOperationalSelfResponse(selfModel, introspectionTextForTurn, introspectionIntent), introspectionTextForTurn));
+            history.push({ type: 'assistant', content, timestamp: new Date() });
+            messages.push({ role: 'assistant', content });
+            yield { type: 'content', content };
+            yield {
+                type: 'token_count',
+                tokenCount: this.deps.tokenCounter.countTokens(content),
+            };
+            if (timelineEnabled) {
+                await this.recordCompletedTimelineTurn(timelineHistoryStart, timelineTurn, history, message);
+            }
+            yield { type: 'done' };
+            return;
+        }
+        // Pure, per-turn tone context. Keep it out of the persisted transcript and
+        // the agent identity: a changing system-prompt append would rebuild Cowork's
+        // cached agent on every message. This block is added to each prepared LLM
+        // request in the turn instead, including post-tool rounds.
+        const emotionalPresenceContext = buildTextEmotionalPresenceContext(turnQueryText, messages.flatMap((turn) => typeof turn.content === 'string'
+            ? [{ role: turn.role, content: turn.content }]
+            : []));
+        const currentTurnContext = transientContext?.trim();
+        const { injection: ctxLevel, complexity: queryComplexity } = classifyQuery(turnQueryText);
+        logger.debug(`Query classified as '${queryComplexity}' — context injection level: ${JSON.stringify(ctxLevel)}`);
+        const incrementalTokenCounter = new IncrementalMessageTokenCounter((batch) => this.deps.tokenCounter.countMessageTokens(batch));
+        let inputTokens = incrementalTokenCounter.count(messages);
         yield {
             type: "token_count",
             tokenCount: inputTokens,
@@ -435,6 +901,41 @@ export class AgentExecutor {
         const maxToolRounds = this.config.maxToolRounds;
         let toolRounds = 0;
         let totalOutputTokens = 0;
+        let totalInputTokensForCost = 0;
+        let providerPromptTokens = 0;
+        let providerCompletionTokens = 0;
+        let providerUsageSeen = false;
+        let sessionCostRecorded = false;
+        const recordTurnCost = () => {
+            if (sessionCostRecorded)
+                return;
+            sessionCostRecorded = true;
+            try {
+                // Pass provider usage when available (takes precedence over local estimates)
+                const providerUsage = providerUsageSeen
+                    ? { promptTokens: providerPromptTokens, completionTokens: providerCompletionTokens }
+                    : undefined;
+                // Only pass provider usage when the provider reported one, so the
+                // historical two-argument call (and its tests) stays byte-identical.
+                if (providerUsage) {
+                    this.config.recordSessionCost(totalInputTokensForCost, totalOutputTokens, providerUsage);
+                }
+                else {
+                    this.config.recordSessionCost(totalInputTokensForCost, totalOutputTokens);
+                }
+            }
+            catch (error) {
+                logger.warn('Failed to record session cost', { error: getErrorMessage(error) });
+            }
+            try {
+                this.config.recordTurnProviderUsage?.(providerUsageSeen
+                    ? { promptTokens: providerPromptTokens, completionTokens: providerCompletionTokens }
+                    : undefined);
+            }
+            catch (error) {
+                logger.warn('Failed to record provider turn usage', { error: getErrorMessage(error) });
+            }
+        };
         // In-loop recovery budgets (Hermes parity): bound re-prompts WITHIN a turn
         // so a length-truncated or post-tool-empty response is recovered instead of
         // returned half-written. 0 disables. Per-turn counters.
@@ -450,16 +951,17 @@ export class AgentExecutor {
         const maxEmptyRetries = parseRecoveryBudget(process.env.CODEBUDDY_MAX_EMPTY_RETRIES, 0);
         let lengthContinuations = 0;
         let emptyRetries = 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;
+            // New task: clear per-task middleware latching (quality-gate run count,
+            // auto-repair attempts, verification one-shot warning). The pipeline is
+            // built once and reused across tasks while toolRound restarts at 0, so
+            // without this the gates would silently stay off after the first task(s).
+            pipeline?.resetForNewTask?.();
             let terminateDetectedStreaming = false;
             while (toolRounds < maxToolRounds) {
                 if (abortController?.signal.aborted) {
@@ -478,8 +980,13 @@ export class AgentExecutor {
                         return;
                     }
                     if (mwResult.action === 'compact') {
-                        // Trigger context compaction
-                        this.deps.contextManager.prepareMessages(messages);
+                        // Trigger context compaction IN PLACE — prepareMessages() is pure
+                        // and its discarded return made this action a silent no-op.
+                        const compacted = compactTurnMessagesInPlace(this.deps.contextManager, messages, {
+                            isolatedSharedHost,
+                        });
+                        if (compacted)
+                            incrementalTokenCounter.invalidate();
                         // 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());
@@ -494,102 +1001,161 @@ export class AgentExecutor {
                         });
                     }
                 }
-                // 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.
+                // Start every independent pre-request task before awaiting any of it.
+                // Time-to-first-token is then bounded by the slowest task instead of the
+                // sum of prompt building, tool selection, and context enrichment.
                 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) {
+                const rebuiltSystemPromptPromise = toolRounds === 0 &&
+                    rebuildSystemPromptForQuery &&
+                    !isolatedSharedHost
+                    ? rebuildSystemPromptForQuery(turnQueryText).catch((err) => {
                         logger.warn('[agent-executor] query-aware SP rebuild failed', { error: String(err) });
-                    }
-                }
+                        return null;
+                    })
+                    : Promise.resolve(null);
                 // 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.
+                // shrink the tool set to a minimal, reliable core.
                 const activeModelName = this.deps.client.getCurrentModel() ?? '';
+                const modelToolConfig = getModelToolConfig(activeModelName);
                 let selectionOpts = activeModelName ? { modelName: activeModelName } : {};
-                try {
-                    const { getModelToolConfig } = await import('../../config/model-tools.js');
-                    const cfg = getModelToolConfig(activeModelName);
-                    if (cfg.promptProfile === 'lite') {
-                        selectionOpts = {
-                            ...selectionOpts,
-                            maxTools: 5,
-                            alwaysInclude: ['view_file', 'bash', 'search'],
-                        };
-                    }
+                if (introspectionIntent === 'improve') {
+                    selectionOpts = {
+                        ...selectionOpts,
+                        // Improvement is not silently elevated: these are only model-facing
+                        // schemas. ToolHandler still applies the active permission, trust,
+                        // confirmation, and WritePolicy gates to every requested effect.
+                        alwaysInclude: ['self_describe', 'view_file', 'search', 'apply_patch', 'bash'],
+                        enableCaching: false,
+                    };
+                }
+                else if (isHeadlessLocalPromptCompact()) {
+                    selectionOpts = {
+                        ...selectionOpts,
+                        maxTools: HEADLESS_LOCAL_COMPACT_MAX_TOOLS,
+                        alwaysInclude: [...HEADLESS_LOCAL_COMPACT_ALWAYS_INCLUDE],
+                    };
+                }
+                else if (modelToolConfig.promptProfile === 'lite') {
+                    selectionOpts = {
+                        ...selectionOpts,
+                        maxTools: 5,
+                        alwaysInclude: ['view_file', 'bash', 'search'],
+                    };
+                }
+                const selectionPromise = this.deps.toolSelectionStrategy.selectToolsForQuery(turnQueryText, selectionOpts);
+                // Build context in a scratch array while the prompt and tools are being
+                // prepared. It is appended only after transcript preparation so the
+                // existing compaction and repair ordering remains unchanged.
+                const contextBlocks = [
+                    ...fileMentionContextBlocks,
+                    ...jitContextBlocks,
+                ];
+                const contextPromise = toolRounds === 0
+                    ? injectInitialContext(contextBlocks, {
+                        message: turnQueryText,
+                        introspectionText: introspectionTextForTurn,
+                        cwd: turnCwd,
+                        ctxLevel,
+                        loadWorkspaceContext: lazyGetWorkspaceContext,
+                        decisionContextProvider: this.getDecisionContextProvider(),
+                        icmBridgeProvider: this.getICMBridgeProvider(),
+                        codeGraphContextProvider: this.getCodeGraphContextProvider(),
+                        docsContextProvider: this.getDocsContextProvider(),
+                        isolatedSharedHost,
+                        ...(operationalRobotName ? { operationalRobotName } : {}),
+                        ...(introspectionIntent
+                            ? {
+                                operationalRuntime: {
+                                    ...(activeModelName ? { model: activeModelName } : {}),
+                                    ...(providerName ? { provider: providerName } : {}),
+                                    ...(surface ? { surface } : {}),
+                                    ...(permissionMode ? { permissionMode } : {}),
+                                    ...configuredSensoryRuntime(surface),
+                                },
+                            }
+                            : {}),
+                    })
+                    : injectNextRoundContext(contextBlocks, {
+                        message: turnQueryText,
+                        introspectionText: introspectionTextForTurn,
+                        cwd: turnCwd,
+                        queryComplexity,
+                        collectiveGraph: ctxLevel.collectiveGraph,
+                        isolatedSharedHost,
+                    });
+                const [rebuiltSystemPrompt, selectionResult] = await Promise.all([
+                    rebuiltSystemPromptPromise,
+                    selectionPromise,
+                    contextPromise,
+                ]);
+                const firstMessage = messages[0];
+                if (rebuiltSystemPrompt && firstMessage && firstMessage.role === 'system') {
+                    firstMessage.content = rebuiltSystemPrompt;
+                    incrementalTokenCounter.invalidate();
+                    logger.debug(`[agent-executor] system prompt rebuilt query-aware (${rebuiltSystemPrompt.length} chars)`);
                 }
-                catch { /* model-tools optional, never block */ }
-                const selectionResult = await this.deps.toolSelectionStrategy.selectToolsForQuery(message, selectionOpts);
                 let tools = selectionResult.tools;
                 let forcedChatOnlyToolRunModel = null;
-                if (toolRounds === 0)
+                if (toolRounds === 0) {
                     this.deps.toolSelectionStrategy.cacheTools(tools, activeModelName);
-                // 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.
+                }
+                // Models explicitly marked chat-only must not see callable schemas.
+                if (activeModelName && modelToolConfig.supportsToolCalls === false && tools.length > 0) {
+                    if (process.env.GROK_FORCE_TOOLS === 'true') {
+                        forcedChatOnlyToolRunModel = activeModelName;
+                    }
+                    else {
+                        logger.debug(`[agent-executor] supportsToolCalls=false for ${activeModelName} — dropping ${tools.length} tools from chat call`);
+                        tools = [];
+                    }
+                }
+                const turnExecutionExtra = introspectionIntent
+                    ? {
+                        ...(activeModelName ? { model: activeModelName } : {}),
+                        ...(providerName ? { provider: providerName } : {}),
+                        ...(surface ? { surface } : {}),
+                        ...(permissionMode ? { permissionMode } : {}),
+                        ...(operationalRobotName
+                            ? { robotName: operationalRobotName }
+                            : {}),
+                        exposedToolNames: tools.map((tool) => tool.function.name),
+                        introspectionIntent,
+                    }
+                    : undefined;
+                let preparedMessages;
                 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 = activeModelName;
-                    if (modelName) {
-                        const cfg = getModelToolConfig(modelName);
-                        if (cfg.supportsToolCalls === false && tools.length > 0) {
-                            if (process.env.GROK_FORCE_TOOLS === 'true') {
-                                forcedChatOnlyToolRunModel = modelName;
-                            }
-                            else {
-                                logger.debug(`[agent-executor] supportsToolCalls=false for ${modelName} — dropping ${tools.length} tools from chat call`);
-                                tools = [];
-                            }
-                        }
+                    preparedMessages = prepareTurnMessages(this.deps.contextManager, messages, {
+                        isolatedSharedHost,
+                    });
+                }
+                catch (error) {
+                    if (error instanceof ContextCompactionError) {
+                        logger.error('Context compaction refused the provider call', {
+                            code: error.code,
+                            tokens: error.tokens,
+                            limit: error.limit,
+                        });
+                        yield { type: 'content', content: `\n\n${error.message}` };
+                        yield { type: 'done' };
+                        return;
                     }
+                    throw error;
                 }
-                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,
+                preparedMessages.push(...contextBlocks);
+                if (emotionalPresenceContext) {
+                    preparedMessages.push({
+                        role: 'system',
+                        content: `<interaction_context ephemeral="true">\n${emotionalPresenceContext}\n</interaction_context>`,
+                    });
+                }
+                if (currentTurnContext) {
+                    preparedMessages.push({
+                        role: 'system',
+                        content: `<companion_current_turn_context ephemeral="true">\n${currentTurnContext}\n</companion_current_turn_context>`,
                     });
                 }
+                inputTokens = incrementalTokenCounter.count(messages);
+                totalInputTokensForCost += inputTokens;
                 // Context warning — always check regardless of pipeline state
                 {
                     const contextWarning = this.deps.contextManager.shouldWarn(preparedMessages);
@@ -613,34 +1179,109 @@ export class AgentExecutor {
                         }
                     }
                 }
-                const stream = this.deps.client.chatStream(preparedMessages, tools, undefined, this.config.isGrokModel() && this.deps.toolSelectionStrategy.shouldUseSearchFor(message)
-                    ? { search_parameters: { mode: "auto" } }
-                    : { search_parameters: { mode: "off" } });
                 this.deps.streamingHandler.reset();
-                for await (const chunk of stream) {
-                    if (abortController?.signal.aborted) {
-                        yield { type: "content", content: "\n\n[Operation cancelled by user]" };
-                        yield { type: "done" };
-                        return;
-                    }
-                    const result = this.deps.streamingHandler.accumulateChunk(chunk);
-                    if (result.reasoningContent) {
-                        yield { type: "reasoning", reasoning: result.reasoningContent };
-                    }
-                    if (result.hasNewToolCalls && result.toolCalls) {
-                        yield { type: "tool_calls", toolCalls: result.toolCalls };
-                    }
-                    if (result.displayContent) {
-                        yield { type: "content", content: result.displayContent };
-                    }
-                    if (result.shouldEmitTokenCount && result.tokenCount !== undefined) {
-                        yield { type: "token_count", tokenCount: inputTokens + result.tokenCount };
+                let steeringRequestedDuringText = false;
+                let streamObservedToolCalls = false;
+                let streamEmittedVisibleDelta = false;
+                // Stall guard: some backends (ChatGPT/Codex OAuth observed) accept
+                // the request then never send a byte — without a bound this loop
+                // hangs FOREVER (turns stuck for hours in Cowork and headless waves).
+                // Fail fast with a clear error instead; the caller/user retries.
+                const progress = startHeadlessPromptProgress();
+                const streamFactory = () => withStallGuard(this.deps.client.chatStream(preparedMessages, tools, {
+                    streamRetry: false,
+                    turnMetrics: {
+                        recorder: getTurnMetricsRecorder(),
+                        inputTokens,
+                        getOutputTokens: () => this.deps.streamingHandler.getTokenCount() || 0,
+                    },
+                    ...(abortController?.signal ? { signal: abortController.signal } : {}),
+                }, this.config.isGrokModel() &&
+                    this.deps.toolSelectionStrategy.shouldUseSearchFor(turnQueryText)
+                    ? { search_parameters: { mode: "auto" } }
+                    : { search_parameters: { mode: "off" } }), resolveStallTimeoutMs(), {
+                    firstTokenTimeoutMs: () => resolveFirstTokenStallTimeoutMs(inputTokens, process.env, {
+                        targetIsLocal: this.deps.client.isEffectiveTargetLocal?.(),
+                    }),
+                });
+                try {
+                    for await (const streamEvent of withLlmStreamRetry(streamFactory, {
+                        maxRetries: 2,
+                        baseDelayMs: 500,
+                        ...(abortController?.signal ? { signal: abortController.signal } : {}),
+                    })) {
+                        if (streamEvent.type === 'retry') {
+                            // A retry after bytes were already shown would concatenate the
+                            // abandoned fragment with the new attempt (hybrid answer). Align
+                            // with the mid-stream integrity rule: retry only when nothing
+                            // visible has been yielded.
+                            if (streamEmittedVisibleDelta) {
+                                throw new Error('Réponse interrompue après un fragment déjà rendu ; retry refusé pour éviter une réponse hybride.');
+                            }
+                            this.deps.streamingHandler.reset();
+                            streamObservedToolCalls = false;
+                            yield {
+                                type: 'reasoning',
+                                reasoning: `Reconnexion ${streamEvent.retry}/${streamEvent.maxRetries}`,
+                            };
+                            continue;
+                        }
+                        const chunk = streamEvent.value;
+                        progress.onFirstToken();
+                        if (abortController?.signal.aborted) {
+                            yield { type: "content", content: "\n\n[Operation cancelled by user]" };
+                            yield { type: "done" };
+                            return;
+                        }
+                        const result = this.deps.streamingHandler.accumulateChunk(chunk);
+                        if (result.reasoningContent && !relationshipSafety && !guardGenerativeSelfInspection) {
+                            yield { type: "reasoning", reasoning: result.reasoningContent };
+                        }
+                        if (result.hasNewToolCalls && result.toolCalls) {
+                            streamObservedToolCalls = true;
+                            streamEmittedVisibleDelta = true;
+                            yield {
+                                type: "tool_calls",
+                                toolCalls: relationshipSafety
+                                    ? relationshipSafeToolCallsForDisplay(result.toolCalls)
+                                    : result.toolCalls,
+                            };
+                        }
+                        if (result.displayContent && !relationshipSafety && !guardGenerativeSelfInspection) {
+                            streamEmittedVisibleDelta = true;
+                            yield { type: "content", content: result.displayContent };
+                        }
+                        if (result.shouldEmitTokenCount && result.tokenCount !== undefined) {
+                            yield { type: "token_count", tokenCount: inputTokens + result.tokenCount };
+                        }
+                        // Steering is safe only while this response is still pure text. Do
+                        // not consume the queue yet: the accumulated message is authoritative
+                        // and may reveal a tool call in the same chunk.
+                        if (!streamObservedToolCalls &&
+                            this.deps.messageQueue?.hasSteeringMessage()) {
+                            steeringRequestedDuringText = true;
+                            break;
+                        }
                     }
                 }
+                finally {
+                    progress.stop();
+                }
+                const trailingDisplayContent = this.deps.streamingHandler.flushDisplayContent?.() ?? '';
+                if (trailingDisplayContent &&
+                    !relationshipSafety &&
+                    !guardGenerativeSelfInspection) {
+                    yield { type: 'content', content: trailingDisplayContent };
+                }
                 if (tools.length > 0 && !this.deps.streamingHandler.hasYieldedToolCalls()) {
                     const extracted = this.deps.streamingHandler.extractToolCalls();
                     if (extracted.toolCalls.length > 0) {
-                        yield { type: "tool_calls", toolCalls: extracted.toolCalls };
+                        yield {
+                            type: "tool_calls",
+                            toolCalls: relationshipSafety
+                                ? relationshipSafeToolCallsForDisplay(extracted.toolCalls)
+                                : extracted.toolCalls,
+                        };
                     }
                 }
                 const accumulatedMessage = this.deps.streamingHandler.getAccumulatedMessage();
@@ -656,6 +1297,9 @@ export class AgentExecutor {
                     }
                     toolCalls = filteredToolCalls.length > 0 ? filteredToolCalls : undefined;
                 }
+                if (relationshipSafety && Array.isArray(toolCalls)) {
+                    toolCalls = toolCalls.map(prepareRelationshipSafeInteractiveToolCall);
+                }
                 const hasToolCalls = Array.isArray(toolCalls) && toolCalls.length > 0;
                 // Pre-fallback raw content — used by in-loop recovery to tell a real
                 // partial answer (retry-able) from a truly empty turn (give up).
@@ -666,321 +1310,565 @@ export class AgentExecutor {
                     rawStreamedContent =
                         `Blocked: ${forcedChatOnlyToolRunModel} is configured as a chat-only local model and ` +
                             'returned no structured tool call even with GROK_FORCE_TOOLS=true. ' +
-                            'Use a tool-capable model such as qwen3.5-ctx32k or gpt-5.5 for goals that need shell/tools.';
-                    yield { type: "content", content: `${rawStreamedContent}\n` };
+                            'Use a tool-capable model such as qwen3.5-ctx32k or gpt-5.6-sol for goals that need shell/tools.';
+                    if (!relationshipSafety && !guardGenerativeSelfInspection) {
+                        yield { type: "content", content: `${rawStreamedContent}\n` };
+                    }
                 }
-                if (!rawStreamedContent)
+                // The "Using tools..." placeholder is only legitimate when this turn
+                // actually carries tool_calls. An empty provider reply without tools
+                // must not be rewritten into a plausible assistant message.
+                const synthesizedToolFallback = !rawStreamedContent.trim() && hasToolCalls;
+                if (synthesizedToolFallback) {
                     rawStreamedContent = "Using tools to help you...";
-                const content = sanitizeAssistantOutput(rawStreamedContent);
+                }
+                const sanitizedContent = sanitizeAssistantOutput(rawStreamedContent);
+                const guardedContent = relationshipSafety
+                    ? guardRelationshipReply(sanitizedContent)
+                    : null;
+                let content = guardedContent?.response ?? sanitizedContent;
+                if (guardGenerativeSelfInspection) {
+                    content = guardLisaOperationalSelfInspectionReply(content, introspectionTextForTurn);
+                }
+                if (guardedContent?.intervened) {
+                    logger.warn('[agent-executor] relationship safety gate rewrote persisted output', {
+                        issues: guardedContent.issues,
+                    });
+                }
+                // D1: empty provider response (no tools, no length truncation).
+                // Retry is bounded and opt-in via CODEBUDDY_MAX_EMPTY_RETRIES, including
+                // the first turn. Exhaustion throws so the caller and transcript get an
+                // honest failure — never an empty or fabricated assistant message.
+                if (!hasToolCalls && !content.trim() && streamFinishReason !== 'length') {
+                    if (!abortController?.signal.aborted && emptyRetries < maxEmptyRetries) {
+                        emptyRetries++;
+                        logger.warn('[agent-executor] empty provider response, retrying', {
+                            attempt: emptyRetries,
+                            max: maxEmptyRetries,
+                        });
+                        messages.push({
+                            role: 'user',
+                            content: toolRounds > 0
+                                ? 'Your last response was empty. Use the results of the tool calls you just made to continue the task and produce your answer.'
+                                : 'Your last response was empty. Please produce your answer now.',
+                        });
+                        continue;
+                    }
+                    throw new Error('réponse vide du fournisseur');
+                }
+                if ((relationshipSafety || guardGenerativeSelfInspection) &&
+                    content &&
+                    !(synthesizedToolFallback && hasToolCalls)) {
+                    // The outer last-mile gate buffers the complete agent turn. Explicit
+                    // spacing keeps a genuine pre-tool preamble and the final answer from
+                    // being concatenated into one word after per-round trimming.
+                    yield { type: 'content', content: `${content}\n\n` };
+                }
+                const persistedAssistantContent = synthesizedToolFallback
+                    ? null
+                    : content;
                 const assistantEntry = {
                     type: "assistant",
-                    content: content,
+                    content: persistedAssistantContent ?? '',
                     timestamp: new Date(),
                     toolCalls: toolCalls,
                 };
                 history.push(assistantEntry);
-                messages.push({ role: "assistant", content: content, tool_calls: toolCalls });
+                messages.push({
+                    role: 'assistant',
+                    content: persistedAssistantContent,
+                    tool_calls: toolCalls,
+                });
                 const currentOutputTokens = this.deps.streamingHandler.getTokenCount() || 0;
                 totalOutputTokens += currentOutputTokens;
+                // Sum the provider's own counters across rounds: one HTTP completion can
+                // cost several provider calls, exactly like the cost accounting above.
+                const roundProviderUsage = this.deps.streamingHandler.getProviderUsage?.();
+                if (roundProviderUsage) {
+                    providerUsageSeen = true;
+                    providerPromptTokens += roundProviderUsage.promptTokens ?? 0;
+                    providerCompletionTokens += roundProviderUsage.completionTokens ?? 0;
+                }
                 yield { type: "token_count", tokenCount: inputTokens + totalOutputTokens };
+                if (steeringRequestedDuringText && !hasToolCalls) {
+                    const steering = this.deps.messageQueue?.consumeSteeringMessage();
+                    if (steering) {
+                        yield { type: 'steer', steer: { content: steering.content, source: steering.source } };
+                        messages.push({ role: 'user', content: steering.content });
+                        history.push({
+                            type: 'user',
+                            content: steering.content,
+                            timestamp: steering.timestamp,
+                        });
+                        continue;
+                    }
+                }
                 if (toolCalls && toolCalls.length > 0) {
                     toolRounds++;
                     // 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.` };
-                        yield { type: "done" };
-                        return;
-                    }
-                    // Check for steering messages (steer mode: interrupt execution)
-                    const mq = this.deps.messageQueue;
-                    if (mq?.hasSteeringMessage()) {
-                        const steering = mq.consumeSteeringMessage();
-                        if (steering) {
-                            yield { type: "steer", steer: { content: steering.content, source: steering.source } };
-                            // Inject as user message and skip remaining tool calls
-                            messages.push({ role: "user", content: steering.content });
+                        for (const toolCall of toolCalls) {
+                            const toolResult = {
+                                success: false,
+                                error: 'Skipped because the session cost limit was reached before tool execution.',
+                            };
                             history.push({
-                                type: "user",
-                                content: steering.content,
+                                type: 'tool_result',
+                                content: toolResult.error ?? 'Tool skipped',
                                 timestamp: new Date(),
+                                toolCall,
+                                toolResult,
                             });
-                            // Rollback toolRounds since we didn't actually execute any tools
-                            toolRounds--;
-                            continue; // Re-enter loop to get new LLM response
+                            messages.push({
+                                role: 'tool',
+                                content: toolResult.error ?? 'Tool skipped',
+                                tool_call_id: toolCall.id,
+                                name: toolCall.function.name,
+                            });
+                            yield { type: 'tool_result', toolCall, toolResult };
                         }
+                        yield { type: "content", content: `\n\nSession cost limit reached ($${sessionCost.toFixed(2)} / $${sessionCostLimit.toFixed(2)}). Stopping before tool execution.` };
+                        yield { type: "done" };
+                        return;
                     }
-                    // Single-tool mode: only execute first tool call, re-enqueue rest
+                    // Single-tool mode executes only the first call. The remaining calls
+                    // still receive synthetic results below so the provider transcript
+                    // never contains an unresolved assistant tool call.
                     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`);
+                    const deferredToolCalls = this.config.singleToolMode
+                        ? toolCalls.slice(1)
+                        : [];
+                    if (deferredToolCalls.length > 0) {
+                        logger.debug(`Single-tool mode (stream): skipped ${deferredToolCalls.length} extra tool calls`);
                     }
                     if (!this.deps.streamingHandler.hasYieldedToolCalls()) {
-                        yield { type: "tool_calls", toolCalls: streamToolCallsToExecute };
+                        yield {
+                            type: "tool_calls",
+                            toolCalls: relationshipSafety
+                                ? relationshipSafeToolCallsForDisplay(streamToolCallsToExecute)
+                                : streamToolCallsToExecute,
+                        };
                     }
-                    // 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;
+                    const executionBatches = createOrderedToolBatches(streamToolCallsToExecute, (toolCall) => this.isToolParallelizable(toolCall));
+                    toolExecution: for (const batch of executionBatches) {
+                        // Compaction mutates shared transcript state, so keep this preflight
+                        // ordered even when the calls themselves are safe to run together.
+                        for (const toolCall of batch) {
+                            try {
+                                const toolArgs = JSON.parse(toolCall.function.arguments || '{}');
+                                const estimatedTokens = estimateToolResultTokens(toolCall.function.name, toolArgs);
+                                const modelName = this.deps.client.getCurrentModel();
+                                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,
+                                    });
+                                    const compacted = compactTurnMessagesInPlace(this.deps.contextManager, messages, {
+                                        isolatedSharedHost,
+                                    });
+                                    if (compacted)
+                                        incrementalTokenCounter.invalidate();
+                                    inputTokens = incrementalTokenCounter.count(messages);
+                                }
+                            }
+                            catch { /* proactive compaction is non-critical */ }
                         }
-                        // --- 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', {
+                        const outcomes = await executeBoundedInOrder(batch, async (toolCall) => {
+                            const startedAt = Date.now();
+                            if (abortController?.signal.aborted) {
+                                return {
+                                    result: abortedToolResult(startedAt),
+                                    startedAt,
+                                    streamChunks: [],
+                                };
+                            }
+                            if (relationshipSafety &&
+                                (isBlockedRelationshipInteractiveToolCall(toolCall) ||
+                                    unsafeRelationshipOutboundToolCall(toolCall))) {
+                                logger.warn('[agent-executor] relationship safety blocked outbound tool call', {
                                     toolName: toolCall.function.name,
-                                    inputTokens,
-                                    estimatedTokens,
-                                    contextWindow,
                                 });
-                                this.deps.contextManager.prepareMessages(messages);
-                                inputTokens = this.deps.tokenCounter.countMessageTokens(messages);
+                                return {
+                                    blockedContent: 'Relationship safety policy blocked manipulative outbound content.',
+                                    startedAt,
+                                    streamChunks: [],
+                                };
                             }
-                        }
-                        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;
-                        const _streamToolStartMs = Date.now();
-                        const STREAMING_TOOLS = ['bash', 'reason', 'generate_document'];
-                        if (STREAMING_TOOLS.includes(toolCall.function.name)) {
-                            const gen = this.deps.toolHandler.executeToolStreaming(toolCall);
-                            let genResult = await gen.next();
-                            while (!genResult.done) {
-                                // Check abort between stream chunks
-                                if (abortController?.signal.aborted) {
-                                    await gen.return({ success: false, error: 'Aborted' });
-                                    yield { type: "content", content: "\n\n[Operation cancelled by user]" };
-                                    yield { type: "done" };
-                                    return;
-                                }
+                            const streamPreHook = await runPreToolUseHook(process.cwd(), toolCall);
+                            if (!streamPreHook.allowed) {
+                                return {
+                                    blockedContent: streamPreHook.feedback ?? 'Action blocked by PreToolUse hook',
+                                    startedAt,
+                                    streamChunks: [],
+                                };
+                            }
+                            if (abortController?.signal.aborted) {
+                                return {
+                                    result: abortedToolResult(startedAt),
+                                    startedAt,
+                                    streamChunks: [],
+                                };
+                            }
+                            emitFleetToolStarted(toolCall);
+                            const execution = await this.executeToolForBatch(toolCall, turnExecutionExtra, abortController?.signal, startedAt);
+                            return { ...execution, startedAt };
+                        }, (error) => ({
+                            result: {
+                                success: false,
+                                error: `Tool execution failed: ${getErrorMessage(error)}`,
+                            },
+                            startedAt: Date.now(),
+                            streamChunks: [],
+                        }), MAX_PARALLEL_TOOL_CALLS);
+                        // Promise completion order is intentionally ignored. Provider-facing
+                        // results and every observable side effect are replayed by call index.
+                        for (let outcomeIndex = 0; outcomeIndex < batch.length; outcomeIndex++) {
+                            const toolCall = batch[outcomeIndex];
+                            const outcome = outcomes[outcomeIndex];
+                            if (!toolCall || !outcome)
+                                continue;
+                            if (outcome.blockedContent) {
+                                const relationshipBlocked = relationshipSafety &&
+                                    (isBlockedRelationshipInteractiveToolCall(toolCall) ||
+                                        unsafeRelationshipOutboundToolCall(toolCall));
                                 yield {
-                                    type: "tool_stream",
-                                    toolStreamData: {
-                                        toolCallId: toolCall.id,
-                                        toolName: toolCall.function.name,
-                                        delta: genResult.value,
-                                    },
+                                    type: 'content',
+                                    content: relationshipBlocked
+                                        ? `\n${SAFE_RELATIONSHIP_REPAIR}\n`
+                                        : `\n[Hook blocked: ${outcome.blockedContent}]\n`,
                                 };
-                                genResult = await gen.next();
+                                pushBlockedToolMessage(messages, toolCall, outcome.blockedContent);
+                                continue;
                             }
-                            result = genResult.value ?? { success: false, error: 'Tool returned no result' };
-                        }
-                        else {
-                            // 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",
+                            let result = outcome.result ?? {
+                                success: false,
+                                error: 'Tool returned no result',
+                            };
+                            const _streamToolStartMs = outcome.startedAt;
+                            if (!relationshipSafety) {
+                                for (const delta of outcome.streamChunks) {
+                                    yield {
+                                        type: 'tool_stream',
                                         toolStreamData: {
-                                            toolCallId: tc.id,
-                                            toolName: tc.function.name,
-                                            delta: chunk,
+                                            toolCallId: toolCall.id,
+                                            toolName: toolCall.function.name,
+                                            delta,
                                         },
-                                    });
-                                });
-                                // 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());
-                                        }
+                            // Expand the current turn's cached schema after discovery or live
+                            // authoring. Without this, a newly created tool is dispatchable but
+                            // invisible to the model until the next user turn.
+                            if (result.success) {
+                                const data = result.data;
+                                const discoveredNames = toolCall.function.name === 'tool_search' ? data?.names : undefined;
+                                const names = [...new Set([
+                                        ...(Array.isArray(discoveredNames) ? discoveredNames : []),
+                                        ...(Array.isArray(data?.createdTools) ? data.createdTools : []),
+                                    ])];
+                                if (names.length > 0) {
+                                    try {
+                                        const added = await this.deps.toolSelectionStrategy.expandCachedTools(names);
+                                        logger.debug('tool selection expanded after tool result', {
+                                            source: toolCall.function.name,
+                                            names,
+                                            added,
+                                        });
+                                    }
+                                    catch (err) {
+                                        logger.warn('tool selection expansion failed', {
+                                            source: toolCall.function.name,
+                                            error: String(err),
+                                        });
                                     }
                                 }
                             }
-                        }
-                        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) {
-                            yield { type: "content", content: "\n\n[Operation cancelled by user]" };
-                            yield { type: "done" };
-                            return;
-                        }
-                        // Apply semantic truncation if tool output is very large (> 20k chars)
-                        const RAW_OUTPUT_LIMIT = 20_000;
-                        if (result?.output && result.output.length > RAW_OUTPUT_LIMIT) {
-                            const truncResult = semanticTruncate(result.output, { maxChars: RAW_OUTPUT_LIMIT });
-                            if (truncResult.truncated) {
-                                result = {
-                                    ...result,
-                                    output: truncResult.output,
-                                };
+                            // --- 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 _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',
+                                });
                             }
-                        }
-                        // --- Disk-backed tool result (Manus AI #19) ---
-                        const rawStreamContent = sanitizeToolResult(result?.success ? result.output || "Success" : result?.error || "Error");
-                        persistToolResult(toolCall.id, rawStreamContent);
-                        // --- Observation Variator (Manus AI #17) ---
-                        const variedStreamContent = applyObservationVariator(toolCall.function.name, rawStreamContent);
-                        const toolResultEntry = {
-                            type: "tool_result",
-                            content: result?.success ? result.output || "Success" : result?.error || "Error occurred",
-                            timestamp: new Date(),
-                            toolCall: toolCall,
-                            toolResult: result,
-                        };
-                        history.push(toolResultEntry);
-                        yield { type: "tool_result", toolCall, toolResult: result };
-                        // Note: 'name' is required for Gemini API to match functionResponse with functionCall
-                        messages.push({
-                            role: "tool",
-                            content: variedStreamContent,
-                            tool_call_id: toolCall.id || `tool_${Date.now()}`,
-                            name: toolCall.function.name,
-                        });
-                        // --- Auto-commit after file-modifying tools (streaming path) ---
-                        if (result?.success) {
+                            catch { /* notification optional */ }
+                            // Phase (d).21 ship 4 — progress update.
+                            try {
+                                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 { 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 });
+                                const fileToolsStream = new Set(['view_file', 'create_file', 'str_replace_editor', 'file_read', 'file_write']);
+                                if (!isolatedSharedHost && fileToolsStream.has(toolCall.function.name)) {
+                                    const args = JSON.parse(toolCall.function.arguments || '{}');
+                                    const filePath = args.path || args.file_path || args.target_file || '';
+                                    if (filePath) {
+                                        trackRecentFile(filePath);
+                                        if (['create_file', 'str_replace_editor', 'file_write'].includes(toolCall.function.name)) {
+                                            const kg = getKnowledgeGraph();
+                                            if (kg.getStats().tripleCount > 0) {
+                                                const absPath = resolvePath(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.
+                            // The current provider request already consumed preparedMessages.
+                            // Keep newly discovered instructions in turn-local state so the
+                            // next provider round actually receives them without persisting
+                            // them into later user turns.
+                            jitContextBlocks.push(...await runJitContextDiscovery(toolCall));
+                            // Build three deliberately separate views of one observation:
+                            //   1. recovery: exact native output persisted before any hook/optimizer,
+                            //   2. display: provider-sanitized ToolResult emitted to the UI,
+                            //   3. model: token-budgeted observation appended to the transcript.
+                            // Non-streaming ToolHandler calls already persisted (1) before their
+                            // after-hooks. Streaming adapters are persisted here on first sight.
+                            const recoveryStore = getRestorableCompressor();
+                            const toolWorkspace = typeof this.deps.toolHandler.getWorkingDirectory === 'function'
+                                ? this.deps.toolHandler.getWorkingDirectory()
+                                : process.cwd();
+                            const recoverySessionId = typeof this.deps.toolHandler.getRecoverySessionId === 'function'
+                                ? this.deps.toolHandler.getRecoverySessionId()
+                                : undefined;
+                            let rawForRecovery = formatToolResultForRecovery(result);
+                            const executionWasAborted = result.error?.startsWith('aborted by user after ') ?? false;
+                            if (toolCall.id && recoveryStore && !executionWasAborted) {
+                                const existingRecovery = recoveryStore.restore(toolCall.id, toolWorkspace, recoverySessionId);
+                                if (existingRecovery.found) {
+                                    rawForRecovery = existingRecovery.content;
                                 }
-                                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}`);
+                                else {
+                                    recoveryStore.writeToolResult(toolCall.id, rawForRecovery, toolWorkspace, recoverySessionId);
                                 }
                             }
-                            catch (err) {
-                                logger.debug('Auto-commit threw (stream)', { err: err instanceof Error ? err.message : String(err) });
+                            let modelObservation = rawForRecovery;
+                            // TokenJuice remains a lossless first pass for verbose web content.
+                            // It only affects the model view; recovery and display stay intact.
+                            if (isTokenJuiceEnabled() &&
+                                result?.success &&
+                                modelObservation.length > JUICE_MIN_CHARS &&
+                                JUICE_WEB_TOOLS.has(toolCall.function.name)) {
+                                const juiced = tokenJuice(modelObservation, { html: true, dedupe: true });
+                                if (juiced.savedChars > 0) {
+                                    logger.debug(`[token-juice] ${toolCall.function.name}: saved ${juiced.savedChars} chars (${juiced.applied.join('+')})`);
+                                    modelObservation = juiced.output;
+                                }
                             }
-                        }
-                        // --- 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"]
+                            let logicalCommand = '';
+                            try {
+                                const args = JSON.parse(toolCall.function.arguments || '{}');
+                                if (typeof args.command === 'string')
+                                    logicalCommand = args.command;
+                            }
+                            catch { /* malformed args were already handled by the dispatcher */ }
+                            const activeObservationModel = this.deps.client.getCurrentModel() ?? '';
+                            const activeObservationConfig = getModelToolConfig(activeObservationModel);
+                            const optimization = await optimizeToolObservation({
+                                toolName: toolCall.function.name,
+                                toolCallId: toolCall.id || `tool_${Date.now()}`,
+                                content: modelObservation,
+                                success: result?.success,
+                                exitCode: result?.success ? 0 : 1,
+                                command: logicalCommand,
+                                query: message ?? '',
+                                workspaceRoot: toolWorkspace,
+                                contextWindow: activeObservationConfig.contextWindow ?? 128_000,
+                                currentInputTokens: inputTokens,
+                                signal: abortController?.signal,
+                            });
+                            let modelStreamContent = optimization.content;
+                            // lm-resizer owns the semantic budget when available. Its absence or
+                            // an intentionally raw failure still receives a model-aware hard cap;
+                            // the exact observation remains available through restore_context.
+                            if (toolCall.function.name !== 'restore_context') {
+                                const budgetTokens = optimization.tokenBudget ?? 5_000;
+                                const hardLimitChars = Math.min(80_000, Math.max(8_000, budgetTokens * 4));
+                                if (modelStreamContent.length > hardLimitChars ||
+                                    this.deps.tokenCounter.countTokens(modelStreamContent) > budgetTokens) {
+                                    const truncated = semanticTruncate(modelStreamContent, { maxChars: hardLimitChars });
+                                    if (truncated.truncated) {
+                                        const recoveryNote = toolCall.id
+                                            ? `\n\n[Full exact observation: restore_context({"identifier":${JSON.stringify(toolCall.id)}})]`
+                                            : '';
+                                        modelStreamContent = `${truncated.output}${recoveryNote}`;
+                                    }
                                 }
+                            }
+                            const observationMetadata = {
+                                optimizer: optimization.optimized ? 'lm-resizer' : 'none',
+                                reason: optimization.reason,
+                                rawRef: optimization.rawRef,
+                                originalBytes: optimization.originalBytes,
+                                finalBytes: Buffer.byteLength(modelStreamContent),
+                                bytesSaved: Math.max(0, optimization.originalBytes - Buffer.byteLength(modelStreamContent)),
+                                ...(optimization.transport ? { transport: optimization.transport } : {}),
                             };
-                            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"]
-                                }
+                            result = {
+                                ...result,
+                                metadata: {
+                                    ...(result?.metadata ?? {}),
+                                    contextOptimization: observationMetadata,
+                                },
                             };
-                            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);
+                            const rawStreamContent = sanitizeToolResult(rawForRecovery);
+                            const sanitizedModelObservation = sanitizeToolResult(modelStreamContent);
+                            const variedStreamContent = applyObservationVariator(toolCall.function.name, sanitizedModelObservation);
+                            const visibleToolResult = relationshipSafety
+                                ? relationshipSafeToolResultForDisplay(result)
+                                : result;
+                            const toolResultEntry = {
+                                type: "tool_result",
+                                content: visibleToolResult.success
+                                    ? visibleToolResult.output || "Success"
+                                    : visibleToolResult.error || "Error occurred",
+                                timestamp: new Date(),
+                                toolCall: toolCall,
+                                toolResult: visibleToolResult,
+                            };
+                            history.push(toolResultEntry);
+                            yield { type: "tool_result", toolCall, toolResult: visibleToolResult };
+                            // Note: 'name' is required for Gemini API to match functionResponse with functionCall
+                            messages.push({
+                                role: "tool",
+                                content: variedStreamContent,
+                                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 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 toolExecution;
+                            }
+                            // --- 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 toolExecution;
+                            }
+                            // --- 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 toolExecution;
+                            }
+                            // --- 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);
+                            }
                         }
                     }
+                    for (const toolCall of deferredToolCalls) {
+                        const toolResult = {
+                            success: false,
+                            error: 'Skipped because single-tool mode executes one call per round.',
+                        };
+                        history.push({
+                            type: 'tool_result',
+                            content: toolResult.error ?? 'Tool skipped',
+                            timestamp: new Date(),
+                            toolCall,
+                            toolResult,
+                        });
+                        messages.push({
+                            role: 'tool',
+                            content: toolResult.error ?? 'Tool skipped',
+                            tool_call_id: toolCall.id,
+                            name: toolCall.function.name,
+                        });
+                        yield { type: 'tool_result', toolCall, toolResult };
+                    }
                     if (terminateDetectedStreaming)
                         break;
-                    inputTokens = this.deps.tokenCounter.countMessageTokens(messages);
+                    if (abortController?.signal.aborted) {
+                        yield { type: "content", content: "\n\n[Operation cancelled by user]" };
+                        yield { type: "done" };
+                        return;
+                    }
+                    // Tool-call/result pairs are complete at this boundary, so a steer
+                    // that arrived while tools were running can now be injected safely.
+                    const deferredSteering = this.deps.messageQueue?.hasSteeringMessage()
+                        ? this.deps.messageQueue.consumeSteeringMessage()
+                        : null;
+                    if (deferredSteering) {
+                        yield {
+                            type: 'steer',
+                            steer: { content: deferredSteering.content, source: deferredSteering.source },
+                        };
+                        messages.push({ role: 'user', content: deferredSteering.content });
+                        history.push({
+                            type: 'user',
+                            content: deferredSteering.content,
+                            timestamp: deferredSteering.timestamp,
+                        });
+                        continue;
+                    }
+                    inputTokens = incrementalTokenCounter.count(messages);
                     yield { type: "token_count", tokenCount: inputTokens + totalOutputTokens };
                     // Run after_turn middleware (handles cost recording + limit)
                     if (pipeline) {
@@ -999,10 +1887,10 @@ export class AgentExecutor {
                     // 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);
+                        incrementalTokenCounter.invalidate();
                     }
                     catch { /* masking is optional */ }
                 }
@@ -1033,64 +1921,48 @@ export class AgentExecutor {
                             });
                             continue;
                         }
-                        // (2) Post-tool empty response: the model went silent after running
-                        // tools. Nudge it to use the results and continue, bounded.
-                        if (streamedContentRaw.length === 0 &&
-                            streamFinishReason !== 'length' &&
-                            toolRounds > 0 &&
-                            emptyRetries < maxEmptyRetries) {
-                            emptyRetries++;
-                            logger.debug('[agent-executor] empty-response re-prompt', {
-                                attempt: emptyRetries,
-                                max: maxEmptyRetries,
-                            });
-                            messages.push({
-                                role: 'user',
-                                content: 'Your last response was empty. Use the results of the tool calls you just made ' +
-                                    'to continue the task and produce your answer.',
+                        if (streamFinishReason === 'length') {
+                            assistantEntry.truncated = true;
+                            const notice = lengthContinuations > 0
+                                ? `Réponse tronquée après ${lengthContinuations} continuation(s) (limite de longueur atteinte).`
+                                : 'Réponse tronquée (limite de longueur atteinte).';
+                            logger.warn('[agent-executor] length-truncated response', {
+                                continuations: lengthContinuations,
+                                max: maxLengthContinuations,
                             });
-                            continue;
-                        }
-                    }
-                    // 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) }));
+                            assistantEntry.content = assistantEntry.content
+                                ? `${assistantEntry.content}\n\n${notice}`
+                                : notice;
+                            const lastMessage = messages[messages.length - 1];
+                            if (lastMessage?.role === 'assistant') {
+                                lastMessage.content = assistantEntry.content;
                             }
+                            yield { type: 'content', content: `\n${notice}\n` };
+                            break;
                         }
-                        catch { /* ICM store optional */ }
+                        // Post-tool empty responses are handled before persist (D1) so an
+                        // empty assistant message is never written to the transcript.
                     }
-                    // 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 || '' });
-                        }
+                    // Companion hosts own the canonical commit boundary: voice,
+                    // channel and Cowork persist only relationship-safe, semantically
+                    // accepted text in their surface continuity/session stores. Generic
+                    // core observers (AutoCapture, ICM and plugin ContextEngine hooks)
+                    // are deliberately not replayed for these protected turns: their
+                    // storage/privacy contracts are independent and must never receive a
+                    // pre-gate draft or intimate cross-surface transcript by accident.
+                    if (!isolatedSharedHost && !relationshipSafety) {
+                        this.commitAssistantSideEffects(message, messages, content || '', toolRounds);
                     }
-                    catch { /* afterTurn hook optional */ }
                     break;
                 }
             }
-            if (toolRounds >= maxToolRounds) {
-                yield { type: "content", content: "\n\nMaximum tool execution rounds reached." };
+            if (toolRounds >= maxToolRounds && !terminateDetectedStreaming) {
+                const limitMessage = 'Maximum tool execution rounds reached.';
+                history.push({ type: 'assistant', content: limitMessage, timestamp: new Date() });
+                messages.push({ role: 'assistant', content: limitMessage });
+                yield { type: 'content', content: `\n\n${limitMessage}` };
             }
-            this.config.recordSessionCost(inputTokens, totalOutputTokens);
+            recordTurnCost();
             // 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.
@@ -1098,8 +1970,12 @@ export class AgentExecutor {
             // 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 });
+                : estimateCost(totalInputTokensForCost, totalOutputTokens, undefined, undefined, this.deps.client.getCurrentModel());
+            const streamUsageDisplay = formatTokenUsage({
+                inputTokens: totalInputTokensForCost,
+                outputTokens: totalOutputTokens,
+                cost: streamTurnCost,
+            });
             logger.info(`Token usage: ${streamUsageDisplay}`);
             yield { type: "content", content: `\n${streamUsageDisplay}` };
             if (this.config.isSessionCostLimitReached()) {
@@ -1141,6 +2017,10 @@ export class AgentExecutor {
                 return;
             }
             const errorMessage = getErrorMessage(error);
+            logger.error('Agent turn failed', {
+                errorType: error instanceof Error ? error.name : 'unknown',
+                error: errorMessage.slice(0, 2_000),
+            });
             const errorEntry = {
                 type: "assistant",
                 content: `Sorry, I encountered an error: ${errorMessage}`,
@@ -1151,6 +2031,99 @@ export class AgentExecutor {
             yield { type: "content", content: errorEntry.content };
             yield { type: "done" };
         }
+        finally {
+            recordTurnCost();
+            if (timelineEnabled) {
+                await this.recordCompletedTimelineTurn(timelineHistoryStart, timelineTurn, history, message);
+            }
+        }
+    }
+    async recordCompletedTimelineTurn(historyStart, turn, history, userMessage) {
+        if (!this.deps.recordTimelineTurn)
+            return;
+        try {
+            const turnHistory = history.slice(historyStart);
+            const assistant = [...turnHistory]
+                .reverse()
+                .find((entry) => entry.type === 'assistant');
+            const results = new Map();
+            for (const entry of turnHistory) {
+                if (entry.type !== 'tool_result' || !entry.toolCall)
+                    continue;
+                results.set(entry.toolCall.id, entry.toolResult?.success === true);
+            }
+            const toolCalls = [];
+            const seenCalls = new Set();
+            for (const entry of turnHistory) {
+                const calls = entry.toolCalls ?? (entry.toolCall ? [entry.toolCall] : []);
+                for (const call of calls) {
+                    const key = call.id || `${call.function.name}:${call.function.arguments}`;
+                    if (seenCalls.has(key))
+                        continue;
+                    seenCalls.add(key);
+                    toolCalls.push({
+                        name: call.function.name,
+                        ok: results.get(call.id) ?? false,
+                    });
+                }
+            }
+            const successfulCallIds = new Set([...results.entries()]
+                .filter(([, success]) => success)
+                .map(([callId]) => callId));
+            const successfulHistory = turnHistory.map((entry) => ({
+                ...entry,
+                ...(entry.toolCalls
+                    ? { toolCalls: entry.toolCalls.filter((call) => successfulCallIds.has(call.id)) }
+                    : {}),
+                ...(entry.toolCall && !successfulCallIds.has(entry.toolCall.id)
+                    ? { toolCall: undefined }
+                    : {}),
+            }));
+            await this.deps.recordTimelineTurn({
+                turn,
+                ts: new Date().toISOString(),
+                role: assistant ? 'assistant' : 'user',
+                text: assistant?.content ?? userMessage,
+                toolCalls,
+                filesTouched: extractEditedFilesFromHistory(successfulHistory),
+            });
+        }
+        catch (error) {
+            logger.warn('[agent-executor] timeline hook failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /** Notify internal memory/context observers for an ordinary committed turn. */
+    commitAssistantSideEffects(message, messages, content, toolRounds = 0) {
+        try {
+            void import('../../memory/auto-capture.js').then(({ getAutoCaptureManager }) => {
+                const acm = getAutoCaptureManager();
+                return acm?.processMessage('assistant', content);
+            }).catch(err => logger.debug('Auto-capture failed', { error: String(err) }));
+        }
+        catch { /* auto-capture optional */ }
+        if (this.getICMBridgeProvider()) {
+            try {
+                const icm = this.getICMBridgeProvider()();
+                if (icm?.isAvailable()) {
+                    const episode = `User: ${message}\nAssistant: ${content.substring(0, 500)}`;
+                    void 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 */ }
+        }
+        try {
+            const engine = this.deps.contextManager.getContextEngine?.();
+            if (engine) {
+                engine.afterTurn(messages, { role: 'assistant', content });
+            }
+        }
+        catch { /* afterTurn hook optional */ }
     }
 }
 //# sourceMappingURL=agent-executor.js.map