@xfey/tutti 0.1.94 → 0.1.95

package/dist/collaboration-state/index.d.ts

@@ -10,6 +10,8 @@ export { openNextTaskBoundClarificationRound, openNextTaskCompileClarificationRo
 export { closeTaskBoundClarificationAsRetaskingRequired, materializeClarificationSuccessor, materializeTaskBoundRunSuccessor, submitClarificationRound, } from "./clarification-successors.js";
 export { readRecoverySummariesPage, readRecoverySummaryProjection, readRunResultProjectionByActivityRef, readTaskRunResultsPage, recordRecoverySummary, } from "./run-results.js";
 export { recordRunNeedsHumanResult, recordRunResult } from "./run-recording.js";
+export { materializeTaskRetryRun, readMaterializedTaskRetry } from "./task-retry.js";
+export type { MaterializeTaskRetryResult } from "./task-retry.js";
 export { readStaleRunningTaskIdentities, recoverStaleRunningTasksAsFailed, } from "./recovery.js";
 export { markReadStateScope, readReadStateSummary, recordReadNotificationEvent, } from "./read-state.js";
 export { readTaskDetailProjection } from "./task-details.js";

package/dist/collaboration-state/index.js

@@ -10,6 +10,7 @@ export { openNextTaskBoundClarificationRound, openNextTaskCompileClarificationRo
 export { closeTaskBoundClarificationAsRetaskingRequired, materializeClarificationSuccessor, materializeTaskBoundRunSuccessor, submitClarificationRound, } from "./clarification-successors.js";
 export { readRecoverySummariesPage, readRecoverySummaryProjection, readRunResultProjectionByActivityRef, readTaskRunResultsPage, recordRecoverySummary, } from "./run-results.js";
 export { recordRunNeedsHumanResult, recordRunResult } from "./run-recording.js";
+export { materializeTaskRetryRun, readMaterializedTaskRetry } from "./task-retry.js";
 export { readStaleRunningTaskIdentities, recoverStaleRunningTasksAsFailed, } from "./recovery.js";
 export { markReadStateScope, readReadStateSummary, recordReadNotificationEvent, } from "./read-state.js";
 export { readTaskDetailProjection } from "./task-details.js";

package/dist/collaboration-state/messages.js

@@ -76,6 +76,21 @@ export function mapMessageRow(row, db) {
     if (row.refs_json !== null) {
         message.refs = parseJson(row.refs_json, {});
     }
+    const taskResult = message.refs?.task_result;
+    if (db !== undefined && taskResult?.latest_run_result_id !== undefined) {
+        const runResult = db
+            .prepare("SELECT result_json FROM run_results WHERE id = ?")
+            .get(taskResult.latest_run_result_id);
+        if (runResult !== undefined) {
+            const result = parseJson(runResult.result_json, {});
+            if (result.retry_action === "retryable" || result.retry_action === "retried") {
+                taskResult.retry_action = result.retry_action;
+            }
+            else {
+                delete taskResult.retry_action;
+            }
+        }
+    }
     if (db !== undefined && row.message_kind === "clarification_card") {
         const clarificationCard = readClarificationCardForMessage(db, row.id);
         if (clarificationCard !== undefined) {

package/dist/collaboration-state/run-recording.js

@@ -19,13 +19,30 @@ export function recordRunResult(db, input) {
         const taskStatus = input.result.result_kind === "finished" && input.result.outcome === "completed"
             ? "done"
             : "failed";
-        const resultJson = { ...input.result };
+        const blocksManualRetry = input.result.result_kind === "failed" &&
+            (input.result.error_code === "codex_app_server_output_schema_invalid" ||
+                input.result.error_code === "codex_app_server_auth_failed" ||
+                input.result.error_code === "codex_app_server_session_unavailable" ||
+                input.result.error_code === "codex_app_server_turn_state_unknown" ||
+                input.result.error_code === "codex_app_server_process_lifecycle_failed" ||
+                input.result.error_code === "run_pipeline_failed" ||
+                input.result.error_code.startsWith("workspace_ops_"));
+        const externalSideEffectBlocksRetry = input.result.result_kind === "finished" &&
+            input.result.external_side_effects?.some((effect) => effect.status === "succeeded" || effect.status === "unknown") === true;
+        const retryAction = taskStatus === "failed" && !blocksManualRetry && !externalSideEffectBlocksRetry
+            ? "retryable"
+            : undefined;
+        const resultJson = {
+            ...input.result,
+            ...(retryAction === undefined ? {} : { retry_action: retryAction }),
+        };
         const detailResult = {
             latest_run_result_id: runResultId,
             result_kind: input.result.result_kind,
             run_lineage: input.run_lineage,
             summary: input.result.summary,
             updated_at: createdAt,
+            ...(retryAction === undefined ? {} : { retry_action: retryAction }),
         };
         if (input.result.result_kind === "finished") {
             detailResult.outcome = input.result.outcome;

package/dist/collaboration-state/run-results.js

@@ -31,6 +31,9 @@ export function mapRunResultRow(row) {
             summary: typeof result.summary === "string" ? result.summary : "",
             error_code: typeof result.error_code === "string" ? result.error_code : "unknown",
             retryable: typeof result.retryable === "boolean" ? result.retryable : false,
+            ...(result.retry_action === "retryable" || result.retry_action === "retried"
+                ? { retry_action: result.retry_action }
+                : {}),
         };
     }
     const projection = {
@@ -68,6 +71,9 @@ export function mapRunResultRow(row) {
         projection.external_side_effects =
             result.external_side_effects;
     }
+    if (result.retry_action === "retryable" || result.retry_action === "retried") {
+        projection.retry_action = result.retry_action;
+    }
     return projection;
 }
 export function readRunResultProjectionByActivityRef(db, activityRef) {

package/dist/collaboration-state/task-retry.d.ts

@@ -0,0 +1,16 @@
+import type { ActivityRef, RunResultId, TaskId } from "@tutti/shared/ids";
+import type { RetryTaskDisposition } from "@tutti/shared/schemas/api";
+import { type SqliteDatabase } from "../store/index.js";
+export type MaterializeTaskRetryResult = {
+    disposition: RetryTaskDisposition;
+};
+export declare function readMaterializedTaskRetry(db: SqliteDatabase, runResultId: RunResultId): Extract<RetryTaskDisposition, {
+    kind: "accepted";
+}> | null;
+export declare function materializeTaskRetryRun(db: SqliteDatabase, input: {
+    task_id: TaskId;
+    expected_latest_run_result_id: RunResultId;
+    activity_ref: ActivityRef;
+    now?: () => Date;
+}): MaterializeTaskRetryResult;
+//# sourceMappingURL=task-retry.d.ts.map

package/dist/collaboration-state/task-retry.js

@@ -0,0 +1,134 @@
+import { withHostStoreTransaction } from "../store/index.js";
+import { nowIso, parseJson, stringifyJson } from "./serialization.js";
+import { readTaskDetailProjection } from "./task-details.js";
+import { readTaskProjection } from "./worklist.js";
+import { recordReadNotificationEvent } from "./read-state.js";
+export function readMaterializedTaskRetry(db, runResultId) {
+    const row = db
+        .prepare("SELECT * FROM run_results WHERE id = ?")
+        .get(runResultId);
+    if (row === undefined) {
+        return null;
+    }
+    const result = parseJson(row.result_json, {});
+    if (typeof result.retry_activity_ref !== "string") {
+        return null;
+    }
+    return {
+        kind: "accepted",
+        task_id: row.task_id,
+        activity_ref: result.retry_activity_ref,
+        retried_run_result_id: row.id,
+    };
+}
+function failedResultCanRetry(row, result) {
+    if (result.retry_action === "retryable") {
+        return true;
+    }
+    if (row.result_kind === "failed") {
+        const errorCode = typeof result.error_code === "string" ? result.error_code : "unknown";
+        return (errorCode !== "codex_app_server_output_schema_invalid" &&
+            errorCode !== "codex_app_server_auth_failed" &&
+            errorCode !== "codex_app_server_session_unavailable" &&
+            errorCode !== "codex_app_server_turn_state_unknown" &&
+            errorCode !== "codex_app_server_process_lifecycle_failed" &&
+            errorCode !== "run_pipeline_failed" &&
+            !errorCode.startsWith("workspace_ops_"));
+    }
+    if (row.result_kind !== "finished" || result.outcome !== "failed") {
+        return false;
+    }
+    if (!Array.isArray(result.external_side_effects)) {
+        return true;
+    }
+    return !result.external_side_effects.some((effect) => typeof effect === "object" &&
+        effect !== null &&
+        "status" in effect &&
+        (effect.status === "succeeded" || effect.status === "unknown"));
+}
+export function materializeTaskRetryRun(db, input) {
+    return withHostStoreTransaction(db, (tx) => {
+        const taskRow = tx.prepare("SELECT * FROM tasks WHERE id = ?").get(input.task_id);
+        if (taskRow === undefined) {
+            return { disposition: { kind: "task_not_failed" } };
+        }
+        if (taskRow.latest_run_result_id !== input.expected_latest_run_result_id) {
+            return {
+                disposition: {
+                    kind: "latest_run_result_changed",
+                    ...(taskRow.latest_run_result_id === null
+                        ? {}
+                        : { latest_run_result_id: taskRow.latest_run_result_id }),
+                },
+            };
+        }
+        if (taskRow.status === "running" && taskRow.current_activity_ref !== null) {
+            return {
+                disposition: {
+                    kind: "already_running",
+                    activity_ref: taskRow.current_activity_ref,
+                },
+            };
+        }
+        if (taskRow.status !== "failed") {
+            return { disposition: { kind: "task_not_failed" } };
+        }
+        const runResultRow = tx
+            .prepare("SELECT * FROM run_results WHERE id = ?")
+            .get(input.expected_latest_run_result_id);
+        if (runResultRow === undefined || runResultRow.task_id !== input.task_id) {
+            return { disposition: { kind: "latest_run_result_changed" } };
+        }
+        const result = parseJson(runResultRow.result_json, {});
+        if (result.retry_activity_ref !== undefined) {
+            return {
+                disposition: {
+                    kind: "retry_already_started",
+                    activity_ref: result.retry_activity_ref,
+                },
+            };
+        }
+        if (!failedResultCanRetry(runResultRow, result)) {
+            return { disposition: { kind: "retry_requires_resolution" } };
+        }
+        const updatedAt = nowIso(input.now);
+        tx.prepare("UPDATE run_results SET result_json = ? WHERE id = ?").run(stringifyJson({
+            ...result,
+            retry_action: "retried",
+            retry_activity_ref: input.activity_ref,
+            retried_at: updatedAt,
+        }), input.expected_latest_run_result_id);
+        tx.prepare(`
+        UPDATE tasks
+        SET status = 'running',
+            current_activity_ref = ?,
+            updated_at = ?
+        WHERE id = ?
+          AND status = 'failed'
+      `).run(input.activity_ref, updatedAt, input.task_id);
+        const detail = readTaskDetailProjection(tx, input.task_id);
+        if (detail === null) {
+            throw new Error("Task retry could not read task detail.");
+        }
+        tx.prepare("UPDATE task_details SET result_json = ?, updated_at = ? WHERE task_id = ?").run(stringifyJson({ ...detail.detail.result, retry_action: "retried", updated_at: updatedAt }), updatedAt, input.task_id);
+        recordReadNotificationEvent(tx, {
+            scope: "worklist",
+            source_kind: "task_run_started",
+            source_ref: input.task_id,
+            occurred_at: updatedAt,
+        });
+        const task = readTaskProjection(tx, input.task_id);
+        if (task === null) {
+            throw new Error("Task retry did not produce a readable task.");
+        }
+        return {
+            disposition: {
+                kind: "accepted",
+                task_id: input.task_id,
+                activity_ref: input.activity_ref,
+                retried_run_result_id: input.expected_latest_run_result_id,
+            },
+        };
+    });
+}
+//# sourceMappingURL=task-retry.js.map

package/dist/control-plane/command-recovery.js

@@ -1,4 +1,4 @@
-import { readClarificationRoundProjection, readRecoverableScheduledRun, readRunResultProjectionByActivityRef, } from "../collaboration-state/index.js";
+import { readClarificationRoundProjection, readRecoverableScheduledRun, readRunResultProjectionByActivityRef, readMaterializedTaskRetry, } from "../collaboration-state/index.js";
 const SUBMIT_CLARIFICATION_ROUND_COMMANDS = new Set([
     "clarification.round.submit",
     "submit_clarification_round",
@@ -10,6 +10,7 @@ const MATERIALIZE_CLARIFICATION_SUCCESSOR_COMMANDS = new Set([
 ]);
 const RECORD_RUN_RESULT_COMMANDS = new Set(["run.result.record", "record_run_result"]);
 const RUN_SCHEDULER_NOW_COMMANDS = new Set(["scheduler.run_now", "runSchedulerNow"]);
+const RETRY_TASK_COMMANDS = new Set(["task.retry"]);
 function completed(disposition) {
     return {
         status: "completed",
@@ -74,6 +75,13 @@ export const resolveControlPlaneCommandRecovery = (db, record) => {
             queued_task_ids: scheduled.queued_task_ids,
         });
     }
+    if (RETRY_TASK_COMMANDS.has(record.command_name)) {
+        if (record.target_ref === null) {
+            return null;
+        }
+        const retry = readMaterializedTaskRetry(db, record.target_ref);
+        return retry === null ? null : completed(retry);
+    }
     return null;
 };
 //# sourceMappingURL=command-recovery.js.map

package/dist/control-plane/index.d.ts

@@ -1,5 +1,5 @@
-import { type ActivityRef, type ClarificationRoundRef, type IdempotencyKey, type WorkflowInvocationRef } from "@tutti/shared/ids";
-import type { ExecutionStatusProjection, MessageProjection, ContextSyncDisposition, ContextSyncResult, RefreshScratchpadDisposition, RefreshScratchpadResult, RunSchedulerNowDisposition, RunSchedulerNowPayload, RefreshReferenceSummariesDisposition, RefreshReferenceSummariesPayload, RefreshReferenceSummariesResult, SendClarificationRoundMessageDisposition, SendClarificationRoundMessagePayload, SendClarificationRoundMessageResult, SubmitClarificationRoundDisposition, SubmitClarificationRoundPayload, SubmitClarificationRoundResult, SubmitWorklistDisposition, SubmitWorklistPayload, SubmitWorklistResult, ProcedureLane } from "@tutti/shared/schemas/api";
+import { type ActivityRef, type ClarificationRoundRef, type IdempotencyKey, type TaskId, type WorkflowInvocationRef } from "@tutti/shared/ids";
+import type { ExecutionStatusProjection, MessageProjection, ContextSyncDisposition, ContextSyncResult, RefreshScratchpadDisposition, RefreshScratchpadResult, RunSchedulerNowDisposition, RunSchedulerNowPayload, RetryTaskDisposition, RetryTaskPayload, RefreshReferenceSummariesDisposition, RefreshReferenceSummariesPayload, RefreshReferenceSummariesResult, SendClarificationRoundMessageDisposition, SendClarificationRoundMessagePayload, SendClarificationRoundMessageResult, SubmitClarificationRoundDisposition, SubmitClarificationRoundPayload, SubmitClarificationRoundResult, SubmitWorklistDisposition, SubmitWorklistPayload, SubmitWorklistResult, ProcedureLane } from "@tutti/shared/schemas/api";
 import type { ContextSyncWorkflowTrigger } from "./workflows/index.js";
 import type { ControlPlaneCommandResult, Phase5ControlPlaneOptions, StartupRecoveryOptions, StartupRecoveryResult, TrustedHumanAuthor } from "./types.js";
 import { type ProjectBriefRefreshReason, type RefreshProjectBriefProjectionResult } from "./project-brief-refresh.js";
@@ -28,6 +28,7 @@ export declare class Phase5ControlPlane {
     constructor(options: Phase5ControlPlaneOptions);
     getExecutionStatus(): ExecutionStatusProjection;
     runSchedulerNow(payload?: RunSchedulerNowPayload): ControlPlaneCommandResult<RunSchedulerNowDisposition, never>;
+    retryTask(taskId: TaskId, payload: RetryTaskPayload): ControlPlaneCommandResult<RetryTaskDisposition, never>;
     runStartupRecovery(options?: StartupRecoveryOptions): StartupRecoveryResult;
     startScratchpadRefresh(options?: {
         lane?: ProcedureLane;

package/dist/control-plane/index.js

@@ -16,6 +16,7 @@ import { startControlPlaneTaskCompileContinuation } from "./task-compile-continu
 import { startControlPlaneTaskBoundFollowUpCheck } from "./follow-up-start.js";
 import { runControlPlaneSchedulerForTaskArrival, runControlPlaneSchedulerNow, } from "./run-scheduler.js";
 import { startControlPlaneRunForTask } from "./run-start.js";
+import { retryControlPlaneTask } from "./run-retry.js";
 import { runSendClarificationRoundMessage, runSubmitClarificationRound, } from "./clarification-commands.js";
 import { emitTaskCompletedResultMessage, emitTaskFailedResultMessage, } from "./worklist-terminal-feedback.js";
 export class Phase5ControlPlane {
@@ -82,6 +83,19 @@ export class Phase5ControlPlane {
             now: this.now,
         });
     }
+    retryTask(taskId, payload) {
+        return retryControlPlaneTask({
+            store: this.store,
+            taskId,
+            payload,
+            resolveRunPipeline: this.resolveRunPipeline,
+            readActiveActivity: () => this.readSchedulerBlocker(),
+            startRunForTask: (runInput) => {
+                void this.startRunForTask(runInput);
+            },
+            now: this.now,
+        });
+    }
     runStartupRecovery(options = {}) {
         return runControlPlaneStartupRecovery({
             store: this.store,

package/dist/control-plane/run-retry.d.ts

@@ -0,0 +1,19 @@
+import { type ActivityRef, type TaskId } from "@tutti/shared/ids";
+import type { RetryTaskDisposition, RetryTaskPayload } from "@tutti/shared/schemas/api";
+import type { HostProjectStore } from "../store/index.js";
+import type { StartRunForTaskInput } from "./run-start.js";
+import type { ControlPlaneCommandResult, RunPipelineResolver } from "./types.js";
+type ActiveActivity = {
+    activity_ref: ActivityRef;
+};
+export declare function retryControlPlaneTask(input: {
+    store: HostProjectStore;
+    taskId: TaskId;
+    payload: RetryTaskPayload;
+    resolveRunPipeline: RunPipelineResolver | undefined;
+    readActiveActivity: () => ActiveActivity | null;
+    startRunForTask: (run: StartRunForTaskInput) => void;
+    now: () => Date;
+}): ControlPlaneCommandResult<RetryTaskDisposition, never>;
+export {};
+//# sourceMappingURL=run-retry.d.ts.map

package/dist/control-plane/run-retry.js

@@ -0,0 +1,103 @@
+import { createActivityRef, } from "@tutti/shared/ids";
+import { materializeTaskRetryRun, readNextRunnableTask, readTaskDetailProjection, readTaskRunResultsPage, } from "../collaboration-state/index.js";
+import { toDomainRunLineage } from "./run-lineage.js";
+function retryCorrectionContext(result, detail) {
+    const resultProjection = detail.detail.result;
+    const reasonCode = result.result_kind === "failed"
+        ? result.error_code
+        : resultProjection.checks === "failed"
+            ? "checks_failed"
+            : resultProjection.promotion?.reason_code ?? "previous_run_failed";
+    return {
+        previous_provider_result: result.result_kind === "finished"
+            ? {
+                decision: "completed",
+                summary: result.summary,
+                ...(result.user_note_candidate === undefined
+                    ? {}
+                    : { user_note_candidate: result.user_note_candidate }),
+            }
+            : { decision: "failed", summary: result.summary },
+        summary: result.summary,
+        reason_code: reasonCode,
+        guidance: "Continue the same task from the retained project state and correct the problem that caused the previous Run to fail.",
+        diagnostic: {
+            source: "previous_run_result",
+            text: result.summary,
+            truncated: false,
+        },
+        promotion_failure: resultProjection.promotion?.status === "not_promoted"
+            ? {
+                reason_code: resultProjection.promotion.reason_code ?? reasonCode,
+                summary: resultProjection.promotion.summary ?? result.summary,
+            }
+            : null,
+    };
+}
+export function retryControlPlaneTask(input) {
+    const active = input.readActiveActivity();
+    if (active !== null) {
+        return { disposition: { kind: "already_running", activity_ref: active.activity_ref } };
+    }
+    const pipelineResolution = input.resolveRunPipeline?.();
+    if (pipelineResolution === undefined || pipelineResolution.kind === "not_configured") {
+        return { disposition: { kind: "provider_not_configured" } };
+    }
+    if (pipelineResolution.kind === "unavailable") {
+        return {
+            disposition: {
+                kind: "provider_unavailable",
+                reason: pipelineResolution.reason,
+                retryable: pipelineResolution.retryable,
+            },
+        };
+    }
+    const latestResult = readTaskRunResultsPage(input.store.db, input.taskId, { limit: 1 })?.items[0];
+    const detail = readTaskDetailProjection(input.store.db, input.taskId);
+    if (latestResult === undefined || detail === null) {
+        return { disposition: { kind: "task_not_failed" } };
+    }
+    const activityRef = createActivityRef();
+    const materialized = materializeTaskRetryRun(input.store.db, {
+        task_id: input.taskId,
+        expected_latest_run_result_id: input.payload.expected_latest_run_result_id,
+        activity_ref: activityRef,
+        now: input.now,
+    });
+    if (materialized.disposition.kind !== "accepted") {
+        return materialized;
+    }
+    const taskDetail = readTaskDetailProjection(input.store.db, input.taskId);
+    if (taskDetail === null) {
+        return { disposition: { kind: "retry_requires_resolution" } };
+    }
+    const parentLineage = toDomainRunLineage(latestResult.run_lineage);
+    const runLineage = {
+        kind: "retry",
+        attempt: parentLineage.attempt + 1,
+        parent_activity_ref: latestResult.activity_ref,
+        root_activity_ref: parentLineage.root_activity_ref ?? latestResult.activity_ref,
+    };
+    const next = readNextRunnableTask(input.store.db);
+    const orderedTaskRefs = next.kind === "found"
+        ? [input.taskId, ...next.queued_task_ids.filter((taskId) => taskId !== input.taskId)]
+        : [input.taskId];
+    const dispatchContext = {
+        trigger: "recovery",
+        queue_scope: { kind: "worklist" },
+        current_task_id: input.taskId,
+        ordered_task_refs: orderedTaskRefs,
+        current_module_id: taskDetail.task.module_id,
+    };
+    input.startRunForTask({
+        activity_ref: activityRef,
+        task: taskDetail.task,
+        task_detail: taskDetail,
+        run_lineage: runLineage,
+        dispatch_context: dispatchContext,
+        correction_context: retryCorrectionContext(latestResult, detail),
+        runner: pipelineResolution.runner,
+    });
+    return materialized;
+}
+//# sourceMappingURL=run-retry.js.map

package/dist/control-plane/run-start.d.ts

@@ -4,7 +4,7 @@ import type { TaskDetailProjection, TaskProjection } from "@tutti/shared/schemas
 import type { RunEngine, RunEngineState, StartRunResult } from "../run-engine/index.js";
 import type { HostProjectStore } from "../store/index.js";
 import { recordRunPipelineResult } from "./run-result-recording.js";
-import type { ControlPlaneLogger, Phase5ControlPlaneOptions, RunContinuationContext, RunDispatchContext, RunPipelineRunner } from "./types.js";
+import type { ControlPlaneLogger, Phase5ControlPlaneOptions, RunCorrectionContext, RunContinuationContext, RunDispatchContext, RunPipelineRunner } from "./types.js";
 export type StartRunForTaskInput = {
     activity_ref: ActivityRef;
     task: TaskProjection;
@@ -12,6 +12,7 @@ export type StartRunForTaskInput = {
     run_lineage: RunLineage;
     dispatch_context: RunDispatchContext;
     continuation_context?: RunContinuationContext;
+    correction_context?: RunCorrectionContext;
     runner: RunPipelineRunner;
 };
 export type RunResultRecordedPublisher = (recorded: ReturnType<typeof recordRunPipelineResult>["recorded"]) => void;

package/dist/control-plane/run-start.js

@@ -107,6 +107,9 @@ export function startControlPlaneRunForTask(input) {
                     ...(input.run.continuation_context === undefined
                         ? {}
                         : { continuation_context: input.run.continuation_context }),
+                    ...(input.run.correction_context === undefined
+                        ? {}
+                        : { correction_context: input.run.correction_context }),
                     ...(sourceMessages.length === 0 ? {} : { source_messages: sourceMessages }),
                     ...(clarificationRounds.length === 0
                         ? {}

package/dist/control-plane/types.d.ts

@@ -85,6 +85,18 @@ export type RunContinuationContext = {
     };
 };
 export type RunCorrectionContext = {
+    previous_provider_result: {
+        decision: "completed" | "completed_no_repo_changes";
+        summary: string;
+        user_note_candidate?: string;
+    } | {
+        decision: "needs_human";
+        summary: string;
+        clarification_request_payload: ClarificationRequestPayload;
+    } | {
+        decision: "failed";
+        summary: string;
+    };
     summary: string;
     reason_code: string;
     guidance: string;

package/dist/control-plane/workflows/openai.d.ts

@@ -19,6 +19,7 @@ export type OpenAiProcedureWorkflowRunnerOptions = {
         turnTimeoutMs?: number;
         baseEnv?: NodeJS.ProcessEnv;
         tuttiHome?: string;
+        projectId?: ProjectId;
         userSkillsRoot?: string;
         builtInSkillsRoot?: string;
         agentContext?: CodexAppServerAgentContextRuntime;

package/dist/control-plane/workflows/openai.js

@@ -7,7 +7,9 @@ import { createOpenAiStructuredOutputClient, runOpenAiStructuredOutput, } from "
 import { readOpenAiApiKeyCredential } from "../../providers/openai/credential-store.js";
 import { resolveOpenAiProviderConfig, } from "../../providers/openai/provider-config.js";
 import { SCRATCHPAD_REFRESH_OUTPUT_SCHEMA, TASK_COMPILE_OUTPUT_SCHEMA, PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA, CONTEXT_SYNC_OUTPUT_SCHEMA, PROJECT_BRIEF_REFRESH_OUTPUT_SCHEMA, FOLLOW_UP_CHECK_OUTPUT_SCHEMA, REFERENCE_FILE_SUMMARY_OUTPUT_SCHEMA, isContextSyncWorkflowOutput, isFollowUpCheckStructuredOutput, isProjectBriefRefreshWorkflowOutput, isProjectContextBootstrapWorkflowOutput, isReferenceFileSummaryStructuredOutput, isScratchpadRefreshStructuredOutput, isTaskCompileStructuredOutput, } from "./structured-output.js";
-import { runCodexAppServerReadOnlyProcedure } from "../../providers/openai/app-server/read-only-procedure.js";
+import { runCodexAppServerReadOnlyProcedure, } from "../../providers/openai/app-server/read-only-procedure.js";
+import { CODEX_APP_SERVER_VERSION } from "../../providers/openai/codex-app-server.js";
+import { acquireCodexTaskSessionLock, createProviderFingerprint, markCodexTaskSessionArchived, openCodexDurableSession, recordCodexSessionArchiveFailure, recordCodexTaskSessionThread, } from "../../providers/openai/app-server/session-store.js";
 import { getProjectUserSkillsRoot } from "../../skills/index.js";
 function readOnlyAppServerOptions(options, prompt, outputSchema, skillSelectionName) {
     if (options.readOnlyAppServer === undefined) {
@@ -70,6 +72,56 @@ function readOnlyRuntimeTelemetry(context, stageId) {
         },
     };
 }
+async function runDurableReadOnlyProcedure(input) {
+    const runtime = input.options.readOnlyAppServer;
+    if (runtime?.tuttiHome === undefined ||
+        runtime.projectId === undefined ||
+        input.context === undefined) {
+        return runCodexAppServerReadOnlyProcedure(input.invocation);
+    }
+    let session = openCodexDurableSession({
+        tuttiHome: runtime.tuttiHome,
+        projectId: runtime.projectId,
+        kind: input.kind,
+        ownerRef: input.context.workflow_ref,
+        compatibility: {
+            codexVersion: CODEX_APP_SERVER_VERSION,
+            model: input.options.config.default_model,
+            providerFingerprint: createProviderFingerprint({
+                providerKind: "openai",
+                ...(input.options.config.api_base_url === undefined
+                    ? {}
+                    : { apiBaseUrl: input.options.config.api_base_url }),
+            }),
+        },
+    });
+    const release = acquireCodexTaskSessionLock(session);
+    try {
+        return await runCodexAppServerReadOnlyProcedure({
+            ...input.invocation,
+            session: {
+                codexHome: session.codexHome,
+                ...(session.metadata.thread_id === undefined
+                    ? {}
+                    : { threadId: session.metadata.thread_id }),
+                ...(session.metadata.lifecycle === "archived" ? { unarchive: true } : {}),
+                onThreadReady: (threadId) => {
+                    session = recordCodexTaskSessionThread(session, threadId);
+                },
+                archiveAfterTurn: input.archiveAfterTurn,
+                onThreadArchived: () => {
+                    session = markCodexTaskSessionArchived(session);
+                },
+                onThreadArchiveFailure: () => {
+                    recordCodexSessionArchiveFailure(session);
+                },
+            },
+        });
+    }
+    finally {
+        release();
+    }
+}
 function referenceSummarySourcePath(options, input) {
     if (options.readOnlyAppServer === undefined) {
         throw new Error("Codex app-server read-only Procedure adapter is not configured");
@@ -284,12 +336,18 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                     workflow_input_json: buildTaskCompilePromptInput(input),
                 },
             });
-            const result = await runCodexAppServerReadOnlyProcedure({
-                ...readOnlyAppServerOptions(options, instructions, TASK_COMPILE_OUTPUT_SCHEMA, "task_compile"),
-                ...readOnlyRuntimeTelemetry(context, "task_compile"),
-                validateOutput: isTaskCompileStructuredOutput,
-                networkAccess: false,
-                webSearchMode: "disabled",
+            const result = await runDurableReadOnlyProcedure({
+                options,
+                context,
+                kind: "task_compile",
+                archiveAfterTurn: (output) => "proposal" in output.result,
+                invocation: {
+                    ...readOnlyAppServerOptions(options, instructions, TASK_COMPILE_OUTPUT_SCHEMA, "task_compile"),
+                    ...readOnlyRuntimeTelemetry(context, "task_compile"),
+                    validateOutput: isTaskCompileStructuredOutput,
+                    networkAccess: false,
+                    webSearchMode: "disabled",
+                },
             });
             recordUsage(options, "task_compile", result, {
                 workflow_ref: context?.workflow_ref ?? input.workflow_ref,
@@ -333,10 +391,16 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                     workflow_input_json: input,
                 },
             });
-            const result = await runCodexAppServerReadOnlyProcedure({
-                ...readOnlyAppServerOptions(options, instructions, PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA, "project_context_bootstrap"),
-                ...readOnlyRuntimeTelemetry(context, "project_context_bootstrap"),
-                validateOutput: isProjectContextBootstrapWorkflowOutput,
+            const result = await runDurableReadOnlyProcedure({
+                options,
+                context,
+                kind: "project_context_bootstrap",
+                archiveAfterTurn: () => true,
+                invocation: {
+                    ...readOnlyAppServerOptions(options, instructions, PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA, "project_context_bootstrap"),
+                    ...readOnlyRuntimeTelemetry(context, "project_context_bootstrap"),
+                    validateOutput: isProjectContextBootstrapWorkflowOutput,
+                },
             });
             recordUsage(options, "project_context_bootstrap", result, {
                 ...(context?.workflow_ref === undefined ? {} : { workflow_ref: context.workflow_ref }),
@@ -349,10 +413,16 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                 templateKey: "procedures.context_sync",
                 ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
             });
-            const result = await runCodexAppServerReadOnlyProcedure({
-                ...readOnlyAppServerOptions(options, instructions, CONTEXT_SYNC_OUTPUT_SCHEMA, "context_sync"),
-                ...readOnlyRuntimeTelemetry(context, "context_sync"),
-                validateOutput: isContextSyncWorkflowOutput,
+            const result = await runDurableReadOnlyProcedure({
+                options,
+                context,
+                kind: "context_sync",
+                archiveAfterTurn: () => true,
+                invocation: {
+                    ...readOnlyAppServerOptions(options, instructions, CONTEXT_SYNC_OUTPUT_SCHEMA, "context_sync"),
+                    ...readOnlyRuntimeTelemetry(context, "context_sync"),
+                    validateOutput: isContextSyncWorkflowOutput,
+                },
             });
             recordUsage(options, "context_sync", result, {
                 workflow_ref: context?.workflow_ref ?? input.workflow_ref,
@@ -426,6 +496,7 @@ export function resolveProjectOpenAiProcedureWorkflowRunner(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.invocationCoordinator === undefined