@qduc/term2 0.11.0 → 0.12.0

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

@@ -1,7 +1,22 @@
-import { collectTerminalResult } from '../session/terminal-result-collector.js';
+import { collectTerminalResult, TerminalResultCollectorExhaustionError } from '../session/terminal-result-collector.js';
 import { getCallIdFromObject } from '../interruption-info.js';
 import { normalizeUserTurn } from '../../types/user-turn.js';
+import { userTurnToProviderItem } from './user-turn-item.js';
 import { QueueController, } from '../queue/queue-controller.js';
+const QUEUED_NON_TEXT_PLACEHOLDER = '[queued non-text user turn]';
+const LEGACY_QUEUED_MESSAGE_PLACEHOLDER = '\u0000queued-message';
+/** Upper bound for waiting on an active turn during cancel so the queue cannot stick in `cancelling`. */
+const ACTIVE_CANCEL_TIMEOUT_MS = 10_000;
+function queueCancellationError(message) {
+    const error = new Error(message);
+    error.name = 'AbortError';
+    return error;
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
 export class ConversationAdapter {
     #sessionId;
     #startedAt;
@@ -14,18 +29,31 @@ export class ConversationAdapter {
     #userTurns;
     #logs;
     #approval;
+    #pendingInteraction;
     #turnFlow;
-    #pendingMessages = [];
     #messagesById = new Map();
+    /**
+     * Ids currently handed to `turnFlow.steer` and not yet settled. Populated
+     * right before the call and cleared when that steer's promise resolves
+     * (admitted, released, or retracted) — this is what lets
+     * `retractSubmission`/`editSubmission` tell a pending steer apart from a
+     * queued item sharing the same id space, per `## The three stages`.
+     */
+    #pendingSteerIds = new Set();
     #queue;
     #nextQueuedMessageId = 1;
     #nextActionId = 1;
     #activeTurn = Promise.resolve();
+    #activeRequestId = null;
+    #cancellingRequestId = null;
+    #cancellationEpoch = 0;
     #cancellation = Promise.resolve();
     #approvalExecutionId = null;
     #approvalActionId = null;
+    #postExecuteApproval = null;
     #queueStateObserver = null;
     #queuedTurnStartObserver = null;
+    #activeCancelTimeoutMs;
     constructor(deps) {
         this.#sessionId = deps.sessionId;
         this.#startedAt = deps.startedAt;
@@ -37,23 +65,29 @@ export class ConversationAdapter {
         this.#userTurns = deps.userTurns;
         this.#logs = deps.logs;
         this.#approval = deps.approval;
+        this.#pendingInteraction = deps.pendingInteraction ?? null;
         this.#turnFlow = deps.turnFlow;
+        this.#activeCancelTimeoutMs = deps.activeCancelTimeoutMs ?? ACTIVE_CANCEL_TIMEOUT_MS;
         if (deps.queueForeground) {
             const driver = {
                 start: (execution) => this.#startQueuedTurn(execution),
                 cancel: async () => {
-                    await this.#activeTurn;
+                    // Prefer natural abort settlement, but never block queue cancel forever
+                    // if the underlying turn ignores abort.
+                    await Promise.race([
+                        this.#activeTurn.then(() => undefined, () => undefined),
+                        delay(this.#activeCancelTimeoutMs),
+                    ]);
+                    return true;
                 },
             };
             this.#queue = new QueueController({
                 driver,
                 snapshotFactory: (item) => {
-                    if (Date.parse(item.submittedAt) < Date.parse(this.#startedAt)) {
-                        return { requestId: `recovered:${item.id}`, recovered: true };
-                    }
-                    const pending = this.#pendingMessages.shift();
-                    return pending ? { requestId: pending.requestId } : { requestId: `recovered:${item.id}`, recovered: true };
+                    const message = this.#messagesById.get(item.id);
+                    return message ? { requestId: item.id } : { requestId: item.id, recovered: true };
                 },
+                capacity: deps.queueCapacity,
                 persistence: deps.queuePersistence,
             });
         }
@@ -84,6 +118,24 @@ export class ConversationAdapter {
             state.kind === 'cancelling' ||
             state.kind === 'completing');
     }
+    /** Whether the foreground queue owns a new submission's UI lifecycle. */
+    isQueueOwningSubmissions() {
+        if (!this.#queue)
+            return false;
+        const state = this.#queue.state();
+        return state.kind !== 'idle' || state.queue.length > 0;
+    }
+    /**
+     * The queue's current state kind, for diagnostics only.
+     *
+     * `isQueueOwningSubmissions` and `isQueueActive` disagree on several states —
+     * a submission can be owned by the queue (so the UI shows it as queued) while
+     * the queue is not active (so a steer is refused before it is ever offered to
+     * the turn). This names the state so that gap is visible in the logs.
+     */
+    queueStateKind() {
+        return this.#queue ? this.#queue.state().kind : 'none';
+    }
     #notifyQueueState() {
         if (!this.#queue || !this.#queueStateObserver)
             return;
@@ -120,7 +172,146 @@ export class ConversationAdapter {
             firstUserMessagePreview,
         }, fn);
     }
-    async sendMessage(input, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, bypassInputSurgeGuard, replayFromHistory, preferredMessageId, } = {}) {
+    /**
+     * Deliver a user message into the turn already running, as a user message the
+     * model reads after the tool results of the round in flight.
+     *
+     * Resolves true once the running turn has taken it. Resolves false when that
+     * turn offers no further request boundary — it is finishing, or parked on an
+     * approval — leaving the caller to send the message as its own turn.
+     *
+     * `options.id` is the submission's address (see `## The three stages`):
+     * while this call is outstanding, `id` is tracked in `#pendingSteerIds` so
+     * `retractSubmission`/`editSubmission` can route to it. Omitted by the one
+     * caller that has no such id — background subagent notifications, via
+     * `injectIntoActiveTurn` directly — which can never be retracted or edited.
+     */
+    async steerActiveTurn(input, options) {
+        const turn = normalizeUserTurn(input);
+        if (!turn.text.trim() && !turn.images?.length)
+            return false;
+        return this.injectIntoActiveTurn([userTurnToProviderItem(turn, { steering: true })], options);
+    }
+    /**
+     * Hand pre-built items to the turn already running, admitted at its next
+     * request boundary.
+     *
+     * Steering is the user's case of this; a settled background subagent run and
+     * shell-session context are the same act by a different speaker, so they
+     * share the delivery and differ only in the text they carry. Resolves false
+     * when no turn will take them, leaving the caller to deliver them itself.
+     *
+     * Keeps its boolean signature regardless of caller: the run loop's
+     * `SteerOutcome` union is collapsed here to `'admitted' → true`, everything
+     * else `→ false`. Only `retractSubmission`/`editSubmission` need the richer
+     * outcome, and they get it by calling `retractSteer`/`editSteer` directly.
+     */
+    async injectIntoActiveTurn(items, options) {
+        if (!this.#turnFlow.steer || items.length === 0)
+            return false;
+        if (!this.isQueueActive())
+            return false;
+        const id = options?.id;
+        if (id)
+            this.#pendingSteerIds.add(id);
+        try {
+            const outcome = await this.#turnFlow.steer(items, id ? { id } : undefined);
+            return outcome === 'admitted';
+        }
+        finally {
+            if (id)
+                this.#pendingSteerIds.delete(id);
+        }
+    }
+    /**
+     * Retract a submission before it reaches the model, addressed by the id
+     * `sendMessage`/`steerActiveTurn` were given (`preferredMessageId`), which
+     * is the same id the UI already keys `pendingQueuedMessages` on.
+     *
+     * Routes by stage (`## The three stages`): a still-waiting steer goes to
+     * `retractSteer` on the run loop; a queued item goes to the controller's
+     * `remove_queued`.
+     *
+     * A pending steer has no matching `#messagesById` entry to settle — its
+     * caller (`steerActiveTurn`) awaits the `turnFlow.steer` promise directly,
+     * not a queued `sendMessage`. `retractSteer` resolves that promise itself
+     * (with `'retracted'`), which `injectIntoActiveTurn` reports as `false` to
+     * that caller. A queued item, by contrast, *does* have a `sendMessage`
+     * promise parked in `#messagesById`, which this settles with an
+     * `AbortError` — the same shape `removeLastQueuedItem` already used.
+     */
+    async retractSubmission(id) {
+        if (this.#pendingSteerIds.has(id)) {
+            if (!this.#turnFlow.retractSteer) {
+                throw new Error(`ConversationAdapter.retractSubmission: pending steer '${id}' has no turnFlow.retractSteer to route to`);
+            }
+            const retracted = this.#turnFlow.retractSteer(id);
+            if (!retracted)
+                return { kind: 'too_late', stage: 'started' };
+            this.#pendingSteerIds.delete(id);
+            return { kind: 'applied', stage: 'pending_steer' };
+        }
+        if (this.#queue) {
+            const inQueue = this.#queue.state().queue.some((item) => item.id === id);
+            if (inQueue) {
+                const result = await this.#queue.command({ kind: 'remove_queued', itemId: id });
+                if (result.kind !== 'accepted')
+                    return { kind: 'too_late', stage: 'started' };
+                this.#settleFailure(id, queueCancellationError('Queued message was removed'));
+                this.#notifyQueueState();
+                return { kind: 'applied', stage: 'queued' };
+            }
+        }
+        if (this.#messagesById.has(id))
+            return { kind: 'too_late', stage: 'started' };
+        return { kind: 'unknown_id' };
+    }
+    /**
+     * Replace a submission's content in place, without changing its stage or
+     * position — a pending steer stays a steer at its slot, a queued item keeps
+     * its queue index and steer-ahead-of-follow-ups priority.
+     *
+     * **The trap**: the controller queue stores display `text` only.
+     * `#runQueuedTurn` executes `message.input` from `#messagesById`, so
+     * issuing `edit_queued` alone redraws the new text but sends the old turn.
+     * This replaces the `#messagesById` entry's `input` first, keeping the
+     * `QUEUED_NON_TEXT_PLACEHOLDER` substitution `sendMessage` applies to the
+     * controller's display copy.
+     */
+    async editSubmission(id, turn) {
+        if (this.#pendingSteerIds.has(id)) {
+            if (!this.#turnFlow.editSteer) {
+                throw new Error(`ConversationAdapter.editSubmission: pending steer '${id}' has no turnFlow.editSteer to route to`);
+            }
+            const item = userTurnToProviderItem(normalizeUserTurn(turn), { steering: true });
+            const edited = this.#turnFlow.editSteer(id, [item]);
+            return edited ? { kind: 'applied', stage: 'pending_steer' } : { kind: 'too_late', stage: 'started' };
+        }
+        if (this.#queue) {
+            const inQueue = this.#queue.state().queue.some((item) => item.id === id);
+            if (inQueue) {
+                const message = this.#messagesById.get(id);
+                if (!message)
+                    return { kind: 'unknown_id' };
+                this.#messagesById.set(id, { ...message, input: structuredClone(turn) });
+                const displayText = normalizeUserTurn(turn).text;
+                const controllerText = displayText.trim() ? displayText : QUEUED_NON_TEXT_PLACEHOLDER;
+                const result = await this.#queue.command({ kind: 'edit_queued', itemId: id, text: controllerText });
+                if (result.kind !== 'accepted') {
+                    if (this.#messagesById.has(id)) {
+                        this.#messagesById.set(id, message);
+                    }
+                    return { kind: 'too_late', stage: 'started' };
+                }
+                this.#notifyQueueState();
+                return { kind: 'applied', stage: 'queued' };
+            }
+        }
+        if (this.#messagesById.has(id))
+            return { kind: 'too_late', stage: 'started' };
+        return { kind: 'unknown_id' };
+    }
+    async sendMessage(input, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, bypassInputSurgeGuard, replayFromHistory, preferredMessageId, suppressUserMessageDisplay, busyMode, } = {}) {
         const queue = this.#queue;
         if (!queue) {
             return this.#executeMessage(input, {
@@ -131,12 +322,19 @@ export class ConversationAdapter {
                 hallucinationRetryCount,
                 bypassInputSurgeGuard,
                 replayFromHistory,
+            }).then((result) => {
+                this.#recordPendingInteraction(result);
+                return result;
             });
         }
         return new Promise((resolve, reject) => {
             const requestId = preferredMessageId ?? String(this.#nextQueuedMessageId++);
+            if (this.#messagesById.has(requestId)) {
+                reject(new Error(`A queued message already uses request id ${requestId}`));
+                return;
+            }
             const message = {
-                input,
+                input: typeof input === 'string' ? input : structuredClone(input),
                 options: {
                     onTextChunk,
                     onReasoningChunk,
@@ -145,15 +343,28 @@ export class ConversationAdapter {
                     hallucinationRetryCount,
                     bypassInputSurgeGuard,
                     replayFromHistory,
+                    suppressUserMessageDisplay,
+                    busyMode,
                 },
                 resolve,
                 reject,
             };
             this.#messagesById.set(requestId, message);
-            this.#pendingMessages.push({ requestId, message });
+            const displayText = normalizeUserTurn(input).text;
+            const controllerText = displayText.trim() ? displayText : QUEUED_NON_TEXT_PLACEHOLDER;
             void queue
-                .command({ kind: 'submit', text: normalizeUserTurn(input).text || '\u0000queued-message' })
-                .then(() => this.#notifyQueueState());
+                .command({ kind: busyMode === 'steer' ? 'steer' : 'submit', id: requestId, text: controllerText })
+                .then((result) => {
+                if (result.kind !== 'accepted') {
+                    const reason = result.kind === 'rejected' ? result.reason : result.kind;
+                    this.#settleFailure(requestId, new Error(`Foreground queue rejected message: ${reason}`));
+                }
+                this.#notifyQueueState();
+            })
+                .catch((error) => {
+                this.#settleFailure(requestId, error);
+                this.#notifyQueueState();
+            });
         });
     }
     async resumeQueue() {
@@ -166,48 +377,40 @@ export class ConversationAdapter {
     async discardQueue() {
         if (!this.#queue)
             return;
-        await this.#queue.command({ kind: 'discard_queue' });
-        this.#notifyQueueState();
-    }
-    /**
-     * Remove the last (most recently queued) item from the queue and return its
-     * text so the caller can move it back to the input box. Returns null when
-     * the queue is empty, the adapter has no queue (pass-through mode), or the
-     * underlying controller rejects the removal.
-     *
-     * Also pops the matching pending message from the internal pending list so
-     * the queue/pending state observers fire consistently.
-     */
-    async removeLastQueuedItem() {
-        const queue = this.#queue;
-        if (!queue)
-            return null;
-        const state = queue.state();
-        if (state.queue.length === 0)
-            return null;
-        // The queue is FIFO. The "last" queued item is the one at the tail.
-        const lastItem = state.queue[state.queue.length - 1];
-        const result = await queue.command({ kind: 'remove_queued', itemId: lastItem.id });
-        if (result.kind !== 'accepted')
-            return null;
-        // The pending message list is in submission order. The corresponding
-        // pending entry for this item is the last one we added. Removing it keeps
-        // the adapter's internal bookkeeping consistent with the queue controller.
-        this.#pendingMessages.pop();
-        // Note: we don't need to touch #messagesById here because the queue head
-        // has not yet started executing this item (it was still queued), so there
-        // is no pending execution for it to resolve. The pending message entry
-        // was only there to support the snapshot factory if the head was popped.
+        const queuedIds = this.#queue.state().queue.map((item) => item.id);
+        const result = await this.#queue.command({ kind: 'discard_queue' });
+        if (result.kind === 'accepted') {
+            for (const requestId of queuedIds) {
+                this.#settleFailure(requestId, queueCancellationError('Queued message was discarded'));
+            }
+        }
         this.#notifyQueueState();
-        return { text: lastItem.text };
     }
     abort() {
+        this.#cancellationEpoch++;
+        this.#pendingInteraction?.clear();
         if (!this.#queue) {
             this.#turnFlow.abort?.();
             return;
         }
+        // Abort the live model/tool turn, then ask the controller to leave running
+        // and pause with retained work. If the active turn fails to settle on its
+        // own (a hung generator, missing abort hook, etc.), force-settle the active
+        // request so orchestrator awaits cannot stick forever. Retained queued
+        // requests stay pending — pause is not a terminal fate.
+        const activeRequestId = this.#activeRequestId;
+        this.#cancellingRequestId = activeRequestId;
         this.#turnFlow.abort?.();
         this.#cancellation = this.#queue.command({ kind: 'cancel' }).then(() => {
+            if (activeRequestId && this.#messagesById.has(activeRequestId)) {
+                this.#settleFailure(activeRequestId, queueCancellationError('Active turn was cancelled'));
+            }
+            if (this.#activeRequestId === activeRequestId) {
+                this.#activeRequestId = null;
+            }
+            if (this.#cancellingRequestId === activeRequestId) {
+                this.#cancellingRequestId = null;
+            }
             this.#notifyQueueState();
         });
     }
@@ -220,6 +423,7 @@ export class ConversationAdapter {
                 this.#queuedTurnStartObserver({
                     requestId: execution.snapshot.requestId,
                     input: message.input,
+                    suppressUserMessageDisplay: message.options.suppressUserMessageDisplay,
                 });
             }
             catch (error) {
@@ -228,14 +432,31 @@ export class ConversationAdapter {
                 });
             }
         }
-        this.#activeTurn = this.#runQueuedTurn(execution);
+        this.#activeRequestId = execution.snapshot.requestId;
+        this.#activeTurn = this.#runQueuedTurn(execution).finally(() => {
+            if (this.#activeRequestId === execution.snapshot.requestId) {
+                this.#activeRequestId = null;
+            }
+        });
     }
+    /**
+     * Run one foreground queue item.
+     *
+     * Failure policy: a failed active turn emits `failed` to the controller, which
+     * pauses the queue (`reason: 'failure'`) whenever retained work remains. The
+     * next item does not auto-start; the user must resume or discard. Cancellation
+     * of the active turn is the same shape with `reason: 'manual'`.
+     */
     async #runQueuedTurn(execution) {
         const message = this.#messagesById.get(execution.snapshot.requestId);
-        if (message)
-            this.#messagesById.delete(execution.snapshot.requestId);
         try {
-            const result = await this.#executeMessage(message?.input ?? execution.item.text, message?.options ?? {});
+            const recoveredInput = execution.item.text === QUEUED_NON_TEXT_PLACEHOLDER || execution.item.text === LEGACY_QUEUED_MESSAGE_PLACEHOLDER
+                ? null
+                : execution.item.text;
+            if (!message && !recoveredInput) {
+                throw new Error('Recovered queued message has no executable text input');
+            }
+            const result = await this.#executeMessage(message?.input ?? recoveredInput, message?.options ?? {}, execution.snapshot.requestId);
             if (result.type === 'approval_required') {
                 this.#approvalExecutionId = execution.executionId;
                 this.#approvalActionId = `adapter-action-${this.#nextActionId++}`;
@@ -246,21 +467,57 @@ export class ConversationAdapter {
                     request: {}, // existing runtime doesn't expose typed tool request details
                 });
                 this.#notifyQueueState();
-                message?.resolve(result);
+                this.#recordPendingInteraction(result);
+                this.#settleSuccess(execution.snapshot.requestId, result);
                 return;
             }
             await this.#queue.event({ kind: 'completed', executionId: execution.executionId, terminal: result });
             this.#notifyQueueState();
-            message?.resolve(result);
+            this.#recordPendingInteraction(result);
+            this.#settleSuccess(execution.snapshot.requestId, result);
         }
         catch (error) {
-            await this.#queue.event({ kind: 'failed', executionId: execution.executionId, failure: error });
+            const failure = this.#cancellingRequestId === execution.snapshot.requestId &&
+                error instanceof TerminalResultCollectorExhaustionError
+                ? queueCancellationError('Active turn was cancelled')
+                : error;
+            // Controller pauses with retained queue on failure when work remains.
+            await this.#queue.event({ kind: 'failed', executionId: execution.executionId, failure });
             this.#notifyQueueState();
-            message?.reject(error);
+            this.#settleFailure(execution.snapshot.requestId, failure);
         }
     }
-    async #executeMessage(input, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, bypassInputSurgeGuard, replayFromHistory, } = {}) {
+    #settleSuccess(requestId, terminal) {
+        const message = this.#messagesById.get(requestId);
+        if (!message)
+            return;
+        this.#messagesById.delete(requestId);
+        message.resolve(terminal);
+    }
+    #settleFailure(requestId, error) {
+        const message = this.#messagesById.get(requestId);
+        if (!message)
+            return;
+        this.#messagesById.delete(requestId);
+        message.reject(error);
+    }
+    async #collectTerminalResult(events, options, cancellationEpoch, requestId) {
+        try {
+            return await collectTerminalResult(events, options);
+        }
+        catch (error) {
+            const wasCancelled = error instanceof TerminalResultCollectorExhaustionError &&
+                (cancellationEpoch < this.#cancellationEpoch ||
+                    (Boolean(requestId) && this.#cancellingRequestId === requestId));
+            if (wasCancelled) {
+                throw queueCancellationError('Active turn was cancelled');
+            }
+            throw error;
+        }
+    }
+    async #executeMessage(input, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, hallucinationRetryCount = 0, bypassInputSurgeGuard, replayFromHistory, } = {}, requestId) {
         const turn = normalizeUserTurn(input);
+        const cancellationEpoch = this.#cancellationEpoch;
         return this.#withTrafficContext(turn.text, async () => {
             const wrappedOnEvent = (event) => {
                 this.#logs.dispatchEventToLog(event);
@@ -277,7 +534,7 @@ export class ConversationAdapter {
                 if (replayFromHistory) {
                     startOptions.replayFromHistory = true;
                 }
-                result = await collectTerminalResult(this.#turnFlow.start(input, startOptions), {
+                result = await this.#collectTerminalResult(this.#turnFlow.start(input, startOptions), {
                     onTextChunk,
                     onReasoningChunk,
                     onCommandMessage,
@@ -290,7 +547,7 @@ export class ConversationAdapter {
                             usage: event.usage,
                         });
                     },
-                });
+                }, cancellationEpoch, requestId);
             }
             finally {
                 this.#subagentEventSinkHost?.cancelSubagentRuns?.();
@@ -303,25 +560,52 @@ export class ConversationAdapter {
                     usage: result.usage,
                 });
             }
+            this.#postExecuteApproval = result.type === 'approval_required' ? result.approval.postExecute ?? null : null;
             return result;
         });
     }
-    async handleApprovalDecision(answer, rejectionReason, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, approvalAnswer } = {}) {
-        if (!this.#approval.getPending()) {
+    async handleApprovalDecision(answer, rejectionReason, { onTextChunk, onReasoningChunk, onCommandMessage, onEvent, approvalAnswer, stopAfterApprovalResolution, } = {}) {
+        const postExecuteApproval = this.#postExecuteApproval;
+        const pendingApproval = this.#approval.getPending();
+        if (!pendingApproval && !postExecuteApproval) {
             return null;
         }
+        if (postExecuteApproval) {
+            const snapshot = this.#approval.getPostExecutePending();
+            if (snapshot.sessionId !== postExecuteApproval.sessionId || snapshot.epoch !== postExecuteApproval.epoch) {
+                return null;
+            }
+            const decision = this.#approval.decidePostExecutePending({
+                revision: postExecuteApproval.revision,
+                ids: postExecuteApproval.ids,
+                decision: answer === 'y'
+                    ? 'approve'
+                    : answer === 'allow-once' || answer === 'allow-remember' || answer === 'unsandboxed-once'
+                        ? answer
+                        : 'reject',
+            });
+            if (decision.kind !== 'settled')
+                return null;
+            this.#postExecuteApproval = null;
+        }
         if (answer === 'y' && approvalAnswer) {
-            const pending = this.#approval.getPending();
-            const callId = pending ? getCallIdFromObject(pending.interruption) : undefined;
+            const callId = pendingApproval ? getCallIdFromObject(pendingApproval.interruption) : undefined;
             if (callId) {
                 this.#askUserAnswerSink?.setAskUserAnswer(callId, approvalAnswer);
             }
         }
+        // This facade is also used directly by non-interactive callers. Clear the
+        // session projection here as well as through the interactive semantic
+        // resolver, so the continuation API remains self-contained.
+        this.#pendingInteraction?.clear();
         this.#logs.log({
             type: 'approval_resolved',
             answer: answer === 'y' ? 'y' : 'n',
             ...(rejectionReason ? { rejectionReason } : {}),
         });
+        // Capture before resolving the queue action: persistence may await while
+        // an abort invalidates this approval and makes the coordinator idle.
+        const cancellationEpoch = this.#cancellationEpoch;
         try {
             // If queue tracks this approval, resolve the typed action before continuing.
             if (this.#queue && this.#approvalExecutionId && this.#approvalActionId) {
@@ -339,6 +623,20 @@ export class ConversationAdapter {
                     this.#approvalActionId = null;
                 }
             }
+            if (cancellationEpoch < this.#cancellationEpoch) {
+                throw queueCancellationError('Approval decision was cancelled');
+            }
+            // Queue resolution may await persistence while abort/new-turn work replaces
+            // the pending approval. A decision captured for the old approval must not
+            // adopt whichever approval happens to be current when continuation starts.
+            if (!postExecuteApproval) {
+                const currentApproval = this.#approval.getPending();
+                const sameApproval = pendingApproval?.token !== undefined
+                    ? currentApproval?.token === pendingApproval.token
+                    : currentApproval === pendingApproval;
+                if (!sameApproval)
+                    return null;
+            }
             const result = await this.#withTrafficContext(undefined, async () => {
                 const wrappedOnEvent = (event) => {
                     this.#logs.dispatchEventToLog(event);
@@ -348,7 +646,13 @@ export class ConversationAdapter {
                 this.#subagentEventSinkHost?.setSubagentEventSink(wrappedOnEvent);
                 let result;
                 try {
-                    result = await collectTerminalResult(this.#turnFlow.continueAfterApproval({ answer, rejectionReason }), {
+                    result = await this.#collectTerminalResult(postExecuteApproval
+                        ? this.#turnFlow.continueAfterPostExecuteApproval()
+                        : this.#turnFlow.continueAfterApproval({
+                            answer,
+                            rejectionReason,
+                            ...(stopAfterApprovalResolution ? { stopAfterApprovalResolution: true } : {}),
+                        }), {
                         onTextChunk,
                         onReasoningChunk,
                         onCommandMessage,
@@ -361,7 +665,7 @@ export class ConversationAdapter {
                                 usage: event.usage,
                             });
                         },
-                    });
+                    }, cancellationEpoch, this.#activeRequestId);
                 }
                 finally {
                     this.#subagentEventSinkHost?.cancelSubagentRuns?.();
@@ -376,6 +680,7 @@ export class ConversationAdapter {
                 }
                 return result;
             });
+            this.#postExecuteApproval = result?.type === 'approval_required' ? result.approval.postExecute ?? null : null;
             if (result && this.#queue && this.#approvalExecutionId) {
                 const executionId = this.#approvalExecutionId;
                 if (result.type === 'approval_required') {
@@ -399,6 +704,8 @@ export class ConversationAdapter {
                     this.#notifyQueueState();
                 }
             }
+            if (result)
+                this.#recordPendingInteraction(result);
             return result;
         }
         catch (error) {
@@ -412,5 +719,13 @@ export class ConversationAdapter {
             throw error;
         }
     }
+    #recordPendingInteraction(result) {
+        if (result.type === 'approval_required') {
+            this.#pendingInteraction?.present(result.approval);
+        }
+        else {
+            this.#pendingInteraction?.clear();
+        }
+    }
 }
 //# sourceMappingURL=conversation-adapter.js.map