@neta-art/cohub-cli 8.2.0 → 8.3.1

package/dist/runtime/connection.js

@@ -1,9 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
-import { RUNTIME_MAX_FRAME_BYTES, RUNTIME_PROTOCOL_VERSION, runtimeCommandSchema, runtimeReadySchema, } from "@neta-art/cohub";
-import { executeCodex, executePi } from "./harness.js";
+import { RUNTIME_MAX_FRAME_BYTES, RUNTIME_PROTOCOL_VERSION, runtimeCommandSchema, runtimeReadySchema, runtimeNativeStopSchema, } from "@neta-art/cohub";
+import { executeTurn } from "./native/execution.js";
+import { ContextRequiredError } from "./native/results.js";
 import { ProcessCleanupUncertainError } from "./process-group.js";
-import { ContextRequiredError } from "./session-store.js";
 import { serializeDiagnosticError, } from "./diagnostics.js";
 export async function serveRuntime(options) {
     const runtimeId = options.runtimeId ?? options.diagnostics?.runtimeId ?? randomUUID();
@@ -13,7 +13,7 @@ export async function serveRuntime(options) {
     const uploads = new AbortController();
     const uploadSignal = AbortSignal.any([options.signal, uploads.signal]);
     const log = (level, event, data, context) => options.diagnostics?.log(level, event, data, context);
-    const flush = () => options.store.flushArchives(uploadSignal).catch((error) => {
+    const flush = () => options.executor.archives.flush(uploadSignal).catch((error) => {
         if (!uploadSignal.aborted) {
             log("warn", "archive.flush_failed", { error: serializeDiagnosticError(error) });
             // The diagnostic sink handles terminal presentation and throttling.
@@ -151,7 +151,8 @@ async function connect(options) {
             return;
         }
         const requestId = randomUUID();
-        const timer = setTimeout(() => { nativePending.delete(requestId); reject(new Error("Native Runtime event timed out")); }, 30_000);
+        // An ingest batch writes each of its Turns durably; everything else answers from memory or one row.
+        const timer = setTimeout(() => { nativePending.delete(requestId); reject(new Error("Native Runtime event timed out")); }, event.type === "ingest" ? 120_000 : 30_000);
         nativePending.set(requestId, { resolve, reject, timer });
         try {
             send({ type: "runtime.native", requestId, event });
@@ -290,7 +291,7 @@ async function connect(options) {
                 options.onNativeChannel?.(sendNative);
                 options.onReady();
                 let recoveryBatch = 0;
-                for await (const executions of options.store.pendingExecutionBatches()) {
+                for await (const executions of options.executor.results.pendingBatches()) {
                     recoveryBatch += 1;
                     log("info", "runtime.recovery_batch_sent", {
                         batch: recoveryBatch,
@@ -305,6 +306,16 @@ async function connect(options) {
             if (raw.type === "runtime.heartbeat") {
                 return;
             }
+            if (raw.type === "runtime.native.stop") {
+                const stop = runtimeNativeStopSchema.safeParse(raw);
+                if (!stop.success) {
+                    log("warn", "runtime.protocol.invalid_native_stop", { error: stop.error.message }, { connectionId });
+                    return;
+                }
+                if (stop.data.spaceId === options.spaceId)
+                    options.onNativeStop?.(stop.data);
+                return;
+            }
             if (raw.type === "runtime.native.result") {
                 const result = raw;
                 const pending = result.requestId ? nativePending.get(result.requestId) : null;
@@ -341,7 +352,7 @@ async function connect(options) {
                     await execution.promise;
                     if (!execution.result)
                         throw new Error("Runtime result is not available");
-                    await options.store.acknowledge(execution.result.state, frame.turnId, frame.revision);
+                    await options.executor.results.acknowledge(execution.sessionId, frame.turnId);
                 }
                 catch (error) {
                     log("error", "runtime.turn_ack_failed", {
@@ -373,7 +384,7 @@ async function connect(options) {
                     if (previous.sessionId !== identity.sessionId || previous.turnId !== identity.turnId || previous.harness !== identity.harness)
                         throw new Error("Runtime recovery identity changed");
                     await previous.promise;
-                    const saved = await options.store.recoverResult(identity);
+                    const saved = await options.executor.results.recover(identity);
                     if (saved)
                         for (const event of saved.events)
                             send({ type: "runtime.event", requestId: frame.requestId, event });
@@ -395,12 +406,12 @@ async function connect(options) {
                             await running[1].promise;
                             active.delete(running[0]);
                         }
-                        const saved = await options.store.recoverResult(identity);
+                        const saved = await options.executor.results.recover(identity);
                         recovery.controller.signal.throwIfAborted();
                         const last = saved?.events.at(-1);
                         if (!saved || last?.type !== "turn.end")
                             throw new Error("No confirmed result");
-                        recovery.result = { state: saved.state, event: last };
+                        recovery.result = { session: saved.session, event: last };
                         for (const event of saved.events)
                             send({ type: "runtime.event", requestId: frame.requestId, event });
                     }
@@ -432,7 +443,7 @@ async function connect(options) {
                 if (previous.sessionId !== frame.input.sessionId || previous.turnId !== frame.input.turnId || previous.harness !== frame.input.harness)
                     throw new Error("Runtime execution identity changed");
                 await previous.promise;
-                const saved = await options.store.recoverResult(frame.input, frame.requestId);
+                const saved = await options.executor.results.recover(frame.input, frame.requestId);
                 if (saved)
                     for (const event of saved.events)
                         send({ type: "runtime.event", requestId: frame.requestId, event });
@@ -441,7 +452,7 @@ async function connect(options) {
             const requestContext = async (executionSignal) => {
                 const signal = AbortSignal.any([executionSignal, disconnected.signal]);
                 signal.throwIfAborted();
-                const pendingTurnIds = await options.store.pendingTurnIds(frame.input.sessionId);
+                const pendingTurnIds = await options.executor.results.pendingTurnIds(frame.input.sessionId);
                 log("debug", "runtime.context_requested", { pendingTurnCount: pendingTurnIds.length }, context);
                 return new Promise((resolve, reject) => {
                     const abort = () => {
@@ -521,12 +532,12 @@ async function connect(options) {
             };
             execution.promise = (async () => {
                 try {
-                    const saved = await options.store.recoverResult(frame.input, frame.requestId);
+                    const saved = await options.executor.results.recover(frame.input, frame.requestId);
                     if (saved) {
                         const last = saved.events.at(-1);
                         if (last?.type !== "turn.end")
                             throw new Error("Incomplete saved Runtime result");
-                        execution.result = { state: saved.state, event: last };
+                        execution.result = { session: saved.session, event: last };
                         for (const event of saved.events)
                             emit(event);
                         return;
@@ -536,7 +547,7 @@ async function connect(options) {
                         active.delete(frame.requestId);
                         return;
                     }
-                    const run = () => (frame.input.harness === "pi" ? executePi : executeCodex)(frame.input, options.harnesses, options.cwd, options.store, emit, controller.signal, options.diagnostics, context);
+                    const run = () => executeTurn(options.executor, frame.input, emit, controller.signal, frame.requestId, context);
                     // Preparation can request context, then fall back once from native archive to DB.
                     // These retries precede started(), so they never replay model or tool work.
                     for (let retry = 0;; retry += 1) {
@@ -550,7 +561,7 @@ async function connect(options) {
                             frame.input.context = await requestContext(controller.signal);
                         }
                     }
-                    await options.store.recordResult(execution.result.state, frame.requestId, [...durableEvents, execution.result.event], execution.result.uncertainCleanup ? { uncertainCleanup: execution.result.uncertainCleanup } : undefined);
+                    await options.executor.results.record(execution.result.session, frame.input, frame.requestId, [...durableEvents, execution.result.event], execution.result.uncertainCleanup);
                     if (execution.result.uncertainCleanup) {
                         log("warn", "runtime.turn_cleanup_pending", { cleanup: execution.result.uncertainCleanup.error }, context);
                     }

package/dist/runtime/harness.d.ts

@@ -1,7 +1,5 @@
-import type { ContentBlock, RuntimeCapabilities, RuntimeExecutionEvent, RuntimeTurnInput } from "@neta-art/cohub";
+import type { ContentBlock, RuntimeCapabilities } from "@neta-art/cohub";
 import { type JsonRecord } from "./json-rpc.js";
-import type { RuntimeSessionStore, NativeSession } from "./session-store.js";
-import { type RuntimeDiagnostics, type RuntimeDiagnosticContext } from "./diagnostics.js";
 export type HarnessOptions = {
     pi?: string;
     codex?: string;
@@ -9,19 +7,13 @@ export type HarnessOptions = {
 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;
+export declare function imageForPi(block: Extract<ContentBlock, {
+    type: "image";
+}>): Promise<{
+    type: string;
+    data: string;
+    mimeType: string;
+}>;
 export declare function discoverHarnesses(harnesses: ("pi" | "codex")[], options: HarnessOptions, cwd: string): Promise<RuntimeCapabilities>;
-export declare function executePi(input: RuntimeTurnInput, options: HarnessOptions, cwd: string, store: RuntimeSessionStore, emit: (event: RuntimeExecutionEvent) => void, signal: AbortSignal, diagnostics?: RuntimeDiagnostics, diagnosticContext?: RuntimeDiagnosticContext): Promise<HarnessResult>;
 export declare function codexItemContent(item: JsonRecord): ContentBlock[];
-export declare function executeCodex(input: RuntimeTurnInput, options: HarnessOptions, cwd: string, store: RuntimeSessionStore, emit: (event: RuntimeExecutionEvent) => void, signal: AbortSignal, diagnostics?: RuntimeDiagnostics, diagnosticContext?: RuntimeDiagnosticContext): Promise<HarnessResult>;

package/dist/runtime/harness.js

@@ -2,11 +2,8 @@ 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 };
@@ -36,7 +33,6 @@ export async function installedHarnesses(cwd, options, path = process.env.PATH ?
     }));
     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 : "";
 export function piContent(value) {
@@ -53,49 +49,16 @@ export function piContent(value) {
         return [{ type: "text", text: JSON.stringify(block) }];
     });
 }
-async function imageForPi(block) {
+export async function imageForPi(block) {
     if (block.source.type === "base64")
         return { type: "image", data: block.source.data, mimeType: block.source.media_type };
     const image = await downloadPublicImage(block.source.url);
     return { type: "image", data: Buffer.from(image.bytes).toString("base64"), mimeType: image.mimeType };
 }
-export function promptText(content) {
-    return content.filter((block) => block.type !== "image").map((block) => block.type === "text" ? block.text : JSON.stringify(block)).join("\n");
-}
 async function initializeCodex(rpc) {
     await rpc.request("initialize", { clientInfo: { name: "cohub", title: "Cohub", version: "1" }, capabilities: { experimentalApi: true } });
     rpc.write({ method: "initialized", params: {} });
 }
-/** Ask the native process to stop, then hard-close it if the request does not settle quickly. */
-function createAbortEscalation(rpc, signal, interrupt) {
-    let timer = null;
-    const abort = () => {
-        interrupt();
-        timer ??= setTimeout(() => { void rpc.close().catch(() => undefined); }, 5000);
-    };
-    signal.addEventListener("abort", abort, { once: true });
-    return {
-        abort,
-        clear: () => { signal.removeEventListener("abort", abort); if (timer)
-            clearTimeout(timer); },
-    };
-}
-/** Native files stay authoritative; archival failure only degrades cross-host resume. */
-async function finishHarnessTurn(store, state, message, resume, turnId, diagnosticContext) {
-    // 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) => {
@@ -133,132 +96,6 @@ export async function discoverHarnesses(harnesses, options, cwd) {
     }));
     return { harnesses, models };
 }
-export async function executePi(input, options, cwd, store, emit, signal, diagnostics, diagnosticContext) {
-    if (input.accessMode === "read_only")
-        throw new Error("Pi cannot enforce read-only access; select Cohub or Codex");
-    signal.throwIfAborted();
-    const { state, resume } = await store.prepare(input, cwd, signal);
-    signal.throwIfAborted();
-    const rpc = new JsonRpcProcess(options.pi || "pi", ["--mode", "rpc", "--session", state.path], cwd, "pi", runtimeEnvironment(input));
-    let ordinal = -1;
-    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;
-    const stopTimeoutLogging = diagnostics
-        ? rpc.onTimeout((method, timeoutMs) => diagnostics.log("error", "harness.rpc_timeout", { method, timeoutMs }, { ...diagnosticContext, component: "harness" }))
-        : () => undefined;
-    try {
-        if (input.model) {
-            let provider = input.provider;
-            if (!provider) {
-                const catalog = await rpc.request("get_available_models");
-                const matches = array(catalog.models).map(record).filter((model) => model.id === input.model);
-                if (matches.length !== 1)
-                    throw new Error("Select a provider for this local model");
-                provider = text(matches[0]?.provider);
-            }
-            await rpc.request("set_model", { provider, modelId: input.model });
-        }
-        if (input.thinkingLevel)
-            await rpc.request("set_thinking_level", { level: input.thinkingLevel });
-        const stateResult = await rpc.request("get_state");
-        state.nativeSessionId = text(stateResult.sessionId) || state.nativeSessionId;
-        const model = record(stateResult.model);
-        const content = input.messages.flatMap((message) => message.content);
-        const images = await Promise.all(content.flatMap((block) => block.type === "image" ? [imageForPi(block)] : []));
-        signal.throwIfAborted();
-        await store.started(state, input.turnId);
-        await new Promise((resolve, reject) => {
-            const offFailure = rpc.onFailure(reject);
-            const off = rpc.onEvent((event) => {
-                try {
-                    if (event.type === "extension_ui_request") {
-                        if (["confirm", "select", "input", "editor"].includes(text(event.method)))
-                            rpc.write({ type: "extension_ui_response", id: event.id, cancelled: true });
-                        return;
-                    }
-                    if (event.type === "message_start" && record(event.message).role === "assistant") {
-                        ordinal++;
-                        currentContent = [];
-                        emit({ type: "message.start", ordinal });
-                    }
-                    if (event.type === "message_end" && record(event.message).role === "assistant") {
-                        currentContent = piContent(record(event.message).content);
-                        emit({ type: "content.replace", ordinal, content: currentContent });
-                    }
-                    if (event.type === "tool_execution_start") {
-                        const id = text(event.toolCallId);
-                        if (!currentContent.some((block) => block.type === "tool_use" && block.id === id))
-                            currentContent.push({ type: "tool_use", id, name: text(event.toolName), input: record(event.args), _meta: { toolStatus: "running" } });
-                        emit({ type: "content.replace", ordinal, content: [...currentContent] });
-                    }
-                    if (event.type === "tool_execution_update" || event.type === "tool_execution_end") {
-                        const id = text(event.toolCallId);
-                        const rawResult = event.type === "tool_execution_end" ? event.result : event.partialResult;
-                        const result = record(rawResult);
-                        const resultContent = typeof rawResult === "string" ? rawResult : piContent(result.content);
-                        currentContent = currentContent.filter((block) => block.type !== "tool_result" || block.tool_use_id !== id);
-                        currentContent.push({ type: "tool_result", tool_use_id: id, content: resultContent, is_error: Boolean(event.isError), _meta: { toolStatus: event.type === "tool_execution_end" ? "done" : "running" } });
-                        emit({ type: "content.replace", ordinal, content: [...currentContent] });
-                    }
-                    if (event.type === "message_update") {
-                        const delta = record(event.assistantMessageEvent);
-                        if (delta.type === "text_delta" || delta.type === "thinking_delta")
-                            emit({ type: "text.delta", ordinal, index: Number(delta.contentIndex ?? 0), kind: delta.type === "text_delta" ? "text" : "thinking", delta: text(delta.delta) });
-                    }
-                    if (event.type === "turn_end") {
-                        const message = record(event.message);
-                        const content = piContent(message.content);
-                        for (const resultValue of array(event.toolResults)) {
-                            const result = record(resultValue);
-                            content.push({ type: "tool_result", tool_use_id: text(result.toolCallId), content: typeof result.content === "string" ? result.content : piContent(result.content), is_error: Boolean(result.isError) });
-                        }
-                        last = { ordinal: Math.max(0, ordinal), content, provider: text(message.provider) || text(model.provider), model: text(message.model) || text(model.id), usage: message.usage, stopReason: text(message.stopReason) === "toolUse" ? "tool_use" : text(message.stopReason) || "stop", errorMessage: text(message.errorMessage) || null };
-                        emit({ type: "content.replace", ordinal: last.ordinal, content });
-                        if (last.stopReason === "tool_use")
-                            emit({ type: "message.commit", message: last });
-                    }
-                    if (event.type === "agent_settled" || event.type === "agent_end" && event.willRetry === undefined) {
-                        off();
-                        offFailure();
-                        resolve();
-                    }
-                }
-                catch (error) {
-                    off();
-                    offFailure();
-                    reject(error);
-                }
-            });
-            void rpc.request("prompt", { message: promptText(content), images }).catch((error) => { off(); offFailure(); reject(error); });
-        });
-        await rpc.request("get_state");
-    }
-    catch (error) {
-        if (!state.pendingTurnId)
-            throw error;
-        last = { ...last, stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : error instanceof Error ? error.message : String(error) };
-    }
-    finally {
-        abortEscalation.clear();
-        stopFailureLogging();
-        stopTimeoutLogging();
-        uncertainCleanup = await closeHarness(rpc, last.errorMessage);
-    }
-    if (signal.aborted)
-        last = { ...last, stopReason: "aborted" };
-    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")
         return [{ type: "text", text: text(item.text) }];
@@ -276,205 +113,3 @@ export function codexItemContent(item) {
         { type: "tool_result", tool_use_id: id, content: typeof item.aggregatedOutput === "string" ? item.aggregatedOutput : JSON.stringify(item.result ?? item.error ?? item.changes ?? item), is_error: item.status === "failed" || typeof item.exitCode === "number" && item.exitCode !== 0 },
     ];
 }
-export async function executeCodex(input, options, cwd, store, emit, signal, diagnostics, diagnosticContext) {
-    signal.throwIfAborted();
-    const { state, resume } = await store.prepare(input, cwd, signal);
-    signal.throwIfAborted();
-    const rpc = new JsonRpcProcess(options.codex || "codex", ["app-server", "--listen", "stdio://"], cwd, "codex", runtimeEnvironment(input));
-    const stopFailureLogging = diagnostics
-        ? rpc.onFailure((error) => diagnostics.log("error", "harness.rpc_process_failed", { error: serializeDiagnosticError(error) }, { ...diagnosticContext, component: "harness" }))
-        : () => undefined;
-    const stopTimeoutLogging = diagnostics
-        ? rpc.onTimeout((method, timeoutMs) => diagnostics.log("error", "harness.rpc_timeout", { method, timeoutMs }, { ...diagnosticContext, component: "harness" }))
-        : () => undefined;
-    let nativeTurnId = null;
-    let ordinal = -1;
-    const ordinals = new Map();
-    const items = new Map();
-    const outputs = new Map();
-    const completedItems = new Set();
-    let pending = null;
-    let final = { ordinal: 0, content: [] };
-    let usage;
-    let usageBaseline = state.codexTokenTotals;
-    const latestMessage = () => {
-        if (pending && pending.ordinal >= ordinal)
-            return pending;
-        const item = [...items.entries()].find(([id]) => ordinals.get(id) === ordinal)?.[1];
-        return { ordinal: Math.max(0, ordinal), content: item ? codexItemContent(item) : [] };
-    };
-    const abortEscalation = createAbortEscalation(rpc, signal, () => {
-        if (nativeTurnId)
-            void rpc.request("turn/interrupt", { threadId: state.nativeSessionId, turnId: nativeTurnId }).catch(() => undefined);
-    });
-    let uncertainCleanup;
-    try {
-        await initializeCodex(rpc);
-        const threadOptions = {
-            cwd,
-            ...(input.model ? { model: input.model } : {}),
-            ...(input.provider && input.provider !== "codex" ? { modelProvider: input.provider } : {}),
-            ...(input.accessMode === "read_only" ? { sandbox: "read-only" } : {}),
-        };
-        const opened = resume === "native"
-            ? await rpc.request("thread/resume", { ...threadOptions, threadId: state.nativeSessionId, path: state.path, excludeTurns: true })
-            : resume === "restored"
-                ? await rpc.request("thread/fork", { ...threadOptions, threadId: state.nativeSessionId, path: state.path, excludeTurns: true })
-                : resume === "handoff"
-                    ? await rpc.request("thread/resume", { ...threadOptions, threadId: state.nativeSessionId, path: state.path, excludeTurns: true })
-                    : await rpc.request("thread/start", threadOptions);
-        const thread = record(opened.thread);
-        if (typeof thread.id !== "string" || typeof thread.path !== "string")
-            throw new Error("Codex did not provide a durable native thread");
-        state.nativeSessionId = thread.id;
-        state.path = thread.path;
-        const provider = text(opened.modelProvider) || "codex";
-        const model = text(opened.model) || input.model;
-        const content = await Promise.all(input.messages.flatMap((message) => message.content).map(async (block) => {
-            if (block.type === "image") {
-                const image = await imageForPi(block);
-                return { type: "image", url: `data:${image.mimeType};base64,${image.data}` };
-            }
-            return { type: "text", text: block.type === "text" ? block.text : JSON.stringify(block), text_elements: [] };
-        }));
-        signal.throwIfAborted();
-        await store.started(state, input.turnId);
-        await new Promise((resolve, reject) => {
-            const offFailure = rpc.onFailure(reject);
-            const off = rpc.onEvent((event) => {
-                try {
-                    const method = text(event.method);
-                    const params = record(event.params);
-                    if (event.id != null) {
-                        // Keep native approval policy. An unattended client never grants an escalation.
-                        rpc.write({ id: event.id, error: { code: -32000, message: "Approval requires an interactive local client" } });
-                        return;
-                    }
-                    if (params.threadId !== state.nativeSessionId)
-                        return;
-                    if (method === "turn/started") {
-                        nativeTurnId = text(record(params.turn).id);
-                        if (signal.aborted)
-                            abortEscalation.abort();
-                    }
-                    if (method === "thread/tokenUsage/updated" && nativeTurnId && params.turnId === nativeTurnId) {
-                        const nativeUsage = record(params.tokenUsage);
-                        const total = codexTokenTotals(nativeUsage.total);
-                        usageBaseline ??= subtractCodexTokens(total, codexTokenTotals(nativeUsage.last));
-                        state.codexTokenTotals = total;
-                        usage = codexUsage(subtractCodexTokens(total, usageBaseline));
-                    }
-                    if (method === "item/started") {
-                        const item = record(params.item);
-                        if (item.type === "userMessage" || completedItems.has(text(item.id)))
-                            return;
-                        const existingOrdinal = ordinals.get(text(item.id));
-                        if (pending && (existingOrdinal == null || existingOrdinal > pending.ordinal)) {
-                            emit({ type: "message.commit", message: pending });
-                            pending = null;
-                        }
-                        if (existingOrdinal != null) {
-                            items.set(text(item.id), item);
-                            if (item.type === "agentMessage" && text(item.text))
-                                emit({ type: "content.replace", ordinal: existingOrdinal, content: codexItemContent(item) });
-                            return;
-                        }
-                        ordinal++;
-                        ordinals.set(text(item.id), ordinal);
-                        items.set(text(item.id), item);
-                        emit({ type: "message.start", ordinal });
-                        if (!["agentMessage", "reasoning", "plan"].includes(text(item.type)))
-                            emit({ type: "content.replace", ordinal, content: codexItemContent(item).filter((block) => block.type !== "tool_result") });
-                    }
-                    if (method === "item/agentMessage/delta" || method === "item/reasoning/textDelta" || method === "item/reasoning/summaryTextDelta") {
-                        const id = text(params.itemId);
-                        if (completedItems.has(id))
-                            return;
-                        const itemOrdinal = ordinals.get(id);
-                        const item = items.get(id);
-                        if (item) {
-                            if (method === "item/agentMessage/delta")
-                                item.text = text(item.text) + text(params.delta);
-                            else {
-                                const key = method.includes("summary") ? "summary" : "content";
-                                item[key] = [array(item[key]).map(text).join("\n") + text(params.delta)];
-                            }
-                        }
-                        if (itemOrdinal != null)
-                            emit({ type: "text.delta", ordinal: itemOrdinal, index: 0, kind: method === "item/agentMessage/delta" ? "text" : "thinking", delta: text(params.delta) });
-                    }
-                    if (method === "item/commandExecution/outputDelta") {
-                        const id = text(params.itemId);
-                        const item = items.get(id);
-                        const itemOrdinal = ordinals.get(id);
-                        if (item && itemOrdinal != null) {
-                            const output = (outputs.get(id) ?? "") + text(params.delta);
-                            outputs.set(id, output);
-                            item.aggregatedOutput = output;
-                            emit({ type: "content.replace", ordinal: itemOrdinal, content: codexItemContent(item) });
-                        }
-                    }
-                    if (method === "item/completed") {
-                        const item = record(params.item);
-                        if (item.type === "userMessage" || completedItems.has(text(item.id)))
-                            return;
-                        completedItems.add(text(item.id));
-                        const itemOrdinal = ordinals.get(text(item.id)) ?? ++ordinal;
-                        if (!ordinals.has(text(item.id))) {
-                            ordinals.set(text(item.id), itemOrdinal);
-                            emit({ type: "message.start", ordinal: itemOrdinal });
-                        }
-                        items.set(text(item.id), item);
-                        const message = { ordinal: itemOrdinal, content: codexItemContent(item), provider, model, stopReason: "stop" };
-                        emit({ type: "content.replace", ordinal: itemOrdinal, content: message.content });
-                        if (pending && pending.ordinal > itemOrdinal)
-                            emit({ type: "message.commit", message });
-                        else {
-                            if (pending && pending.ordinal !== itemOrdinal)
-                                emit({ type: "message.commit", message: pending });
-                            pending = message;
-                        }
-                    }
-                    if (method === "turn/completed") {
-                        const turn = record(params.turn);
-                        final = { ...latestMessage(), provider, model, stopReason: turn.status === "interrupted" ? "aborted" : turn.status === "failed" ? "error" : "stop", errorMessage: text(record(turn.error).message) || null };
-                        off();
-                        offFailure();
-                        resolve();
-                    }
-                }
-                catch (error) {
-                    off();
-                    offFailure();
-                    reject(error);
-                }
-            });
-            void rpc.request("turn/start", { threadId: state.nativeSessionId, clientUserMessageId: input.userMessageId, input: content, ...(input.thinkingLevel ? { effort: input.thinkingLevel } : {}) })
-                .then((result) => { nativeTurnId = text(record(result.turn).id); if (signal.aborted)
-                abortEscalation.abort(); })
-                .catch((error) => { off(); offFailure(); reject(error); });
-        });
-    }
-    catch (error) {
-        if (!state.pendingTurnId)
-            throw error;
-        final = { ...latestMessage(), stopReason: signal.aborted ? "aborted" : "error", errorMessage: signal.aborted ? null : error instanceof Error ? error.message : String(error) };
-    }
-    finally {
-        abortEscalation.clear();
-        stopFailureLogging();
-        stopTimeoutLogging();
-        uncertainCleanup = await closeHarness(rpc, final.errorMessage);
-    }
-    if (signal.aborted)
-        final = { ...final, stopReason: "aborted" };
-    if (usage)
-        final = { ...final, usage };
-    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

@@ -1,5 +1,12 @@
 import type { RuntimeSummary } from "./presentation.js";
 export declare function runtimeInstanceDirectory(identity: string, spaceId: string): string;
+type Response = {
+    status: RuntimeSummary;
+    result?: unknown;
+};
 export declare function requestRuntimeInstance(directory: string, action?: "status" | "stop", force?: boolean): Promise<RuntimeSummary | null>;
+/** Send a control action to the running Runtime; `null` when none runs. */
+export declare function controlRuntimeInstance(directory: string, action: string, payload?: Record<string, unknown>, timeoutMs?: number): Promise<Response | 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>>;
+export declare function ownRuntimeInstance(directory: string, status: () => RuntimeSummary, stop: (force: boolean) => Promise<void>, control?: (action: string, message: Record<string, unknown>) => Promise<unknown>): Promise<() => Promise<void>>;
+export {};