@aria-cli/cli 1.0.50 → 1.0.52

package/dist/headless/run-orchestrator.js

@@ -0,0 +1,703 @@
+import { randomUUID } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+import { setStallPhase, clearStallPhase } from "../event-loop-watchdog.js";
+import { resolveTrustedRuntimeErrorMessage } from "@aria-cli/tools";
+import { fromModelMessages } from "../history/conversation-message.js";
+const SESSION_LEASE_MS = 30_000;
+const SESSION_LEASE_RENEW_INTERVAL_MS = 10_000;
+function initialRunSynthesisState() {
+    return {
+        output: "",
+        messages: [],
+        toolCalls: [],
+        usage: undefined,
+        turnCount: 0,
+        thinking: [],
+        nativeToolResults: [],
+        pipelineTiming: undefined,
+        guardrailEvents: [],
+        handoffs: [],
+        pausedState: null,
+    };
+}
+function synthesizeRunResult(state) {
+    return {
+        success: !state.pausedState,
+        ...(state.output ? { output: state.output } : {}),
+        ...(state.messages.length > 0 ? { messages: state.messages } : {}),
+        ...(state.toolCalls.length > 0 ? { toolCalls: state.toolCalls } : {}),
+        ...(state.usage !== undefined ? { usage: state.usage } : {}),
+        ...(state.turnCount > 0 ? { turnCount: state.turnCount } : {}),
+        ...(state.thinking.length > 0 ? { thinking: state.thinking } : {}),
+        ...(state.nativeToolResults.length > 0 ? { nativeToolResults: state.nativeToolResults } : {}),
+        ...(state.pipelineTiming !== undefined ? { pipelineTiming: state.pipelineTiming } : {}),
+        ...(state.guardrailEvents.length > 0 ? { guardrailEvents: state.guardrailEvents } : {}),
+        ...(state.handoffs.length > 0 ? { handoffs: state.handoffs } : {}),
+        ...(state.pausedState ? { state: state.pausedState } : {}),
+    };
+}
+function toHeadlessError(code, message, details) {
+    return {
+        code,
+        message,
+        ...(details ? { details } : {}),
+    };
+}
+function toFailureResult(requestId, op, code, message, details) {
+    return {
+        kind: "result",
+        requestId,
+        op,
+        ok: false,
+        error: toHeadlessError(code, message, details),
+    };
+}
+function toSuccessResult(requestId, op, result) {
+    return {
+        kind: "result",
+        requestId,
+        op,
+        ok: true,
+        result,
+    };
+}
+function buildPolicySnapshot(request) {
+    return {
+        ...(request.arion ? { arion: request.arion } : {}),
+        ...(request.cwd ? { cwd: request.cwd } : {}),
+        ...(request.requestedModel ? { requestedModel: request.requestedModel } : {}),
+        ...(request.preferredTier ? { preferredTier: request.preferredTier } : {}),
+        ...(typeof request.budget === "number" ? { budget: request.budget } : {}),
+        ...(typeof request.maxTurns === "number" ? { maxTurns: request.maxTurns } : {}),
+        ...(request.autonomy ? { autonomy: request.autonomy } : {}),
+        ...(request.allowedTools ? { allowedTools: request.allowedTools } : {}),
+        ...(request.deniedTools ? { deniedTools: request.deniedTools } : {}),
+        ...(typeof request.noMemory === "boolean" ? { noMemory: request.noMemory } : {}),
+        ...(request.systemPrompt ? { systemPrompt: request.systemPrompt } : {}),
+    };
+}
+function applySessionArionToRunRequest(request, sessionArion) {
+    if (request.arion || !sessionArion) {
+        return request;
+    }
+    return {
+        ...request,
+        arion: sessionArion,
+    };
+}
+function toRuntimeRunRequest(request) {
+    const { sessionId: _sessionId, ...runtimeRequest } = request;
+    return runtimeRequest;
+}
+function toRuntimeResumeRequest(request) {
+    const { sessionId: _sessionId, ...runtimeRequest } = request;
+    return runtimeRequest;
+}
+function applySessionModelToRunRequest(request, sessionModel) {
+    if (request.requestedModel || !sessionModel) {
+        return request;
+    }
+    return {
+        ...request,
+        requestedModel: sessionModel,
+    };
+}
+function persistTranscript(sessionLedger, sessionId, messages) {
+    if (!Array.isArray(messages) || messages.length === 0) {
+        return;
+    }
+    sessionLedger.replaceConversationMessages(sessionId, fromModelMessages(messages));
+}
+function buildInteractionRequest(requestId, sessionId, pausedState) {
+    if ((pausedState.pendingUserQuestions?.length ?? 0) > 0) {
+        const interactionId = `${sessionId}:questionnaire:${randomUUID()}`;
+        const interaction = {
+            kind: "questionnaire",
+            questions: pausedState.pendingUserQuestions ?? [],
+        };
+        return {
+            record: {
+                interactionId,
+                requestId,
+                source: "run",
+                kind: interaction.kind,
+                prompt: interaction,
+            },
+            frame: {
+                kind: "interaction.required",
+                requestId,
+                interactionId,
+                source: "run",
+                interaction,
+            },
+        };
+    }
+    if ((pausedState.pendingToolCalls?.length ?? 0) > 0) {
+        const pendingTool = pausedState.pendingToolCalls[0];
+        const interactionId = `${sessionId}:tool-approval:${randomUUID()}`;
+        const interaction = {
+            kind: "tool_approval",
+            toolName: pendingTool.name,
+            toolInput: pendingTool.arguments,
+            prompt: `Approval required for ${pendingTool.name}`,
+        };
+        return {
+            record: {
+                interactionId,
+                requestId,
+                source: "run",
+                kind: interaction.kind,
+                prompt: interaction,
+            },
+            frame: {
+                kind: "interaction.required",
+                requestId,
+                interactionId,
+                source: "run",
+                interaction,
+            },
+        };
+    }
+    return null;
+}
+function buildResumeRequestFromInteraction(pausedState, interaction, response, runtimeStateRevision, runtimeStatePolicySnapshot) {
+    const baseRequest = {
+        state: pausedState,
+        ...(runtimeStatePolicySnapshot ?? {}),
+    };
+    if (interaction.kind === "tool_approval") {
+        if (response.response.kind !== "confirm") {
+            throw new Error(`Interaction ${interaction.interactionId} requires a confirm response`);
+        }
+        return {
+            ...baseRequest,
+            approvalMode: response.response.approved ? "approve" : "deny",
+            // Preserve a revision breadcrumb for diagnostics only; ignored by schema consumers.
+            ...(runtimeStateRevision >= 0 ? {} : {}),
+        };
+    }
+    if (interaction.kind === "questionnaire") {
+        if (response.response.kind !== "questionnaire") {
+            throw new Error(`Interaction ${interaction.interactionId} requires a questionnaire response`);
+        }
+        return {
+            ...baseRequest,
+            askUserAnswers: response.response.answers,
+        };
+    }
+    throw new Error(`Unsupported run interaction kind ${interaction.kind}`);
+}
+export class HeadlessRunOrchestrator {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    renewSessionLease(sessionId, ownerId) {
+        const ledger = this.ctx.sessionLedger;
+        if (typeof ledger.renewSessionClaim === "function") {
+            return ledger.renewSessionClaim(sessionId, ownerId, SESSION_LEASE_MS);
+        }
+        return ledger.claimSessionForMutation(sessionId, ownerId, SESSION_LEASE_MS);
+    }
+    clearRunningSession(sessionId, ownerId, expectedRevision) {
+        const ledger = this.ctx.sessionLedger;
+        if (typeof ledger.clearActiveRun === "function") {
+            return ledger.clearActiveRun(sessionId, { ownerId, expectedRevision });
+        }
+        return ledger.completeRun(sessionId, {}, { ownerId, expectedRevision });
+    }
+    releaseClaimOnce(sessionId, ownerId) {
+        let released = false;
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
+        };
+    }
+    static isAbortError(error) {
+        return (error instanceof Error &&
+            (error.name === "AbortError" ||
+                error.message === "The operation was aborted" ||
+                error.message === "This operation was aborted"));
+    }
+    static createAbortReason(code, message) {
+        const error = new Error(message);
+        error.name = "AbortError";
+        error.code = code;
+        return error;
+    }
+    static getAbortCode(signal, error) {
+        const candidate = signal?.aborted ? signal.reason : error;
+        if (candidate &&
+            typeof candidate === "object" &&
+            "code" in candidate &&
+            typeof candidate.code === "string") {
+            return candidate.code;
+        }
+        return signal?.aborted || HeadlessRunOrchestrator.isAbortError(error) ? "RUN_ABORTED" : null;
+    }
+    static getAbortMessage(signal, error) {
+        const candidate = signal?.aborted ? signal.reason : error;
+        if (candidate instanceof Error && candidate.message) {
+            return candidate.message;
+        }
+        return "Run aborted before completion.";
+    }
+    async *start(requestId, request, signal) {
+        const sessionId = request.sessionId?.trim() || requestId;
+        const ownerId = `headless:${requestId}`;
+        const sessionModel = this.ctx.getSessionModel?.();
+        const sessionArion = this.ctx.getSessionArion?.();
+        const effectiveRequest = applySessionModelToRunRequest(applySessionArionToRunRequest(request, sessionArion), sessionModel);
+        const arionName = effectiveRequest.arion ?? this.ctx.getSessionArion?.() ?? "ARIA";
+        const model = effectiveRequest.requestedModel ?? effectiveRequest.preferredTier ?? "balanced";
+        const policySnapshot = buildPolicySnapshot(effectiveRequest);
+        if (!this.ctx.sessionLedger.loadSession(sessionId)) {
+            this.ctx.sessionLedger.createSession(arionName, model, sessionId);
+        }
+        let claimed = this.ctx.sessionLedger.claimSessionForMutation(sessionId, ownerId, 30_000);
+        const releaseClaim = this.releaseClaimOnce(sessionId, ownerId);
+        const state = initialRunSynthesisState();
+        const controller = new AbortController();
+        let releaseExternalAbort = null;
+        let renewalTimer = null;
+        // Deferred persistence closure — captured in the success path, executed
+        // from the finally block via setTimeout(0). This architectural boundary
+        // ensures persistence (DELETE+INSERT of entire transcript) NEVER blocks
+        // the consumer from receiving the result frame and updating the UI.
+        let deferredPersistence = null;
+        if (signal) {
+            const onAbort = () => {
+                controller.abort(HeadlessRunOrchestrator.createAbortReason("CONNECTION_CLOSED", "Connection closed before request completed"));
+            };
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener("abort", onAbort, { once: true });
+                releaseExternalAbort = () => signal.removeEventListener("abort", onAbort);
+            }
+        }
+        renewalTimer = setInterval(() => {
+            try {
+                claimed = this.renewSessionLease(sessionId, ownerId);
+            }
+            catch (error) {
+                controller.abort(HeadlessRunOrchestrator.createAbortReason("SESSION_LEASE_LOST", error instanceof Error ? error.message : String(error)));
+            }
+        }, SESSION_LEASE_RENEW_INTERVAL_MS);
+        try {
+            for await (const event of this.ctx.localControl.streamRun(toRuntimeRunRequest(effectiveRequest), controller.signal)) {
+                if (controller.signal.aborted) {
+                    releaseClaim();
+                    return;
+                }
+                this.consumeRunEvent(state, event);
+                yield {
+                    kind: "event",
+                    requestId,
+                    seq: state.turnCount + state.toolCalls.length + state.thinking.length,
+                    op: "run.start",
+                    event,
+                };
+            }
+            if (controller.signal.aborted) {
+                persistTranscript(this.ctx.sessionLedger, sessionId, state.messages);
+                this.clearRunningSession(sessionId, ownerId, claimed.revision);
+                releaseClaim();
+                const abortCode = HeadlessRunOrchestrator.getAbortCode(controller.signal);
+                if (abortCode !== "CONNECTION_CLOSED") {
+                    yield toFailureResult(requestId, "run.start", abortCode ?? "RUN_ABORTED", HeadlessRunOrchestrator.getAbortMessage(controller.signal), { sessionId, runId: `run:${sessionId}` });
+                }
+                return;
+            }
+            if (state.pausedState) {
+                persistTranscript(this.ctx.sessionLedger, sessionId, state.pausedState.messages);
+                const interaction = buildInteractionRequest(requestId, sessionId, state.pausedState);
+                this.ctx.sessionLedger.recordPausedRun(sessionId, `run:${sessionId}`, state.pausedState, policySnapshot, interaction?.record, {
+                    ownerId,
+                    expectedRevision: claimed.revision,
+                });
+                releaseClaim();
+                if (interaction) {
+                    yield interaction.frame;
+                }
+                yield toFailureResult(requestId, "run.start", "INTERACTION_REQUIRED", "Run paused and requires interaction before it can continue.", {
+                    sessionId,
+                    ...(interaction
+                        ? {
+                            interactionId: interaction.frame.interactionId,
+                            source: interaction.frame.source,
+                            interaction: interaction.frame.interaction,
+                        }
+                        : {}),
+                });
+                return;
+            }
+            const result = synthesizeRunResult(state);
+            // Yield result BEFORE persistence — the consumer must receive the result
+            // frame without waiting for SQLite writes. persistTranscript does
+            // DELETE + INSERT for the entire conversation transcript, which blocks
+            // the event loop for 100-500ms on long conversations. Deferring it to
+            // the finally block (via setTimeout) ensures the consumer's for-await
+            // loop exits immediately after this yield.
+            deferredPersistence = () => {
+                const msgCount = Array.isArray(result.messages) ? result.messages.length : 0;
+                setStallPhase(`orchestrator:persistTranscript(${msgCount} msgs)`);
+                const _pt0 = performance.now();
+                persistTranscript(this.ctx.sessionLedger, sessionId, result.messages);
+                const _pt1 = performance.now();
+                setStallPhase("orchestrator:completeRun");
+                this.ctx.sessionLedger.completeRun(sessionId, result, {
+                    ownerId,
+                    expectedRevision: claimed.revision,
+                });
+                const _pt2 = performance.now();
+                clearStallPhase();
+                releaseClaim();
+                const _total = _pt2 - _pt0;
+                if (_total > 100) {
+                    try {
+                        process.stderr.write(`[Orchestrator][DIAG] deferredPersistence: ` +
+                            `total=${_total.toFixed(0)}ms transcript=${(_pt1 - _pt0).toFixed(0)}ms ` +
+                            `completeRun=${(_pt2 - _pt1).toFixed(0)}ms msgs=${msgCount}\n`);
+                    }
+                    catch {
+                        /* best effort */
+                    }
+                }
+            };
+            yield toSuccessResult(requestId, "run.start", result);
+        }
+        catch (error) {
+            try {
+                if (controller.signal.aborted || HeadlessRunOrchestrator.isAbortError(error)) {
+                    persistTranscript(this.ctx.sessionLedger, sessionId, state.messages);
+                    this.clearRunningSession(sessionId, ownerId, claimed.revision);
+                }
+                releaseClaim();
+            }
+            catch {
+                // Best effort cleanup on failure.
+            }
+            if (controller.signal.aborted || HeadlessRunOrchestrator.isAbortError(error)) {
+                const abortCode = HeadlessRunOrchestrator.getAbortCode(controller.signal, error);
+                if (abortCode !== "CONNECTION_CLOSED") {
+                    yield toFailureResult(requestId, "run.start", abortCode ?? "RUN_ABORTED", HeadlessRunOrchestrator.getAbortMessage(controller.signal, error), { sessionId, runId: `run:${sessionId}` });
+                }
+                return;
+            }
+            yield toFailureResult(requestId, "run.start", "RUN_START_FAILED", error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            if (renewalTimer) {
+                clearInterval(renewalTimer);
+            }
+            releaseExternalAbort?.();
+            // Execute deferred persistence from the success path. Scheduled via
+            // setTimeout(0) so it runs AFTER React's microtask render cycle —
+            // the consumer sets isStreaming=false and yields, React renders the
+            // input area, THEN persistence runs. This makes it structurally
+            // impossible for transcript persistence to block the UI transition.
+            if (deferredPersistence) {
+                const persist = deferredPersistence;
+                deferredPersistence = null;
+                setTimeout(() => {
+                    try {
+                        setStallPhase("orchestrator:deferredPersistence");
+                        const dpT0 = performance.now();
+                        persist();
+                        const dpElapsed = performance.now() - dpT0;
+                        clearStallPhase();
+                        if (dpElapsed > 200) {
+                            try {
+                                process.stderr.write(`[Orchestrator][DIAG] deferredPersistence blocked ${dpElapsed.toFixed(0)}ms\n`);
+                            }
+                            catch {
+                                /* best effort */
+                            }
+                        }
+                    }
+                    catch {
+                        clearStallPhase();
+                        // Non-fatal: consumer already has the result frame.
+                        // Crash recovery handles stale session state on next startup.
+                        releaseClaim();
+                    }
+                }, 0);
+            }
+        }
+    }
+    async *resume(requestId, request, signal) {
+        const sessionId = request.sessionId?.trim();
+        const ownerId = `headless:${requestId}`;
+        const sessionModel = this.ctx.getSessionModel?.();
+        const sessionArion = this.ctx.getSessionArion?.();
+        const effectiveRequest = applySessionModelToRunRequest(applySessionArionToRunRequest(request, sessionArion), sessionModel);
+        const runtimeRequest = toRuntimeResumeRequest(effectiveRequest);
+        const policySnapshot = buildPolicySnapshot(runtimeRequest);
+        let createdSession = false;
+        let claimed = null;
+        try {
+            if (signal?.aborted) {
+                return;
+            }
+            if (sessionId) {
+                if (!this.ctx.sessionLedger.loadSession(sessionId)) {
+                    this.ctx.sessionLedger.createSession(effectiveRequest.arion ?? this.ctx.getSessionArion?.() ?? "ARIA", effectiveRequest.requestedModel ?? effectiveRequest.preferredTier ?? "balanced", sessionId);
+                    createdSession = true;
+                }
+                claimed = this.ctx.sessionLedger.claimSessionForMutation(sessionId, ownerId, 30_000);
+            }
+            const result = await this.ctx.localControl.resumeRun(runtimeRequest);
+            if (signal?.aborted) {
+                if (sessionId && claimed) {
+                    this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
+                    if (createdSession) {
+                        this.ctx.sessionLedger.deleteSession(sessionId);
+                    }
+                }
+                return;
+            }
+            if (sessionId && claimed) {
+                if (result.state) {
+                    const pausedState = result.state;
+                    persistTranscript(this.ctx.sessionLedger, sessionId, pausedState.messages);
+                    const nextInteraction = buildInteractionRequest(requestId, sessionId, pausedState);
+                    this.ctx.sessionLedger.recordPausedRun(sessionId, `run:${sessionId}`, pausedState, policySnapshot, nextInteraction?.record, {
+                        ownerId,
+                        expectedRevision: claimed.revision,
+                    });
+                    this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
+                    if (nextInteraction) {
+                        yield nextInteraction.frame;
+                    }
+                    yield toFailureResult(requestId, "run.resume", "INTERACTION_REQUIRED", "Run paused and requires interaction before it can continue.", {
+                        sessionId,
+                        ...(nextInteraction
+                            ? {
+                                interactionId: nextInteraction.frame.interactionId,
+                                source: nextInteraction.frame.source,
+                                interaction: nextInteraction.frame.interaction,
+                            }
+                            : {}),
+                    });
+                    return;
+                }
+                persistTranscript(this.ctx.sessionLedger, sessionId, result.messages);
+                this.ctx.sessionLedger.completeRun(sessionId, result, {
+                    ownerId,
+                    expectedRevision: claimed.revision,
+                });
+                this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
+            }
+            yield toSuccessResult(requestId, "run.resume", result);
+        }
+        catch (error) {
+            if (sessionId && claimed) {
+                try {
+                    this.ctx.sessionLedger.releaseSessionClaim(sessionId, ownerId);
+                    if (createdSession) {
+                        this.ctx.sessionLedger.deleteSession(sessionId);
+                    }
+                }
+                catch {
+                    // Best effort cleanup.
+                }
+            }
+            if (signal?.aborted || HeadlessRunOrchestrator.isAbortError(error)) {
+                return;
+            }
+            yield toFailureResult(requestId, "run.resume", "RUN_RESUME_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    async *abort(requestId, input, activeRunController) {
+        const aborted = await (activeRunController ?? this.ctx.activeRunController)?.abort(input);
+        if (aborted) {
+            yield {
+                kind: "result",
+                requestId,
+                op: "run.abort",
+                ok: true,
+                result: {
+                    aborted: true,
+                    ...(input.runId ? { runId: input.runId } : {}),
+                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+                },
+            };
+            return;
+        }
+        yield toFailureResult(requestId, "run.abort", "RUN_NOT_FOUND", "No active run matched the requested runId or sessionId.", {
+            ...(input.runId ? { runId: input.runId } : {}),
+            ...(input.sessionId ? { sessionId: input.sessionId } : {}),
+        });
+    }
+    async *respond(response, signal) {
+        const interaction = this.ctx.sessionLedger.getInteraction(response.interactionId);
+        if (!interaction) {
+            yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_NOT_FOUND", `Unknown interaction ${response.interactionId}`);
+            return;
+        }
+        if (interaction.source !== "run") {
+            yield toFailureResult(response.requestId, "interaction.respond", "UNSUPPORTED_INTERACTION_SOURCE", `Interaction source ${interaction.source} is not handled by the run orchestrator`);
+            return;
+        }
+        const runtimeState = this.ctx.sessionLedger.getSessionRuntimeState(interaction.sessionId);
+        if (!runtimeState?.pausedState) {
+            yield toFailureResult(response.requestId, "interaction.respond", "SESSION_NOT_PAUSED", `Session ${interaction.sessionId} is not paused`);
+            return;
+        }
+        const ownerId = `headless:${response.requestId}`;
+        try {
+            if (signal?.aborted) {
+                return;
+            }
+            const claimed = this.ctx.sessionLedger.claimSessionForMutation(interaction.sessionId, ownerId, 30_000);
+            let effectiveResponse = response.response;
+            let responseRevision = claimed.revision;
+            if (interaction.status === "pending") {
+                this.ctx.sessionLedger.recordInteractionResponse(interaction.sessionId, interaction.interactionId, effectiveResponse, {
+                    ownerId,
+                    expectedRevision: claimed.revision,
+                });
+                responseRevision += 1;
+            }
+            else if (interaction.status === "answered") {
+                if (!interaction.response) {
+                    this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
+                    yield toFailureResult(response.requestId, "interaction.respond", "INVALID_INTERACTION_STATE", `Interaction ${interaction.interactionId} is missing its recorded response`);
+                    return;
+                }
+                if (!isDeepStrictEqual(interaction.response, effectiveResponse)) {
+                    this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
+                    yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_ALREADY_ANSWERED", `Interaction ${interaction.interactionId} was already answered with a different response`);
+                    return;
+                }
+                effectiveResponse = interaction.response;
+            }
+            else {
+                this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
+                yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_NOT_PENDING", `Interaction ${interaction.interactionId} is not resumable in state ${interaction.status}`);
+                return;
+            }
+            const resumeRequest = buildResumeRequestFromInteraction(runtimeState.pausedState, interaction, {
+                ...response,
+                response: effectiveResponse,
+            }, runtimeState.revision, runtimeState.policySnapshot);
+            const result = await this.ctx.localControl.resumeRun(resumeRequest);
+            if (signal?.aborted) {
+                this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
+                return;
+            }
+            if (result.state) {
+                const pausedState = result.state;
+                persistTranscript(this.ctx.sessionLedger, interaction.sessionId, pausedState.messages);
+                const nextInteraction = buildInteractionRequest(response.requestId, interaction.sessionId, pausedState);
+                this.ctx.sessionLedger.recordPausedRun(interaction.sessionId, runtimeState.activeRunId ?? `run:${interaction.sessionId}`, pausedState, runtimeState.policySnapshot ?? {}, nextInteraction?.record, {
+                    ownerId,
+                    expectedRevision: responseRevision,
+                });
+                this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
+                if (nextInteraction) {
+                    yield nextInteraction.frame;
+                }
+                yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_REQUIRED", "Run paused again and requires another interaction.", {
+                    sessionId: interaction.sessionId,
+                    ...(nextInteraction
+                        ? {
+                            interactionId: nextInteraction.frame.interactionId,
+                            source: nextInteraction.frame.source,
+                            interaction: nextInteraction.frame.interaction,
+                        }
+                        : {}),
+                });
+                return;
+            }
+            persistTranscript(this.ctx.sessionLedger, interaction.sessionId, result.messages);
+            this.ctx.sessionLedger.completeRun(interaction.sessionId, result, {
+                ownerId,
+                expectedRevision: responseRevision,
+            });
+            this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
+            yield toSuccessResult(response.requestId, "interaction.respond", result);
+        }
+        catch (error) {
+            try {
+                this.ctx.sessionLedger.releaseSessionClaim(interaction.sessionId, ownerId);
+            }
+            catch {
+                // Best effort.
+            }
+            if (signal?.aborted || HeadlessRunOrchestrator.isAbortError(error)) {
+                return;
+            }
+            yield toFailureResult(response.requestId, "interaction.respond", "INTERACTION_RESPONSE_FAILED", error instanceof Error ? error.message : String(error));
+        }
+    }
+    consumeRunEvent(state, event) {
+        switch (event.type) {
+            case "text_delta":
+                state.output += event.content;
+                break;
+            case "tool_result":
+                state.toolCalls.push({
+                    id: event.id,
+                    name: event.name,
+                    input: event.input,
+                    result: event.result,
+                    durationMs: event.durationMs,
+                });
+                break;
+            case "usage_update":
+                state.usage = event.usage;
+                break;
+            case "turn_complete":
+                state.turnCount = event.turnNumber;
+                break;
+            case "guardrail_rejected":
+                state.guardrailEvents.push({
+                    stage: event.stage,
+                    message: event.message,
+                });
+                break;
+            case "pipeline_timing":
+                state.pipelineTiming = event.report;
+                break;
+            case "messages_snapshot":
+                state.messages = Array.isArray(event.messages) ? event.messages : [];
+                break;
+            case "thinking_end":
+                if (event.blocks)
+                    state.thinking.push(...event.blocks);
+                break;
+            case "native_tool_result":
+                state.nativeToolResults.push(event.metadata);
+                break;
+            case "handoff_start":
+                state.handoffs.push({
+                    type: "start",
+                    target: event.target,
+                    id: event.id,
+                });
+                break;
+            case "handoff_result":
+                state.handoffs.push({
+                    type: "result",
+                    target: event.target,
+                    id: event.id,
+                    result: event.result,
+                });
+                break;
+            case "paused":
+                state.pausedState = event.state;
+                break;
+            case "error":
+                throw new Error(resolveTrustedRuntimeErrorMessage(event.error.message, "diagnostic" in event.error ? event.error.diagnostic : undefined) ?? event.error.message);
+            default:
+                break;
+        }
+    }
+}
+//# sourceMappingURL=run-orchestrator.js.map