@neta-art/cohub-cli 10.6.0 → 10.8.0

package/dist/runtime/native/sessions.js

@@ -31,7 +31,10 @@ export class NativeSessions {
             if (restored) {
                 // A restored copy is history the server already has, even where it carries no markers.
                 const through = (await readTranscript(restored.path, restored.harness).catch(() => null))?.turns.at(-1)?.key ?? null;
-                this.options.ingest.adopt(restored, input.sessionId, { turnKey: through, turnId: input.context.throughTurnId });
+                if (through)
+                    this.options.ingest.adopt(restored, input.sessionId, { turnKey: through, turnId: input.context.throughTurnId });
+                else
+                    this.options.ingest.adopt(restored, input.sessionId);
                 return { session: restored, resume: "restored" };
             }
         }
@@ -45,6 +48,8 @@ export class NativeSessions {
         const id = randomUUID();
         const raw = join(this.options.root, "native", "restored", `${id}.jsonl`);
         const format = harnessAdapter(input.harness).session.archive;
+        if (!format)
+            throw new ArchiveNotRestorableError(`${input.harness} archives are not restorable`);
         try {
             const restored = await this.options.archives.restore(archive, raw, signal);
             const path = format.target({ id, nativeSessionId: restored.nativeSessionId, cwd: input.cwd });

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

@@ -18,6 +18,8 @@ export type NativeTranscriptTurn = {
     boundaries: Record<number, string>;
     sha256: string;
     result: NativeTurnComplete | null;
+    /** The file itself recorded this Turn's end, so it settles without waiting for a quiet period. */
+    ended?: boolean;
     path?: string;
     rolloutId?: string;
     sequence?: number;
@@ -31,6 +33,14 @@ export type NativeTranscript = {
     lineagePaths?: string[];
     lineageRolloutIds?: string[];
 };
+export type TranscriptLine = {
+    value: JsonRecord;
+    startBytes: number;
+    endBytes: number;
+    sha256: string;
+};
+type Line = TranscriptLine;
+export declare const iso: (value: unknown) => string;
 export declare const NATIVE_MAX_RECORD_BYTES: number;
 export declare const NATIVE_MAX_TRANSCRIPT_BYTES: number;
 export declare const codexSessionsDirectory: () => string;
@@ -50,6 +60,8 @@ export type NativeTranscriptHeader = {
 };
 /** Read exactly the first JSONL record of a stream without re-concatenating per chunk. */
 export declare function readFirstRecord(stream: AsyncIterable<Buffer>): Promise<JsonRecord>;
+/** The first record a format without a header line identifies its session by; `null` when none is found early. */
+export declare function readFirstMatchingRecord(stream: AsyncIterable<Buffer>, match: (value: JsonRecord) => boolean): Promise<JsonRecord | null>;
 /** 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. */
@@ -58,9 +70,16 @@ export declare function codexRolloutBytes(path: string, endBytes: number | null,
 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>;
+type TranscriptLines = {
+    lines: Line[];
+    prefixes: Map<number, string>;
+};
+/** Newline framing with exact byte offsets and rolling checksums; a partial tail stays unparsed. */
+export declare function readTranscriptLines(stream: AsyncIterable<Buffer>): Promise<TranscriptLines>;
 /** Partial trailing records are retried, never parsed or acknowledged as complete. */
 export declare function readNativeTranscript(path: string, harness: "pi" | "codex", options?: {
     settled?: boolean;
     leafId?: string | null;
     signal?: AbortSignal;
 }): Promise<NativeTranscript>;
+export {};

package/dist/runtime/native/transcript.js

@@ -12,7 +12,7 @@ import { codexTokenTotals, codexUsage } from "../codex-usage.js";
 import { record } from "../json-rpc.js";
 const text = (value) => typeof value === "string" ? value : "";
 const list = (value) => Array.isArray(value) ? value : [];
-const iso = (value) => {
+export const iso = (value) => {
     const date = new Date(typeof value === "number" || typeof value === "string" ? value : 0);
     if (!Number.isFinite(date.getTime()))
         throw new Error("Invalid native timestamp");
@@ -22,6 +22,8 @@ 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;
+/** Formats without a header line are searched this far for the record naming the session's project. */
+const NATIVE_HEADER_SCAN_MAX_BYTES = 16 * 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)$/;
@@ -64,6 +66,35 @@ export async function readFirstRecord(stream) {
     }
     throw new Error("Native transcript is empty");
 }
+/** The first record a format without a header line identifies its session by; `null` when none is found early. */
+export async function readFirstMatchingRecord(stream, match) {
+    let fragments = [], scanned = 0;
+    for await (const chunk of stream) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        let start = 0;
+        for (let end = bytes.indexOf(10, start); end >= 0; end = bytes.indexOf(10, start)) {
+            const line = Buffer.concat([...fragments, bytes.subarray(start, end)]);
+            fragments = [];
+            start = end + 1;
+            if (!line.length)
+                continue;
+            let value;
+            try {
+                value = record(JSON.parse(line.toString("utf8")));
+            }
+            catch {
+                return null;
+            }
+            if (match(value))
+                return value;
+        }
+        fragments.push(bytes.subarray(start));
+        scanned += bytes.length;
+        if (scanned > NATIVE_HEADER_SCAN_MAX_BYTES)
+            return null;
+    }
+    return null;
+}
 async function readCodexHeader(path, signal) {
     const value = await readFirstRecord(codexRolloutBytes(path, null, signal));
     const payload = record(value.payload);
@@ -188,7 +219,7 @@ export async function ensurePlainCodexRollout(path, cacheDirectory, signal, maxB
     }
 }
 /** Newline framing with exact byte offsets and rolling checksums; a partial tail stays unparsed. */
-async function readTranscriptLines(stream) {
+export async function readTranscriptLines(stream) {
     const lines = [];
     const prefixes = new Map();
     let fragments = [], pendingBytes = 0, offset = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.6.0",
+  "version": "10.8.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,8 +18,8 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "11.5.0",
-    "@neta-art/generation": "^0.1.39",
+    "@neta-art/cohub": "12.0.0",
+    "@neta-art/generation": "^0.1.40",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",
     "ws": "^8.21.3"