@xfey/tutti 0.1.78 → 0.1.79

package/dist/control-plane/run-result-recording.js

@@ -1,4 +1,5 @@
 import { recordRunNeedsHumanResult, recordRunResult, } from "../collaboration-state/index.js";
+import { safeRuntimeFailureSummary } from "../runtime-failures.js";
 export function recordRunPipelineResult(input) {
     if (input.pipelineResult.result_kind === "needs_human") {
         const recorded = recordRunNeedsHumanResult(input.store.db, {
@@ -35,7 +36,7 @@ export function recordRunPipelineResult(input) {
     };
 }
 export function recordRunPipelineFailure(input) {
-    const summary = input.error instanceof Error ? input.error.message : "Run failed";
+    const summary = safeRuntimeFailureSummary("Run", input.error, "run_failed");
     const recorded = recordRunResult(input.store.db, {
         activity_ref: input.activityRef,
         task_id: input.task.id,

package/dist/control-plane/task-compile-start.d.ts

@@ -17,6 +17,7 @@ export declare function startControlPlaneTaskCompile(options: {
     publishProcedureTransition: (state: ProcedureEngineState) => void;
     registerReferenceSummaryWaiter: (activityRef: ActivityRef, waiter: (state: ProcedureEngineState) => void) => void;
     onTasksAdded: () => void;
+    shouldContinue?: () => boolean;
 }): ControlPlaneCommandResult<SubmitWorklistDisposition, SubmitWorklistResult>;
 export declare function runControlPlaneTaskCompileProcedure(options: {
     runner: ProcedureWorkflowRunner;

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

@@ -137,6 +137,9 @@ function startScratchpadRefreshBeforeTaskCompileActivity(options) {
             if (state.transition_kind !== "terminal" || state.activity.status !== "finished") {
                 return;
             }
+            if (options.shouldContinue?.() === false) {
+                return;
+            }
             const scratchpad = readScratchpadProjection(options.store.db);
             if (!scratchpadHasSubmittableContent(scratchpad)) {
                 return;
@@ -257,7 +260,7 @@ function startReferenceSummaryGateOrNextStage(options) {
 }
 function registerReferenceSummaryGateWaiter(options, activityRef) {
     options.registerReferenceSummaryWaiter(activityRef, (state) => {
-        if (state.activity.status !== "finished") {
+        if (state.activity.status !== "finished" || options.shouldContinue?.() === false) {
             rollbackTaskCompileContext(options.store.db, {
                 workflow_ref: options.taskCompileWorkflowRef,
                 now: options.now,
@@ -300,6 +303,13 @@ function startProjectContextBootstrapActivity(options) {
             if (state.transition_kind !== "terminal" || state.activity.status !== "finished") {
                 return;
             }
+            if (options.shouldContinue?.() === false) {
+                rollbackTaskCompileContext(options.store.db, {
+                    workflow_ref: options.taskCompileWorkflowRef,
+                    now: options.now,
+                });
+                return;
+            }
             if (shouldInitializeControlPlaneProjectContext(options)) {
                 return;
             }

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

@@ -4,6 +4,8 @@ import { type OpenAiStructuredOutputClient } from "../../providers/openai/sdk-pr
 import { type OpenAiProviderConfig } from "../../providers/openai/provider-config.js";
 import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolution, TaskCompilePromptInput, TaskCompileWorkflowInput } from "./types.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 type OpenAiProcedureWorkflowRunnerOptions = {
     config: OpenAiProviderConfig;
     client: OpenAiStructuredOutputClient;
@@ -20,6 +22,8 @@ export type OpenAiProcedureWorkflowRunnerOptions = {
         userSkillsRoot?: string;
         builtInSkillsRoot?: string;
         agentContext?: CodexAppServerAgentContextRuntime;
+        invocationCoordinator?: CodexAppServerInvocationCoordinator;
+        onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
     };
 };
 export type ProjectOpenAiProcedureWorkflowRunnerOptions = {
@@ -29,6 +33,8 @@ export type ProjectOpenAiProcedureWorkflowRunnerOptions = {
     promptsRoot?: string;
     agentContext?: CodexAppServerAgentContextRuntime;
     recordUsage?: ProviderUsageRecorder;
+    invocationCoordinator?: CodexAppServerInvocationCoordinator;
+    onLifecycleIncident?: (incident: CodexAppServerLifecycleIncident) => void;
 };
 export declare function buildTaskCompilePromptInput(input: TaskCompileWorkflowInput): TaskCompilePromptInput;
 export declare function createOpenAiProcedureWorkflowRunner(options: OpenAiProcedureWorkflowRunnerOptions): ProcedureWorkflowRunner;

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

@@ -1,4 +1,5 @@
-import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
+import { copyFileSync, mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { extname, isAbsolute, join, relative, resolve } from "node:path";
 import { renderPromptTemplate } from "../../prompt-templates/index.js";
@@ -46,6 +47,12 @@ function readOnlyAppServerOptions(options, prompt, outputSchema, skillSelectionN
         ...(options.readOnlyAppServer.agentContext === undefined
             ? {}
             : { agentContext: options.readOnlyAppServer.agentContext }),
+        ...(options.readOnlyAppServer.invocationCoordinator === undefined
+            ? {}
+            : { invocationCoordinator: options.readOnlyAppServer.invocationCoordinator }),
+        ...(options.readOnlyAppServer.onLifecycleIncident === undefined
+            ? {}
+            : { onLifecycleIncident: options.readOnlyAppServer.onLifecycleIncident }),
     };
 }
 function readOnlyRuntimeTelemetry(context, stageId) {
@@ -81,7 +88,7 @@ function createReferenceSummaryWorkspace(input) {
     copyFileSync(input.sourcePath, join(root, `target${extension}`));
     return {
         cwd: root,
-        cleanup: () => rmSync(root, { recursive: true, force: true }),
+        cleanup: () => rm(root, { recursive: true, force: true, maxRetries: 4, retryDelay: 50 }),
     };
 }
 function referenceFileSummaryWorkflowOutput(output, originalPath) {
@@ -379,7 +386,7 @@ export function createOpenAiProcedureWorkflowRunner(options) {
                 return referenceFileSummaryWorkflowOutput(result.output, input.file.path);
             }
             finally {
-                workspace.cleanup();
+                await workspace.cleanup();
             }
         };
     }
@@ -420,6 +427,12 @@ export function resolveProjectOpenAiProcedureWorkflowRunner(options) {
                 tuttiHome: options.tuttiHome,
                 userSkillsRoot: getProjectUserSkillsRoot(options.tuttiHome, options.projectId),
                 ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
+                ...(options.invocationCoordinator === undefined
+                    ? {}
+                    : { invocationCoordinator: options.invocationCoordinator }),
+                ...(options.onLifecycleIncident === undefined
+                    ? {}
+                    : { onLifecycleIncident: options.onLifecycleIncident }),
             },
             ...(options.recordUsage === undefined ? {} : { recordUsage: options.recordUsage }),
         }),

package/dist/procedure-engine/index.d.ts

@@ -56,6 +56,7 @@ export declare class ProcedureEngine {
     getActiveProcedures(): ActivityProjection[];
     getExecutionStatus(): ExecutionStatusProjection;
     waitForIdle(): Promise<void>;
+    waitForLaneIdle(lane: ProcedureLane): Promise<void>;
     private stateForActivity;
     private updateActiveProgress;
     private finishActive;

package/dist/procedure-engine/index.js

@@ -1,4 +1,5 @@
 import { createActivityRef } from "@tutti/shared/ids";
+import { safeRuntimeFailureSummary } from "../runtime-failures.js";
 const DEFAULT_PROCEDURE_LANE = "foreground";
 const PROCEDURE_LANE_ORDER = ["foreground", "scratchpad_background"];
 export class ProcedureEngine {
@@ -55,7 +56,7 @@ export class ProcedureEngine {
                 }
                 this.finishActive(activityRef, lane, {
                     kind: "failed",
-                    summary: error instanceof Error ? error.message : "Procedure failed",
+                    summary: safeRuntimeFailureSummary("Procedure", error, "procedure_failed"),
                 }, options.onTransition);
             }
         };
@@ -101,6 +102,11 @@ export class ProcedureEngine {
             await Promise.all(this.orderedActiveProcedures().map((active) => active.promise));
         }
     }
+    async waitForLaneIdle(lane) {
+        while (this.activeByLane.has(lane)) {
+            await this.activeByLane.get(lane)?.promise;
+        }
+    }
     stateForActivity(activity, transitionKind, progress) {
         const state = {
             activity,

package/dist/process-tree.d.ts

@@ -0,0 +1,25 @@
+import type { ChildProcess } from "node:child_process";
+export type ManagedChildProcess<TChild extends ChildProcess = ChildProcess> = {
+    child: TChild;
+    processGroupId?: number;
+    hasClosed: () => boolean;
+    closed: Promise<{
+        code: number | null;
+        signal: NodeJS.Signals | null;
+    }>;
+};
+export type ProcessTreeTerminationOptions = {
+    termGraceMs?: number;
+    killGraceMs?: number;
+    pollIntervalMs?: number;
+};
+export declare class ProcessTreeTerminationError extends Error {
+    readonly code: "process_tree_not_terminated";
+    constructor(code: "process_tree_not_terminated", message: string);
+}
+export declare function systemErrorCode(error: unknown): string;
+export declare function createManagedChildProcess<TChild extends ChildProcess>(child: TChild): ManagedChildProcess<TChild>;
+export declare function terminateManagedProcessTree(managedProcess: ManagedChildProcess, options?: ProcessTreeTerminationOptions): Promise<{
+    forced: boolean;
+}>;
+//# sourceMappingURL=process-tree.d.ts.map

package/dist/process-tree.js

@@ -0,0 +1,121 @@
+export class ProcessTreeTerminationError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ProcessTreeTerminationError";
+    }
+}
+const DEFAULT_TERM_GRACE_MS = 3_000;
+const DEFAULT_KILL_GRACE_MS = 2_000;
+const DEFAULT_POLL_INTERVAL_MS = 25;
+export function systemErrorCode(error) {
+    if (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (typeof error.code === "string" || typeof error.code === "number")) {
+        return String(error.code);
+    }
+    return error instanceof Error && error.name !== "" ? error.name : "UnknownError";
+}
+export function createManagedChildProcess(child) {
+    let closedState = false;
+    const closed = new Promise((resolve) => {
+        let settled = false;
+        const settle = (code, signal) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            closedState = true;
+            resolve({ code, signal });
+        };
+        if (child.exitCode !== null || child.signalCode !== null) {
+            settle(child.exitCode, child.signalCode);
+            return;
+        }
+        child.once("close", settle);
+        child.once("error", () => settle(child.exitCode, child.signalCode));
+    });
+    return {
+        child,
+        ...(process.platform === "win32" || child.pid === undefined
+            ? {}
+            : { processGroupId: child.pid }),
+        hasClosed: () => closedState,
+        closed,
+    };
+}
+function processGroupIsAlive(processGroupId) {
+    try {
+        process.kill(-processGroupId, 0);
+        return true;
+    }
+    catch (error) {
+        return systemErrorCode(error) !== "ESRCH";
+    }
+}
+function childIsAlive(managedProcess) {
+    return (!managedProcess.hasClosed() &&
+        managedProcess.child.exitCode === null &&
+        managedProcess.child.signalCode === null);
+}
+function processTreeIsAlive(managedProcess) {
+    if (managedProcess.processGroupId !== undefined) {
+        return processGroupIsAlive(managedProcess.processGroupId);
+    }
+    return childIsAlive(managedProcess);
+}
+function sendProcessTreeSignal(managedProcess, signal) {
+    if (managedProcess.processGroupId !== undefined) {
+        try {
+            process.kill(-managedProcess.processGroupId, signal);
+            return;
+        }
+        catch (error) {
+            if (systemErrorCode(error) === "ESRCH") {
+                return;
+            }
+        }
+    }
+    if (childIsAlive(managedProcess)) {
+        try {
+            managedProcess.child.kill(signal);
+        }
+        catch {
+            // The bounded wait below decides whether termination actually succeeded.
+        }
+    }
+}
+function wait(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+async function waitForProcessTreeExit(managedProcess, timeoutMs, pollIntervalMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (processTreeIsAlive(managedProcess)) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            return false;
+        }
+        await wait(Math.min(pollIntervalMs, remainingMs));
+    }
+    await Promise.race([managedProcess.closed.then(() => undefined), wait(pollIntervalMs)]);
+    return !processTreeIsAlive(managedProcess);
+}
+export async function terminateManagedProcessTree(managedProcess, options = {}) {
+    if (!processTreeIsAlive(managedProcess)) {
+        await managedProcess.closed;
+        return { forced: false };
+    }
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    sendProcessTreeSignal(managedProcess, "SIGTERM");
+    if (await waitForProcessTreeExit(managedProcess, options.termGraceMs ?? DEFAULT_TERM_GRACE_MS, pollIntervalMs)) {
+        return { forced: false };
+    }
+    sendProcessTreeSignal(managedProcess, "SIGKILL");
+    if (await waitForProcessTreeExit(managedProcess, options.killGraceMs ?? DEFAULT_KILL_GRACE_MS, pollIntervalMs)) {
+        return { forced: true };
+    }
+    throw new ProcessTreeTerminationError("process_tree_not_terminated", "Child process tree did not terminate within the bounded shutdown window.");
+}
+//# sourceMappingURL=process-tree.js.map

package/dist/providers/openai/app-server/invocation-coordinator.d.ts

@@ -0,0 +1,28 @@
+export type CodexAppServerInvocationLease = {
+    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

package/dist/providers/openai/app-server/invocation-coordinator.js

@@ -0,0 +1,104 @@
+export class CodexAppServerAdmissionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "CodexAppServerAdmissionError";
+    }
+}
+export class CodexAppServerInvocationCoordinator {
+    accepting = true;
+    active = null;
+    queue = [];
+    idleWaiters = new Set();
+    maxQueued;
+    constructor(options = {}) {
+        this.maxQueued = options.maxQueued ?? 32;
+    }
+    get activeCount() {
+        return this.active === null ? 0 : 1;
+    }
+    get queuedCount() {
+        return this.queue.length;
+    }
+    acquire() {
+        if (!this.accepting) {
+            return Promise.reject(new CodexAppServerAdmissionError("admission_closed", "Codex app-server admission is closed."));
+        }
+        if (this.active === null) {
+            return Promise.resolve(this.activate());
+        }
+        if (this.queue.length >= this.maxQueued) {
+            return Promise.reject(new CodexAppServerAdmissionError("queue_full", "Codex app-server admission queue is full."));
+        }
+        return new Promise((resolve, reject) => {
+            this.queue.push({ resolve, reject });
+        });
+    }
+    stopAccepting() {
+        if (!this.accepting) {
+            return;
+        }
+        this.accepting = false;
+        const error = new CodexAppServerAdmissionError("admission_closed", "Codex app-server admission is closed.");
+        for (const pending of this.queue.splice(0)) {
+            pending.reject(error);
+        }
+        this.resolveIdleIfNeeded();
+    }
+    async closeActive() {
+        const active = this.active;
+        if (active?.closer !== undefined) {
+            await active.closer();
+        }
+    }
+    waitForIdle() {
+        if (this.active === null && this.queue.length === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    activate() {
+        const admission = { released: false };
+        this.active = admission;
+        return {
+            setCloser: (closer) => {
+                if (!admission.released) {
+                    admission.closer = closer;
+                }
+            },
+            release: () => {
+                if (admission.released) {
+                    return;
+                }
+                admission.released = true;
+                if (this.active === admission) {
+                    this.active = null;
+                    this.startNext();
+                }
+            },
+        };
+    }
+    startNext() {
+        if (!this.accepting) {
+            this.resolveIdleIfNeeded();
+            return;
+        }
+        const pending = this.queue.shift();
+        if (pending === undefined) {
+            this.resolveIdleIfNeeded();
+            return;
+        }
+        pending.resolve(this.activate());
+    }
+    resolveIdleIfNeeded() {
+        if (this.active !== null || this.queue.length !== 0) {
+            return;
+        }
+        for (const resolve of this.idleWaiters) {
+            resolve();
+        }
+        this.idleWaiters.clear();
+    }
+}
+//# sourceMappingURL=invocation-coordinator.js.map

package/dist/providers/openai/app-server/invocation-lifecycle.d.ts

@@ -0,0 +1,45 @@
+import { createManagedChildProcess, type ManagedChildProcess, type ProcessTreeTerminationOptions } from "../../../process-tree.js";
+export type ManagedCodexAppServerProcess = ManagedChildProcess;
+export type CodexAppServerTerminationOptions = ProcessTreeTerminationOptions;
+export declare const createManagedProcess: typeof createManagedChildProcess;
+export type CodexAppServerLifecycleIncident = {
+    code: "protocol_close_failed";
+    error_code: string;
+} | {
+    code: "temp_cleanup_failed";
+    error_code: string;
+} | {
+    code: "process_termination_failed";
+    error_code: string;
+};
+export type CodexAppServerInvocationCloseResult = {
+    forced: boolean;
+    cleanup_status: "removed" | "kept" | "failed";
+};
+export declare class CodexAppServerLifecycleError extends Error {
+    readonly code: "process_tree_not_terminated";
+    constructor(code: "process_tree_not_terminated", message: string);
+}
+export declare const CODEX_APP_SERVER_OWNER_MARKER_FILE = ".tutti-app-server-owner.json";
+export declare const CODEX_APP_SERVER_TEMP_PREFIXES: readonly ["tutti-codex-readonly-procedure-", "tutti-codex-workspace-write-run-", "tutti-codex-app-server-smoke-"];
+export declare function terminateCodexAppServerProcessTree(managedProcess: ManagedCodexAppServerProcess, options?: CodexAppServerTerminationOptions): Promise<{
+    forced: boolean;
+}>;
+export declare class CodexAppServerInvocation {
+    private readonly options;
+    private closePromise;
+    constructor(options: {
+        managedProcess: ManagedCodexAppServerProcess;
+        tempRoot: string;
+        closeProtocol: () => void | Promise<void>;
+        keepTemp?: boolean;
+        termination?: CodexAppServerTerminationOptions;
+        removeTempRoot?: (tempRoot: string) => Promise<void>;
+        onIncident?: (incident: CodexAppServerLifecycleIncident) => void;
+    });
+    close(): Promise<CodexAppServerInvocationCloseResult>;
+    reportProcessTerminationFailure(error: unknown): void;
+    private emitIncident;
+    private closeOnce;
+}
+//# sourceMappingURL=invocation-lifecycle.d.ts.map

package/dist/providers/openai/app-server/invocation-lifecycle.js

@@ -0,0 +1,104 @@
+import { writeFileSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { createManagedChildProcess, ProcessTreeTerminationError, systemErrorCode, terminateManagedProcessTree, } from "../../../process-tree.js";
+export const createManagedProcess = createManagedChildProcess;
+export class CodexAppServerLifecycleError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "CodexAppServerLifecycleError";
+    }
+}
+const TEMP_ROOT_CLEANUP_MAX_RETRIES = 4;
+const TEMP_ROOT_CLEANUP_RETRY_DELAY_MS = 50;
+export const CODEX_APP_SERVER_OWNER_MARKER_FILE = ".tutti-app-server-owner.json";
+export const CODEX_APP_SERVER_TEMP_PREFIXES = [
+    "tutti-codex-readonly-procedure-",
+    "tutti-codex-workspace-write-run-",
+    "tutti-codex-app-server-smoke-",
+];
+export async function terminateCodexAppServerProcessTree(managedProcess, options = {}) {
+    try {
+        return await terminateManagedProcessTree(managedProcess, options);
+    }
+    catch (error) {
+        if (error instanceof ProcessTreeTerminationError) {
+            throw new CodexAppServerLifecycleError("process_tree_not_terminated", "Codex app-server process tree did not terminate within the bounded shutdown window.");
+        }
+        throw error;
+    }
+}
+async function removeTempRootWithRetries(tempRoot) {
+    await rm(tempRoot, {
+        recursive: true,
+        force: true,
+        maxRetries: TEMP_ROOT_CLEANUP_MAX_RETRIES,
+        retryDelay: TEMP_ROOT_CLEANUP_RETRY_DELAY_MS,
+    });
+}
+export class CodexAppServerInvocation {
+    options;
+    closePromise;
+    constructor(options) {
+        this.options = options;
+        try {
+            writeFileSync(join(options.tempRoot, CODEX_APP_SERVER_OWNER_MARKER_FILE), JSON.stringify({
+                version: 1,
+                owner_pid: process.pid,
+                process_group_id: options.managedProcess.processGroupId ?? null,
+                created_at: new Date().toISOString(),
+                keep_temp: options.keepTemp === true,
+            }), { encoding: "utf8", mode: 0o600 });
+        }
+        catch {
+            // The marker is defense-in-depth for later stale cleanup, not an invocation prerequisite.
+        }
+    }
+    close() {
+        this.closePromise ??= this.closeOnce();
+        return this.closePromise;
+    }
+    reportProcessTerminationFailure(error) {
+        this.emitIncident({
+            code: "process_termination_failed",
+            error_code: systemErrorCode(error),
+        });
+    }
+    emitIncident(incident) {
+        try {
+            this.options.onIncident?.(incident);
+        }
+        catch {
+            // Diagnostic hooks must never change provider lifecycle semantics.
+        }
+    }
+    async closeOnce() {
+        try {
+            await this.options.closeProtocol();
+        }
+        catch (error) {
+            this.emitIncident({
+                code: "protocol_close_failed",
+                error_code: systemErrorCode(error),
+            });
+        }
+        const termination = await terminateCodexAppServerProcessTree(this.options.managedProcess, this.options.termination);
+        if (this.options.keepTemp === true) {
+            return { forced: termination.forced, cleanup_status: "kept" };
+        }
+        try {
+            await (this.options.removeTempRoot ?? removeTempRootWithRetries)(this.options.tempRoot);
+            return { forced: termination.forced, cleanup_status: "removed" };
+        }
+        catch (error) {
+            this.emitIncident({
+                code: "temp_cleanup_failed",
+                error_code: systemErrorCode(error),
+            });
+            return { forced: termination.forced, cleanup_status: "failed" };
+        }
+    }
+}
+//# sourceMappingURL=invocation-lifecycle.js.map

package/dist/providers/openai/app-server/json-rpc.d.ts

@@ -64,7 +64,7 @@ export declare class CodexAppServerJsonRpcClient {
     waitForServerRequest(timeoutMs: number): Promise<CodexAppServerJsonRpcServerRequest>;
     respondToServerRequest(id: CodexAppServerRequestId, result: unknown): void;
     rejectServerRequest(id: CodexAppServerRequestId, error: CodexAppServerJsonRpcError): void;
-    dispose(): void;
+    close(): void;
     private rejectAll;
     private writeServerRequestResponse;
     private handleStdout;

package/dist/providers/openai/app-server/json-rpc.js

@@ -1,6 +1,5 @@
 import { StringDecoder } from "node:string_decoder";
 import { redactText } from "@tutti/shared/utils";
-const PROCESS_EXIT_STDERR_EXCERPT_MAX_LENGTH = 500;
 export class CodexAppServerProtocolError extends Error {
     code;
     constructor(message, code) {
@@ -22,16 +21,6 @@ function normalizeProtocolError(method, error) {
     const message = typeof rawMessage === "string" ? redactText(rawMessage) : "protocol_error";
     return new CodexAppServerProtocolError(`Codex app-server request failed: ${method}: ${code}: ${message}`, "request_failed");
 }
-function processExitStderrExcerpt(value) {
-    const normalized = redactText(value).replace(/\s+/gu, " ").trim();
-    if (normalized.length === 0) {
-        return "";
-    }
-    if (normalized.length <= PROCESS_EXIT_STDERR_EXCERPT_MAX_LENGTH) {
-        return normalized;
-    }
-    return `${normalized.slice(0, PROCESS_EXIT_STDERR_EXCERPT_MAX_LENGTH)}...`;
-}
 export class CodexAppServerJsonRpcClient {
     child;
     options;
@@ -58,8 +47,7 @@ export class CodexAppServerJsonRpcClient {
         });
         child.on("exit", (code, signal) => {
             this.closed = true;
-            const stderrExcerpt = processExitStderrExcerpt(this.stderrText);
-            this.rejectAll(new CodexAppServerProtocolError(`Codex app-server exited before request completed: code=${code ?? "null"} signal=${signal ?? "null"}${stderrExcerpt === "" ? "" : ` stderr=${stderrExcerpt}`}`, "process_exited"));
+            this.rejectAll(new CodexAppServerProtocolError(`Codex app-server exited before request completed: code=${code ?? "null"} signal=${signal ?? "null"}`, "process_exited"));
         });
         child.on("error", (error) => {
             this.closed = true;
@@ -185,9 +173,14 @@ export class CodexAppServerJsonRpcClient {
     rejectServerRequest(id, error) {
         this.writeServerRequestResponse(id, { id, error });
     }
-    dispose() {
-        if (!this.child.killed) {
-            this.child.kill("SIGTERM");
+    close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.rejectAll(new CodexAppServerProtocolError("Codex app-server protocol client is closed", "process_closed"));
+        if (!this.child.stdin.destroyed) {
+            this.child.stdin.end();
         }
     }
     rejectAll(error) {