@qduc/term2 0.11.1 → 0.13.0

package/dist/services/conversation/conversation-orchestrator.js

@@ -1,12 +1,12 @@
 import { describeError, isAbortLikeError } from '../../utils/error-helpers.js';
-import { ASK_USER_DECLINE_RESULT } from '../../tools/agent/ask-user-constants.js';
 import { createMessageIdFactory } from '../../utils/message-id-factory.js';
-import { isUserMessage } from '../../types/message.js';
+import { isCommandMessage, isUserMessage } from '../../types/message.js';
 import { isDeniedReadApproveAnswer } from '../../contracts/conversation.js';
 import { createStreamingSession } from '../../utils/streaming/streaming-session-factory.js';
 import { enhanceApiKeyError, isMaxTurnsError } from '../../utils/conversation/conversation-utils.js';
 import { clearStreamingBotMessage, computeNextMessages } from '../../utils/conversation/apply-conversation-result.js';
-import { countUndoableUserTurnsFrom, findLastUndoableUserMessage, trimTrailingAssistantMessages, } from '../../utils/conversation/message-utils.js';
+import { trimTrailingAssistantMessages } from '../../utils/conversation/message-utils.js';
+import { ASK_USER_NO_ANSWER_RESULT } from '../../tools/agent/ask-user-constants.js';
 import { annotateApprovedCommandMessage, filterPendingCommandMessagesForApproval, } from '../approval/approval-presentation-policy.js';
 import { formatUserTurnForDisplay, hasUserTurnContent, injectSkillIntoTurn, normalizeUserTurn, } from '../../types/user-turn.js';
 const REASONING_RESPONSE_THROTTLE_MS = 200;
@@ -18,6 +18,9 @@ const REASONING_RESPONSE_THROTTLE_MS = 200;
 function formatBackgroundSubagentNotifications(notifications) {
     const completions = notifications.filter((notification) => notification.kind === 'completion');
     const questions = notifications.filter((notification) => notification.kind === 'question');
+    const shellCompletions = notifications.filter((notification) => notification.kind === 'shell_completion');
+    const shellOutputs = notifications.filter((notification) => notification.kind === 'shell_output');
+    const userControls = notifications.filter((notification) => notification.kind === 'user_control');
     const sections = [];
     if (completions.length > 0) {
         const noun = completions.length === 1 ? 'run' : 'runs';
@@ -25,7 +28,11 @@ function formatBackgroundSubagentNotifications(notifications) {
             const lines = [
                 `- runId: ${notification.runId} | role: ${notification.role} | status: ${notification.status}`,
                 ...(notification.error ? [`  error: ${notification.error}`] : []),
-                ...(notification.preview ? [`  preview: ${notification.preview}`] : []),
+                '  result:',
+                notification.formattedResult
+                    .split('\n')
+                    .map((line) => `    ${line}`)
+                    .join('\n'),
             ];
             return lines.join('\n');
         });
@@ -34,7 +41,7 @@ function formatBackgroundSubagentNotifications(notifications) {
             '',
             ...entries,
             '',
-            'Call get_subagent_result(runId) for the full report. Assess it against the task before you accept it, then continue through the next necessary steps yourself rather than stopping at the fact that a run finished. Tell the user concisely, in your own words, what you concluded — the report is input to your judgement, not a message to relay.',
+            'The full result is inlined above; you do not need to call get_subagent_result. Assess it against the task before you accept it, then continue through the next necessary steps yourself rather than stopping at the fact that a run finished. Tell the user concisely, in your own words, what you concluded — the report is input to your judgement, not a message to relay.',
         ].join('\n'));
     }
     if (questions.length > 0) {
@@ -53,6 +60,74 @@ function formatBackgroundSubagentNotifications(notifications) {
             'Decide the answer, investigate it yourself, or escalate to the user if needed. To answer a specific waiting subagent, call send_message({ target, reply_to: messageId, message }). The subagent has no direct user channel; an answer resumes only its waiting tool call.',
         ].join('\n'));
     }
+    if (shellCompletions.length > 0) {
+        const noun = shellCompletions.length === 1 ? 'job' : 'jobs';
+        const entries = shellCompletions.map((notification) => [
+            `- jobId: ${notification.jobId} | command: ${notification.command} | status: ${notification.status}`,
+            ...(notification.error ? [`  error: ${notification.error}`] : []),
+            '  output:',
+            notification.output
+                .split('\n')
+                .map((line) => `    ${line}`)
+                .join('\n'),
+        ].join('\n'));
+        sections.push([
+            `Background shell ${noun} finished (${shellCompletions.length}). This is an automatic system notification, not a user message.`,
+            '',
+            ...entries,
+            '',
+            'Assess the command result against the task and continue through the next necessary steps. Tell the user concisely, in your own words, what you concluded.',
+        ].join('\n'));
+    }
+    if (shellOutputs.length > 0) {
+        const noun = shellOutputs.length === 1 ? 'watch' : 'watches';
+        const entries = shellOutputs.map((notification) => [
+            `- jobId: ${notification.jobId} | command: ${notification.command} | watchId: ${notification.watchId} | seq: ${notification.seq}`,
+            ...(notification.droppedBytes !== undefined ? [`  droppedBytes: ${notification.droppedBytes}`] : []),
+            '  matchedLines:',
+            notification.matchedLines
+                .split('\n')
+                .map((line) => `    ${line}`)
+                .join('\n'),
+        ].join('\n'));
+        sections.push([
+            `Background shell ${noun} matched output (${shellOutputs.length}). This is an automatic system notification, not a user message.`,
+            '',
+            ...entries,
+            '',
+            'Assess whether the matched output changes what you should do next and continue through the next necessary steps yourself, telling the user concisely, in your own words, what you concluded.',
+        ].join('\n'));
+    }
+    if (userControls.length > 0) {
+        const stopControls = userControls.filter((notification) => notification.action === 'stop');
+        const backgroundMoves = userControls.filter((notification) => notification.action === 'background');
+        const entriesFor = (notifications, verb) => notifications.map((notification) => {
+            const details = notification.details;
+            return details.kind === 'subagent'
+                ? `- ${verb} background subagent ${details.name ?? details.id} | runId: ${details.id} | role: ${details.role} | task: ${details.task}`
+                : `- ${verb} background shell | jobId: ${details.id} | command: ${details.command}`;
+        });
+        if (stopControls.length > 0) {
+            sections.push([
+                `The user requested that ${stopControls.length === 1 ? 'a background task be stopped' : 'background tasks be stopped'}. This is an automatic user control notification, not a user message.`,
+                '',
+                ...entriesFor(stopControls, 'stop requested for'),
+                '',
+                'Plan the next step around the requested stop. The task may settle later with a cancelled completion notification; do not assume its result is available yet.',
+            ].join('\n'));
+        }
+        if (backgroundMoves.length > 0) {
+            sections.push([
+                `The user moved ${backgroundMoves.length === 1
+                    ? 'a foreground shell into the background'
+                    : 'foreground shells into the background'}. This is an automatic user control notification, not a user message.`,
+                '',
+                ...entriesFor(backgroundMoves, 'moved to'),
+                '',
+                'The same execution continues running in the background. Plan the next step without waiting for it, and do not stop or relaunch it unless the task now requires that.',
+            ].join('\n'));
+        }
+    }
     return sections.join('\n\n');
 }
 /** The user-facing companion to the model-only background notification instruction. */
@@ -66,6 +141,31 @@ function formatBackgroundSubagentNotificationDisplay(notifications) {
                 `question: ${notification.question}`,
             ].join('\n');
         }
+        if (notification.kind === 'shell_completion') {
+            return [
+                `- jobId: ${notification.jobId} | command: ${notification.command} | status: ${notification.status}`,
+                ...(notification.error ? [`  error: ${notification.error}`] : []),
+                ...(notification.output ? [`  output: ${notification.output}`] : []),
+            ].join('\n');
+        }
+        if (notification.kind === 'shell_output') {
+            return [
+                `- jobId: ${notification.jobId} | command: ${notification.command} | watchId: ${notification.watchId} | seq: ${notification.seq}`,
+                ...(notification.droppedBytes !== undefined ? [`  droppedBytes: ${notification.droppedBytes}`] : []),
+                ...(notification.matchedLines ? [`  matchedLines: ${notification.matchedLines}`] : []),
+            ].join('\n');
+        }
+        if (notification.kind === 'user_control') {
+            const details = notification.details;
+            if (notification.action === 'background') {
+                return details.kind === 'subagent'
+                    ? `Moved to background: ${details.name ?? details.id} (${details.role})`
+                    : `Moved to background: shell ${details.command}`;
+            }
+            return details.kind === 'subagent'
+                ? `Stop requested: background ${details.name ?? details.id} (${details.role})`
+                : `Stop requested: shell ${details.command}`;
+        }
         const lines = [
             `- runId: ${notification.runId} | role: ${notification.role} | status: ${notification.status}`,
             ...(notification.error ? [`  error: ${notification.error}`] : []),
@@ -77,9 +177,6 @@ function formatBackgroundSubagentNotificationDisplay(notifications) {
 }
 export class ConversationOrchestrator {
     config;
-    pendingApproval = null;
-    askUserAnswers = [];
-    currentAskUserQuestionIndex = 0;
     createMessageId;
     #directlyAppendedMessageIds = new Set();
     #displayedBackgroundNotificationMessageIds = new Set();
@@ -89,6 +186,14 @@ export class ConversationOrchestrator {
      * them — remove/discard/reject must not require a matching `#endTurn`.
      */
     #deferredTurnActivators = new Map();
+    /**
+     * A pending steer retracted through the id-addressed mutation path. The
+     * adapter intentionally keeps the shared steer API boolean, so this marker
+     * distinguishes a deliberate retraction from an ordinary failed steer.
+     */
+    #retractedSteerIds = new Set();
+    /** Latest user turn for a pending steer edited before admission. */
+    #editedSteerTurns = new Map();
     /**
      * Turns this orchestrator currently owns. Count only executions that have
      * actually started (direct submit or queue-start activation), never merely
@@ -97,6 +202,8 @@ export class ConversationOrchestrator {
     #activeTurns = 0;
     /** True while {@link stopProcessing} is tearing the conversation down. */
     #stoppingByUser = false;
+    /** Stranded rows already reported, so the warning stays one per occurrence. */
+    #reportedStrandedCallIds = new Set();
     constructor(config) {
         this.config = config;
         this.createMessageId = config.createMessageId ?? createMessageIdFactory(config.now);
@@ -144,17 +251,14 @@ export class ConversationOrchestrator {
     getSubagentUsage() {
         return this.config.subagentUsageAccumulator?.get() ?? null;
     }
+    getCostSummary() {
+        return this.config.costAccumulator?.getSummary() ?? null;
+    }
     goToPreviousQuestion() {
-        if (this.currentAskUserQuestionIndex <= 0) {
-            return;
-        }
-        this.currentAskUserQuestionIndex -= 1;
-        this.askUserAnswers.pop();
-        this.config.ui.onAskUserGoBack(this.currentAskUserQuestionIndex, this.askUserAnswers.slice());
+        this.config.conversationService.goToPreviousPendingInteractionQuestion?.();
     }
     goToNextQuestion() {
-        this.currentAskUserQuestionIndex += 1;
-        this.config.ui.onAskUserAdvanceToNext(this.currentAskUserQuestionIndex);
+        this.config.conversationService.goToNextPendingInteractionQuestion?.();
     }
     async clearConversation() {
         if (this.config.onClear) {
@@ -165,13 +269,16 @@ export class ConversationOrchestrator {
         }
         this.config.messages.setMessages(() => []);
         this.config.approvedContext.current = null;
-        this.pendingApproval = null;
-        this.resetAskUserState();
+        this.config.conversationService.clearPendingInteraction?.();
         this.config.ui.onResetAll();
         this.config.usageAccumulator?.reset();
         this.config.subagentUsageAccumulator?.reset();
+        this.config.costAccumulator?.reset();
         this.#directlyAppendedMessageIds.clear();
         this.#displayedBackgroundNotificationMessageIds.clear();
+        this.#retractedSteerIds.clear();
+        this.#editedSteerTurns.clear();
+        this.#reportedStrandedCallIds.clear();
     }
     stopProcessing() {
         // The user asked everything to stop, so background subagent runs go too.
@@ -188,67 +295,68 @@ export class ConversationOrchestrator {
                 ? { ...message, status: 'aborted' }
                 : message));
             this.config.approvedContext.current = null;
-            this.pendingApproval = null;
-            this.resetAskUserState();
+            this.config.conversationService.clearPendingInteraction?.();
             this.config.ui.onResetTransient();
             this.#directlyAppendedMessageIds.clear();
             this.#displayedBackgroundNotificationMessageIds.clear();
+            this.#retractedSteerIds.clear();
+            this.#editedSteerTurns.clear();
             this.config.conversationService.backgroundSubagentNotifications?.drain();
         }
         finally {
             this.#stoppingByUser = false;
         }
     }
-    undoLastUserMessage() {
-        const messages = this.config.messages.getMessages();
-        const lastUserIndex = findLastUndoableUserMessage(messages);
-        if (lastUserIndex === -1) {
+    /**
+     * Rewind through an opaque store target. `uiIndex` is used only to trim the
+     * rendered projection after the domain operation accepted the same target.
+     */
+    rewindToTarget(targetId, uiIndex) {
+        const restored = this.config.conversationService.rewindToTarget(targetId);
+        if (restored === null)
             return null;
-        }
-        const lastUserMessage = messages[lastUserIndex];
-        const uiText = isUserMessage(lastUserMessage) ? lastUserMessage.text : '';
+        // Keep rewind's historical foreground-only cancellation behavior, but do
+        // not abort an active turn for a stale picker target that the store rejects.
         this.config.conversationService.abort();
-        const removed = this.config.conversationService.undoLastUserTurn();
-        const restored = removed ?? { text: uiText };
-        this.config.messages.setMessages((prev) => prev.slice(0, lastUserIndex));
+        this.config.messages.setMessages((prev) => prev.slice(0, uiIndex));
         this.config.approvedContext.current = null;
-        this.pendingApproval = null;
-        this.resetAskUserState();
+        this.config.conversationService.clearPendingInteraction?.();
         this.config.ui.onResetTransient();
         this.#directlyAppendedMessageIds.clear();
         this.#displayedBackgroundNotificationMessageIds.clear();
         return restored;
     }
-    /**
-     * Cancel the most recently queued message and return its text so the UI
-     * can move it back into the input box. Returns null when there are no
-     * pending queued messages, the service cannot cancel the tail item, or the
-     * service does not implement cancellation.
-     */
-    async removeLastQueuedPendingMessage() {
+    async retractPendingSubmission(id) {
         const service = this.config.conversationService;
-        if (typeof service.removeLastQueuedItem !== 'function') {
-            return null;
-        }
-        const result = await service.removeLastQueuedItem();
-        if (!result)
-            return null;
-        // The pending indicator above the input box is managed by the UI. The
-        // adapter already removed the matching internal entry, but the UI state
-        // is still showing it until we tell it to drop the last entry.
-        if (this.config.ui.onQueuedMessageRemoved) {
-            this.config.ui.onQueuedMessageRemoved(result.id);
+        if (typeof service.retractSubmission !== 'function')
+            return { kind: 'unknown_id' };
+        const result = await service.retractSubmission(id);
+        if (result.kind === 'applied') {
+            if (result.stage === 'pending_steer') {
+                this.#retractedSteerIds.add(id);
+                this.#editedSteerTurns.delete(id);
+            }
+            this.config.ui.onQueuedMessageRemoved?.(id);
         }
-        else {
-            this.config.ui.onRemoveLastPendingMessage?.();
+        return result;
+    }
+    async editPendingSubmission(id, turn) {
+        const service = this.config.conversationService;
+        if (typeof service.editSubmission !== 'function')
+            return { kind: 'unknown_id' };
+        const result = await service.editSubmission(id, turn);
+        if (result.kind === 'applied') {
+            if (result.stage === 'pending_steer') {
+                this.#editedSteerTurns.set(id, structuredClone(normalizeUserTurn(turn)));
+            }
+            this.config.ui.onQueuedMessageEdited?.(id, formatUserTurnForDisplay(normalizeUserTurn(turn)));
         }
-        return result.text;
+        return result;
     }
     async retryLastToolOutput() {
         this.config.conversationService.abort();
         this.config.approvedContext.current = null;
-        this.pendingApproval = null;
-        this.resetAskUserState();
+        this.config.conversationService.clearPendingInteraction?.();
         this.config.ui.onResetTransient();
         if (!this.config.conversationService.peekLastToolOutput()) {
             return false;
@@ -275,7 +383,6 @@ export class ConversationOrchestrator {
             }
             const errorMessage = enhanceApiKeyError(describeError(error));
             this.appendBotError(errorMessage);
-            this.config.ui.onApprovalResolved();
             return true;
         }
         finally {
@@ -285,25 +392,6 @@ export class ConversationOrchestrator {
             this.#endTurn();
         }
     }
-    undoToUserMessage(uiIndex) {
-        const messages = this.config.messages.getMessages();
-        const undoCount = countUndoableUserTurnsFrom(messages, uiIndex);
-        if (undoCount === 0) {
-            return null;
-        }
-        const selectedMessage = messages[uiIndex];
-        const uiText = isUserMessage(selectedMessage) ? selectedMessage.text : '';
-        this.config.conversationService.abort();
-        const removed = this.config.conversationService.undoNUserTurns(undoCount);
-        const restored = removed?.text ?? uiText;
-        this.config.messages.setMessages((prev) => prev.slice(0, uiIndex));
-        this.config.approvedContext.current = null;
-        this.pendingApproval = null;
-        this.resetAskUserState();
-        this.config.ui.onResetTransient();
-        this.#directlyAppendedMessageIds.clear();
-        return restored;
-    }
     async sendUserMessage(input, options) {
         const turn = normalizeUserTurn(input);
         if (!hasUserTurnContent(turn)) {
@@ -324,12 +412,80 @@ export class ConversationOrchestrator {
         const queueOwnsSubmission = this.config.conversationService.isQueueOwningSubmissions?.() ??
             this.config.conversationService.isQueueActive?.() ??
             false;
+        // Logged before the branch below, not inside it. "Steer attempt resolved"
+        // only exists on the path that actually tries to steer, so a submission
+        // that never enters that path — because it arrived without busyMode
+        // 'steer', or because the queue did not claim it — is indistinguishable in
+        // the logs from one that was never submitted at all. That gap hid a real
+        // report of a steer silently queueing: the queue file held the message and
+        // the transcript held the user_message, and nothing recorded the decision
+        // in between. These four fields name that decision.
+        this.config.loggingService.info('Submission routing decided', {
+            busyMode: options?.busyMode ?? 'none',
+            queueOwnsSubmission,
+            queueStateKind: this.config.conversationService.queueStateKind?.() ?? 'unknown',
+            canSteer: Boolean(this.config.conversationService.steerActiveTurn),
+            messageId: userMessage.id,
+        });
         if (queueOwnsSubmission) {
             // A turn is already in flight or the queue is paused with retained work.
             // Show the message above the input box until the queue actually starts
             // processing it; the message list will be updated when the queue pops
             // this turn.
             this.config.ui.onQueuedMessagePending?.(userMessage.id, userMessage.text);
+            // A steer belongs to the turn already running: hand it to that turn so
+            // the model reads it at its next request, rather than making the user
+            // wait for the whole turn to end. The message joins the transcript at the
+            // moment the turn takes it, which is when the model actually sees it.
+            if (options?.busyMode === 'steer' && this.config.conversationService.steerActiveTurn) {
+                // Diagnostics for "my steer just queued". The three fields below
+                // separate the ways delivery can fail, which otherwise look identical
+                // in the UI because the queued label is drawn before this even runs:
+                //   queueActive=false            → refused by the adapter's predicate;
+                //     the queue owns the submission but is not in a state that offers
+                //     steering (awaiting_preflight, paused, idle with retained work).
+                //   queueActive=true, waited≈0ms → refused synchronously downstream:
+                //     awaiting an approval, or no run in flight at the run loop.
+                //   queueActive=true, waited>0ms → held as pending and released when
+                //     the run ended: the turn never reached another request boundary.
+                //   steered=true                 → admitted; waitedMs is how long the
+                //     user waited for the turn to reach that boundary.
+                const queueActive = this.config.conversationService.isQueueActive?.() ?? false;
+                const queueStateKind = this.config.conversationService.queueStateKind?.() ?? 'unknown';
+                const steerStartedAt = Date.now();
+                const steered = await this.config.conversationService
+                    .steerActiveTurn(turn, { id: userMessage.id })
+                    .catch((error) => {
+                    this.logError('Error steering the active turn', error);
+                    return false;
+                });
+                this.config.loggingService.info('Steer attempt resolved', {
+                    steered,
+                    queueActive,
+                    queueStateKind,
+                    waitedMs: Date.now() - steerStartedAt,
+                    messageId: userMessage.id,
+                });
+                if (steered) {
+                    const admittedTurn = this.#editedSteerTurns.get(userMessage.id) ?? turn;
+                    this.#editedSteerTurns.delete(userMessage.id);
+                    const { skill: _originalSkill, ...messageWithoutSkill } = userMessage;
+                    const admittedMessage = {
+                        ...messageWithoutSkill,
+                        text: formatUserTurnForDisplay(admittedTurn),
+                        ...(admittedTurn.skill ? { skill: admittedTurn.skill } : {}),
+                    };
+                    this.config.ui.onQueuedMessageStarted?.(userMessage.id);
+                    this.config.messages.appendMessages([admittedMessage]);
+                    this.config.logWriter?.append({ type: 'user_message', message: { ...admittedMessage } });
+                    return;
+                }
+                if (this.#retractedSteerIds.delete(userMessage.id)) {
+                    this.#editedSteerTurns.delete(userMessage.id);
+                    return;
+                }
+                this.#editedSteerTurns.delete(userMessage.id);
+            }
         }
         else {
             // No turn is in flight — append directly. The queue observer will also
@@ -338,7 +494,7 @@ export class ConversationOrchestrator {
             this.config.messages.appendMessages([userMessage]);
             this.#directlyAppendedMessageIds.add(userMessage.id);
         }
-        this.config.logWriter?.append({ type: 'user_message', message: userMessage });
+        this.config.logWriter?.append({ type: 'user_message', message: { ...userMessage } });
         // Streaming callbacks are bound at submit time, but deferred submissions
         // must not count as active turns until the queue starts them. Otherwise
         // remove/discard would need a matching endTurn for work that never ran.
@@ -360,6 +516,7 @@ export class ConversationOrchestrator {
             const result = await this.config.conversationService.sendMessage(turnToSend, {
                 onEvent: this.createOnEventHandler(applyConversationEvent),
                 bypassInputSurgeGuard: options?.bypassInputSurgeGuard,
+                busyMode: options?.busyMode,
                 preferredMessageId: userMessage.id,
             });
             applyConversationEvent({ type: 'final', finalText: '' });
@@ -375,9 +532,12 @@ export class ConversationOrchestrator {
                 this.config.loggingService.debug('Suppressing abort error in sendUserMessage');
                 return;
             }
-            // Errors for work that never left the pending queue should not paint a bot
-            // error into the transcript; the submission simply did not run.
+            // A submission that never left the pending queue produced no turn to
+            // report on, but it also produced no answer: the pending indicator has
+            // just been cleared, so saying nothing would make the user's text vanish
+            // without explanation. Report the rejection and hand the text back.
             if (queueOwnsSubmission && !turnActivated) {
+                this.appendBotError(`${enhanceApiKeyError(describeError(error))}\n\nThis message was not sent: ${userMessage.text}`);
                 return;
             }
             const rawErrorMessage = describeError(error);
@@ -402,12 +562,11 @@ export class ConversationOrchestrator {
                     rawInterruption: null,
                     isMaxTurnsPrompt: true,
                 };
-                this.pendingApproval = pendingApproval;
+                this.config.conversationService.presentPendingInteraction?.(pendingApproval);
                 this.config.ui.onApprovalRequested(pendingApproval);
             }
             else {
                 this.appendBotError(errorMessage);
-                this.config.ui.onApprovalResolved();
             }
         }
         finally {
@@ -420,56 +579,27 @@ export class ConversationOrchestrator {
             }
         }
     }
-    async handleApprovalDecision(answer, rejectionReason, approvalAnswer) {
-        const pendingApproval = this.pendingApproval;
-        if (!pendingApproval) {
+    async handleApprovalDecision(answer, rejectionReason, approvalAnswer, expectedInteractionId, options = {}) {
+        const resolution = this.config.conversationService.resolvePendingInteraction?.({
+            expectedInteractionId,
+            answer,
+            rejectionReason,
+            approvalAnswer,
+        });
+        if (!resolution || resolution.kind === 'none' || resolution.kind === 'stale_interaction') {
             return;
         }
+        if (resolution.kind === 'awaiting_next_question')
+            return;
+        const pendingApproval = resolution.approval;
         const isMaxTurnsPrompt = pendingApproval.isMaxTurnsPrompt;
-        const isAskUser = pendingApproval.toolName === 'ask_user';
-        if (isAskUser && answer === 'y' && approvalAnswer !== ASK_USER_DECLINE_RESULT) {
-            let questions = [];
-            try {
-                const parsed = JSON.parse(pendingApproval.argumentsText);
-                questions = parsed.questions || [];
-            }
-            catch {
-                // noop
-            }
-            let parsedAns = approvalAnswer ?? '';
-            const currentQuestion = questions[this.askUserAnswers.length];
-            if (currentQuestion?.is_multi_select) {
-                try {
-                    const maybeArray = JSON.parse(approvalAnswer ?? '');
-                    if (Array.isArray(maybeArray)) {
-                        parsedAns = maybeArray;
-                    }
-                }
-                catch {
-                    // keep plain string
-                }
-            }
-            const nextAnswers = [...this.askUserAnswers, parsedAns];
-            this.config.ui.onAskUserAnswerSubmitted(parsedAns);
-            if (nextAnswers.length < questions.length) {
-                this.askUserAnswers = nextAnswers;
-                this.currentAskUserQuestionIndex = nextAnswers.length;
-                this.config.ui.onAskUserAdvanceToNext(nextAnswers.length);
-                return;
-            }
-            this.askUserAnswers = nextAnswers;
-            this.currentAskUserQuestionIndex = nextAnswers.length;
-            approvalAnswer = JSON.stringify(nextAnswers);
-        }
+        this.config.ui.onApprovalResolved();
         if (answer === 'y' || isDeniedReadApproveAnswer(answer)) {
             this.config.approvedContext.current = {
                 callId: pendingApproval.callId,
                 toolName: pendingApproval.toolName,
             };
         }
-        this.config.ui.onApprovalResolved();
-        this.pendingApproval = null;
-        this.resetAskUserState();
         if (isMaxTurnsPrompt && answer === 'n') {
             this.#endTurn();
             return;
@@ -491,7 +621,6 @@ export class ConversationOrchestrator {
                 }
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 this.appendBotError(errorMessage);
-                this.config.ui.onApprovalResolved();
             }
             finally {
                 reasoningUpdater.flush();
@@ -504,7 +633,8 @@ export class ConversationOrchestrator {
         try {
             const result = await this.config.conversationService.handleApprovalDecision(answer, rejectionReason, {
                 onEvent: this.createOnEventHandler(applyConversationEvent),
-                approvalAnswer,
+                approvalAnswer: resolution.approvalAnswer,
+                ...(options.stopAfterApprovalResolution ? { stopAfterApprovalResolution: true } : {}),
             });
             applyConversationEvent({ type: 'final', finalText: '' });
             botResponseUpdater.flush();
@@ -518,7 +648,6 @@ export class ConversationOrchestrator {
             }
             const errorMessage = error instanceof Error ? error.message : String(error);
             this.appendBotError(errorMessage);
-            this.config.ui.onApprovalResolved();
         }
         finally {
             this.config.loggingService.debug('handleApprovalDecision finally block - resetting state');
@@ -527,6 +656,18 @@ export class ConversationOrchestrator {
             this.#endTurn();
         }
     }
+    /**
+     * Escape on an `ask_user` prompt. The tool still returns
+     * {@link ASK_USER_NO_ANSWER_RESULT}, so the question and the fact that it
+     * went unanswered are committed to history and travel with the user's next
+     * message. The turn then ends instead of handing the model another turn:
+     * cancelling means the user speaks next.
+     */
+    async cancelAskUser(expectedInteractionId) {
+        return this.handleApprovalDecision('y', undefined, ASK_USER_NO_ANSWER_RESULT, expectedInteractionId, {
+            stopAfterApprovalResolution: true,
+        });
+    }
     /** Open a turn this orchestrator owns, and its streaming session. */
     #beginTurn(label) {
         this.#activeTurns += 1;
@@ -541,15 +682,186 @@ export class ConversationOrchestrator {
     #endTurn(flushNotifications = true) {
         this.#activeTurns = Math.max(0, this.#activeTurns - 1);
         this.config.ui.onTurnEnd();
+        this.#finalizeStrandedCommandMessages();
         if (flushNotifications) {
             void this.#deliverBackgroundSubagentNotifications();
         }
     }
     /**
-     * Hand every settled background subagent run to the main agent as one
-     * system-initiated turn. Does nothing unless the conversation is idle: a
-     * running turn or a pending approval owns the agent, and the store keeps the
-     * notifications until the next terminal state re-attempts delivery.
+     * Close command rows that no completion will ever close.
+     *
+     * A row opens as `running` on `tool_started` and closes only when a command
+     * message carrying the same callId arrives. Anything that ends a turn without
+     * that message — a stream error, a retry, a tool whose result is never
+     * rendered — leaves the row running for the rest of the session. That is not
+     * cosmetic: a running command is the first message that cannot render
+     * statically, so one stranded row keeps every later message re-rendering
+     * outside Ink's Static region.
+     *
+     * The warning is half the point. A silent net would hide the next tool that
+     * strands a row the way the last one hid for fourteen hours.
+     */
+    #finalizeStrandedCommandMessages() {
+        // A turn that parks on an approval closes and reopens around the prompt, so
+        // reaching here does not mean the work finished. Anything still running is
+        // legitimately in flight until the user decides.
+        if (this.#activeTurns > 0)
+            return;
+        if (this.config.conversationService.getPendingInteractionSnapshot?.())
+            return;
+        const stranded = this.config.messages
+            .getMessages()
+            .filter((message) => isCommandMessage(message) && message.status === 'running');
+        if (stranded.length === 0)
+            return;
+        this.config.messages.setMessages((messages) => messages.map((message) => message.sender === 'command' && message.status === 'running'
+            ? { ...message, status: 'aborted' }
+            : message));
+        const unreported = stranded.filter((message) => !this.#reportedStrandedCallIds.has(message.callId ?? message.id));
+        if (unreported.length === 0)
+            return;
+        for (const message of unreported) {
+            this.#reportedStrandedCallIds.add(message.callId ?? message.id);
+        }
+        this.config.loggingService.warn('Command rows left running at turn end; aborting them', {
+            tools: unreported.map((message) => message.toolName ?? 'unknown'),
+            callIds: unreported.map((message) => message.callId ?? message.id),
+        });
+    }
+    /**
+     * Announce settled runs in the transcript, once each.
+     *
+     * Display is deliberately not tied to the agent receiving them: the user
+     * should see a run land the moment it does, whether the report reaches the
+     * agent at the next request boundary or waits for a turn of its own.
+     */
+    #announceBackgroundSubagentNotifications(notifications) {
+        const newlyDisplayed = notifications.filter((notification) => !this.#displayedBackgroundNotificationMessageIds.has(notification.messageId));
+        if (newlyDisplayed.length === 0)
+            return;
+        for (const notification of newlyDisplayed) {
+            this.#displayedBackgroundNotificationMessageIds.add(notification.messageId);
+        }
+        const subagentNotifications = newlyDisplayed.filter((notification) => notification.kind === 'completion' || notification.kind === 'question');
+        const runs = subagentNotifications
+            .filter((notification) => notification.kind === 'completion')
+            .map(({ name, role, status, error }) => ({
+            ...(name !== undefined ? { name } : {}),
+            role,
+            status,
+            ...(error ? { error } : {}),
+        }));
+        const shellJobs = newlyDisplayed.filter((notification) => notification.kind === 'shell_completion');
+        const shellOutputs = newlyDisplayed.filter((notification) => notification.kind === 'shell_output');
+        const userControls = newlyDisplayed.filter((notification) => notification.kind === 'user_control');
+        this.config.messages.appendMessages([
+            ...(subagentNotifications.length > 0
+                ? [
+                    {
+                        id: this.createMessageId(),
+                        sender: 'command',
+                        status: 'completed',
+                        command: 'background_subagent_notification',
+                        output: formatBackgroundSubagentNotificationDisplay(subagentNotifications),
+                        success: true,
+                        toolName: 'background_subagent_notification',
+                        toolArgs: { runs },
+                    },
+                ]
+                : []),
+            ...(shellJobs.length > 0
+                ? [
+                    {
+                        id: this.createMessageId(),
+                        sender: 'command',
+                        status: 'completed',
+                        command: 'background_shell_notification',
+                        output: formatBackgroundSubagentNotificationDisplay(shellJobs),
+                        success: true,
+                        toolName: 'background_shell_notification',
+                        toolArgs: {
+                            jobs: shellJobs.map(({ jobId, command, status, error }) => ({
+                                jobId,
+                                command,
+                                status,
+                                ...(error ? { error } : {}),
+                            })),
+                        },
+                    },
+                ]
+                : []),
+            ...(shellOutputs.length > 0
+                ? [
+                    {
+                        id: this.createMessageId(),
+                        sender: 'command',
+                        status: 'completed',
+                        command: 'background_shell_output_notification',
+                        output: formatBackgroundSubagentNotificationDisplay(shellOutputs),
+                        success: true,
+                        toolName: 'background_shell_output_notification',
+                        toolArgs: {
+                            firings: shellOutputs.map(({ jobId, command, watchId, seq, matchedLines, droppedBytes }) => ({
+                                jobId,
+                                command,
+                                watchId,
+                                seq,
+                                matchedLines,
+                                ...(droppedBytes !== undefined ? { droppedBytes } : {}),
+                            })),
+                        },
+                    },
+                ]
+                : []),
+            ...(userControls.length > 0
+                ? [
+                    {
+                        id: this.createMessageId(),
+                        sender: 'command',
+                        status: 'completed',
+                        command: 'background_task_control_notification',
+                        output: formatBackgroundSubagentNotificationDisplay(userControls),
+                        success: true,
+                        toolName: 'background_task_control_notification',
+                        toolArgs: {
+                            actions: userControls.map(({ action, target }) => ({ action, target })),
+                        },
+                    },
+                ]
+                : []),
+        ]);
+    }
+    /**
+     * Offer settled runs to the turn already in flight.
+     *
+     * Taken as one report at that turn's next request boundary. If the turn will
+     * not take them they go back to the store unchanged, so the idle path still
+     * delivers them and the agent never sees the same run twice.
+     */
+    async #injectBackgroundSubagentNotifications(pending) {
+        if (!this.config.conversationService.injectIntoActiveTurn)
+            return;
+        const notifications = pending.drain();
+        if (notifications.length === 0)
+            return;
+        this.#announceBackgroundSubagentNotifications(notifications);
+        const injected = await this.config.conversationService
+            .injectIntoActiveTurn([
+            { type: 'message', role: 'user', content: formatBackgroundSubagentNotifications(notifications) },
+        ])
+            .catch((error) => {
+            this.logError('Error delivering background subagent notifications', error);
+            return false;
+        });
+        if (!injected)
+            pending.retain(notifications);
+    }
+    /**
+     * Hand every settled background subagent run to the main agent.
+     *
+     * The agent that launched these runs is usually still working when they
+     * settle, so delivery goes into that turn at its next request boundary. Only
+     * when no turn will take them does this open one of its own.
      */
     async #deliverBackgroundSubagentNotifications() {
         const pending = this.config.conversationService.backgroundSubagentNotifications;
@@ -557,31 +869,17 @@ export class ConversationOrchestrator {
             return;
         if (this.#stoppingByUser)
             return;
-        if (this.#activeTurns > 0 || this.pendingApproval)
+        const turnIsRunning = this.#activeTurns > 0 || this.config.conversationService.isQueueActive?.() === true;
+        if (turnIsRunning) {
+            await this.#injectBackgroundSubagentNotifications(pending);
             return;
-        if (this.config.conversationService.isQueueActive?.())
+        }
+        if (this.config.conversationService.getPendingInteractionSnapshot?.())
             return;
         const notifications = pending.drain();
         if (notifications.length === 0)
             return;
-        const newlyDisplayed = notifications.filter((notification) => !this.#displayedBackgroundNotificationMessageIds.has(notification.messageId));
-        if (newlyDisplayed.length > 0) {
-            for (const notification of newlyDisplayed) {
-                this.#displayedBackgroundNotificationMessageIds.add(notification.messageId);
-            }
-            this.config.messages.appendMessages([
-                {
-                    id: this.createMessageId(),
-                    sender: 'command',
-                    status: 'completed',
-                    command: 'background_subagent_notification',
-                    output: formatBackgroundSubagentNotificationDisplay(newlyDisplayed),
-                    success: true,
-                    toolName: 'background_subagent_notification',
-                    toolArgs: { count: newlyDisplayed.length },
-                },
-            ]);
-        }
+        this.#announceBackgroundSubagentNotifications(notifications);
         const { botResponseUpdater, reasoningUpdater, applyConversationEvent, streamingState } = this.#beginTurn('backgroundSubagentNotification');
         let delivered = false;
         try {
@@ -603,7 +901,6 @@ export class ConversationOrchestrator {
                 return;
             }
             this.appendBotError(enhanceApiKeyError(describeError(error)));
-            this.config.ui.onApprovalResolved();
         }
         finally {
             reasoningUpdater.flush();
@@ -631,11 +928,11 @@ export class ConversationOrchestrator {
     }
     createOnEventHandler(baseOnEvent) {
         return (event) => {
-            const eventType = typeof event?.type === 'string' ? event.type : undefined;
+            const eventType = event.type;
             if (eventType === 'reasoning_delta') {
                 this.config.ui.onStreamingThinkingStarted((this.config.now ?? Date.now)());
             }
-            else if (eventType && this.clearsThinkingIndicator(eventType)) {
+            else if (this.clearsThinkingIndicator(eventType)) {
                 this.config.ui.onStreamingThinkingCleared();
             }
             if (eventType === 'tool_call_streaming_delta') {
@@ -644,7 +941,7 @@ export class ConversationOrchestrator {
             else if (eventType === 'tool_started' || eventType === 'text_delta' || eventType === 'final') {
                 this.config.ui.onStreamingToolInfo(null);
             }
-            if (event?.type === 'user_message_consumed_for_abort') {
+            if (eventType === 'user_message_consumed_for_abort') {
                 this.config.messages.setMessages((prev) => {
                     for (let i = prev.length - 1; i >= 0; i--) {
                         const msg = prev[i];
@@ -661,11 +958,29 @@ export class ConversationOrchestrator {
                 return;
             }
             baseOnEvent(event);
-            if (event?.type === 'subagent_completed' && event?.result?.usage) {
-                this.config.subagentUsageAccumulator?.add(event.result.usage);
+            if (eventType === 'cost_update') {
+                // Per-request cost records arrive live during the run; the terminal
+                // result re-delivers the same records and the accumulator dedups them
+                // by request id, so adding here is idempotent.
+                this.config.costAccumulator?.addRecord(event.record);
+                this.emitCostSummary();
+                return;
+            }
+            if (eventType === 'subagent_completed') {
+                if (event.result.usage) {
+                    this.config.subagentUsageAccumulator?.add(event.result.usage);
+                }
+                this.config.costAccumulator?.addRecords(event.result.costRecords ?? []);
+                this.emitCostSummary();
             }
         };
     }
+    /** Push the accumulator's current summary to the UI after any cost add. */
+    emitCostSummary() {
+        const summary = this.config.costAccumulator?.getSummary();
+        if (summary)
+            this.config.ui.onCostUpdate?.(summary);
+    }
     applyServiceResult(result, streamingState, latestStreamedUsage) {
         if (!result) {
             return;
@@ -674,13 +989,11 @@ export class ConversationOrchestrator {
             if (result.usage) {
                 this.config.ui.onUsageUpdate(latestStreamedUsage ?? result.usage);
             }
-            this.pendingApproval = result.approval;
             this.config.messages.setMessages((prev) => this.config.messages.trimMessages(filterPendingCommandMessagesForApproval(prev, result.approval)));
             this.config.ui.onApprovalRequested({ ...result.approval, llmAdvisory: result.approval.llmAdvisory });
             this.config.notifier?.approvalNeeded();
             return;
         }
-        this.pendingApproval = null;
         this.config.messages.setMessages((prev) => computeNextMessages({
             prev,
             result,
@@ -698,6 +1011,8 @@ export class ConversationOrchestrator {
             this.config.usageAccumulator?.add(result.usage);
             this.config.ui.onUsageUpdate(latestStreamedUsage ?? result.usage);
         }
+        this.config.costAccumulator?.addRecords(result.costRecords ?? []);
+        this.emitCostSummary();
     }
     /**
      * Append a previously-queued user message into the message list. Called by
@@ -752,10 +1067,6 @@ export class ConversationOrchestrator {
             eventType === 'tool_call_streaming_delta' ||
             eventType === 'final');
     }
-    resetAskUserState() {
-        this.askUserAnswers = [];
-        this.currentAskUserQuestionIndex = 0;
-    }
     appendBotError(errorMessage) {
         const botErrorMessage = {
             id: this.createMessageId(),