@neta-art/cohub-cli 7.1.2 → 8.0.1

package/dist/runtime/process-group.js

@@ -3,43 +3,143 @@ import { setTimeout as delay } from "node:timers/promises";
 import { spawn } from "node:child_process";
 export class ProcessCleanupUncertainError extends Error {
 }
-async function groupAlive(pid) {
-    try {
-        process.kill(-pid, 0);
-    }
-    catch (error) {
-        if (error.code === "ESRCH")
-            return false;
-        throw error;
-    }
-    if (process.platform !== "linux")
-        return true;
-    // Linux can retain reparented zombies: they cannot execute, but kill(0) still sees them.
+/** A member that can still execute code. Zombies cannot, so they never block cleanup. */
+const executable = (member) => member.state !== "Z" && member.state !== "X";
+/** Linux: /proc/<pid>/stat exposes pgrp and state for every member of the group. */
+async function probeLinux(pid) {
+    const members = [];
     for (const entry of await readdir("/proc")) {
         if (!/^\d+$/.test(entry))
             continue;
         try {
             const stat = await readFile(`/proc/${entry}/stat`, "utf8");
             // After removing `pid (comm)`: state, ppid, pgrp, session, ...
-            const [state, _parentPid, processGroupId] = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
-            if (Number(processGroupId) === pid && state !== "Z" && state !== "X")
-                return true;
+            const [state, , processGroupId] = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+            if (processGroupId !== undefined && Number(processGroupId) === pid)
+                members.push({ pid: Number(entry), state: state ?? "U" });
         }
         catch (error) {
-            if (error.code !== "ENOENT" && error.code !== "ESRCH")
+            // The member exited between readdir and read; it cannot execute anymore.
+            if (error.code !== "ENOENT")
                 throw error;
         }
     }
-    return false;
+    return members.some(executable) ? { state: "alive", members } : { state: "quiescent", members };
+}
+/** macOS/BSD: one `ps` snapshot; a zombie's STAT starts with Z. */
+async function probePosixSnapshot(pid) {
+    const output = await new Promise((resolve, reject) => {
+        const task = spawn("ps", ["-A", "-o", "pid=,pgid=,stat="], { stdio: ["ignore", "pipe", "ignore"] });
+        let text = "";
+        task.stdout.on("data", (chunk) => { text += chunk.toString(); });
+        task.once("error", reject);
+        task.once("close", (code) => code === 0 ? resolve(text) : reject(new Error(`ps exited ${code}`)));
+    });
+    const members = [];
+    for (const line of output.split("\n")) {
+        const [processId, processGroupId, stat] = line.trim().split(/\s+/);
+        if (processGroupId !== undefined && Number(processGroupId) === pid)
+            members.push({ pid: Number(processId), state: stat?.[0] ?? "U" });
+    }
+    return members.some(executable) ? { state: "alive", members } : { state: "quiescent", members };
+}
+/**
+ * `kill(-pgid)` outcomes that carry no liveness information on their own.
+ * ESRCH: the group is gone. EPERM: xnu's killpg1() reports it when no member can be
+ * signalled anymore (exited or zombie), so on macOS it is the normal end state; our
+ * harnesses run as the same user, so a real permission denial cannot occur here.
+ */
+const signalCode = (error) => error.code;
+const groupUnsignallable = (error) => signalCode(error) === "ESRCH" || signalCode(error) === "EPERM";
+/**
+ * Windows has no process groups: cleanup kills the tree with taskkill, so the leader's
+ * absence is the practical quiescence signal. A reused PID can only keep a result
+ * uncertain, never wrongly confirm it.
+ */
+async function probeWindows(pid) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch (error) {
+        if (signalCode(error) === "ESRCH")
+            return { state: "quiescent", members: [] };
+        return { state: "unknown", cause: error };
+    }
+    return { state: "alive", members: [{ pid, state: "R" }] };
+}
+/**
+ * A group is alive only while a member can still execute. `kill(0)` is only a fast
+ * path; the platform snapshot is the source of truth, and only a failing snapshot is
+ * uncertain.
+ */
+async function probeProcessGroup(pid) {
+    if (process.platform === "win32")
+        return probeWindows(pid);
+    try {
+        process.kill(-pid, 0);
+    }
+    catch (error) {
+        if (signalCode(error) === "ESRCH")
+            return { state: "quiescent", members: [] };
+        if (signalCode(error) !== "EPERM")
+            return { state: "unknown", cause: error };
+    }
+    if (process.platform === "linux") {
+        try {
+            return await probeLinux(pid);
+        }
+        catch (error) {
+            return { state: "unknown", cause: error };
+        }
+    }
+    try {
+        return await probePosixSnapshot(pid);
+    }
+    catch (error) {
+        return { state: "unknown", cause: error };
+    }
+}
+const describeMembers = (members) => members.map((member) => `${member.pid}:${member.state}`).join(" ") || "none";
+/** True only when the process group is gone or holds nothing that can execute. */
+export async function confirmQuiescentProcessGroup(pid) {
+    const probe = await probeProcessGroup(pid);
+    return probe.state === "quiescent";
+}
+/**
+ * Poll until the probe confirms quiescence. The interval backs off from 25ms to 200ms:
+ * normal exits confirm on the first probe, while a resistant group stops spawning
+ * snapshot subprocesses at full rate.
+ */
+async function awaitQuiescence(pid, probe, escalate) {
+    const started = Date.now();
+    let escalated = false;
+    let pollMs = 25;
+    for (;;) {
+        const state = await probe(pid);
+        if (state.state === "quiescent")
+            return;
+        if (state.state === "unknown" || Date.now() - started >= 5000) {
+            throw new Error(state.state === "unknown" ? `probe failed: ${state.cause instanceof Error ? state.cause.message : String(state.cause)}` : `still running: ${describeMembers(state.members)}`);
+        }
+        if (escalate && !escalated && Date.now() - started >= 2000) {
+            escalate();
+            escalated = true;
+        }
+        await delay(pollMs);
+        pollMs = Math.min(pollMs * 2, 200);
+    }
 }
 export async function stopProcessGroup(pid) {
     try {
         if (process.platform === "win32") {
-            await new Promise((resolve, reject) => {
+            // taskkill's exit code is not authoritative: a PID that already exited is an
+            // "error". The request is sent, then liveness decides.
+            await new Promise((resolve) => {
                 const task = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", timeout: 5000 });
-                task.once("error", reject);
-                task.once("exit", (code) => code === 0 ? resolve() : reject(new Error(`taskkill exited ${code}`)));
+                task.once("error", () => resolve());
+                task.once("exit", () => resolve());
             });
+            await awaitQuiescence(pid, probeWindows);
             return;
         }
         const signal = (value) => {
@@ -47,22 +147,15 @@ export async function stopProcessGroup(pid) {
                 process.kill(-pid, value);
             }
             catch (error) {
-                if (error.code !== "ESRCH")
+                if (!groupUnsignallable(error))
                     throw error;
             }
         };
         signal("SIGTERM");
-        const started = Date.now();
-        while (await groupAlive(pid)) {
-            const elapsed = Date.now() - started;
-            if (elapsed >= 5000)
-                throw new Error("Process group is still running");
-            if (elapsed >= 2000)
-                signal("SIGKILL");
-            await delay(25);
-        }
+        await awaitQuiescence(pid, probeProcessGroup, () => signal("SIGKILL"));
     }
     catch (cause) {
-        throw new ProcessCleanupUncertainError("Tool process cleanup could not be confirmed; execution remains unresolved", { cause });
+        // Any cleanup failure leaves the outcome unresolved; callers treat it as uncertain.
+        throw new ProcessCleanupUncertainError(`Tool process cleanup could not be confirmed; execution remains unresolved (${cause instanceof Error ? cause.message : String(cause)})`, { cause });
     }
 }

package/dist/runtime/session-store.d.ts

@@ -7,7 +7,8 @@ export declare class ContextRequiredError extends Error {
 }
 export type RuntimeSessionStoreOptions = {
     stateRoot?: string;
-    archiveTransport?: ArchiveTransport;
+    /** Explicit, so a serve path can never silently lose archive uploads. */
+    archiveTransport: ArchiveTransport | null;
     projectionSource: SessionTurnProjectionClient;
 };
 export type NativeSession = {
@@ -30,6 +31,8 @@ export type NativeSession = {
     sourceFingerprint?: string | null;
     nativeLeafId?: string | null;
 };
+/** Reverse lookup for native clients; the existing Runtime state remains authoritative. */
+export declare function findRuntimeNativeSession(root: string, harness: "pi" | "codex", nativeSessionId: string, path?: string): Promise<NativeSession | null>;
 /** Local references are hints validated against actual native files, never cloud existence claims. */
 export declare class RuntimeSessionStore {
     readonly root: string;
@@ -59,11 +62,23 @@ export declare class RuntimeSessionStore {
     }>;
     started(state: NativeSession, turnId: string): Promise<void>;
     private resultPath;
-    recordResult(state: NativeSession, requestId: string, events: RuntimeExecutionEvent[]): Promise<void>;
+    recordResult(state: NativeSession, requestId: string | null, events: RuntimeExecutionEvent[], options?: {
+        uncertainCleanup?: {
+            processGroupId: number;
+            error: string;
+        };
+    }): Promise<void>;
     recoverResult(input: Pick<RuntimeTurnInput, "sessionId" | "harness" | "turnId">, requestId?: string): Promise<{
         state: NativeSession;
         events: RuntimeExecutionEvent[];
     } | null>;
+    /**
+     * Receipt-less recovery: the native file is the authority. When a Turn completed but no
+     * receipt survived (a crash between native completion and recordResult), rebuild the
+     * result from transcript bytes appended after the Turn started, without ever rewriting
+     * native data. Anything ambiguous stays unrecovered.
+     */
+    private reconstructResult;
     archive(state: NativeSession, turnId: string, diagnosticContext?: RuntimeDiagnosticContext): Promise<HarnessArchive | null>;
     acknowledge(state: NativeSession, turnId: string, revision: string): Promise<void>;
 }

package/dist/runtime/session-store.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, open, readFile, readdir, rename, rm } from "node:fs/promises";
+import { mkdir, open, readFile, readdir, realpath, rename, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { RUNTIME_RECOVERY_BATCH_SIZE, runtimeEventSchema, serializeProjectionRecords } from "@neta-art/cohub";
@@ -7,8 +7,39 @@ import { RuntimeArchiveStore, checksumNativeFile, atomicRuntimeJson as atomicJso
 import { importNativeArchive, readCodexArchiveTotals } from "./native-archive.js";
 import { serializeDiagnosticError } from "./diagnostics.js";
 import { ProjectionStore, rebindProjectionNativeSession } from "./projection-store.js";
+import { confirmQuiescentProcessGroup } from "./process-group.js";
+import { readNativeTranscript } from "./native-transcript.js";
 export class ContextRequiredError extends Error {
 }
+/** Reverse lookup for native clients; the existing Runtime state remains authoritative. */
+export async function findRuntimeNativeSession(root, harness, nativeSessionId, path) {
+    const directory = join(root, harness);
+    const names = await readdir(directory).catch((error) => { if (error.code === "ENOENT")
+        return []; throw error; });
+    const matches = [];
+    for (const name of names) {
+        if (!name.endsWith(".json"))
+            continue;
+        const state = JSON.parse(await readFile(join(directory, name), "utf8"));
+        if (state.version === 1 && state.harness === harness && state.nativeSessionId === nativeSessionId)
+            matches.push(state);
+    }
+    if (path && matches.length) {
+        const canonical = await realpath(path);
+        const exact = [];
+        for (const state of matches) {
+            const candidate = await realpath(state.path).catch((error) => { if (error.code === "ENOENT")
+                return null; throw error; });
+            if (candidate === canonical)
+                exact.push(state);
+        }
+        if (exact.length === 1)
+            return exact[0] ?? null;
+    }
+    if (matches.length > 1)
+        throw new Error("Native Session has ambiguous Runtime bindings");
+    return matches[0] ?? null;
+}
 const checksum = (data) => createHash("sha256").update(data).digest("hex");
 const missing = (error) => error?.code === "ENOENT";
 class CaptureUnavailableError extends Error {
@@ -240,7 +271,6 @@ export class RuntimeSessionStore {
                 }
                 catch (error) {
                     this.diagnostics?.log("error", "runtime.session_state_unreadable", { path: join(directory, name), error: serializeDiagnosticError(error) });
-                    console.error(`Runtime session state unreadable: ${join(directory, name)}`, error);
                 }
             }
         }
@@ -252,6 +282,9 @@ export class RuntimeSessionStore {
         return this.archiveFlush;
     }
     async flushArchiveOutbox(signal) {
+        if (!this.archives.hasTransport && await this.archives.pendingCount() > 0) {
+            this.diagnostics?.log("debug", "archive.transport_absent", { note: "captures stay local" }, { component: "archive" });
+        }
         const captures = join(this.archives.root, "captures");
         const names = await readdir(captures).catch((error) => { if (missing(error))
             return []; throw error; });
@@ -295,11 +328,9 @@ export class RuntimeSessionStore {
                     });
                     await rm(join(captures, name), { force: true });
                     this.diagnostics?.log("error", "archive.capture_unavailable", { reason: error.message, receipt: true }, { component: "archive" });
-                    console.error("Archive capture unavailable; receipt retained:", error.message);
                 }
                 else {
                     this.diagnostics?.log("warn", "archive.capture_pending", { error: serializeDiagnosticError(error) }, { component: "archive" });
-                    console.error("Archive capture pending:", error);
                 }
             }
         }
@@ -368,6 +399,16 @@ export class RuntimeSessionStore {
                 }
             }
         }
+        if (previous) {
+            const previousPath = previous.path;
+            const canonical = await realpath(previousPath).catch((error) => { if (missing(error))
+                return previousPath; throw error; });
+            const externallyOwned = await readFile(join(this.root, "native-owners", `${checksum(canonical)}.json`), "utf8").then(() => true).catch((error) => { if (missing(error))
+                return false; throw error; });
+            // Interactive clients own their native files, including symlink aliases. Use an independent projection.
+            if (externallyOwned)
+                previous = null;
+        }
         if (previous) {
             try {
                 const nativeChecksum = await checksumNativeFile(previous.path);
@@ -408,14 +449,13 @@ export class RuntimeSessionStore {
             catch (error) {
                 signal?.throwIfAborted();
                 this.diagnostics?.log("warn", "archive.restore_failed", { error: serializeDiagnosticError(error) }, { component: "archive" });
-                console.error("Native archive unavailable; rebuilding from durable history:", error);
             }
         }
         return await this.syncNativeProjection(input, cwd, state, signal);
     }
     async started(state, turnId) { state.pendingTurnId = turnId; state.resultChecksum = undefined; await atomicJson(this.statePath(state), state); }
     resultPath(state) { return join(this.root, "results", `${state.sessionId}.${state.harness}.json`); }
-    async recordResult(state, requestId, events) {
+    async recordResult(state, requestId, events, options) {
         if (!state.pendingTurnId)
             throw new Error("Cannot record a result for an idle native session");
         if (state.harness === "pi")
@@ -423,7 +463,7 @@ export class RuntimeSessionStore {
         state.resultChecksum = await checksumNativeFile(state.path);
         if (state.archivePendingTurnId)
             await atomicJson(join(this.archives.root, "captures", `${state.archivePendingTurnId}.json`), state);
-        await atomicJson(this.resultPath(state), { requestId, state, events });
+        await atomicJson(this.resultPath(state), { requestId, state, events, ...(options?.uncertainCleanup ? { uncertainCleanup: options.uncertainCleanup } : {}) });
         await atomicJson(this.statePath(state), state);
     }
     async recoverResult(input, requestId) {
@@ -432,16 +472,85 @@ export class RuntimeSessionStore {
             if (saved.state.sessionId !== input.sessionId || saved.state.harness !== input.harness)
                 throw new Error("Runtime result identity mismatch");
             if (saved.state.pendingTurnId !== input.turnId)
-                return null;
-            if (requestId && saved.requestId !== requestId)
+                return this.reconstructResult(input);
+            if (requestId && saved.requestId != null && saved.requestId !== requestId)
                 throw new Error("Runtime result execution identity mismatch");
+            // A quiescent process group upgrades the receipt to confirmed; a live one stays uncertain.
+            if (saved.uncertainCleanup && !saved.uncertainCleanup.confirmedAt) {
+                if (!(await confirmQuiescentProcessGroup(saved.uncertainCleanup.processGroupId)))
+                    return null;
+                saved.uncertainCleanup.confirmedAt = new Date().toISOString();
+                await atomicJson(this.resultPath(input), saved);
+            }
             return { state: saved.state, events: saved.events.map((event) => runtimeEventSchema.parse(event)) };
         }
+        catch (error) {
+            if (missing(error))
+                return this.reconstructResult(input);
+            throw error;
+        }
+    }
+    /**
+     * Receipt-less recovery: the native file is the authority. When a Turn completed but no
+     * receipt survived (a crash between native completion and recordResult), rebuild the
+     * result from transcript bytes appended after the Turn started, without ever rewriting
+     * native data. Anything ambiguous stays unrecovered.
+     */
+    async reconstructResult(input) {
+        const statePath = this.statePath(input);
+        let state;
+        try {
+            state = JSON.parse(await readFile(statePath, "utf8"));
+        }
         catch (error) {
             if (missing(error))
                 return null;
             throw error;
         }
+        if (state.sessionId !== input.sessionId || state.harness !== input.harness || state.pendingTurnId !== input.turnId)
+            return null;
+        let transcript;
+        try {
+            transcript = await readNativeTranscript(state.path, state.harness, { settled: state.harness === "pi" });
+        }
+        catch {
+            return null;
+        }
+        // The Turn must start at the byte boundary the file had when the Turn began.
+        const boundary = state.checksum
+            ? [...transcript.prefixes].find(([, sha]) => sha === state.checksum)?.[0]
+            : 0;
+        if (boundary === undefined)
+            return null;
+        const turns = transcript.turns.filter((turn) => turn.startBytes >= boundary);
+        const completed = turns.length === 1 ? turns[0] : null;
+        const result = completed?.result ?? null;
+        // An interrupted Turn may still be executing in a surviving native process.
+        if (!completed || !result || result.status === "interrupted")
+            return null;
+        const messages = result.messages.filter((message) => message.content.length);
+        if (!messages.length)
+            return null;
+        const last = messages.at(-1);
+        const asRuntimeMessage = (message, ordinal) => ({
+            ordinal,
+            content: message.content,
+            ...(message.provider != null ? { provider: message.provider } : {}),
+            ...(message.model != null ? { model: message.model } : {}),
+            ...(message.usage != null ? { usage: message.usage } : {}),
+            ...(message.stopReason != null ? { stopReason: message.stopReason } : {}),
+            ...(message.errorMessage != null ? { errorMessage: message.errorMessage } : {}),
+        });
+        const events = messages.slice(0, -1).map((message, index) => ({ type: "message.commit", message: asRuntimeMessage(message, index + 1) }));
+        const archive = await this.archive(state, input.turnId, { component: "recovery", sessionId: input.sessionId, turnId: input.turnId, harness: input.harness }).catch(() => null);
+        const final = { type: "turn.end", message: asRuntimeMessage(last, messages.length), archive, resume: "native" };
+        await this.recordResult(state, null, [...events, final]);
+        this.diagnostics?.log("warn", "runtime.result_reconstructed", {
+            startBytes: completed.startBytes,
+            messageCount: messages.length,
+            status: result.status,
+        }, { component: "recovery", sessionId: input.sessionId, turnId: input.turnId, harness: input.harness });
+        return { state, events: [...events, final] };
     }
     async archive(state, turnId, diagnosticContext = {}) {
         if (!state.path)

package/dist/runtime/space-binding.d.ts

@@ -39,6 +39,9 @@ export declare function resolveRuntimeSpace(input: {
     root: string;
     identityKey: string | null | undefined;
     explicitSpaceId?: string | null;
+    /** Explicit new selection; compare the binding observed before prompting. */
+    newSpace?: boolean;
+    expectedSpaceId?: string | null;
     createSpace: () => Promise<string>;
     validateSpace?: (spaceId: string) => Promise<void>;
     path?: string;

package/dist/runtime/space-binding.js

@@ -99,7 +99,7 @@ function upsertRuntimeSpaceBinding(file, binding) {
     bindings[index] = nextBinding;
     return { file: { version: 1, bindings }, changed: true };
 }
-async function writeRuntimeSpaceBindings(path, file) {
+async function writeRuntimeJson(path, file) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
     try {
@@ -248,7 +248,7 @@ async function persistRuntimeSpaceBinding(path, binding) {
         const file = await readRuntimeSpaceBindings(path);
         const result = upsertRuntimeSpaceBinding(file, binding);
         if (result.changed)
-            await writeRuntimeSpaceBindings(path, result.file);
+            await writeRuntimeJson(path, result.file);
     }, { path, lockPath: `${path}${GLOBAL_LOCK_SUFFIX}` });
 }
 export async function getRuntimeSpaceBinding(root, key, path = runtimeSpaceBindingsPath()) {
@@ -281,25 +281,62 @@ export async function resolveRuntimeSpace(input) {
     const lockPath = bindingLockPath(path, root, bindingKey);
     return withRuntimeSpaceBindingsLock(async () => {
         const file = await readRuntimeSpaceBindings(path);
+        const receiptPath = `${lockPath}.creation.json`;
         if (explicitSpaceId) {
             await input.validateSpace?.(explicitSpaceId);
             await persistRuntimeSpaceBinding(path, { root, key: bindingKey, spaceId: explicitSpaceId });
+            // Preserve an ambiguous creation receipt for diagnosis, rather than deleting it.
+            if (await statIfPresent(receiptPath))
+                await rename(receiptPath, `${receiptPath}.${randomUUID()}.resolved`);
             return { spaceId: explicitSpaceId, source: "explicit" };
         }
         const existing = findRuntimeSpaceBinding(file, { root, key: bindingKey });
-        if (existing) {
+        if (input.newSpace && (existing?.spaceId ?? null) !== (input.expectedSpaceId ?? null)) {
+            throw new RuntimeSpaceBindingsError("Directory binding changed; run up again");
+        }
+        if (existing && !input.newSpace) {
             await input.validateSpace?.(existing.spaceId);
             return { spaceId: existing.spaceId, source: "binding" };
         }
-        // Remote creation and the local binding commit are separate durability
-        // domains; a server-side idempotency key is needed to close this crash window.
-        const createdSpaceId = await input.createSpace();
+        // Fail closed across the remote-create/local-commit crash window. A saved ID
+        // resumes binding; an ambiguous request must be resolved with --space, never replayed.
+        let receipt = null;
+        try {
+            receipt = JSON.parse(await readFile(receiptPath, "utf8"));
+            if (!receipt || !nonEmptyString(receipt.operationId) || receipt.spaceId !== undefined && !nonEmptyString(receipt.spaceId)) {
+                throw new RuntimeSpaceBindingsError(`Invalid creation receipt; original retained: ${receiptPath}`);
+            }
+        }
+        catch (error) {
+            if (!missing(error))
+                throw error;
+        }
+        if (receipt && !receipt.spaceId)
+            throw new RuntimeSpaceBindingsError(`A previous Space creation has an unknown outcome. Check your Spaces and use --space <id>. ${receiptPath}`);
+        if (!receipt) {
+            receipt = { operationId: randomUUID() };
+            await writeRuntimeJson(receiptPath, receipt);
+        }
+        let createdSpaceId = receipt.spaceId;
+        if (!createdSpaceId) {
+            try {
+                createdSpaceId = await input.createSpace();
+            }
+            catch (error) {
+                const status = error?.status;
+                if (status && status >= 400 && status < 500 && status !== 408)
+                    await rm(receiptPath);
+                throw error;
+            }
+            await writeRuntimeJson(receiptPath, { ...receipt, spaceId: createdSpaceId });
+        }
         if (!nonEmptyString(createdSpaceId)) {
             throw new RuntimeSpaceBindingsError("Local Runtime Space creation returned no Space ID");
         }
         const spaceId = createdSpaceId.trim();
         await input.validateSpace?.(spaceId);
         await persistRuntimeSpaceBinding(path, { root, key: bindingKey, spaceId });
+        await rm(receiptPath);
         return { spaceId, source: "created" };
     }, { path, lockPath });
 }

package/dist/runtime/supervisor.d.ts

@@ -0,0 +1,16 @@
+import { type RuntimeCapabilities } from "@neta-art/cohub";
+import { type HarnessOptions } from "./harness.js";
+import { type RuntimeDiagnostic, type RuntimeDiagnosticLevel } from "./diagnostics.js";
+import { type RuntimeSummary } from "./presentation.js";
+export type RuntimeLaunch = {
+    spaceId: string;
+    root: string;
+    identity: string;
+    harnesses: ("pi" | "codex")[];
+    executables: HarnessOptions;
+    capabilities?: RuntimeCapabilities;
+    background: boolean;
+    verbose?: boolean;
+};
+export declare function sandboxOutputLevel(value: unknown, stream: "stdout" | "stderr"): RuntimeDiagnosticLevel;
+export declare function runRuntime(config: RuntimeLaunch, onState: (status: RuntimeSummary) => void, externalSignal?: AbortSignal, onDiagnostic?: (event: RuntimeDiagnostic) => void): Promise<void>;