@neta-art/cohub-cli 8.1.0 → 8.2.0

package/dist/commands/app-commerce.js

@@ -1,6 +1,6 @@
 import { resolveExecutionAppId, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
-import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
+import { error, formatLocalDateTime, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
 function collectOption(value, previous = []) {
     return [...previous, value];
 }
@@ -69,7 +69,7 @@ function printOrder(order) {
         { key: "status", label: "Status" },
         { key: "amount", label: "Amount" },
         { key: "paid", label: "Paid" },
-        { key: "created", label: "Created" },
+        { key: "created", label: "Created", format: formatLocalDateTime },
         { key: "paidAt", label: "Paid At" },
     ]);
 }

package/dist/commands/me.js

@@ -1,5 +1,5 @@
 import { createClient } from "../client.js";
-import { handleHttp, json as outJson, jsonRequested, table } from "../output.js";
+import { formatLocalDateTime, handleHttp, json as outJson, jsonRequested, table } from "../output.js";
 function parseInteger(value, name, min) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isSafeInteger(parsed) || parsed < min) {
@@ -70,7 +70,7 @@ export function registerMe(program) {
             });
             if (jsonRequested(opts))
                 return outJson(activity);
-            console.log(`\n  ${activity.range.from} → ${activity.range.to}`);
+            console.log(`\n  ${formatLocalDateTime(activity.range.from)} → ${formatLocalDateTime(activity.range.to)}`);
             table([activity.summary], [
                 { key: "totalTokens", label: "Tokens" },
                 { key: "costTotal", label: "Cost ($)" },

package/dist/commands/references.js

@@ -1,6 +1,6 @@
 import { isUuid, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
-import { table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
+import { formatLocalDateTime, table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
 const RESOURCE_TYPES = new Set([
     "turn",
     "session",
@@ -104,7 +104,7 @@ Examples:
                 source: `${r.sourceType}:${r.sourceId.slice(0, 8)}`,
                 target: formatTarget(r.targetType, r.targetId),
                 count: r.count,
-                lastSeen: r.updatedAt.slice(0, 10),
+                lastSeen: formatLocalDateTime(r.updatedAt).slice(0, 10),
             }));
             table(rows, [
                 { key: "kind", label: "Kind" },

package/dist/commands/runtime.d.ts

@@ -1,3 +1,15 @@
 import type { Command } from "commander";
+import { type NativeIpcResponse } from "../runtime/native-ipc.js";
 export { resolveLocalSpaceName, parseRuntimeHarnesses } from "../runtime/launch.js";
+export declare function applyNativeImportResponse(result: {
+    imported: number;
+    failed: Array<{
+        path: string;
+        message: string;
+    }>;
+    skipped: Array<{
+        path: string;
+        message: string;
+    }>;
+}, path: string, response: NativeIpcResponse): void;
 export declare function registerRuntime(program: Command): void;

package/dist/commands/runtime.js

@@ -17,6 +17,16 @@ const reportFailure = (cause) => {
     process.stderr.write(`Runtime failed: ${serializeDiagnosticError(cause).message}\n`);
     process.exitCode = 1;
 };
+export function applyNativeImportResponse(result, path, response) {
+    if (!response.ok) {
+        if (response.skipped) {
+            result.skipped.push({ path, message: response.message });
+            return;
+        }
+        throw new Error(response.message);
+    }
+    result.imported += 1;
+}
 export function registerRuntime(program) {
     const runtime = program.command("runtime").description("Connect a local workspace");
     runtime.command("up [dir]")
@@ -105,10 +115,11 @@ export function registerRuntime(program) {
                 },
             });
             const candidates = discovered.candidates.filter((candidate) => !options.session || candidate.nativeSessionId === options.session);
+            const superseded = discovered.superseded.filter((skip) => !options.session || skip.nativeSessionId === options.session);
             const result = {
                 spaceId, root, harnesses, candidates, errors: discovered.errors,
-                imported: 0, failed: [], dryRun: Boolean(options.dryRun),
-                complete: discovered.errors.length === 0,
+                imported: 0, pendingTurns: 0, failed: [], skipped: [], superseded, dryRun: Boolean(options.dryRun),
+                complete: discovered.errors.length === 0 && superseded.length === 0,
             };
             if (jsonRequested(options) && options.dryRun) {
                 result.complete = result.complete && result.failed.length === 0;
@@ -122,8 +133,13 @@ export function registerRuntime(program) {
                     process.exitCode = 1;
                 if (jsonRequested(options))
                     outJson(result);
-                else
+                else {
                     process.stdout.write("No existing native conversations found\n");
+                    for (const error of discovered.errors)
+                        process.stdout.write(`Skipped ${error.path}: ${error.message}\n`);
+                    for (const skip of superseded)
+                        process.stdout.write(`Superseded ${skip.path}: ${skip.message}\n`);
+                }
                 return;
             }
             if (options.dryRun) {
@@ -135,6 +151,8 @@ export function registerRuntime(program) {
                         process.stdout.write(`  ${candidate.harness} ${candidate.nativeSessionId} ${candidate.turnCount} Turn${candidate.turnCount === 1 ? "" : "s"} ${candidate.path}\n`);
                     for (const error of discovered.errors)
                         process.stdout.write(`Skipped ${error.path}: ${error.message}\n`);
+                    for (const skip of superseded)
+                        process.stdout.write(`Superseded ${skip.path}: ${skip.message}\n`);
                 }
                 if (!result.complete)
                     process.exitCode = 1;
@@ -159,28 +177,43 @@ export function registerRuntime(program) {
                     rl.close();
                 }
             }
+            let processed = 0;
             for (const candidate of candidates) {
+                if (controller.signal.aborted)
+                    break;
                 try {
                     const response = await requestNativeDaemon({ harness: candidate.harness, cwd: root, path: candidate.path, nativeSessionId: candidate.nativeSessionId,
                         sessionStartedAt: candidate.sessionStartedAt, origin: "local_import", settled: true });
-                    if (!response.ok)
-                        throw new Error(response.message);
-                    result.imported += 1;
+                    applyNativeImportResponse(result, candidate.path, response);
+                    if (response.ok)
+                        result.pendingTurns += response.pendingTurns;
                 }
                 catch (error) {
-                    result.failed.push({ path: candidate.path, message: error instanceof Error ? error.message : String(error) });
+                    if (!controller.signal.aborted)
+                        result.failed.push({ path: candidate.path, message: error instanceof Error ? error.message : String(error) });
+                }
+                finally {
+                    processed += 1;
+                    if (!jsonRequested(options) && !controller.signal.aborted) {
+                        process.stderr.write(`\rSubmitted ${result.imported}/${candidates.length} · pending ${result.pendingTurns} Turns`);
+                    }
                 }
             }
-            result.complete = result.complete && result.failed.length === 0;
+            const cancelled = controller.signal.aborted;
+            result.complete = result.complete && result.failed.length === 0 && !cancelled;
             if (jsonRequested(options))
-                outJson(result);
+                outJson({ ...result, cancelled, processed });
             else {
-                process.stdout.write(`Imported ${result.imported}/${candidates.length} native conversation${candidates.length === 1 ? "" : "s"}\n`);
-                for (const error of [...discovered.errors, ...result.failed])
+                if (processed)
+                    process.stderr.write("\n");
+                process.stdout.write(`Submitted ${result.imported}/${candidates.length} native conversation${candidates.length === 1 ? "" : "s"}${cancelled ? " (interrupted)" : ""}\n`);
+                for (const error of [...discovered.errors, ...result.skipped, ...result.failed])
                     process.stdout.write(`Skipped ${error.path}: ${error.message}\n`);
-                process.stdout.write("Uploads continue in the local Runtime background\n");
+                for (const skip of result.superseded)
+                    process.stdout.write(`Superseded ${skip.path}: ${skip.message}\n`);
+                process.stdout.write("Uploads continue in the local Runtime background; use runtime status to check confirmation\n");
             }
-            if (!result.complete)
+            if (!result.complete && !cancelled)
                 process.exitCode = 1;
         }
         catch (cause) {

package/dist/commands/search.js

@@ -1,6 +1,6 @@
 import { isUuid } from "@neta-art/cohub";
 import { createClient } from "../client.js";
-import { table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
+import { formatLocalDateTime, table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
 const DEFAULT_LIMIT = 20;
 const MAX_TITLE_LENGTH = 72;
 const MAX_CONTEXT_LENGTH = 42;
@@ -50,7 +50,7 @@ function rowsFor(items) {
         title: truncate(item.title, MAX_TITLE_LENGTH),
         context: truncate(contextFor(item), MAX_CONTEXT_LENGTH),
         match: item.matchedField,
-        updated: item.updatedAt ? item.updatedAt.slice(0, 10) : "",
+        updated: item.updatedAt ? formatLocalDateTime(item.updatedAt).slice(0, 10) : "",
         href: item.href,
     }));
 }

package/dist/commands/space-commerce.js

@@ -1,5 +1,5 @@
 import { createClient } from "../client.js";
-import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
+import { error, formatLocalDateTime, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
 import { resolveSpace } from "../space.js";
 const PRODUCT_STATUSES = ["draft", "active"];
 const PRODUCT_UPDATE_STATUSES = ["draft", "active", "archived"];
@@ -135,7 +135,7 @@ function printOrders(orders) {
         { key: "product", label: "Product" },
         { key: "status", label: "Status" },
         { key: "amount", label: "Amount" },
-        { key: "created", label: "Created" },
+        { key: "created", label: "Created", format: formatLocalDateTime },
     ]);
 }
 async function confirmDanger(opts, detail) {

package/dist/output.d.ts

@@ -10,11 +10,18 @@ export type Column = {
     format?: (value: unknown, row: Row) => string;
 };
 /**
- * Epoch milliseconds → ISO 8601, matching the ISO timestamps other tables print.
+ * Timestamp → local ISO-style date and time with the system's UTC offset.
+ *
+ * CLI tables are for people and follow the machine's local timezone. Structured
+ * output remains untouched so scripts continue to receive the server value.
+ */
+export declare function formatLocalDateTime(value: unknown): string;
+/**
+ * Epoch milliseconds → local date and time.
  *
  * Absent values render empty rather than falling through `Number()` coercion:
  * `null` and `""` both become 0 there, which would print a confident-looking
- * `1970-01-01T00:00:00.000Z` for a timestamp the server never sent.
+ * Unix epoch for a timestamp the server never sent.
  */
 export declare function formatEpochMs(value: unknown): string;
 export declare function table(rows: Row[], columns: Column[]): void;

package/dist/output.js

@@ -1,11 +1,34 @@
 import process from "node:process";
 import { extractBillingPayload } from "@neta-art/cohub";
 /**
- * Epoch milliseconds → ISO 8601, matching the ISO timestamps other tables print.
+ * Timestamp → local ISO-style date and time with the system's UTC offset.
+ *
+ * CLI tables are for people and follow the machine's local timezone. Structured
+ * output remains untouched so scripts continue to receive the server value.
+ */
+export function formatLocalDateTime(value) {
+    const date = value instanceof Date
+        ? value
+        : typeof value === "number"
+            ? new Date(value)
+            : typeof value === "string" && value.trim() !== ""
+                ? new Date(value)
+                : null;
+    if (!date || Number.isNaN(date.getTime()))
+        return "";
+    const pad = (part) => String(part).padStart(2, "0");
+    const offsetMinutes = -date.getTimezoneOffset();
+    const offsetSign = offsetMinutes >= 0 ? "+" : "-";
+    const absoluteOffset = Math.abs(offsetMinutes);
+    const offset = `${offsetSign}${pad(Math.floor(absoluteOffset / 60))}:${pad(absoluteOffset % 60)}`;
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())} ${offset}`;
+}
+/**
+ * Epoch milliseconds → local date and time.
  *
  * Absent values render empty rather than falling through `Number()` coercion:
  * `null` and `""` both become 0 there, which would print a confident-looking
- * `1970-01-01T00:00:00.000Z` for a timestamp the server never sent.
+ * Unix epoch for a timestamp the server never sent.
  */
 export function formatEpochMs(value) {
     const ms = typeof value === "number"
@@ -15,13 +38,14 @@ export function formatEpochMs(value) {
             : Number.NaN;
     if (!Number.isFinite(ms))
         return "";
-    const date = new Date(ms);
-    return Number.isNaN(date.getTime()) ? "" : date.toISOString();
+    return formatLocalDateTime(ms);
 }
 function cellText(column, row) {
     const raw = row[column.key];
     if (column.format)
         return column.format(raw, row);
+    if (/(?:At|Timestamp)$/.test(column.key))
+        return formatLocalDateTime(raw);
     const v = raw ?? "";
     return typeof v === "object" ? JSON.stringify(v) : String(v);
 }

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

@@ -15,6 +15,10 @@ export type ArchiveTransport = {
         signal?: AbortSignal;
     }): Promise<RuntimeArchivePage>;
 };
+/** Raised when local capture bytes fail integrity checks (checksum, truncation, boundary); retryable via cache rebuild. */
+export declare class ArchiveCaptureIntegrityError extends Error {
+    constructor(message: string);
+}
 export declare function checksumNativeFile(path: string): Promise<string>;
 export declare function atomicRuntimeJson(path: string, value: unknown): Promise<void>;
 /** Immutable local segments are the outbox. Model acknowledgements never remove them. */

package/dist/runtime/archive-store.js

@@ -4,6 +4,10 @@ import { mkdir, open, readFile, readdir, rename, rm, stat, link } from "node:fs/
 import { dirname, join } from "node:path";
 import { RUNTIME_ARCHIVE_SEGMENT_BYTES, harnessArchiveIndexSchema, validateArchiveBoundary, } from "@neta-art/cohub";
 const missing = (error) => error?.code === "ENOENT";
+/** Raised when local capture bytes fail integrity checks (checksum, truncation, boundary); retryable via cache rebuild. */
+export class ArchiveCaptureIntegrityError extends Error {
+    constructor(message) { super(message); this.name = "ArchiveCaptureIntegrityError"; }
+}
 const hash = (bytes, algorithm = "sha256") => createHash(algorithm).update(bytes).digest("hex");
 export async function checksumNativeFile(path) {
     const digest = createHash("sha256");
@@ -118,7 +122,7 @@ export class RuntimeArchiveStore {
             if (saved.sessionId !== state.sessionId || saved.harness !== state.harness)
                 throw new Error("Archive identity mismatch");
             if (state.expectedChecksum && state.expectedChecksum !== saved.sha256)
-                throw new Error("Native Turn bytes changed; original archive retained");
+                throw new ArchiveCaptureIntegrityError("Native Turn bytes changed; original archive retained");
             const committed = await stat(join(this.root, "ready", `${turnId}.json`)).catch((error) => { if (missing(error))
                 return null; throw error; });
             if (!committed)
@@ -133,10 +137,10 @@ export class RuntimeArchiveStore {
         try {
             const before = await file.stat();
             if (!before.isFile() || !before.size)
-                throw new Error("Native archive is empty");
+                throw new ArchiveCaptureIntegrityError("Native archive is empty");
             const sizeBytes = state.sizeBytes ?? before.size;
             if (!Number.isSafeInteger(sizeBytes) || sizeBytes < 1 || sizeBytes > before.size)
-                throw new Error("Native archive boundary is unavailable");
+                throw new ArchiveCaptureIntegrityError("Native archive boundary is unavailable");
             const buffer = Buffer.alloc(RUNTIME_ARCHIVE_SEGMENT_BYTES);
             let offset = 0;
             let digest = createHash("sha256");
@@ -172,14 +176,14 @@ export class RuntimeArchiveStore {
             }
             const after = await stat(state.path);
             if (before.ino !== after.ino || after.size < sizeBytes || state.sizeBytes === undefined && (before.size !== after.size || before.mtimeMs !== after.mtimeMs))
-                throw new Error("Native file changed during capture");
+                throw new ArchiveCaptureIntegrityError("Native file changed during capture");
             if (state.sizeBytes !== undefined) {
                 // Native clients may append while an earlier Turn is captured. Validate the exact prefix twice.
                 const verified = createHash("sha256");
                 for await (const bytes of createReadStream(state.path, { end: sizeBytes - 1 }))
                     verified.update(bytes);
                 if (verified.digest("hex") !== digest.copy().digest("hex"))
-                    throw new Error("Native prefix changed during capture");
+                    throw new ArchiveCaptureIntegrityError("Native prefix changed during capture");
             }
             if (process.platform !== "win32") {
                 const directory = await open(join(this.root, "objects"), "r");
@@ -195,7 +199,7 @@ export class RuntimeArchiveStore {
                 sizeBytes, sha256: digest.digest("hex"), segments });
             validateArchiveBoundary(index, parent);
             if (state.expectedChecksum && index.sha256 !== state.expectedChecksum)
-                throw new Error("Native Turn bytes changed during capture; original retained");
+                throw new ArchiveCaptureIntegrityError("Native Turn bytes changed during capture; original retained");
         }
         finally {
             await file.close();

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

@@ -1,4 +1,8 @@
 import { type CodexTokenTotals } from "./codex-usage.js";
+/** A structurally unrestorable archive (e.g. its history reference is not carried); never retried. */
+export declare class ArchiveNotRestorableError extends Error {
+    constructor(message: string);
+}
 export declare function readCodexArchiveTotals(path: string): Promise<CodexTokenTotals | undefined>;
 /** Change only the header of a working copy. Raw archive bytes remain untouched. */
 export declare function importNativeArchive(input: {

package/dist/runtime/native-archive.js

@@ -5,6 +5,10 @@ import { dirname } from "node:path";
 import { RUNTIME_MAX_FRAME_BYTES } from "@neta-art/cohub";
 import { JsonLineDecoder } from "./json-rpc.js";
 import { codexArchiveTotals } from "./codex-usage.js";
+/** A structurally unrestorable archive (e.g. its history reference is not carried); never retried. */
+export class ArchiveNotRestorableError extends Error {
+    constructor(message) { super(message); this.name = "ArchiveNotRestorableError"; }
+}
 export async function readCodexArchiveTotals(path) {
     let totals;
     const decoder = new JsonLineDecoder((row) => { totals = codexArchiveTotals([row]) ?? totals; });
@@ -35,6 +39,10 @@ export async function importNativeArchive(input) {
         else {
             if (header?.type !== "session_meta" || header.payload?.id !== input.nativeSessionId)
                 throw new Error("Codex archive identity mismatch");
+            // A leaf archive does not carry its ancestor rollout. Importing it as-is would resume with
+            // silently truncated history; failing lets the caller rebuild from durable cloud Turns.
+            if (header.payload?.history_base != null)
+                throw new ArchiveNotRestorableError("Codex archive references history it does not carry; rebuild from the Session instead");
             header.payload.id = input.id;
             if (header.payload.session_id != null)
                 header.payload.session_id = input.id;

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

@@ -10,13 +10,22 @@ type NativeIpcRequest = {
     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,6 +6,16 @@ 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)
@@ -20,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 = "";
@@ -88,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

@@ -20,6 +20,16 @@ type NativeBinding = {
         sizeBytes: number;
         sha256: string;
     }>;
+    /** After a Codex rollover: the superseded rollout's settled boundary, addressed by rollout id. */
+    ancestor?: {
+        rolloutId: string;
+        throughBytes: number;
+        anchors: Array<{
+            turnId: string;
+            sizeBytes: number;
+            sha256: string;
+        }>;
+    };
 };
 export type NativeTurnReceipt = {
     version: 1;
@@ -35,6 +45,8 @@ export type NativeTurnReceipt = {
     sessionStartedAt?: string;
     origin?: "local_import";
     progress?: NativeTurnProgress;
+    /** Merged lineage order across Codex rollout files. */
+    sequence?: number;
 };
 export type NativeSyncTransport = ArchiveTransport & {
     startNativeTurn?(input: NativeTurnStart, options?: {
@@ -80,12 +92,14 @@ export declare class NativeSyncStore {
     private acknowledgementPath;
     private pendingPath;
     private requestPath;
+    private retryPath;
     private cloudBindingPath;
     binding(): Promise<NativeBinding>;
     private initialize;
     capture(path: string, transcript: NativeTranscript, context?: {
         sessionStartedAt?: string;
         origin?: "local_import";
+        signal?: AbortSignal;
     }): Promise<void>;
     receipts(pendingOnly?: boolean): Promise<NativeTurnReceipt[]>;
     status(): Promise<{