@xfey/tutti 0.1.94 → 0.1.95

package/dist/run-pipeline/openai.js

@@ -17,17 +17,18 @@ function summarizeProviderError(error) {
         error.message.includes("invalid_json_schema") ||
         error.message.includes("Invalid schema") ||
         error.message.includes("response_format");
+    const turnStateUnknown = error.details.turn_start_state === "start_requested";
     const errorCode = looksLikeSchemaError
         ? "codex_app_server_output_schema_invalid"
-        : `codex_app_server_${error.code}`;
+        : turnStateUnknown
+            ? "codex_app_server_turn_state_unknown"
+            : `codex_app_server_${error.code}`;
     return failedBeforeChecks({
         summary: `Provider execution failed before checks. (${errorCode})`,
         errorCode,
         retryable: !looksLikeSchemaError &&
-            (error.code === "app_server_protocol_error" ||
-                error.code === "turn_timeout" ||
-                error.code === "turn_failed" ||
-                error.code === "thread_start_failed"),
+            error.details.turn_start_state === "not_started" &&
+            (error.code === "app_server_protocol_error" || error.code === "thread_start_failed"),
     });
 }
 function summarizeWorkspaceOpsError(error, changedPaths) {
@@ -153,12 +154,12 @@ function loggedSyncStage(options, input, stage, run, completedFields = () => ({}
     }
 }
 const MAX_SELF_CORRECTION_RETRIES = 1;
-const MAX_PROVIDER_TRANSIENT_RETRIES = 1;
 function runPipelineResultPromotion(result) {
     return "promotion" in result ? result.promotion : undefined;
 }
 function buildCorrectionContext(input) {
     const correction = {
+        previous_provider_result: input.previousProviderResult,
         summary: input.result.summary,
         reason_code: input.reasonCode,
         guidance: input.guidance,
@@ -189,23 +190,12 @@ function selfCorrectionInput(input, nextAttempt, correctionContext) {
     return {
         ...input,
         run_lineage: {
-            kind: "retry",
+            ...input.run_lineage,
             attempt: nextAttempt,
-            parent_activity_ref: input.activity_ref,
-            root_activity_ref: input.run_lineage.root_activity_ref ?? input.activity_ref,
         },
         correction_context: correctionContext,
     };
 }
-function providerTransientRetryInput(input) {
-    return {
-        ...input,
-        run_lineage: {
-            ...input.run_lineage,
-            attempt: input.run_lineage.attempt + 1,
-        },
-    };
-}
 function appendSelfCorrectionExhaustedSummary(input) {
     if (input.attemptedRetries <= 0) {
         return input.result;
@@ -218,12 +208,6 @@ function appendSelfCorrectionExhaustedSummary(input) {
 function isSelfCorrectionRequest(result) {
     return "request_kind" in result && result.request_kind === "self_correction";
 }
-function isProviderTransientRunFailure(result) {
-    return (!isSelfCorrectionRequest(result) &&
-        result.result_kind === "failed" &&
-        result.retryable &&
-        result.error_code.startsWith("codex_app_server_"));
-}
 async function runTaskAttempt(options, input) {
     let changedPaths;
     try {
@@ -289,8 +273,9 @@ async function runTaskAttempt(options, input) {
             });
             return requestSelfCorrection({
                 result,
+                previousProviderResult: taskOutput,
                 reasonCode: "no_candidate_changes",
-                guidance: "Produce a concrete candidate diff for the frozen task contract.",
+                guidance: "Produce a concrete candidate diff for the current task goal and scope.",
             });
         }
         const artifactGate = await loggedAsyncStage(options, input, "artifact_candidate_validate", () => runArtifactCandidateGate({
@@ -336,6 +321,7 @@ async function runTaskAttempt(options, input) {
             }
             return requestSelfCorrection({
                 result: artifactResult,
+                previousProviderResult: taskOutput,
                 reasonCode: artifactGate.failure.reason_code,
                 guidance: artifactGate.failure.guidance,
                 diagnostic: artifactGate.failure.diagnostic,
@@ -361,6 +347,7 @@ async function runTaskAttempt(options, input) {
             });
             return requestSelfCorrection({
                 result,
+                previousProviderResult: taskOutput,
                 reasonCode: "checks_failed",
                 guidance: "Use the failed checks summary to fix the candidate so the task can pass Tutti checks.",
             });
@@ -378,8 +365,9 @@ async function runTaskAttempt(options, input) {
             });
             return requestSelfCorrection({
                 result,
+                previousProviderResult: taskOutput,
                 reasonCode: "no_candidate_changes",
-                guidance: "Produce a concrete final candidate diff for the frozen task contract.",
+                guidance: "Produce a concrete final candidate diff for the current task goal and scope.",
             });
         }
         const checkpoint = loggedSyncStage(options, input, "accepted_checkpoint", () => createAcceptedCheckpoint({
@@ -444,25 +432,8 @@ export function createOpenAiRunPipelineRunner(options) {
         async runTask(input) {
             let currentInput = input;
             let selfCorrectionRetries = 0;
-            let providerTransientRetries = 0;
             for (;;) {
                 const result = await runTaskAttempt(options, currentInput);
-                if (isProviderTransientRunFailure(result) &&
-                    providerTransientRetries < MAX_PROVIDER_TRANSIENT_RETRIES) {
-                    providerTransientRetries += 1;
-                    input.on_stage?.({
-                        stage: "provider_retry",
-                        summary: "retrying Codex task after a transient provider failure.",
-                    });
-                    logRunPipelineStage(options, currentInput, {
-                        stage: "provider_retry",
-                        next_attempt: currentInput.run_lineage.attempt + 1,
-                        error_code: result.error_code,
-                    }, "Run pipeline scheduling provider transient retry");
-                    currentInput = providerTransientRetryInput(currentInput);
-                    continue;
-                }
-                providerTransientRetries = 0;
                 if (!isSelfCorrectionRequest(result)) {
                     return result;
                 }
@@ -512,6 +483,7 @@ export function resolveProjectOpenAiRunPipelineRunner(options) {
             apiKey: credential.secret,
             workspaceRoot: options.workspaceRoot,
             tuttiHome: options.tuttiHome,
+            projectId: options.projectId,
             userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
             ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
             ...(options.approvalManager === undefined

package/dist/run-pipeline/task-run-invocation.js

@@ -1,5 +1,7 @@
 import { renderPromptTemplate } from "../prompt-templates/index.js";
-import { runCodexAppServerWorkspaceWriteRun, } from "../providers/openai/app-server/workspace-write-run.js";
+import { CODEX_APP_SERVER_VERSION } from "../providers/openai/codex-app-server.js";
+import { CodexAppServerWorkspaceWriteRunError, runCodexAppServerWorkspaceWriteRun, } from "../providers/openai/app-server/workspace-write-run.js";
+import { acquireCodexTaskSessionLock, createProviderFingerprint, markCodexTaskSessionArchived, openCodexTaskSession, readCodexSessionRecoveryEvidence, recordCodexSessionArchiveFailure, recordCodexTaskSessionThread, writeCodexSessionRecoveryEvidence, } from "../providers/openai/app-server/session-store.js";
 import { TASK_RUN_OUTPUT_SCHEMA, isInitialTaskRunOutput, normalizeTaskRunOutput, } from "./task-run-output.js";
 function taskContractRunInput(input) {
     return {
@@ -28,57 +30,77 @@ function taskContractRunInput(input) {
             : { recent_references: input.recent_references }),
     };
 }
-function initialTaskRunInput(input) {
-    return taskContractRunInput(input);
-}
-function continuationTaskRunInput(input) {
-    return {
-        ...taskContractRunInput(input),
-        ...(input.continuation_context === undefined
-            ? {}
-            : { continuation: input.continuation_context }),
-    };
+function renderResultContract(options) {
+    return renderPromptTemplate({
+        templateKey: "runs.task_result_contract",
+        ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+    });
 }
-function retryTaskRunInput(input) {
-    if (input.correction_context === undefined) {
-        throw new Error("Retry task run requires correction context.");
+function createExecutePrompt(options, input, session) {
+    let executionInput;
+    if (input.run_lineage.kind === "continuation") {
+        if (input.continuation_context === undefined) {
+            throw new CodexAppServerWorkspaceWriteRunError("session_unavailable", "Task continuation context is unavailable.");
+        }
+        executionInput = {
+            continuation: input.continuation_context,
+            ...(session === undefined ||
+                session.disposition !== "resumed" ||
+                session.metadata.thread_id === undefined
+                ? { task_context: taskContractRunInput(input) }
+                : {}),
+        };
     }
-    return {
-        ...taskContractRunInput(input),
-        correction: input.correction_context,
-    };
+    else {
+        executionInput = taskContractRunInput(input);
+    }
+    return renderPromptTemplate({
+        templateKey: "runs.task_execute",
+        ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+        variables: { execution_input_json: executionInput },
+    });
 }
-function createRunPrompt(options, input) {
-    const templateKey = input.run_lineage.kind === "continuation"
-        ? "runs.task_continuation"
-        : input.run_lineage.kind === "retry"
-            ? "runs.task_retry"
-            : "runs.task_run";
+function createFinalizePrompt(options) {
     return renderPromptTemplate({
-        templateKey,
+        templateKey: "runs.task_finalize",
         ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+        variables: { result_contract: renderResultContract(options) },
+    });
+}
+function createRecoveryPrompt(input) {
+    const needsCanonicalContext = input.session === undefined || input.session.metadata.thread_id === undefined;
+    return renderPromptTemplate({
+        templateKey: "runs.task_recovery",
+        ...(input.options.promptsRoot === undefined
+            ? {}
+            : { promptsRoot: input.options.promptsRoot }),
         variables: {
-            run_input_json: input.run_lineage.kind === "initial"
-                ? initialTaskRunInput(input)
-                : input.run_lineage.kind === "continuation"
-                    ? continuationTaskRunInput(input)
-                    : retryTaskRunInput(input),
+            recovery_input_json: {
+                ...(needsCanonicalContext
+                    ? { task_context: taskContractRunInput(input.pipelineInput) }
+                    : {}),
+                recovery: input.recovery,
+            },
+            result_contract: renderResultContract(input.options),
         },
     });
 }
-function usageSource(input) {
-    switch (input.run_lineage.kind) {
-        case "continuation":
-            return "follow_up_run";
-        case "retry":
-            return "pipeline_self_correction";
-        case "initial":
-            return "workspace_write_run";
+function usageSource(input, phase) {
+    if (phase === "finalize") {
+        return "task_result_finalize";
     }
+    if (phase === "recovery") {
+        return "task_result_recovery";
+    }
+    return input.run_lineage.kind === "continuation"
+        ? "follow_up_execute"
+        : input.run_lineage.kind === "retry"
+            ? "manual_retry_execute"
+            : "workspace_write_execute";
 }
-export async function runWorkspaceWriteTask(options, input) {
+function createApprovalHandler(options, input) {
     const manager = options.approvalManager;
-    const approvalHandler = manager === undefined
+    return manager === undefined
         ? undefined
         : (approvalInput) => manager.awaitApproval({
             request: approvalInput.request,
@@ -97,69 +119,308 @@ export async function runWorkspaceWriteTask(options, input) {
             },
             timeoutMs: approvalInput.context.turnTimeoutMs,
         });
-    let result;
+}
+function openTaskSession(options, input) {
+    if (options.tuttiHome === undefined || options.projectId === undefined) {
+        return undefined;
+    }
     try {
-        result = await runCodexAppServerWorkspaceWriteRun({
-            apiKey: options.apiKey,
-            workspaceRoot: options.workspaceRoot,
-            prompt: createRunPrompt(options, input),
-            outputSchema: TASK_RUN_OUTPUT_SCHEMA,
-            validateOutput: (value) => isInitialTaskRunOutput(value),
-            skillSelectionName: input.run_lineage.kind === "continuation" ? "follow_up_run" : "workspace_write_run",
-            defaultModel: options.config.default_model,
-            approvalContext: {
-                workspaceRoot: options.workspaceRoot,
-                taskId: input.task.id,
-                activityRef: input.activity_ref,
-            },
-            ...(approvalHandler === undefined ? {} : { approvalHandler }),
-            ...(options.config.api_base_url === undefined
-                ? {}
-                : { apiBaseUrl: options.config.api_base_url }),
-            ...(options.tuttiHome === undefined ? {} : { tuttiHome: options.tuttiHome }),
-            ...(options.userSkillsRoot === undefined ? {} : { userSkillsRoot: options.userSkillsRoot }),
-            ...(options.builtInSkillsRoot === undefined
-                ? {}
-                : { builtInSkillsRoot: options.builtInSkillsRoot }),
-            ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
-            ...(options.codexCommand === undefined ? {} : { codexCommand: options.codexCommand }),
-            ...(options.requestTimeoutMs === undefined
-                ? {}
-                : { requestTimeoutMs: options.requestTimeoutMs }),
-            ...(options.turnTimeoutMs === undefined ? {} : { turnTimeoutMs: options.turnTimeoutMs }),
-            ...(options.baseEnv === undefined ? {} : { baseEnv: options.baseEnv }),
-            ...(options.invocationCoordinator === undefined
-                ? {}
-                : { invocationCoordinator: options.invocationCoordinator }),
-            ...(options.onLifecycleIncident === undefined
-                ? {}
-                : { onLifecycleIncident: options.onLifecycleIncident }),
-            runtimeTelemetry: {
-                activityRef: input.activity_ref,
-                stageId: "provider_task_run",
-                workspaceRoot: options.workspaceRoot,
-                onSnapshot: (snapshot) => input.on_stage?.({
-                    stage: "provider_task_run",
-                    summary: "running Codex task implementation.",
-                    runtime: snapshot,
+        return openCodexTaskSession({
+            tuttiHome: options.tuttiHome,
+            projectId: options.projectId,
+            taskId: input.task.id,
+            compatibility: {
+                codexVersion: CODEX_APP_SERVER_VERSION,
+                model: options.config.default_model,
+                providerFingerprint: createProviderFingerprint({
+                    providerKind: "openai",
+                    ...(options.config.api_base_url === undefined
+                        ? {}
+                        : { apiBaseUrl: options.config.api_base_url }),
                 }),
             },
         });
     }
-    finally {
-        options.approvalManager?.clearPending();
+    catch {
+        throw new CodexAppServerWorkspaceWriteRunError("session_unavailable", "The durable Codex task session is unavailable.");
+    }
+}
+async function runTaskTurn(input) {
+    let activeSession = input.session;
+    const invoke = () => runCodexAppServerWorkspaceWriteRun({
+        apiKey: input.options.apiKey,
+        workspaceRoot: input.options.workspaceRoot,
+        prompt: input.prompt,
+        sandboxMode: input.sandboxMode,
+        networkAccess: input.networkAccess,
+        defaultModel: input.options.config.default_model,
+        approvalContext: {
+            workspaceRoot: input.options.workspaceRoot,
+            taskId: input.pipelineInput.task.id,
+            activityRef: input.pipelineInput.activity_ref,
+        },
+        ...(input.outputSchema === undefined ? {} : { outputSchema: input.outputSchema }),
+        ...(input.validateOutput === undefined ? {} : { validateOutput: input.validateOutput }),
+        ...(input.skillSelectionName === undefined
+            ? {}
+            : { skillSelectionName: input.skillSelectionName }),
+        ...(input.approvalHandler === undefined
+            ? {}
+            : { approvalHandler: input.approvalHandler }),
+        ...(input.options.config.api_base_url === undefined
+            ? {}
+            : { apiBaseUrl: input.options.config.api_base_url }),
+        ...(input.options.tuttiHome === undefined ? {} : { tuttiHome: input.options.tuttiHome }),
+        ...(input.options.userSkillsRoot === undefined
+            ? {}
+            : { userSkillsRoot: input.options.userSkillsRoot }),
+        ...(input.options.builtInSkillsRoot === undefined
+            ? {}
+            : { builtInSkillsRoot: input.options.builtInSkillsRoot }),
+        ...(input.options.agentContext === undefined
+            ? {}
+            : { agentContext: input.options.agentContext }),
+        ...(input.options.codexCommand === undefined
+            ? {}
+            : { codexCommand: input.options.codexCommand }),
+        ...(input.options.requestTimeoutMs === undefined
+            ? {}
+            : { requestTimeoutMs: input.options.requestTimeoutMs }),
+        ...(input.options.turnTimeoutMs === undefined
+            ? {}
+            : { turnTimeoutMs: input.options.turnTimeoutMs }),
+        ...(input.options.baseEnv === undefined ? {} : { baseEnv: input.options.baseEnv }),
+        ...(input.options.invocationCoordinator === undefined
+            ? {}
+            : { invocationCoordinator: input.options.invocationCoordinator }),
+        ...(input.options.onLifecycleIncident === undefined
+            ? {}
+            : { onLifecycleIncident: input.options.onLifecycleIncident }),
+        ...(activeSession === undefined
+            ? {}
+            : {
+                session: {
+                    codexHome: activeSession.codexHome,
+                    ...(activeSession.metadata.thread_id === undefined
+                        ? {}
+                        : { threadId: activeSession.metadata.thread_id }),
+                    ...(activeSession.metadata.lifecycle === "archived" ? { unarchive: true } : {}),
+                    onThreadReady: (threadId) => {
+                        const updated = recordCodexTaskSessionThread(activeSession, threadId);
+                        activeSession = updated;
+                        input.setSession(updated);
+                    },
+                    ...(input.archiveAfterTurn === undefined
+                        ? {}
+                        : {
+                            archiveAfterTurn: input.archiveAfterTurn,
+                            onThreadArchived: () => {
+                                const updated = markCodexTaskSessionArchived(activeSession);
+                                activeSession = updated;
+                                input.setSession(updated);
+                            },
+                            onThreadArchiveFailure: () => {
+                                recordCodexSessionArchiveFailure(activeSession);
+                            },
+                        }),
+                },
+            }),
+        runtimeTelemetry: {
+            activityRef: input.pipelineInput.activity_ref,
+            stageId: `provider_task_${input.phase}`,
+            workspaceRoot: input.options.workspaceRoot,
+            onSnapshot: (snapshot) => input.pipelineInput.on_stage?.({
+                stage: `provider_task_${input.phase}`,
+                summary: input.phase === "execute"
+                    ? "running Codex task implementation."
+                    : input.phase === "finalize"
+                        ? "preparing the task result."
+                        : "recovering the task result.",
+                runtime: snapshot,
+            }),
+        },
+    });
+    let result;
+    try {
+        result = await invoke();
     }
-    if (options.recordUsage !== undefined && result.usage !== undefined) {
-        options.recordUsage({
+    catch (error) {
+        const canRetryBeforeTurn = error instanceof CodexAppServerWorkspaceWriteRunError &&
+            error.details.turn_start_state === "not_started" &&
+            (error.code === "app_server_protocol_error" || error.code === "thread_start_failed");
+        if (!canRetryBeforeTurn) {
+            throw error;
+        }
+        input.pipelineInput.on_stage?.({
+            stage: "provider_retry",
+            summary: "retrying the Codex connection before the task turn started.",
+        });
+        result = await invoke();
+    }
+    if (input.options.recordUsage !== undefined && result.usage !== undefined) {
+        input.options.recordUsage({
             provider: "openai",
-            source: usageSource(input),
+            source: usageSource(input.pipelineInput, input.phase),
             model: result.model,
             usage: result.usage,
-            activity_ref: input.activity_ref,
-            task_id: input.task.id,
-            run_lineage_kind: input.run_lineage.kind,
+            activity_ref: input.pipelineInput.activity_ref,
+            task_id: input.pipelineInput.task.id,
+            run_lineage_kind: input.pipelineInput.run_lineage.kind,
         });
     }
-    return normalizeTaskRunOutput(result.output);
+    return result;
+}
+function outputRecoveryEvidence(error) {
+    return {
+        previous_agent_output: error.details.agent_output ?? "",
+        provider_output_failure: {
+            kind: error.code === "output_parse_failed"
+                ? "malformed_or_missing_json"
+                : "schema_mismatch",
+            diagnostic: error.message,
+        },
+    };
+}
+function taskResultEndsCurrentLineage(output) {
+    return !("needs_human" in output.result);
+}
+function gateRecoveryEvidence(input) {
+    const context = input.correction_context;
+    return {
+        previous_provider_result: context.previous_provider_result,
+        gate_failure: {
+            summary: context.summary,
+            reason_code: context.reason_code,
+            guidance: context.guidance,
+            diagnostic: context.diagnostic,
+            promotion_failure: context.promotion_failure,
+        },
+    };
+}
+function recoveryEvidenceForRun(input) {
+    if (input.pipelineInput.run_lineage.kind !== "retry" ||
+        input.session === undefined) {
+        return input.current;
+    }
+    const persisted = readCodexSessionRecoveryEvidence(input.session);
+    if (persisted === null ||
+        persisted.owner_activity_ref !== input.pipelineInput.run_lineage.parent_activity_ref) {
+        return input.current;
+    }
+    return {
+        ...input.current,
+        previous_run_recovery_evidence: persisted.evidence,
+        previous_run_recovery_evidence_truncated: persisted.truncated,
+    };
+}
+function persistRecoveryEvidence(input) {
+    if (input.session === undefined) {
+        return;
+    }
+    writeCodexSessionRecoveryEvidence({
+        session: input.session,
+        ownerActivityRef: input.pipelineInput.activity_ref,
+        evidence: input.evidence,
+    });
+}
+export async function runWorkspaceWriteTask(options, input) {
+    let session = openTaskSession(options, input);
+    const releaseSessionLock = session === undefined ? undefined : acquireCodexTaskSessionLock(session);
+    const setSession = (updated) => {
+        session = updated;
+    };
+    const approvalHandler = createApprovalHandler(options, input);
+    const skillSelectionName = input.run_lineage.kind === "continuation" ? "follow_up_run" : "workspace_write_run";
+    try {
+        let structuredResult;
+        if (input.correction_context !== undefined) {
+            const recovery = recoveryEvidenceForRun({
+                pipelineInput: input,
+                session,
+                current: gateRecoveryEvidence(input),
+            });
+            persistRecoveryEvidence({ pipelineInput: input, session, evidence: recovery });
+            structuredResult = await runTaskTurn({
+                options,
+                pipelineInput: input,
+                prompt: createRecoveryPrompt({
+                    options,
+                    pipelineInput: input,
+                    session,
+                    recovery,
+                }),
+                phase: "recovery",
+                sandboxMode: "workspace-write",
+                networkAccess: true,
+                session,
+                setSession,
+                skillSelectionName,
+                ...(approvalHandler === undefined ? {} : { approvalHandler }),
+                outputSchema: TASK_RUN_OUTPUT_SCHEMA,
+                validateOutput: (value) => isInitialTaskRunOutput(value),
+                archiveAfterTurn: taskResultEndsCurrentLineage,
+            });
+        }
+        else {
+            await runTaskTurn({
+                options,
+                pipelineInput: input,
+                prompt: createExecutePrompt(options, input, session),
+                phase: "execute",
+                sandboxMode: "workspace-write",
+                networkAccess: true,
+                session,
+                setSession,
+                skillSelectionName,
+                ...(approvalHandler === undefined ? {} : { approvalHandler }),
+            });
+            try {
+                structuredResult = await runTaskTurn({
+                    options,
+                    pipelineInput: input,
+                    prompt: createFinalizePrompt(options),
+                    phase: "finalize",
+                    sandboxMode: "read-only",
+                    networkAccess: false,
+                    session,
+                    setSession,
+                    outputSchema: TASK_RUN_OUTPUT_SCHEMA,
+                    validateOutput: (value) => isInitialTaskRunOutput(value),
+                    archiveAfterTurn: taskResultEndsCurrentLineage,
+                });
+            }
+            catch (error) {
+                if (!(error instanceof CodexAppServerWorkspaceWriteRunError) ||
+                    (error.code !== "output_parse_failed" && error.code !== "output_validation_failed")) {
+                    throw error;
+                }
+                const recovery = outputRecoveryEvidence(error);
+                persistRecoveryEvidence({ pipelineInput: input, session, evidence: recovery });
+                structuredResult = await runTaskTurn({
+                    options,
+                    pipelineInput: input,
+                    prompt: createRecoveryPrompt({
+                        options,
+                        pipelineInput: input,
+                        session,
+                        recovery,
+                    }),
+                    phase: "recovery",
+                    sandboxMode: "read-only",
+                    networkAccess: false,
+                    session,
+                    setSession,
+                    outputSchema: TASK_RUN_OUTPUT_SCHEMA,
+                    validateOutput: (value) => isInitialTaskRunOutput(value),
+                    archiveAfterTurn: taskResultEndsCurrentLineage,
+                });
+            }
+        }
+        return normalizeTaskRunOutput(structuredResult.output);
+    }
+    finally {
+        options.approvalManager?.clearPending();
+        releaseSessionLock?.();
+    }
 }
 //# sourceMappingURL=task-run-invocation.js.map