@neta-art/cohub-cli 8.0.0 → 8.1.0

package/README.md

@@ -85,26 +85,21 @@ COHUB_SPACE_ID=<spaceId> cohub spaces prompt "message" --json
 Connect one local workspace to a Space and select Pi or Codex per turn.
 
 To keep using native terminals with ordinary Cohub Chats / Turns:
-使用原生终端，并同步到普通 Cohub Chat / Turn：
 
 ```bash
 cohub runtime up -d --harness pi --harness codex
-cohub runtime attach --harness pi --harness codex
-# Reload Pi / restart Codex and approve its hook trust prompt.
-# 重载 Pi / 重启 Codex，并审核 Hook 信任提示。
-cohub runtime detach --harness pi --harness codex # Pause; retain data / 暂停，保留数据
+# Answer the native sync consent (default yes), then reload Pi / restart Codex
+# and approve its hook trust prompt.
+cohub runtime detach --harness pi --harness codex # Pause; retain data
 ```
 
-`attach` explicitly authorizes this project's opened conversation history and raw native archives.
-The Runtime Supervisor is the single local Daemon: Pi / Codex integrations use its private IPC,
+`up` installs native sync by default after one explicit consent (default yes); declining or a
+capability failure keeps the Runtime running without it, and `up` is idempotent. The Runtime
+Supervisor is the single local Daemon: Pi / Codex integrations use its private IPC,
 while native Turn events use the existing Runtime WebSocket. Configuration is backed up, existing
 Runtime bindings are reused, and competing continuations fork at complete Turns without blocking native work. Requires Pi 0.85.1+ or Codex with stable
 Hooks enabled. User-level integrations remain inert outside opted-in directories. See
-[boundaries and privacy](../../docs/local-runtime.md#native-clients--原生客户端).
-
-`attach` 明确授权上传当前项目打开的对话历史与原生归档；复用现有绑定，配置修改前备份。
-冲突时按完整 Turn 分支，不阻塞本地执行。用户级集成在未授权目录中不会采集数据。
-
+[boundaries and privacy](../../docs/local-runtime.md#native-clients).
 
 ```bash
 cohub runtime up ./project --harness pi --harness codex
@@ -142,10 +137,6 @@ local process and remote component status. `down` retains all data and requires
 when executions remain unconfirmed. `logs --level warn --follow` shows sensitive events;
 foreground startup prints these automatically. Runtime commands never fall back to Home.
 
-普通使用只需 `cohub runtime up`，首次提示新建，后续优先复用。`-n` 是 `--new` 的简写，
-`--name` 单独指定名称。`-d` 后台运行并返回链接、PID 和日志位置；`down` 停止但保留所有数据。
-断网及临时凭证错误自动重试；断连不代表任务已停止，也不会自动重跑工具。
-
 ## Chats and prompts
 
 Use `spaces prompt` for immediate sends, delayed sends, one-time schedules, recurring schedules, new Chats, and existing Chats.

package/dist/commands/runtime.js

@@ -1,35 +1,36 @@
 import { setTimeout as delay } from "node:timers/promises";
-import { createInterface } from "node:readline/promises";
 import { createClient } from "../client.js";
 import { json as outJson, jsonRequested } from "../output.js";
 import { currentIdentityKey } from "../space.js";
 import { resolveRuntimeTarget, runtimeUp, parseRuntimeHarnesses } from "../runtime/launch.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding } from "../runtime/space-binding.js";
 import { installNativeSync } from "../runtime/native-install.js";
+import { discoverNativeImportCandidates, nativeRuntimeRoot, readNativeSyncConfig } from "../runtime/native-sync.js";
 import { listNativeSyncStores } from "../runtime/native-sync-store.js";
+import { requestNativeDaemon } from "../runtime/native-ipc.js";
 import { requestRuntimeInstance, runtimeInstanceDirectory } from "../runtime/instance.js";
-import { atLeastLevel, diagnosticLevels, formatDiagnostic, printRuntimeSummary } from "../runtime/presentation.js";
+import { atLeastLevel, diagnosticLevels, formatDiagnostic, formatNativeSync, printRuntimeSummary } from "../runtime/presentation.js";
 import { RuntimeSessionStore } from "../runtime/session-store.js";
 import { readRuntimeDiagnosticEvents, RuntimeDiagnosticReader, runtimeDiagnosticsDirectory, serializeDiagnosticError } from "../runtime/diagnostics.js";
 export { resolveLocalSpaceName, parseRuntimeHarnesses } from "../runtime/launch.js";
 const reportFailure = (cause) => {
-    process.stderr.write(`Runtime failed / Runtime 失败: ${serializeDiagnosticError(cause).message}\n`);
+    process.stderr.write(`Runtime failed: ${serializeDiagnosticError(cause).message}\n`);
     process.exitCode = 1;
 };
 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, --new", "Create a new Space / 创建新 Space")
-        .option("--name <name>", "New Space name / 新 Space 名称")
-        .option("-d, --detach", "Run in the background / 后台运行")
-        .option("--harness <name>", "Pi or Codex; repeatable / 可重复指定", (value, previous) => [...previous, value], [])
-        .option("--pi <path>", "Pi executable / Pi 可执行文件")
-        .option("--codex <path>", "Codex executable / Codex 可执行文件")
-        .option("-y, --yes", "Accept defaults and local execution / 接受默认选择并授权本地执行")
-        .option("--verbose", "Show diagnostic details / 显示诊断详情")
-        .option("--json", "JSON output / JSON 输出")
+        .description("Connect local Harnesses and files")
+        .option("-s, --space <id>", "Target Space")
+        .option("-n, --new", "Create a new Space")
+        .option("--name <name>", "New Space name")
+        .option("-d, --detach", "Run in the background")
+        .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 defaults and authorize local execution and native sync")
+        .option("--verbose", "Show diagnostic details")
+        .option("--json", "JSON output")
         .action(async (dir, options) => {
         try {
             await runtimeUp(program, dir, { ...options, json: jsonRequested(options) });
@@ -38,100 +39,202 @@ export function registerRuntime(program) {
             reportFailure(cause);
         }
     });
-    for (const action of ["attach", "detach"])
-        runtime.command(action)
-            .description(action === "attach" ? "Sync native Pi / Codex Turns / 同步原生 Pi / Codex 对话" : "Pause native sync; retain all receipts / 暂停原生同步，保留所有回执")
-            .option("-s, --space <id>", "Target Space / 目标 Space")
-            .option("--harness <name>", "Pi or Codex; repeatable / 可重复指定", (value, previous) => [...previous, value], [])
-            .option("--pi <path>", "Pi executable for capability checks / 用于能力检查的 Pi 路径")
-            .option("--codex <path>", "Codex executable for capability checks / 用于能力检查的 Codex 路径")
-            .option("-y, --yes", "Authorize project conversation and native archive uploads / 授权上传项目对话及原生归档")
-            .option("--json", "JSON output / JSON 输出")
-            .action(async (options) => {
-            try {
-                const spaceId = await resolveRuntimeTarget(program, options.space);
-                const identity = currentIdentityKey();
-                if (!identity)
-                    throw new Error("Sign in first / 请先登录");
-                const root = await canonicalRuntimeRoot(process.cwd());
-                if (action === "attach" && (await getRuntimeSpaceBinding(root, identity))?.spaceId !== spaceId)
-                    throw new Error("Bind this directory with runtime up --space first / 请先使用 runtime up --space 绑定当前目录");
-                const instance = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
-                if (action === "attach" && (!instance || instance.root !== root))
-                    throw new Error("Start this directory's Runtime first: cohub runtime up -d / 请先启动当前目录的 Runtime");
-                if (action === "attach" && !instance?.nativeSync)
-                    throw new Error("Restart the Runtime with this CLI before attaching / 请先使用新版 CLI 重启 Runtime，再接入原生客户端");
-                const harnesses = parseRuntimeHarnesses(options.harness.length ? options.harness : instance?.harnesses ?? ["pi", "codex"]);
-                if (action === "attach" && harnesses.some((harness) => !instance?.harnesses.includes(harness)))
-                    throw new Error("Enable these Harnesses with runtime up first / 请先通过 runtime up 启用对应 Harness");
-                if (action === "attach" && !options.yes) {
-                    if (!process.stdin.isTTY)
-                        throw new Error("Use --yes to authorize native sync / 请使用 --yes 授权原生同步");
-                    const rl = createInterface({ input: process.stdin, output: process.stderr });
-                    try {
-                        const answer = await rl.question(`Install user-level ${harnesses.join(" / ")} integration and upload this project's opened conversations, tool output and raw archives to this Space? History may contain secrets. [y/N]\n安装用户级原生集成，并将当前项目打开的对话、工具输出和原始归档上传至此 Space？历史可能包含敏感信息。[y/N] `);
-                        if (!/^y(es)?$/i.test(answer.trim()))
-                            return;
-                    }
-                    finally {
-                        rl.close();
-                    }
-                }
-                const result = await installNativeSync({ root, spaceId, identity, harnesses, disabled: action === "detach", executables: { pi: options.pi, codex: options.codex } });
+    runtime.command("detach")
+        .description("Pause native sync; retain all receipts")
+        .option("-s, --space <id>", "Target Space")
+        .option("--harness <name>", "Pi or Codex; repeatable", (value, previous) => [...previous, value], [])
+        .option("--json", "JSON output")
+        .action(async (options) => {
+        try {
+            const spaceId = await resolveRuntimeTarget(program, options.space);
+            const identity = currentIdentityKey();
+            if (!identity)
+                throw new Error("Sign in first");
+            const root = await canonicalRuntimeRoot(process.cwd());
+            if ((await getRuntimeSpaceBinding(root, identity))?.spaceId !== spaceId)
+                throw new Error("Bind this directory with runtime up first");
+            const instance = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
+            const harnesses = parseRuntimeHarnesses(options.harness.length ? options.harness : instance?.harnesses ?? ["pi", "codex"]);
+            const result = await installNativeSync({ root, spaceId, identity, harnesses, disabled: true });
+            if (jsonRequested(options))
+                outJson({ ...result, enabled: false });
+            else
+                process.stdout.write("Native sync paused; all local records retained\n");
+        }
+        catch (cause) {
+            reportFailure(cause);
+        }
+    });
+    runtime.command("import [dir]")
+        .description("Import local conversations")
+        .option("-s, --space <id>", "Target Space")
+        .option("--harness <name>", "Filter by harness; repeatable", (value, previous) => [...previous, value], [])
+        .option("--session <id>", "Filter by native session ID")
+        .option("--dry-run", "Preview without importing")
+        .option("-y, --yes", "Skip confirmation")
+        .option("--json", "Output as JSON")
+        .action(async (dir, options) => {
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        try {
+            const identity = currentIdentityKey();
+            if (!identity)
+                throw new Error("Sign in first");
+            const root = await canonicalRuntimeRoot(dir ?? process.cwd());
+            const spaceId = await resolveRuntimeTarget(program, options.space);
+            const binding = await getRuntimeSpaceBinding(root, identity);
+            if (!binding || binding.spaceId !== spaceId)
+                throw new Error("Bind this directory with runtime up first");
+            const local = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
+            if (!local)
+                throw new Error("Local Runtime is not running");
+            const config = await readNativeSyncConfig(nativeRuntimeRoot(spaceId), identity);
+            if (!config || config.root !== root)
+                throw new Error("Native sync is not enabled for this directory");
+            const harnesses = parseRuntimeHarnesses(options.harness.length ? options.harness : config.harnesses);
+            let lastProgress = 0;
+            const discovered = await discoverNativeImportCandidates(root, harnesses, {
+                signal: controller.signal,
+                onProgress: ({ harness, scanned, candidates: found }) => {
+                    if (jsonRequested(options) || scanned - lastProgress < 25)
+                        return;
+                    lastProgress = scanned;
+                    process.stderr.write(`Scanned ${scanned} ${harness} transcript${scanned === 1 ? "" : "s"}; found ${found}\n`);
+                },
+            });
+            const candidates = discovered.candidates.filter((candidate) => !options.session || candidate.nativeSessionId === options.session);
+            const result = {
+                spaceId, root, harnesses, candidates, errors: discovered.errors,
+                imported: 0, failed: [], dryRun: Boolean(options.dryRun),
+                complete: discovered.errors.length === 0,
+            };
+            if (jsonRequested(options) && options.dryRun) {
+                result.complete = result.complete && result.failed.length === 0;
+                outJson(result);
+                if (!result.complete)
+                    process.exitCode = 1;
+                return;
+            }
+            if (!candidates.length) {
+                if (!result.complete)
+                    process.exitCode = 1;
                 if (jsonRequested(options))
                     outJson(result);
                 else
-                    process.stdout.write(action === "attach"
-                        ? `Native sync enabled. Reload Pi or restart Codex and review its hook trust prompt. / 原生同步已启用。请重载 Pi 或重启 Codex，并审核 Hook 信任提示。\n${result.configPath}\n`
-                        : "Native sync paused; all local records retained / 原生同步已暂停，所有本地记录已保留\n");
+                    process.stdout.write("No existing native conversations found\n");
+                return;
             }
-            catch (cause) {
-                reportFailure(cause);
+            if (options.dryRun) {
+                if (jsonRequested(options))
+                    outJson(result);
+                else {
+                    process.stdout.write(`Found ${candidates.length} native conversation${candidates.length === 1 ? "" : "s"}\n`);
+                    for (const candidate of candidates)
+                        process.stdout.write(`  ${candidate.harness} ${candidate.nativeSessionId} ${candidate.turnCount} Turn${candidate.turnCount === 1 ? "" : "s"} ${candidate.path}\n`);
+                    for (const error of discovered.errors)
+                        process.stdout.write(`Skipped ${error.path}: ${error.message}\n`);
+                }
+                if (!result.complete)
+                    process.exitCode = 1;
+                return;
+            }
+            if (!options.yes) {
+                if (!process.stdin.isTTY)
+                    throw new Error("Use --yes in non-interactive mode");
+                const { createInterface } = await import("node:readline/promises");
+                const rl = createInterface({ input: process.stdin, output: process.stderr });
+                try {
+                    const answer = await rl.question(`Import ${candidates.length} native conversation${candidates.length === 1 ? "" : "s"} to Space ${spaceId}? [Y/n] `);
+                    if (!/^(|y(es)?)$/i.test(answer.trim())) {
+                        if (jsonRequested(options))
+                            outJson({ ...result, cancelled: true });
+                        else
+                            process.stdout.write("Import cancelled\n");
+                        return;
+                    }
+                }
+                finally {
+                    rl.close();
+                }
+            }
+            for (const candidate of candidates) {
+                try {
+                    const response = await requestNativeDaemon({ harness: candidate.harness, cwd: root, path: candidate.path, nativeSessionId: candidate.nativeSessionId,
+                        sessionStartedAt: candidate.sessionStartedAt, origin: "local_import", settled: true });
+                    if (!response.ok)
+                        throw new Error(response.message);
+                    result.imported += 1;
+                }
+                catch (error) {
+                    result.failed.push({ path: candidate.path, message: error instanceof Error ? error.message : String(error) });
+                }
+            }
+            result.complete = result.complete && result.failed.length === 0;
+            if (jsonRequested(options))
+                outJson(result);
+            else {
+                process.stdout.write(`Imported ${result.imported}/${candidates.length} native conversation${candidates.length === 1 ? "" : "s"}\n`);
+                for (const error of [...discovered.errors, ...result.failed])
+                    process.stdout.write(`Skipped ${error.path}: ${error.message}\n`);
+                process.stdout.write("Uploads continue in the local Runtime background\n");
             }
-        });
-    runtime.command("status").description("Local and server status / 本地与服务端状态")
-        .option("-s, --space <id>", "Target Space / 目标 Space")
-        .option("--json", "JSON output / JSON 输出")
+            if (!result.complete)
+                process.exitCode = 1;
+        }
+        catch (cause) {
+            reportFailure(cause);
+        }
+        finally {
+            process.removeListener("SIGINT", stop);
+            process.removeListener("SIGTERM", stop);
+        }
+    });
+    runtime.command("status").description("Local and server status")
+        .option("-s, --space <id>", "Target Space")
+        .option("--json", "JSON output")
         .action(async (options) => {
         try {
             const spaceId = await resolveRuntimeTarget(program, options.space);
             const identity = currentIdentityKey();
             const local = identity ? await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId)) : null;
             const space = createClient().space(spaceId);
-            const store = new RuntimeSessionStore(spaceId, { projectionSource: space });
+            const store = new RuntimeSessionStore(spaceId, { projectionSource: space, archiveTransport: null });
             const [remote, pendingLocalArchives, failedLocalArchives, nativeStores] = await Promise.all([
                 space.getRuntime(undefined, { signal: AbortSignal.timeout(5000) }).then((value) => ({ value, error: null })).catch((error) => ({ value: null, error: serializeDiagnosticError(error).message })),
                 store.archives.pendingCount(), store.archives.failedCaptureCount(),
                 identity ? listNativeSyncStores(store.root, spaceId, identity) : [],
             ]);
             const nativeSessions = await Promise.all(nativeStores.map((native) => native.status()));
-            const result = { ...remote.value, spaceId, local, remote: remote.value, remoteError: remote.error, diagnosticsPath: runtimeDiagnosticsDirectory(store.root), pendingLocalArchives, failedLocalArchives, nativeSessions };
+            // A corrupt native sync config must never take down the whole status report.
+            const nativeSync = identity ? await readNativeSyncConfig(store.root, identity).then((config) => ({ config, error: null }), (error) => ({ config: null, error: serializeDiagnosticError(error).message })) : { config: null, error: null };
+            const result = { ...remote.value, spaceId, local, remote: remote.value, remoteError: remote.error, diagnosticsPath: runtimeDiagnosticsDirectory(store.root), pendingLocalArchives, failedLocalArchives, nativeSync: nativeSync.config, nativeSyncError: nativeSync.error, nativeSessions };
             if (jsonRequested(options))
                 outJson(result);
             else {
                 if (local)
                     printRuntimeSummary(local);
                 else
-                    process.stdout.write(`Local process / 本地进程  Not running / 未运行\nSpace / 空间  ${spaceId}\nLogs / 日志  ${result.diagnosticsPath}\n`);
-                process.stdout.write(`Server / 服务端  ${remote.error ? `Unknown / 未知 — ${remote.error}` : remote.value?.online ? "Harness connected / Harness 已连接" : "Offline / 离线"}\nArchives / 归档  ${pendingLocalArchives} pending / 待同步 · ${failedLocalArchives} failed / 失败\n`);
-                if (nativeSessions.length)
-                    process.stdout.write(`Native chats / 原生对话  ${nativeSessions.length} · ${nativeSessions.reduce((sum, session) => sum + session.pendingTurns, 0)} Turns pending / Turn 待同步 · ${nativeSessions.reduce((sum, session) => sum + session.pendingArchives, 0)} archives pending / 归档待同步\n`);
+                    process.stdout.write(`Local process  Not running\nSpace  ${spaceId}\nLogs  ${result.diagnosticsPath}\n`);
+                process.stdout.write(`Server  ${remote.error ? `Unknown — ${remote.error}` : remote.value?.online ? "Harness connected" : "Offline"}\nArchives  ${pendingLocalArchives} pending · ${failedLocalArchives} failed\n`);
+                process.stdout.write(formatNativeSync(nativeSync.config, nativeSessions, nativeSync.error));
             }
         }
         catch (cause) {
             reportFailure(cause);
         }
     });
-    runtime.command("down").description("Stop this local Runtime; retain all data / 停止本地 Runtime，保留所有数据")
-        .option("-s, --space <id>", "Target Space / 目标 Space")
-        .option("-y, --yes", "Stop even with unconfirmed executions / 确认停止包含未确认执行的 Runtime")
-        .option("--json", "JSON output / JSON 输出")
+    runtime.command("down").description("Stop this local Runtime; retain all data")
+        .option("-s, --space <id>", "Target Space")
+        .option("-y, --yes", "Stop even with unconfirmed executions")
+        .option("--json", "JSON output")
         .action(async (options) => {
         try {
             const spaceId = await resolveRuntimeTarget(program, options.space);
             const identity = currentIdentityKey();
             if (!identity)
-                throw new Error("Sign in to the Runtime account / 请登录 Runtime 所属账号");
+                throw new Error("Sign in to the Runtime account");
             const directory = runtimeInstanceDirectory(identity, spaceId);
             const local = await requestRuntimeInstance(directory, "stop", Boolean(options.yes));
             const until = Date.now() + 15_000;
@@ -146,33 +249,33 @@ export function registerRuntime(program) {
                 } // An unreachable control socket does not prove the process stopped.
             }
             if (running)
-                throw new Error("Runtime is still stopping; inspect logs / Runtime 仍在停止，请检查日志");
+                throw new Error("Runtime is still stopping; inspect logs");
             if (jsonRequested(options))
                 outJson({ spaceId, stopped: true });
             else
-                process.stdout.write("Runtime stopped; data retained / Runtime 已停止，数据已保留\n");
+                process.stdout.write("Runtime stopped; data retained\n");
         }
         catch (cause) {
             reportFailure(cause);
         }
     });
-    runtime.command("logs").description("Read local Runtime diagnostics / 查看本地 Runtime 日志")
-        .option("-s, --space <id>", "Target Space / 目标 Space")
-        .option("-l, --limit <count>", "Number of events / 事件数量", "100")
-        .option("--level <level>", "Minimum level: debug, info, warn, error / 最低级别", "info")
-        .option("-f, --follow", "Keep watching / 持续查看")
-        .option("--json", "Raw diagnostic events / 原始诊断事件")
+    runtime.command("logs").description("Read local Runtime diagnostics")
+        .option("-s, --space <id>", "Target Space")
+        .option("-l, --limit <count>", "Number of events", "100")
+        .option("--level <level>", "Minimum level: debug, info, warn, error", "info")
+        .option("-f, --follow", "Keep watching")
+        .option("--json", "Raw diagnostic events")
         .action(async (options) => {
         const controller = new AbortController();
         const stop = () => controller.abort();
         try {
             const spaceId = await resolveRuntimeTarget(program, options.space);
-            const store = new RuntimeSessionStore(spaceId, { projectionSource: createClient().space(spaceId) });
+            const store = new RuntimeSessionStore(spaceId, { projectionSource: createClient().space(spaceId), archiveTransport: null });
             const limit = Number(options.limit);
             if (!Number.isSafeInteger(limit) || limit < 1 || limit > 10_000)
-                throw new Error("Use a limit from 1 to 10000 / 数量范围为 1 到 10000");
+                throw new Error("Use a limit from 1 to 10000");
             if (!diagnosticLevels.includes(options.level))
-                throw new Error("Use debug, info, warn or error / 请使用有效日志级别");
+                throw new Error("Use debug, info, warn or error");
             const asJson = jsonRequested(options);
             const reader = new RuntimeDiagnosticReader(store.root);
             process.once("SIGINT", stop);
@@ -187,7 +290,7 @@ export function registerRuntime(program) {
                         process.stdout.write(asJson ? `${JSON.stringify(event)}\n` : formatDiagnostic(event, true));
                 if (!options.follow) {
                     if (!asJson && !events.length)
-                        process.stdout.write("No matching diagnostics / 未找到匹配日志\n");
+                        process.stdout.write("No matching diagnostics\n");
                     break;
                 }
                 await delay(1000, undefined, { signal: controller.signal }).catch(() => undefined);

package/dist/commands/sandboxd-binary.d.ts

@@ -1,4 +1,4 @@
-export declare const SANDBOXD_VERSION = "v2.54.0";
+export declare const SANDBOXD_VERSION = "v2.55.0";
 export declare class SandboxdDownloadError extends Error {
     name: string;
 }

package/dist/commands/sandboxd-binary.js

@@ -21,7 +21,14 @@ import { Readable } from "node:stream";
 // carries the optional workspace-search runner download. v2.53.1 already has
 // the native FSEvents backends and the `runtimeId` control frame, and older
 // releases stay usable through the compatibility readiness/restart path.
-export const SANDBOXD_VERSION = "v2.54.0";
+//
+// v2.54.1 keeps the same wire protocol and adds relay diagnostics: data-channel
+// pairing outlives the runner's dial timeout, dial failures distinguish a
+// timeout from an explicit rejection, and teardown-time websocket write
+// failures log at debug instead of warn. v2.55.0 republishes that compatible
+// runner alongside the matching platform release; no new runner capability is
+// required.
+export const SANDBOXD_VERSION = "v2.55.0";
 const BINARY_NAME = "cohub-sandboxd";
 // Public CDN prefix hosting the release archives (the repo is private, so the
 // GitHub Release assets are not publicly downloadable). Overridable for staging

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

@@ -24,7 +24,9 @@ export declare class RuntimeArchiveStore {
     private flushing;
     private readonly capturing;
     private errorReporter;
-    constructor(root: string, transport?: ArchiveTransport | undefined);
+    constructor(root: string, transport?: ArchiveTransport | null | undefined);
+    /** Distinguishes "no transport configured" from transient upload failures. */
+    get hasTransport(): boolean;
     setErrorReporter(reporter: ((error: unknown, index?: HarnessArchiveIndex) => void) | null): void;
     pendingCount(): Promise<number>;
     failedCaptureCount(): Promise<number>;

package/dist/runtime/archive-store.js

@@ -49,6 +49,8 @@ export class RuntimeArchiveStore {
         this.root = root;
         this.transport = transport;
     }
+    /** Distinguishes "no transport configured" from transient upload failures. */
+    get hasTransport() { return this.transport != null; }
     setErrorReporter(reporter) {
         this.errorReporter = reporter;
     }

package/dist/runtime/connection.js

@@ -56,7 +56,7 @@ export async function serveRuntime(options) {
             if (options.signal.aborted)
                 return;
             if (outcome === "fatal")
-                throw new Error("Runtime connection rejected / Runtime 连接被拒绝，请检查权限或升级 CLI");
+                throw new Error("Runtime connection rejected; check permissions or upgrade the CLI");
             if (readyAt && Date.now() - readyAt >= 60_000) {
                 backoff = 500;
                 attempt = 0;
@@ -139,10 +139,11 @@ async function connect(options) {
         }
         socket.send(data);
     };
-    const stop = () => {
+    const closeTransport = () => socket.close();
+    const shutdown = () => {
         for (const execution of active.values())
             execution.controller.abort();
-        socket.close();
+        closeTransport();
     };
     const sendNative = (event) => new Promise((resolve, reject) => {
         if (!nativeChannelReady || !connectionId) {
@@ -161,7 +162,7 @@ async function connect(options) {
             reject(error instanceof Error ? error : new Error(String(error)));
         }
     });
-    options.signal.addEventListener("abort", stop, { once: true });
+    options.signal.addEventListener("abort", shutdown, { once: true });
     const heartbeat = setInterval(() => {
         const heartbeatAgeMs = Date.now() - lastHeartbeat;
         if (heartbeatAgeMs > 30_000) {
@@ -169,12 +170,7 @@ async function connect(options) {
                 ageMs: heartbeatAgeMs,
                 activeExecutions: active.size,
             }, { connectionId });
-            for (const execution of active.values()) {
-                log("error", "runtime.execution_heartbeat_timeout", {
-                    ageMs: heartbeatAgeMs,
-                }, executionContext(connectionId, execution));
-            }
-            stop();
+            closeTransport();
         }
         else if (connectionId) {
             try {
@@ -184,7 +180,7 @@ async function connect(options) {
                 log("warn", "runtime.heartbeat_send_failed", {
                     error: serializeDiagnosticError(error),
                 }, { connectionId });
-                stop();
+                closeTransport();
             }
             void options.token().then((next) => {
                 if (next !== currentToken) {
@@ -197,12 +193,12 @@ async function connect(options) {
                         log("warn", "runtime.auth_refresh_send_failed", {
                             error: serializeDiagnosticError(error),
                         }, { connectionId });
-                        stop();
+                        closeTransport();
                     }
                 }
             }).catch((error) => {
                 log("warn", "runtime.auth_refresh_failed", { error: serializeDiagnosticError(error) }, { connectionId });
-                stop();
+                closeTransport();
             });
         }
     }, 10_000);
@@ -227,12 +223,14 @@ async function connect(options) {
             }
             nativePending.clear();
             options.onDisconnected?.();
+            const executionMustStop = options.signal.aborted || fatal || conflict;
             for (const execution of active.values()) {
-                log("error", "runtime.execution_transport_lost", {
+                log(executionMustStop ? "error" : "warn", executionMustStop ? "runtime.execution_transport_invalidated" : "runtime.execution_transport_detached", {
                     code: event.code,
                     reason: event.reason,
                 }, executionContext(connectionId, execution));
-                execution.controller.abort();
+                if (executionMustStop)
+                    execution.controller.abort();
             }
             resolve();
         }, { once: true });
@@ -261,7 +259,7 @@ async function connect(options) {
         }
         catch (error) {
             log("error", "runtime.hello_failed", { error: serializeDiagnosticError(error) });
-            stop();
+            closeTransport();
         }
     });
     socket.addEventListener("message", (event) => {
@@ -274,6 +272,8 @@ async function connect(options) {
                 log("error", "runtime.protocol.invalid_json", { error: serializeDiagnosticError(error) }, { connectionId });
                 throw error;
             }
+            // Any inbound frame proves the transport is live; heartbeat frames are one case.
+            lastHeartbeat = Date.now();
             if (raw.type === "runtime.ready") {
                 const frame = runtimeReadySchema.parse(raw);
                 if (connectionId === frame.connectionId)
@@ -303,7 +303,6 @@ async function connect(options) {
             if (!connectionId)
                 throw new Error("Runtime handshake is incomplete");
             if (raw.type === "runtime.heartbeat") {
-                lastHeartbeat = Date.now();
                 return;
             }
             if (raw.type === "runtime.native.result") {
@@ -508,7 +507,17 @@ async function connect(options) {
             const emit = (value) => {
                 if (value.type === "message.commit")
                     durableEvents.push(value);
-                send({ type: "runtime.event", requestId: frame.requestId, event: value });
+                // Streaming is best-effort. A detached transport must not cancel local model or tool work;
+                // durable commits and the final result are replayed after reconnect.
+                if (disconnected.signal.aborted || socket.readyState !== WebSocket.OPEN || socket.bufferedAmount > RUNTIME_MAX_FRAME_BYTES)
+                    return;
+                try {
+                    send({ type: "runtime.event", requestId: frame.requestId, event: value });
+                }
+                catch (error) {
+                    if (!disconnected.signal.aborted && socket.readyState === WebSocket.OPEN)
+                        throw error;
+                }
             };
             execution.promise = (async () => {
                 try {
@@ -541,7 +550,10 @@ async function connect(options) {
                             frame.input.context = await requestContext(controller.signal);
                         }
                     }
-                    await options.store.recordResult(execution.result.state, frame.requestId, [...durableEvents, execution.result.event]);
+                    await options.store.recordResult(execution.result.state, frame.requestId, [...durableEvents, execution.result.event], execution.result.uncertainCleanup ? { uncertainCleanup: execution.result.uncertainCleanup } : undefined);
+                    if (execution.result.uncertainCleanup) {
+                        log("warn", "runtime.turn_cleanup_pending", { cleanup: execution.result.uncertainCleanup.error }, context);
+                    }
                     emit(execution.result.event);
                 }
                 catch (error) {
@@ -560,7 +572,7 @@ async function connect(options) {
             })();
         })().catch((error) => {
             log("error", "runtime.protocol_error", { error: serializeDiagnosticError(error) }, { connectionId });
-            stop();
+            closeTransport();
         });
     });
     readyTimer = setTimeout(() => {
@@ -568,7 +580,7 @@ async function connect(options) {
         socket.close(4408, "Runtime handshake timed out");
     }, 15_000);
     if (options.signal.aborted)
-        stop();
+        shutdown();
     try {
         await closed;
         await Promise.allSettled([...active.values()].map((entry) => entry.promise));
@@ -576,7 +588,7 @@ async function connect(options) {
     finally {
         clearTimeout(readyTimer);
         clearInterval(heartbeat);
-        options.signal.removeEventListener("abort", stop);
+        options.signal.removeEventListener("abort", shutdown);
     }
     if (unauthorized && !options.signal.aborted)
         await options.token(true);