@qduc/term2 0.11.1 → 0.13.0

package/dist/services/session/turn-workflow.js

@@ -5,11 +5,20 @@ import { describeError } from '../../utils/error-helpers.js';
 import { ContinuationState } from './continuation-state.js';
 import { ToolApprovalBatchCoordinator } from '../approval/tool-approval-batch-coordinator.js';
 import { createApprovalRequiredTerminal, buildConversationResult, } from '../conversation/conversation-result-builder.js';
+import { selectAgentStreamItems } from '../agent-stream.js';
 import { extractCommandMessages, markToolCallAsLlmAutoApproved, } from '../../utils/streaming/extract-command-messages.js';
-import { resolveAbortedApprovalCallIds, resolveResponseCycleCallIds } from './continuation-call-id-resolver.js';
+import { collectKnownToolCallIds, resolveAbortedApprovalCallIds, resolveResponseCycleCallIds, } from './continuation-call-id-resolver.js';
+import { LiveRun } from './live-run.js';
+import { extractFinalizationSnapshot } from '../stream-snapshot.js';
+import { lastOpenAICompaction } from './session-stream-processor.js';
+import { contextCompactionFailureCategory } from '../../providers/openai-responses-model.js';
 export class TurnWorkflow {
     deps;
     #batchCoordinator;
+    #liveAttemptOwners = new WeakSet();
+    #liveRun = null;
+    #nextLiveRunId = 0;
+    #hookTurnId;
     constructor(deps) {
         this.deps = deps;
         this.#batchCoordinator =
@@ -20,10 +29,57 @@ export class TurnWorkflow {
                     shellAutoApproval: deps.shellAutoApproval,
                     logger: deps.logger,
                     sessionId: deps.sessionId,
+                    sessionAccess: deps.sessionAccess,
                     isCurrent: (token) => deps.generationGuard.isCurrent(token),
+                    hookLifecycle: deps.hookLifecycle,
+                    hookEvents: deps.hookEvents,
                 });
     }
+    /**
+     * Tell the run loop where this turn begins and ends, so a message steered
+     * into it survives the gaps between its streams — the preparation before the
+     * first request, and the backoff before a retry restarts one.
+     */
+    openTurn() {
+        this.deps.agentClient.openTurn?.();
+    }
+    closeTurn() {
+        this.deps.agentClient.closeTurn?.();
+    }
+    steer(items, options) {
+        return this.deps.agentClient.steer?.(items, options) ?? Promise.resolve('released');
+    }
+    /** Drop a still-waiting steer. False when it was already admitted. */
+    retractSteer(id) {
+        return this.deps.agentClient.retractSteer?.(id) ?? false;
+    }
+    /** Replace a waiting steer's items in place, keeping its position. */
+    editSteer(id, items) {
+        return this.deps.agentClient.editSteer?.(id, items) ?? false;
+    }
+    /** Internal composition seam for correlating physical tool calls to a turn. */
+    setHookTurnId(turnId) {
+        this.#hookTurnId = turnId;
+    }
     async *executeInitial(attemptOrInput, options = {}) {
+        try {
+            return yield* this.#executeInitialBody(attemptOrInput, options);
+        }
+        catch (error) {
+            const failure = contextCompactionFailureCategory(error);
+            if (failure) {
+                yield {
+                    type: 'context_compaction_failed',
+                    provider: 'openai',
+                    sessionId: this.deps.sessionId,
+                    errorCategory: failure,
+                    durationMs: 0,
+                };
+            }
+            throw error;
+        }
+    }
+    async *#executeInitialBody(attemptOrInput, options = {}) {
         let currentInput = attemptOrInput;
         let currentOptions = options;
         while (true) {
@@ -63,12 +119,37 @@ export class TurnWorkflow {
         }
     }
     async *executeContinuation(init, policy) {
+        try {
+            return yield* this.#executeContinuationBodyImpl(init, policy);
+        }
+        catch (error) {
+            const failure = contextCompactionFailureCategory(error);
+            if (failure) {
+                yield {
+                    type: 'context_compaction_failed',
+                    provider: 'openai',
+                    sessionId: this.deps.sessionId,
+                    errorCategory: failure,
+                    durationMs: 0,
+                };
+            }
+            throw error;
+        }
+    }
+    async *#executeContinuationBodyImpl(init, policy) {
+        if (this.#liveRun) {
+            return yield* this.#continuePostExecuteRun();
+        }
         const driveResult = yield* this.executeContinuationAttempt(init, policy);
         if (driveResult.kind !== 'fresh_start_required') {
             return driveResult;
         }
         return yield* this.#replayFromFreshStart(init.generation, driveResult);
     }
+    /** Re-observe an already-running post-execute stream without involving SDK approvals. */
+    async *continuePostExecute() {
+        return yield* this.#continuePostExecuteRun();
+    }
     #freshStartReplayOptions(generation, result) {
         return {
             skipUserMessage: true,
@@ -163,10 +244,17 @@ export class TurnWorkflow {
                     const cycleResult = yield* this.#executeInitialStreamCycle(attempt, {
                         resumeState: currentResumeState,
                         resumePreviousResponseId: currentResumePreviousResponseId,
+                        observeOpenAIRootSelectorParity: !options.replayFromHistory &&
+                            !currentResumeState &&
+                            !currentResumePreviousResponseId &&
+                            this.#isFirstAttempt(attempt.retryCounts),
                     });
                     if (cycleResult.kind === 'stale') {
                         return { kind: 'stale' };
                     }
+                    if (cycleResult.kind === 'post_execute_approval_required') {
+                        return { kind: 'approval_required', terminal: this.#postExecuteApprovalTerminal(cycleResult.entries) };
+                    }
                     const { outcome } = cycleResult;
                     if (outcome.kind === 'response') {
                         return { kind: 'response', terminal: outcome.result };
@@ -201,6 +289,7 @@ export class TurnWorkflow {
                             arguments: outcome.result.approval.argumentsText,
                         });
                     }
+                    await this.#emitApprovalRequested(outcome.result.approval);
                     this.deps.logger.debug('Tool approval required', {
                         eventType: 'approval.required',
                         category: 'approval',
@@ -240,21 +329,96 @@ export class TurnWorkflow {
             }
         }
         finally {
-            attempt.close();
+            // A post-execute gate hands this attempt to its live consumer. That task
+            // owns terminal cleanup; closing here would detach abort handling while
+            // the SDK is still waiting at the tool boundary.
+            if (!this.#liveAttemptOwners.has(attempt))
+                attempt.close();
         }
     }
     async *#executeInitialStreamCycle(attempt, options) {
-        const stream = await this.#startInitialStream(attempt, options);
+        // Establish ownership before asking the client for a stream. Some clients
+        // can start consuming synchronously while constructing their stream.
+        const runId = `${this.deps.sessionId}:live:${++this.#nextLiveRunId}`;
+        this.deps.setActivePostExecuteRunId?.(runId);
+        let stream;
+        try {
+            stream = await this.#startInitialStream(attempt, options);
+        }
+        catch (error) {
+            this.deps.setActivePostExecuteRunId?.(null);
+            throw error;
+        }
         attempt.attachStream(stream);
-        const accumulated = yield* this.deps.streamProcessor.process(stream, {
+        const liveRun = new LiveRun(runId, this.deps.postExecutePending, async (emit) => {
+            try {
+                return await this.#consumeInitialStream(stream, attempt, emit);
+            }
+            finally {
+                this.#liveAttemptOwners.delete(attempt);
+                attempt.close();
+            }
+        });
+        this.#liveAttemptOwners.add(attempt);
+        this.#liveRun = liveRun;
+        return yield* this.#drainLiveRun(liveRun);
+    }
+    async *#drainLiveRun(liveRun) {
+        while (true) {
+            let state;
+            try {
+                state = await liveRun.next();
+            }
+            catch (error) {
+                if (this.#liveRun === liveRun) {
+                    this.#liveRun = null;
+                    this.deps.setActivePostExecuteRunId?.(null);
+                }
+                throw error;
+            }
+            if (state.kind === 'event') {
+                yield state.event;
+                continue;
+            }
+            if (state.kind === 'post_execute_approval_required')
+                return state;
+            if (state.kind === 'cancelled') {
+                if (this.#liveRun === liveRun) {
+                    this.#liveRun = null;
+                    this.deps.setActivePostExecuteRunId?.(null);
+                }
+                return { kind: 'stale' };
+            }
+            if (this.#liveRun === liveRun) {
+                this.#liveRun = null;
+                this.deps.setActivePostExecuteRunId?.(null);
+            }
+            return state.result;
+        }
+    }
+    async #consumeInitialStream(stream, attempt, emit) {
+        const processor = this.deps.streamProcessor.process(stream, {
             gen: attempt.token,
             source: 'startStream',
             preserveExistingToolArgs: false,
         });
+        let next = await processor.next();
+        while (!next.done) {
+            emit(next.value);
+            next = await processor.next();
+        }
+        const accumulated = next.value;
         const finalized = this.deps.streamProcessor.finalize(stream, attempt.token, attempt.inputMode, 'startStream');
         if (finalized.kind === 'stale') {
             return { kind: 'stale' };
         }
+        for (const event of this.#contextCompactionCompletedEvent({
+            stream,
+            inputTokensBefore: accumulated.latestUsage?.prompt_tokens,
+            durationMs: accumulated.lastContextCompactionDurationMs,
+        })) {
+            emit(event);
+        }
         const outcome = await buildConversationResult({
             result: stream,
             finalOutputOverride: accumulated.finalOutput || undefined,
@@ -270,23 +434,144 @@ export class TurnWorkflow {
             shellAutoApproval: this.deps.shellAutoApproval,
             logger: this.deps.logger,
             sessionId: this.deps.sessionId,
+            sessionAccess: this.deps.sessionAccess,
         });
         this.deps.inputPlanner.recordSuccess(attempt.inputMode === 'delta' ? attempt.streamInput : this.deps.conversationStore.getHistory(), attempt.inputMode === 'delta'
             ? { kind: attempt.inputMode }
             : { kind: attempt.inputMode, previousInput: attempt.streamInput });
         return { kind: 'completed', outcome };
     }
+    /**
+     * The compaction completion notice.
+     *
+     * `started` is *not* emitted here: it is surfaced live by the stream processor from the
+     * provider's own `output_item.added` frame, which is the only moment that corresponds to
+     * compaction actually beginning. This site owns only the completion, because the token
+     * count it reports comes from `usage`, which the provider does not send until the response
+     * completes — after the compaction frames have already gone by.
+     *
+     * `durationMs` likewise comes from the frames (parked on the accumulator), not from a
+     * clock read here: a `Date.now()` captured at this call site is taken after the stream has
+     * finished, so it would always yield ~0.
+     */
+    #contextCompactionCompletedEvent(args) {
+        const compaction = lastOpenAICompaction(extractFinalizationSnapshot(args.stream).output);
+        if (!compaction)
+            return [];
+        return [
+            {
+                type: 'context_compaction_completed',
+                provider: compaction.provider,
+                sessionId: this.deps.sessionId,
+                ...(args.inputTokensBefore !== undefined ? { inputTokensBefore: args.inputTokensBefore } : {}),
+                // The provider reports no post-compaction size: usage.input_tokens is the
+                // compaction pass's own input, i.e. the pre-compaction total.
+                inputTokensAfter: undefined,
+                durationMs: args.durationMs ?? 0,
+            },
+        ];
+    }
+    async *#continuePostExecuteRun() {
+        const liveRun = this.#liveRun;
+        if (!liveRun) {
+            throw new Error('No live post-execute run active to continue.');
+        }
+        try {
+            const result = yield* this.#drainLiveRun(liveRun);
+            if (result.kind === 'stale')
+                return { kind: 'stale' };
+            if (result.kind === 'post_execute_approval_required') {
+                return { kind: 'approval_required', terminal: this.#postExecuteApprovalTerminal(result.entries) };
+            }
+            const { outcome } = result;
+            if (outcome.kind === 'response')
+                return { kind: 'response', terminal: outcome.result };
+            if (outcome.kind === 'approval_required')
+                return { kind: 'approval_required', terminal: outcome.result };
+            throw new Error('Post-execute live run finished without a terminal outcome.');
+        }
+        catch (error) {
+            this.#liveRun = null;
+            this.deps.setActivePostExecuteRunId?.(null);
+            throw error;
+        }
+    }
+    #postExecuteApprovalTerminal(entries) {
+        const entry = entries[0];
+        const snapshot = this.deps.postExecutePending.snapshot();
+        return createApprovalRequiredTerminal({
+            agentName: 'Agent',
+            toolName: entry.toolName,
+            argumentsText: entry.argumentsText,
+            deniedRead: entry.deniedRead,
+            rawInterruption: { type: 'post_execute', runId: entry.runId, id: entry.id },
+            callId: entry.toolCallId,
+            postExecute: {
+                kind: 'post_execute',
+                sessionId: snapshot.sessionId,
+                epoch: snapshot.epoch,
+                revision: snapshot.revision,
+                ids: [entry.id],
+            },
+        });
+    }
     async #startInitialStream(attempt, options) {
         if (options.resumeState && typeof this.deps.agentClient.continueRunStream === 'function') {
-            return (await this.deps.agentClient.continueRunStream(options.resumeState, {
+            const resumeOptions = {
                 previousResponseId: options.resumePreviousResponseId ?? this.deps.providerContinuity.previousResponseId,
                 sessionId: this.deps.sessionId,
-            }));
+                providerHistorySnapshot: this.deps.conversationStore.getProviderHistorySnapshot(),
+                hookTurnId: this.#hookTurnId,
+            };
+            Object.defineProperty(resumeOptions, 'providerContinuityLineage', {
+                value: this.deps.providerContinuity.lineage,
+                enumerable: this.deps.providerContinuity.lineage !== 0,
+            });
+            return (await this.deps.agentClient.continueRunStream(options.resumeState, resumeOptions));
+        }
+        const legacyPreviousResponseId = attempt.inputMode === 'delta' ? this.deps.providerContinuity.previousResponseId : null;
+        let selectedPreviousResponseId = legacyPreviousResponseId;
+        if (options.observeOpenAIRootSelectorParity &&
+            this.deps.agentClient.getProvider?.() === 'openai' &&
+            legacyPreviousResponseId &&
+            attempt.providerHistorySnapshot) {
+            try {
+                const observation = this.deps.openAIRootFreshTurnSelectorParityObserver?.observe({
+                    legacyPreviousResponseId,
+                    plannedSnapshot: attempt.providerHistorySnapshot,
+                });
+                // This is intentionally an equality-gated ownership handoff: a
+                // checkpoint can only become the selector when it has proved the same
+                // ID the established legacy selector would send for this exact
+                // snapshot. Any absent, ineligible, mismatched, or faulty observation
+                // retains legacy selection.
+                if (observation?.eligible &&
+                    observation.matches &&
+                    observation.acceptedCheckpointResponseId === legacyPreviousResponseId) {
+                    selectedPreviousResponseId = observation.acceptedCheckpointResponseId;
+                }
+            }
+            catch {
+                // Parity must never change the established request path on failure.
+            }
         }
-        return (await this.deps.agentClient.startStream(attempt.streamInput, {
-            previousResponseId: attempt.inputMode === 'delta' ? this.deps.providerContinuity.previousResponseId : null,
+        const startOptions = {
+            previousResponseId: selectedPreviousResponseId,
             sessionId: this.deps.sessionId,
-        }));
+            providerHistorySnapshot: attempt.providerHistorySnapshot,
+            hookTurnId: this.#hookTurnId,
+        };
+        Object.defineProperty(startOptions, 'providerContinuityLineage', {
+            value: this.deps.providerContinuity.lineage,
+            enumerable: this.deps.providerContinuity.lineage !== 0,
+        });
+        return (await this.deps.agentClient.startStream(attempt.streamInput, startOptions));
+    }
+    #isFirstAttempt(retryCounts) {
+        return (retryCounts.transientRetryCount === 0 &&
+            retryCounts.serviceTierFallbackCount === 0 &&
+            retryCounts.modelRetryCount === 0 &&
+            retryCounts.transportDowngradeCount === 0);
     }
     async *executeContinuationAttempt(init, policy) {
         const activePolicy = policy ?? new ShellAutoApprovalDecisionPolicy(this.deps.shellAutoApproval);
@@ -311,7 +596,7 @@ export class TurnWorkflow {
                         return { kind: 'approval_required', terminal: batchDecision.terminal };
                     }
                     const previousInputForSurge = state.inputMode === 'full_history' ? this.deps.conversationStore.getHistory() : undefined;
-                    const cycleResult = yield* this.#executeContinuationStreamCycle(state);
+                    const cycleResult = yield* this.#executeContinuationStreamCycle(state, init.kind === 'approval_decision' && init.stopAfterApprovalResolution === true);
                     if (cycleResult.kind === 'stale') {
                         return { kind: 'stale' };
                     }
@@ -330,8 +615,8 @@ export class TurnWorkflow {
                     if (approvalResult.action === 'loop') {
                         yield* this.deps.planApplier.applyNextPlan(approvalResult.nextPlan, state, mergedEmittedIds, approvalResult.isApproved);
                         state.currentCallIds = resolveResponseCycleCallIds({
-                            runState: approvalResult.nextPlan.pendingApprovalContext.state,
-                            primaryInterruption: approvalResult.nextPlan.pendingApprovalContext.interruption,
+                            interruptionCallIds: this.#interruptionCallIds(approvalResult.nextPlan.pendingApprovalContext.state, approvalResult.nextPlan.pendingApprovalContext.interruption),
+                            completedResultCallIds: this.deps.toolTracker.completedResultCallIdsForCurrentTurn(),
                             fallbackCallIds: state.currentCallIds,
                             conversationHistory: this.deps.conversationStore.getHistory(),
                         });
@@ -375,9 +660,6 @@ export class TurnWorkflow {
             };
             throw error;
         }
-        finally {
-            prepared.removeInterceptor();
-        }
     }
     async *#stagePendingParallelApprovals(state, activePolicy) {
         const result = yield* this.#batchCoordinator.stageBatch({
@@ -391,8 +673,8 @@ export class TurnWorkflow {
         if (result.kind === 'ready') {
             const pending = this.deps.approvalFlow.getPending?.();
             state.currentCallIds = resolveResponseCycleCallIds({
-                runState: state.currentState,
-                primaryInterruption: pending?.interruption,
+                interruptionCallIds: this.#interruptionCallIds(state.currentState, pending?.interruption),
+                completedResultCallIds: this.deps.toolTracker.completedResultCallIdsForCurrentTurn(),
                 fallbackCallIds: state.currentCallIds,
                 conversationHistory: this.deps.conversationStore.getHistory(),
                 preserveFallback: true,
@@ -416,6 +698,10 @@ export class TurnWorkflow {
             finalText: result.finalText,
             ...(result.reasoningText ? { reasoningText: result.reasoningText } : {}),
             ...(usage && Object.keys(usage).length > 0 ? { usage } : {}),
+            // Cost records are run-cumulative, so the continuation cycle must carry
+            // forward what the collector observed; dropping them here silently
+            // unprices every turn that used a tool or paused for approval.
+            ...(result.costRecords?.length ? { costRecords: result.costRecords } : {}),
             turnItems: result.turnItems,
         };
     }
@@ -436,7 +722,7 @@ export class TurnWorkflow {
                 model: outcome.advisory?.model,
                 reasoning: outcome.advisory?.reasoning,
             });
-            const nextPlan = this.deps.approvalFlow.prepareContinuation('y', undefined);
+            const nextPlan = this.deps.approvalFlow.prepareContinuation('y', undefined, 'policy');
             if (!nextPlan) {
                 const approvalFallback = this.#createApprovalRequiredFromAutoApprove(outcome, nextCumulativeUsage);
                 return { action: 'return', result: { kind: 'approval_required', terminal: approvalFallback } };
@@ -481,18 +767,27 @@ export class TurnWorkflow {
             });
         }
         const answer = decision === 'approve' ? 'y' : 'n';
-        const nextPlan = this.deps.approvalFlow.prepareContinuation(answer, undefined);
+        const nextPlan = this.deps.approvalFlow.prepareContinuation(answer, undefined, decision === 'approve' || decision === 'reject' ? 'policy' : 'user');
         if (!nextPlan) {
             return { action: 'return', result: { kind: 'approval_required', terminal: outcome.result } };
         }
         return { action: 'loop', nextPlan, isApproved: answer === 'y' };
     }
-    async *#executeContinuationStreamCycle(state) {
-        const stream = (await this.deps.agentClient.continueRunStream(state.currentState, {
+    async *#executeContinuationStreamCycle(state, stopAfterApprovalResolution = false) {
+        const continuationOptions = {
             previousResponseId: state.currentResumePreviousResponseId ?? this.deps.providerContinuity.previousResponseId,
             sessionId: this.deps.sessionId,
             toolResultCallIds: state.currentCallIds,
-        }));
+            knownToolCallIds: collectKnownToolCallIds(this.deps.conversationStore.getHistory(), this.deps.toolTracker.activeCallIdsForCurrentTurn()),
+            providerHistorySnapshot: this.deps.conversationStore.getProviderHistorySnapshot(),
+            hookTurnId: this.#hookTurnId,
+            ...(stopAfterApprovalResolution ? { stopAfterApprovalResolution: true } : {}),
+        };
+        Object.defineProperty(continuationOptions, 'providerContinuityLineage', {
+            value: this.deps.providerContinuity.lineage,
+            enumerable: this.deps.providerContinuity.lineage !== 0,
+        });
+        const stream = (await this.deps.agentClient.continueRunStream(state.currentState, continuationOptions));
         state.setLastStream(stream);
         const allEmittedIds = new Set([...state.previouslyEmittedIds]);
         const acc = yield* this.deps.streamProcessor.process(stream, {
@@ -505,8 +800,15 @@ export class TurnWorkflow {
         if (finalizeResult.kind === 'stale') {
             return { kind: 'stale' };
         }
+        for (const event of this.#contextCompactionCompletedEvent({
+            stream,
+            inputTokensBefore: acc.latestUsage?.prompt_tokens,
+            durationMs: acc.lastContextCompactionDurationMs,
+        })) {
+            yield event;
+        }
         const mergedEmittedIds = new Set([...allEmittedIds, ...acc.emittedCommandIds]);
-        const streamMessages = extractCommandMessages(stream.newItems || stream.history || []);
+        const streamMessages = extractCommandMessages(selectAgentStreamItems(stream));
         const filteredMessages = streamMessages.filter((msg) => !state.previouslyEmittedIds.has(msg.id));
         const nextCumulativeMessages = [...state.cumulativeCommandMessages, ...filteredMessages];
         const nextCumulativeUsage = acc.latestUsage ?? state.cumulativeUsage;
@@ -529,6 +831,7 @@ export class TurnWorkflow {
             shellAutoApproval: this.deps.shellAutoApproval,
             logger: this.deps.logger,
             sessionId: this.deps.sessionId,
+            sessionAccess: this.deps.sessionAccess,
         });
         return {
             kind: 'completed',
@@ -542,22 +845,48 @@ export class TurnWorkflow {
     #activeCallIdsForInit(init, prepared) {
         if (init.kind === 'abort_resolution') {
             return resolveAbortedApprovalCallIds({
-                runState: init.abortedContext.state,
-                primaryInterruption: init.abortedContext.interruption,
+                interruptionCallIds: this.#interruptionCallIds(init.abortedContext.state, init.abortedContext.interruption),
+                completedResultCallIds: this.deps.toolTracker.completedResultCallIdsForCurrentTurn(),
             });
         }
         return resolveResponseCycleCallIds({
-            runState: prepared.state,
-            primaryInterruption: prepared.interruption,
+            interruptionCallIds: this.#interruptionCallIds(prepared.state, prepared.interruption),
+            completedResultCallIds: this.deps.toolTracker.completedResultCallIdsForCurrentTurn(),
             fallbackCallIds: this.deps.toolTracker.activeCallIdsForCurrentTurn(),
             conversationHistory: this.deps.conversationStore.getHistory(),
         });
     }
+    #interruptionCallIds(state, primaryInterruption) {
+        const callIds = new Set();
+        const interruptions = getMethod(state, 'getInterruptions')?.();
+        if (Array.isArray(interruptions)) {
+            for (const interruption of interruptions) {
+                const callId = getCallIdFromObject(interruption);
+                if (callId) {
+                    callIds.add(callId);
+                }
+            }
+        }
+        const primaryCallId = getCallIdFromObject(primaryInterruption);
+        if (primaryCallId) {
+            callIds.add(primaryCallId);
+        }
+        return [...callIds];
+    }
     #recordSuccess(state, previousInputForSurge) {
         this.deps.inputPlanner.recordSuccess(state.inputMode === 'delta' ? state.lastStream : this.deps.conversationStore.getHistory(), state.inputMode === 'delta'
             ? { kind: state.inputMode }
             : { kind: state.inputMode, previousInput: previousInputForSurge });
     }
+    abortLiveRun() {
+        const liveRun = this.#liveRun;
+        this.#liveRun = null;
+        liveRun?.cancel();
+        this.deps.setActivePostExecuteRunId?.(null);
+    }
+    get activePostExecuteRunId() {
+        return this.#liveRun?.runId ?? null;
+    }
     #createApprovalRequiredFromAutoApprove(outcome, usage) {
         const pending = this.deps.approvalFlow.getPending();
         if (pending) {
@@ -587,5 +916,26 @@ export class TurnWorkflow {
             usage,
         });
     }
+    async #emitApprovalRequested(approval) {
+        if (!this.deps.hookLifecycle || !this.deps.hookEvents)
+            return;
+        let normalizedArguments = approval.argumentsText;
+        try {
+            normalizedArguments = JSON.parse(approval.argumentsText);
+        }
+        catch {
+            // Preserve a bounded opaque representation for malformed model input.
+        }
+        await this.deps.hookLifecycle.emit(this.deps.hookEvents.create('approval.requested', {
+            toolName: approval.toolName,
+            normalizedArguments: this.deps.hookEvents.includeToolArguments
+                ? normalizedArguments
+                : typeof normalizedArguments === 'string'
+                    ? normalizedArguments.slice(0, 500)
+                    : JSON.stringify(normalizedArguments).slice(0, 500),
+            approvalKind: approval.toolName === 'ask_user' ? 'ask_user' : 'tool',
+            proposedDecision: 'approve',
+        }, { toolCallId: approval.callId }));
+    }
 }
 //# sourceMappingURL=turn-workflow.js.map