@neta-art/cohub-cli 8.1.0 → 8.2.0

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

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { mkdir, readFile, readdir, stat, rm } from "node:fs/promises";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { nativeTurnCompleteSchema, nativeTurnStartSchema, nativeTurnProgressSchema, harnessArchiveIndexSchema } from "@neta-art/cohub";
-import { RuntimeArchiveStore, atomicRuntimeJson } from "./archive-store.js";
+import { ArchiveCaptureIntegrityError, RuntimeArchiveStore, atomicRuntimeJson } from "./archive-store.js";
+import { codexRolloutCachePath, codexRolloutIdOf, codexRolloutBytes, ensurePlainCodexRollout } from "./native-transcript.js";
 import { findRuntimeNativeSession } from "./session-store.js";
 import { withRuntimeSpaceBindingsLock } from "./space-binding.js";
 const missing = (error) => error.code === "ENOENT";
@@ -23,6 +24,26 @@ async function readJson(path) {
         throw error;
     }
 }
+/** Whole-Turn archive checkpoints only; native offsets never become cloud fork anchors. */
+function matchAnchor(turn, anchors) {
+    return anchors.filter((anchor) => anchor.sizeBytes >= turn.contentEndBytes && turn.boundaries[anchor.sizeBytes] === anchor.sha256);
+}
+/** Archive checkpoints of one managed session, optionally bounded by a byte prefix. */
+async function collectArchiveAnchors(runtimeRoot, managed, throughBytes = Number.POSITIVE_INFINITY) {
+    const anchors = [];
+    const versions = join(runtimeRoot, "archives", "versions");
+    const names = await readdir(versions).catch((error) => { if (missing(error))
+        return []; throw error; });
+    for (const name of names) {
+        if (!name.endsWith(".json"))
+            continue;
+        const version = harnessArchiveIndexSchema.parse(await readJson(join(versions, name)));
+        if (version.sessionId === managed.sessionId && version.harness === managed.harness && version.nativeSessionId === managed.nativeSessionId && version.sizeBytes <= throughBytes) {
+            anchors.push({ turnId: version.turnId, sizeBytes: version.sizeBytes, sha256: version.sha256 });
+        }
+    }
+    return anchors;
+}
 /** Turn receipts are append-only. Capture never waits for the network; network ACKs live in separate files. */
 export class NativeSyncStore {
     options;
@@ -50,6 +71,7 @@ export class NativeSyncStore {
     acknowledgementPath(id) { return join(this.root, "acknowledged", `${id}.json`); }
     pendingPath(id) { return join(this.root, "pending", `${id}.json`); }
     requestPath(id) { return join(this.root, "requests", `${id}.json`); }
+    retryPath(id) { return join(this.root, "retries", `${id}.json`); }
     cloudBindingPath(id) { return join(this.root, "bindings", `${id}.json`); }
     async binding() {
         const value = await readJson(this.bindingPath());
@@ -57,10 +79,31 @@ export class NativeSyncStore {
             throw new Error("Native binding mismatch");
         return value;
     }
-    async initialize(path, transcript) {
+    async initialize(path, transcript, signal) {
         const existing = await readJson(this.bindingPath());
         if (existing) {
             const binding = await this.binding();
+            // Codex rollover keeps the thread id but moves appends to a fresh rollout that references
+            // the old one as its history base. Follow the reference instead of failing — matched by
+            // rollout id, so archiving or compressing the ancestor still migrates cleanly. When the
+            // previous rollout is the leaf itself (the same file merely moved or compressed), the
+            // byte boundary stays valid: only the path changes.
+            const previousRolloutId = codexRolloutIdOf(basename(binding.path));
+            const lineageRolloutIds = transcript.lineageRolloutIds ?? [];
+            if (binding.path !== path && previousRolloutId && lineageRolloutIds.includes(previousRolloutId)) {
+                const sameRollout = lineageRolloutIds.at(-1) === previousRolloutId;
+                let moved = { ...binding, path };
+                if (!sameRollout) {
+                    // Byte offsets from the old rollout no longer address the new one; the settled
+                    // boundary moves into the ancestor record and the binding restarts at the leaf.
+                    moved = { ...moved, throughBytes: 0, anchors: [] };
+                    if (binding.throughBytes > 0)
+                        moved.ancestor = { rolloutId: previousRolloutId, throughBytes: binding.throughBytes, anchors: binding.anchors };
+                }
+                await atomicRuntimeJson(join(this.options.runtimeRoot, "native-owners", `${hash(path)}.json`), { path, nativeSessionId: binding.nativeSessionId });
+                await atomicRuntimeJson(this.bindingPath(), moved);
+                return moved;
+            }
             if (binding.path !== path)
                 throw new Error("Native path changed; original binding retained");
             return binding;
@@ -71,6 +114,42 @@ export class NativeSyncStore {
         if (managed) {
             if (managed.pendingTurnId)
                 throw new Error("Reconcile the managed Turn before native continuation");
+            // A Codex rollover before the first native capture: the managed projection lives on an
+            // ancestor rollout now. Its byte boundary addresses the ancestor, so express it as the
+            // ancestor record instead of validating it against the new leaf.
+            const managedRolloutId = codexRolloutIdOf(basename(managed.path));
+            const lineageRolloutIds = transcript.lineageRolloutIds ?? [];
+            const managedInLineage = this.options.harness === "codex" && managedRolloutId != null && lineageRolloutIds.slice(0, -1).includes(managedRolloutId);
+            if (managedInLineage && managed.throughTurnId) {
+                anchors.push(...await collectArchiveAnchors(this.options.runtimeRoot, managed));
+                // The managed projection is the whole ancestor rollout: verify its bytes still match the
+                // recorded checksum, measured on the logical JSONL (decompressed when the file is cold).
+                const ancestorIndex = lineageRolloutIds.indexOf(managedRolloutId);
+                const ancestorPath = transcript.lineagePaths?.[ancestorIndex] ?? managed.path;
+                const checksum = createHash("sha256");
+                let ancestorBytes = 0;
+                for await (const bytes of codexRolloutBytes(ancestorPath, null, signal)) {
+                    checksum.update(bytes);
+                    ancestorBytes += bytes.length;
+                }
+                if (!managed.checksum)
+                    throw new Error("Managed rollout has no checksum to validate its settled boundary");
+                if (checksum.digest("hex") !== managed.checksum)
+                    throw new Error("Runtime history prefix changed");
+                // The verified whole-file boundary is a synthetic anchor, mirroring the regular first
+                // binding: trailing records after the last Turn (e.g. usage) make contentEndBytes
+                // undershoot the file size, and matchAnchor resolves through `boundaries`.
+                anchors.push({ turnId: managed.throughTurnId, sizeBytes: ancestorBytes, sha256: managed.checksum });
+                const binding = { version: 1, identity: this.options.identity, spaceId: this.options.spaceId, harness: this.options.harness,
+                    nativeSessionId: transcript.nativeSessionId, instanceKey: this.options.instanceKey, path, originSessionId: nativeStableId(`${this.root}:archive`),
+                    sessionId: managed.sessionId, throughTurnId: managed.throughTurnId, throughBytes: 0, anchors: [],
+                    ancestor: { rolloutId: managedRolloutId, throughBytes: ancestorBytes, anchors } };
+                // Persist like any first binding: the owner marker keeps the managed Runtime out of this
+                // leaf file, and flush/status read binding.json before touching any receipt.
+                await atomicRuntimeJson(join(this.options.runtimeRoot, "native-owners", `${hash(path)}.json`), { path, nativeSessionId: binding.nativeSessionId });
+                await atomicRuntimeJson(this.bindingPath(), binding);
+                return binding;
+            }
             if (managed.throughTurnId) {
                 const index = await readJson(join(this.options.runtimeRoot, "archives", "versions", `${managed.throughTurnId}.json`));
                 if (index) {
@@ -91,17 +170,7 @@ export class NativeSyncStore {
                     throughBytes = (await stat(path)).size;
                     anchors.push({ turnId: managed.throughTurnId, sizeBytes: throughBytes, sha256: managed.checksum });
                 }
-                const versions = join(this.options.runtimeRoot, "archives", "versions");
-                const names = await readdir(versions).catch((error) => { if (missing(error))
-                    return []; throw error; });
-                for (const name of names) {
-                    if (!name.endsWith(".json"))
-                        continue;
-                    const version = harnessArchiveIndexSchema.parse(await readJson(join(versions, name)));
-                    if (version.sessionId === managed.sessionId && version.harness === managed.harness && version.nativeSessionId === managed.nativeSessionId && version.sizeBytes <= throughBytes) {
-                        anchors.push({ turnId: version.turnId, sizeBytes: version.sizeBytes, sha256: version.sha256 });
-                    }
-                }
+                anchors.push(...await collectArchiveAnchors(this.options.runtimeRoot, managed, throughBytes));
             }
         }
         const binding = { version: 1, identity: this.options.identity, spaceId: this.options.spaceId, harness: this.options.harness,
@@ -113,10 +182,11 @@ export class NativeSyncStore {
         return binding;
     }
     async capture(path, transcript, context = {}) {
+        const signal = context.signal;
         if (transcript.nativeSessionId !== this.options.nativeSessionId)
             throw new Error("Native session identity mismatch");
         await withRuntimeSpaceBindingsLock(async () => {
-            const binding = await this.initialize(path, transcript);
+            const binding = await this.initialize(path, transcript, signal);
             if (binding.throughBytes > 0) {
                 const anchor = binding.anchors.find((entry) => entry.sizeBytes === binding.throughBytes);
                 if (!anchor || transcript.prefixes.get(binding.throughBytes) !== anchor.sha256)
@@ -125,10 +195,14 @@ export class NativeSyncStore {
             let parentKey = null;
             let parentCloudTurnId = binding.throughTurnId;
             let knownBoundary = binding.throughBytes === 0;
+            const ancestor = binding.ancestor;
+            const leafRolloutId = transcript.lineageRolloutIds?.at(-1);
             for (const turn of transcript.turns) {
-                if (turn.startBytes < binding.throughBytes) {
-                    // Native offsets only validate whole-Turn archive checkpoints; they never become cloud fork anchors.
-                    const matches = (binding.anchors ?? []).filter((anchor) => anchor.sizeBytes >= turn.contentEndBytes && turn.boundaries[anchor.sizeBytes] === anchor.sha256);
+                // Lineage Turns keep their own rollout's offsets; only Turns from the binding's rollout
+                // (the leaf, however it is now represented on disk) address the binding's byte boundary.
+                const inLeafRollout = !turn.rolloutId || turn.rolloutId === leafRolloutId;
+                if (inLeafRollout && turn.startBytes < binding.throughBytes) {
+                    const matches = matchAnchor(turn, binding.anchors ?? []);
                     if (new Set(matches.map((anchor) => anchor.turnId)).size > 1)
                         throw new Error("Ambiguous Runtime Turn boundary");
                     parentCloudTurnId = matches[0]?.turnId ?? null;
@@ -142,28 +216,65 @@ export class NativeSyncStore {
                     parentKey = null;
                     continue;
                 }
-                if (!parentKey && !knownBoundary)
-                    throw new Error("Native continuation is not at a complete Runtime Turn boundary");
                 const turnId = this.turnId(turn.key);
                 const old = await readJson(this.receiptPath(turnId));
                 if (old?.result) {
                     if (turn.contentEndBytes < (old.contentEndBytes ?? old.endBytes) || JSON.stringify(turn.userContent) !== JSON.stringify(old.userContent) || turn.result && JSON.stringify(nativeTurnCompleteSchema.parse(turn.result)) !== JSON.stringify(old.result)) {
                         throw new Error("Native branch is inside a settled Turn; only whole-Turn forks are supported");
                     }
+                    // Receipts written before lineage support lack the merged order; backfill it from the immutable chain.
+                    if (turn.sequence != null && old.sequence == null)
+                        await atomicRuntimeJson(this.receiptPath(turnId), { ...old, sequence: turn.sequence });
                     parentKey = turn.key;
                     continue;
                 }
+                // After a rollover, ancestor Turns below the superseded rollout's settled boundary are
+                // already durable cloud history (the retained ancestor record); anything above it is
+                // new native work — including Turns whose pending receipts still need finishing.
+                if (ancestor && turn.rolloutId === ancestor.rolloutId && turn.contentEndBytes <= ancestor.throughBytes) {
+                    const matches = matchAnchor(turn, ancestor.anchors);
+                    if (new Set(matches.map((anchor) => anchor.turnId)).size > 1)
+                        throw new Error("Ambiguous Runtime Turn boundary");
+                    parentCloudTurnId = matches[0]?.turnId ?? null;
+                    knownBoundary = matches.length > 0;
+                    parentKey = null;
+                    continue;
+                }
+                if (!parentKey && !knownBoundary)
+                    throw new Error("Native continuation is not at a complete Runtime Turn boundary");
                 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,
+                    ...(turn.sequence != null ? { sequence: turn.sequence } : {}),
                     ...(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");
                 // Capture immutable native bytes before publishing the completed receipt. Subsequent Turns may change the source.
-                if (result)
-                    await this.archives.stage({ sessionId: binding.originSessionId, harness: binding.harness, nativeSessionId: binding.nativeSessionId, path, sizeBytes: turn.endBytes, expectedChecksum: turn.sha256 }, turnId);
+                if (result) {
+                    const cache = join(this.options.runtimeRoot, "native", "cache", "rollouts");
+                    const source = turn.path ?? path;
+                    const state = { sessionId: binding.originSessionId, harness: binding.harness, nativeSessionId: binding.nativeSessionId, sizeBytes: turn.endBytes, expectedChecksum: turn.sha256 };
+                    const stage = async () => this.archives.stage({ ...state, path: await ensurePlainCodexRollout(source, cache, signal) }, turnId);
+                    try {
+                        await stage();
+                    }
+                    catch (error) {
+                        // A corrupted `.zst` cache copy (bad checksum, truncation) is rebuilt once. A
+                        // mismatch against an already-saved index is not a cache problem: that index is
+                        // immutable, so rebuilding would only repeat a full decompression before failing.
+                        if (!source.endsWith(".zst") || !(error instanceof ArchiveCaptureIntegrityError))
+                            throw error;
+                        const savedIndex = await readJson(join(this.archives.root, "versions", `${turnId}.json`)).catch(() => { throw error; });
+                        if (!savedIndex) {
+                            await rm(codexRolloutCachePath(source, cache), { force: true });
+                            await stage();
+                        }
+                        else
+                            throw error;
+                    }
+                }
                 if (JSON.stringify(old) !== JSON.stringify(receipt)) {
                     // The pending index precedes the receipt, so a crash cannot silently strand an unacknowledged Turn.
                     await atomicRuntimeJson(this.pendingPath(turnId), { turnId });
@@ -191,7 +302,7 @@ export class NativeSyncStore {
                 throw new Error("Native receipt is corrupt; original retained");
             receipts.push(receipt);
         }
-        return receipts.sort((a, b) => a.endBytes - b.endBytes || a.turnId.localeCompare(b.turnId));
+        return receipts.sort((a, b) => (a.sequence ?? Infinity) - (b.sequence ?? Infinity) || a.endBytes - b.endBytes || a.turnId.localeCompare(b.turnId));
     }
     async status() {
         const binding = await this.binding();
@@ -224,6 +335,9 @@ export class NativeSyncStore {
                 if (processed.has(receipt.key))
                     return false;
                 processed.add(receipt.key);
+                const retry = await readJson(this.retryPath(receipt.turnId));
+                if (retry && retry.nextAt > Date.now())
+                    return false;
                 let parent = null;
                 if (receipt.parentKey) {
                     const parentId = this.turnId(receipt.parentKey);
@@ -285,6 +399,7 @@ export class NativeSyncStore {
                     throw new Error("Native artifacts are pending; completion replays later");
                 }
                 await rm(backoffPath, { force: true });
+                await rm(this.retryPath(receipt.turnId), { force: true });
                 await atomicRuntimeJson(this.acknowledgementPath(receipt.turnId), remote);
                 await rm(this.pendingPath(receipt.turnId), { force: true });
                 return true;
@@ -296,6 +411,11 @@ export class NativeSyncStore {
                         await visit(receipt);
                     }
                     catch (error) {
+                        const previous = await readJson(this.retryPath(receipt.turnId));
+                        const attempt = Math.min((previous?.attempt ?? 0) + 1, 6);
+                        const base = Math.min(30_000, 1_000 * 2 ** (attempt - 1));
+                        const jitter = base * (0.8 + Math.random() * 0.4);
+                        await atomicRuntimeJson(this.retryPath(receipt.turnId), { attempt, nextAt: Date.now() + Math.round(jitter) });
                         failures.push(error);
                     }
                 }
@@ -303,6 +423,7 @@ export class NativeSyncStore {
             // Resolve Session identities before the archive dependency walk. A fork baseline must not
             // wait for an unrelated parent Session's failed upload. Immutable local versions stay untouched.
             const archivePending = join(this.archives.root, "pending");
+            let archiveBlocked = false;
             const indexes = await readdir(archivePending).catch((error) => { if (missing(error))
                 return []; throw error; });
             for (const name of indexes) {
@@ -311,6 +432,11 @@ export class NativeSyncStore {
                 try {
                     const path = join(archivePending, name);
                     const index = harnessArchiveIndexSchema.parse(await readJson(path));
+                    const retry = await readJson(this.retryPath(index.turnId));
+                    if (retry && retry.nextAt > Date.now()) {
+                        archiveBlocked = true;
+                        continue;
+                    }
                     const resolved = await this.cloudArchive(index);
                     if (JSON.stringify(index) !== JSON.stringify(resolved))
                         await atomicRuntimeJson(path, resolved);
@@ -320,7 +446,8 @@ export class NativeSyncStore {
                 }
             }
             this.archiveFailure = undefined;
-            await this.archives.flush(signal);
+            if (!archiveBlocked)
+                await this.archives.flush(signal);
             if (failures.length)
                 throw failures[0];
             if (this.archiveFailure)

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

@@ -31,6 +31,11 @@ export declare function discoverNativeImportCandidates(root: string, harnesses:
         path: string;
         message: string;
     }[];
+    superseded: {
+        path: string;
+        nativeSessionId: 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>;
@@ -44,7 +49,17 @@ export declare function captureNativeSession(input: {
     leafId?: string | null;
     sessionStartedAt?: string;
     origin?: "local_import";
+    signal?: AbortSignal;
 }): 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 const NATIVE_SYNC_SESSION_CONCURRENCY = 4;
+export declare function runNativeSyncPool<T>(items: readonly T[], concurrency: number, signal: AbortSignal, processItem: (item: T) => Promise<void>): Promise<void>;
+export declare function summarizeNativeSyncErrors(errors: unknown[]): {
+    name: string;
+    message: string;
+    code?: string;
+    status?: number;
+    count: number;
+}[];
+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,12 +1,13 @@
 import { readFile, readdir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { createClient } from "../client.js";
 import { currentIdentityKey } from "../space.js";
 import { canonicalRuntimeRoot, getRuntimeSpaceBinding } from "./space-binding.js";
-import { readNativeTranscript, readNativeTranscriptHeader } from "./native-transcript.js";
+import { readNativeTranscript, readNativeTranscriptHeader, codexSessionsDirectory, codexArchivedSessionsDirectory, codexRolloutIdOf } from "./native-transcript.js";
 import { findRuntimeNativeSession } from "./session-store.js";
 import { listNativeSyncStores, nativeIdentityHash, NativeSyncStore } from "./native-sync-store.js";
+import { serializeDiagnosticError } from "./diagnostics.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) => {
@@ -17,10 +18,11 @@ const piSessionDirectory = (cwd) => {
     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()];
+    // Codex keeps rollouts active or archived, plain or `.zst`-compressed; Pi writes plain JSONL.
+    const pending = harness === "pi" ? [piSessionDirectory(root)] : [codexSessionsDirectory(), codexArchivedSessionsDirectory()];
+    const accepts = harness === "pi" ? (name) => name.endsWith(".jsonl") : (name) => name.endsWith(".jsonl") || name.endsWith(".jsonl.zst");
     const paths = [];
     const errors = [];
     while (pending.length) {
@@ -38,7 +40,7 @@ async function nativeTranscriptPaths(root, harness, signal) {
             const path = join(directory, entry.name);
             if (entry.isDirectory())
                 pending.push(path);
-            else if (entry.isFile() && entry.name.endsWith(".jsonl"))
+            else if (entry.isFile() && accepts(entry.name))
                 paths.push(path);
         }
     }
@@ -48,10 +50,68 @@ async function nativeTranscriptPaths(root, harness, signal) {
 export async function discoverNativeImportCandidates(root, harnesses, options = {}) {
     const candidates = [];
     const errors = [];
+    /** Same-thread rollouts left out of import; they may carry Turns no candidate contains. */
+    const superseded = [];
     for (const harness of harnesses) {
         options.signal?.throwIfAborted();
         const scanned = await nativeTranscriptPaths(root, harness, options.signal);
         errors.push(...scanned.errors);
+        // One rollout chain per thread: every rollout referenced by a same-thread file is
+        // superseded by it (rollover / revert); a parent referenced only from a different thread
+        // (fork) still owns its own Turns and stays importable. Headers are read once and reused.
+        const headers = new Map();
+        const absorbedRollouts = new Set();
+        if (harness === "codex") {
+            // Bounded concurrency: one descriptor per open file across the global Codex sessions tree.
+            let next = 0;
+            const readHeaders = async () => {
+                for (;;) {
+                    const path = scanned.paths[next++];
+                    if (!path)
+                        return;
+                    try {
+                        headers.set(path, await readNativeTranscriptHeader(path, harness, options.signal));
+                    }
+                    catch (error) {
+                        if (options.signal?.aborted)
+                            throw error;
+                        errors.push({ harness, path, message: error instanceof Error ? error.message : String(error) });
+                    }
+                }
+            };
+            await Promise.all(Array.from({ length: Math.min(16, scanned.paths.length) }, readHeaders));
+            const threadByRollout = new Map();
+            for (const header of headers.values())
+                if (header.rolloutId)
+                    threadByRollout.set(header.rolloutId, header.nativeSessionId);
+            for (const header of headers.values()) {
+                const base = header.historyBase;
+                if (base && threadByRollout.get(base.rolloutId) === header.nativeSessionId)
+                    absorbedRollouts.add(base.rolloutId);
+            }
+        }
+        // One candidate per thread: several same-thread rollouts can survive absorption (two
+        // siblings reverting from the same parent). The newest by rollout filename timestamp wins;
+        // the losers are reported, never imported twice under one nativeSessionId.
+        const supersededSiblings = new Set();
+        if (harness === "codex") {
+            const byThread = new Map();
+            for (const [path, header] of headers) {
+                if (absorbedRollouts.has(header.rolloutId ?? ""))
+                    continue;
+                const list = byThread.get(header.nativeSessionId) ?? [];
+                list.push({ path, rolloutId: header.rolloutId ?? "", sortKey: basename(path) });
+                byThread.set(header.nativeSessionId, list);
+            }
+            for (const list of byThread.values()) {
+                if (list.length < 2)
+                    continue;
+                const newest = list.reduce((a, b) => (a.sortKey > b.sortKey ? a : b));
+                for (const sibling of list)
+                    if (sibling !== newest)
+                        supersededSiblings.add(sibling.path);
+            }
+        }
         let start = 0;
         while (start < scanned.paths.length) {
             options.signal?.throwIfAborted();
@@ -60,9 +120,16 @@ export async function discoverNativeImportCandidates(root, harnesses, options =
             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);
+                    // Pre-scan failures are already reported; do not read the header again.
+                    const header = headers.get(path) ?? (harness === "pi" ? await readNativeTranscriptHeader(path, harness, options.signal) : null);
+                    if (!header)
+                        return null;
                     if (await canonicalRuntimeRoot(header.cwd) !== root)
                         return null;
+                    if (header.rolloutId && absorbedRollouts.has(header.rolloutId))
+                        return null;
+                    if (supersededSiblings.has(path))
+                        return { superseded: { path, nativeSessionId: header.nativeSessionId, message: "Superseded by a newer rollout of the same conversation; its Turns are not imported" } };
                     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" } };
@@ -77,10 +144,10 @@ export async function discoverNativeImportCandidates(root, harnesses, options =
                 options.signal?.throwIfAborted();
                 if (!result)
                     continue;
-                if ("error" in result) {
-                    if (result.error)
-                        errors.push(result.error);
-                }
+                if ("superseded" in result)
+                    superseded.push(result.superseded);
+                else if ("error" in result)
+                    errors.push(result.error);
                 else
                     candidates.push(result);
                 options.onProgress?.({ harness, scanned: start + batch.length, candidates: candidates.length });
@@ -88,7 +155,7 @@ export async function discoverNativeImportCandidates(root, harnesses, options =
             start += concurrency;
         }
     }
-    return { candidates, errors };
+    return { candidates, errors, superseded };
 }
 export function nativeArchiveTransport(spaceId, identity) {
     const client = createClient().space(spaceId);
@@ -120,6 +187,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)
@@ -127,7 +198,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;
@@ -135,26 +210,36 @@ 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");
+    // The path stays in the cache key: restored Pi working copies share a native ID but not a file.
     const key = JSON.stringify([identity, space.spaceId, input.harness, transcript.nativeSessionId, path]);
     let store = nativeStores.get(key);
     if (!store) {
         const transport = nativeArchiveTransport(space.spaceId, identity);
+        const lineage = input.harness === "codex" ? transcript.lineageRolloutIds ?? [] : [];
         const candidates = (await listNativeSyncStores(runtimeRoot, space.spaceId, identity, transport))
             .filter((candidate) => candidate.options.harness === input.harness && candidate.options.nativeSessionId === transcript.nativeSessionId);
-        for (const candidate of candidates)
-            if ((await candidate.binding()).path === path) {
+        // A Codex rollover moves appends to a fresh rollout that references the old one: a store
+        // bound anywhere in the new leaf's lineage is the same conversation, so keep using it —
+        // the binding migrates inside capture. Exact-path matches win; lineage matches follow.
+        for (const candidate of candidates) {
+            const binding = await candidate.binding();
+            if (binding.path === path) {
                 store = candidate;
                 break;
             }
+            if (!store && lineage.includes(codexRolloutIdOf(basename(binding.path)) ?? ""))
+                store = candidate;
+        }
         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;
-            if (candidates.length && managedPath !== path)
+            const managedPath = managed ? await canonicalPathOrNull(managed.path) : null;
+            if (candidates.length && managedPath !== path && !(managedPath && lineage.includes(codexRolloutIdOf(basename(managedPath)) ?? "")))
                 throw new Error("Native path changed; original bindings retained");
             // Restored Pi working copies can share a native ID. Existing Cohub sidecars disambiguate them.
             store = new NativeSyncStore({ runtimeRoot, spaceId: space.spaceId, identity, harness: input.harness, nativeSessionId: transcript.nativeSessionId,
@@ -164,7 +249,7 @@ export async function captureNativeSession(input) {
             nativeStores.delete(nativeStores.keys().next().value ?? "");
         nativeStores.set(key, store);
     }
-    await store.capture(path, transcript, { sessionStartedAt: input.sessionStartedAt, origin: input.origin });
+    await store.capture(path, transcript, { sessionStartedAt: input.sessionStartedAt, origin: input.origin, signal: input.signal });
     return store;
 }
 /** The existing Runtime supervisor retries receipts even after the original terminal has exited. */
@@ -178,32 +263,64 @@ export function nativeWebSocketTransport(spaceId, identity, send) {
         heartbeatNativeTurn: async (sessionId, turnId) => await send({ type: "heartbeat", sessionId, turnId }),
     };
 }
+export const NATIVE_SYNC_SESSION_CONCURRENCY = 4;
+export async function runNativeSyncPool(items, concurrency, signal, processItem) {
+    let next = 0;
+    const worker = async () => {
+        while (!signal.aborted) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            await processItem(items[index]);
+        }
+    };
+    const results = await Promise.allSettled(Array.from({ length: Math.min(items.length, Math.max(1, concurrency)) }, worker));
+    const failure = results.find((result) => result.status === "rejected");
+    if (failure)
+        throw failure.reason;
+}
+export function summarizeNativeSyncErrors(errors) {
+    const groups = new Map();
+    for (const error of errors) {
+        const value = serializeDiagnosticError(error);
+        const key = JSON.stringify([value.name, value.code, value.status, value.causeCode, value.message]);
+        const group = groups.get(key);
+        if (group)
+            group.count += 1;
+        else
+            groups.set(key, { name: value.name ?? "Error", message: value.message, ...(value.code ? { code: value.code } : {}), ...(value.status ? { status: value.status } : {}), count: 1 });
+    }
+    return [...groups.values()];
+}
 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);
-    for (const store of stores) {
-        signal.throwIfAborted();
-        const binding = await store.binding();
-        if (!config.harnesses.includes(binding.harness))
-            continue;
+    let failed = false;
+    await runNativeSyncPool(stores, NATIVE_SYNC_SESSION_CONCURRENCY, signal, async (store) => {
         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.
+            signal.throwIfAborted();
+            const binding = await store.binding();
+            if (!config.harnesses.includes(binding.harness))
+                return;
+            // 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;
 }