@neta-art/cohub-cli 8.0.1 → 8.1.1

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

@@ -9,7 +9,7 @@ export async function runCodexNativeHook(payload) {
     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 });
-    if (!result.ok)
+    if (!result.ok && !result.skipped)
         throw new Error(result.message);
 }
 async function main() {

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

@@ -7,14 +7,25 @@ type NativeIpcRequest = {
     nativeSessionId: string;
     settled?: boolean;
     leafId?: string | null;
+    sessionStartedAt?: string;
+    origin?: "local_import";
 };
-type NativeIpcResponse = {
+export type NativeIpcResponse = {
     ok: true;
     pendingTurns: number;
 } | {
     ok: false;
+    skipped?: true;
     message: string;
 };
+/**
+ * `store: null` means the request was valid but nothing was applicable yet (an unbound
+ * workspace, or a transcript a harness has not written). That is not a sync failure, so
+ * clients stay silent instead of warning about it.
+ */
+export declare function nativeCaptureResponse(result: {
+    store: NativeSyncStore | null;
+}): Promise<NativeIpcResponse>;
 export declare function nativeDaemonSocketFor(cwd: string): Promise<string | null>;
 export declare function requestNativeDaemon(input: Omit<NativeIpcRequest, "type">): Promise<NativeIpcResponse>;
 export declare function serveNativeDaemon(input: {

package/dist/runtime/native-ipc.js

@@ -6,10 +6,22 @@ import { currentIdentityKey } from "../space.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding } from "./space-binding.js";
 const MAX_LINE_BYTES = 4 * 1024 * 1024;
 const socketPath = (runtimeRoot) => join(runtimeRoot, "native", "daemon.sock");
+/**
+ * `store: null` means the request was valid but nothing was applicable yet (an unbound
+ * workspace, or a transcript a harness has not written). That is not a sync failure, so
+ * clients stay silent instead of warning about it.
+ */
+export async function nativeCaptureResponse(result) {
+    if (!result.store)
+        return { ok: false, skipped: true, message: "No native capture is pending" };
+    return { ok: true, pendingTurns: (await result.store.status()).pendingTurns };
+}
 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") {
+        || 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;
@@ -18,14 +30,19 @@ export async function nativeDaemonSocketFor(cwd) {
     const identity = currentIdentityKey();
     if (!identity)
         return null;
-    const root = await canonicalRuntimeRoot(cwd);
+    // A vanished workspace is unbound, not an error; the terminal has nothing left to sync.
+    const root = await canonicalRuntimeRoot(cwd).catch((error) => { if (error.code === "ENOENT")
+        return null; throw error; });
+    if (!root)
+        return null;
     const binding = await getRuntimeSpaceBinding(root, identity);
     return binding ? socketPath(nativeRuntimeRoot(binding.spaceId)) : null;
 }
 export async function requestNativeDaemon(input) {
     const path = await nativeDaemonSocketFor(input.cwd);
+    // An unbound workspace is a normal state, not an error the terminal should surface.
     if (!path)
-        return { ok: false, message: "Native Runtime is not bound" };
+        return { ok: false, skipped: true, message: "Native Runtime is not bound" };
     return new Promise((resolve, reject) => {
         const socket = createConnection(path);
         let buffer = "";
@@ -86,7 +103,7 @@ export async function serveNativeDaemon(input) {
             void (async () => {
                 const request = parse(buffer.slice(0, newline));
                 const result = await input.handle(request);
-                respond({ ok: true, pendingTurns: result.store ? (await result.store.status()).pendingTurns : 0 });
+                respond(await nativeCaptureResponse(result));
             })().catch((error) => respond({ ok: false, message: error instanceof Error ? error.message : String(error) }));
         });
     });

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

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { requestNativeDaemon } from "./native-ipc.js";
 /** Thin native adapter. The Runtime Daemon owns Cohub auth, WS, retries and archives. */
 export default function cohubNativeExtension(pi) {
@@ -6,7 +7,6 @@ export default function cohubNativeExtension(pi) {
     let context = null;
     let captures = Promise.resolve();
     let lastError = "";
-    let timer;
     const report = (error) => {
         const message = error instanceof Error ? error.message : String(error);
         if (message !== lastError)
@@ -19,9 +19,16 @@ export default function cohubNativeExtension(pi) {
         if (!path)
             return Promise.resolve();
         captures = captures.then(async () => {
+            // Pi persists the transcript lazily; a not-yet-created file is not a sync failure.
+            if (!existsSync(path))
+                return;
             const result = await requestNativeDaemon({ harness: "pi", cwd: ctx.cwd, path, nativeSessionId: ctx.sessionManager.getSessionId(), leafId: ctx.sessionManager.getLeafId(), settled });
-            if (!result.ok)
+            // Nothing to sync yet (unbound workspace, or config not installed) is silence, not a warning.
+            if (!result.ok) {
+                if (result.skipped)
+                    return;
                 throw new Error(result.message);
+            }
             ctx.ui.setStatus("cohub", "Cohub");
             lastError = "";
         }).catch(report);
@@ -29,17 +36,10 @@ export default function cohubNativeExtension(pi) {
     };
     pi.on("session_start", async (_event, ctx) => {
         await capture(ctx, ctx.isIdle());
-        if (timer)
-            clearInterval(timer);
-        timer = setInterval(() => { void capture(ctx, ctx.isIdle()); }, 5000);
-        timer.unref();
     });
     pi.on("message_end", (_event, ctx) => capture(ctx));
     pi.on("agent_settled", (_event, ctx) => capture(ctx, true));
     pi.on("session_shutdown", async (_event, ctx) => {
-        if (timer)
-            clearInterval(timer);
-        timer = undefined;
         await captures;
         ctx.ui.setStatus("cohub", undefined);
         context = null;

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";

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

@@ -112,7 +112,7 @@ 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");
         await withRuntimeSpaceBindingsLock(async () => {
@@ -156,6 +156,8 @@ 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");
@@ -238,7 +240,8 @@ export class NativeSyncStore {
                 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));

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,7 +42,9 @@ 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;
-export declare function flushNativeSessions(spaceId: string, identity: string, signal: AbortSignal, report: (error: unknown) => void, transportOverride?: NativeSyncTransport): Promise<void>;
+export declare function flushNativeSessions(spaceId: string, identity: string, signal: AbortSignal, report: (error: unknown) => void, transportOverride?: NativeSyncTransport): Promise<boolean>;

package/dist/runtime/native-sync.js

@@ -1,14 +1,95 @@
-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) => {
@@ -39,6 +120,10 @@ export async function readNativeSyncConfig(runtimeRoot, identity) {
     }
 }
 const nativeStores = new Map();
+const missing = (error) => error.code === "ENOENT";
+/** Canonical alias, but a missing target reports itself instead of failing capture. */
+const canonicalPathOrNull = async (path) => canonicalRuntimeRoot(path).catch((error) => { if (missing(error))
+    return null; throw error; });
 /** Local capture only. Neither Pi callbacks nor Codex hooks wait for Cohub's network. */
 export async function captureNativeSession(input) {
     if (process.env.COHUB_TURN_ID || process.env.COHUB_EXECUTION_TOKEN)
@@ -46,7 +131,11 @@ export async function captureNativeSession(input) {
     const identity = currentIdentityKey();
     if (!identity)
         return null;
-    const root = await canonicalRuntimeRoot(input.cwd);
+    // Pi and Codex create their transcripts lazily, so a pending capture for a file that does
+    // not exist yet (or a workspace that has since been removed) is not a sync failure.
+    const root = await canonicalPathOrNull(input.cwd);
+    if (!root)
+        return null;
     const space = await getRuntimeSpaceBinding(root, identity);
     if (!space)
         return null;
@@ -54,9 +143,11 @@ export async function captureNativeSession(input) {
     const config = await readNativeSyncConfig(runtimeRoot, identity);
     if (!config || config.root !== root || config.spaceId !== space.spaceId || !config.harnesses.includes(input.harness))
         return null;
-    const path = await canonicalRuntimeRoot(input.path);
+    const path = await canonicalPathOrNull(input.path);
+    if (!path)
+        return null;
     const transcript = await readNativeTranscript(path, input.harness, input);
-    if (await canonicalRuntimeRoot(transcript.cwd) !== root || input.nativeSessionId && transcript.nativeSessionId !== input.nativeSessionId)
+    if (await canonicalPathOrNull(transcript.cwd) !== root || input.nativeSessionId && transcript.nativeSessionId !== input.nativeSessionId)
         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);
@@ -71,8 +162,7 @@ export async function captureNativeSession(input) {
             }
         if (!store) {
             const managed = await findRuntimeNativeSession(runtimeRoot, input.harness, transcript.nativeSessionId, path);
-            const managedPath = managed ? await canonicalRuntimeRoot(managed.path).catch((error) => { if (error.code === "ENOENT")
-                return null; throw error; }) : null;
+            const managedPath = managed ? await canonicalPathOrNull(managed.path) : null;
             if (candidates.length && managedPath !== path)
                 throw new Error("Native path changed; original bindings retained");
             // Restored Pi working copies can share a native ID. Existing Cohub sidecars disambiguate them.
@@ -83,7 +173,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. */
@@ -99,30 +189,33 @@ export function nativeWebSocketTransport(spaceId, identity, send) {
 }
 export async function flushNativeSessions(spaceId, identity, signal, report, transportOverride) {
     if (currentIdentityKey() !== identity)
-        return;
+        return false;
     const runtimeRoot = nativeRuntimeRoot(spaceId);
     const config = await readNativeSyncConfig(runtimeRoot, identity);
     if (!config || config.spaceId !== spaceId)
-        return;
+        return false;
     const transport = transportOverride;
     if (!transport)
-        return;
+        return false;
     const stores = await listNativeSyncStores(runtimeRoot, spaceId, identity, transport);
+    let failed = false;
     for (const store of stores) {
         signal.throwIfAborted();
         const binding = await store.binding();
         if (!config.harnesses.includes(binding.harness))
             continue;
         try {
-            // Codex hooks only push capture requests while its terminal lives; the Daemon keeps re-reading
-            // the transcript between hooks so Stop-flushed Turns are picked up even if a hook is missed.
+            // Codex hooks trigger captures; re-reading here also closes gaps after reconnects or missed hooks.
             if (binding.harness === "codex")
                 await store.capture(binding.path, await readNativeTranscript(binding.path, "codex"));
             await store.flush(AbortSignal.any([signal, AbortSignal.timeout(30_000)]));
         }
         catch (error) {
-            if (!signal.aborted)
+            if (!signal.aborted) {
+                failed = true;
                 report(error);
+            }
         }
     }
+    return failed;
 }

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

@@ -11,6 +11,35 @@ const iso = (value) => {
         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));

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

@@ -76,3 +76,19 @@ export function printRuntimeSummary(summary, json = false, reused = false) {
         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`;
+}