@neta-art/cohub-cli 8.0.0 → 8.1.0

package/dist/runtime/diagnostics.js

@@ -21,6 +21,12 @@ function isRecord(value) {
 function redactUrl(value) {
     try {
         const url = new URL(value);
+        // Redaction must not rewrite the string when there is nothing to hide;
+        // URL.toString() re-encodes (e.g. quotes from wrapped log lines) and
+        // makes healthy URLs look corrupted.
+        const sensitive = [...url.searchParams.keys()].some((key) => SENSITIVE_KEY.test(key));
+        if (!sensitive)
+            return value;
         for (const key of [...url.searchParams.keys()]) {
             if (SENSITIVE_KEY.test(key))
                 url.searchParams.set(key, "[REDACTED]");
@@ -37,7 +43,8 @@ export function redactDiagnosticString(value) {
         : value;
     return shortened
         .replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [REDACTED]")
-        .replace(/\b(rediss?|https?|wss?):\/\/[^\s]+/gi, (url) => redactUrl(url))
+        // Trailing quotes/brackets from wrapped log lines are not part of the URL.
+        .replace(/\b(rediss?|https?|wss?):\/\/[^\s"'<>]+/gi, (url) => redactUrl(url))
         .replace(/\b(authorization|password|secret|token|access[_-]?key|refresh[_-]?token)([\s:=]+)([^\s,;]+)/gi, "$1$2[REDACTED]");
 }
 function redactValue(value, seen = new WeakSet(), depth = 0) {

package/dist/runtime/harness.d.ts

@@ -14,6 +14,10 @@ export type HarnessResult = {
     event: Extract<RuntimeExecutionEvent, {
         type: "turn.end";
     }>;
+    uncertainCleanup?: {
+        processGroupId: number;
+        error: string;
+    };
 };
 export declare function piContent(value: unknown): ContentBlock[];
 export declare function promptText(content: ContentBlock[]): string;

package/dist/runtime/harness.js

@@ -2,6 +2,7 @@ import { access, stat } from "node:fs/promises";
 import { constants } from "node:fs";
 import { delimiter, join, resolve, win32 } from "node:path";
 import { JsonRpcProcess, record } from "./json-rpc.js";
+import { ProcessCleanupUncertainError } from "./process-group.js";
 import { codexModelCatalog } from "./model-catalog.js";
 import { codexTokenTotals, codexUsage, subtractCodexTokens } from "./codex-usage.js";
 import { downloadPublicImage } from "../safe-remote-image.js";
@@ -85,6 +86,16 @@ async function finishHarnessTurn(store, state, message, resume, turnId, diagnost
     const archive = await store.archive(state, turnId, diagnosticContext).catch(() => null);
     return { state, event: { type: "turn.end", message, resume, archive } };
 }
+/** Close the RPC process. An unconfirmable cleanup degrades the result to uncertain, never masks it. */
+async function closeHarness(rpc, executionError) {
+    return rpc.close().then(() => undefined, (cleanupError) => {
+        const processGroupId = rpc.processGroupId;
+        if (!(cleanupError instanceof ProcessCleanupUncertainError) || processGroupId == null)
+            throw cleanupError;
+        const detail = executionError ? `; execution error: ${executionError}` : "";
+        return { processGroupId, error: `${cleanupError.message}${detail}` };
+    });
+}
 export async function discoverHarnesses(harnesses, options, cwd) {
     const models = [];
     await Promise.all(harnesses.map(async (harness) => {
@@ -133,6 +144,7 @@ export async function executePi(input, options, cwd, store, emit, signal, diagno
     let currentContent = [];
     let last = { ordinal: 0, content: [] };
     const abortEscalation = createAbortEscalation(rpc, signal, () => { void rpc.request("abort").catch(() => undefined); });
+    let uncertainCleanup;
     const stopFailureLogging = diagnostics
         ? rpc.onFailure((error) => diagnostics.log("error", "harness.rpc_process_failed", { error: serializeDiagnosticError(error) }, { ...diagnosticContext, component: "harness" }))
         : () => undefined;
@@ -235,17 +247,17 @@ export async function executePi(input, options, cwd, store, emit, signal, diagno
         abortEscalation.clear();
         stopFailureLogging();
         stopTimeoutLogging();
-        await rpc.close();
+        uncertainCleanup = await closeHarness(rpc, last.errorMessage);
     }
     if (signal.aborted)
         last = { ...last, stopReason: "aborted" };
-    return finishHarnessTurn(store, state, last, resume, input.turnId, {
-        component: "harness",
-        sessionId: input.sessionId,
-        turnId: input.turnId,
-        harness: "pi",
-        traceContext: input.traceContext,
-    });
+    return { ...await finishHarnessTurn(store, state, last, resume, input.turnId, {
+            component: "harness",
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            harness: "pi",
+            traceContext: input.traceContext,
+        }), ...(uncertainCleanup ? { uncertainCleanup } : {}) };
 }
 export function codexItemContent(item) {
     if (item.type === "agentMessage" || item.type === "plan")
@@ -295,6 +307,7 @@ export async function executeCodex(input, options, cwd, store, emit, signal, dia
         if (nativeTurnId)
             void rpc.request("turn/interrupt", { threadId: state.nativeSessionId, turnId: nativeTurnId }).catch(() => undefined);
     });
+    let uncertainCleanup;
     try {
         await initializeCodex(rpc);
         const threadOptions = {
@@ -451,17 +464,17 @@ export async function executeCodex(input, options, cwd, store, emit, signal, dia
         abortEscalation.clear();
         stopFailureLogging();
         stopTimeoutLogging();
-        await rpc.close();
+        uncertainCleanup = await closeHarness(rpc, final.errorMessage);
     }
     if (signal.aborted)
         final = { ...final, stopReason: "aborted" };
     if (usage)
         final = { ...final, usage };
-    return finishHarnessTurn(store, state, final, resume, input.turnId, {
-        component: "harness",
-        sessionId: input.sessionId,
-        turnId: input.turnId,
-        harness: "codex",
-        traceContext: input.traceContext,
-    });
+    return { ...await finishHarnessTurn(store, state, final, resume, input.turnId, {
+            component: "harness",
+            sessionId: input.sessionId,
+            turnId: input.turnId,
+            harness: "codex",
+            traceContext: input.traceContext,
+        }), ...(uncertainCleanup ? { uncertainCleanup } : {}) };
 }

package/dist/runtime/instance.js

@@ -23,7 +23,7 @@ async function readRecord(directory) {
     try {
         const value = JSON.parse(await readFile(join(directory, "owner.json"), "utf8"));
         if (!Number.isSafeInteger(value.pid) || typeof value.nonce !== "string" || typeof value.socket !== "string")
-            throw new Error("Invalid Runtime instance record / Runtime 实例记录无效");
+            throw new Error("Invalid Runtime instance record");
         return value;
     }
     catch (error) {
@@ -35,7 +35,7 @@ async function readRecord(directory) {
 function request(record, action, force = false) {
     return new Promise((resolve, reject) => {
         const socket = createConnection(record.socket);
-        const timer = setTimeout(() => { socket.destroy(); reject(new Error("Runtime control timed out / Runtime 控制连接超时")); }, 3000);
+        const timer = setTimeout(() => { socket.destroy(); reject(new Error("Runtime control timed out")); }, 3000);
         let buffer = "";
         let settled = false;
         const finish = (error, value) => {
@@ -51,7 +51,7 @@ function request(record, action, force = false) {
         };
         socket.on("connect", () => socket.write(`${JSON.stringify({ nonce: record.nonce, action, force })}\n`));
         socket.on("error", (error) => finish(error));
-        socket.on("close", () => finish(new Error("Runtime control closed / Runtime 控制连接已关闭")));
+        socket.on("close", () => finish(new Error("Runtime control closed")));
         socket.on("data", (chunk) => {
             buffer += chunk.toString();
             if (buffer.length > 64 * 1024) {
@@ -65,7 +65,7 @@ function request(record, action, force = false) {
                 if (response.error)
                     finish(new Error(response.error));
                 else if (response.nonce !== record.nonce || response.status?.pid !== record.pid)
-                    finish(new Error("Runtime identity changed / Runtime 身份已变化"));
+                    finish(new Error("Runtime identity changed"));
                 else
                     finish(undefined, response.status);
             }
@@ -95,7 +95,7 @@ export async function ownRuntimeInstance(directory, status, stop) {
     await mkdir(directory, { recursive: true, mode: 0o700 });
     return withRuntimeSpaceBindingsLock(async () => {
         if (await requestRuntimeInstance(directory))
-            throw new Error("Runtime already running; use status / Runtime 已在运行，请使用 status");
+            throw new Error("Runtime already running; use status");
         const socketPath = process.platform === "win32"
             ? `\\\\.\\pipe\\cohub-${createHash("sha256").update(directory).digest("hex").slice(0, 24)}`
             : join(directory, "control.sock");

package/dist/runtime/json-rpc.d.ts

@@ -17,6 +17,8 @@ export declare function harnessEnvironment(): NodeJS.ProcessEnv;
 export declare class JsonRpcProcess {
     private mode;
     private child;
+    /** Process-group id of the harness process, for deferred cleanup confirmation. */
+    get processGroupId(): number | null;
     private pending;
     private listeners;
     private failureListeners;

package/dist/runtime/json-rpc.js

@@ -50,6 +50,8 @@ export function harnessEnvironment() {
 export class JsonRpcProcess {
     mode;
     child;
+    /** Process-group id of the harness process, for deferred cleanup confirmation. */
+    get processGroupId() { return this.child.pid ?? null; }
     pending = new Map();
     listeners = new Set();
     failureListeners = new Set();

package/dist/runtime/launch.js

@@ -10,19 +10,20 @@ import { createClient } from "../client.js";
 import { currentIdentityKey, explicitSpace } from "../space.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding, resolveRuntimeSpace } from "./space-binding.js";
 import { requestRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
+import { ensureNativeSync } from "./native-attach.js";
 import { createDiagnosticConsole, printRuntimeSummary, runtimeWebUrl } from "./presentation.js";
 import { runRuntime } from "./supervisor.js";
 export const resolveLocalSpaceName = (root, name) => name?.trim() || basename(root) || "local-space";
 export function parseRuntimeHarnesses(values) {
     const names = values.flatMap((value) => value.split(",")).map((name) => name.trim()).filter(Boolean);
     if (names.some((name) => !isLocalHarness(name)))
-        throw new Error("Harness must be pi or codex / Harness 必须是 pi 或 codex");
+        throw new Error("Harness must be pi or codex");
     return [...new Set(names.length ? names : ["pi"])];
 }
 export async function resolveRuntimeTarget(program, target) {
     const spaceId = target?.trim() || explicitSpace(program) || (await getRuntimeSpaceBinding(process.cwd(), currentIdentityKey()))?.spaceId;
     if (!spaceId)
-        throw new Error("No directory binding. Use --space <id> or runtime up / 此目录未绑定 Space，请使用 --space <id> 或 runtime up");
+        throw new Error("No directory binding. Use --space <id> or runtime up");
     return spaceId;
 }
 export async function startBackgroundRuntime(config) {
@@ -47,11 +48,11 @@ export async function startBackgroundRuntime(config) {
             else if (last)
                 resolve(last);
             else
-                reject(new Error("Runtime did not start / Runtime 未启动"));
+                reject(new Error("Runtime did not start"));
         };
-        const timeout = setTimeout(() => finish(last ? undefined : new Error("Runtime startup timed out / Runtime 启动超时")), 30_000);
+        const timeout = setTimeout(() => finish(last ? undefined : new Error("Runtime startup timed out")), 30_000);
         child.on("error", (error) => finish(error));
-        child.on("exit", (code) => finish(new Error(`Runtime exited (${code}) / Runtime 已退出`)));
+        child.on("exit", (code) => finish(new Error(`Runtime exited (${code})`)));
         child.on("message", (message) => {
             if (message.type === "status" && message.status) {
                 last = message.status;
@@ -69,17 +70,17 @@ export async function startBackgroundRuntime(config) {
 export async function runtimeUp(program, dir, options) {
     const requestedRoot = resolve(dir ?? process.cwd());
     if (!(await stat(requestedRoot)).isDirectory())
-        throw new Error("Workspace is not a directory / 工作区不是目录");
+        throw new Error("Workspace is not a directory");
     const root = await canonicalRuntimeRoot(requestedRoot);
     const requested = options.space?.trim() || explicitSpace(program);
     if (options.new && requested)
-        throw new Error("--new cannot be combined with --space or COHUB_SPACE_ID / --new 不能与显式 Space 同时使用");
+        throw new Error("--new cannot be combined with --space or COHUB_SPACE_ID");
     if (options.name && requested)
-        throw new Error("--name only applies to a new Space / --name 仅用于新建 Space");
+        throw new Error("--name only applies to a new Space");
     const identity = currentIdentityKey();
     if (!identity) {
         await requireAccessToken();
-        throw new Error("Cannot identify the signed-in account / 无法识别当前登录账号");
+        throw new Error("Cannot identify the signed-in account");
     }
     const binding = await getRuntimeSpaceBinding(root, identity);
     const existingId = requested || binding?.spaceId;
@@ -88,8 +89,11 @@ export async function runtimeUp(program, dir, options) {
         const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, existingId));
         if (existing) {
             if (existing.root !== root || options.harness.length && [...existing.harnesses].sort().join() !== [...harnesses].sort().join() || options.pi || options.codex) {
-                throw new Error("Runtime is running with a different configuration. Use down first / Runtime 正使用不同配置运行，请先 down");
+                throw new Error("Runtime is running with a different configuration. Use down first");
             }
+            // `up` is the single idempotent entry: a reused instance adopts its running
+            // Harnesses (unless explicitly overridden) and completes native sync setup.
+            await ensureNativeSync({ root, spaceId: existing.spaceId, identity, harnesses: options.harness.length ? harnesses : parseRuntimeHarnesses(existing.harnesses), yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
             printRuntimeSummary(existing, options.json, true);
             return;
         }
@@ -97,33 +101,33 @@ export async function runtimeUp(program, dir, options) {
     if (!options.harness.length)
         harnesses = await installedHarnesses(root, options);
     if (!harnesses.length)
-        throw new Error("Install and sign in to Pi or Codex, or pass --harness / 请安装并登录 Pi 或 Codex，或显式指定 --harness");
+        throw new Error("Install and sign in to Pi or Codex, or pass --harness");
     let createNew = Boolean(options.new);
     let name = resolveLocalSpaceName(root, options.name);
     if (!options.yes) {
         if (!process.stdin.isTTY)
-            throw new Error("Use --yes to authorize local execution / 请使用 --yes 授权本地执行");
+            throw new Error("Use --yes to authorize local execution");
         const rl = createInterface({ input: process.stdin, output: process.stderr });
         try {
             if (!requested && binding) {
-                process.stderr.write(`\nLinked Space / 已关联 Space\n  ${runtimeWebUrl(binding.spaceId)}\n`);
-                const answer = (await rl.question("Reuse this Space? [Y/n, q to cancel] / 复用此 Space？[Y/n，q 取消] ")).trim().toLowerCase();
+                process.stderr.write(`\nLinked Space\n  ${runtimeWebUrl(binding.spaceId)}\n`);
+                const answer = (await rl.question("Reuse this Space? [Y/n, q to cancel] ")).trim().toLowerCase();
                 if (answer === "q")
                     return;
                 createNew = answer === "n" || answer === "no";
             }
             else if (!requested) {
-                const answer = (await rl.question("Create a new Space? [Y/n] / 创建新 Space？[Y/n] ")).trim().toLowerCase();
+                const answer = (await rl.question("Create a new Space? [Y/n] ")).trim().toLowerCase();
                 if (answer && answer !== "y" && answer !== "yes")
                     return;
             }
             if (binding && createNew && !options.name)
                 name = `${name}-${randomUUID().slice(0, 6)}`;
             if (!requested && (!binding || createNew))
-                name = (await rl.question(`Space name / Space 名称 [${name}]: `)).trim() || name;
-            process.stderr.write(`\nDirectory / 目录  ${root}\n${requested ? `Space / 空间  ${runtimeWebUrl(requested)}\n` : ""}`);
-            const answer = await rl.question("Collaborators can execute as your OS user, beyond this folder. Allow? [y/N] / 协作者可使用你的系统身份执行命令，不限于此目录。允许？[y/N] ");
-            if (!/^y(es)?$/i.test(answer.trim()))
+                name = (await rl.question(`Space name [${name}]: `)).trim() || name;
+            process.stderr.write(`\nDirectory  ${root}\n${requested ? `Space  ${runtimeWebUrl(requested)}\n` : ""}`);
+            const answer = await rl.question("Collaborators can execute as your OS user, beyond this folder. Allow? [Y/n] ");
+            if (/^n(o)?$/i.test(answer.trim()))
                 return;
         }
         finally {
@@ -133,7 +137,7 @@ export async function runtimeUp(program, dir, options) {
     if (options.yes && createNew && binding && !options.name)
         name = `${name}-${randomUUID().slice(0, 6)}`;
     if (createNew && binding && await requestRuntimeInstance(runtimeInstanceDirectory(identity, binding.spaceId))) {
-        throw new Error("Stop the existing Runtime before rebinding this directory / 请先停止此目录的 Runtime，再创建新绑定");
+        throw new Error("Stop the existing Runtime before rebinding this directory");
     }
     // Fail local preflight before creating remote state; the worker reuses this catalog.
     const capabilities = await discoverHarnesses(harnesses, options, root);
@@ -145,14 +149,16 @@ export async function runtimeUp(program, dir, options) {
         validateSpace: async (id) => {
             const sandbox = (await client.space(id).sandbox.get()).sandbox;
             if (sandbox?.provider !== "local")
-                throw new Error("Space does not have a local Runtime / 此 Space 不是本地 Runtime");
+                throw new Error("Space does not have a local Runtime");
         },
     });
+    // Consent (or --yes) precedes any user-level integration install; failure never blocks startup.
+    await ensureNativeSync({ root, spaceId, identity, harnesses, yes: options.yes, executables: { pi: options.pi, codex: options.codex } });
     const config = { spaceId, root, identity, harnesses, capabilities, executables: { pi: options.pi, codex: options.codex }, background: Boolean(options.detach), verbose: options.verbose };
     const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
     if (existing) {
         if (existing.root !== root)
-            throw new Error("This Space is running in another directory / 此 Space 已在另一目录运行");
+            throw new Error("This Space is running in another directory");
         printRuntimeSummary(existing, options.json, true);
         return;
     }
@@ -170,7 +176,7 @@ export async function runtimeUp(program, dir, options) {
                 printRuntimeSummary(status, options.json, source === "binding");
             }
             else if (!announced && status.state === "starting" && !options.json)
-                process.stderr.write(`Connecting / 正在连接\n  ${runtimeWebUrl(spaceId)}\n  Logs / 日志  ${status.diagnosticsPath}\n`);
+                process.stderr.write(`Connecting\n  ${runtimeWebUrl(spaceId)}\n  Logs  ${status.diagnosticsPath}\n`);
         });
     }
 }

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

@@ -0,0 +1,28 @@
+import { type NativeSyncConfig } from "./native-sync.js";
+type Harness = "pi" | "codex";
+export type NativeSyncReport = {
+    enabled: boolean;
+    harnesses: Harness[];
+    note?: string;
+};
+/** Already enabled for this exact directory and every requested Harness: installation is idempotent. */
+export declare function nativeSyncSatisfied(config: NativeSyncConfig | null, input: {
+    spaceId: string;
+    root: string;
+    harnesses: Harness[];
+}): boolean;
+/** One explicit consent prompt, defaulting to yes; native history may contain secrets. */
+export declare function askNativeSyncConsent(harnesses: Harness[], ask?: (question: string) => Promise<string>): Promise<boolean>;
+/** Enable native sync after consent; capability or write failures warn and never block the Runtime. */
+export declare function ensureNativeSync(input: {
+    root: string;
+    spaceId: string;
+    identity: string;
+    harnesses: Harness[];
+    yes?: boolean;
+    executables?: {
+        pi?: string;
+        codex?: string;
+    };
+}, log?: (line: string) => void): Promise<NativeSyncReport>;
+export {};

package/dist/runtime/native-attach.js

@@ -0,0 +1,47 @@
+import { createInterface } from "node:readline/promises";
+import { installNativeSync } from "./native-install.js";
+import { nativeRuntimeRoot, readNativeSyncConfig } from "./native-sync.js";
+import { serializeDiagnosticError } from "./diagnostics.js";
+/** Already enabled for this exact directory and every requested Harness: installation is idempotent. */
+export function nativeSyncSatisfied(config, input) {
+    return Boolean(config && config.spaceId === input.spaceId && config.root === input.root && input.harnesses.every((harness) => config.harnesses.includes(harness)));
+}
+/** One explicit consent prompt, defaulting to yes; native history may contain secrets. */
+export async function askNativeSyncConsent(harnesses, ask = defaultAsk) {
+    const answer = await ask(`Sync native ${harnesses.join(" / ")} chats in this folder and upload their history (may contain secrets) to this Space? [Y/n] `);
+    return /^(|y(es)?)$/i.test(answer.trim());
+}
+async function defaultAsk(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        return await rl.question(question);
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Enable native sync after consent; capability or write failures warn and never block the Runtime. */
+export async function ensureNativeSync(input, log = (line) => process.stderr.write(line)) {
+    const config = await readNativeSyncConfig(nativeRuntimeRoot(input.spaceId), input.identity).catch(() => null);
+    if (nativeSyncSatisfied(config, input))
+        return { enabled: true, harnesses: config?.harnesses ?? [] };
+    if (!input.yes) {
+        // Non-interactive sessions cannot consent; they continue without sync instead of failing `up`.
+        if (!process.stdin.isTTY) {
+            log("Native sync off · rerun interactively or with --yes to enable\n");
+            return { enabled: false, harnesses: input.harnesses, note: "non-interactive" };
+        }
+        if (!await askNativeSyncConsent(input.harnesses))
+            return { enabled: false, harnesses: input.harnesses, note: "declined" };
+    }
+    try {
+        const result = await installNativeSync(input);
+        log(`Native sync enabled. Reload Pi or restart Codex and review its hook trust prompt.\n${result.configPath}`);
+        return { enabled: true, harnesses: result.harnesses };
+    }
+    catch (error) {
+        const message = serializeDiagnosticError(error).message;
+        log(`Native sync unavailable; Runtime continues without it — ${message}\n`);
+        return { enabled: false, harnesses: input.harnesses, note: message };
+    }
+}

package/dist/runtime/native-codex-hook.js

@@ -5,7 +5,7 @@ export async function runCodexNativeHook(payload) {
         return;
     const value = payload;
     if (!value || typeof value.cwd !== "string" || typeof value.session_id !== "string")
-        throw new Error("Invalid Codex hook identity / Codex Hook 身份无效");
+        throw new Error("Invalid Codex hook identity");
     if (typeof value.transcript_path !== "string" || !value.transcript_path)
         return;
     const result = await requestNativeDaemon({ harness: "codex", cwd: value.cwd, path: value.transcript_path, nativeSessionId: value.session_id });
@@ -17,12 +17,12 @@ async function main() {
     for await (const chunk of process.stdin) {
         input += chunk.toString();
         if (Buffer.byteLength(input) > 4 * 1024 * 1024)
-            throw new Error("Codex hook input is too large / Codex Hook 输入过大");
+            throw new Error("Codex hook input is too large");
     }
     await runCodexNativeHook(JSON.parse(input));
 }
 if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
     void main().catch((error) => {
-        process.stderr.write(`Cohub sync pending; native execution continues / Cohub 待同步，原生执行继续: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.stderr.write(`Cohub sync pending; native execution continues: ${error instanceof Error ? error.message : String(error)}\n`);
     });
 }

package/dist/runtime/native-install.js

@@ -21,7 +21,7 @@ async function installText(path, update) {
         const info = await lstat(path).catch((error) => { if (missing(error))
             return null; throw error; });
         if (info && (!info.isFile() || info.isSymbolicLink()))
-            throw new Error(`Refusing to replace a non-regular file / 不覆盖非普通文件: ${path}`);
+            throw new Error(`Refusing to replace a non-regular file: ${path}`);
         const original = info ? await readFile(path, "utf8") : null;
         const next = update(original);
         if (next === original)
@@ -54,7 +54,7 @@ async function installText(path, update) {
             const current = await readFile(path, "utf8").catch((error) => { if (missing(error))
                 return null; throw error; });
             if (current !== original)
-                throw new Error(`Configuration changed during installation / 安装期间配置已变化: ${path}`);
+                throw new Error(`Configuration changed during installation: ${path}`);
             await rename(temporary, path);
             const directory = await open(dirname(path), "r");
             try {
@@ -75,10 +75,10 @@ export async function verifyNativeSyncSupport(harnesses, cwd, executables = {})
         if (harness === "pi") {
             const version = /\b(\d+)\.(\d+)\.(\d+)\b/.exec(stdout);
             if (!version || Number(version[1]) === 0 && (Number(version[2]) < 85 || Number(version[2]) === 85 && Number(version[3]) < 1))
-                throw new Error("Native sync requires Pi 0.85.1+ / 原生同步需要 Pi 0.85.1 或更高版本");
+                throw new Error("Native sync requires Pi 0.85.1+");
         }
         else if (!/^hooks\s+stable\s+true\s*$/m.test(stdout))
-            throw new Error("Install a Codex version with stable Hooks and enable hooks first / 请安装支持稳定 Hooks 的 Codex 版本并启用 Hooks");
+            throw new Error("Install a Codex version with stable Hooks and enable hooks first");
     }
 }
 /** Install once in the user's native configuration; data collection remains explicitly project-scoped. */
@@ -92,10 +92,10 @@ export async function installNativeSync(input) {
     if (!input.disabled)
         for (const harness of input.harnesses) {
             if (harness === "pi") {
-                const content = `// Cohub native Turn sync / Cohub 原生 Turn 同步\nexport { default } from ${JSON.stringify(extension.href)};\n`;
+                const content = `// Cohub native Turn sync\nexport { default } from ${JSON.stringify(extension.href)};\n`;
                 await installText(join(process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent"), "extensions", "cohub.ts"), (existing) => {
                     if (existing !== null && existing !== content)
-                        throw new Error("Pi Cohub extension already exists; preserve it and review manually / Pi Cohub 扩展已存在，请保留并手动核对");
+                        throw new Error("Pi Cohub extension already exists; preserve it and review manually");
                     return content;
                 });
             }
@@ -105,9 +105,9 @@ export async function installNativeSync(input) {
                     if (existing?.includes(block))
                         return existing;
                     if (existing?.includes(START) || existing?.includes(END))
-                        throw new Error("Codex Cohub hook block differs; preserve it and review manually / Codex Cohub Hook 配置不同，请保留并手动核对");
+                        throw new Error("Codex Cohub hook block differs; preserve it and review manually");
                     if (existing && /^\s*hooks\s*=/m.test(existing))
-                        throw new Error("Inline Codex hooks require manual merging / 内联 Codex Hooks 需要手动合并");
+                        throw new Error("Inline Codex hooks require manual merging");
                     return `${existing ?? ""}${existing?.endsWith("\n") ? "\n" : "\n\n"}${block}`;
                 });
             }
@@ -115,7 +115,7 @@ export async function installNativeSync(input) {
     await withRuntimeSpaceBindingsLock(async () => {
         const previous = await readNativeSyncConfig(runtimeRoot, input.identity);
         if (previous && previous.root !== input.root)
-            throw new Error("Space native sync belongs to another directory / 此 Space 原生同步属于其他目录");
+            throw new Error("Space native sync belongs to another directory");
         const harnesses = new Set(previous?.harnesses ?? []);
         for (const harness of input.harnesses) {
             if (input.disabled)

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

@@ -7,6 +7,8 @@ type NativeIpcRequest = {
     nativeSessionId: string;
     settled?: boolean;
     leafId?: string | null;
+    sessionStartedAt?: string;
+    origin?: "local_import";
 };
 type NativeIpcResponse = {
     ok: true;

package/dist/runtime/native-ipc.js

@@ -9,8 +9,10 @@ const socketPath = (runtimeRoot) => join(runtimeRoot, "native", "daemon.sock");
 const parse = (raw) => {
     const value = JSON.parse(raw);
     if (value?.type !== "native.capture" || !["pi", "codex"].includes(value.harness)
-        || typeof value.cwd !== "string" || typeof value.path !== "string" || typeof value.nativeSessionId !== "string") {
-        throw new Error("Invalid native daemon request / 原生 Daemon 请求无效");
+        || typeof value.cwd !== "string" || typeof value.path !== "string" || typeof value.nativeSessionId !== "string"
+        || value.origin !== undefined && value.origin !== "local_import"
+        || value.sessionStartedAt !== undefined && typeof value.sessionStartedAt !== "string") {
+        throw new Error("Invalid native daemon request");
     }
     return value;
 };
@@ -25,18 +27,18 @@ export async function nativeDaemonSocketFor(cwd) {
 export async function requestNativeDaemon(input) {
     const path = await nativeDaemonSocketFor(input.cwd);
     if (!path)
-        return { ok: false, message: "Native Runtime is not bound / 原生 Runtime 未绑定" };
+        return { ok: false, message: "Native Runtime is not bound" };
     return new Promise((resolve, reject) => {
         const socket = createConnection(path);
         let buffer = "";
-        const timer = setTimeout(() => { socket.destroy(); reject(new Error("Native Runtime daemon timed out / 原生 Runtime Daemon 超时")); }, 15_000);
+        const timer = setTimeout(() => { socket.destroy(); reject(new Error("Native Runtime daemon timed out")); }, 15_000);
         const finish = (error, result) => {
             clearTimeout(timer);
             socket.destroy();
             if (error)
                 reject(error);
             else
-                resolve(result ?? { ok: false, message: "Empty daemon response / Daemon 返回为空" });
+                resolve(result ?? { ok: false, message: "Empty daemon response" });
         };
         socket.once("error", (error) => finish(error));
         socket.on("data", (chunk) => {

package/dist/runtime/native-pi-extension.js

@@ -10,7 +10,7 @@ export default function cohubNativeExtension(pi) {
     const report = (error) => {
         const message = error instanceof Error ? error.message : String(error);
         if (message !== lastError)
-            context?.ui.notify(`Cohub sync pending / Cohub 待同步: ${message}`, "warning");
+            context?.ui.notify(`Cohub sync pending: ${message}`, "warning");
         lastError = message;
     };
     const capture = (ctx, settled = false) => {

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

@@ -32,6 +32,8 @@ export type NativeTurnReceipt = {
     endBytes: number;
     contentEndBytes?: number;
     result: NativeTurnComplete | null;
+    sessionStartedAt?: string;
+    origin?: "local_import";
     progress?: NativeTurnProgress;
 };
 export type NativeSyncTransport = ArchiveTransport & {
@@ -81,7 +83,10 @@ export declare class NativeSyncStore {
     private cloudBindingPath;
     binding(): Promise<NativeBinding>;
     private initialize;
-    capture(path: string, transcript: NativeTranscript): Promise<void>;
+    capture(path: string, transcript: NativeTranscript, context?: {
+        sessionStartedAt?: string;
+        origin?: "local_import";
+    }): Promise<void>;
     receipts(pendingOnly?: boolean): Promise<NativeTurnReceipt[]>;
     status(): Promise<{
         harness: "codex" | "pi";