@neta-art/cohub-cli 8.0.0 → 8.0.1

package/dist/runtime/presentation.js

@@ -3,26 +3,28 @@ export const diagnosticLevels = ["debug", "info", "warn", "error"];
 export const atLeastLevel = (level, minimum) => diagnosticLevels.indexOf(level) >= diagnosticLevels.indexOf(minimum);
 export const runtimeWebUrl = (spaceId) => `https://${resolveCohubEnvironment() === "prod" ? "" : "dev."}cohub.live/spaces/${spaceId}`;
 const messages = {
-    "runtime.ready": "Harness connected / Harness 已连接",
-    "runtime.available": "Runtime ready / Runtime 已就绪",
-    "runtime.websocket.closed": "Connection lost; reconnecting / 连接中断，正在重连",
-    "runtime.heartbeat_timeout": "Connection timed out; reconnecting / 连接超时，正在重连",
-    "runtime.auth_token_failed": "Cannot obtain credentials; retrying / 暂时无法获取凭证，正在重试",
-    "runtime.auth_required": "Sign in with cohub auth login / 请运行 cohub auth login 登录",
-    "runtime.stopped": "Runtime stopped / Runtime 已停止",
-    "runtime.failed": "Runtime needs attention / Runtime 需要处理",
-    "runtime.turn_failed": "Turn failed; local files retained / 执行失败，本地文件已保留",
-    "runtime.connection_failed": "Connection attempt failed; retrying / 连接失败，将继续重试",
-    "runtime.execution_transport_lost": "Execution disconnected; outcome needs reconciliation / 执行连接中断，结果待确认",
-    "archive.upload_pending": "Archive upload pending; local data retained / 归档待上传，本地数据已保留",
-    "native.sync_pending": "Native sync pending; local records retained / 原生同步待处理，本地记录已保留",
-    "archive.capture_pending": "Archive capture pending / 归档待处理",
-    "archive.capture_unavailable": "Archive unavailable; original receipt retained / 归档不可用，原始回执已保留",
-    "archive.restore_failed": "Native restore unavailable; using saved history / 原生恢复不可用，使用已保存历史",
-    "sandboxd.process_exit": "File bridge stopped; restarting / 文件桥接已退出，正在重启",
-    "sandboxd.download": "Preparing file bridge / 正在准备文件桥接",
-    "sandboxd.connected": "File bridge connected / 文件桥接已连接",
-    "sandboxd.disconnected": "File bridge disconnected; reconnecting / 文件桥接已断开，正在重连",
+    "runtime.ready": "Harness connected",
+    "runtime.available": "Runtime ready",
+    "runtime.websocket.closed": "Connection lost; reconnecting",
+    "runtime.heartbeat_timeout": "Connection timed out; reconnecting",
+    "runtime.auth_token_failed": "Cannot obtain credentials; retrying",
+    "runtime.auth_required": "Sign in with cohub auth login",
+    "runtime.stopped": "Runtime stopped",
+    "runtime.failed": "Runtime needs attention",
+    "runtime.turn_failed": "Turn failed; local files retained",
+    "runtime.turn_cleanup_pending": "Turn result saved; tool cleanup still unconfirmed",
+    "runtime.connection_failed": "Connection attempt failed; retrying",
+    "runtime.execution_transport_detached": "Execution continues locally; result replays after reconnect",
+    "runtime.execution_transport_invalidated": "Execution interrupted; outcome needs reconciliation",
+    "archive.upload_pending": "Archive upload pending; local data retained",
+    "native.sync_pending": "Native sync pending; local records retained",
+    "archive.capture_pending": "Archive capture pending",
+    "archive.capture_unavailable": "Archive unavailable; original receipt retained",
+    "archive.restore_failed": "Native restore unavailable; using saved history",
+    "sandboxd.process_exit": "File bridge stopped; restarting",
+    "sandboxd.download": "Preparing file bridge",
+    "sandboxd.connected": "File bridge connected",
+    "sandboxd.disconnected": "File bridge disconnected; reconnecting",
 };
 export function formatDiagnostic(event, verbose = false) {
     const text = messages[event.event] ?? (typeof event.data?.message === "string" ? event.data.message : event.event);
@@ -46,7 +48,7 @@ export function createDiagnosticConsole(verbose = false, write = (line) => proce
         if (last.size >= 256)
             last.delete(last.keys().next().value ?? "");
         last.set(key, { at: now, suppressed: 0 });
-        const repeated = previous?.suppressed ? ` (+${previous.suppressed} repeated / 重复)` : "";
+        const repeated = previous?.suppressed ? ` (+${previous.suppressed} repeated)` : "";
         write(`${formatDiagnostic(event, verbose).trimEnd()}${repeated}\n`);
     };
 }
@@ -56,21 +58,21 @@ export function printRuntimeSummary(summary, json = false, reused = false) {
         process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
         return;
     }
-    const label = summary.state === "ready" ? "Runtime ready / Runtime 已就绪" : `Runtime ${summary.state} / Runtime 尚未就绪`;
-    process.stdout.write(`\n${label}${reused ? " · reused / 已复用" : ""}\n\n`);
+    const label = summary.state === "ready" ? "Runtime ready" : `Runtime ${summary.state}`;
+    process.stdout.write(`\n${label}${reused ? " · reused" : ""}\n\n`);
     const rows = [
-        ["Space / 空间", summary.spaceId],
-        ["URL / 链接", value.url],
-        ["Directory / 目录", summary.root],
+        ["Space", summary.spaceId],
+        ["URL", value.url],
+        ["Directory", summary.root],
         ["Harness", summary.harnesses.join(" · ")],
-        ["Mode / 模式", summary.background ? "Background / 后台" : "Foreground / 前台"],
+        ["Mode", summary.background ? "Background" : "Foreground"],
         ["PID", String(summary.pid)],
-        ["Logs / 日志", summary.diagnosticsPath],
+        ["Logs", summary.diagnosticsPath],
     ];
     for (const [name, text] of rows)
         process.stdout.write(`  ${name}  ${text}\n`);
     process.stdout.write(`\n  cohub runtime logs --space ${summary.spaceId} --follow\n  cohub runtime down --space ${summary.spaceId}\n`);
     if (!summary.background && !reused)
-        process.stdout.write("  Ctrl+C to stop / 按 Ctrl+C 停止\n");
+        process.stdout.write("  Ctrl+C to stop\n");
     process.stdout.write("\n");
 }

package/dist/runtime/process-group.d.ts

@@ -1,3 +1,5 @@
 export declare class ProcessCleanupUncertainError extends Error {
 }
+/** True only when the process group is gone or holds nothing that can execute. */
+export declare function confirmQuiescentProcessGroup(pid: number): Promise<boolean>;
 export declare function stopProcessGroup(pid: number): Promise<void>;

package/dist/runtime/process-group.js

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

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

@@ -7,7 +7,8 @@ export declare class ContextRequiredError extends Error {
 }
 export type RuntimeSessionStoreOptions = {
     stateRoot?: string;
-    archiveTransport?: ArchiveTransport;
+    /** Explicit, so a serve path can never silently lose archive uploads. */
+    archiveTransport: ArchiveTransport | null;
     projectionSource: SessionTurnProjectionClient;
 };
 export type NativeSession = {
@@ -61,11 +62,23 @@ export declare class RuntimeSessionStore {
     }>;
     started(state: NativeSession, turnId: string): Promise<void>;
     private resultPath;
-    recordResult(state: NativeSession, requestId: string, events: RuntimeExecutionEvent[]): Promise<void>;
+    recordResult(state: NativeSession, requestId: string | null, events: RuntimeExecutionEvent[], options?: {
+        uncertainCleanup?: {
+            processGroupId: number;
+            error: string;
+        };
+    }): Promise<void>;
     recoverResult(input: Pick<RuntimeTurnInput, "sessionId" | "harness" | "turnId">, requestId?: string): Promise<{
         state: NativeSession;
         events: RuntimeExecutionEvent[];
     } | null>;
+    /**
+     * Receipt-less recovery: the native file is the authority. When a Turn completed but no
+     * receipt survived (a crash between native completion and recordResult), rebuild the
+     * result from transcript bytes appended after the Turn started, without ever rewriting
+     * native data. Anything ambiguous stays unrecovered.
+     */
+    private reconstructResult;
     archive(state: NativeSession, turnId: string, diagnosticContext?: RuntimeDiagnosticContext): Promise<HarnessArchive | null>;
     acknowledge(state: NativeSession, turnId: string, revision: string): Promise<void>;
 }

package/dist/runtime/session-store.js

@@ -7,6 +7,8 @@ import { RuntimeArchiveStore, checksumNativeFile, atomicRuntimeJson as atomicJso
 import { importNativeArchive, readCodexArchiveTotals } from "./native-archive.js";
 import { serializeDiagnosticError } from "./diagnostics.js";
 import { ProjectionStore, rebindProjectionNativeSession } from "./projection-store.js";
+import { confirmQuiescentProcessGroup } from "./process-group.js";
+import { readNativeTranscript } from "./native-transcript.js";
 export class ContextRequiredError extends Error {
 }
 /** Reverse lookup for native clients; the existing Runtime state remains authoritative. */
@@ -35,7 +37,7 @@ export async function findRuntimeNativeSession(root, harness, nativeSessionId, p
             return exact[0] ?? null;
     }
     if (matches.length > 1)
-        throw new Error("Native Session has ambiguous Runtime bindings / 原生会话存在多个 Runtime 关联");
+        throw new Error("Native Session has ambiguous Runtime bindings");
     return matches[0] ?? null;
 }
 const checksum = (data) => createHash("sha256").update(data).digest("hex");
@@ -280,6 +282,9 @@ export class RuntimeSessionStore {
         return this.archiveFlush;
     }
     async flushArchiveOutbox(signal) {
+        if (!this.archives.hasTransport && await this.archives.pendingCount() > 0) {
+            this.diagnostics?.log("debug", "archive.transport_absent", { note: "captures stay local" }, { component: "archive" });
+        }
         const captures = join(this.archives.root, "captures");
         const names = await readdir(captures).catch((error) => { if (missing(error))
             return []; throw error; });
@@ -450,7 +455,7 @@ export class RuntimeSessionStore {
     }
     async started(state, turnId) { state.pendingTurnId = turnId; state.resultChecksum = undefined; await atomicJson(this.statePath(state), state); }
     resultPath(state) { return join(this.root, "results", `${state.sessionId}.${state.harness}.json`); }
-    async recordResult(state, requestId, events) {
+    async recordResult(state, requestId, events, options) {
         if (!state.pendingTurnId)
             throw new Error("Cannot record a result for an idle native session");
         if (state.harness === "pi")
@@ -458,7 +463,7 @@ export class RuntimeSessionStore {
         state.resultChecksum = await checksumNativeFile(state.path);
         if (state.archivePendingTurnId)
             await atomicJson(join(this.archives.root, "captures", `${state.archivePendingTurnId}.json`), state);
-        await atomicJson(this.resultPath(state), { requestId, state, events });
+        await atomicJson(this.resultPath(state), { requestId, state, events, ...(options?.uncertainCleanup ? { uncertainCleanup: options.uncertainCleanup } : {}) });
         await atomicJson(this.statePath(state), state);
     }
     async recoverResult(input, requestId) {
@@ -467,16 +472,85 @@ export class RuntimeSessionStore {
             if (saved.state.sessionId !== input.sessionId || saved.state.harness !== input.harness)
                 throw new Error("Runtime result identity mismatch");
             if (saved.state.pendingTurnId !== input.turnId)
-                return null;
-            if (requestId && saved.requestId !== requestId)
+                return this.reconstructResult(input);
+            if (requestId && saved.requestId != null && saved.requestId !== requestId)
                 throw new Error("Runtime result execution identity mismatch");
+            // A quiescent process group upgrades the receipt to confirmed; a live one stays uncertain.
+            if (saved.uncertainCleanup && !saved.uncertainCleanup.confirmedAt) {
+                if (!(await confirmQuiescentProcessGroup(saved.uncertainCleanup.processGroupId)))
+                    return null;
+                saved.uncertainCleanup.confirmedAt = new Date().toISOString();
+                await atomicJson(this.resultPath(input), saved);
+            }
             return { state: saved.state, events: saved.events.map((event) => runtimeEventSchema.parse(event)) };
         }
+        catch (error) {
+            if (missing(error))
+                return this.reconstructResult(input);
+            throw error;
+        }
+    }
+    /**
+     * Receipt-less recovery: the native file is the authority. When a Turn completed but no
+     * receipt survived (a crash between native completion and recordResult), rebuild the
+     * result from transcript bytes appended after the Turn started, without ever rewriting
+     * native data. Anything ambiguous stays unrecovered.
+     */
+    async reconstructResult(input) {
+        const statePath = this.statePath(input);
+        let state;
+        try {
+            state = JSON.parse(await readFile(statePath, "utf8"));
+        }
         catch (error) {
             if (missing(error))
                 return null;
             throw error;
         }
+        if (state.sessionId !== input.sessionId || state.harness !== input.harness || state.pendingTurnId !== input.turnId)
+            return null;
+        let transcript;
+        try {
+            transcript = await readNativeTranscript(state.path, state.harness, { settled: state.harness === "pi" });
+        }
+        catch {
+            return null;
+        }
+        // The Turn must start at the byte boundary the file had when the Turn began.
+        const boundary = state.checksum
+            ? [...transcript.prefixes].find(([, sha]) => sha === state.checksum)?.[0]
+            : 0;
+        if (boundary === undefined)
+            return null;
+        const turns = transcript.turns.filter((turn) => turn.startBytes >= boundary);
+        const completed = turns.length === 1 ? turns[0] : null;
+        const result = completed?.result ?? null;
+        // An interrupted Turn may still be executing in a surviving native process.
+        if (!completed || !result || result.status === "interrupted")
+            return null;
+        const messages = result.messages.filter((message) => message.content.length);
+        if (!messages.length)
+            return null;
+        const last = messages.at(-1);
+        const asRuntimeMessage = (message, ordinal) => ({
+            ordinal,
+            content: message.content,
+            ...(message.provider != null ? { provider: message.provider } : {}),
+            ...(message.model != null ? { model: message.model } : {}),
+            ...(message.usage != null ? { usage: message.usage } : {}),
+            ...(message.stopReason != null ? { stopReason: message.stopReason } : {}),
+            ...(message.errorMessage != null ? { errorMessage: message.errorMessage } : {}),
+        });
+        const events = messages.slice(0, -1).map((message, index) => ({ type: "message.commit", message: asRuntimeMessage(message, index + 1) }));
+        const archive = await this.archive(state, input.turnId, { component: "recovery", sessionId: input.sessionId, turnId: input.turnId, harness: input.harness }).catch(() => null);
+        const final = { type: "turn.end", message: asRuntimeMessage(last, messages.length), archive, resume: "native" };
+        await this.recordResult(state, null, [...events, final]);
+        this.diagnostics?.log("warn", "runtime.result_reconstructed", {
+            startBytes: completed.startBytes,
+            messageCount: messages.length,
+            status: result.status,
+        }, { component: "recovery", sessionId: input.sessionId, turnId: input.turnId, harness: input.harness });
+        return { state, events: [...events, final] };
     }
     async archive(state, turnId, diagnosticContext = {}) {
         if (!state.path)

package/dist/runtime/space-binding.js

@@ -292,7 +292,7 @@ export async function resolveRuntimeSpace(input) {
         }
         const existing = findRuntimeSpaceBinding(file, { root, key: bindingKey });
         if (input.newSpace && (existing?.spaceId ?? null) !== (input.expectedSpaceId ?? null)) {
-            throw new RuntimeSpaceBindingsError("Directory binding changed; run up again / 目录绑定已变化，请重新运行 up");
+            throw new RuntimeSpaceBindingsError("Directory binding changed; run up again");
         }
         if (existing && !input.newSpace) {
             await input.validateSpace?.(existing.spaceId);
@@ -304,7 +304,7 @@ export async function resolveRuntimeSpace(input) {
         try {
             receipt = JSON.parse(await readFile(receiptPath, "utf8"));
             if (!receipt || !nonEmptyString(receipt.operationId) || receipt.spaceId !== undefined && !nonEmptyString(receipt.spaceId)) {
-                throw new RuntimeSpaceBindingsError(`Invalid creation receipt; original retained / 创建回执无效，原始信息已保留: ${receiptPath}`);
+                throw new RuntimeSpaceBindingsError(`Invalid creation receipt; original retained: ${receiptPath}`);
             }
         }
         catch (error) {
@@ -312,7 +312,7 @@ export async function resolveRuntimeSpace(input) {
                 throw error;
         }
         if (receipt && !receipt.spaceId)
-            throw new RuntimeSpaceBindingsError(`A previous Space creation has an unknown outcome. Check your Spaces and use --space <id> / 上次创建结果未知，请检查 Space 后使用 --space <id>。${receiptPath}`);
+            throw new RuntimeSpaceBindingsError(`A previous Space creation has an unknown outcome. Check your Spaces and use --space <id>. ${receiptPath}`);
         if (!receipt) {
             receipt = { operationId: randomUUID() };
             await writeRuntimeJson(receiptPath, receipt);

package/dist/runtime/supervisor.js

@@ -29,7 +29,7 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
     process.once("SIGTERM", stop);
     const client = createClient();
     const space = client.space(config.spaceId);
-    const store = new RuntimeSessionStore(config.spaceId, { projectionSource: space });
+    const store = new RuntimeSessionStore(config.spaceId, { projectionSource: space, archiveTransport: space });
     const consoleSink = config.background ? undefined : createDiagnosticConsole(config.verbose);
     const diagnostics = new RuntimeDiagnostics({
         root: store.root, spaceId: config.spaceId, runtimeId: randomUUID(),
@@ -67,12 +67,12 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
     const token = (forceRefresh = false) => {
         tokenInFlight ??= (async () => {
             if (currentIdentityKey() !== config.identity)
-                throw new AuthRequiredError("Runtime account changed; sign in to the original account / Runtime 账号已变化，请登录原账号");
+                throw new AuthRequiredError("Runtime account changed; sign in to the original account");
             const value = await resolveAccessToken({ forceRefresh });
             if (!value)
                 throw new AuthRequiredError();
             if (currentIdentityKey() !== config.identity)
-                throw new AuthRequiredError("Runtime account changed / Runtime 账号已变化");
+                throw new AuthRequiredError("Runtime account changed");
             return value;
         })().finally(() => { tokenInFlight = null; });
         return tokenInFlight;
@@ -82,7 +82,7 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
             if (!force)
                 for await (const batch of store.pendingExecutionBatches()) {
                     if (batch.length)
-                        throw new Error("Unconfirmed executions remain. Use down --yes to stop; results and files are retained / 尚有未确认执行，使用 down --yes 停止；结果和文件会保留");
+                        throw new Error("Unconfirmed executions remain. Use down --yes to stop; results and files are retained");
                 }
             update({ state: "stopping" });
             setTimeout(stop, 30);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "8.0.0",
+  "version": "8.0.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {