@neta-art/cohub-cli 8.1.0 → 8.2.0

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

@@ -12,6 +12,12 @@ export type NativeTranscriptTurn = {
     boundaries: Record<number, string>;
     sha256: string;
     result: NativeTurnComplete | null;
+    /** Codex lineage: the rollout file this Turn was read from. */
+    path?: string;
+    /** Codex lineage: the rollout id of the file this Turn was read from. */
+    rolloutId?: string;
+    /** Codex lineage: merged order across rollout files. */
+    sequence?: number;
 };
 export type NativeTranscript = {
     nativeSessionId: string;
@@ -19,14 +25,36 @@ export type NativeTranscript = {
     cloudSessionId?: string;
     turns: NativeTranscriptTurn[];
     prefixes: ReadonlyMap<number, string>;
+    /** Codex lineage: every rollout file oldest-to-leaf, including the leaf itself. */
+    lineagePaths?: string[];
+    /** Codex lineage: rollout ids matching `lineagePaths` order. */
+    lineageRolloutIds?: 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<{
+export declare const codexSessionsDirectory: () => string;
+export declare const codexArchivedSessionsDirectory: () => string;
+/** Ordinary rollout names encode one id; reverted threads append `_rollout-id`. */
+export declare function codexRolloutIdOf(fileName: string): string | null;
+export type CodexHistoryBase = {
+    rolloutId: string;
+    endOrdinal: number;
+    endBytes: number;
+};
+export type NativeTranscriptHeader = {
     nativeSessionId: string;
     cwd: string;
-}>;
+    rolloutId?: string;
+    historyBase?: CodexHistoryBase;
+};
+/** 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<NativeTranscriptHeader>;
+/** Raw JSONL bytes of a rollout, transparently decompressing `.zst` and honoring a lineage cutoff. */
+export declare function codexRolloutBytes(path: string, endBytes: number | null, signal?: AbortSignal): AsyncGenerator<Buffer>;
+/** Cache location for a rollout's decompressed copy; shared by capture and archival. */
+export declare function codexRolloutCachePath(source: string, cacheDirectory: string): string;
+/** Archives need plain JSONL bytes; decompress a cold `.zst` rollout into a cache once. */
+export declare function ensurePlainCodexRollout(path: string, cacheDirectory: string, signal?: AbortSignal, maxBytes?: number): Promise<string>;
 /** Partial trailing records are retried, never parsed or acknowledged as complete. */
 export declare function readNativeTranscript(path: string, harness: "pi" | "codex", options?: {
     settled?: boolean;

package/dist/runtime/native-transcript.js

@@ -1,5 +1,11 @@
-import { createReadStream } from "node:fs";
-import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { Transform } from "node:stream";
+import { createHash, randomUUID } from "node:crypto";
+import { link, mkdir, readdir, rm, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { createZstdDecompress } from "node:zlib";
+import { pipeline } from "node:stream/promises";
 import { piContent } from "./harness.js";
 import { codexTokenTotals, codexUsage } from "./codex-usage.js";
 import { record } from "./json-rpc.js";
@@ -11,37 +17,177 @@ const iso = (value) => {
         throw new Error("Invalid native timestamp");
     return date.toISOString();
 };
+const missing = (error) => error?.code === "ENOENT";
 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;
+const CODEX_HISTORY_MAX_DEPTH = 64;
+const CODEX_ROLLOUT_INDEX_TTL_MS = 2_000;
+const CODEX_ROLLOUT_NAME = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([0-9a-f-]{36})(?:_([0-9a-f-]{36}))?\.(?:jsonl|jsonl\.zst)$/;
+const codexHomeDirectory = () => process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+export const codexSessionsDirectory = () => join(codexHomeDirectory(), "sessions");
+export const codexArchivedSessionsDirectory = () => join(codexHomeDirectory(), "archived_sessions");
+/** Ordinary rollout names encode one id; reverted threads append `_rollout-id`. */
+export function codexRolloutIdOf(fileName) {
+    const match = CODEX_ROLLOUT_NAME.exec(fileName);
+    return match ? match[2] ?? match[1] ?? null : null;
+}
+function parseCodexHistoryBase(value) {
+    if (value == null)
+        return undefined;
+    const base = record(value);
+    const rolloutId = text(base.thread_id);
+    const endOrdinal = base.end_ordinal_exclusive, endBytes = base.end_byte_offset;
+    if (!rolloutId || typeof endOrdinal !== "number" || !Number.isSafeInteger(endOrdinal) || endOrdinal < 1
+        || typeof endBytes !== "number" || !Number.isSafeInteger(endBytes) || endBytes < 1)
+        throw new Error("Codex history reference is invalid; retain the original files");
+    return { rolloutId, endOrdinal, endBytes };
+}
+/** Read exactly the first JSONL line of a stream without re-concatenating per chunk. */
+async function readFirstLine(stream) {
+    const chunks = [];
+    let buffered = 0;
+    for await (const chunk of stream) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        chunks.push(bytes);
+        buffered += bytes.length;
+        const newline = bytes.indexOf(10);
+        if (newline >= 0) {
+            const buffer = Buffer.concat(chunks, buffered);
+            // The newline position is chunk-relative; offset it into the concatenated line.
+            const line = buffer.subarray(0, buffered - bytes.length + newline);
+            return record(JSON.parse(line.toString("utf8")));
+        }
+        if (buffered > NATIVE_HEADER_MAX_BYTES)
+            throw new Error("Native session header is too large");
+    }
+    throw new Error("Native transcript is empty");
+}
+async function readCodexHeader(path, signal) {
+    const value = await readFirstLine(codexRolloutBytes(path, null, signal));
+    const payload = record(value.payload);
+    const threadId = text(payload.id), cwd = text(payload.cwd);
+    if (value.type !== "session_meta" || !threadId || !cwd)
+        throw new Error("Invalid native session header");
+    const historyBase = parseCodexHistoryBase(payload.history_base);
+    return { threadId, cwd, ...(historyBase ? { historyBase } : {}) };
+}
 /** 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 (harness === "pi") {
+        const value = await readFirstLine(createReadStream(path, { signal }));
+        if (value.type !== "session" || !text(value.id) || !text(value.cwd))
+            throw new Error("Invalid native session header");
+        return { nativeSessionId: text(value.id), cwd: text(value.cwd) };
+    }
+    const header = await readCodexHeader(path, signal);
+    const rolloutId = codexRolloutIdOf(basename(path)) ?? undefined;
+    return { nativeSessionId: header.threadId, cwd: header.cwd, ...(rolloutId ? { rolloutId } : {}), ...(header.historyBase ? { historyBase: header.historyBase } : {}) };
+}
+let codexRolloutIndexCache = null;
+/** Locate rollout files by id across active and archived storage; plain files win over `.zst`. */
+async function scanCodexRollouts(signal) {
+    const home = codexHomeDirectory();
+    const cached = codexRolloutIndexCache;
+    if (cached && cached.home === home && Date.now() - cached.at < CODEX_ROLLOUT_INDEX_TTL_MS)
+        return cached.index;
+    const index = new Map();
+    for (const root of [codexSessionsDirectory(), codexArchivedSessionsDirectory()]) {
+        const pending = [root];
+        while (pending.length) {
+            signal?.throwIfAborted();
+            const directory = pending.pop();
+            if (!directory)
+                continue;
+            const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+                if (missing(error))
+                    return [];
+                throw error;
+            });
+            for (const entry of entries) {
+                const path = join(directory, entry.name);
+                if (entry.isDirectory())
+                    pending.push(path);
+                else if (entry.isFile()) {
+                    const id = codexRolloutIdOf(entry.name);
+                    if (!id)
+                        continue;
+                    const existing = index.get(id);
+                    if (!existing || (existing.endsWith(".zst") && !path.endsWith(".zst")))
+                        index.set(id, path);
+                }
             }
-            if (buffer.length > NATIVE_HEADER_MAX_BYTES)
-                throw new Error("Native session header is too large");
         }
-        throw new Error("Native transcript is empty");
+    }
+    codexRolloutIndexCache = { at: Date.now(), home, index };
+    return index;
+}
+/** Raw JSONL bytes of a rollout, transparently decompressing `.zst` and honoring a lineage cutoff. */
+export async function* codexRolloutBytes(path, endBytes, signal) {
+    // compose (not pipe) so a source error propagates and early exit destroys both streams.
+    const stream = path.endsWith(".zst")
+        ? createReadStream(path, { signal }).compose(createZstdDecompress())
+        : createReadStream(path, endBytes != null ? { end: endBytes - 1, signal } : { signal });
+    let total = 0, last = -1;
+    for await (const chunk of stream) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        let cut = bytes;
+        if (endBytes != null && total + bytes.length > endBytes)
+            cut = bytes.subarray(0, endBytes - total);
+        if (cut.length) {
+            total += cut.length;
+            last = cut.at(-1) ?? last;
+            yield cut;
+        }
+        if (endBytes != null && total >= endBytes)
+            break;
+    }
+    if (endBytes != null) {
+        if (total < endBytes)
+            throw new Error("Codex history prefix is past the end of its source rollout; retain the original files");
+        if (last !== 10)
+            throw new Error("Codex history prefix does not end at a record boundary; retain the original files");
+    }
+}
+/** Cache location for a rollout's decompressed copy; shared by capture and archival. */
+export function codexRolloutCachePath(source, cacheDirectory) {
+    return join(cacheDirectory, `${createHash("sha256").update(source).digest("hex")}.jsonl`);
+}
+/** Archives need plain JSONL bytes; decompress a cold `.zst` rollout into a cache once. */
+export async function ensurePlainCodexRollout(path, cacheDirectory, signal, maxBytes = NATIVE_MAX_TRANSCRIPT_BYTES) {
+    if (!path.endsWith(".zst"))
+        return path;
+    const target = codexRolloutCachePath(path, cacheDirectory);
+    const exists = async () => await stat(target).then(() => true, (error) => { if (missing(error))
+        return false; throw error; });
+    if (await exists())
+        return target;
+    await mkdir(cacheDirectory, { recursive: true, mode: 0o700 });
+    const temporary = `${target}.${randomUUID()}.tmp`;
+    try {
+        // Bound decompression: a corrupt or hostile archive must not fill the disk.
+        let written = 0;
+        const bounded = new Transform({
+            transform(chunk, _encoding, push) {
+                written += chunk.length;
+                if (written > maxBytes) {
+                    push(new Error("Decompressed rollout exceeds the local limit"));
+                    return;
+                }
+                push(null, chunk);
+            },
+        });
+        await pipeline(createReadStream(path, { signal }), createZstdDecompress(), bounded, createWriteStream(temporary, { flags: "wx", mode: 0o600 }));
+        await link(temporary, target).catch((error) => { if (error.code !== "EEXIST")
+            throw error; });
+        return target;
     }
     finally {
-        stream.destroy();
+        await rm(temporary, { force: true });
     }
 }
-/** Partial trailing records are retried, never parsed or acknowledged as complete. */
-export async function readNativeTranscript(path, harness, options = {}) {
+/** Newline framing with exact byte offsets and rolling checksums; a partial tail stays unparsed. */
+async function readTranscriptLines(stream) {
     const lines = [];
     const prefixes = new Map();
     let fragments = [], pendingBytes = 0, offset = 0;
@@ -57,7 +203,7 @@ export async function readNativeTranscript(path, harness, options = {}) {
         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, { signal: options.signal })) {
+    for await (const chunk of stream) {
         let start = 0;
         for (let end = chunk.indexOf(10); end >= 0; end = chunk.indexOf(10, start)) {
             append(chunk.subarray(start, end + 1));
@@ -84,9 +230,17 @@ export async function readNativeTranscript(path, harness, options = {}) {
         }
         append(chunk.subarray(start));
     }
-    if (!lines.length)
-        throw new Error("Native transcript is empty");
-    return { ...(harness === "pi" ? parsePiTranscript(lines, options) : parseCodexTranscript(lines)), prefixes };
+    return { lines, prefixes };
+}
+/** Partial trailing records are retried, never parsed or acknowledged as complete. */
+export async function readNativeTranscript(path, harness, options = {}) {
+    if (harness === "pi") {
+        const read = await readTranscriptLines(createReadStream(path, { signal: options.signal }));
+        if (!read.lines.length)
+            throw new Error("Native transcript is empty");
+        return { ...parsePiTranscript(read.lines, options), prefixes: read.prefixes };
+    }
+    return await readCodexTranscript(path, options);
 }
 function parsePiTranscript(lines, options) {
     const header = lines[0]?.value ?? {};
@@ -183,13 +337,49 @@ function codexContent(value) {
         return [];
     });
 }
-function parseCodexTranscript(lines) {
+/** Follow `history_base` pointers from a live rollout to its immutable ancestors, oldest first. */
+async function resolveCodexLineage(leafPath, signal) {
+    const segments = [];
+    const visited = new Set();
+    let path = leafPath, endBytes = null, endOrdinal = null;
+    let leafCwd = null;
+    for (;;) {
+        if (segments.length >= CODEX_HISTORY_MAX_DEPTH)
+            throw new Error("Codex history chain is too deep; retain the original files");
+        const header = await readCodexHeader(path, signal);
+        // Every segment of one conversation must belong to the same project: a cross-project
+        // reference would import another workspace's history into this one.
+        if (header.cwd && leafCwd != null && header.cwd !== leafCwd)
+            throw new Error("Codex lineage crosses projects; retain the original files");
+        leafCwd ??= header.cwd;
+        if (!header.historyBase) {
+            // No reference: this file is the whole conversation. Non-canonical names stay readable.
+            segments.push({ path, rolloutId: codexRolloutIdOf(basename(path)) ?? "", threadId: header.threadId, cwd: header.cwd, endBytes, endOrdinal });
+            break;
+        }
+        const rolloutId = codexRolloutIdOf(basename(path));
+        if (!rolloutId)
+            throw new Error("Codex rollout file name is not canonical; retain the original file");
+        if (visited.has(rolloutId))
+            throw new Error("Codex history chain is cyclic; retain the original files");
+        visited.add(rolloutId);
+        segments.push({ path, rolloutId, threadId: header.threadId, cwd: header.cwd, endBytes, endOrdinal });
+        const ancestor = (await scanCodexRollouts(signal)).get(header.historyBase.rolloutId);
+        if (!ancestor)
+            throw new Error(`Codex history source ${header.historyBase.rolloutId} is missing; retain the original files`);
+        path = ancestor;
+        endBytes = header.historyBase.endBytes;
+        endOrdinal = header.historyBase.endOrdinal;
+    }
+    return segments.reverse();
+}
+function parseCodexLines(lines, segment) {
     const header = lines[0]?.value ?? {};
     const metadata = record(header.payload);
     if (header.type !== "session_meta" || !text(metadata.id))
         throw new Error("Invalid Codex session");
-    if (metadata.history_base || metadata.fork_source)
-        throw new Error("Codex history references another rollout; retain the original and materialize its full history first");
+    if (metadata.fork_source != null)
+        throw new Error("Legacy Codex fork source is unsupported; retain the original files");
     const turns = [];
     let current = null;
     let messages = [];
@@ -215,7 +405,7 @@ function parseCodexTranscript(lines) {
         if (entry.type === "event_msg" && ["turn_started", "task_started"].includes(text(payload.type))) {
             if (current)
                 turns.push(current);
-            current = { key: text(payload.turn_id), parentKey: turns.at(-1)?.key ?? null, userContent: [], messages: [], startedAt: iso(entry.timestamp), startBytes: line.startBytes, endBytes: line.endBytes, contentEndBytes: line.endBytes, boundaries: {}, sha256: line.sha256, result: null };
+            current = { key: text(payload.turn_id), parentKey: turns.at(-1)?.key ?? null, userContent: [], messages: [], startedAt: iso(entry.timestamp), startBytes: line.startBytes, endBytes: line.endBytes, contentEndBytes: line.endBytes, boundaries: {}, sha256: line.sha256, result: null, path: segment.path, rolloutId: segment.rolloutId };
             if (!current.key)
                 throw new Error("Codex Turn identity is missing");
             messages = current.messages;
@@ -299,6 +489,7 @@ function parseCodexTranscript(lines) {
             messages = [];
         }
     }
+    const settled = current === null;
     if (current && userFromResponse)
         turns.push(current);
     for (const turn of turns) {
@@ -306,5 +497,72 @@ function parseCodexTranscript(lines) {
         if (last && usageByTurn.has(turn.key))
             last.usage = usageByTurn.get(turn.key);
     }
-    return { nativeSessionId: text(metadata.id), cwd: text(metadata.cwd), cloudSessionId: cloudSessionId || undefined, turns };
+    return { turns, ...(cloudSessionId ? { cloudSessionId } : {}), settled };
+}
+const codexSegmentMemo = new Map();
+// Ancestor prefixes are immutable, so the cache is a pure win; parsed objects inflate in
+// memory several-fold over raw bytes, hence a conservative budget.
+const CODEX_MEMO_MAX_BYTES = 128 * 1024 * 1024;
+/** Ancestors are immutable; only their bounded prefixes are worth caching, bounded by bytes. */
+async function parseCodexSegment(segment, signal) {
+    const cacheable = segment.endBytes != null;
+    const info = cacheable ? await stat(segment.path) : null;
+    const key = `${segment.path}|${segment.endBytes ?? "-"}|${segment.endOrdinal ?? "-"}|${info?.size ?? ""}|${info?.mtimeMs ?? ""}`;
+    const cached = codexSegmentMemo.get(key);
+    if (cached) {
+        // Refresh recency: eviction below must spare the segments still in use.
+        codexSegmentMemo.delete(key);
+        codexSegmentMemo.set(key, cached);
+        return cached;
+    }
+    const read = await readTranscriptLines(codexRolloutBytes(segment.path, segment.endBytes, signal));
+    if (!read.lines.length)
+        throw new Error("Native transcript is empty");
+    const parsed = parseCodexLines(read.lines, segment);
+    // A paginated ancestor stamps every record with its ordinal; the referenced prefix must end
+    // exactly at the ordinal bound. Records without the stamp cannot validate a paginated bound.
+    if (segment.endBytes != null && segment.endOrdinal != null) {
+        const ordinal = read.lines.at(-1)?.value.ordinal;
+        if (typeof ordinal !== "number" || ordinal !== segment.endOrdinal - 1)
+            throw new Error("Codex history ordinal bound does not match the prefix; retain the original files");
+    }
+    const value = { turns: parsed.turns, prefixes: read.prefixes, ...(parsed.cloudSessionId ? { cloudSessionId: parsed.cloudSessionId } : {}), settled: parsed.settled, bytes: segment.endBytes ?? 0 };
+    if (cacheable) {
+        // Evict oldest entries first until the cached bytes stay bounded.
+        let total = [...codexSegmentMemo.values()].reduce((sum, entry) => sum + entry.bytes, 0) + value.bytes;
+        for (const [existing, entry] of codexSegmentMemo) {
+            if (total <= CODEX_MEMO_MAX_BYTES)
+                break;
+            total -= entry.bytes;
+            codexSegmentMemo.delete(existing);
+        }
+        codexSegmentMemo.set(key, value);
+    }
+    return value;
+}
+async function readCodexTranscript(path, options) {
+    const segments = await resolveCodexLineage(path, options.signal);
+    const files = [];
+    let prefixes = new Map();
+    for (const [index, segment] of segments.entries()) {
+        const parsed = await parseCodexSegment(segment, options.signal);
+        // An ancestor contributes exactly its referenced prefix; an in-flight tail would corrupt the boundary.
+        if (index < segments.length - 1 && !parsed.settled)
+            throw new Error("Codex history boundary is not at a completed Turn; retain the original files");
+        files.push({ segment, parsed });
+        if (index === segments.length - 1)
+            prefixes = parsed.prefixes;
+    }
+    const leaf = files.at(-1);
+    if (!leaf)
+        throw new Error("Native transcript is empty");
+    const turns = [];
+    for (const file of files)
+        for (const turn of file.parsed.turns)
+            turns.push({ ...turn, parentKey: turns.at(-1)?.key ?? null, sequence: turns.length });
+    // The leaf's own cloud binding wins; ancestors only matter when the leaf has none (a native
+    // continuation of a previously managed conversation).
+    const cloudSessionId = files.at(-1)?.parsed.cloudSessionId ?? files.map((file) => file.parsed.cloudSessionId).find(Boolean);
+    return { nativeSessionId: leaf.segment.threadId, cwd: leaf.segment.cwd, ...(cloudSessionId ? { cloudSessionId } : {}), turns, prefixes,
+        lineagePaths: files.map((file) => file.segment.path), lineageRolloutIds: files.map((file) => file.segment.rolloutId) };
 }

package/dist/runtime/session-store.js

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { RUNTIME_RECOVERY_BATCH_SIZE, runtimeEventSchema, serializeProjectionRecords } from "@neta-art/cohub";
 import { RuntimeArchiveStore, checksumNativeFile, atomicRuntimeJson as atomicJson } from "./archive-store.js";
-import { importNativeArchive, readCodexArchiveTotals } from "./native-archive.js";
+import { ArchiveNotRestorableError, importNativeArchive, readCodexArchiveTotals } from "./native-archive.js";
 import { serializeDiagnosticError } from "./diagnostics.js";
 import { ProjectionStore, rebindProjectionNativeSession } from "./projection-store.js";
 import { confirmQuiescentProcessGroup } from "./process-group.js";
@@ -441,15 +441,29 @@ export class RuntimeSessionStore {
             projectionVersion: 1, sourceSequence: null, sourceTurnId: null, sourceFingerprint: null,
         };
         if (restore) {
-            try {
-                const restored = await this.archives.restore(archive, rawPath, signal);
-                Object.assign(state, await importNativeArchive({ source: rawPath, target: path, harness: input.harness, nativeSessionId: restored.nativeSessionId, id, cwd, signal }));
-                return { state, resume: "restored" };
-            }
-            catch (error) {
-                signal?.throwIfAborted();
-                this.diagnostics?.log("warn", "archive.restore_failed", { error: serializeDiagnosticError(error) }, { component: "archive" });
-            }
+            // Failed restores keep their raw bytes for diagnosis; remembering the verdict stops a
+            // post-rollover archive from being re-downloaded on every resume when it can never import.
+            const failureMarker = join(this.root, "archives", "restore-failures", `${archive.turnId}.json`);
+            const knownFailure = await readFile(failureMarker, "utf8").then(() => true, (error) => { if (missing(error))
+                return false; throw error; });
+            signal?.throwIfAborted();
+            if (!knownFailure)
+                try {
+                    const restored = await this.archives.restore(archive, rawPath, signal);
+                    Object.assign(state, await importNativeArchive({ source: rawPath, target: path, harness: input.harness, nativeSessionId: restored.nativeSessionId, id, cwd, signal }));
+                    // The imported working copy replaces the staged download; the raw duplicate is no longer needed.
+                    await rm(rawPath, { force: true }).catch(() => undefined);
+                    return { state, resume: "restored" };
+                }
+                catch (error) {
+                    signal?.throwIfAborted();
+                    // Only structurally unrestorable archives get remembered: transient network or disk
+                    // failures must stay retryable on the next resume.
+                    if (error instanceof ArchiveNotRestorableError) {
+                        await atomicJson(failureMarker, { turnId: archive.turnId, failedAt: new Date().toISOString(), error: serializeDiagnosticError(error) }).catch(() => undefined);
+                    }
+                    this.diagnostics?.log("warn", "archive.restore_failed", { error: serializeDiagnosticError(error) }, { component: "archive" });
+                }
         }
         return await this.syncNativeProjection(input, cwd, state, signal);
     }

package/dist/runtime/supervisor.js

@@ -13,7 +13,7 @@ import { RuntimeDiagnostics, serializeDiagnosticError } from "./diagnostics.js";
 import { ownRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
 import { createDiagnosticConsole } from "./presentation.js";
 import { RuntimeSessionStore } from "./session-store.js";
-import { captureNativeSession, flushNativeSessions, nativeWebSocketTransport } from "./native-sync.js";
+import { captureNativeSession, flushNativeSessions, nativeWebSocketTransport, summarizeNativeSyncErrors } from "./native-sync.js";
 import { serveNativeDaemon } from "./native-ipc.js";
 export function sandboxOutputLevel(value, stream) {
     const level = typeof value === "string" ? value.toLowerCase() : "";
@@ -220,29 +220,105 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
             }
         };
         bridgeTask = runBridge();
-        closeNativeDaemon = await serveNativeDaemon({ runtimeRoot: store.root, handle: async (request) => ({
-                store: await captureNativeSession(request),
-            }) });
+        // Native reconciliation is event-driven: captures and channel reconnects wake it, while failures
+        // get bounded exponential retries so idle Runtimes do not scan every few seconds.
+        let nativeWakePending = true;
+        let nativeWake = null;
+        let nativeRetryTimer;
+        let nativeRetryDelay = 1000;
+        const wakeNativeSync = () => {
+            nativeWakePending = true;
+            // A new capture may wake healthy work, but it must not cancel a failed receipt's backoff.
+            if (!nativeRetryTimer) {
+                nativeWake?.();
+                nativeWake = null;
+            }
+        };
+        const waitForNativeWake = async () => {
+            if (nativeWakePending && !nativeRetryTimer) {
+                nativeWakePending = false;
+                return;
+            }
+            await new Promise((resolve) => {
+                const finish = () => {
+                    signal.removeEventListener("abort", finish);
+                    if (nativeWake === finish)
+                        nativeWake = null;
+                    resolve();
+                };
+                nativeWake = finish;
+                signal.addEventListener("abort", finish, { once: true });
+                if (signal.aborted)
+                    finish();
+            });
+            nativeWakePending = false;
+        };
         nativeSyncTask = (async () => {
-            const report = (error) => diagnostics.log("warn", "native.sync_pending", { error: serializeDiagnosticError(error) });
+            let lastFailureLogAt = 0;
+            let failureStartedAt = 0;
+            let accumulatedErrors = [];
             while (!signal.aborted) {
+                await waitForNativeWake();
+                if (signal.aborted)
+                    break;
+                if (!nativeSend)
+                    continue;
+                let failed = false;
+                const cycleErrors = [];
                 try {
-                    if (nativeSend)
-                        await flushNativeSessions(config.spaceId, config.identity, signal, report, nativeWebSocketTransport(config.spaceId, config.identity, nativeSend));
+                    failed = await flushNativeSessions(config.spaceId, config.identity, signal, (error) => cycleErrors.push(error), nativeWebSocketTransport(config.spaceId, config.identity, nativeSend));
                 }
                 catch (error) {
-                    if (!signal.aborted)
-                        report(error);
+                    if (!signal.aborted) {
+                        cycleErrors.push(error);
+                        failed = true;
+                    }
+                }
+                if (cycleErrors.length && !signal.aborted) {
+                    const now = Date.now();
+                    failureStartedAt ||= now;
+                    accumulatedErrors.push(...cycleErrors);
+                    if (!lastFailureLogAt || now - lastFailureLogAt >= 60_000) {
+                        diagnostics.log("warn", "native.sync_pending", {
+                            failedStores: accumulatedErrors.length,
+                            retryInMs: nativeRetryDelay,
+                            errors: summarizeNativeSyncErrors(accumulatedErrors),
+                        });
+                        accumulatedErrors = [];
+                        lastFailureLogAt = now;
+                    }
+                }
+                else if (!signal.aborted && !failed && failureStartedAt) {
+                    diagnostics.log("info", "native.sync_recovered", { durationMs: Date.now() - failureStartedAt });
+                    failureStartedAt = 0;
+                    lastFailureLogAt = 0;
+                    accumulatedErrors = [];
+                }
+                if (failed && !signal.aborted) {
+                    nativeWakePending = false;
+                    if (!nativeRetryTimer)
+                        nativeRetryTimer = setTimeout(() => { nativeRetryTimer = undefined; wakeNativeSync(); }, nativeRetryDelay);
+                    nativeRetryDelay = Math.min(30_000, nativeRetryDelay * 2);
+                }
+                else if (!failed) {
+                    nativeRetryDelay = 1000;
                 }
-                await delay(5000, undefined, { signal }).catch(() => undefined);
             }
+            if (nativeRetryTimer)
+                clearTimeout(nativeRetryTimer);
         })();
+        closeNativeDaemon = await serveNativeDaemon({ runtimeRoot: store.root, handle: async (request) => {
+                const result = { store: await captureNativeSession(request) };
+                if (result.store)
+                    wakeNativeSync();
+                return result;
+            } });
         await serveRuntime({
             spaceId: config.spaceId, cwd: config.root, url: url.toString(), capabilities,
             harnesses: config.executables, runtimeId: status.runtimeId, diagnostics, token, signal, store,
             onReady: () => update({ harnessConnected: true }),
             onDisconnected: () => { nativeSend = null; update({ harnessConnected: false }); },
-            onNativeChannel: (send) => { nativeSend = send; },
+            onNativeChannel: (send) => { nativeSend = send; wakeNativeSync(); },
         });
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "8.1.0",
+  "version": "8.2.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {