@xfey/tutti 0.1.78 → 0.1.80

package/dist/providers/openai/chat-assistant.d.ts

@@ -2,6 +2,8 @@ import type { ProjectId } from "@tutti/shared/ids";
 import { type ReadOnlyChatAssistantModel } from "../../chat-assistant/index.js";
 import { type OpenAiProviderConfig } from "./provider-config.js";
 import type { CodexAppServerAgentContextRuntime } from "./app-server/skills.js";
+import type { CodexAppServerInvocationCoordinator } from "./app-server/invocation-coordinator.js";
+import type { CodexAppServerLifecycleIncident } from "./app-server/invocation-lifecycle.js";
 import type { ProviderUsageRecorder } from "../../provider-usage/index.js";
 export type OpenAiReadOnlyChatAssistantModelOptions = {
     config: OpenAiProviderConfig;
@@ -16,6 +18,8 @@ export type OpenAiReadOnlyChatAssistantModelOptions = {
     turnTimeoutMs?: number;
     baseEnv?: NodeJS.ProcessEnv;
     recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
 };
 export type ProjectOpenAiReadOnlyChatAssistantModelOptions = {
     tuttiHome: string;
@@ -23,6 +27,8 @@ export type ProjectOpenAiReadOnlyChatAssistantModelOptions = {
     workspaceRoot: string;
     agentContext?: CodexAppServerAgentContextRuntime;
     recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
 };
 export type ReadOnlyChatAssistantModelResolution = {
     kind: "ready";

package/dist/providers/openai/chat-assistant.js

@@ -31,6 +31,12 @@ export function createOpenAiReadOnlyChatAssistantModel(options) {
                     : { requestTimeoutMs: options.requestTimeoutMs }),
                 ...(options.turnTimeoutMs === undefined ? {} : { turnTimeoutMs: options.turnTimeoutMs }),
                 ...(options.baseEnv === undefined ? {} : { baseEnv: options.baseEnv }),
+                ...(options.invocationCoordinator === undefined
+                    ? {}
+                    : { invocationCoordinator: options.invocationCoordinator }),
+                ...(options.onLifecycleIncident === undefined
+                    ? {}
+                    : { onLifecycleIncident: options.onLifecycleIncident }),
             });
             if (options.recordUsage !== undefined && result.usage !== undefined) {
                 options.recordUsage({
@@ -65,6 +71,12 @@ export function resolveProjectOpenAiReadOnlyChatAssistantModel(options) {
                 userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
                 ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
                 ...(options.recordUsage === undefined ? {} : { recordUsage: options.recordUsage }),
+                ...(options.invocationCoordinator === undefined
+                    ? {}
+                    : { invocationCoordinator: options.invocationCoordinator }),
+                ...(options.onLifecycleIncident === undefined
+                    ? {}
+                    : { onLifecycleIncident: options.onLifecycleIncident }),
             }),
         };
     }

package/dist/providers/openai/index.d.ts

@@ -8,6 +8,7 @@ export * from "./credential-store.js";
 export * from "./credential-validation.js";
 export * from "./model-config.js";
 export * from "./provider-config.js";
+export * from "./provider-models.js";
 export * from "./provider-setup.js";
 export * from "./sdk-procedure-runner.js";
 export * from "./token-usage.js";

package/dist/providers/openai/index.js

@@ -8,6 +8,7 @@ export * from "./credential-store.js";
 export * from "./credential-validation.js";
 export * from "./model-config.js";
 export * from "./provider-config.js";
+export * from "./provider-models.js";
 export * from "./provider-setup.js";
 export * from "./sdk-procedure-runner.js";
 export * from "./token-usage.js";

package/dist/providers/openai/machine-local-files.d.ts

@@ -8,7 +8,7 @@ export type JsonFileReadResult = {
 };
 export declare function ensurePrivateDirectory(directoryPath: string): void;
 export declare function writePrivateJsonFile(filePath: string, value: unknown): void;
-export declare function writePrivateTextFile(filePath: string, value: string): void;
+export declare function writePrivateTextFileAtomically(filePath: string, value: string): void;
 export declare function readJsonFile(filePath: string): JsonFileReadResult;
 export declare function readTextFile(filePath: string): {
     kind: "missing";

package/dist/providers/openai/machine-local-files.js

@@ -1,5 +1,6 @@
-import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
+import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { randomBytes } from "node:crypto";
+import { basename, dirname, join } from "node:path";
 function isErrnoException(error) {
     return error instanceof Error && "code" in error;
 }
@@ -15,13 +16,35 @@ export function writePrivateJsonFile(filePath, value) {
     });
     chmodSync(filePath, 0o600);
 }
-export function writePrivateTextFile(filePath, value) {
-    ensurePrivateDirectory(dirname(filePath));
-    writeFileSync(filePath, value, {
-        encoding: "utf8",
-        mode: 0o600,
-    });
-    chmodSync(filePath, 0o600);
+export function writePrivateTextFileAtomically(filePath, value) {
+    const directoryPath = dirname(filePath);
+    ensurePrivateDirectory(directoryPath);
+    const temporaryPath = join(directoryPath, `.${basename(filePath)}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`);
+    let descriptor;
+    try {
+        descriptor = openSync(temporaryPath, "wx", 0o600);
+        writeFileSync(descriptor, value, { encoding: "utf8" });
+        closeSync(descriptor);
+        descriptor = undefined;
+        renameSync(temporaryPath, filePath);
+    }
+    catch (error) {
+        if (descriptor !== undefined) {
+            try {
+                closeSync(descriptor);
+            }
+            catch {
+                // Preserve the original write or close failure.
+            }
+        }
+        try {
+            unlinkSync(temporaryPath);
+        }
+        catch {
+            // The temporary file may already have been renamed or never created.
+        }
+        throw error;
+    }
 }
 export function readJsonFile(filePath) {
     let raw;

package/dist/providers/openai/provider-config.d.ts

@@ -3,7 +3,7 @@ import { type OpenAiCredentialRef } from "./credential-store.js";
 import type { OPENAI_API_KEY_AUTH_KIND, OPENAI_PROVIDER } from "./model-config.js";
 import { OpenAiProviderConfigError } from "./provider-config-errors.js";
 export { OpenAiProviderConfigError } from "./provider-config-errors.js";
-export { parseOpenAiProviderConfig, } from "./provider-config-shape.js";
+export { parseOpenAiProviderConfig } from "./provider-config-shape.js";
 export type OpenAiProviderConfig = {
     provider: typeof OPENAI_PROVIDER;
     auth_kind: typeof OPENAI_API_KEY_AUTH_KIND;
@@ -58,6 +58,10 @@ export type OpenAiProviderConfigResolution = {
 };
 export declare function resolveTuttiHome(input: string | undefined, cwd?: string): string;
 export declare function getProjectProviderConfigPath(tuttiHome: string, projectId: ProjectId): string;
+export declare function withProjectOpenAiProviderConfigLock<T>(options: {
+    tuttiHome: string;
+    projectId: ProjectId;
+}, operation: () => Promise<T>): Promise<T>;
 export declare function readProjectOpenAiProviderConfig(tuttiHome: string, projectId: ProjectId): ProviderConfigReadResult<OpenAiProviderConfig>;
 export declare function resolveOpenAiProviderConfig(options: {
     tuttiHome: string;

package/dist/providers/openai/provider-config.js

@@ -1,12 +1,12 @@
 import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
-import { openAiCredentialExists, } from "./credential-store.js";
-import { readTextFile, writePrivateTextFile } from "./machine-local-files.js";
+import { openAiCredentialExists } from "./credential-store.js";
+import { readTextFile, writePrivateTextFileAtomically } from "./machine-local-files.js";
 import { OpenAiProviderConfigError } from "./provider-config-errors.js";
 import { parseOpenAiProviderConfig } from "./provider-config-shape.js";
 import { formatProjectOpenAiProviderConfig, parseTomlOpenAiSection, parseTuttiConfigToml, } from "./provider-config-toml.js";
 export { OpenAiProviderConfigError } from "./provider-config-errors.js";
-export { parseOpenAiProviderConfig, } from "./provider-config-shape.js";
+export { parseOpenAiProviderConfig } from "./provider-config-shape.js";
 export function resolveTuttiHome(input, cwd = process.cwd()) {
     if (input === undefined || input.trim() === "") {
         return join(homedir(), ".tutti");
@@ -23,6 +23,27 @@ export function resolveTuttiHome(input, cwd = process.cwd()) {
 export function getProjectProviderConfigPath(tuttiHome, projectId) {
     return join(tuttiHome, "projects", projectId, "config.toml");
 }
+const providerConfigMutationTails = new Map();
+export async function withProjectOpenAiProviderConfigLock(options, operation) {
+    const key = getProjectProviderConfigPath(options.tuttiHome, options.projectId);
+    const previous = providerConfigMutationTails.get(key) ?? Promise.resolve();
+    let release = () => { };
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    const tail = previous.then(() => current);
+    providerConfigMutationTails.set(key, tail);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (providerConfigMutationTails.get(key) === tail) {
+            providerConfigMutationTails.delete(key);
+        }
+    }
+}
 export function readProjectOpenAiProviderConfig(tuttiHome, projectId) {
     const sourcePath = getProjectProviderConfigPath(tuttiHome, projectId);
     const readResult = readTextFile(sourcePath);
@@ -77,7 +98,7 @@ export function resolveOpenAiProviderConfig(options) {
     };
 }
 export function writeProjectOpenAiProviderConfig(tuttiHome, projectId, config) {
-    writePrivateTextFile(getProjectProviderConfigPath(tuttiHome, projectId), formatProjectOpenAiProviderConfig(config));
+    writePrivateTextFileAtomically(getProjectProviderConfigPath(tuttiHome, projectId), formatProjectOpenAiProviderConfig(config));
 }
 export function createRedactedOpenAiProviderConfigProjection(config) {
     const projection = {

package/dist/providers/openai/provider-models.d.ts

@@ -0,0 +1,41 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import { type OpenAiCredentialValidationFailureReason, type OpenAiCredentialValidationInput, type OpenAiCredentialValidationResult, type OpenAiModelDiscoveryInput, type OpenAiModelDiscoveryResult } from "./credential-validation.js";
+import { type RedactedOpenAiProviderConfigProjection } from "./provider-config.js";
+export type ProjectOpenAiProviderUnavailableReason = "provider_not_configured" | "provider_config_invalid" | "provider_credential_missing";
+export type ProjectOpenAiModelDiscoveryResult = OpenAiModelDiscoveryResult | {
+    kind: "unavailable";
+    reason: ProjectOpenAiProviderUnavailableReason;
+};
+export type UpdateProjectOpenAiDefaultModelResult = {
+    kind: "updated";
+    projection: RedactedOpenAiProviderConfigProjection;
+} | {
+    kind: "unchanged";
+    projection: RedactedOpenAiProviderConfigProjection;
+} | {
+    kind: "stale_default_model";
+    current_default_model: string;
+} | {
+    kind: "validation_failed";
+    reason: OpenAiCredentialValidationFailureReason;
+    retryable: boolean;
+} | {
+    kind: "provider_unavailable";
+    reason: ProjectOpenAiProviderUnavailableReason;
+};
+export type DiscoverProjectOpenAiModelsOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    discoverModels?: (input: OpenAiModelDiscoveryInput) => Promise<OpenAiModelDiscoveryResult>;
+};
+export type UpdateProjectOpenAiDefaultModelOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    defaultModel: string;
+    expectedDefaultModel: string;
+    now?: () => Date;
+    validateCredential?: (input: OpenAiCredentialValidationInput) => Promise<OpenAiCredentialValidationResult>;
+};
+export declare function discoverProjectOpenAiModels(options: DiscoverProjectOpenAiModelsOptions): Promise<ProjectOpenAiModelDiscoveryResult>;
+export declare function updateProjectOpenAiDefaultModel(options: UpdateProjectOpenAiDefaultModelOptions): Promise<UpdateProjectOpenAiDefaultModelResult>;
+//# sourceMappingURL=provider-models.d.ts.map

package/dist/providers/openai/provider-models.js

@@ -0,0 +1,82 @@
+import { readOpenAiApiKeyCredential } from "./credential-store.js";
+import { discoverOpenAiModels, validateOpenAiCredential, } from "./credential-validation.js";
+import { createRedactedOpenAiProviderConfigProjection, readProjectOpenAiProviderConfig, withProjectOpenAiProviderConfigLock, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
+function providerConfigSnapshot(options) {
+    const config = readProjectOpenAiProviderConfig(options.tuttiHome, options.projectId);
+    if (config.kind === "missing") {
+        return { kind: "unavailable", reason: "provider_not_configured" };
+    }
+    if (config.kind === "invalid") {
+        return { kind: "unavailable", reason: "provider_config_invalid" };
+    }
+    try {
+        const credential = readOpenAiApiKeyCredential(options.tuttiHome, options.projectId, config.config.credential_ref);
+        return { kind: "ready", config: config.config, apiKey: credential.secret };
+    }
+    catch {
+        return { kind: "unavailable", reason: "provider_credential_missing" };
+    }
+}
+function providerInput(config, apiKey) {
+    return {
+        apiKey,
+        ...(config.api_base_url === undefined ? {} : { apiBaseUrl: config.api_base_url }),
+        ...(config.organization_id === undefined ? {} : { organizationId: config.organization_id }),
+        ...(config.openai_project_id === undefined
+            ? {}
+            : { openAiProjectId: config.openai_project_id }),
+    };
+}
+export async function discoverProjectOpenAiModels(options) {
+    return await withProjectOpenAiProviderConfigLock(options, async () => {
+        const snapshot = providerConfigSnapshot(options);
+        if (snapshot.kind === "unavailable") {
+            return snapshot;
+        }
+        return await (options.discoverModels ?? discoverOpenAiModels)(providerInput(snapshot.config, snapshot.apiKey));
+    });
+}
+export async function updateProjectOpenAiDefaultModel(options) {
+    return await withProjectOpenAiProviderConfigLock(options, async () => {
+        const snapshot = providerConfigSnapshot(options);
+        if (snapshot.kind === "unavailable") {
+            return { kind: "provider_unavailable", reason: snapshot.reason };
+        }
+        if (snapshot.config.default_model !== options.expectedDefaultModel) {
+            return {
+                kind: "stale_default_model",
+                current_default_model: snapshot.config.default_model,
+            };
+        }
+        if (snapshot.config.default_model === options.defaultModel) {
+            return {
+                kind: "unchanged",
+                projection: createRedactedOpenAiProviderConfigProjection(snapshot.config),
+            };
+        }
+        const validator = options.validateCredential ??
+            ((input) => validateOpenAiCredential(input, options.now === undefined ? {} : { now: options.now }));
+        const validation = await validator({
+            ...providerInput(snapshot.config, snapshot.apiKey),
+            defaultModel: options.defaultModel,
+        });
+        if (validation.kind === "failed") {
+            return {
+                kind: "validation_failed",
+                reason: validation.reason,
+                retryable: validation.retryable,
+            };
+        }
+        const config = {
+            ...snapshot.config,
+            default_model: validation.default_model,
+            validated_at: validation.validated_at,
+        };
+        writeProjectOpenAiProviderConfig(options.tuttiHome, options.projectId, config);
+        return {
+            kind: "updated",
+            projection: createRedactedOpenAiProviderConfigProjection(config),
+        };
+    });
+}
+//# sourceMappingURL=provider-models.js.map

package/dist/providers/openai/provider-setup.js

@@ -1,7 +1,7 @@
 import { createOpenAiCredentialRef, createRedactedOpenAiApiKeyLabel, isOpenAiApiKey, writeOpenAiApiKeyCredential, } from "./credential-store.js";
 import { validateOpenAiCredential, } from "./credential-validation.js";
 import { DEFAULT_OPENAI_MODEL, OPENAI_API_KEY_AUTH_KIND, OPENAI_PROVIDER } from "./model-config.js";
-import { createRedactedOpenAiProviderConfigProjection, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
+import { createRedactedOpenAiProviderConfigProjection, withProjectOpenAiProviderConfigLock, writeProjectOpenAiProviderConfig, } from "./provider-config.js";
 function trimOptional(value) {
     const trimmed = value?.trim();
     return trimmed === undefined || trimmed === "" ? undefined : trimmed;
@@ -32,7 +32,7 @@ function validationInput(options) {
     }
     return input;
 }
-export async function configureProjectOpenAiProvider(options) {
+async function configureProjectOpenAiProviderUnlocked(options) {
     const apiKey = options.apiKey.trim();
     if (!isOpenAiApiKey(apiKey)) {
         return {
@@ -85,4 +85,7 @@ export async function configureProjectOpenAiProvider(options) {
         projection: createRedactedOpenAiProviderConfigProjection(config),
     };
 }
+export async function configureProjectOpenAiProvider(options) {
+    return await withProjectOpenAiProviderConfigLock(options, () => configureProjectOpenAiProviderUnlocked(options));
+}
 //# sourceMappingURL=provider-setup.js.map

package/dist/run-engine/index.js

@@ -1,4 +1,5 @@
 import { createActivityRef } from "@tutti/shared/ids";
+import { safeRuntimeFailureSummary } from "../runtime-failures.js";
 export class RunEngine {
     active = null;
     lastConclusion = null;
@@ -43,7 +44,7 @@ export class RunEngine {
             catch (error) {
                 this.finishActive(activityRef, {
                     kind: "failed",
-                    summary: error instanceof Error ? error.message : "Run failed",
+                    summary: safeRuntimeFailureSummary("Run", error, "run_failed"),
                 }, options.onTransition);
             }
         };

package/dist/run-pipeline/artifact-applicability.js

@@ -251,13 +251,13 @@ export async function runArtifactCandidateGate(options) {
         try {
             applicability = await judgeApplicability(options.judge ?? createDefaultJudge(options), input);
         }
-        catch (error) {
+        catch {
             return gateFailure({
                 reasonCode: "artifact_applicability_failed",
                 summary: "Tutti could not determine whether this candidate requires an Artifact.",
                 guidance: "Retry when the Artifact applicability provider is available.",
                 source: "applicability_judge",
-                detail: error instanceof Error ? error.message : "Artifact applicability judge failed",
+                detail: "Artifact applicability could not be determined by the provider.",
                 correctable: false,
             });
         }

package/dist/run-pipeline/openai.d.ts

@@ -1,5 +1,6 @@
 import type { ProjectId } from "@tutti/shared/ids";
 import type { ApprovalRequestManager } from "../approvals/index.js";
+import { type CheckProcessCoordinator } from "../checks/index.js";
 import type { ControlPlaneLogger, RunPipelineResolution, RunPipelineRunner } from "../control-plane/index.js";
 import type { ProviderUsageRecorder } from "../provider-usage/index.js";
 import type { OpenAiStructuredOutputClient } from "../providers/openai/sdk-procedure-runner.js";
@@ -8,6 +9,8 @@ import { type ArtifactApplicabilityJudge } from "./artifact-applicability.js";
 import { type OpenAiProviderConfig } from "../providers/openai/provider-config.js";
 import { type CodexLinuxSandboxReadiness } from "../providers/openai/app-server/linux-sandbox-readiness.js";
 import type { CodexAppServerAgentContextRuntime } from "../providers/openai/app-server/skills.js";
+import type { CodexAppServerInvocationCoordinator } from "../providers/openai/app-server/invocation-coordinator.js";
+import type { CodexAppServerLifecycleIncident } from "../providers/openai/app-server/invocation-lifecycle.js";
 export { TASK_RUN_OUTPUT_SCHEMA } from "./task-run-output.js";
 export type OpenAiRunPipelineRunnerOptions = {
     config: OpenAiProviderConfig;
@@ -23,9 +26,12 @@ export type OpenAiRunPipelineRunnerOptions = {
     requestTimeoutMs?: number;
     turnTimeoutMs?: number;
     checkTimeoutMs?: number;
+    checkProcessCoordinator?: CheckProcessCoordinator;
     baseEnv?: NodeJS.ProcessEnv;
     logger?: ControlPlaneLogger | undefined;
     recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
     artifactApplicabilityClient?: OpenAiStructuredOutputClient;
     artifactApplicabilityJudge?: ArtifactApplicabilityJudge;
     validateArtifactCandidate?: (options: ValidateCandidateArtifactOptions) => Promise<CandidateArtifactValidationResult>;
@@ -40,6 +46,9 @@ export type ProjectOpenAiRunPipelineRunnerOptions = {
     approvalManager?: ApprovalRequestManager;
     logger?: ControlPlaneLogger | undefined;
     recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    checkProcessCoordinator?: CheckProcessCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
 };
 export declare function createOpenAiRunPipelineRunner(options: OpenAiRunPipelineRunnerOptions): RunPipelineRunner;
 export declare function resolveProjectOpenAiRunPipelineRunner(options: ProjectOpenAiRunPipelineRunnerOptions): RunPipelineResolution;

package/dist/run-pipeline/openai.js

@@ -1,4 +1,4 @@
-import { createNodeNpmCheckPlan, executeCheckPlan } from "../checks/index.js";
+import { createNodeNpmCheckPlan, executeCheckPlan, } from "../checks/index.js";
 import { runArtifactCandidateGate, } from "./artifact-applicability.js";
 import { checkSkipFields, checkStatus, checksSummary, completedWithoutRepoChanges, docsStatusForChangedPaths, failedBeforeChecks, failedFinishedResult, promotionNotAttempted, promotionNotPromoted, successfulRunSummary, } from "./result-projections.js";
 import { runWorkspaceWriteTask } from "./task-run-invocation.js";
@@ -13,28 +13,16 @@ function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function summarizeProviderError(error) {
-    const diagnosticParts = [
-        error.details.turn_error_code === undefined
-            ? ""
-            : `provider_code=${error.details.turn_error_code}`,
-        error.details.turn_error_http_status === undefined
-            ? ""
-            : `http_status=${error.details.turn_error_http_status}`,
-        error.details.stderr_excerpt === undefined || error.details.stderr_excerpt.trim() === ""
-            ? ""
-            : `stderr=${error.details.stderr_excerpt}`,
-    ].filter((part) => part !== "");
-    const summary = diagnosticParts.length === 0
-        ? error.message
-        : `${error.message} (${diagnosticParts.join("; ")})`;
-    const looksLikeSchemaError = summary.includes("invalid_json_schema") ||
-        summary.includes("Invalid schema") ||
-        summary.includes("response_format");
+    const looksLikeSchemaError = error.details.turn_error_code === "invalid_json_schema" ||
+        error.message.includes("invalid_json_schema") ||
+        error.message.includes("Invalid schema") ||
+        error.message.includes("response_format");
+    const errorCode = looksLikeSchemaError
+        ? "codex_app_server_output_schema_invalid"
+        : `codex_app_server_${error.code}`;
     return failedBeforeChecks({
-        summary,
-        errorCode: looksLikeSchemaError
-            ? "codex_app_server_output_schema_invalid"
-            : `codex_app_server_${error.code}`,
+        summary: `Provider execution failed before checks. (${errorCode})`,
+        errorCode,
         retryable: !looksLikeSchemaError &&
             (error.code === "app_server_protocol_error" ||
                 error.code === "turn_timeout" ||
@@ -44,13 +32,13 @@ function summarizeProviderError(error) {
 }
 function summarizeWorkspaceOpsError(error, changedPaths) {
     return failedBeforeChecks({
-        summary: error.message,
+        summary: `Workspace operation failed before checks. (workspace_ops_${error.code})`,
         errorCode: `workspace_ops_${error.code}`,
         retryable: error.code === "conflict",
         ...(changedPaths === undefined ? {} : { changedPaths }),
         promotion: error.code === "conflict"
-            ? promotionNotPromoted("mainline_not_promotable", error.message)
-            : promotionNotAttempted("workspace_ops_failed", error.message),
+            ? promotionNotPromoted("mainline_not_promotable", "Workspace state could not be accepted safely.")
+            : promotionNotAttempted("workspace_ops_failed", "Workspace operation failed before promotion."),
     });
 }
 function runLineageFields(input) {
@@ -359,6 +347,9 @@ async function runTaskAttempt(options, input) {
             workspaceRoot: options.workspaceRoot,
             plan: checkPlan,
             ...(options.checkTimeoutMs === undefined ? {} : { timeoutMs: options.checkTimeoutMs }),
+            ...(options.checkProcessCoordinator === undefined
+                ? {}
+                : { processCoordinator: options.checkProcessCoordinator }),
         }), (result) => ({ checks_status: result.status, command_count: result.commands.length }));
         if (checks.status === "failed") {
             const result = failedFinishedResult({
@@ -441,7 +432,7 @@ async function runTaskAttempt(options, input) {
             return summarizeWorkspaceOpsError(error, changedPaths);
         }
         return failedBeforeChecks({
-            summary: error instanceof Error ? error.message : "Run pipeline failed",
+            summary: "Run pipeline failed before checks. (run_pipeline_failed)",
             errorCode: "run_pipeline_failed",
             retryable: false,
             ...(changedPaths === undefined ? {} : { changedPaths }),
@@ -529,6 +520,15 @@ export function resolveProjectOpenAiRunPipelineRunner(options) {
             ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
             ...(options.logger === undefined ? {} : { logger: options.logger }),
             ...(options.recordUsage === undefined ? {} : { recordUsage: options.recordUsage }),
+            ...(options.invocationCoordinator === undefined
+                ? {}
+                : { invocationCoordinator: options.invocationCoordinator }),
+            ...(options.checkProcessCoordinator === undefined
+                ? {}
+                : { checkProcessCoordinator: options.checkProcessCoordinator }),
+            ...(options.onLifecycleIncident === undefined
+                ? {}
+                : { onLifecycleIncident: options.onLifecycleIncident }),
             ...(process.platform === "linux"
                 ? { codexSandboxReadiness: () => inspectCodexLinuxSandboxReadiness() }
                 : {}),

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

@@ -111,6 +111,12 @@ export async function runWorkspaceWriteTask(options, input) {
                 : { requestTimeoutMs: options.requestTimeoutMs }),
             ...(options.turnTimeoutMs === undefined ? {} : { turnTimeoutMs: options.turnTimeoutMs }),
             ...(options.baseEnv === undefined ? {} : { baseEnv: options.baseEnv }),
+            ...(options.invocationCoordinator === undefined
+                ? {}
+                : { invocationCoordinator: options.invocationCoordinator }),
+            ...(options.onLifecycleIncident === undefined
+                ? {}
+                : { onLifecycleIncident: options.onLifecycleIncident }),
             runtimeTelemetry: {
                 activityRef: input.activity_ref,
                 stageId: "provider_task_run",

package/dist/runtime-failures.d.ts

@@ -0,0 +1,3 @@
+export declare function stableRuntimeFailureCode(error: unknown, fallback: string): string;
+export declare function safeRuntimeFailureSummary(subject: "Procedure" | "Run", error: unknown, fallbackCode: "procedure_failed" | "run_failed"): string;
+//# sourceMappingURL=runtime-failures.d.ts.map

package/dist/runtime-failures.js

@@ -0,0 +1,22 @@
+const STABLE_FAILURE_CODE = /^[a-z][a-z0-9_]{0,63}$/u;
+export function stableRuntimeFailureCode(error, fallback) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        STABLE_FAILURE_CODE.test(error.code)) {
+        return error.code;
+    }
+    return fallback;
+}
+export function safeRuntimeFailureSummary(subject, error, fallbackCode) {
+    const code = stableRuntimeFailureCode(error, fallbackCode);
+    if (code === "process_lifecycle_failed" || code === "process_tree_not_terminated") {
+        return `${subject} stopped because the provider process could not close safely. Restart the Host before retrying. (${code})`;
+    }
+    if (code === "admission_unavailable" || code === "admission_closed") {
+        return `${subject} stopped because provider execution is unavailable while the Host is closing. Retry after the Host is ready. (${code})`;
+    }
+    return `${subject} failed because the runtime returned an internal error. Retry the action. (${code})`;
+}
+//# sourceMappingURL=runtime-failures.js.map

package/dist/server-shell/cli/host-lifecycle.js

@@ -393,7 +393,7 @@ export function formatLaunchLifecycleResult(result, options = {}) {
 }
 export async function waitForForegroundHostShutdown(handle, processLike = process) {
     const stop = () => {
-        void handle.close();
+        void handle.close().catch(() => undefined);
     };
     processLike.once("SIGINT", stop);
     processLike.once("SIGTERM", stop);

package/dist/server-shell/cli/host-project-runtime-lifecycle.d.ts

@@ -0,0 +1,43 @@
+type ControlPlaneLifecycleOwner = {
+    beginShutdown: () => void;
+    waitForIdle: () => Promise<void>;
+};
+type ChatAssistantLifecycleOwner = {
+    stopAccepting: () => void;
+    waitForIdle: () => Promise<void>;
+};
+type InvocationLifecycleOwner = {
+    stopAccepting: () => void;
+    closeActive: () => Promise<void>;
+    waitForIdle: () => Promise<void>;
+};
+type CheckLifecycleOwner = {
+    stopAccepting: () => void;
+    terminateActive: () => Promise<void>;
+    waitForIdle: () => Promise<void>;
+};
+type ApprovalLifecycleOwner = {
+    clearPending: () => void;
+    dispose: () => void;
+};
+export declare class HostProjectRuntimeShutdownError extends Error {
+    readonly code: "drain_timeout";
+    constructor(code: "drain_timeout", message: string);
+}
+export declare class HostProjectRuntimeLifecycle {
+    private readonly options;
+    private closePromise;
+    constructor(options: {
+        controlPlane: ControlPlaneLifecycleOwner;
+        chatAssistant: ChatAssistantLifecycleOwner;
+        invocationCoordinator: InvocationLifecycleOwner;
+        checkProcessCoordinator: CheckLifecycleOwner;
+        approvalManager: ApprovalLifecycleOwner;
+        gracefulDrainMs?: number;
+        forcedDrainMs?: number;
+    });
+    close(): Promise<void>;
+    private closeOnce;
+}
+export {};
+//# sourceMappingURL=host-project-runtime-lifecycle.d.ts.map