@qduc/term2 0.6.1 → 0.7.0

package/dist/services/conversation-session.js

@@ -9,11 +9,65 @@ import { ShellAutoApprovalResolver } from './shell-auto-approval-resolver.js';
 import { ApprovalFlowCoordinator } from './approval-flow-coordinator.js';
 import { buildConversationResult, toTerminalEvent } from './conversation-result-builder.js';
 import { normalizeUserTurn } from '../types/user-turn.js';
-import { InputSurgeGuard } from './input-surge-guard.js';
+import { collectDuplicateToolCallResultPairs, InputSurgeGuard } from './input-surge-guard.js';
+import { LargeUncachedInputGuard } from './large-uncached-input-guard.js';
+import { reconcileHistoryWithToolLedger, ToolExecutionLedger, } from './tool-execution-ledger.js';
+import { describeError } from '../utils/error-helpers.js';
+const asRecordLocal = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+const rawItemLocal = (item) => {
+    const rec = asRecordLocal(item);
+    if (!rec)
+        return null;
+    return asRecordLocal(rec.rawItem) ?? rec;
+};
+const callIdOfLocal = (item) => {
+    const raw = rawItemLocal(item);
+    const cid = raw?.callId ?? raw?.call_id ?? raw?.tool_call_id ?? raw?.toolCallId ?? raw?.id;
+    return typeof cid === 'string' && cid ? cid : null;
+};
+const toolNameOfLocal = (item) => {
+    const raw = rawItemLocal(item);
+    const name = raw?.name ?? asRecordLocal(item)?.name;
+    return typeof name === 'string' && name ? name : 'unknown';
+};
+const outputOfLocal = (item) => {
+    const raw = rawItemLocal(item);
+    return raw?.output ?? asRecordLocal(item)?.output;
+};
 const supportsConversationChaining = (providerId) => {
     const providerDef = getProvider(providerId);
     return providerDef?.capabilities?.supportsConversationChaining ?? false;
 };
+const asArray = (value) => (Array.isArray(value) ? value : []);
+const warnIfStreamHistoryReplayedTools = ({ logger, sessionId, source, stream, }) => {
+    const streamRecord = stream;
+    const history = asArray(streamRecord.history);
+    const newItems = asArray(streamRecord.newItems);
+    const stateGeneratedItems = asArray(streamRecord.state?._generatedItems);
+    const historyDuplicates = collectDuplicateToolCallResultPairs(history);
+    const newItemsDuplicates = collectDuplicateToolCallResultPairs(newItems);
+    const stateGeneratedItemsDuplicates = collectDuplicateToolCallResultPairs(stateGeneratedItems);
+    if (historyDuplicates.pairs === 0 && newItemsDuplicates.pairs === 0 && stateGeneratedItemsDuplicates.pairs === 0) {
+        return;
+    }
+    logger.warn('Completed stream history contains replayed tool call/result pairs', {
+        eventType: 'conversation.stream_history.replayed_tools',
+        category: 'provider',
+        phase: 'post_stream',
+        sessionId,
+        traceId: logger.getCorrelationId(),
+        source,
+        historyLength: history.length,
+        newItemsLength: newItems.length,
+        stateGeneratedItemsLength: stateGeneratedItems.length,
+        historyDuplicatePairs: historyDuplicates.pairs,
+        historyMaxCopies: historyDuplicates.maxCopies,
+        newItemsDuplicatePairs: newItemsDuplicates.pairs,
+        newItemsMaxCopies: newItemsDuplicates.maxCopies,
+        stateGeneratedItemsDuplicatePairs: stateGeneratedItemsDuplicates.pairs,
+        stateGeneratedItemsMaxCopies: stateGeneratedItemsDuplicates.maxCopies,
+    });
+};
 export class ConversationSession {
     id;
     startedAt;
@@ -24,12 +78,16 @@ export class ConversationSession {
     approvalState = new ApprovalState();
     toolCallArgumentsById = new Map();
     emittedInvalidToolCallPackets = new Set();
+    emittedToolStartedCallIds = new Set();
     shellAutoApproval;
     approvalFlow;
     inputSurgeGuard = new InputSurgeGuard();
+    largeUncachedInputGuard = new LargeUncachedInputGuard();
+    toolLedger = new ToolExecutionLedger();
     generation = 0;
     settingsService;
     pendingModeNotice = null;
+    logSink = null;
     constructor(id, { agentClient, deps, sessionStartedAt, }) {
         this.id = id;
         this.startedAt = sessionStartedAt ?? new Date().toISOString();
@@ -63,6 +121,78 @@ export class ConversationSession {
             return 'mentor';
         return 'standard';
     }
+    #getModelForGuard() {
+        return this.settingsService?.get('agent.model') ?? null;
+    }
+    #getReasoningEffortForGuard() {
+        return this.settingsService?.get('agent.reasoningEffort') ?? null;
+    }
+    #getProviderForGuard() {
+        const getProvider = getMethod(this.agentClient, 'getProvider');
+        return getProvider
+            ? getProvider.call(this.agentClient)
+            : this.settingsService?.get('agent.provider') ?? null;
+    }
+    #makeUserInputItem(turn) {
+        const images = turn.images ?? [];
+        if (images.length === 0) {
+            return { role: 'user', type: 'message', content: turn.text ?? '' };
+        }
+        const content = [];
+        if (turn.text) {
+            content.push({ type: 'input_text', text: turn.text });
+        }
+        for (const image of images) {
+            content.push({
+                type: 'input_image',
+                image: `data:${image.mimeType};base64,${image.data}`,
+                detail: 'auto',
+            });
+        }
+        return { role: 'user', type: 'message', content };
+    }
+    #buildOutgoingInput(turn, { includeTurn }) {
+        const provider = this.#getProviderForGuard() ?? 'openai';
+        const supportsChaining = supportsConversationChaining(provider);
+        const history = this.conversationStore.getHistory();
+        const outgoingHistory = includeTurn ? [...history, this.#makeUserInputItem(turn)] : history;
+        const useChaining = supportsChaining && (!!this.previousResponseId || outgoingHistory.length <= 1);
+        const notice = this.pendingModeNotice;
+        const latestInput = outgoingHistory[outgoingHistory.length - 1] ?? turn.text;
+        const chainedInput = turn.images?.length ? latestInput : turn.text;
+        if (notice) {
+            if (useChaining) {
+                const userItem = typeof chainedInput === 'string' ? { role: 'user', type: 'message', content: chainedInput } : chainedInput;
+                const noticeItem = { role: 'system', type: 'message', content: notice };
+                return {
+                    streamInput: [noticeItem, userItem],
+                    inputSurgeKind: 'delta',
+                };
+            }
+            const noticeItem = { role: 'user', type: 'message', content: notice };
+            return {
+                streamInput: [...outgoingHistory, noticeItem],
+                inputSurgeKind: 'full_history',
+                modeNoticeToPersist: notice,
+            };
+        }
+        return {
+            streamInput: useChaining ? (typeof chainedInput === 'string' ? chainedInput : [chainedInput]) : outgoingHistory,
+            inputSurgeKind: useChaining ? 'delta' : 'full_history',
+        };
+    }
+    previewLargeUncachedInput(input, now = Date.now()) {
+        const turn = normalizeUserTurn(input);
+        const { streamInput } = this.#buildOutgoingInput(turn, { includeTurn: true });
+        return this.largeUncachedInputGuard.inspect({
+            input: streamInput,
+            now,
+            provider: this.#getProviderForGuard(),
+            model: this.#getModelForGuard(),
+            reasoningEffort: this.#getReasoningEffortForGuard(),
+            mode: this.#getTrafficMode(),
+        });
+    }
     #getFirstUserMessagePreview(currentTurn) {
         const [firstTurn] = this.conversationStore.listUserTurns();
         return firstTurn?.text ?? currentTurn ?? '';
@@ -89,8 +219,11 @@ export class ConversationSession {
         this.approvalState.clearPending();
         this.approvalState.consumeAborted();
         this.toolCallArgumentsById.clear();
+        this.emittedToolStartedCallIds.clear();
+        this.toolLedger = new ToolExecutionLedger();
         this.shellAutoApproval.clearCache();
         this.inputSurgeGuard.reset();
+        this.largeUncachedInputGuard.reset();
         const clearConversations = getMethod(this.agentClient, 'clearConversations');
         clearConversations?.call(this.agentClient);
     }
@@ -103,8 +236,11 @@ export class ConversationSession {
         this.approvalState.clearPending();
         this.approvalState.consumeAborted();
         this.toolCallArgumentsById.clear();
+        this.emittedToolStartedCallIds.clear();
         this.shellAutoApproval.clearCache();
         this.inputSurgeGuard.reset();
+        this.largeUncachedInputGuard.markUndoOrRewind();
+        this.#log({ type: 'undo', removedUserTurns: 1, snapshot: this.getCurrentSnapshot() });
         return removed;
     }
     listUserTurns() {
@@ -119,8 +255,11 @@ export class ConversationSession {
         this.approvalState.clearPending();
         this.approvalState.consumeAborted();
         this.toolCallArgumentsById.clear();
+        this.emittedToolStartedCallIds.clear();
         this.shellAutoApproval.clearCache();
         this.inputSurgeGuard.reset();
+        this.largeUncachedInputGuard.markUndoOrRewind();
+        this.#log({ type: 'undo', removedUserTurns: n, snapshot: this.getCurrentSnapshot() });
         return removed;
     }
     setModel(model) {
@@ -135,27 +274,160 @@ export class ConversationSession {
         setTemperature?.call(this.agentClient, temperature);
     }
     setProvider(provider) {
+        this.generation++;
+        this.previousResponseId = null;
+        this.approvalState.clearPending();
+        this.approvalState.consumeAborted();
+        this.toolCallArgumentsById.clear();
+        this.emittedToolStartedCallIds.clear();
+        this.shellAutoApproval.clearCache();
+        this.inputSurgeGuard.reset();
+        const clearConversations = getMethod(this.agentClient, 'clearConversations');
+        clearConversations?.call(this.agentClient);
         const setProvider = getMethod(this.agentClient, 'setProvider');
         setProvider?.call(this.agentClient, provider);
     }
+    switchProvider(provider) {
+        this.setProvider(provider);
+    }
     setRetryCallback(callback) {
         if (typeof this.agentClient.setRetryCallback === 'function') {
             this.agentClient.setRetryCallback(callback);
         }
     }
+    setLogSink(sink) {
+        this.logSink = sink;
+    }
+    getCurrentSnapshot() {
+        const getProvider = getMethod(this.agentClient, 'getProvider');
+        const provider = getProvider
+            ? getProvider.call(this.agentClient)
+            : this.settingsService?.get('agent.provider');
+        const model = this.settingsService?.get('agent.model');
+        return {
+            history: this.conversationStore.getHistory(),
+            previousResponseId: this.previousResponseId,
+            toolLedger: this.toolLedger.export(),
+            ...(model ? { model } : {}),
+            ...(provider ? { provider } : {}),
+        };
+    }
+    #log(event) {
+        if (!this.logSink)
+            return;
+        try {
+            this.logSink(event);
+        }
+        catch (err) {
+            this.logger.warn('Conversation log sink threw', {
+                eventType: 'conversation_log.sink_failed',
+                category: 'persistence',
+                errorMessage: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    #dispatchEventToLog(event) {
+        if (!this.logSink)
+            return;
+        switch (event.type) {
+            case 'tool_started':
+                this.#log({
+                    type: 'tool_started',
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    arguments: event.arguments,
+                });
+                return;
+            case 'command_message':
+                this.#log({ type: 'command_message', message: event.message });
+                return;
+            case 'approval_required':
+                this.#log({
+                    type: 'approval_required',
+                    approval: {
+                        toolName: event.approval.toolName,
+                        argumentsText: event.approval.argumentsText,
+                        agentName: event.approval.agentName,
+                        ...('callId' in event.approval && event.approval.callId ? { callId: event.approval.callId } : {}),
+                    },
+                });
+                return;
+            case 'subagent_started':
+                this.#log({
+                    type: 'subagent_started',
+                    agentId: event.agentId,
+                    role: event.role,
+                    task: event.task,
+                });
+                return;
+            case 'subagent_completed':
+                this.#log({ type: 'subagent_completed', result: event.result });
+                return;
+            case 'error':
+                this.#log({ type: 'error', message: event.message, ...(event.kind ? { kind: event.kind } : {}) });
+                return;
+            case 'final': {
+                const snapshot = this.getCurrentSnapshot();
+                this.#log({
+                    type: 'assistant_final',
+                    message: {
+                        id: `bot-${snapshot.history.length}-${Date.now()}`,
+                        sender: 'bot',
+                        status: 'finalized',
+                        text: event.finalText,
+                        ...(event.reasoningText ? { reasoningText: event.reasoningText } : {}),
+                    },
+                    finalText: event.finalText,
+                    ...(event.reasoningText ? { reasoningText: event.reasoningText } : {}),
+                    ...(event.usage ? { usage: event.usage } : {}),
+                    snapshot,
+                });
+                return;
+            }
+            default:
+                return;
+        }
+    }
+    #dedupeToolStarted(event) {
+        if (event.type !== 'tool_started') {
+            return event;
+        }
+        if (this.emittedToolStartedCallIds.has(event.toolCallId)) {
+            return null;
+        }
+        this.emittedToolStartedCallIds.add(event.toolCallId);
+        return event;
+    }
     exportState() {
         return {
             history: this.conversationStore.getHistory(),
             previousResponseId: this.previousResponseId,
+            toolLedger: this.toolLedger.export(),
         };
     }
     importState(state) {
         this.conversationStore.clear();
-        for (const item of state.history) {
+        this.toolLedger.import(state.toolLedger);
+        const reconciled = reconcileHistoryWithToolLedger(state.history, state.toolLedger);
+        if (reconciled.addedCompletedPairs > 0 || reconciled.droppedIncompleteCalls > 0) {
+            this.logger.warn('Reconciled saved conversation history with tool execution ledger', {
+                eventType: 'conversation.tool_ledger.reconciled',
+                category: 'conversation',
+                phase: 'resume',
+                sessionId: this.id,
+                addedCompletedPairs: reconciled.addedCompletedPairs,
+                droppedIncompleteCalls: reconciled.droppedIncompleteCalls,
+            });
+        }
+        for (const item of reconciled.history) {
             this.conversationStore.addImportedItem(item);
         }
         this.previousResponseId = state.previousResponseId;
+        this.emittedToolStartedCallIds.clear();
         this.inputSurgeGuard.reset();
+        this.largeUncachedInputGuard.markResumedSession({
+            updatedAtMs: state.updatedAt ? Date.parse(state.updatedAt) : null,
+        });
         this.generation++;
     }
     addShellContext(historyText) {
@@ -181,6 +453,8 @@ export class ConversationSession {
         const turn = normalizeUserTurn(input);
         const text = turn.text;
         let addedUserMessage = false;
+        const ledgerSnapshot = this.toolLedger.export();
+        this.toolLedger.beginTurn();
         try {
             this.logger.debug('Conversation stream start', {
                 eventType: 'stream.started',
@@ -196,6 +470,12 @@ export class ConversationSession {
                 this.conversationStore.addUserTurn(turn);
                 addedUserMessage = true;
             }
+            else if (abortedContext && !skipUserMessage) {
+                // The UI appended a user message for this input, but the store will consume it
+                // as fake tool output for the aborted approval rather than as a new user turn.
+                // Signal the UI to mark it so /undo skips it.
+                yield { type: 'user_message_consumed_for_abort' };
+            }
             // If there's an aborted approval, we need to resolve it first.
             // The user's message is a new input, but the agent is stuck waiting for tool output.
             if (abortedContext) {
@@ -213,16 +493,43 @@ export class ConversationSession {
                 try {
                     const continuedStream = (await this.agentClient.continueRunStream(abortedContext.state, {
                         previousResponseId: this.previousResponseId,
+                        sessionId: this.id,
                     }));
                     const acc = createStreamAccumulator();
                     acc.emittedCommandIds = new Set(abortedContext.emittedCommandIds);
-                    yield* processStreamEvents(continuedStream, acc, {
+                    for await (const event of processStreamEvents(continuedStream, acc, {
                         toolCallArgumentsById: this.toolCallArgumentsById,
                         emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                         preserveExistingToolArgs: true,
-                    }, { logger: this.logger, sessionId: this.id });
+                        onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
+                        onFunctionResultItem: (item) => {
+                            this.toolLedger.recordFunctionResult(item);
+                            const cid = callIdOfLocal(item);
+                            if (cid && this.logSink) {
+                                const entry = this.toolLedger.export().find((e) => e.callId === cid);
+                                this.#log({
+                                    type: 'tool_result',
+                                    callId: cid,
+                                    toolName: entry?.toolName ?? toolNameOfLocal(item),
+                                    status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
+                                    output: entry?.output ?? outputOfLocal(item),
+                                    ...(entry?.historyItems ? { historyItems: entry.historyItems } : {}),
+                                });
+                            }
+                        },
+                    }, { logger: this.logger, sessionId: this.id })) {
+                        const filtered = this.#dedupeToolStarted(event);
+                        if (filtered)
+                            yield filtered;
+                    }
                     if (this.#isCurrentGeneration(gen)) {
                         this.previousResponseId = continuedStream.lastResponseId ?? null;
+                        warnIfStreamHistoryReplayedTools({
+                            logger: this.logger,
+                            sessionId: this.id,
+                            source: 'abortResolution',
+                            stream: continuedStream,
+                        });
                         this.conversationStore.updateFromResult(continuedStream);
                     }
                     // Check if another interruption occurred
@@ -251,49 +558,33 @@ export class ConversationSession {
                 }
             }
             // Normal message flow
-            const getProvider = getMethod(this.agentClient, 'getProvider');
-            const provider = getProvider ? getProvider.call(this.agentClient) : 'openai';
-            const supportsChaining = supportsConversationChaining(provider);
-            const history = this.conversationStore.getHistory();
             // Use chaining mode only when the provider supports it AND either a valid
             // chain exists (previousResponseId is set) or there is no prior history to
             // resync (fresh start with just the current message). After undo the chain
             // is severed (previousResponseId = null) while prior turns remain in the
             // local store, so we fall back to full-history mode to re-establish context.
-            const useChaining = supportsChaining && (!!this.previousResponseId || history.length <= 1);
-            let streamInput;
+            const { streamInput, inputSurgeKind, modeNoticeToPersist } = this.#buildOutgoingInput(turn, {
+                includeTurn: false,
+            });
             if (this.pendingModeNotice) {
-                const notice = this.pendingModeNotice;
                 this.pendingModeNotice = null;
-                if (useChaining) {
-                    const latestInput = history[history.length - 1] ?? text;
-                    const chainedInput = turn.images?.length ? latestInput : text;
-                    const userItem = typeof chainedInput === 'string' ? { role: 'user', type: 'message', content: chainedInput } : chainedInput;
-                    const noticeItem = { role: 'system', type: 'message', content: notice };
-                    streamInput = [noticeItem, userItem];
-                }
-                else {
-                    // Persist the notice at the tail (append-only) rather than splicing
-                    // it before the last user turn or sending it as a one-shot item.
-                    // Mid-history insertion adds a stray ephemeral cache breakpoint (see
-                    // addCacheControlToLastTwoMessages) and a transient item makes
-                    // consecutive requests diverge at the tail — both break the
-                    // Claude/Qwen prompt cache. Appending keeps the cached prefix
-                    // byte-identical and only growing.
-                    this.conversationStore.addModeNotice(notice);
-                    streamInput = this.conversationStore.getHistory();
-                }
             }
-            else {
-                const latestInput = history[history.length - 1] ?? text;
-                const chainedInput = turn.images?.length ? latestInput : text;
-                streamInput = useChaining ? (typeof chainedInput === 'string' ? chainedInput : [chainedInput]) : history;
+            if (modeNoticeToPersist) {
+                // Persist the notice at the tail (append-only) rather than splicing
+                // it before the last user turn or sending it as a one-shot item.
+                // Mid-history insertion adds a stray ephemeral cache breakpoint (see
+                // addCacheControlToLastTwoMessages) and a transient item makes
+                // consecutive requests diverge at the tail — both break the
+                // Claude/Qwen prompt cache. Appending keeps the cached prefix
+                // byte-identical and only growing.
+                this.conversationStore.addModeNotice(modeNoticeToPersist);
             }
-            const inputSurgeKind = useChaining ? 'delta' : 'full_history';
             const surgeDecision = this.inputSurgeGuard.inspect(streamInput, { kind: inputSurgeKind });
             if (surgeDecision.action === 'block') {
+                let droppedUserMessage;
                 if (addedUserMessage && this.#isCurrentGeneration(gen)) {
                     this.conversationStore.removeLastUserMessage();
+                    droppedUserMessage = { text: turn.text, imageCount: turn.images?.length ?? 0 };
                 }
                 this.logger.warn('Input surge guard blocked provider request', {
                     eventType: 'input_surge.blocked',
@@ -309,24 +600,38 @@ export class ConversationSession {
                     type: 'error',
                     kind: 'input_surge_guard',
                     message: `${surgeDecision.reason} Request blocked to prevent runaway context growth. Try /undo or /clear, or compact the conversation history.`,
+                    ...(droppedUserMessage ? { droppedUserMessage } : {}),
                 };
                 return;
             }
             stream = (await this.agentClient.startStream(streamInput, {
-                previousResponseId: this.previousResponseId,
+                previousResponseId: inputSurgeKind === 'delta' ? this.previousResponseId : null,
+                sessionId: this.id,
             }));
             const acc = createStreamAccumulator();
-            yield* processStreamEvents(stream, acc, {
+            for await (const event of processStreamEvents(stream, acc, {
                 toolCallArgumentsById: this.toolCallArgumentsById,
                 emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                 preserveExistingToolArgs: false,
-            }, { logger: this.logger, sessionId: this.id });
+                onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
+                onFunctionResultItem: (item) => this.toolLedger.recordFunctionResult(item),
+            }, { logger: this.logger, sessionId: this.id })) {
+                const filtered = this.#dedupeToolStarted(event);
+                if (filtered)
+                    yield filtered;
+            }
             if (this.#isCurrentGeneration(gen)) {
                 this.previousResponseId = stream.lastResponseId ?? null;
+                warnIfStreamHistoryReplayedTools({
+                    logger: this.logger,
+                    sessionId: this.id,
+                    source: 'startStream',
+                    stream,
+                });
                 this.conversationStore.updateFromResult(stream);
             }
             const resolvedResult = yield* this.#buildAndResolve(stream, acc.finalOutput || undefined, acc.reasoningOutput || undefined, acc.emittedCommandIds, acc.latestUsage);
-            if (useChaining) {
+            if (inputSurgeKind === 'delta') {
                 this.inputSurgeGuard.recordSuccessfulInput(streamInput, { kind: inputSurgeKind });
             }
             else {
@@ -335,6 +640,14 @@ export class ConversationSession {
                     previousInput: streamInput,
                 });
             }
+            this.largeUncachedInputGuard.recordSuccessfulInput({
+                input: inputSurgeKind === 'delta' ? streamInput : this.conversationStore.getHistory(),
+                now: Date.now(),
+                provider: this.#getProviderForGuard(),
+                model: this.#getModelForGuard(),
+                reasoningEffort: this.#getReasoningEffortForGuard(),
+                mode: this.#getTrafficMode(),
+            });
             if (resolvedResult.type === 'approval_required') {
                 this.logger.debug('Tool approval required', {
                     eventType: 'approval.required',
@@ -374,6 +687,7 @@ export class ConversationSession {
                     retryType: 'flex_service_tier',
                 };
                 getMethod(this.agentClient, 'useStandardServiceTierForNextRequest')?.call(this.agentClient);
+                this.toolLedger.import(ledgerSnapshot);
                 yield* this.run(turn, {
                     skipUserMessage: true,
                     flexServiceTierFallbackCount: flexServiceTierFallbackCount + 1,
@@ -399,6 +713,7 @@ export class ConversationSession {
                 if (!this.#isCurrentGeneration(gen))
                     return;
                 if (decision.hadStream && stream) {
+                    this.toolLedger.import(ledgerSnapshot);
                     if (decision.shouldInjectErrorContext) {
                         this.conversationStore.addErrorContext(decision.errorContextMessage);
                     }
@@ -409,20 +724,38 @@ export class ConversationSession {
                 yield* this.run(turn, decision.nextRunOptions);
                 return;
             }
-            yield {
-                type: 'error',
-                message: error instanceof Error ? error.message : String(error),
-            };
+            // Drop the just-added user turn from the store before yielding so the
+            // generator-cleanup path doesn't strand the removal — and so the error
+            // event can carry the dropped text for UI restoration.
+            let droppedUserMessage;
             if (addedUserMessage && !stream && this.#isCurrentGeneration(gen)) {
                 this.conversationStore.removeLastUserMessage();
+                droppedUserMessage = { text: turn.text, imageCount: turn.images?.length ?? 0 };
+            }
+            if (stream && this.#isCurrentGeneration(gen)) {
+                this.toolLedger.markOpenCallsAborted(error instanceof Error ? error.message : String(error));
+                const recoverySummary = this.toolLedger.getRecoverySummary();
+                if (recoverySummary) {
+                    yield {
+                        type: 'tool_recovery',
+                        recoveredCallIds: recoverySummary.recoveredCallIds,
+                        droppedCallIds: recoverySummary.droppedCallIds,
+                        message: recoverySummary.message,
+                    };
+                }
             }
+            yield {
+                type: 'error',
+                message: describeError(error),
+                ...(droppedUserMessage ? { droppedUserMessage } : {}),
+            };
             this.logger.error('Conversation stream error', {
                 eventType: 'stream.failed',
                 category: 'stream',
                 phase: 'abort',
                 sessionId: this.id,
                 traceId: this.logger.getCorrelationId(),
-                errorMessage: error instanceof Error ? error.message : String(error),
+                errorMessage: describeError(error),
             });
             throw error;
         }
@@ -440,7 +773,9 @@ export class ConversationSession {
         }
         const { pendingApprovalContext: { state, toolCallArgumentsById, emittedCommandIds: previouslyEmittedIds }, toolStartedEvent, removeInterceptor, } = plan;
         if (toolStartedEvent) {
-            yield toolStartedEvent;
+            const filtered = this.#dedupeToolStarted(toolStartedEvent);
+            if (filtered)
+                yield filtered;
         }
         // Restore cached tool-call arguments so continuation outputs can attach them
         this.toolCallArgumentsById.clear();
@@ -455,15 +790,42 @@ export class ConversationSession {
                 try {
                     const stream = (await this.agentClient.continueRunStream(state, {
                         previousResponseId: this.previousResponseId,
+                        sessionId: this.id,
                     }));
                     const acc = createStreamAccumulator();
-                    yield* processStreamEvents(stream, acc, {
+                    for await (const event of processStreamEvents(stream, acc, {
                         toolCallArgumentsById: this.toolCallArgumentsById,
                         emittedInvalidToolCallPackets: this.emittedInvalidToolCallPackets,
                         preserveExistingToolArgs: true,
-                    }, { logger: this.logger, sessionId: this.id });
+                        onFunctionCallItem: (item) => this.toolLedger.recordFunctionCall(item),
+                        onFunctionResultItem: (item) => {
+                            this.toolLedger.recordFunctionResult(item);
+                            const cid = callIdOfLocal(item);
+                            if (cid && this.logSink) {
+                                const entry = this.toolLedger.export().find((e) => e.callId === cid);
+                                this.#log({
+                                    type: 'tool_result',
+                                    callId: cid,
+                                    toolName: entry?.toolName ?? toolNameOfLocal(item),
+                                    status: entry?.status === 'failed' || entry?.status === 'aborted' ? entry.status : 'completed',
+                                    output: entry?.output ?? outputOfLocal(item),
+                                    ...(entry?.historyItems ? { historyItems: entry.historyItems } : {}),
+                                });
+                            }
+                        },
+                    }, { logger: this.logger, sessionId: this.id })) {
+                        const filtered = this.#dedupeToolStarted(event);
+                        if (filtered)
+                            yield filtered;
+                    }
                     if (this.#isCurrentGeneration(gen)) {
                         this.previousResponseId = stream.lastResponseId ?? null;
+                        warnIfStreamHistoryReplayedTools({
+                            logger: this.logger,
+                            sessionId: this.id,
+                            source: 'continueRunStream',
+                            stream,
+                        });
                         this.conversationStore.updateFromResult(stream);
                     }
                     // Merge previously emitted command IDs with newly emitted ones
@@ -519,7 +881,7 @@ export class ConversationSession {
         catch (error) {
             yield {
                 type: 'error',
-                message: error instanceof Error ? error.message : String(error),
+                message: describeError(error),
             };
             throw error;
         }
@@ -531,14 +893,18 @@ export class ConversationSession {
     async sendMessage(input, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, } = {}) {
         const turn = normalizeUserTurn(input);
         return this.#withTrafficContext(turn.text, async () => {
-            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, onEvent ?? null);
+            const wrappedOnEvent = (event) => {
+                this.#dispatchEventToLog(event);
+                onEvent?.(event);
+            };
+            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, wrappedOnEvent);
             let result;
             try {
                 result = await collectTerminalResult(this.run(input, { hallucinationRetryCount }), {
                     onTextChunk,
                     onReasoningChunk,
                     onCommandMessage,
-                    onEvent,
+                    onEvent: wrappedOnEvent,
                     getRawInterruption: () => this.approvalFlow.getPendingInterruption(),
                     onFinalEvent: (event) => {
                         this.logger.debug('sendMessage received final event', {
@@ -566,15 +932,24 @@ export class ConversationSession {
         if (!this.approvalFlow.getPending()) {
             return null;
         }
+        this.#log({
+            type: 'approval_resolved',
+            answer: answer === 'y' ? 'y' : 'n',
+            ...(rejectionReason ? { rejectionReason } : {}),
+        });
         return this.#withTrafficContext(undefined, async () => {
-            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, onEvent ?? null);
+            const wrappedOnEvent = (event) => {
+                this.#dispatchEventToLog(event);
+                onEvent?.(event);
+            };
+            getMethod(this.agentClient, 'setSubagentEventSink')?.call(this.agentClient, wrappedOnEvent);
             let result;
             try {
                 result = await collectTerminalResult(this['continue']({ answer, rejectionReason }), {
                     onTextChunk,
                     onReasoningChunk,
                     onCommandMessage,
-                    onEvent,
+                    onEvent: wrappedOnEvent,
                     getRawInterruption: () => this.approvalFlow.getPendingInterruption(),
                     onFinalEvent: (event) => {
                         this.logger.debug('handleApprovalDecision received final event', {