@xfey/tenso 0.1.130

package/dist/provider-usage/index.js

@@ -0,0 +1,228 @@
+const EMPTY_BREAKDOWN = {
+    input_tokens: 0,
+    cached_input_tokens: 0,
+    output_tokens: 0,
+    reasoning_output_tokens: 0,
+    total_tokens: 0,
+    event_count: 0,
+};
+const SOURCE_LABELS = {
+    workspace_write_run: { label: "Implementation", category: "implementation" },
+    follow_up_run: { label: "Follow-up run", category: "implementation" },
+    pipeline_self_correction: { label: "Self-correction", category: "implementation" },
+    artifact_applicability: { label: "Artifact applicability", category: "planning" },
+    task_compile: { label: "Worklist planning", category: "planning" },
+    scratchpad_refresh: { label: "Scratchpad sync", category: "planning" },
+    project_brief_refresh: { label: "Project brief", category: "context" },
+    project_context_bootstrap: { label: "Project context setup", category: "context" },
+    context_sync: { label: "Docs sync", category: "context" },
+    reference_summary_refresh: { label: "Reference processing", category: "context" },
+    follow_up_check: { label: "Follow-up check", category: "planning" },
+    chat_assistant: { label: "Project Q&A", category: "qna" },
+};
+export function providerUsageSourceMetadata(source) {
+    return SOURCE_LABELS[source] ?? { label: source, category: "other" };
+}
+function breakdownFromRow(row) {
+    if (row === undefined) {
+        return { ...EMPTY_BREAKDOWN };
+    }
+    return {
+        input_tokens: row.input_tokens ?? 0,
+        cached_input_tokens: row.cached_input_tokens ?? 0,
+        output_tokens: row.output_tokens ?? 0,
+        reasoning_output_tokens: row.reasoning_output_tokens ?? 0,
+        total_tokens: row.total_tokens ?? 0,
+        event_count: row.event_count ?? 0,
+    };
+}
+function usageBreakdownSelect(whereClause = "") {
+    return `
+    SELECT
+      COALESCE(SUM(input_tokens), 0) AS input_tokens,
+      COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+      COALESCE(SUM(output_tokens), 0) AS output_tokens,
+      COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+      COALESCE(SUM(total_tokens), 0) AS total_tokens,
+      COUNT(*) AS event_count
+    FROM provider_usage_events
+    ${whereClause}
+  `;
+}
+function usageAnchorWhereClause(anchors, options = {}) {
+    const clauses = [];
+    const params = [];
+    if (anchors.activity_ref !== undefined) {
+        clauses.push("activity_ref = ?");
+        params.push(anchors.activity_ref);
+    }
+    if (anchors.workflow_ref !== undefined) {
+        clauses.push("workflow_ref = ?");
+        params.push(anchors.workflow_ref);
+    }
+    if (anchors.task_id !== undefined) {
+        clauses.push("task_id = ?");
+        params.push(anchors.task_id);
+    }
+    if (anchors.run_result_id !== undefined) {
+        clauses.push("run_result_id = ?");
+        params.push(anchors.run_result_id);
+    }
+    if (clauses.length === 0) {
+        return null;
+    }
+    const sourceFilter = options.sources === undefined || options.sources.length === 0
+        ? ""
+        : ` AND source IN (${options.sources.map(() => "?").join(", ")})`;
+    return {
+        whereClause: `WHERE (${clauses.join(" OR ")})${sourceFilter}`,
+        params: [...params, ...(options.sources ?? [])],
+    };
+}
+export function recordProviderUsageEvent(db, input) {
+    const recordedAt = (input.now ?? (() => new Date()))().toISOString();
+    db.prepare(`
+      INSERT INTO provider_usage_events (
+        provider,
+        source,
+        model,
+        input_tokens,
+        cached_input_tokens,
+        output_tokens,
+        reasoning_output_tokens,
+        total_tokens,
+        recorded_at,
+        activity_ref,
+        workflow_ref,
+        task_id,
+        run_result_id,
+        run_lineage_kind
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(input.provider, input.source, input.model ?? null, input.usage.input_tokens, input.usage.cached_input_tokens, input.usage.output_tokens, input.usage.reasoning_output_tokens, input.usage.total_tokens, recordedAt, input.activity_ref ?? null, input.workflow_ref ?? null, input.task_id ?? null, input.run_result_id ?? null, input.run_lineage_kind ?? null);
+}
+export function readProviderUsageBreakdownForAnchors(db, anchors, options = {}) {
+    const anchorWhere = usageAnchorWhereClause(anchors, options);
+    if (anchorWhere === null) {
+        return { ...EMPTY_BREAKDOWN };
+    }
+    return breakdownFromRow(db
+        .prepare(usageBreakdownSelect(anchorWhere.whereClause))
+        .get(...anchorWhere.params));
+}
+export function readProviderUsageSourceSummariesForAnchors(db, anchors, options = {}) {
+    const anchorWhere = usageAnchorWhereClause(anchors, options);
+    if (anchorWhere === null) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT
+          source,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        ${anchorWhere.whereClause}
+        GROUP BY source
+        ORDER BY total_tokens DESC, source ASC
+      `)
+        .all(...anchorWhere.params);
+    return rows.map((row) => ({
+        source: row.source,
+        ...providerUsageSourceMetadata(row.source),
+        ...breakdownFromRow(row),
+    }));
+}
+export function readProviderUsageModelSummariesForAnchors(db, anchors, options = {}) {
+    const anchorWhere = usageAnchorWhereClause(anchors, options);
+    if (anchorWhere === null) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT
+          model,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        ${anchorWhere.whereClause}
+        GROUP BY model
+        ORDER BY total_tokens DESC, model ASC
+      `)
+        .all(...anchorWhere.params);
+    return rows.map((row) => ({
+        model: row.model ?? "unknown",
+        ...breakdownFromRow(row),
+    }));
+}
+export function readProviderUsageProjection(db, options = {}) {
+    const now = (options.now ?? (() => new Date()))();
+    const todayStart = new Date(now);
+    todayStart.setHours(0, 0, 0, 0);
+    const last7Days = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    const last30Days = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+    const totals = breakdownFromRow(db.prepare(usageBreakdownSelect()).get());
+    const bySourceRows = db
+        .prepare(`
+        SELECT
+          source,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        GROUP BY source
+        ORDER BY total_tokens DESC, source ASC
+      `)
+        .all();
+    const byModelRows = db
+        .prepare(`
+        SELECT
+          model,
+          COALESCE(SUM(input_tokens), 0) AS input_tokens,
+          COALESCE(SUM(cached_input_tokens), 0) AS cached_input_tokens,
+          COALESCE(SUM(output_tokens), 0) AS output_tokens,
+          COALESCE(SUM(reasoning_output_tokens), 0) AS reasoning_output_tokens,
+          COALESCE(SUM(total_tokens), 0) AS total_tokens,
+          COUNT(*) AS event_count
+        FROM provider_usage_events
+        GROUP BY model
+        ORDER BY total_tokens DESC, model ASC
+      `)
+        .all();
+    return {
+        total_tokens: totals.total_tokens,
+        totals,
+        by_source: bySourceRows.map((row) => ({
+            source: row.source,
+            ...providerUsageSourceMetadata(row.source),
+            ...breakdownFromRow(row),
+        })),
+        by_model: byModelRows.map((row) => ({
+            model: row.model ?? "unknown",
+            ...breakdownFromRow(row),
+        })),
+        recent_windows: {
+            today: breakdownFromRow(db
+                .prepare(usageBreakdownSelect("WHERE recorded_at >= ?"))
+                .get(todayStart.toISOString())),
+            last_7_days: breakdownFromRow(db
+                .prepare(usageBreakdownSelect("WHERE recorded_at >= ?"))
+                .get(last7Days.toISOString())),
+            last_30_days: breakdownFromRow(db
+                .prepare(usageBreakdownSelect("WHERE recorded_at >= ?"))
+                .get(last30Days.toISOString())),
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/providers/failure-classification.d.ts

@@ -0,0 +1,23 @@
+declare const aliases: {
+    readonly provider_not_configured: "provider_not_configured";
+    readonly provider_auth_invalid: "provider_auth_invalid";
+    readonly provider_quota_or_billing_required: "provider_quota_or_billing_required";
+    readonly provider_rate_limited: "provider_rate_limited";
+    readonly provider_model_unavailable: "provider_model_unavailable";
+    readonly provider_network_error: "provider_network_error";
+    readonly auth_failed: "provider_auth_invalid";
+    readonly host_delegation_revoked: "provider_auth_invalid";
+    readonly authority_invalid: "provider_auth_invalid";
+    readonly gateway_rate_limited: "provider_rate_limited";
+    readonly control_queue_full: "provider_rate_limited";
+    readonly turn_timeout: "provider_timeout";
+    readonly output_parse_failed: "provider_output_invalid";
+    readonly output_validation_failed: "provider_output_invalid";
+    readonly process_lifecycle_failed: "provider_lifecycle_failed";
+    readonly process_tree_not_terminated: "provider_lifecycle_failed";
+};
+export type ProviderFailureCode = (typeof aliases)[keyof typeof aliases];
+/** Facts only, never a retry policy. Do not parse provider prose or raw stderr. */
+export declare function providerFailureCode(error: unknown): ProviderFailureCode | undefined;
+export {};
+//# sourceMappingURL=failure-classification.d.ts.map

package/dist/providers/failure-classification.js

@@ -0,0 +1,43 @@
+const aliases = {
+    provider_not_configured: "provider_not_configured",
+    provider_auth_invalid: "provider_auth_invalid",
+    provider_quota_or_billing_required: "provider_quota_or_billing_required",
+    provider_rate_limited: "provider_rate_limited",
+    provider_model_unavailable: "provider_model_unavailable",
+    provider_network_error: "provider_network_error",
+    auth_failed: "provider_auth_invalid",
+    host_delegation_revoked: "provider_auth_invalid",
+    authority_invalid: "provider_auth_invalid",
+    gateway_rate_limited: "provider_rate_limited",
+    control_queue_full: "provider_rate_limited",
+    turn_timeout: "provider_timeout",
+    output_parse_failed: "provider_output_invalid",
+    output_validation_failed: "provider_output_invalid",
+    process_lifecycle_failed: "provider_lifecycle_failed",
+    process_tree_not_terminated: "provider_lifecycle_failed",
+};
+/** Facts only, never a retry policy. Do not parse provider prose or raw stderr. */
+export function providerFailureCode(error) {
+    if (typeof error !== "object" || error === null)
+        return undefined;
+    const value = error;
+    const code = typeof value.code === "string" ? value.code : value.reason;
+    if (typeof code === "string" && Object.hasOwn(aliases, code))
+        return aliases[code];
+    if (code !== "turn_failed" || typeof value.details !== "object" || value.details === null)
+        return undefined;
+    const details = value.details;
+    // Quota can also carry HTTP 429; the specific bounded code takes precedence.
+    if (details.turn_error_code === "insufficient_quota")
+        return "provider_quota_or_billing_required";
+    if (details.turn_error_code === "invalid_api_key")
+        return "provider_auth_invalid";
+    if (details.turn_error_code === "model_not_found")
+        return "provider_model_unavailable";
+    if (details.turn_error_code === "rate_limit_exceeded" || details.turn_error_http_status === 429)
+        return "provider_rate_limited";
+    if (details.turn_error_http_status === 401)
+        return "provider_auth_invalid";
+    return undefined;
+}
+//# sourceMappingURL=failure-classification.js.map

package/dist/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./openai/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.js

@@ -0,0 +1,2 @@
+export * from "./openai/index.js";
+//# sourceMappingURL=index.js.map

package/dist/providers/invocation-progress.d.ts

@@ -0,0 +1,16 @@
+export type ProviderInvocationProgress = {
+    stage: "provider_queued" | "provider_started" | "context_ready" | "skills_ready" | "turn_started" | "turn_completed" | "provider_failed";
+    invocation_ref?: string;
+    skill_count?: number;
+    completed_tool_count?: number;
+    turn_timeout_ms?: number;
+    notification_count?: number;
+    server_request_count?: number;
+    last_activity_age_ms?: number;
+    reason_code?: "provider_unavailable" | "app_server_protocol_error" | "auth_failed" | "thread_start_failed" | "turn_failed" | "turn_timeout" | "unexpected_server_request" | "skill_selection_failed" | "output_parse_failed" | "output_validation_failed" | "file_read_not_observed" | "write_detected" | "secret_leak_detected" | "process_lifecycle_failed" | "admission_unavailable";
+};
+export type ProviderInvocationProgressObserver = (event: ProviderInvocationProgress) => void;
+/** Copy only finite counters. Do not forward raw error details/methods/prose. */
+export declare function providerInvocationFailureCounters(error: unknown, now?: number): Partial<ProviderInvocationProgress>;
+export declare function reportProviderInvocationProgress(observer: ProviderInvocationProgressObserver | undefined, event: ProviderInvocationProgress): void;
+//# sourceMappingURL=invocation-progress.d.ts.map

package/dist/providers/invocation-progress.js

@@ -0,0 +1,33 @@
+/** Copy only finite counters. Do not forward raw error details/methods/prose. */
+export function providerInvocationFailureCounters(error, now = Date.now()) {
+    if (typeof error !== "object" || error === null || !("details" in error))
+        return {};
+    const details = error.details;
+    if (typeof details !== "object" || details === null)
+        return {};
+    const source = details;
+    const counters = {};
+    for (const key of ["turn_timeout_ms", "notification_count", "completed_tool_count"]) {
+        const value = source[key];
+        if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0)
+            counters[key] = value;
+    }
+    if (Array.isArray(source.server_request_methods))
+        counters.server_request_count = source.server_request_methods.length;
+    if (typeof source.last_activity_at === "string" &&
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(source.last_activity_at)) {
+        const age = now - Date.parse(source.last_activity_at);
+        if (Number.isSafeInteger(age) && age >= 0)
+            counters.last_activity_age_ms = age;
+    }
+    return counters;
+}
+export function reportProviderInvocationProgress(observer, event) {
+    try {
+        observer?.(event);
+    }
+    catch {
+        /* Diagnostics cannot change the provider outcome. */
+    }
+}
+//# sourceMappingURL=invocation-progress.js.map

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/invocation-coordinator.d.ts

@@ -0,0 +1,29 @@
+export type CodexAppServerInvocationLease = {
+    isClosing?: () => boolean;
+    setCloser: (closer: () => Promise<unknown>) => void;
+    release: () => void;
+};
+export declare class CodexAppServerAdmissionError extends Error {
+    readonly code: "admission_closed" | "queue_full";
+    constructor(code: "admission_closed" | "queue_full", message: string);
+}
+export declare class CodexAppServerInvocationCoordinator {
+    private accepting;
+    private active;
+    private readonly queue;
+    private readonly idleWaiters;
+    private readonly maxQueued;
+    constructor(options?: {
+        maxQueued?: number;
+    });
+    get activeCount(): number;
+    get queuedCount(): number;
+    acquire(): Promise<CodexAppServerInvocationLease>;
+    stopAccepting(): void;
+    closeActive(): Promise<void>;
+    waitForIdle(): Promise<void>;
+    private activate;
+    private startNext;
+    private resolveIdleIfNeeded;
+}
+//# sourceMappingURL=invocation-coordinator.d.ts.map