@xfey/tutti 0.1.93 → 0.1.95

package/dist/control-plane/task-compile-start.js

@@ -6,6 +6,7 @@ import { projectBriefShouldRefreshForUpdatedPaths, refreshProjectBriefProjection
 import { applyProjectDocsInitializationResult, buildProjectDocsInitializationContext, tryProjectContextBootstrapDocuments, } from "./project-context-bootstrap.js";
 import { readActiveScratchpadRefreshActivityRef, readControlPlaneScratchpadSourceBatch, runControlPlaneScratchpadRefreshProcedure, } from "./scratchpad-refresh-start.js";
 import { applyTaskCompileProcedureOutput } from "./task-compile-output.js";
+import { materializePromptSourceMessages } from "./task-source-context.js";
 import { materializeRecentReferences, readPendingRecentReferenceSummaryPaths, readRecentReferenceSources, } from "./recent-references.js";
 import { startReferenceSummaryRefreshProcedure } from "./reference-summary-refresh.js";
 export function startControlPlaneTaskCompile(options) {
@@ -431,6 +432,7 @@ export async function runControlPlaneTaskCompileProcedure(options) {
         const output = await options.runner.runTaskCompile({
             workflow_ref: options.workflowRef,
             scratchpad: context.scratchpad_snapshot,
+            source_messages: materializePromptSourceMessages(options.store.db, context.sources),
             worklist: readWorklistProjection(options.store.db),
             ...(recentReferences.length === 0
                 ? {}

package/dist/control-plane/task-source-context-types.d.ts

@@ -0,0 +1,11 @@
+import type { ClarificationRequestPayload } from "@tutti/shared/schemas/api";
+export type PromptSourceMessage = {
+    role: "human" | "tutti";
+    author_display_name?: string;
+    text: string;
+};
+export type TaskCompileClarificationContext = {
+    request_payload: ClarificationRequestPayload;
+    answer_messages: PromptSourceMessage[];
+};
+//# sourceMappingURL=task-source-context-types.d.ts.map

package/dist/control-plane/task-source-context-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=task-source-context-types.js.map

package/dist/control-plane/task-source-context.d.ts

@@ -0,0 +1,7 @@
+import type { SqliteDatabase } from "../store/index.js";
+import type { PromptSourceMessage } from "./task-source-context-types.js";
+export type TaskSourceMessageRef = {
+    message_id: string;
+};
+export declare function materializePromptSourceMessages(db: SqliteDatabase, sources: TaskSourceMessageRef[]): PromptSourceMessage[];
+//# sourceMappingURL=task-source-context.d.ts.map

package/dist/control-plane/task-source-context.js

@@ -0,0 +1,31 @@
+import { readMessageProjectionById } from "../collaboration-state/index.js";
+function promptSourceMessage(db, source) {
+    const message = readMessageProjectionById(db, source.message_id);
+    if (message === null) {
+        throw new Error("Task source message is unavailable");
+    }
+    if (message.scope.kind !== "main_chat") {
+        throw new Error("Task source message is outside main chat");
+    }
+    if (message.message_kind === "user_text" && message.author.kind === "human") {
+        const displayName = message.author.display_name?.trim();
+        return {
+            role: "human",
+            ...(displayName === undefined || displayName === ""
+                ? {}
+                : { author_display_name: displayName }),
+            text: message.body,
+        };
+    }
+    if (message.message_kind === "agent_text" && message.author.kind === "agent") {
+        return {
+            role: "tutti",
+            text: message.body,
+        };
+    }
+    throw new Error("Task source message has an unsupported kind or author");
+}
+export function materializePromptSourceMessages(db, sources) {
+    return sources.map((source) => promptSourceMessage(db, source));
+}
+//# sourceMappingURL=task-source-context.js.map

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

@@ -5,6 +5,7 @@ import type { ActiveApprovalProjection, ClarificationRequestPayload, ExecutionRu
 import type { HostProjectStore } from "../store/index.js";
 import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
 import type { RecentReferenceContext } from "./reference-context-types.js";
+import type { PromptSourceMessage, TaskCompileClarificationContext } from "./task-source-context-types.js";
 import type { ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
 export type Phase5ControlPlaneOptions = {
     store: HostProjectStore;
@@ -84,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;
@@ -105,6 +118,8 @@ export type RunPipelineInput = {
     dispatch_context: RunDispatchContext;
     continuation_context?: RunContinuationContext;
     correction_context?: RunCorrectionContext;
+    source_messages?: PromptSourceMessage[];
+    clarification_rounds?: TaskCompileClarificationContext[];
     recent_references?: RecentReferenceContext[];
     on_stage?: (progress: RunPipelineStageProgress) => void;
 };

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");
@@ -153,6 +205,7 @@ export function buildTaskCompilePromptInput(input) {
             open_questions: input.scratchpad.open_questions,
             task_changes: input.scratchpad.task_changes,
         },
+        source_messages: input.source_messages.map((message) => ({ ...message })),
         worklist: {
             modules: input.worklist.modules.map((entry) => ({
                 id: entry.module.id,
@@ -283,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,
@@ -332,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 }),
@@ -348,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,
@@ -425,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

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

@@ -1,5 +1,6 @@
 import type { ExecutionRuntimeSnapshot, MessageProjection, RunResultProjection, TaskDetailProjection, WorklistProjection } from "@tutti/shared/schemas/api";
 import type { RecentReferenceContext } from "../reference-context-types.js";
+import type { PromptSourceMessage, TaskCompileClarificationContext } from "../task-source-context-types.js";
 import type { ClarificationRequestPayload, TaskContractProjection } from "@tutti/shared/schemas/api";
 import type { ProjectDocKey } from "@tutti/shared/schemas/api";
 import type { ActivityRef, ClarificationRoundRef, ClarificationThreadRef, MessageId, TaskId, TaskModuleId, WorkflowInvocationRef } from "@tutti/shared/ids";
@@ -28,11 +29,7 @@ export type ScratchpadRefreshWorklistInput = {
         }>;
     }>;
 };
-export type ScratchpadRefreshSourceMessageInput = {
-    role: "human" | "tutti";
-    author_display_name?: string;
-    text: string;
-};
+export type ScratchpadRefreshSourceMessageInput = PromptSourceMessage;
 export type ScratchpadRefreshWorkflowContext = {
     workflow_ref: WorkflowInvocationRef;
     activity_ref: ActivityRef;
@@ -80,12 +77,10 @@ export type TaskCompileProposalTask = {
 export type TaskCompileWorkflowInput = {
     workflow_ref: WorkflowInvocationRef;
     scratchpad: ScratchpadWorkflowSnapshot;
+    source_messages: PromptSourceMessage[];
     worklist: WorklistProjection;
     recent_references?: RecentReferenceContext[];
-    clarification_rounds?: Array<{
-        request_payload: ClarificationRequestPayload;
-        answer_messages: TaskCompilePromptClarificationMessage[];
-    }>;
+    clarification_rounds?: TaskCompileClarificationContext[];
 };
 export type TaskCompileWorkflowOutput = {
     decision: "ready";
@@ -102,6 +97,7 @@ export type TaskCompilePromptInput = {
         open_questions: string[];
         task_changes: string[];
     };
+    source_messages: PromptSourceMessage[];
     worklist: {
         modules: Array<{
             id: TaskModuleId;
@@ -125,11 +121,7 @@ export type TaskCompilePromptInput = {
         answer_messages: TaskCompilePromptClarificationMessage[];
     }>;
 };
-export type TaskCompilePromptClarificationMessage = {
-    role: "human" | "tutti";
-    author_display_name?: string;
-    text: string;
-};
+export type TaskCompilePromptClarificationMessage = PromptSourceMessage;
 export type TaskCompileStructuredOutput = {
     result: {
         proposal: TaskCompileStructuredProposal;

package/dist/control-plane/worklist-terminal-feedback.js

@@ -272,6 +272,9 @@ export function emitTaskFailedResultMessage(input) {
             : { latest_run_result_id: item.latest_run_result_id }),
         ...(input.activityRef === undefined ? {} : { activity_ref: input.activityRef }),
         ...(errorCode === undefined ? {} : { error_code: errorCode }),
+        ...(entry.detail?.detail.result.retry_action === undefined
+            ? {}
+            : { retry_action: entry.detail.detail.result.retry_action }),
     };
     return publishTaskResultMessage(input, result);
 }

package/dist/prompt-templates/index.d.ts

@@ -1,4 +1,4 @@
-export type PromptTemplateKey = "procedures.project_context_bootstrap" | "procedures.context_sync" | "procedures.project_brief_refresh" | "procedures.scratchpad_refresh" | "procedures.task_compile" | "procedures.reference_file_summary" | "procedures.follow_up_check" | "runs.task_run" | "runs.task_continuation" | "runs.task_retry" | "artifacts.applicability" | "chat.assistant" | "codex.no_write_smoke";
+export type PromptTemplateKey = "procedures.project_context_bootstrap" | "procedures.context_sync" | "procedures.project_brief_refresh" | "procedures.scratchpad_refresh" | "procedures.task_compile" | "procedures.reference_file_summary" | "procedures.follow_up_check" | "runs.task_execute" | "runs.task_finalize" | "runs.task_recovery" | "runs.task_result_contract" | "artifacts.applicability" | "chat.assistant" | "codex.no_write_smoke";
 export type RenderPromptTemplateOptions = {
     templateKey: PromptTemplateKey;
     variables?: Record<string, unknown>;

package/dist/prompt-templates/index.js

@@ -19,9 +19,10 @@ const TEMPLATE_REGISTRY = {
     "procedures.task_compile": "procedures/task-compile.md",
     "procedures.reference_file_summary": "procedures/reference-file-summary.md",
     "procedures.follow_up_check": "procedures/follow-up-check.md",
-    "runs.task_run": "runs/task-run.md",
-    "runs.task_continuation": "runs/task-continuation.md",
-    "runs.task_retry": "runs/task-retry.md",
+    "runs.task_execute": "runs/task-execute.md",
+    "runs.task_finalize": "runs/task-finalize.md",
+    "runs.task_recovery": "runs/task-recovery.md",
+    "runs.task_result_contract": "runs/task-result-contract.md",
     "artifacts.applicability": "artifacts/applicability.md",
     "chat.assistant": "chat-assistant.md",
     "codex.no_write_smoke": "codex/no-write-smoke.md",

package/dist/providers/openai/app-server/durable-session-smoke-cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=durable-session-smoke-cli.d.ts.map

package/dist/providers/openai/app-server/durable-session-smoke-cli.js

@@ -0,0 +1,229 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { existsSync, lstatSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync, } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, relative } from "node:path";
+import { createProjectId, createTaskId } from "@tutti/shared/ids";
+import { CODEX_APP_SERVER_VERSION } from "../codex-app-server.js";
+import { DEFAULT_OPENAI_MODEL } from "../model-config.js";
+import { runCodexAppServerReadOnlyProcedure } from "./read-only-procedure.js";
+import { resolveCodexAppServerSmokeProviderInput } from "./smoke-provider-input.js";
+import { acquireCodexTaskSessionLock, createProviderFingerprint, markCodexTaskSessionArchived, openCodexTaskSession, recordCodexTaskSessionThread, } from "./session-store.js";
+import { runCodexAppServerWorkspaceWriteRun } from "./workspace-write-run.js";
+const WRITE_SENTINEL = "TUTTI_DURABLE_WRITE";
+const RESULT_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        sentinel: { type: "string", enum: [WRITE_SENTINEL] },
+        file_present: { type: "boolean" },
+    },
+    required: ["sentinel", "file_present"],
+};
+function isResult(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        value.sentinel === WRITE_SENTINEL &&
+        value.file_present === true);
+}
+function mode(path) {
+    return statSync(path).mode & 0o777;
+}
+function requireMode(path, expected) {
+    const actual = mode(path);
+    if (actual !== expected) {
+        throw new Error(`Durable session path has mode ${actual.toString(8)}; expected ${expected.toString(8)}.`);
+    }
+}
+function fingerprintPath(path) {
+    if (!existsSync(path)) {
+        return "missing";
+    }
+    const hash = createHash("sha256");
+    const visit = (current) => {
+        const entry = lstatSync(current);
+        hash.update(JSON.stringify({
+            path: relative(path, current),
+            mode: entry.mode & 0o777,
+            size: entry.size,
+            modified_ms: entry.mtimeMs,
+            type: entry.isDirectory() ? "directory" : entry.isSymbolicLink() ? "symlink" : "file",
+        }));
+        if (!entry.isDirectory()) {
+            return;
+        }
+        for (const child of readdirSync(current).sort()) {
+            visit(join(current, child));
+        }
+    };
+    visit(path);
+    return hash.digest("hex");
+}
+function userCodexConfigurationFingerprint() {
+    const root = join(homedir(), ".codex");
+    const hash = createHash("sha256");
+    for (const relativePath of ["auth.json", "config.toml", "plugins", "skills"]) {
+        hash.update(relativePath);
+        hash.update(fingerprintPath(join(root, relativePath)));
+    }
+    return hash.digest("hex");
+}
+async function withSessionLock(session, run) {
+    const release = acquireCodexTaskSessionLock(session);
+    try {
+        return await run();
+    }
+    finally {
+        release();
+    }
+}
+async function main() {
+    const provider = resolveCodexAppServerSmokeProviderInput();
+    const model = provider.defaultModel ?? DEFAULT_OPENAI_MODEL;
+    const smokeRoot = mkdtempSync(join(tmpdir(), "tutti-codex-durable-session-smoke-"));
+    const tuttiHome = join(smokeRoot, "tutti-home");
+    const workspaceRoot = join(smokeRoot, "repo");
+    const projectId = createProjectId();
+    const taskId = createTaskId();
+    const userCodexBefore = userCodexConfigurationFingerprint();
+    let session = openCodexTaskSession({
+        tuttiHome,
+        projectId,
+        taskId,
+        compatibility: {
+            codexVersion: CODEX_APP_SERVER_VERSION,
+            model,
+            providerFingerprint: createProviderFingerprint({
+                providerKind: "openai",
+                ...(provider.apiBaseUrl === undefined ? {} : { apiBaseUrl: provider.apiBaseUrl }),
+            }),
+        },
+    });
+    try {
+        execFileSync("git", ["init", workspaceRoot], { stdio: "ignore" });
+        execFileSync("git", [
+            "-C",
+            workspaceRoot,
+            "config",
+            "user.email",
+            "tutti-smoke@example.invalid",
+        ]);
+        execFileSync("git", ["-C", workspaceRoot, "config", "user.name", "Tutti Smoke"]);
+        const common = {
+            apiKey: provider.apiKey,
+            ...(provider.apiBaseUrl === undefined ? {} : { apiBaseUrl: provider.apiBaseUrl }),
+            defaultModel: model,
+            workspaceRoot,
+            networkAccess: false,
+            strictLeakCheck: true,
+        };
+        const execute = await withSessionLock(session, async () => await runCodexAppServerWorkspaceWriteRun({
+            ...common,
+            approvalPolicy: "never",
+            prompt: `Create durable-smoke.txt in the workspace root with exactly one line: ${WRITE_SENTINEL}. ` +
+                "Do not modify any other file. Then briefly report completion.",
+            session: {
+                codexHome: session.codexHome,
+                onThreadReady: (threadId) => {
+                    session = recordCodexTaskSessionThread(session, threadId);
+                },
+            },
+        }));
+        if (readFileSync(join(workspaceRoot, "durable-smoke.txt"), "utf8") !== `${WRITE_SENTINEL}\n`) {
+            throw new Error("Workspace-write turn did not create the exact durable smoke fixture.");
+        }
+        const threadId = session.metadata.thread_id;
+        if (threadId === undefined) {
+            throw new Error("Workspace-write turn did not persist a durable thread id.");
+        }
+        const finalize = await withSessionLock(session, async () => await runCodexAppServerReadOnlyProcedure({
+            ...common,
+            prompt: "Read durable-smoke.txt and return the supplied JSON shape. " +
+                `Use sentinel ${WRITE_SENTINEL} and set file_present to true.`,
+            outputSchema: RESULT_SCHEMA,
+            validateOutput: isResult,
+            session: {
+                codexHome: session.codexHome,
+                threadId,
+                archiveAfterTurn: () => true,
+                onThreadArchived: () => {
+                    session = markCodexTaskSessionArchived(session);
+                },
+            },
+        }));
+        if (session.metadata.lifecycle !== "archived") {
+            throw new Error("Durable smoke thread was not archived after the read-only turn.");
+        }
+        const recovery = await withSessionLock(session, async () => await runCodexAppServerReadOnlyProcedure({
+            ...common,
+            prompt: "After resuming this archived thread, read durable-smoke.txt and return the supplied " +
+                `JSON shape with sentinel ${WRITE_SENTINEL} and file_present true.`,
+            outputSchema: RESULT_SCHEMA,
+            validateOutput: isResult,
+            session: {
+                codexHome: session.codexHome,
+                threadId,
+                unarchive: true,
+                onThreadReady: (threadId) => {
+                    session = recordCodexTaskSessionThread(session, threadId);
+                },
+                archiveAfterTurn: () => true,
+                onThreadArchived: () => {
+                    session = markCodexTaskSessionArchived(session);
+                },
+            },
+        }));
+        const authPath = join(session.codexHome, "auth.json");
+        const sessionIndexPath = join(tuttiHome, "projects", projectId, "codex-sessions", "task-index", `${taskId}.json`);
+        requireMode(session.root, 0o700);
+        requireMode(session.codexHome, 0o700);
+        requireMode(session.metadataPath, 0o600);
+        requireMode(sessionIndexPath, 0o600);
+        requireMode(authPath, 0o600);
+        const codexHomeEntries = readdirSync(session.codexHome);
+        const repoSessionPaths = readdirSync(workspaceRoot).filter((entry) => entry === ".codex" || entry === "codex-sessions" || entry === "auth.json");
+        if (repoSessionPaths.length > 0) {
+            throw new Error("Durable session state was written into the target repository.");
+        }
+        if (userCodexConfigurationFingerprint() !== userCodexBefore) {
+            throw new Error("The durable smoke changed user-level Codex configuration.");
+        }
+        if (execute.thread_id !== finalize.thread_id || finalize.thread_id !== recovery.thread_id) {
+            throw new Error("Durable smoke turns did not resume the same app-server thread.");
+        }
+        console.log(JSON.stringify({
+            provider_source: provider.source,
+            status: "passed",
+            codex_version: CODEX_APP_SERVER_VERSION,
+            model,
+            same_thread_across_processes: true,
+            per_turn_output_schema: true,
+            workspace_write_then_read_only: true,
+            archive_then_unarchive: true,
+            final_lifecycle: session.metadata.lifecycle,
+            private_session_root_mode: mode(session.root).toString(8),
+            private_codex_home_mode: mode(session.codexHome).toString(8),
+            private_metadata_mode: mode(session.metadataPath).toString(8),
+            private_auth_json_mode: mode(authPath).toString(8),
+            auth_json_in_private_home: true,
+            plugin_cache_in_private_home: existsSync(join(session.codexHome, ".tmp", "plugins")),
+            state_store_in_private_home: codexHomeEntries.some((entry) => /^state_\d+\.sqlite$/u.test(entry)),
+            shell_snapshots_in_private_home: existsSync(join(session.codexHome, "shell_snapshots")),
+            user_codex_configuration_unchanged: true,
+            repo_session_files: 0,
+        }, null, 2));
+    }
+    finally {
+        rmSync(smokeRoot, { recursive: true, force: true });
+    }
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(JSON.stringify({
+        status: "failed",
+        message,
+    }, null, 2));
+    process.exitCode = 1;
+});
+//# sourceMappingURL=durable-session-smoke-cli.js.map

package/dist/providers/openai/app-server/read-only-procedure.d.ts

@@ -14,6 +14,15 @@ export type CodexAppServerReadOnlyProcedureInput<TOutput> = {
     prompt: string;
     outputSchema: unknown;
     validateOutput: (value: unknown) => value is TOutput;
+    session?: {
+        codexHome: string;
+        threadId?: string;
+        unarchive?: boolean;
+        onThreadReady?: (threadId: string) => void | Promise<void>;
+        archiveAfterTurn?: (output: TOutput) => boolean;
+        onThreadArchived?: () => void | Promise<void>;
+        onThreadArchiveFailure?: () => void | Promise<void>;
+    };
     networkAccess?: boolean;
     webSearchMode?: CodexAppServerWebSearchMode;
     skillSelectionName?: CodexAppServerSkillSelectionName;
@@ -34,6 +43,7 @@ export type CodexAppServerReadOnlyProcedureInput<TOutput> = {
 };
 export type CodexAppServerReadOnlyProcedureResult<TOutput> = {
     output: TOutput;
+    thread_id: string;
     model: string;
     turn_status: "completed";
     notification_count: number;