@neta-art/cohub-cli 7.0.0 → 7.0.1

package/README.md

@@ -79,26 +79,22 @@ cohub -s <spaceId> spaces prompt "message" --json
 COHUB_SPACE_ID=<spaceId> cohub spaces prompt "message" --json
 ```
 
-## Local Runtime / 本地 Runtime
+## Local Runtime
 
 Connect one local workspace to a Space and select Pi or Codex per turn.
-将一个本地工作区连接到 Space，每轮可选择 Pi 或 Codex。
 
 ```bash
 cohub runtime up ./project --harness pi --harness codex
 cohub runtime up ./project --space <spaceId> --harness codex
-cohub -s <spaceId> spaces prompt "Continue / 继续" --harness codex
+cohub -s <spaceId> spaces prompt "Continue" --harness codex
 cohub runtime status --space <spaceId>
 ```
 
 The Runtime uses WebSockets, native Pi RPC / Codex app-server, and existing cloud
 streaming. Local executables and credentials are required. `sandbox up` has been
 removed. Reconnection and result reconciliation are automatic; no recovery command is needed.
-See [Runtime details](../../docs/local-runtime.md).
-
-Runtime 使用 WebSocket、原生 Pi RPC / Codex app-server 和现有云端流式链路。
-需要本机已安装并登录对应程序。Runtime 断线重连和结果核对自动完成，无需恢复命令。
-仅在无法确定结果时，由 Space 页头提供异常确认。旧 `sandbox up` 命令已移除。
+When a result genuinely cannot be determined, the affected Chat offers an explicit stop
+confirmation. See [Runtime details](../../docs/local-runtime.md).
 
 ## Chats and prompts
 
@@ -378,7 +374,7 @@ legacy bare targets. A bare target checks the current Space for a file first, th
 falls back to the same App references as `apps get`. Showing a preview is
 idempotent: repeating it re-activates the same tab and refreshes any launch state
 carried by the reference. With `--call`, the command waits for the App to announce readiness, invokes the method,
-and waits for the App to complete the same UI command with `client.ui.reportResult()`.
+and waits for the App to complete the same UI command with `client.desktop.reportResult()`.
 
 App authors decide what is callable by registering handlers inside the App:
 

package/dist/commands/apps.js

@@ -508,7 +508,7 @@ export function registerApps(program) {
         .option("--app-scope <scope>", "Scope granted directly to the app runtime (space.view, session.view, file.view, file.edit, taskrun.view, session.prompt.readonly, session.prompt.fullaccess, command.execute)", collectOption, [])
         .option("--viewer-scope <scope>", "Deprecated: viewer grants are no longer gated by the app configuration", collectOption, [])
         .option("--clear-app-scopes", "Clear app runtime scopes")
-        .option("--clear-viewer-scopes", "Deprecated: clear legacy scope metadata / 已废弃：清除旧权限元数据")
+        .option("--clear-viewer-scopes", "Deprecated: clear legacy scope metadata")
         .option("--meta <json>", "App metadata as a JSON object")
         .option("--hide-cohub-bar", "Hide the Cohub footer bar on the public app page")
         .option("--show-cohub-bar", "Show the Cohub footer bar on the public app page")
@@ -728,7 +728,7 @@ export function registerApps(program) {
         .description("Grant an app scopes as the current user")
         .requiredOption("--scope <scope>", "Scope to grant (repeatable)", collectOption, [])
         .option("--space <spaceId>", "Target space; defaults to the app's own space")
-        .option("--extend", "Add scopes without replacing active grants / 增加权限，保留有效授权")
+        .option("--extend", "Add scopes without replacing active grants")
         .option("--json", "Output as JSON")
         .action(async (appRef, opts) => {
         const client = createClient();

package/dist/commands/runtime.js

@@ -15,20 +15,20 @@ export const resolveLocalSpaceName = (root, name) => name?.trim() || basename(ro
 export function parseRuntimeHarnesses(values) {
     const names = values.flatMap((value) => value.split(",")).map((name) => name.trim()).filter(Boolean);
     if (names.some((name) => !isLocalHarness(name)))
-        throw new Error("Harness must be pi or codex / Harness 必须是 pi 或 codex");
+        throw new Error("Harness must be pi or codex");
     return [...new Set(names.length ? names : ["pi"])];
 }
 export function registerRuntime(program) {
-    const runtime = program.command("runtime").description("Connect a local workspace / 连接本地工作区");
+    const runtime = program.command("runtime").description("Connect a local workspace");
     runtime.command("up [dir]")
-        .description("Connect local Harnesses and files / 连接本地 Harness 与文件")
-        .option("-s, --space <id>", "Target Space / 目标 Space")
-        .option("-n, --name <name>", "New Space name / 新 Space 名称")
-        .option("--harness <name>", "Pi or Codex; repeatable / Pi 或 Codex，可重复", (value, previous) => [...previous, value], [])
-        .option("--pi <path>", "Pi executable / Pi 可执行文件")
-        .option("--codex <path>", "Codex executable / Codex 可执行文件")
-        .option("-y, --yes", "Accept local execution access / 同意本机执行权限")
-        .option("--json", "JSON output / JSON 输出")
+        .description("Connect local Harnesses and files")
+        .option("-s, --space <id>", "Target Space")
+        .option("-n, --name <name>", "New Space name")
+        .option("--harness <name>", "Pi or Codex; repeatable", (value, previous) => [...previous, value], [])
+        .option("--pi <path>", "Pi executable")
+        .option("--codex <path>", "Codex executable")
+        .option("-y, --yes", "Accept local execution access")
+        .option("--json", "JSON output")
         .action(async (dir, options) => {
         const controller = new AbortController();
         const stop = () => controller.abort();
@@ -37,14 +37,14 @@ export function registerRuntime(program) {
         try {
             const root = resolve(dir ?? process.cwd());
             if (!(await stat(root)).isDirectory())
-                throw new Error("Workspace is not a directory / 工作区不是目录");
+                throw new Error("Workspace is not a directory");
             const harnesses = parseRuntimeHarnesses(options.harness);
             if (!options.yes) {
                 if (!process.stdin.isTTY)
-                    throw new Error("Use --yes to authorize local execution / 请使用 --yes 授权本机执行");
+                    throw new Error("Use --yes to authorize local execution");
                 const rl = createInterface({ input: process.stdin, output: process.stderr });
                 try {
-                    const answer = await rl.question(`Connect ${root}? Space collaborators can run commands as your OS user, beyond this folder.\n连接此目录？Space 协作者可使用当前系统用户执行命令，权限不限于此目录。 [y/N] `);
+                    const answer = await rl.question(`Connect ${root}? Space collaborators can run commands as your OS user, beyond this folder. [y/N] `);
                     if (!/^y(es)?$/i.test(answer.trim()))
                         return;
                 }
@@ -58,7 +58,7 @@ export function registerRuntime(program) {
             const spaceId = requested || (await client.spaces.create({ name: resolveLocalSpaceName(root, options.name), config: { sandbox: { provider: "local" } } })).space.id;
             const sandbox = (await client.space(spaceId).sandbox.get()).sandbox;
             if (sandbox?.provider !== "local")
-                throw new Error("Space does not have a local Runtime / Space 不是本地 Runtime");
+                throw new Error("Space does not have a local Runtime");
             const binary = await ensureSandboxdBinary();
             const wsBase = resolveWebsocketUrl({ url: process.env.COHUB_WS_URL });
             const url = new URL(wsBase);
@@ -83,7 +83,7 @@ export function registerRuntime(program) {
                         if (jsonRequested(options))
                             outJson({ spaceId, root, harnesses, url: webUrl });
                         else
-                            console.error(`Runtime connected / Runtime 已连接: ${webUrl}`);
+                            console.error(`Runtime connected: ${webUrl}`);
                     },
                 });
             }
@@ -99,14 +99,14 @@ export function registerRuntime(program) {
         }
         catch (cause) {
             if (!controller.signal.aborted)
-                error("Runtime failed / Runtime 失败", cause instanceof Error ? cause.message : String(cause));
+                error("Runtime failed", cause instanceof Error ? cause.message : String(cause));
         }
         finally {
             process.removeListener("SIGINT", stop);
             process.removeListener("SIGTERM", stop);
         }
     });
-    runtime.command("status").description("Runtime status / Runtime 状态").option("-s, --space <id>", "Target Space / 目标 Space").action(async (options) => {
+    runtime.command("status").description("Runtime status").option("-s, --space <id>", "Target Space").action(async (options) => {
         const spaceId = options.space?.trim() || await resolveSpace(program);
         const { archives } = new RuntimeSessionStore(spaceId);
         const [status, pendingLocalArchives, failedLocalArchives] = await Promise.all([

package/dist/runtime/archive-store.js

@@ -110,7 +110,7 @@ export class RuntimeArchiveStore {
         const saved = await this.readIndex(this.version(turnId));
         if (saved) {
             if (saved.sessionId !== state.sessionId || saved.harness !== state.harness)
-                throw new Error("Archive identity mismatch / 归档身份不匹配");
+                throw new Error("Archive identity mismatch");
             const committed = await stat(join(this.root, "ready", `${turnId}.json`)).catch((error) => { if (missing(error))
                 return null; throw error; });
             if (!committed)
@@ -125,7 +125,7 @@ export class RuntimeArchiveStore {
         try {
             const before = await file.stat();
             if (!before.isFile() || !before.size)
-                throw new Error("Native archive is empty / 原生归档为空");
+                throw new Error("Native archive is empty");
             const buffer = Buffer.alloc(RUNTIME_ARCHIVE_SEGMENT_BYTES);
             let offset = 0;
             let digest = createHash("sha256");
@@ -135,7 +135,7 @@ export class RuntimeArchiveStore {
                 while (offset < previous.sizeBytes) {
                     const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, previous.sizeBytes - offset), offset);
                     if (!bytesRead)
-                        throw new Error("Native file changed during capture / 归档时文件发生变化");
+                        throw new Error("Native file changed during capture");
                     digest.update(buffer.subarray(0, bytesRead));
                     offset += bytesRead;
                 }
@@ -151,7 +151,7 @@ export class RuntimeArchiveStore {
             while (offset < before.size) {
                 const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, before.size - offset), offset);
                 if (!bytesRead)
-                    throw new Error("Native file changed during capture / 归档时文件发生变化");
+                    throw new Error("Native file changed during capture");
                 const bytes = buffer.subarray(0, bytesRead);
                 digest.update(bytes);
                 const segment = { offset, sizeBytes: bytesRead, sha256: hash(bytes), md5: hash(bytes, "md5") };
@@ -161,7 +161,7 @@ export class RuntimeArchiveStore {
             }
             const after = await stat(state.path);
             if (before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs)
-                throw new Error("Native file changed during capture / 归档时文件发生变化");
+                throw new Error("Native file changed during capture");
             if (process.platform !== "win32") {
                 const directory = await open(join(this.root, "objects"), "r");
                 try {
@@ -219,7 +219,7 @@ export class RuntimeArchiveStore {
                 queue.push(index);
         }
         if (pending.size && !queue.length)
-            throw new Error("Cyclic archive outbox / 归档队列引用循环");
+            throw new Error("Cyclic archive outbox");
         for (let cursor = 0; cursor < queue.length; cursor++) {
             signal.throwIfAborted();
             const index = queue[cursor];
@@ -228,19 +228,19 @@ export class RuntimeArchiveStore {
             try {
                 const { uploads } = await transport.prepareRuntimeArchive(index, { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]) });
                 if (uploads.length > index.segments.length)
-                    throw new Error("Upload plan mismatch / 上传计划不匹配");
+                    throw new Error("Upload plan mismatch");
                 const expected = new Set(index.segments.map((segment) => JSON.stringify(segment)));
                 for (const { segment, uploadUrl, headers } of uploads) {
                     if (!expected.has(JSON.stringify(segment)))
-                        throw new Error("Upload segment mismatch / 上传分段不匹配");
+                        throw new Error("Upload segment mismatch");
                     signal.throwIfAborted();
                     const bytes = await readFile(this.blob(segment.sha256));
                     if (bytes.length !== segment.sizeBytes || hash(bytes) !== segment.sha256)
-                        throw new Error("Local archive segment is corrupt / 本地归档分段已损坏");
+                        throw new Error("Local archive segment is corrupt");
                     const response = await (transport.fetchObject ?? fetch)(uploadUrl, { method: "PUT", headers, body: bytes, redirect: "error", signal: AbortSignal.any([signal, AbortSignal.timeout(60_000)]) });
                     // An immutable segment may already exist after a lost acknowledgement. Commit verifies it.
                     if (!response.ok && ![409, 412].includes(response.status))
-                        throw new Error(`Archive upload failed / 归档上传失败: ${response.status}`);
+                        throw new Error(`Archive upload failed: ${response.status}`);
                 }
                 await transport.commitRuntimeArchive(index, { signal: AbortSignal.any([signal, AbortSignal.timeout(30_000)]) });
                 await atomicRuntimeJson(join(this.root, "ready", `${index.turnId}.json`), { turnId: index.turnId, sha256: index.sha256 });
@@ -249,13 +249,13 @@ export class RuntimeArchiveStore {
             }
             catch (error) {
                 if (!signal.aborted)
-                    console.error("Archive pending; native segments retained / 归档待重试，原始分段已保留:", error);
+                    console.error("Archive pending; native segments retained:", error);
             }
         }
     }
     async restore(reference, target, signal) {
         if (!this.transport)
-            throw new Error("Archive transport unavailable / 归档传输不可用");
+            throw new Error("Archive transport unavailable");
         const timeout = (ms) => signal ? AbortSignal.any([signal, AbortSignal.timeout(ms)]) : AbortSignal.timeout(ms);
         const pages = [];
         const visited = new Set();
@@ -263,18 +263,18 @@ export class RuntimeArchiveStore {
         while (turnId) {
             signal?.throwIfAborted();
             if (visited.has(turnId))
-                throw new Error("Cyclic archive / 归档引用循环");
+                throw new Error("Cyclic archive");
             visited.add(turnId);
             const page = await this.transport.getRuntimeArchive(reference.sessionId, turnId, { signal: timeout(30_000) });
             const index = harnessArchiveIndexSchema.parse(page.index);
             if (index.turnId !== turnId || index.sessionId !== reference.sessionId || index.harness !== reference.harness)
-                throw new Error("Archive identity mismatch / 归档身份不匹配");
+                throw new Error("Archive identity mismatch");
             pages.push({ ...page, index });
             turnId = index.parentTurnId;
         }
         const head = pages[0]?.index;
         if (!head)
-            throw new Error("Archive missing / 归档不存在");
+            throw new Error("Archive missing");
         await mkdir(dirname(target), { recursive: true, mode: 0o700 });
         const temporary = `${target}.${randomUUID()}.restoring`;
         const file = await open(temporary, "wx", 0o600);
@@ -284,53 +284,53 @@ export class RuntimeArchiveStore {
             for (const page of pages.reverse()) {
                 validateArchiveBoundary(page.index, parent);
                 if (page.segments.length !== page.index.segments.length)
-                    throw new Error("Missing archive segments / 归档分段缺失");
+                    throw new Error("Missing archive segments");
                 for (const [ordinal, expected] of page.index.segments.entries()) {
                     signal?.throwIfAborted();
                     const cached = await readFile(this.blob(expected.sha256)).catch((error) => { if (missing(error))
                         return null; throw error; });
                     if (cached) {
                         if (cached.length !== expected.sizeBytes || hash(cached) !== expected.sha256)
-                            throw new Error("Cached archive segment is corrupt / 缓存归档分段已损坏");
+                            throw new Error("Cached archive segment is corrupt");
                         digest.update(cached);
                         await file.writeFile(cached);
                         continue;
                     }
                     let link = page.segments[ordinal];
                     if (!link || JSON.stringify(link.segment) !== JSON.stringify(expected))
-                        throw new Error("Archive segment identity mismatch / 归档分段标识不匹配");
+                        throw new Error("Archive segment identity mismatch");
                     let response = await (this.transport.fetchObject ?? fetch)(link.downloadUrl, { redirect: "error", signal: timeout(60_000) });
                     if ([401, 403].includes(response.status)) {
                         const refreshed = await this.transport.getRuntimeArchive(reference.sessionId, page.index.turnId, { signal: timeout(30_000) });
                         link = refreshed.segments[ordinal];
                         if (!link || JSON.stringify(link.segment) !== JSON.stringify(expected))
-                            throw new Error("Archive segment missing / 归档分段缺失");
+                            throw new Error("Archive segment missing");
                         response = await (this.transport.fetchObject ?? fetch)(link.downloadUrl, { redirect: "error", signal: timeout(60_000) });
                     }
                     if (!response.ok || !response.body)
-                        throw new Error(`Archive download failed / 归档下载失败: ${response.status}`);
+                        throw new Error(`Archive download failed: ${response.status}`);
                     const segmentHash = createHash("sha256");
                     let size = 0;
                     const chunks = [];
                     for await (const chunk of response.body) {
                         size += chunk.length;
                         if (size > expected.sizeBytes)
-                            throw new Error("Archive size mismatch / 归档大小不匹配");
+                            throw new Error("Archive size mismatch");
                         chunks.push(chunk);
                         segmentHash.update(chunk);
                         digest.update(chunk);
                         await file.writeFile(chunk);
                     }
                     if (size !== expected.sizeBytes || segmentHash.digest("hex") !== expected.sha256)
-                        throw new Error("Archive checksum mismatch / 归档校验失败");
+                        throw new Error("Archive checksum mismatch");
                     await this.saveBlob(expected.sha256, Buffer.concat(chunks));
                 }
                 if (digest.copy().digest("hex") !== page.index.sha256)
-                    throw new Error("Archive version checksum mismatch / 归档版本校验失败");
+                    throw new Error("Archive version checksum mismatch");
                 parent = page.index;
             }
             if ((await file.stat()).size !== head.sizeBytes)
-                throw new Error("Archive length mismatch / 归档长度不匹配");
+                throw new Error("Archive length mismatch");
             await file.sync();
             await file.close();
             await link(temporary, target);

package/dist/runtime/connection.js

@@ -10,7 +10,7 @@ export async function serveRuntime(options) {
     const uploadSignal = AbortSignal.any([options.signal, uploads.signal]);
     const flush = () => options.store.flushArchives(uploadSignal).catch((error) => {
         if (!uploadSignal.aborted)
-            console.error("Archive pending / 归档待重试:", error);
+            console.error("Archive pending:", error);
     });
     const timer = setInterval(() => { void flush(); }, 10_000);
     void flush();
@@ -20,11 +20,11 @@ export async function serveRuntime(options) {
             if (options.signal.aborted)
                 return;
             if (outcome === "fatal")
-                throw new Error("Runtime connection rejected / Runtime 连接被拒绝");
+                throw new Error("Runtime connection rejected");
             if (outcome === "conflict") {
                 conflictSince ??= Date.now();
                 if (Date.now() - conflictSince >= (options.leaseConflictTimeoutMs ?? 90_000))
-                    throw new Error("Space is already connected to another Runtime / Space 已连接其他 Runtime");
+                    throw new Error("Space is already connected to another Runtime");
             }
             await delay(backoff, undefined, { signal: options.signal }).catch(() => undefined);
             backoff = Math.min(10_000, backoff * 2);
@@ -37,7 +37,7 @@ export async function serveRuntime(options) {
     }
 }
 async function connect(options) {
-    let token = await options.token();
+    let currentToken = await options.token();
     const socket = new WebSocket(options.url);
     const active = new Map();
     const seen = new Set();
@@ -69,9 +69,9 @@ async function connect(options) {
             catch {
                 stop();
             }
-            void options.token().then((next) => { if (next !== token) {
+            void options.token().then((next) => { if (next !== currentToken) {
                 send({ type: "runtime.auth", token: next });
-                token = next;
+                currentToken = next;
             } }).catch(stop);
         }
     }, 10_000);
@@ -90,7 +90,7 @@ async function connect(options) {
     socket.addEventListener("error", () => socket.close());
     socket.addEventListener("open", () => {
         try {
-            send({ type: "runtime.hello", version: RUNTIME_PROTOCOL_VERSION, spaceId: options.spaceId, token, capabilities: options.capabilities });
+            send({ type: "runtime.hello", version: RUNTIME_PROTOCOL_VERSION, spaceId: options.spaceId, token: currentToken, capabilities: options.capabilities });
         }
         catch {
             stop();
@@ -108,6 +108,9 @@ async function connect(options) {
                 connectionId = frame.connectionId;
                 clearTimeout(readyTimer);
                 options.onReady();
+                for await (const executions of options.store.pendingExecutionBatches()) {
+                    send({ type: "runtime.recovery", executions });
+                }
                 return;
             }
             if (!connectionId)
@@ -139,7 +142,7 @@ async function connect(options) {
                 catch (error) {
                     console.error("Runtime acknowledgement failed; result retained:", error);
                     active.delete(frame.requestId);
-                    send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", message: "Local acknowledgement failed; result retained / 本地确认失败，结果已保留" } });
+                    send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", message: "Local acknowledgement failed; result retained" } });
                     return;
                 }
                 active.delete(frame.requestId);
@@ -184,7 +187,7 @@ async function connect(options) {
                         if (!recovery.controller.signal.aborted) {
                             console.error("Runtime recovery failed; original files retained:", error);
                             try {
-                                send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", uncertain: true, message: "Result unavailable; files retained / 结果不可用，原始文件已保留" } });
+                                send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", uncertain: true, message: "Result unavailable; files retained" } });
                             }
                             catch { /* The next connection can read the same result. */ }
                         }
@@ -240,7 +243,7 @@ async function connect(options) {
                 active.delete(requestId);
             }
             if ([...active.values()].some((entry) => entry.sessionId === frame.input.sessionId) || active.size >= 8) {
-                send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", message: "Local Runtime is busy / 本地 Runtime 繁忙" } });
+                send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", message: "Local Runtime is busy" } });
                 return;
             }
             seen.add(frame.requestId);

package/dist/runtime/native-archive.js

@@ -28,13 +28,13 @@ export async function importNativeArchive(input) {
         const header = JSON.parse(Buffer.concat(fragments).toString("utf8"));
         if (input.harness === "pi") {
             if (header?.type !== "session" || header.id !== input.nativeSessionId)
-                throw new Error("Pi archive identity mismatch / Pi 归档身份不匹配");
+                throw new Error("Pi archive identity mismatch");
             header.cwd = input.cwd;
             delete header.parentSession;
         }
         else {
             if (header?.type !== "session_meta" || header.payload?.id !== input.nativeSessionId)
-                throw new Error("Codex archive identity mismatch / Codex 归档身份不匹配");
+                throw new Error("Codex archive identity mismatch");
             header.payload.id = input.id;
             if (header.payload.session_id != null)
                 header.payload.session_id = input.id;
@@ -56,7 +56,7 @@ export async function importNativeArchive(input) {
             const prefix = newline < 0 ? bytes : bytes.subarray(0, newline);
             headerBytes += prefix.length;
             if (headerBytes > RUNTIME_MAX_FRAME_BYTES)
-                throw new Error("Native header is too large / 原生文件头过大");
+                throw new Error("Native header is too large");
             fragments.push(prefix);
             if (newline >= 0) {
                 await writeHeader();

package/dist/runtime/process-group.js

@@ -63,6 +63,6 @@ export async function stopProcessGroup(pid) {
         }
     }
     catch (cause) {
-        throw new ProcessCleanupUncertainError("Tool process cleanup could not be confirmed; execution remains unresolved / 无法确认工具进程已停止，执行结果保持未确认", { cause });
+        throw new ProcessCleanupUncertainError("Tool process cleanup could not be confirmed; execution remains unresolved", { cause });
     }
 }

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

@@ -1,4 +1,4 @@
-import { type RuntimeExecutionEvent, type HarnessArchive, type RuntimeTurnInput } from "@neta-art/cohub";
+import { type RuntimeExecutionEvent, type HarnessArchive, type RuntimePendingExecution, type RuntimeTurnInput } from "@neta-art/cohub";
 import { RuntimeArchiveStore, type ArchiveTransport } from "./archive-store.js";
 import type { CodexTokenTotals } from "./codex-usage.js";
 export declare class ContextRequiredError extends Error {
@@ -27,6 +27,7 @@ export declare class RuntimeSessionStore {
     private archiveFlush;
     constructor(spaceId: string, stateRoot?: string, transport?: ArchiveTransport);
     private statePath;
+    pendingExecutionBatches(): AsyncGenerator<RuntimePendingExecution[]>;
     flushArchives(signal: AbortSignal): Promise<void>;
     private flushArchiveOutbox;
     pendingTurnIds(sessionId: string): Promise<string[]>;

package/dist/runtime/session-store.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { mkdir, open, readFile, readdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { contextToPiMessages, selectRuntimeContextMessages, runtimeEventSchema } from "@neta-art/cohub";
+import { contextToPiMessages, RUNTIME_RECOVERY_BATCH_SIZE, selectRuntimeContextMessages, runtimeEventSchema } from "@neta-art/cohub";
 import { RuntimeArchiveStore, checksumNativeFile, atomicRuntimeJson as atomicJson } from "./archive-store.js";
 import { importNativeArchive, readCodexArchiveTotals } from "./native-archive.js";
 export class ContextRequiredError extends Error {
@@ -26,6 +26,33 @@ export class RuntimeSessionStore {
         this.archives = new RuntimeArchiveStore(join(this.root, "archives"), transport);
     }
     statePath(input) { return join(this.root, input.harness, `${input.sessionId}.json`); }
+    async *pendingExecutionBatches() {
+        let batch = [];
+        for (const harness of ["pi", "codex"]) {
+            const directory = join(this.root, harness);
+            const names = await readdir(directory).catch((error) => { if (missing(error))
+                return []; throw error; });
+            for (const name of names) {
+                if (!name.endsWith(".json"))
+                    continue;
+                try {
+                    const state = JSON.parse(await readFile(join(directory, name), "utf8"));
+                    if (state.version !== 1 || state.harness !== harness || !state.sessionId || !state.pendingTurnId)
+                        continue;
+                    batch.push({ sessionId: state.sessionId, turnId: state.pendingTurnId, harness });
+                    if (batch.length >= RUNTIME_RECOVERY_BATCH_SIZE) {
+                        yield batch;
+                        batch = [];
+                    }
+                }
+                catch (error) {
+                    console.error(`Runtime session state unreadable: ${join(directory, name)}`, error);
+                }
+            }
+        }
+        if (batch.length)
+            yield batch;
+    }
     async flushArchives(signal) {
         this.archiveFlush ??= this.flushArchiveOutbox(signal).finally(() => { this.archiveFlush = null; });
         return this.archiveFlush;
@@ -46,20 +73,20 @@ export class RuntimeSessionStore {
                     state = JSON.parse(receipt);
                 }
                 catch {
-                    throw new CaptureUnavailableError("Invalid capture receipt / 归档捕获记录无效");
+                    throw new CaptureUnavailableError("Invalid capture receipt");
                 }
                 const turnId = state?.archivePendingTurnId;
                 if (typeof turnId !== "string" || typeof state?.path !== "string" || typeof state.resultChecksum !== "string") {
-                    throw new CaptureUnavailableError("Invalid capture receipt / 归档捕获记录无效");
+                    throw new CaptureUnavailableError("Invalid capture receipt");
                 }
                 if (!await this.archives.hasCapture(turnId)) {
                     const digest = await checksumNativeFile(state.path).catch((error) => {
                         if (missing(error))
-                            throw new CaptureUnavailableError("Native session missing / 原生会话文件不存在");
+                            throw new CaptureUnavailableError("Native session missing");
                         throw error;
                     });
                     if (digest !== state.resultChecksum)
-                        throw new CaptureUnavailableError("Native session changed; original files retained / 原生会话已变化，原文件已保留");
+                        throw new CaptureUnavailableError("Native session changed; original files retained");
                     signal.throwIfAborted();
                     await this.archives.stage(state, turnId);
                 }
@@ -73,10 +100,10 @@ export class RuntimeSessionStore {
                         receipt, reason: error.message, failedAt: new Date().toISOString(),
                     });
                     await rm(join(captures, name), { force: true });
-                    console.error("Archive capture unavailable; receipt retained / 归档捕获不可恢复，记录已保留:", error.message);
+                    console.error("Archive capture unavailable; receipt retained:", error.message);
                 }
                 else
-                    console.error("Archive capture pending / 归档捕获待重试:", error);
+                    console.error("Archive capture pending:", error);
             }
         }
         await this.archives.flush(signal);
@@ -182,7 +209,7 @@ export class RuntimeSessionStore {
             }
             catch (error) {
                 signal?.throwIfAborted();
-                console.error("Native archive unavailable; rebuilding from durable history / 原生归档不可用，将从持久历史重建:", error);
+                console.error("Native archive unavailable; rebuilding from durable history:", error);
             }
         }
         if (input.context.complete === false)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -22,7 +22,7 @@
     "commander": "^15.0.0",
     "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.18.0"
+    "@neta-art/cohub": "8.19.0"
   },
   "publishConfig": {
     "access": "public"