@neta-art/cohub-cli 8.0.0 → 8.1.0

package/dist/runtime/native-sync-store.js

@@ -54,7 +54,7 @@ export class NativeSyncStore {
     async binding() {
         const value = await readJson(this.bindingPath());
         if (value?.version !== 1 || value.identity !== this.options.identity || value.spaceId !== this.options.spaceId || value.nativeSessionId !== this.options.nativeSessionId || value.instanceKey !== this.options.instanceKey || value.harness !== this.options.harness)
-            throw new Error("Native binding mismatch / 原生关联不匹配");
+            throw new Error("Native binding mismatch");
         return value;
     }
     async initialize(path, transcript) {
@@ -62,7 +62,7 @@ export class NativeSyncStore {
         if (existing) {
             const binding = await this.binding();
             if (binding.path !== path)
-                throw new Error("Native path changed; original binding retained / 原生路径已变化，原关联已保留");
+                throw new Error("Native path changed; original binding retained");
             return binding;
         }
         const managed = await findRuntimeNativeSession(this.options.runtimeRoot, this.options.harness, transcript.nativeSessionId, path);
@@ -70,7 +70,7 @@ export class NativeSyncStore {
         const anchors = [];
         if (managed) {
             if (managed.pendingTurnId)
-                throw new Error("Reconcile the managed Turn before native continuation / 请先确认 Runtime 中尚未确认的 Turn");
+                throw new Error("Reconcile the managed Turn before native continuation");
             if (managed.throughTurnId) {
                 const index = await readJson(join(this.options.runtimeRoot, "archives", "versions", `${managed.throughTurnId}.json`));
                 if (index) {
@@ -79,7 +79,7 @@ export class NativeSyncStore {
                     for await (const bytes of createReadStream(path, { end: parsed.sizeBytes - 1 }))
                         checksum.update(bytes);
                     if (checksum.digest("hex") !== parsed.sha256)
-                        throw new Error("Runtime history prefix changed / Runtime 历史前缀已变化");
+                        throw new Error("Runtime history prefix changed");
                     throughBytes = parsed.sizeBytes;
                 }
                 else {
@@ -87,7 +87,7 @@ export class NativeSyncStore {
                     for await (const bytes of createReadStream(path))
                         checksum.update(bytes);
                     if (checksum.digest("hex") !== managed.checksum)
-                        throw new Error("Cannot identify the last complete Runtime Turn / 无法识别 Runtime 最后一个完整 Turn");
+                        throw new Error("Cannot identify the last complete Runtime Turn");
                     throughBytes = (await stat(path)).size;
                     anchors.push({ turnId: managed.throughTurnId, sizeBytes: throughBytes, sha256: managed.checksum });
                 }
@@ -112,15 +112,15 @@ export class NativeSyncStore {
         await atomicRuntimeJson(this.bindingPath(), binding);
         return binding;
     }
-    async capture(path, transcript) {
+    async capture(path, transcript, context = {}) {
         if (transcript.nativeSessionId !== this.options.nativeSessionId)
-            throw new Error("Native session identity mismatch / 原生会话身份不匹配");
+            throw new Error("Native session identity mismatch");
         await withRuntimeSpaceBindingsLock(async () => {
             const binding = await this.initialize(path, transcript);
             if (binding.throughBytes > 0) {
                 const anchor = binding.anchors.find((entry) => entry.sizeBytes === binding.throughBytes);
                 if (!anchor || transcript.prefixes.get(binding.throughBytes) !== anchor.sha256)
-                    throw new Error("Runtime history prefix changed; original binding retained / Runtime 历史前缀已变化，原关联已保留");
+                    throw new Error("Runtime history prefix changed; original binding retained");
             }
             let parentKey = null;
             let parentCloudTurnId = binding.throughTurnId;
@@ -130,7 +130,7 @@ export class NativeSyncStore {
                     // Native offsets only validate whole-Turn archive checkpoints; they never become cloud fork anchors.
                     const matches = (binding.anchors ?? []).filter((anchor) => anchor.sizeBytes >= turn.contentEndBytes && turn.boundaries[anchor.sizeBytes] === anchor.sha256);
                     if (new Set(matches.map((anchor) => anchor.turnId)).size > 1)
-                        throw new Error("Ambiguous Runtime Turn boundary / Runtime Turn 边界不明确");
+                        throw new Error("Ambiguous Runtime Turn boundary");
                     parentCloudTurnId = matches[0]?.turnId ?? null;
                     knownBoundary = matches.length > 0;
                     parentKey = null;
@@ -143,12 +143,12 @@ export class NativeSyncStore {
                     continue;
                 }
                 if (!parentKey && !knownBoundary)
-                    throw new Error("Native continuation is not at a complete Runtime Turn boundary / 原生续聊不在完整 Runtime Turn 边界上");
+                    throw new Error("Native continuation is not at a complete Runtime Turn boundary");
                 const turnId = this.turnId(turn.key);
                 const old = await readJson(this.receiptPath(turnId));
                 if (old?.result) {
                     if (turn.contentEndBytes < (old.contentEndBytes ?? old.endBytes) || JSON.stringify(turn.userContent) !== JSON.stringify(old.userContent) || turn.result && JSON.stringify(nativeTurnCompleteSchema.parse(turn.result)) !== JSON.stringify(old.result)) {
-                        throw new Error("Native branch is inside a settled Turn; only whole-Turn forks are supported / 原生分支位于已结束的 Turn 内，仅支持完整 Turn 分支");
+                        throw new Error("Native branch is inside a settled Turn; only whole-Turn forks are supported");
                     }
                     parentKey = turn.key;
                     continue;
@@ -156,9 +156,11 @@ export class NativeSyncStore {
                 const result = turn.result ? nativeTurnCompleteSchema.parse(turn.result) : null;
                 const receipt = { version: 1, turnId, key: turn.key, parentKey, parentCloudTurnId: parentKey ? null : parentCloudTurnId,
                     userContent: turn.userContent, startedAt: turn.startedAt, endBytes: turn.endBytes, contentEndBytes: turn.contentEndBytes, result,
+                    ...(context.sessionStartedAt ? { sessionStartedAt: context.sessionStartedAt } : {}),
+                    ...(context.origin ? { origin: context.origin } : {}),
                     ...(!result ? { progress: nativeTurnProgressSchema.parse({ revision: turn.endBytes, messages: turn.messages }) } : {}) };
                 if (old && (JSON.stringify(old.userContent) !== JSON.stringify(receipt.userContent) || old.parentKey !== receipt.parentKey))
-                    throw new Error("Native Turn changed; original receipt retained / 原生 Turn 已变化，原回执已保留");
+                    throw new Error("Native Turn changed; original receipt retained");
                 // Capture immutable native bytes before publishing the completed receipt. Subsequent Turns may change the source.
                 if (result)
                     await this.archives.stage({ sessionId: binding.originSessionId, harness: binding.harness, nativeSessionId: binding.nativeSessionId, path, sizeBytes: turn.endBytes, expectedChecksum: turn.sha256 }, turnId);
@@ -186,7 +188,7 @@ export class NativeSyncStore {
                 continue;
             }
             if (receipt?.version !== 1 || receipt.turnId !== this.turnId(receipt.key))
-                throw new Error("Native receipt is corrupt; original retained / 原生回执损坏，原件已保留");
+                throw new Error("Native receipt is corrupt; original retained");
             receipts.push(receipt);
         }
         return receipts.sort((a, b) => a.endBytes - b.endBytes || a.turnId.localeCompare(b.turnId));
@@ -233,21 +235,22 @@ export class NativeSyncStore {
                         parent = await readJson(this.acknowledgementPath(parentId));
                     }
                     if (!parent)
-                        throw new Error("Parent binding is missing / 父 Turn 关联缺失");
+                        throw new Error("Parent binding is missing");
                 }
                 let request = await readJson(this.requestPath(receipt.turnId));
                 if (!request) {
                     request = nativeTurnStartSchema.parse({ turnId: receipt.turnId, sessionId: parent?.sessionId ?? binding.sessionId, parentTurnId: parent?.turnId ?? receipt.parentCloudTurnId,
-                        branchSessionId: nativeStableId(`${receipt.turnId}:branch`), harness: binding.harness, nativeSessionId: binding.nativeSessionId, userContent: receipt.userContent, startedAt: receipt.startedAt });
+                        branchSessionId: nativeStableId(`${receipt.turnId}:branch`), harness: binding.harness, nativeSessionId: binding.nativeSessionId, userContent: receipt.userContent, startedAt: receipt.startedAt,
+                        ...(receipt.sessionStartedAt ? { sessionStartedAt: receipt.sessionStartedAt } : {}), ...(receipt.origin ? { origin: receipt.origin } : {}) });
                     await atomicRuntimeJson(this.requestPath(receipt.turnId), request);
                 }
                 let remote = await readJson(this.cloudBindingPath(receipt.turnId));
                 if (!remote) {
                     if (!transport.startNativeTurn)
-                        throw new Error("Native Runtime WS is unavailable / 原生 Runtime WS 不可用");
+                        throw new Error("Native Runtime WS is unavailable");
                     remote = await transport.startNativeTurn(request, { signal });
                     if (remote.turnId !== receipt.turnId)
-                        throw new Error("Server Turn identity mismatch / 服务端 Turn 身份不匹配");
+                        throw new Error("Server Turn identity mismatch");
                     await atomicRuntimeJson(this.cloudBindingPath(receipt.turnId), remote);
                 }
                 if (!receipt.result) {
@@ -267,7 +270,7 @@ export class NativeSyncStore {
                     return false;
                 }
                 if (!transport.completeNativeTurn)
-                    throw new Error("Native Runtime WS is unavailable / 原生 Runtime WS 不可用");
+                    throw new Error("Native Runtime WS is unavailable");
                 // Artifact retries back off: the terminal state is durable, so hammering the completion
                 // endpoint every flush cycle (5s) while object storage is down only adds load.
                 const backoffPath = join(this.root, "backoff", `${receipt.turnId}.json`);
@@ -279,7 +282,7 @@ export class NativeSyncStore {
                     // Terminal state is durable; only the artifact snapshot is missing. Keep the receipt pending
                     // and retry on the next flush cycle (>= 30s) until artifacts persist.
                     await atomicRuntimeJson(backoffPath, { at: Date.now() });
-                    throw new Error("Native artifacts are pending; completion replays later / 原生产物待生成，稍后重放完成请求");
+                    throw new Error("Native artifacts are pending; completion replays later");
                 }
                 await rm(backoffPath, { force: true });
                 await atomicRuntimeJson(this.acknowledgementPath(receipt.turnId), remote);
@@ -327,7 +330,7 @@ export class NativeSyncStore {
     async cloudArchive(index) {
         const binding = await readJson(this.acknowledgementPath(index.turnId));
         if (!binding)
-            throw new Error("Native Turn result is not confirmed / 原生 Turn 结果尚未确认");
+            throw new Error("Native Turn result is not confirmed");
         if (index.parentTurnId) {
             const parent = await readJson(this.acknowledgementPath(index.parentTurnId));
             if (parent?.sessionId === binding.sessionId)
@@ -338,7 +341,7 @@ export class NativeSyncStore {
             let parentId = index.parentTurnId;
             while (parentId) {
                 if (visited.has(parentId))
-                    throw new Error("Cyclic native archive / 原生归档存在循环");
+                    throw new Error("Cyclic native archive");
                 visited.add(parentId);
                 const previous = harnessArchiveIndexSchema.parse(await readJson(join(this.archives.root, "versions", `${parentId}.json`)));
                 segments.unshift(...previous.segments);

package/dist/runtime/native-sync.d.ts

@@ -9,6 +9,29 @@ export type NativeSyncConfig = {
 };
 export declare const nativeRuntimeRoot: (spaceId: string) => string;
 export declare const nativeSyncConfigPath: (runtimeRoot: string, identity: string) => string;
+export type NativeImportCandidate = {
+    harness: "pi" | "codex";
+    path: string;
+    nativeSessionId: string;
+    turnCount: number;
+    sessionStartedAt: string | undefined;
+};
+/** Find existing native transcripts for exactly one bound project. */
+export declare function discoverNativeImportCandidates(root: string, harnesses: ("pi" | "codex")[], options?: {
+    signal?: AbortSignal;
+    onProgress?: (progress: {
+        harness: "pi" | "codex";
+        scanned: number;
+        candidates: number;
+    }) => void;
+}): Promise<{
+    candidates: NativeImportCandidate[];
+    errors: {
+        harness: "pi" | "codex";
+        path: string;
+        message: string;
+    }[];
+}>;
 export declare function nativeArchiveTransport(spaceId: string, identity: string): Pick<NativeSyncTransport, "prepareRuntimeArchive" | "commitRuntimeArchive" | "getRuntimeArchive">;
 export declare function readNativeSyncConfig(runtimeRoot: string, identity: string): Promise<NativeSyncConfig | null>;
 /** Local capture only. Neither Pi callbacks nor Codex hooks wait for Cohub's network. */
@@ -19,6 +42,8 @@ export declare function captureNativeSession(input: {
     nativeSessionId?: string;
     settled?: boolean;
     leafId?: string | null;
+    sessionStartedAt?: string;
+    origin?: "local_import";
 }): Promise<NativeSyncStore | null>;
 /** The existing Runtime supervisor retries receipts even after the original terminal has exited. */
 export declare function nativeWebSocketTransport(spaceId: string, identity: string, send: (event: NativeRuntimeEvent) => Promise<unknown>): NativeSyncTransport;

package/dist/runtime/native-sync.js

@@ -1,22 +1,103 @@
-import { readFile } from "node:fs/promises";
+import { readFile, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createClient } from "../client.js";
 import { currentIdentityKey } from "../space.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding } from "./space-binding.js";
-import { readNativeTranscript } from "./native-transcript.js";
+import { readNativeTranscript, readNativeTranscriptHeader } from "./native-transcript.js";
 import { findRuntimeNativeSession } from "./session-store.js";
 import { listNativeSyncStores, nativeIdentityHash, NativeSyncStore } from "./native-sync-store.js";
 export const nativeRuntimeRoot = (spaceId) => join(homedir(), ".local", "state", "cohub", "runtime", spaceId);
 export const nativeSyncConfigPath = (runtimeRoot, identity) => join(runtimeRoot, "native", nativeIdentityHash(identity), "config.json");
+const piSessionDirectory = (cwd) => {
+    const custom = process.env.PI_CODING_AGENT_SESSION_DIR?.trim();
+    if (custom)
+        return custom;
+    const agentDir = process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
+    const safePath = `--${cwd.replace(/^[/\\\\]/, "").replace(/[/\\\\:]/g, "-")}--`;
+    return join(agentDir, "sessions", safePath);
+};
+const codexSessionDirectory = () => join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "sessions");
+const LARGE_TRANSCRIPT_BYTES = 64 * 1024 * 1024;
+async function nativeTranscriptPaths(root, harness, signal) {
+    const pending = [harness === "pi" ? piSessionDirectory(root) : codexSessionDirectory()];
+    const paths = [];
+    const errors = [];
+    while (pending.length) {
+        signal?.throwIfAborted();
+        const directory = pending.pop();
+        if (!directory)
+            continue;
+        const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+            if (error.code === "ENOENT")
+                return [];
+            errors.push({ harness, path: directory, message: error instanceof Error ? error.message : String(error) });
+            return [];
+        });
+        for (const entry of entries) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory())
+                pending.push(path);
+            else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+                paths.push(path);
+        }
+    }
+    return { paths, errors };
+}
+/** Find existing native transcripts for exactly one bound project. */
+export async function discoverNativeImportCandidates(root, harnesses, options = {}) {
+    const candidates = [];
+    const errors = [];
+    for (const harness of harnesses) {
+        options.signal?.throwIfAborted();
+        const scanned = await nativeTranscriptPaths(root, harness, options.signal);
+        errors.push(...scanned.errors);
+        let start = 0;
+        while (start < scanned.paths.length) {
+            options.signal?.throwIfAborted();
+            const paths = scanned.paths.slice(start, start + 2);
+            const sizes = await Promise.all(paths.map((path) => stat(path).then((value) => value.size).catch(() => 0)));
+            const concurrency = sizes.some((size) => size > LARGE_TRANSCRIPT_BYTES) ? 1 : 2;
+            const batch = await Promise.all(paths.slice(0, concurrency).map(async (path) => {
+                try {
+                    const header = await readNativeTranscriptHeader(path, harness, options.signal);
+                    if (await canonicalRuntimeRoot(header.cwd) !== root)
+                        return null;
+                    const transcript = await readNativeTranscript(path, harness, { settled: true, signal: options.signal });
+                    if (transcript.turns.length === 0)
+                        return { error: { harness, path, message: "Transcript contains no importable Turns" } };
+                    return { harness, path, nativeSessionId: transcript.nativeSessionId, turnCount: transcript.turns.length,
+                        sessionStartedAt: transcript.turns.map((turn) => turn.startedAt).sort()[0] };
+                }
+                catch (error) {
+                    return { error: { harness, path, message: error instanceof Error ? error.message : String(error) } };
+                }
+            }));
+            for (const result of batch) {
+                options.signal?.throwIfAborted();
+                if (!result)
+                    continue;
+                if ("error" in result) {
+                    if (result.error)
+                        errors.push(result.error);
+                }
+                else
+                    candidates.push(result);
+                options.onProgress?.({ harness, scanned: start + batch.length, candidates: candidates.length });
+            }
+            start += concurrency;
+        }
+    }
+    return { candidates, errors };
+}
 export function nativeArchiveTransport(spaceId, identity) {
     const client = createClient().space(spaceId);
     const guard = async (task) => {
         if (currentIdentityKey() !== identity)
-            throw new Error("Native sync account changed / 原生同步账号已变化");
+            throw new Error("Native sync account changed");
         const result = await task();
         if (currentIdentityKey() !== identity)
-            throw new Error("Native sync account changed / 原生同步账号已变化");
+            throw new Error("Native sync account changed");
         return result;
     };
     return {
@@ -29,7 +110,7 @@ export async function readNativeSyncConfig(runtimeRoot, identity) {
     try {
         const config = JSON.parse(await readFile(nativeSyncConfigPath(runtimeRoot, identity), "utf8"));
         if (config.version !== 1 || config.identity !== identity || !Array.isArray(config.harnesses))
-            throw new Error("Invalid native sync configuration / 原生同步配置无效");
+            throw new Error("Invalid native sync configuration");
         return config;
     }
     catch (error) {
@@ -57,7 +138,7 @@ export async function captureNativeSession(input) {
     const path = await canonicalRuntimeRoot(input.path);
     const transcript = await readNativeTranscript(path, input.harness, input);
     if (await canonicalRuntimeRoot(transcript.cwd) !== root || input.nativeSessionId && transcript.nativeSessionId !== input.nativeSessionId)
-        throw new Error("Native transcript belongs to another project or Session / 原生记录属于其他项目或会话");
+        throw new Error("Native transcript belongs to another project or Session");
     const key = JSON.stringify([identity, space.spaceId, input.harness, transcript.nativeSessionId, path]);
     let store = nativeStores.get(key);
     if (!store) {
@@ -74,7 +155,7 @@ export async function captureNativeSession(input) {
             const managedPath = managed ? await canonicalRuntimeRoot(managed.path).catch((error) => { if (error.code === "ENOENT")
                 return null; throw error; }) : null;
             if (candidates.length && managedPath !== path)
-                throw new Error("Native path changed; original bindings retained / 原生路径已变化，原关联已保留");
+                throw new Error("Native path changed; original bindings retained");
             // Restored Pi working copies can share a native ID. Existing Cohub sidecars disambiguate them.
             store = new NativeSyncStore({ runtimeRoot, spaceId: space.spaceId, identity, harness: input.harness, nativeSessionId: transcript.nativeSessionId,
                 instanceKey: managedPath === path ? path : undefined, transport });
@@ -83,7 +164,7 @@ export async function captureNativeSession(input) {
             nativeStores.delete(nativeStores.keys().next().value ?? "");
         nativeStores.set(key, store);
     }
-    await store.capture(path, transcript);
+    await store.capture(path, transcript, { sessionStartedAt: input.sessionStartedAt, origin: input.origin });
     return store;
 }
 /** The existing Runtime supervisor retries receipts even after the original terminal has exited. */

package/dist/runtime/native-transcript.d.ts

@@ -20,8 +20,16 @@ export type NativeTranscript = {
     turns: NativeTranscriptTurn[];
     prefixes: ReadonlyMap<number, string>;
 };
+export declare const NATIVE_MAX_RECORD_BYTES: number;
+export declare const NATIVE_MAX_TRANSCRIPT_BYTES: number;
+/** Read only the session header before deciding whether a global Codex file belongs to this project. */
+export declare function readNativeTranscriptHeader(path: string, harness: "pi" | "codex", signal?: AbortSignal): Promise<{
+    nativeSessionId: string;
+    cwd: string;
+}>;
 /** Partial trailing records are retried, never parsed or acknowledged as complete. */
 export declare function readNativeTranscript(path: string, harness: "pi" | "codex", options?: {
     settled?: boolean;
     leafId?: string | null;
+    signal?: AbortSignal;
 }): Promise<NativeTranscript>;

package/dist/runtime/native-transcript.js

@@ -8,9 +8,38 @@ const list = (value) => Array.isArray(value) ? value : [];
 const iso = (value) => {
     const date = new Date(typeof value === "number" || typeof value === "string" ? value : 0);
     if (!Number.isFinite(date.getTime()))
-        throw new Error("Invalid native timestamp / 原生时间无效");
+        throw new Error("Invalid native timestamp");
     return date.toISOString();
 };
+export const NATIVE_MAX_RECORD_BYTES = 256 * 1024 * 1024;
+export const NATIVE_MAX_TRANSCRIPT_BYTES = 1024 * 1024 * 1024;
+const NATIVE_HEADER_MAX_BYTES = 1024 * 1024;
+/** Read only the session header before deciding whether a global Codex file belongs to this project. */
+export async function readNativeTranscriptHeader(path, harness, signal) {
+    const stream = createReadStream(path, { signal });
+    let buffer = Buffer.alloc(0);
+    try {
+        for await (const chunk of stream) {
+            buffer = Buffer.concat([buffer, chunk]);
+            const newline = buffer.indexOf(10);
+            if (newline >= 0) {
+                const value = record(JSON.parse(buffer.subarray(0, newline).toString("utf8")));
+                const payload = record(value.payload);
+                const nativeSessionId = harness === "pi" ? text(value.id) : text(payload.id);
+                const cwd = harness === "pi" ? text(value.cwd) : text(payload.cwd);
+                if ((harness === "pi" && value.type !== "session") || (harness === "codex" && value.type !== "session_meta") || !nativeSessionId || !cwd)
+                    throw new Error("Invalid native session header");
+                return { nativeSessionId, cwd };
+            }
+            if (buffer.length > NATIVE_HEADER_MAX_BYTES)
+                throw new Error("Native session header is too large");
+        }
+        throw new Error("Native transcript is empty");
+    }
+    finally {
+        stream.destroy();
+    }
+}
 /** Partial trailing records are retried, never parsed or acknowledged as complete. */
 export async function readNativeTranscript(path, harness, options = {}) {
     const lines = [];
@@ -23,12 +52,12 @@ export async function readNativeTranscript(path, harness, options = {}) {
         fragments.push(bytes);
         pendingBytes += bytes.length;
         checksum.update(bytes);
-        if (pendingBytes > 32 * 1024 * 1024)
-            throw new Error("Native record is too large / 原生记录过大");
-        if (offset + pendingBytes > 128 * 1024 * 1024)
-            throw new Error("Native transcript exceeds the capture limit; original retained / 原生记录超出采集上限，原件已保留");
+        if (pendingBytes > NATIVE_MAX_RECORD_BYTES)
+            throw new Error("Native record exceeds the 256 MiB local parse limit; original retained");
+        if (offset + pendingBytes > NATIVE_MAX_TRANSCRIPT_BYTES)
+            throw new Error("Native transcript exceeds the 1 GiB local parse limit; original retained");
     };
-    for await (const chunk of createReadStream(path)) {
+    for await (const chunk of createReadStream(path, { signal: options.signal })) {
         let start = 0;
         for (let end = chunk.indexOf(10); end >= 0; end = chunk.indexOf(10, start)) {
             append(chunk.subarray(start, end + 1));
@@ -47,7 +76,7 @@ export async function readNativeTranscript(path, harness, options = {}) {
                     value = record(JSON.parse(line.toString("utf8")));
                 }
                 catch {
-                    throw new Error("Invalid native JSON record; original retained / 原生 JSON 记录无效，原件已保留");
+                    throw new Error("Invalid native JSON record; original retained");
                 }
                 lines.push({ value, startBytes, endBytes: offset, sha256 });
             }
@@ -56,24 +85,24 @@ export async function readNativeTranscript(path, harness, options = {}) {
         append(chunk.subarray(start));
     }
     if (!lines.length)
-        throw new Error("Native transcript is empty / 原生记录为空");
+        throw new Error("Native transcript is empty");
     return { ...(harness === "pi" ? parsePiTranscript(lines, options) : parseCodexTranscript(lines)), prefixes };
 }
 function parsePiTranscript(lines, options) {
     const header = lines[0]?.value ?? {};
     if (header.type !== "session" || !text(header.id))
-        throw new Error("Invalid Pi session / Pi 会话无效");
+        throw new Error("Invalid Pi session");
     const entries = new Map(lines.slice(1).filter((line) => text(line.value.id)).map((line) => [text(line.value.id), line]));
     const branch = [];
     let leaf = options.leafId ?? (lines.length > 1 ? text(lines.at(-1)?.value.id) : "");
     const visited = new Set();
     while (leaf) {
         if (visited.has(leaf))
-            throw new Error("Cyclic Pi history / Pi 历史存在循环");
+            throw new Error("Cyclic Pi history");
         visited.add(leaf);
         const entry = entries.get(leaf);
         if (!entry)
-            throw new Error("Pi parent history is missing / Pi 父历史缺失");
+            throw new Error("Pi parent history is missing");
         branch.push(entry);
         leaf = text(entry.value.parentId);
     }
@@ -128,7 +157,7 @@ function parsePiTranscript(lines, options) {
         else if (current && message.role === "toolResult") {
             const assistant = messages.at(-1);
             if (!assistant)
-                throw new Error("Pi tool result has no assistant Turn / Pi 工具结果缺少所属 Turn");
+                throw new Error("Pi tool result has no assistant Turn");
             assistant.content.push({ type: "tool_result", tool_use_id: text(message.toolCallId), content: typeof message.content === "string" ? message.content : piContent(message.content), is_error: Boolean(message.isError) });
         }
         if (current) {
@@ -158,9 +187,9 @@ function parseCodexTranscript(lines) {
     const header = lines[0]?.value ?? {};
     const metadata = record(header.payload);
     if (header.type !== "session_meta" || !text(metadata.id))
-        throw new Error("Invalid Codex session / Codex 会话无效");
+        throw new Error("Invalid Codex session");
     if (metadata.history_base || metadata.fork_source)
-        throw new Error("Codex history references another rollout; retain the original and materialize its full history first / Codex 历史引用其他记录，请保留原件并先导出完整历史");
+        throw new Error("Codex history references another rollout; retain the original and materialize its full history first");
     const turns = [];
     let current = null;
     let messages = [];
@@ -188,7 +217,7 @@ function parseCodexTranscript(lines) {
                 turns.push(current);
             current = { key: text(payload.turn_id), parentKey: turns.at(-1)?.key ?? null, userContent: [], messages: [], startedAt: iso(entry.timestamp), startBytes: line.startBytes, endBytes: line.endBytes, contentEndBytes: line.endBytes, boundaries: {}, sha256: line.sha256, result: null };
             if (!current.key)
-                throw new Error("Codex Turn identity is missing / Codex Turn 身份缺失");
+                throw new Error("Codex Turn identity is missing");
             messages = current.messages;
             userFromResponse = false;
         }
@@ -255,7 +284,7 @@ function parseCodexTranscript(lines) {
         }
         if (entry.type === "event_msg" && ["turn_complete", "task_complete", "turn_aborted"].includes(text(payload.type))) {
             if (payload.turn_id && payload.turn_id !== current.key)
-                throw new Error("Codex Turn boundary mismatch / Codex Turn 边界不匹配");
+                throw new Error("Codex Turn boundary mismatch");
             if (!messages.length && text(payload.last_agent_message))
                 messages.push({ content: [{ type: "text", text: text(payload.last_agent_message) }], model, provider });
             const errorMessage = text(record(payload.error).message);

package/dist/runtime/presentation.d.ts

@@ -1,3 +1,4 @@
+import type { NativeSyncConfig } from "./native-sync.js";
 import type { RuntimeDiagnostic, RuntimeDiagnosticLevel } from "./diagnostics.js";
 export declare const diagnosticLevels: RuntimeDiagnosticLevel[];
 export declare const atLeastLevel: (level: RuntimeDiagnosticLevel, minimum: RuntimeDiagnosticLevel) => boolean;
@@ -16,6 +17,14 @@ export type RuntimeSummary = {
     workspaceConnected: boolean;
     diagnosticsPath: string;
     background: boolean;
-    nativeSync?: boolean;
 };
 export declare function printRuntimeSummary(summary: RuntimeSummary, json?: boolean, reused?: boolean): void;
+export type NativeSessionStatus = {
+    harness: "pi" | "codex";
+    nativeSessionId: string;
+    sessionId: string | null;
+    pendingTurns: number;
+    pendingArchives: number;
+};
+/** `runtime status` native sync block: installation state plus per-Harness pending work. */
+export declare function formatNativeSync(config: NativeSyncConfig | null, sessions: NativeSessionStatus[], error?: string | null): string;

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,37 @@ 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");
 }
+/** `runtime status` native sync block: installation state plus per-Harness pending work. */
+export function formatNativeSync(config, sessions, error = null) {
+    if (error)
+        return `Native sync  unknown — ${error} · fix or remove the config, then runtime up\n`;
+    if (!config?.harnesses.length)
+        return "Native sync  off · run cohub runtime up to enable\n";
+    const lines = [`Native sync  enabled · ${config.harnesses.join(", ")}`];
+    for (const session of sessions) {
+        lines.push(`  ${session.harness.padEnd(5)} ${session.nativeSessionId.slice(0, 8)}  ${session.pendingTurns} Turns · ${session.pendingArchives} archives pending`);
+    }
+    if (!sessions.length)
+        lines.push("  No native chats captured yet");
+    else if (sessions.every((session) => !session.pendingTurns && !session.pendingArchives))
+        lines.push("  Up to date");
+    return `${lines.join("\n")}\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>;