@neta-art/cohub-cli 7.1.2 → 8.0.1

package/dist/runtime/archive-store.js

@@ -49,6 +49,8 @@ export class RuntimeArchiveStore {
         this.root = root;
         this.transport = transport;
     }
+    /** Distinguishes "no transport configured" from transient upload failures. */
+    get hasTransport() { return this.transport != null; }
     setErrorReporter(reporter) {
         this.errorReporter = reporter;
     }
@@ -115,6 +117,8 @@ export class RuntimeArchiveStore {
         if (saved) {
             if (saved.sessionId !== state.sessionId || saved.harness !== state.harness)
                 throw new Error("Archive identity mismatch");
+            if (state.expectedChecksum && state.expectedChecksum !== saved.sha256)
+                throw new Error("Native Turn bytes changed; original archive retained");
             const committed = await stat(join(this.root, "ready", `${turnId}.json`)).catch((error) => { if (missing(error))
                 return null; throw error; });
             if (!committed)
@@ -130,12 +134,15 @@ export class RuntimeArchiveStore {
             const before = await file.stat();
             if (!before.isFile() || !before.size)
                 throw new Error("Native archive is empty");
+            const sizeBytes = state.sizeBytes ?? before.size;
+            if (!Number.isSafeInteger(sizeBytes) || sizeBytes < 1 || sizeBytes > before.size)
+                throw new Error("Native archive boundary is unavailable");
             const buffer = Buffer.alloc(RUNTIME_ARCHIVE_SEGMENT_BYTES);
             let offset = 0;
             let digest = createHash("sha256");
             let parent = null;
             // Hash the old prefix, not just its size: equal-size and growing rewrites are valid.
-            if (previous && previous.nativeSessionId === state.nativeSessionId && previous.sizeBytes <= before.size) {
+            if (previous && previous.nativeSessionId === state.nativeSessionId && previous.sizeBytes <= sizeBytes) {
                 while (offset < previous.sizeBytes) {
                     const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, previous.sizeBytes - offset), offset);
                     if (!bytesRead)
@@ -152,8 +159,8 @@ export class RuntimeArchiveStore {
             }
             const segments = [];
             await mkdir(join(this.root, "objects"), { recursive: true, mode: 0o700 });
-            while (offset < before.size) {
-                const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, before.size - offset), offset);
+            while (offset < sizeBytes) {
+                const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, sizeBytes - offset), offset);
                 if (!bytesRead)
                     throw new Error("Native file changed during capture");
                 const bytes = buffer.subarray(0, bytesRead);
@@ -164,8 +171,16 @@ export class RuntimeArchiveStore {
                 offset += bytesRead;
             }
             const after = await stat(state.path);
-            if (before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs)
+            if (before.ino !== after.ino || after.size < sizeBytes || state.sizeBytes === undefined && (before.size !== after.size || before.mtimeMs !== after.mtimeMs))
                 throw new Error("Native file changed during capture");
+            if (state.sizeBytes !== undefined) {
+                // Native clients may append while an earlier Turn is captured. Validate the exact prefix twice.
+                const verified = createHash("sha256");
+                for await (const bytes of createReadStream(state.path, { end: sizeBytes - 1 }))
+                    verified.update(bytes);
+                if (verified.digest("hex") !== digest.copy().digest("hex"))
+                    throw new Error("Native prefix changed during capture");
+            }
             if (process.platform !== "win32") {
                 const directory = await open(join(this.root, "objects"), "r");
                 try {
@@ -177,8 +192,10 @@ export class RuntimeArchiveStore {
             }
             index = harnessArchiveIndexSchema.parse({ ...identity, version: 1, nativeSessionId: state.nativeSessionId,
                 nativeFormat: state.harness === "pi" ? "pi.jsonl" : "codex.rollout", parentTurnId: parent?.turnId ?? null,
-                sizeBytes: before.size, sha256: digest.digest("hex"), segments });
+                sizeBytes, sha256: digest.digest("hex"), segments });
             validateArchiveBoundary(index, parent);
+            if (state.expectedChecksum && index.sha256 !== state.expectedChecksum)
+                throw new Error("Native Turn bytes changed during capture; original retained");
         }
         finally {
             await file.close();
@@ -254,7 +271,6 @@ export class RuntimeArchiveStore {
             catch (error) {
                 if (!signal.aborted) {
                     this.errorReporter?.(error, index);
-                    console.error("Archive pending; native segments retained:", error);
                 }
             }
         }

package/dist/runtime/connection.d.ts

@@ -1,4 +1,4 @@
-import { type RuntimeCapabilities } from "@neta-art/cohub";
+import { type RuntimeCapabilities, type NativeRuntimeEvent } from "@neta-art/cohub";
 import { type HarnessOptions } from "./harness.js";
 import { type RuntimeSessionStore } from "./session-store.js";
 import { type RuntimeDiagnostics } from "./diagnostics.js";
@@ -8,12 +8,14 @@ export type RuntimeConnectionOptions = {
     url: string;
     capabilities: RuntimeCapabilities;
     harnesses: HarnessOptions;
-    token: () => Promise<string>;
+    token: (forceRefresh?: boolean) => Promise<string>;
     signal: AbortSignal;
     store: RuntimeSessionStore;
     onReady: () => void;
+    onDisconnected?: () => void;
     runtimeId?: string;
     diagnostics?: RuntimeDiagnostics;
     leaseConflictTimeoutMs?: number;
+    onNativeChannel?: (send: (event: NativeRuntimeEvent) => Promise<unknown>) => void;
 };
 export declare function serveRuntime(options: RuntimeConnectionOptions): Promise<void>;

package/dist/runtime/connection.js

@@ -16,7 +16,7 @@ export async function serveRuntime(options) {
     const flush = () => options.store.flushArchives(uploadSignal).catch((error) => {
         if (!uploadSignal.aborted) {
             log("warn", "archive.flush_failed", { error: serializeDiagnosticError(error) });
-            console.error("Archive pending:", error);
+            // The diagnostic sink handles terminal presentation and throttling.
         }
     });
     const timer = setInterval(() => {
@@ -31,22 +31,36 @@ export async function serveRuntime(options) {
     try {
         while (!options.signal.aborted) {
             attempt += 1;
-            const outcome = await connect({
-                ...options,
-                runtimeId,
-                attempt,
-                onReady: () => {
-                    backoff = 500;
-                    attempt = 0;
-                    conflictSince = null;
-                    options.onReady();
-                    void flush();
-                },
-            });
+            let readyAt = 0;
+            let outcome;
+            try {
+                outcome = await connect({
+                    ...options,
+                    runtimeId,
+                    attempt,
+                    onReady: () => {
+                        readyAt = Date.now();
+                        conflictSince = null;
+                        options.onReady();
+                        void flush();
+                    },
+                });
+            }
+            catch (error) {
+                if (options.signal.aborted)
+                    return;
+                log("warn", "runtime.connection_failed", { error: serializeDiagnosticError(error) });
+                outcome = "retry";
+            }
+            options.onDisconnected?.();
             if (options.signal.aborted)
                 return;
             if (outcome === "fatal")
-                throw new Error("Runtime connection rejected");
+                throw new Error("Runtime connection rejected; check permissions or upgrade the CLI");
+            if (readyAt && Date.now() - readyAt >= 60_000) {
+                backoff = 500;
+                attempt = 0;
+            }
             if (outcome === "conflict") {
                 conflictSince ??= Date.now();
                 if (Date.now() - conflictSince >= (options.leaseConflictTimeoutMs ?? 90_000)) {
@@ -58,8 +72,8 @@ export async function serveRuntime(options) {
                 delayMs: backoff,
                 outcome,
             });
-            await delay(backoff, undefined, { signal: options.signal }).catch(() => undefined);
-            backoff = Math.min(10_000, backoff * 2);
+            await delay(backoff / 2 + Math.random() * backoff / 2, undefined, { signal: options.signal }).catch(() => undefined);
+            backoff = Math.min(30_000, backoff * 2);
         }
     }
     finally {
@@ -91,7 +105,7 @@ async function connect(options) {
         currentToken = await options.token();
     }
     catch (error) {
-        log("error", "runtime.auth_token_failed", { error: serializeDiagnosticError(error) });
+        log("warn", error instanceof Error && error.name === "AuthRequiredError" ? "runtime.auth_required" : "runtime.auth_token_failed", { error: serializeDiagnosticError(error) });
         throw error;
     }
     const runtimeUrl = new URL(options.url);
@@ -105,7 +119,10 @@ async function connect(options) {
     let connectionId = null;
     let fatal = false;
     let conflict = false;
+    let unauthorized = false;
     let readyTimer;
+    const nativePending = new Map();
+    let nativeChannelReady = false;
     const send = (frame) => {
         if (socket.readyState !== WebSocket.OPEN || socket.bufferedAmount > RUNTIME_MAX_FRAME_BYTES) {
             log("warn", "runtime.frame_send_unavailable", {
@@ -122,12 +139,30 @@ async function connect(options) {
         }
         socket.send(data);
     };
-    const stop = () => {
+    const closeTransport = () => socket.close();
+    const shutdown = () => {
         for (const execution of active.values())
             execution.controller.abort();
-        socket.close();
+        closeTransport();
     };
-    options.signal.addEventListener("abort", stop, { once: true });
+    const sendNative = (event) => new Promise((resolve, reject) => {
+        if (!nativeChannelReady || !connectionId) {
+            reject(new Error("Runtime native channel is unavailable"));
+            return;
+        }
+        const requestId = randomUUID();
+        const timer = setTimeout(() => { nativePending.delete(requestId); reject(new Error("Native Runtime event timed out")); }, 30_000);
+        nativePending.set(requestId, { resolve, reject, timer });
+        try {
+            send({ type: "runtime.native", requestId, event });
+        }
+        catch (error) {
+            clearTimeout(timer);
+            nativePending.delete(requestId);
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+    options.signal.addEventListener("abort", shutdown, { once: true });
     const heartbeat = setInterval(() => {
         const heartbeatAgeMs = Date.now() - lastHeartbeat;
         if (heartbeatAgeMs > 30_000) {
@@ -135,12 +170,7 @@ async function connect(options) {
                 ageMs: heartbeatAgeMs,
                 activeExecutions: active.size,
             }, { connectionId });
-            for (const execution of active.values()) {
-                log("error", "runtime.execution_heartbeat_timeout", {
-                    ageMs: heartbeatAgeMs,
-                }, executionContext(connectionId, execution));
-            }
-            stop();
+            closeTransport();
         }
         else if (connectionId) {
             try {
@@ -150,7 +180,7 @@ async function connect(options) {
                 log("warn", "runtime.heartbeat_send_failed", {
                     error: serializeDiagnosticError(error),
                 }, { connectionId });
-                stop();
+                closeTransport();
             }
             void options.token().then((next) => {
                 if (next !== currentToken) {
@@ -163,21 +193,22 @@ async function connect(options) {
                         log("warn", "runtime.auth_refresh_send_failed", {
                             error: serializeDiagnosticError(error),
                         }, { connectionId });
-                        stop();
+                        closeTransport();
                     }
                 }
             }).catch((error) => {
                 log("warn", "runtime.auth_refresh_failed", { error: serializeDiagnosticError(error) }, { connectionId });
-                stop();
+                closeTransport();
             });
         }
     }, 10_000);
     const closed = new Promise((resolve) => {
         socket.addEventListener("close", (event) => {
-            fatal = [4400, 4401, 4403].includes(event.code);
+            unauthorized = event.code === 4401;
+            fatal = [4400, 4403].includes(event.code);
             conflict = event.code === 4409;
             disconnected.abort();
-            log(fatal || conflict ? "error" : "warn", "runtime.websocket.closed", {
+            log(options.signal.aborted ? "debug" : fatal || conflict ? "error" : "warn", "runtime.websocket.closed", {
                 code: event.code,
                 reason: event.reason,
                 durationMs: Date.now() - connectedAt,
@@ -185,14 +216,21 @@ async function connect(options) {
                 fatal,
                 conflict,
             }, { connectionId });
-            if (!options.signal.aborted)
-                console.error(`Runtime disconnected (${event.code}): ${event.reason}`);
+            nativeChannelReady = false;
+            for (const pending of nativePending.values()) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error("Runtime native channel disconnected"));
+            }
+            nativePending.clear();
+            options.onDisconnected?.();
+            const executionMustStop = options.signal.aborted || fatal || conflict;
             for (const execution of active.values()) {
-                log("error", "runtime.execution_transport_lost", {
+                log(executionMustStop ? "error" : "warn", executionMustStop ? "runtime.execution_transport_invalidated" : "runtime.execution_transport_detached", {
                     code: event.code,
                     reason: event.reason,
                 }, executionContext(connectionId, execution));
-                execution.controller.abort();
+                if (executionMustStop)
+                    execution.controller.abort();
             }
             resolve();
         }, { once: true });
@@ -221,7 +259,7 @@ async function connect(options) {
         }
         catch (error) {
             log("error", "runtime.hello_failed", { error: serializeDiagnosticError(error) });
-            stop();
+            closeTransport();
         }
     });
     socket.addEventListener("message", (event) => {
@@ -234,6 +272,8 @@ async function connect(options) {
                 log("error", "runtime.protocol.invalid_json", { error: serializeDiagnosticError(error) }, { connectionId });
                 throw error;
             }
+            // Any inbound frame proves the transport is live; heartbeat frames are one case.
+            lastHeartbeat = Date.now();
             if (raw.type === "runtime.ready") {
                 const frame = runtimeReadySchema.parse(raw);
                 if (connectionId === frame.connectionId)
@@ -246,6 +286,8 @@ async function connect(options) {
                     connectionId,
                     durationMs: Date.now() - connectedAt,
                 }, { connectionId });
+                nativeChannelReady = true;
+                options.onNativeChannel?.(sendNative);
                 options.onReady();
                 let recoveryBatch = 0;
                 for await (const executions of options.store.pendingExecutionBatches()) {
@@ -261,7 +303,19 @@ async function connect(options) {
             if (!connectionId)
                 throw new Error("Runtime handshake is incomplete");
             if (raw.type === "runtime.heartbeat") {
-                lastHeartbeat = Date.now();
+                return;
+            }
+            if (raw.type === "runtime.native.result") {
+                const result = raw;
+                const pending = result.requestId ? nativePending.get(result.requestId) : null;
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                nativePending.delete(result.requestId ?? "");
+                if (result.error)
+                    pending.reject(new Error(result.error));
+                else
+                    pending.resolve(result.result);
                 return;
             }
             const frame = runtimeCommandSchema.parse(raw);
@@ -294,7 +348,7 @@ async function connect(options) {
                         revision: frame.revision,
                         error: serializeDiagnosticError(error),
                     }, context);
-                    console.error("Runtime acknowledgement failed; result retained:", error);
+                    // Keep the receipt; the next reconciliation can retry acknowledgement.
                     active.delete(frame.requestId);
                     send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", message: "Local acknowledgement failed; result retained" } });
                     return;
@@ -353,7 +407,7 @@ async function connect(options) {
                     catch (error) {
                         if (!recovery.controller.signal.aborted) {
                             log("error", "runtime.recovery_failed", { error: serializeDiagnosticError(error) }, context);
-                            console.error("Runtime recovery failed; original files retained:", error);
+                            // Original files and receipts remain available for reconciliation.
                             try {
                                 send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", uncertain: true, message: "Result unavailable; files retained" } });
                             }
@@ -453,7 +507,17 @@ async function connect(options) {
             const emit = (value) => {
                 if (value.type === "message.commit")
                     durableEvents.push(value);
-                send({ type: "runtime.event", requestId: frame.requestId, event: value });
+                // Streaming is best-effort. A detached transport must not cancel local model or tool work;
+                // durable commits and the final result are replayed after reconnect.
+                if (disconnected.signal.aborted || socket.readyState !== WebSocket.OPEN || socket.bufferedAmount > RUNTIME_MAX_FRAME_BYTES)
+                    return;
+                try {
+                    send({ type: "runtime.event", requestId: frame.requestId, event: value });
+                }
+                catch (error) {
+                    if (!disconnected.signal.aborted && socket.readyState === WebSocket.OPEN)
+                        throw error;
+                }
             };
             execution.promise = (async () => {
                 try {
@@ -486,7 +550,10 @@ async function connect(options) {
                             frame.input.context = await requestContext(controller.signal);
                         }
                     }
-                    await options.store.recordResult(execution.result.state, frame.requestId, [...durableEvents, execution.result.event]);
+                    await options.store.recordResult(execution.result.state, frame.requestId, [...durableEvents, execution.result.event], execution.result.uncertainCleanup ? { uncertainCleanup: execution.result.uncertainCleanup } : undefined);
+                    if (execution.result.uncertainCleanup) {
+                        log("warn", "runtime.turn_cleanup_pending", { cleanup: execution.result.uncertainCleanup.error }, context);
+                    }
                     emit(execution.result.event);
                 }
                 catch (error) {
@@ -505,7 +572,7 @@ async function connect(options) {
             })();
         })().catch((error) => {
             log("error", "runtime.protocol_error", { error: serializeDiagnosticError(error) }, { connectionId });
-            stop();
+            closeTransport();
         });
     });
     readyTimer = setTimeout(() => {
@@ -513,7 +580,7 @@ async function connect(options) {
         socket.close(4408, "Runtime handshake timed out");
     }, 15_000);
     if (options.signal.aborted)
-        stop();
+        shutdown();
     try {
         await closed;
         await Promise.allSettled([...active.values()].map((entry) => entry.promise));
@@ -521,7 +588,9 @@ async function connect(options) {
     finally {
         clearTimeout(readyTimer);
         clearInterval(heartbeat);
-        options.signal.removeEventListener("abort", stop);
+        options.signal.removeEventListener("abort", shutdown);
     }
+    if (unauthorized && !options.signal.aborted)
+        await options.token(true);
     return fatal ? "fatal" : conflict ? "conflict" : "retry";
 }

package/dist/runtime/diagnostics.d.ts

@@ -50,6 +50,8 @@ export type RuntimeDiagnosticsOptions = {
     logFlushIntervalMs?: number;
     maxLogFileBytes?: number;
     maxTotalLogBytes?: number;
+    /** Receives only the redacted event, before asynchronous disk I/O. */
+    onEvent?: (event: RuntimeDiagnostic) => void;
 };
 export type ReadRuntimeDiagnosticsOptions = {
     limit?: number;
@@ -64,6 +66,7 @@ export declare class RuntimeDiagnostics {
     readonly logPath: string;
     private readonly spaceId;
     private readonly component;
+    private readonly onEvent?;
     private readonly logFlushIntervalMs;
     private readonly maxLogFileBytes;
     private readonly maxTotalLogBytes;

package/dist/runtime/diagnostics.js

@@ -134,6 +134,7 @@ export class RuntimeDiagnostics {
     logPath;
     spaceId;
     component;
+    onEvent;
     logFlushIntervalMs;
     maxLogFileBytes;
     maxTotalLogBytes;
@@ -153,6 +154,7 @@ export class RuntimeDiagnostics {
         this.runtimeId = options.runtimeId ?? randomUUID();
         this.spaceId = options.spaceId;
         this.component = options.component ?? "runtime";
+        this.onEvent = options.onEvent;
         this.logFlushIntervalMs = options.logFlushIntervalMs ?? DEFAULT_LOG_FLUSH_INTERVAL_MS;
         this.maxLogFileBytes = options.maxLogFileBytes ?? DEFAULT_MAX_LOG_FILE_BYTES;
         this.maxTotalLogBytes = options.maxTotalLogBytes ?? DEFAULT_MAX_TOTAL_LOG_BYTES;
@@ -193,6 +195,7 @@ export class RuntimeDiagnostics {
             ...(diagnosticError ? { error: diagnosticError } : {}),
         });
         this.enqueueWrite(value);
+        this.onEvent?.(value);
     }
     async close() {
         this.closed = true;

package/dist/runtime/harness.d.ts

@@ -6,11 +6,18 @@ export type HarnessOptions = {
     pi?: string;
     codex?: string;
 };
+export declare function harnessExecutableCandidates(binary: string, cwd: string, path: string, platform?: NodeJS.Platform, pathExt?: string | undefined): string[];
+/** Discover installed executables only; authentication/capability errors stay explicit. */
+export declare function installedHarnesses(cwd: string, options: HarnessOptions, path?: string): Promise<("pi" | "codex")[]>;
 export type HarnessResult = {
     state: NativeSession;
     event: Extract<RuntimeExecutionEvent, {
         type: "turn.end";
     }>;
+    uncertainCleanup?: {
+        processGroupId: number;
+        error: string;
+    };
 };
 export declare function piContent(value: unknown): ContentBlock[];
 export declare function promptText(content: ContentBlock[]): string;

package/dist/runtime/harness.js

@@ -1,8 +1,41 @@
+import { access, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { delimiter, join, resolve, win32 } from "node:path";
 import { JsonRpcProcess, record } from "./json-rpc.js";
+import { ProcessCleanupUncertainError } from "./process-group.js";
 import { codexModelCatalog } from "./model-catalog.js";
 import { codexTokenTotals, codexUsage, subtractCodexTokens } from "./codex-usage.js";
 import { downloadPublicImage } from "../safe-remote-image.js";
 import { serializeDiagnosticError } from "./diagnostics.js";
+export function harnessExecutableCandidates(binary, cwd, path, platform = process.platform, pathExt = process.env.PATHEXT) {
+    const windows = platform === "win32";
+    const paths = windows ? win32 : { delimiter, join, resolve };
+    const extensions = windows && !win32.extname(binary)
+        ? ["", ...(pathExt || ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => /^\.[a-z0-9]+$/i.test(ext))]
+        : [""];
+    const roots = binary.includes("/") || binary.includes("\\")
+        ? [paths.resolve(cwd, binary)]
+        : path.split(paths.delimiter).map((directory) => directory.replace(/^"(.*)"$/, "$1")).filter(Boolean).map((directory) => paths.resolve(cwd, directory, binary));
+    return roots.flatMap((root) => extensions.map((ext) => `${root}${ext}`));
+}
+/** Discover installed executables only; authentication/capability errors stay explicit. */
+export async function installedHarnesses(cwd, options, path = process.env.PATH ?? "") {
+    const names = options.pi || options.codex ? ["pi", "codex"].filter((name) => options[name]) : ["pi", "codex"];
+    const found = await Promise.all(names.map(async (name) => {
+        const binary = options[name] || name;
+        const candidates = harnessExecutableCandidates(binary, cwd, path);
+        for (const candidate of candidates) {
+            try {
+                await access(candidate, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+                if ((await stat(candidate)).isFile())
+                    return name;
+            }
+            catch { /* Try the next PATH entry. */ }
+        }
+        return null;
+    }));
+    return found.filter((name) => name !== null);
+}
 const runtimeEnvironment = (input) => ({ COHUB_SPACE_ID: input.spaceId, COHUB_SESSION_ID: input.sessionId, COHUB_TURN_ID: input.turnId });
 const array = (value) => Array.isArray(value) ? value : [];
 const text = (value) => typeof value === "string" ? value : "";
@@ -49,9 +82,20 @@ function createAbortEscalation(rpc, signal, interrupt) {
 }
 /** Native files stay authoritative; archival failure only degrades cross-host resume. */
 async function finishHarnessTurn(store, state, message, resume, turnId, diagnosticContext) {
-    const archive = await store.archive(state, turnId, diagnosticContext).catch((error) => { console.error("Native archive unavailable; local files retained:", error); return null; });
+    // The store records a redacted diagnostic; native files remain authoritative.
+    const archive = await store.archive(state, turnId, diagnosticContext).catch(() => null);
     return { state, event: { type: "turn.end", message, resume, archive } };
 }
+/** Close the RPC process. An unconfirmable cleanup degrades the result to uncertain, never masks it. */
+async function closeHarness(rpc, executionError) {
+    return rpc.close().then(() => undefined, (cleanupError) => {
+        const processGroupId = rpc.processGroupId;
+        if (!(cleanupError instanceof ProcessCleanupUncertainError) || processGroupId == null)
+            throw cleanupError;
+        const detail = executionError ? `; execution error: ${executionError}` : "";
+        return { processGroupId, error: `${cleanupError.message}${detail}` };
+    });
+}
 export async function discoverHarnesses(harnesses, options, cwd) {
     const models = [];
     await Promise.all(harnesses.map(async (harness) => {
@@ -100,6 +144,7 @@ export async function executePi(input, options, cwd, store, emit, signal, diagno
     let currentContent = [];
     let last = { ordinal: 0, content: [] };
     const abortEscalation = createAbortEscalation(rpc, signal, () => { void rpc.request("abort").catch(() => undefined); });
+    let uncertainCleanup;
     const stopFailureLogging = diagnostics
         ? rpc.onFailure((error) => diagnostics.log("error", "harness.rpc_process_failed", { error: serializeDiagnosticError(error) }, { ...diagnosticContext, component: "harness" }))
         : () => undefined;
@@ -202,17 +247,17 @@ export async function executePi(input, options, cwd, store, emit, signal, diagno
         abortEscalation.clear();
         stopFailureLogging();
         stopTimeoutLogging();
-        await rpc.close();
+        uncertainCleanup = await closeHarness(rpc, last.errorMessage);
     }
     if (signal.aborted)
         last = { ...last, stopReason: "aborted" };
-    return finishHarnessTurn(store, state, last, resume, input.turnId, {
-        component: "harness",
-        sessionId: input.sessionId,
-        turnId: input.turnId,
-        harness: "pi",
-        traceContext: input.traceContext,
-    });
+    return { ...await finishHarnessTurn(store, state, last, resume, input.turnId, {
+            component: "harness",
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            harness: "pi",
+            traceContext: input.traceContext,
+        }), ...(uncertainCleanup ? { uncertainCleanup } : {}) };
 }
 export function codexItemContent(item) {
     if (item.type === "agentMessage" || item.type === "plan")
@@ -262,6 +307,7 @@ export async function executeCodex(input, options, cwd, store, emit, signal, dia
         if (nativeTurnId)
             void rpc.request("turn/interrupt", { threadId: state.nativeSessionId, turnId: nativeTurnId }).catch(() => undefined);
     });
+    let uncertainCleanup;
     try {
         await initializeCodex(rpc);
         const threadOptions = {
@@ -418,17 +464,17 @@ export async function executeCodex(input, options, cwd, store, emit, signal, dia
         abortEscalation.clear();
         stopFailureLogging();
         stopTimeoutLogging();
-        await rpc.close();
+        uncertainCleanup = await closeHarness(rpc, final.errorMessage);
     }
     if (signal.aborted)
         final = { ...final, stopReason: "aborted" };
     if (usage)
         final = { ...final, usage };
-    return finishHarnessTurn(store, state, final, resume, input.turnId, {
-        component: "harness",
-        sessionId: input.sessionId,
-        turnId: input.turnId,
-        harness: "codex",
-        traceContext: input.traceContext,
-    });
+    return { ...await finishHarnessTurn(store, state, final, resume, input.turnId, {
+            component: "harness",
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            harness: "codex",
+            traceContext: input.traceContext,
+        }), ...(uncertainCleanup ? { uncertainCleanup } : {}) };
 }

package/dist/runtime/instance.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeSummary } from "./presentation.js";
+export declare function runtimeInstanceDirectory(identity: string, spaceId: string): string;
+export declare function requestRuntimeInstance(directory: string, action?: "status" | "stop", force?: boolean): Promise<RuntimeSummary | null>;
+/** Private local IPC is both the single-instance guard and the control surface. */
+export declare function ownRuntimeInstance(directory: string, status: () => RuntimeSummary, stop: (force: boolean) => Promise<void>): Promise<() => Promise<void>>;