@qduc/term2 0.32.1 → 0.33.0

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

@@ -1,1055 +0,0 @@
-import { isCommittedOutputEvent } from '../conversation/conversation-events.js';
-import { TurnAttempt } from './turn-attempt.js';
-import { getMethod, getCallIdFromObject, getToolInfoFromInterruption } from '../interruption-info.js';
-import { issueInputSurgeApproval } from '../input-surge-approval.js';
-import { ShellAutoApprovalDecisionPolicy } from '../approval/approval-decision-policy.js';
-import { describeError } from '../../utils/error-helpers.js';
-import { classifyProviderFailure, isClassifiedCancellation } from '../retry/provider-failure-classification.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, ToolCallMarkerStore } from '../../utils/streaming/extract-command-messages.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';
-import { resolvePromptCacheKey, resolveSessionId } from './session-identity.js';
-export class TurnWorkflow {
-    deps;
-    /**
-     * Graph registry pinned for the active turn. Re-resolved from the client at
-     * each fresh-turn boundary so post-rebuild turns follow the rebuilt graph,
-     * while in-flight turns and pending-approval continuations keep the graph
-     * that produced their interruptions and tools.
-     */
-    #activePolicyRegistry;
-    #batchCoordinator;
-    #toolCallMarkers;
-    #liveAttemptOwners = new WeakSet();
-    #liveRun = null;
-    #nextLiveRunId = 0;
-    #hookTurnId;
-    /**
-     * The recovery envelope of the initial attempt that started the current
-     * logical turn, if one is active. Continuation attempts (tool-call
-     * follow-ups, and standalone approval-resolution continuations) reuse it so
-     * the whole turn shares one 90s/3-attempt/1-replay budget rather than each
-     * continuation getting its own unbounded allowance.
-     */
-    #activeRecoveryBudget;
-    /**
-     * Set once `context_compaction_failed` has been yielded for the current failure
-     * episode. Recovery replays the same request-boundary failure through both the
-     * initial and continuation catch sites, and without this each replay appends
-     * another identical "Context compaction failed" system message. Cleared at the
-     * next turn boundary (openTurn) and whenever a turn returns an outcome, so a
-     * genuinely separate episode still surfaces.
-     */
-    #compactionFailureNotified = false;
-    /** Pull the client's current graph registry when it has rotated (rebuild). */
-    #syncPolicyRegistry() {
-        const current = this.deps.agentClient?.getApprovalPolicyRegistry?.();
-        if (current && current !== this.#activePolicyRegistry) {
-            this.#activePolicyRegistry = current;
-            this.#batchCoordinator.updatePolicyRegistry(current);
-        }
-    }
-    constructor(deps) {
-        this.deps = deps;
-        this.#activePolicyRegistry = deps.approvalPolicyRegistry;
-        this.#toolCallMarkers = deps.toolCallMarkers ?? new ToolCallMarkerStore();
-        this.#batchCoordinator =
-            deps.batchCoordinator ??
-                new ToolApprovalBatchCoordinator({
-                    approvalFlow: deps.approvalFlow,
-                    planApplier: deps.planApplier,
-                    shellAutoApproval: deps.shellAutoApproval,
-                    logger: deps.logger,
-                    sessionId: deps.sessionId,
-                    sessionAccess: deps.sessionAccess,
-                    policyRegistry: deps.approvalPolicyRegistry,
-                    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.#compactionFailureNotified = false;
-        this.deps.agentClient.openTurn?.();
-    }
-    closeTurn() {
-        this.deps.agentClient.closeTurn?.();
-    }
-    /**
-     * Yields at most one `context_compaction_failed` per failure episode. Returns
-     * undefined (and emits nothing) when the same episode already notified, so
-     * recovery replays of one request-boundary failure render a single UI message.
-     */
-    #compactionFailureEvent(category) {
-        if (this.#compactionFailureNotified)
-            return undefined;
-        this.#compactionFailureNotified = true;
-        return {
-            type: 'context_compaction_failed',
-            provider: 'openai',
-            sessionId: resolveSessionId(this.deps.sessionId),
-            errorCategory: category,
-            durationMs: 0,
-        };
-    }
-    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 = {}) {
-        // Fresh-turn boundary: follow a mid-session rebuild. Continuations
-        // deliberately do not re-sync — a pending approval resolves against the
-        // graph that produced its interruption.
-        this.#syncPolicyRegistry();
-        try {
-            const outcome = yield* this.#executeInitialBody(attemptOrInput, options);
-            // A returned outcome ends the failure episode even when the turn itself
-            // failed; only a thrown error keeps the episode (and the suppression) alive.
-            this.#compactionFailureNotified = false;
-            return outcome;
-        }
-        catch (error) {
-            const failure = contextCompactionFailureCategory(error);
-            if (failure) {
-                const event = this.#compactionFailureEvent(failure);
-                if (event)
-                    yield event;
-            }
-            throw error;
-        }
-    }
-    async *#executeInitialBody(attemptOrInput, options = {}) {
-        let currentInput = attemptOrInput;
-        let currentOptions = options;
-        while (true) {
-            const initialOutcome = yield* this.executeInitialAttempt(currentInput, currentOptions);
-            if (initialOutcome.kind !== 'abort_resolution_required' && initialOutcome.kind !== 'auto_approval_required') {
-                return initialOutcome;
-            }
-            const generation = initialOutcome.generation;
-            let driveResult;
-            if (initialOutcome.kind === 'abort_resolution_required') {
-                driveResult = yield* this.executeContinuationAttempt({
-                    kind: 'abort_resolution',
-                    abortedContext: initialOutcome.abortedContext,
-                    userText: initialOutcome.userText,
-                    generation,
-                }, new ShellAutoApprovalDecisionPolicy(this.deps.shellAutoApproval));
-            }
-            else {
-                driveResult = yield* this.executeContinuationAttempt({
-                    kind: 'approval_decision',
-                    answer: 'y',
-                    generation,
-                }, new ShellAutoApprovalDecisionPolicy(this.deps.shellAutoApproval));
-            }
-            if (driveResult.kind !== 'fresh_start_required') {
-                return driveResult;
-            }
-            currentInput = { text: '' };
-            currentOptions = {
-                skipUserMessage: true,
-                retries: driveResult.retryCounts,
-                delayMs: driveResult.delayMs,
-                useStandardServiceTier: driveResult.useStandardServiceTier,
-                disableChainingForAttempt: driveResult.disableChainingForAttempt,
-                token: generation,
-                replayFromHistory: true,
-            };
-        }
-    }
-    async *executeContinuation(init, policy) {
-        try {
-            const outcome = yield* this.#executeContinuationBodyImpl(init, policy);
-            // A returned outcome ends the failure episode (see executeInitial).
-            this.#compactionFailureNotified = false;
-            return outcome;
-        }
-        catch (error) {
-            const failure = contextCompactionFailureCategory(error);
-            if (failure) {
-                const event = this.#compactionFailureEvent(failure);
-                if (event)
-                    yield event;
-            }
-            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,
-            retries: result.retryCounts,
-            delayMs: result.delayMs,
-            useStandardServiceTier: result.useStandardServiceTier,
-            disableChainingForAttempt: result.disableChainingForAttempt,
-            token: generation,
-            replayFromHistory: true,
-        };
-    }
-    async *#replayFromFreshStart(generation, result) {
-        return yield* this.executeInitial({ text: '' }, this.#freshStartReplayOptions(generation, result));
-    }
-    async *executeInitialAttempt(attemptOrInput, options = {}) {
-        let attempt;
-        if (attemptOrInput instanceof TurnAttempt) {
-            attempt = attemptOrInput;
-        }
-        else {
-            const creation = this.deps.attemptFactory.create(attemptOrInput, options);
-            if (creation.kind === 'stale') {
-                return { kind: 'stale' };
-            }
-            attempt = creation.attempt;
-        }
-        // Continuation attempts driven from within this same logical turn (tool
-        // approvals, abort resolution) reuse this budget instead of getting their
-        // own unbounded one; see #activeRecoveryBudget.
-        this.#activeRecoveryBudget = attempt.recoveryBudget;
-        let skipUser = options.skipUserMessage ?? false;
-        let currentResumeState = options.resumeState;
-        let currentResumePreviousResponseId = options.resumePreviousResponseId;
-        let currentDisableChainingForAttempt = options.disableChainingForAttempt === true;
-        let currentAbortedContext = options.abortedContext ?? null;
-        const initialCounts = attempt.retryCounts;
-        if (options.replayFromHistory ||
-            !skipUser ||
-            initialCounts.modelRetryCount > 0 ||
-            initialCounts.serviceTierFallbackCount > 0 ||
-            initialCounts.transientRetryCount > 0 ||
-            initialCounts.transportDowngradeCount > 0) {
-            this.deps.turnAccumulator.resetPersistedTurnState();
-        }
-        try {
-            if (options.delayMs && options.delayMs > 0) {
-                await this.#waitBeforeRetry(attempt, options.delayMs);
-            }
-            if (!this.deps.generationGuard.isCurrent(attempt.token)) {
-                return { kind: 'stale' };
-            }
-            if (options.useStandardServiceTier) {
-                getMethod(this.deps.agentClient, 'useStandardServiceTierForNextRequest')?.call(this.deps.agentClient);
-            }
-            this.deps.toolTracker.ledger.beginTurn();
-            this.deps.journal.resetForNewTurn();
-            while (true) {
-                // 1. Check generation token validity
-                if (currentAbortedContext) {
-                    const tokenVal = currentAbortedContext.token ?? 0;
-                    if (!this.deps.generationGuard.isCurrent(tokenVal)) {
-                        return { kind: 'stale' };
-                    }
-                }
-                else {
-                    if (!this.deps.generationGuard.isCurrent(attempt.token)) {
-                        return { kind: 'stale' };
-                    }
-                }
-                // 2. Handle aborted-approval resolution
-                if (currentAbortedContext) {
-                    // Preserve the follow-up prompt as a normal user turn so the next
-                    // turn can steer the conversation naturally after an ESC abort.
-                    const preparation = this.deps.inputPreparer.prepare(attempt, skipUser, {
-                        inputSurgeApproval: issueInputSurgeApproval(attempt.submittedTurn),
-                        replayFromHistory: options.replayFromHistory,
-                    });
-                    if (preparation.kind === 'blocked') {
-                        yield preparation.event;
-                        return { kind: 'failed' };
-                    }
-                    this.deps.logger.debug('Resolving aborted approval with fake execution', {
-                        message: attempt.turn.text,
-                    });
-                    return {
-                        kind: 'abort_resolution_required',
-                        abortedContext: currentAbortedContext,
-                        userText: attempt.turn.text,
-                        generation: attempt.token,
-                    };
-                }
-                const preparation = this.deps.inputPreparer.prepare(attempt, skipUser, options);
-                if (preparation.kind === 'blocked') {
-                    yield preparation.event;
-                    return { kind: 'failed' };
-                }
-                try {
-                    const cycleResult = yield* this.#executeInitialStreamCycle(attempt, {
-                        resumeState: currentResumeState,
-                        resumePreviousResponseId: currentResumePreviousResponseId,
-                        disableChainingForAttempt: currentDisableChainingForAttempt,
-                    });
-                    currentDisableChainingForAttempt = false;
-                    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;
-                    attempt.advanceRetry({ ...attempt.retryCounts, transientRetryCount: 0 });
-                    if (outcome.kind === 'response') {
-                        return { kind: 'response', terminal: outcome.result };
-                    }
-                    if (outcome.kind === 'auto_approve') {
-                        if (outcome.advisory?.source === 'llm') {
-                            this.#toolCallMarkers.markToolCallAsLlmAutoApproved(outcome.callId);
-                        }
-                        this.deps.logger.debug('Shell command auto-approved by LLM', {
-                            eventType: 'approval.auto_approved',
-                            category: 'approval',
-                            phase: 'approval',
-                            sessionId: resolveSessionId(this.deps.sessionId),
-                            traceId: this.deps.logger.getCorrelationId(),
-                            callId: outcome.callId,
-                            command: outcome.argumentsText,
-                            model: outcome.advisory?.model,
-                            reasoning: outcome.advisory?.reasoning,
-                        });
-                        return {
-                            kind: 'auto_approval_required',
-                            generation: attempt.token,
-                            callId: outcome.callId,
-                            command: outcome.argumentsText,
-                        };
-                    }
-                    if (outcome.result.approval.callId) {
-                        this.deps.toolTracker.recordFunctionCall({
-                            type: 'function_call',
-                            callId: outcome.result.approval.callId,
-                            name: outcome.result.approval.toolName,
-                            arguments: outcome.result.approval.argumentsText,
-                        });
-                    }
-                    await this.#emitApprovalRequested(outcome.result.approval);
-                    this.deps.logger.debug('Tool approval required', {
-                        eventType: 'approval.required',
-                        category: 'approval',
-                        phase: 'approval',
-                        sessionId: resolveSessionId(this.deps.sessionId),
-                        traceId: this.deps.logger.getCorrelationId(),
-                        toolName: outcome.result.approval.toolName,
-                    });
-                    return { kind: 'approval_required', terminal: outcome.result };
-                }
-                catch (error) {
-                    const handled = yield* this.deps.recoveryHandler.handle({
-                        error,
-                        attempt,
-                        stream: attempt.stream,
-                    });
-                    if (handled.kind === 'run') {
-                        skipUser = handled.instruction.skipUserMessage;
-                        currentResumeState = handled.instruction.resumeState;
-                        currentResumePreviousResponseId = handled.instruction.resumePreviousResponseId;
-                        currentDisableChainingForAttempt = handled.instruction.disableChainingForAttempt === true;
-                        currentAbortedContext = null;
-                        if (handled.delayMs && handled.delayMs > 0) {
-                            await this.#waitBeforeRetry(attempt, handled.delayMs);
-                        }
-                        if (handled.useStandardServiceTier) {
-                            getMethod(this.deps.agentClient, 'useStandardServiceTierForNextRequest')?.call(this.deps.agentClient);
-                        }
-                        continue;
-                    }
-                    else if (handled.kind === 'stale') {
-                        return { kind: 'stale' };
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-            }
-        }
-        finally {
-            // 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) {
-        // 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 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) {
-            if (isCommittedOutputEvent(next.value))
-                attempt.markModelEventSeen();
-            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,
-            reasoningOutputOverride: accumulated.reasoningOutput || undefined,
-            emittedCommandIds: accumulated.emittedCommandIds,
-            usage: accumulated.latestUsage,
-            toolCallArgumentsById: this.deps.toolTracker.argumentsById,
-            turnItems: this.deps.turnAccumulator.getTurnItems(),
-            token: attempt.token,
-            inputMode: attempt.inputMode,
-        }, {
-            approvalFlow: this.deps.approvalFlow,
-            shellAutoApproval: this.deps.shellAutoApproval,
-            logger: this.deps.logger,
-            sessionId: resolveSessionId(this.deps.sessionId),
-            sessionAccess: this.deps.sessionAccess,
-            approvalPolicyRegistry: this.#activePolicyRegistry,
-            toolCallMarkers: this.#toolCallMarkers,
-        });
-        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, generation: attempt.token };
-    }
-    /**
-     * 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: resolveSessionId(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, generation } = result;
-            if (outcome.kind === 'response')
-                return { kind: 'response', terminal: outcome.result };
-            if (outcome.kind === 'approval_required')
-                return { kind: 'approval_required', terminal: outcome.result };
-            if (outcome.kind === 'auto_approve') {
-                // Initial-path parity (`turn-workflow.test.ts:685`): the resumed live
-                // run ended on a shell interruption the auto-approval policy already
-                // approved, so settle exactly as the initial path settles an
-                // `auto_approve` stream result — drive the auto-approval continuation
-                // instead of re-prompting a decision the policy has made. The
-                // generation travels with the live run so the init-less
-                // `continuePostExecute` observer path uses the same token.
-                if (outcome.advisory?.source === 'llm') {
-                    this.#toolCallMarkers.markToolCallAsLlmAutoApproved(outcome.callId);
-                }
-                this.deps.logger.debug('Shell command auto-approved by LLM', {
-                    eventType: 'approval.auto_approved',
-                    category: 'approval',
-                    phase: 'approval',
-                    sessionId: resolveSessionId(this.deps.sessionId),
-                    traceId: this.deps.logger.getCorrelationId(),
-                    callId: outcome.callId,
-                    command: outcome.argumentsText,
-                    model: outcome.advisory?.model,
-                    reasoning: outcome.advisory?.reasoning,
-                });
-                const driveResult = yield* this.executeContinuationAttempt({ kind: 'approval_decision', answer: 'y', generation }, new ShellAutoApprovalDecisionPolicy(this.deps.shellAutoApproval));
-                if (driveResult.kind !== 'fresh_start_required') {
-                    return driveResult;
-                }
-                return yield* this.#replayFromFreshStart(generation, driveResult);
-            }
-            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') {
-            const resumeOptions = {
-                recoveryBudget: attempt.recoveryBudget,
-                previousResponseId: options.resumePreviousResponseId ?? this.deps.providerContinuity.previousResponseId,
-                sessionId: resolveSessionId(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;
-        const selectedPreviousResponseId = legacyPreviousResponseId;
-        const sessionId = resolveSessionId(this.deps.sessionId);
-        const promptCacheKey = resolvePromptCacheKey(this.deps.sessionId);
-        const startOptions = {
-            recoveryBudget: attempt.recoveryBudget,
-            previousResponseId: options.disableChainingForAttempt ? undefined : selectedPreviousResponseId,
-            sessionId,
-            ...(promptCacheKey !== sessionId ? { promptCacheKey } : {}),
-            providerHistorySnapshot: attempt.providerHistorySnapshot,
-            ...(this.#hookTurnId ? { hookTurnId: this.#hookTurnId } : {}),
-            ...(options.disableChainingForAttempt ? { disableChainingForAttempt: true } : {}),
-        };
-        Object.defineProperty(startOptions, 'providerContinuityLineage', {
-            value: this.deps.providerContinuity.lineage,
-            enumerable: this.deps.providerContinuity.lineage !== 0,
-        });
-        return (await this.deps.agentClient.startStream(attempt.streamInput, startOptions));
-    }
-    async #waitBeforeRetry(attempt, delayMs) {
-        if (attempt.signal?.aborted)
-            throw Object.assign(new Error('Operation aborted'), { name: 'AbortError' });
-        if (!attempt.signal) {
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-            return;
-        }
-        await new Promise((resolve, reject) => {
-            const onAbort = () => {
-                clearTimeout(timer);
-                attempt.signal?.removeEventListener('abort', onAbort);
-                reject(Object.assign(new Error('Operation aborted'), { name: 'AbortError' }));
-            };
-            const timer = setTimeout(() => {
-                attempt.signal?.removeEventListener('abort', onAbort);
-                resolve();
-            }, delayMs);
-            attempt.signal.addEventListener('abort', onAbort, { once: true });
-        });
-    }
-    async *executeContinuationAttempt(init, policy) {
-        const activePolicy = policy ?? new ShellAutoApprovalDecisionPolicy(this.deps.shellAutoApproval);
-        if (!this.deps.generationGuard.isCurrent(init.generation)) {
-            return { kind: 'stale' };
-        }
-        const prepared = this.deps.planApplier.prepareInit(init);
-        const state = new ContinuationState(init.generation, this.#activeRecoveryBudget);
-        state.initializeFrom(prepared, this.#activeCallIdsForInit(init, prepared));
-        try {
-            yield* this.deps.planApplier.applyInitialSetup(prepared, state);
-            while (true) {
-                if (!this.deps.generationGuard.isCurrent(state.token)) {
-                    return { kind: 'stale' };
-                }
-                try {
-                    const batchDecision = yield* this.#stagePendingParallelApprovals(state, activePolicy);
-                    if (batchDecision.kind === 'stale') {
-                        return { kind: 'stale' };
-                    }
-                    if (batchDecision.kind === 'approval_required') {
-                        return { kind: 'approval_required', terminal: batchDecision.terminal };
-                    }
-                    const previousInputForSurge = state.inputMode === 'full_history' ? this.deps.conversationStore.getHistory() : undefined;
-                    const cycleResult = yield* this.#executeContinuationStreamCycle(state, init.kind === 'approval_decision' && init.stopAfterApprovalResolution === true);
-                    if (cycleResult.kind === 'stale') {
-                        return { kind: 'stale' };
-                    }
-                    const { outcome, nextCumulativeMessages, nextCumulativeUsage, nextCumulativeTurnItems, mergedEmittedIds } = cycleResult;
-                    state.setRetryCounts({ ...state.retryCounts, transientRetryCount: 0 });
-                    state.setCumulativeUsage(nextCumulativeUsage);
-                    state.setCumulativeCommandMessages(nextCumulativeMessages);
-                    state.setCumulativeTurnItems(nextCumulativeTurnItems);
-                    if (outcome.kind === 'response') {
-                        this.#recordSuccess(state, previousInputForSurge);
-                        return { kind: 'response', terminal: this.#buildResponse(outcome.result, nextCumulativeUsage) };
-                    }
-                    const approvalResult = await this.#handleApprovalOutcome(outcome, state, activePolicy, nextCumulativeUsage, previousInputForSurge);
-                    if (approvalResult.action === 'return') {
-                        return approvalResult.result;
-                    }
-                    if (approvalResult.action === 'loop') {
-                        yield* this.deps.planApplier.applyNextPlan(approvalResult.nextPlan, state, mergedEmittedIds, approvalResult.isApproved);
-                        state.currentCallIds = resolveResponseCycleCallIds({
-                            interruptionCallIds: this.#interruptionCallIds(approvalResult.nextPlan.pendingApprovalContext.state, approvalResult.nextPlan.pendingApprovalContext.interruption),
-                            completedResultCallIds: this.deps.toolTracker.completedResultCallIdsForCurrentTurn(),
-                            fallbackCallIds: state.currentCallIds,
-                            conversationHistory: this.deps.conversationStore.getHistory(),
-                        });
-                    }
-                    continue;
-                }
-                catch (error) {
-                    const recovery = yield* this.#handleContinuationRecovery(error, state);
-                    if (recovery.kind === 'terminated') {
-                        throw error;
-                    }
-                    if (recovery.kind === 'stale') {
-                        return { kind: 'stale' };
-                    }
-                    if (recovery.kind === 'fresh_start') {
-                        return {
-                            kind: 'fresh_start_required',
-                            retryCounts: recovery.retryCounts,
-                            ...(recovery.delayMs !== undefined ? { delayMs: recovery.delayMs } : {}),
-                            ...(recovery.useStandardServiceTier ? { useStandardServiceTier: true } : {}),
-                            ...(recovery.disableChainingForAttempt ? { disableChainingForAttempt: true } : {}),
-                        };
-                    }
-                    // recovery.kind === 'resume' -> continue loop
-                }
-            }
-        }
-        catch (error) {
-            const classification = classifyProviderFailure(error);
-            const cancelled = isClassifiedCancellation(error);
-            const log = cancelled ? this.deps.logger.debug : this.deps.logger.error;
-            log.call(this.deps.logger, cancelled ? 'Conversation stream aborted during continuation' : 'Conversation stream error during continuation', {
-                eventType: cancelled ? 'stream.aborted' : 'stream.failed',
-                category: 'stream',
-                phase: 'abort',
-                sessionId: resolveSessionId(this.deps.sessionId),
-                traceId: this.deps.logger.getCorrelationId(),
-                errorMessage: describeError(error),
-                errorKind: classification.errorKind,
-                stack: error instanceof Error ? error.stack : undefined,
-            });
-            if (!cancelled) {
-                yield {
-                    type: 'error',
-                    message: describeError(error),
-                    ...(error && typeof error === 'object' && 'code' in error && typeof error.code === 'string'
-                        ? { code: error.code }
-                        : {}),
-                    ...(error instanceof Error && error.stack ? { stack: error.stack } : {}),
-                };
-            }
-            throw error;
-        }
-    }
-    async *#stagePendingParallelApprovals(state, activePolicy) {
-        const result = yield* this.#batchCoordinator.stageBatch({
-            state,
-            policy: activePolicy,
-            token: state.token,
-        });
-        if (result.kind === 'stale') {
-            return { kind: 'stale' };
-        }
-        if (result.kind === 'ready') {
-            const pending = this.deps.approvalFlow.getPending?.();
-            state.currentCallIds = resolveResponseCycleCallIds({
-                interruptionCallIds: this.#interruptionCallIds(state.currentState, pending?.interruption),
-                completedResultCallIds: this.deps.toolTracker.completedResultCallIdsForCurrentTurn(),
-                fallbackCallIds: state.currentCallIds,
-                conversationHistory: this.deps.conversationStore.getHistory(),
-                preserveFallback: true,
-            });
-        }
-        return result;
-    }
-    async *#handleContinuationRecovery(error, state) {
-        const recoveryIterator = this.deps.continuationRecoveryHandler.handle({ error, state });
-        let recoveryNext = await recoveryIterator.next();
-        while (!recoveryNext.done) {
-            yield recoveryNext.value;
-            recoveryNext = await recoveryIterator.next();
-        }
-        return recoveryNext.value;
-    }
-    #buildResponse(result, usage) {
-        return {
-            type: 'response',
-            commandMessages: result.commandMessages ?? [],
-            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,
-        };
-    }
-    async #handleApprovalOutcome(outcome, state, activePolicy, nextCumulativeUsage, previousInputForSurge) {
-        const { kind } = outcome;
-        if (kind === 'auto_approve') {
-            if (outcome.advisory?.source === 'llm') {
-                this.#toolCallMarkers.markToolCallAsLlmAutoApproved(outcome.callId);
-            }
-            this.deps.logger.debug('Shell command auto-approved by LLM', {
-                eventType: 'approval.auto_approved',
-                category: 'approval',
-                phase: 'approval',
-                sessionId: resolveSessionId(this.deps.sessionId),
-                traceId: this.deps.logger.getCorrelationId(),
-                callId: outcome.callId,
-                command: outcome.argumentsText,
-                model: outcome.advisory?.model,
-                reasoning: outcome.advisory?.reasoning,
-            });
-            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 } };
-            }
-            return { action: 'loop', nextPlan, isApproved: true };
-        }
-        const approvalContext = {
-            toolName: outcome.result.approval.toolName,
-            argumentsText: outcome.result.approval.argumentsText,
-            callId: outcome.result.approval.callId,
-            llmAdvisory: outcome.result.approval.llmAdvisory,
-        };
-        const decision = await activePolicy.decide(approvalContext);
-        if (decision === 'prompt') {
-            this.deps.planApplier.recordPendingApproval(approvalContext);
-            if (outcome.result.approval.callId) {
-                this.deps.logger.debug('Tool approval required', {
-                    eventType: 'approval.required',
-                    category: 'approval',
-                    phase: 'approval',
-                    sessionId: resolveSessionId(this.deps.sessionId),
-                    traceId: this.deps.logger.getCorrelationId(),
-                    toolName: outcome.result.approval.toolName,
-                });
-            }
-            this.#recordSuccess(state, previousInputForSurge);
-            const resultWithUsage = {
-                ...outcome.result,
-                ...(nextCumulativeUsage && Object.keys(nextCumulativeUsage).length > 0 ? { usage: nextCumulativeUsage } : {}),
-            };
-            return { action: 'return', result: { kind: 'approval_required', terminal: resultWithUsage } };
-        }
-        if (decision === 'approve') {
-            this.deps.logger.debug('Shell command auto-approved by policy', {
-                eventType: 'approval.auto_approved',
-                category: 'approval',
-                phase: 'approval',
-                sessionId: resolveSessionId(this.deps.sessionId),
-                traceId: this.deps.logger.getCorrelationId(),
-                callId: approvalContext.callId,
-                command: approvalContext.argumentsText,
-            });
-        }
-        const answer = decision === 'approve' ? 'y' : 'n';
-        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, stopAfterApprovalResolution = false) {
-        const sessionId = resolveSessionId(this.deps.sessionId);
-        const promptCacheKey = resolvePromptCacheKey(this.deps.sessionId);
-        const continuationOptions = {
-            recoveryBudget: state.recoveryBudget,
-            previousResponseId: state.currentResumePreviousResponseId ?? this.deps.providerContinuity.previousResponseId,
-            sessionId,
-            ...(promptCacheKey !== sessionId ? { promptCacheKey } : {}),
-            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, {
-            gen: state.token,
-            source: state.source,
-            preserveExistingToolArgs: true,
-            previouslyEmittedCommandIds: allEmittedIds,
-        });
-        const finalizeResult = this.deps.streamProcessor.finalize(stream, state.token, state.inputMode, state.source);
-        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(selectAgentStreamItems(stream), this.#toolCallMarkers);
-        const filteredMessages = streamMessages.filter((msg) => !state.previouslyEmittedIds.has(msg.id));
-        const nextCumulativeMessages = [...state.cumulativeCommandMessages, ...filteredMessages];
-        const nextCumulativeUsage = acc.latestUsage ?? state.cumulativeUsage;
-        const nextCumulativeTurnItems = this.deps.turnAccumulator.getTurnItems();
-        const outcome = await buildConversationResult({
-            result: stream,
-            finalOutputOverride: acc.finalOutput || undefined,
-            reasoningOutputOverride: acc.reasoningOutput || undefined,
-            emittedCommandIds: mergedEmittedIds,
-            usage: acc.latestUsage,
-            toolCallArgumentsById: this.deps.toolTracker.argumentsById,
-            turnItems: nextCumulativeTurnItems,
-            token: state.token,
-            inputMode: state.inputMode,
-            cumulativeUsage: nextCumulativeUsage,
-            cumulativeCommandMessages: nextCumulativeMessages,
-            cumulativeTurnItems: nextCumulativeTurnItems,
-        }, {
-            approvalFlow: this.deps.approvalFlow,
-            shellAutoApproval: this.deps.shellAutoApproval,
-            logger: this.deps.logger,
-            sessionId: resolveSessionId(this.deps.sessionId),
-            sessionAccess: this.deps.sessionAccess,
-            approvalPolicyRegistry: this.#activePolicyRegistry,
-            toolCallMarkers: this.#toolCallMarkers,
-        });
-        return {
-            kind: 'completed',
-            outcome,
-            nextCumulativeMessages,
-            nextCumulativeUsage,
-            nextCumulativeTurnItems,
-            mergedEmittedIds,
-        };
-    }
-    #activeCallIdsForInit(init, prepared) {
-        if (init.kind === 'abort_resolution') {
-            return resolveAbortedApprovalCallIds({
-                interruptionCallIds: this.#interruptionCallIds(init.abortedContext.state, init.abortedContext.interruption),
-                completedResultCallIds: this.deps.toolTracker.completedResultCallIdsForCurrentTurn(),
-            });
-        }
-        return resolveResponseCycleCallIds({
-            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);
-        return (liveRun?.completion.then(() => undefined, () => undefined) ?? Promise.resolve());
-    }
-    get activePostExecuteRunId() {
-        return this.#liveRun?.runId ?? null;
-    }
-    #createApprovalRequiredFromAutoApprove(outcome, usage) {
-        const pending = this.deps.approvalFlow.getPending();
-        if (pending) {
-            const { toolName, argumentsText } = getToolInfoFromInterruption(pending.interruption);
-            const agent = pending.interruption && typeof pending.interruption === 'object'
-                ? pending.interruption.agent
-                : undefined;
-            const agentName = agent && typeof agent === 'object' ? agent.name : 'Agent';
-            const callId = getCallIdFromObject(pending.interruption);
-            return createApprovalRequiredTerminal({
-                agentName: typeof agentName === 'string' ? agentName : 'Agent',
-                toolName: toolName ?? 'Unknown Tool',
-                argumentsText,
-                rawInterruption: pending.interruption,
-                callId: callId ? String(callId) : undefined,
-                llmAdvisory: outcome.advisory,
-                usage,
-            });
-        }
-        return createApprovalRequiredTerminal({
-            agentName: 'Agent',
-            toolName: 'Unknown Tool',
-            argumentsText: outcome.argumentsText,
-            rawInterruption: undefined,
-            callId: outcome.callId,
-            llmAdvisory: outcome.advisory,
-            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