@neta-art/cohub-cli 10.7.0 → 10.8.1

package/dist/commands/boards/examples.js

@@ -10,9 +10,9 @@ export const BOARD_EXAMPLES = {
         value: {
             board: { title: "Launch plan" },
             items: {
-                title: { type: "text", position: { x: 80, y: 60 }, props: { text: "Launch plan", fontSize: 48, fontWeight: 700 } },
-                note: { type: "text", position: { x: 80, y: 140 }, props: { text: "Ship the beta to ten design partners, then widen.", fontSize: 20, width: 420 } },
-                goal: { type: "shape", position: { x: 600, y: 60 }, size: { width: 240, height: 140 }, style: { stroke: "green", fill: "green", fillOpacity: 0.12, radius: 16 }, props: { text: "Beta in March" } },
+                title: { type: "text", position: { x: 80, y: 60 }, props: { text: "Launch plan", fontSize: 40, fontWeight: 700 } },
+                note: { type: "text", position: { x: 80, y: 128 }, props: { text: "Ship the beta to ten design partners, then widen.", width: 420 } },
+                goal: { type: "shape", position: { x: 600, y: 60 }, size: { width: 200, height: 140 }, style: { stroke: "green", fill: "green", fillOpacity: 0.12, radius: 16 }, props: { text: "Beta in March" } },
             },
         },
     },
@@ -29,14 +29,14 @@ export const BOARD_EXAMPLES = {
         },
     },
     slides: {
-        description: "Frames as slides; children move and clip with their frame.",
+        description: "960×540 frames as slides; children move and clip with their frame.",
         value: {
             items: {
-                s1: { type: "frame", position: { x: 0, y: 0 }, size: { width: 1600, height: 900 }, props: { label: "Intro" } },
-                "s1-title": { type: "text", parent: "s1", position: { x: 120, y: 120 }, props: { text: "Special relativity", fontSize: 96, fontWeight: 700 } },
-                "s1-sub": { type: "text", parent: "s1", position: { x: 120, y: 260 }, props: { text: "Nothing outruns light", fontSize: 40 } },
-                s2: { type: "frame", position: { x: 1800, y: 0 }, size: { width: 1600, height: 900 }, props: { label: "Time dilation" } },
-                "s2-title": { type: "text", parent: "s2", position: { x: 120, y: 120 }, props: { text: "Moving clocks run slow", fontSize: 72, fontWeight: 700 } },
+                s1: { type: "frame", position: { x: 0, y: 0 }, size: { width: 960, height: 540 }, props: { label: "Intro" } },
+                "s1-title": { type: "text", parent: "s1", position: { x: 72, y: 72 }, props: { text: "Special relativity", fontSize: 56, fontWeight: 700 } },
+                "s1-sub": { type: "text", parent: "s1", position: { x: 72, y: 160 }, props: { text: "Nothing outruns light" } },
+                s2: { type: "frame", position: { x: 1080, y: 0 }, size: { width: 960, height: 540 }, props: { label: "Time dilation" } },
+                "s2-title": { type: "text", parent: "s2", position: { x: 72, y: 72 }, props: { text: "Moving clocks run slow", fontSize: 40, fontWeight: 700 } },
             },
         },
     },
@@ -44,12 +44,12 @@ export const BOARD_EXAMPLES = {
         description: "An animated lesson: entrances, a drawn arrow, typed text and camera moves with pause markers.",
         value: {
             items: {
-                s1: { type: "frame", size: { width: 1600, height: 900 }, props: { label: "Length contraction" } },
-                title: { type: "text", parent: "s1", position: { x: 120, y: 100 }, props: { text: "Moving rulers get shorter", fontSize: 72, fontWeight: 700 } },
-                ruler: { type: "shape", parent: "s1", position: { x: 200, y: 420 }, size: { width: 800, height: 60 }, style: { stroke: "blue", fill: "blue", fillOpacity: 0.15 }, props: { text: "1 m" } },
-                caption: { type: "text", parent: "s1", position: { x: 200, y: 560 }, props: { text: "L = L₀ √(1 − v²/c²)", fontSize: 44, font: "serif", reveal: 1 } },
-                motion: { type: "arrow", parent: "s1", style: { stroke: "rose", strokeWidth: 4 }, props: { start: { x: 200, y: 360 }, end: { x: 1000, y: 360 }, label: "v → c" } },
-                glow: { type: "effect", parent: "s1", position: { x: 1050, y: 380 }, size: { width: 160, height: 160 }, style: { fill: "amber" }, props: { kind: "glow" } },
+                s1: { type: "frame", size: { width: 960, height: 540 }, props: { label: "Length contraction" } },
+                title: { type: "text", parent: "s1", position: { x: 72, y: 60 }, props: { text: "Moving rulers get shorter", fontSize: 40, fontWeight: 700 } },
+                ruler: { type: "shape", parent: "s1", position: { x: 120, y: 252 }, size: { width: 480, height: 40 }, style: { stroke: "blue", fill: "blue", fillOpacity: 0.15 }, props: { text: "1 m", fontSize: 16 } },
+                caption: { type: "text", parent: "s1", position: { x: 120, y: 336 }, props: { text: "L = L₀ √(1 − v²/c²)", font: "serif", reveal: 1 } },
+                motion: { type: "arrow", parent: "s1", style: { stroke: "rose", strokeWidth: 3 }, props: { start: { x: 120, y: 216 }, end: { x: 600, y: 216 }, label: "v → c" } },
+                glow: { type: "effect", parent: "s1", position: { x: 630, y: 224 }, size: { width: 96, height: 96 }, style: { fill: "amber" }, props: { kind: "glow" } },
             },
             animations: {
                 lecture: {
@@ -69,7 +69,7 @@ export const BOARD_EXAMPLES = {
         description: "Custom Canvas content; use --module to print scripts/wave.js.",
         value: {
             items: {
-                wave: { type: "custom", position: { x: 0, y: 0 }, size: { width: 640, height: 360 }, script: { src: "scripts/wave.js", params: { amplitude: 60 } } },
+                wave: { type: "custom", position: { x: 0, y: 0 }, size: { width: 480, height: 270 }, script: { src: "scripts/wave.js", params: { amplitude: 48 } } },
             },
         },
     },

package/dist/commands/boards.js

@@ -151,7 +151,7 @@ function registerExportCommand(boards) {
         .requiredOption("-o, --out <file>", "Output file; the extension picks the format. Sequences need %d, e.g. frames/%04d.png")
         .option("--at <time>", "A moment, comma-separated moments, or start:end:step")
         .option("--camera", "Follow the animation camera")
-        .option("--size <widthxheight>", "Camera viewport in pixels", "1600x900")
+        .option("--size <widthxheight>", "Camera output in pixels; frames keep their own size", "1600x900")
         .option("--animation <id>", "Animation the --at times refer to")
         .option("--frame <item-id>", "Export one frame as a page")
         .option("--items <ids>", "Comma-separated item ids")

package/dist/commands/runtime.js

@@ -10,7 +10,6 @@ import { RuntimeArchiveStore } from "../runtime/archive-store.js";
 import { readNativeConfig, runtimeStateRoot, writeNativeConfig } from "../runtime/native/config.js";
 import { MAX_IMPORT_CONCURRENCY, DEFAULT_IMPORT_CONCURRENCY } from "../runtime/native/ingest.js";
 import { installPiExtension, piExtensionState } from "../runtime/native/install.js";
-import { nativeSyncHarnesses } from "../runtime/harnesses/index.js";
 import { controlRuntimeInstance, requestRuntimeInstance, runtimeInstanceDirectory } from "../runtime/instance.js";
 import { atLeastLevel, diagnosticLevels, formatDiagnostic, formatImportProgress, formatNativeSync, printRuntimeSummary } from "../runtime/presentation.js";
 import { readRuntimeDiagnosticEvents, RuntimeDiagnosticReader, runtimeDiagnosticsDirectory, serializeDiagnosticError } from "../runtime/diagnostics.js";
@@ -19,16 +18,6 @@ const reportFailure = (cause) => {
     process.stderr.write(`Runtime failed: ${serializeDiagnosticError(cause).message}\n`);
     process.exitCode = 1;
 };
-const SYNCED = nativeSyncHarnesses(LOCAL_HARNESSES);
-const SYNCED_LABELS = SYNCED.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(" or ");
-/** Native sync and import cover only harnesses whose terminal conversations sync. */
-function parseSyncedHarnesses(values) {
-    const harnesses = parseRuntimeHarnesses(values);
-    const unsynced = harnesses.filter((harness) => !SYNCED.includes(harness));
-    if (unsynced.length)
-        throw new Error(`${unsynced.map((harness) => LOCAL_HARNESS_SPECS[harness].label).join(", ")} conversations do not sync; native sync covers ${SYNCED_LABELS}`);
-    return harnesses;
-}
 const megabytes = (bytes) => `${(bytes / 1024 / 1024).toFixed(1)} MB`;
 /** The bound Space of a directory, with its running Runtime; import and attach act through it. */
 async function boundRuntime(program, dir, space) {
@@ -97,14 +86,14 @@ export function registerRuntime(program) {
     runtime.command("detach")
         .description("Pause native sync; keep all data")
         .option("-s, --space <space>", "Target Space: ID, slug, or username/slug")
-        .option("--harness <name>", `${SYNCED_LABELS}; repeatable`, (value, previous) => [...previous, value], [])
+        .option("--harness <name>", `${LOCAL_HARNESSES.join(", ")}; repeatable`, (value, previous) => [...previous, value], [])
         .option("--json", "JSON output")
         .action(async (options) => {
         try {
             const { identity, spaceId, directory } = await boundRuntime(program, undefined, options.space);
             const stateRoot = runtimeStateRoot(spaceId);
             const config = await readNativeConfig(stateRoot, identity);
-            const paused = options.harness.length ? parseSyncedHarnesses(options.harness) : config?.harnesses ?? SYNCED;
+            const paused = options.harness.length ? parseRuntimeHarnesses(options.harness) : config?.harnesses ?? [...LOCAL_HARNESSES];
             const harnesses = (config?.harnesses ?? []).filter((harness) => !paused.includes(harness));
             if (config)
                 await writeNativeConfig(stateRoot, { ...config, harnesses, codexShared: harnesses.includes("codex") && config.codexShared });
@@ -144,7 +133,7 @@ export function registerRuntime(program) {
                 throw new Error(`Use a concurrency from 1 to ${MAX_IMPORT_CONCURRENCY}`);
             const { spaceId, root, directory } = await boundRuntime(program, dir, options.space);
             // The Runtime does the work, so an import survives this command: Ctrl-C only pauses it.
-            const filter = { harnesses: options.harness.length ? parseSyncedHarnesses(options.harness) : [], ...(options.session ? { nativeSessionId: options.session } : {}) };
+            const filter = { harnesses: options.harness.length ? parseRuntimeHarnesses(options.harness) : [], ...(options.session ? { nativeSessionId: options.session } : {}) };
             const control = async (command, timeoutMs = 60_000) => {
                 const response = await controlRuntimeInstance(directory, "import", { ...filter, command, concurrency }, timeoutMs);
                 if (!response)

package/dist/runtime/connection.js

@@ -4,6 +4,7 @@ import { RUNTIME_MAX_FRAME_BYTES, RUNTIME_PROTOCOL_VERSION, runtimeCommandSchema
 import { describeError } from "../network-error.js";
 import { executeTurn } from "./native/execution.js";
 import { ContextRequiredError } from "./native/results.js";
+import { SizeLimitError } from "./native/transcript.js";
 import { ProcessCleanupUncertainError } from "./process-group.js";
 import { serializeDiagnosticError, } from "./diagnostics.js";
 export async function serveRuntime(options) {
@@ -11,6 +12,11 @@ export async function serveRuntime(options) {
     let backoff = 500;
     let attempt = 0;
     let conflictSince = null;
+    // Executions outlive a single transport so a dropped socket reconnects immediately
+    // instead of waiting for in-flight turns to finish.
+    const executions = new Map();
+    const seen = new Set();
+    const announce = { current: null };
     const uploads = new AbortController();
     const uploadSignal = AbortSignal.any([options.signal, uploads.signal]);
     const log = (level, event, data, context) => options.diagnostics?.log(level, event, data, context);
@@ -33,12 +39,16 @@ export async function serveRuntime(options) {
         while (!options.signal.aborted) {
             attempt += 1;
             let readyAt = 0;
+            const connectStartedAt = Date.now();
             let outcome;
             try {
                 outcome = await connect({
                     ...options,
                     runtimeId,
                     attempt,
+                    executions,
+                    seen,
+                    announce,
                     onReady: () => {
                         readyAt = Date.now();
                         conflictSince = null;
@@ -72,18 +82,40 @@ export async function serveRuntime(options) {
                 attempt: attempt || 1,
                 delayMs: backoff,
                 outcome: outcome.kind,
+                connectedMs: Date.now() - connectStartedAt,
+                readyMs: readyAt ? Date.now() - readyAt : null,
+                activeExecutions: executions.size,
             });
             await delay(backoff / 2 + Math.random() * backoff / 2, undefined, { signal: options.signal }).catch(() => undefined);
             backoff = Math.min(30_000, backoff * 2);
         }
     }
     finally {
+        for (const execution of executions.values())
+            execution.controller.abort();
+        await Promise.allSettled([...executions.values()].map((entry) => entry.promise));
         clearInterval(timer);
         uploads.abort();
         await flush();
         log("info", "runtime.stopped", { runtimeId });
     }
 }
+function frameIdentity(frame) {
+    const value = frame;
+    const event = value?.event;
+    const pick = (input) => typeof input === "string" ? input : undefined;
+    return {
+        frameType: pick(value?.type),
+        requestId: pick(value?.requestId),
+        eventType: pick(event?.type),
+        sessionId: pick(event?.sessionId) ?? pick(event?.input?.sessionId),
+        turnId: pick(event?.turnId) ?? pick(event?.input?.turnId),
+        harness: pick(event?.input?.harness),
+        nativeSessionId: pick(event?.input?.nativeSessionId),
+        turnCount: Array.isArray(event?.input?.turns) ? event.input.turns.length : undefined,
+        turnIds: Array.isArray(event?.input?.turns) ? event.input.turns.slice(0, 10).map((turn) => pick(turn?.turnId)).filter(Boolean) : undefined,
+    };
+}
 function executionContext(connectionId, input) {
     return {
         connectionId,
@@ -112,11 +144,13 @@ async function connect(options) {
     const runtimeUrl = new URL(options.url);
     runtimeUrl.searchParams.set("runtimeId", options.runtimeId);
     const socket = new WebSocket(runtimeUrl.toString());
-    const active = new Map();
-    const seen = new Set();
+    const active = options.executions;
+    const seen = options.seen;
     const disconnected = new AbortController();
     const contexts = new Map();
     let lastHeartbeat = Date.now();
+    let openedAt = 0;
+    let readyAt = 0;
     let connectionId = null;
     let fatal = false;
     let fatalCode = 0;
@@ -137,8 +171,10 @@ async function connect(options) {
         const data = JSON.stringify(frame);
         const bytes = Buffer.byteLength(data);
         if (bytes > RUNTIME_MAX_FRAME_BYTES) {
-            log("error", "runtime.frame_too_large", { bytes, maxBytes: RUNTIME_MAX_FRAME_BYTES }, { connectionId });
-            throw new Error("Runtime frame exceeds transfer limit");
+            const identity = frameIdentity(frame);
+            const execution = identity.requestId ? active.get(identity.requestId) : undefined;
+            log("error", "runtime.frame_too_large", { bytes, maxBytes: RUNTIME_MAX_FRAME_BYTES, ...identity }, execution ? executionContext(connectionId, execution) : { connectionId });
+            throw new SizeLimitError("Runtime frame exceeds transfer limit");
         }
         socket.send(data);
     };
@@ -173,8 +209,13 @@ async function connect(options) {
             log("error", "runtime.heartbeat_timeout", {
                 ageMs: heartbeatAgeMs,
                 activeExecutions: active.size,
+                readyState: socket.readyState,
+                bufferedBytes: socket.bufferedAmount,
             }, { connectionId });
             closeTransport();
+            // A half-open TCP path may never deliver the close event; stop waiting so reconnect can start.
+            if (heartbeatAgeMs > 45_000)
+                handleClose({ code: 1006, reason: "Runtime heartbeat timed out", wasClean: false }, true);
         }
         else if (connectionId) {
             try {
@@ -206,52 +247,108 @@ async function connect(options) {
             });
         }
     }, 10_000);
-    const closed = new Promise((resolve) => {
-        socket.addEventListener("close", (event) => {
-            unauthorized = event.code === 4401;
-            fatal = [4400, 4403].includes(event.code);
-            if (fatal) {
-                fatalCode = event.code;
-                fatalReason = event.reason;
+    const announceHere = (execution) => {
+        try {
+            send({ type: "runtime.recovery", executions: [execution] });
+            log("info", "runtime.detached_result_announced", undefined, executionContext(connectionId, execution));
+        }
+        catch {
+            // The next ready connection reports every pending receipt.
+        }
+    };
+    /** Replays a saved result, or answers explicitly that none is available; never leaves the server waiting. */
+    const replaySaved = async (requestId, input, context, executionRequestId) => {
+        let saved = null;
+        try {
+            saved = await options.executor.results.recover(input, executionRequestId);
+        }
+        catch (error) {
+            log("error", "runtime.recovery_failed", { error: serializeDiagnosticError(error) }, context);
+        }
+        if (saved)
+            for (const event of saved.events)
+                send({ type: "runtime.event", requestId, event });
+        else
+            send({ type: "runtime.event", requestId, event: { type: "turn.error", uncertain: true, message: "Result unavailable; files retained" } });
+    };
+    let closeHandled = false;
+    let resolveClosed = () => { };
+    const closed = new Promise((resolve) => { resolveClosed = resolve; });
+    const handleClose = (event, forced = false) => {
+        if (closeHandled)
+            return;
+        closeHandled = true;
+        unauthorized = event.code === 4401;
+        fatal = [4400, 4403].includes(event.code);
+        if (fatal) {
+            fatalCode = event.code;
+            fatalReason = event.reason;
+        }
+        conflict = event.code === 4409;
+        disconnected.abort();
+        const now = Date.now();
+        log(options.signal.aborted ? "debug" : fatal || conflict ? "error" : "warn", fatal ? "runtime.websocket.rejected" : "runtime.websocket.closed", {
+            code: event.code,
+            reason: event.reason,
+            wasClean: event.wasClean,
+            forced,
+            durationMs: now - connectedAt,
+            openMs: openedAt ? now - openedAt : null,
+            readyMs: readyAt ? now - readyAt : null,
+            lastInboundAgeMs: now - lastHeartbeat,
+            bufferedBytes: socket.bufferedAmount,
+            activeExecutions: active.size,
+            fatal,
+            conflict,
+        }, { connectionId });
+        nativeChannelReady = false;
+        for (const pending of nativePending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error("Runtime native channel disconnected"));
+        }
+        nativePending.clear();
+        options.onDisconnected?.();
+        const executionMustStop = options.signal.aborted || fatal || conflict;
+        if (options.announce.current === announceHere)
+            options.announce.current = null;
+        for (const [requestId, execution] of active) {
+            if (executionMustStop) {
+                log("error", "runtime.execution_transport_invalidated", { code: event.code, reason: event.reason }, executionContext(connectionId, execution));
+                execution.controller.abort();
             }
-            conflict = event.code === 4409;
-            disconnected.abort();
-            log(options.signal.aborted ? "debug" : fatal || conflict ? "error" : "warn", fatal ? "runtime.websocket.rejected" : "runtime.websocket.closed", {
-                code: event.code,
-                reason: event.reason,
-                durationMs: Date.now() - connectedAt,
-                activeExecutions: active.size,
-                fatal,
-                conflict,
-            }, { connectionId });
-            nativeChannelReady = false;
-            for (const pending of nativePending.values()) {
-                clearTimeout(pending.timer);
-                pending.reject(new Error("Runtime native channel disconnected"));
+            else if (execution.recovery) {
+                // The server re-asks on the next connection; a stale waiter must not hold a slot or its request id.
+                execution.controller.abort();
             }
-            nativePending.clear();
-            options.onDisconnected?.();
-            const executionMustStop = options.signal.aborted || fatal || conflict;
-            for (const execution of active.values()) {
-                log(executionMustStop ? "error" : "warn", executionMustStop ? "runtime.execution_transport_invalidated" : "runtime.execution_transport_detached", {
-                    code: event.code,
-                    reason: event.reason,
-                }, executionContext(connectionId, execution));
-                if (executionMustStop)
-                    execution.controller.abort();
+            else if (!execution.detached) {
+                execution.detached = true;
+                log("warn", "runtime.execution_transport_detached", { code: event.code, reason: event.reason }, executionContext(connectionId, execution));
+                // The server may have stopped asking by the time this finishes; a saved result is announced again.
+                void execution.promise.finally(() => {
+                    if (!execution.result || active.get(requestId) !== execution)
+                        return;
+                    options.announce.current?.({ sessionId: execution.sessionId, turnId: execution.turnId, harness: execution.harness });
+                });
             }
-            resolve();
-        }, { once: true });
-    });
+        }
+        resolveClosed();
+    };
+    socket.addEventListener("close", (event) => handleClose(event), { once: true });
     socket.addEventListener("error", (event) => {
-        const detail = event.error;
+        const detail = event;
         log("warn", "runtime.websocket.error", {
             type: event.type,
-            error: serializeDiagnosticError(detail ?? new Error("WebSocket error")),
+            message: typeof detail.message === "string" && detail.message ? detail.message : undefined,
+            readyState: socket.readyState,
+            opened: openedAt > 0,
+            ready: readyAt > 0,
+            lastInboundAgeMs: Date.now() - lastHeartbeat,
+            error: serializeDiagnosticError(detail.error ?? new Error("WebSocket error")),
         }, { connectionId });
         socket.close();
     });
     socket.addEventListener("open", () => {
+        openedAt = Date.now();
         try {
             log("info", "runtime.websocket.open", {
                 attempt: options.attempt,
@@ -289,14 +386,17 @@ async function connect(options) {
                 if (connectionId)
                     throw new Error("Runtime connection identity changed");
                 connectionId = frame.connectionId;
+                readyAt = Date.now();
                 clearTimeout(readyTimer);
                 log("info", "runtime.ready", {
                     connectionId,
-                    durationMs: Date.now() - connectedAt,
+                    durationMs: readyAt - connectedAt,
+                    detachedExecutions: [...active.values()].filter((entry) => entry.detached).length,
                 }, { connectionId });
                 nativeChannelReady = true;
                 options.onNativeChannel?.(sendNative);
                 options.onReady();
+                options.announce.current = announceHere;
                 let recoveryBatch = 0;
                 for await (const executions of options.executor.results.pendingBatches()) {
                     recoveryBatch += 1;
@@ -391,10 +491,7 @@ async function connect(options) {
                     if (previous.sessionId !== identity.sessionId || previous.turnId !== identity.turnId || previous.harness !== identity.harness)
                         throw new Error("Runtime recovery identity changed");
                     await previous.promise;
-                    const saved = await options.executor.results.recover(identity);
-                    if (saved)
-                        for (const event of saved.events)
-                            send({ type: "runtime.event", requestId: frame.requestId, event });
+                    await replaySaved(frame.requestId, identity, context);
                     return;
                 }
                 const running = [...active].find(([, entry]) => entry.turnId === identity.turnId && entry.sessionId === identity.sessionId && entry.harness === identity.harness);
@@ -404,14 +501,26 @@ async function connect(options) {
                     traceContext: frame.traceContext,
                     controller: new AbortController(),
                     promise: Promise.resolve(),
+                    recovery: true,
                 };
                 active.set(frame.requestId, recovery);
                 recovery.promise = (async () => {
                     try {
                         if (running) {
-                            running[1].controller.abort();
-                            await running[1].promise;
-                            active.delete(running[0]);
+                            // A detached execution was not superseded by this host; wait for its result instead of discarding it.
+                            if (running[1].detached) {
+                                log("info", "runtime.recovery_waiting_detached", { runningRequestId: running[0] }, context);
+                                // A recovery the server gave up on must not hold an execution slot until the Turn ends.
+                                const stopped = recovery.controller.signal;
+                                await Promise.race([running[1].promise, new Promise((resolve) => stopped.addEventListener("abort", () => resolve(), { once: true }))]);
+                                stopped.throwIfAborted();
+                            }
+                            else {
+                                running[1].controller.abort();
+                                await running[1].promise;
+                            }
+                            if (active.get(running[0]) === running[1])
+                                active.delete(running[0]);
                         }
                         const saved = await options.executor.results.recover(identity);
                         recovery.controller.signal.throwIfAborted();
@@ -433,7 +542,8 @@ async function connect(options) {
                                 // The next connection can read the same result.
                             }
                         }
-                        active.delete(frame.requestId);
+                        if (active.get(frame.requestId) === recovery)
+                            active.delete(frame.requestId);
                     }
                 })();
                 return;
@@ -449,11 +559,9 @@ async function connect(options) {
             if (previous) {
                 if (previous.sessionId !== frame.input.sessionId || previous.turnId !== frame.input.turnId || previous.harness !== frame.input.harness)
                     throw new Error("Runtime execution identity changed");
+                log("info", "runtime.execution_resumed", { detached: previous.detached === true, settled: Boolean(previous.result) }, executionContext(connectionId, frame.input));
                 await previous.promise;
-                const saved = await options.executor.results.recover(frame.input, frame.requestId);
-                if (saved)
-                    for (const event of saved.events)
-                        send({ type: "runtime.event", requestId: frame.requestId, event });
+                await replaySaved(frame.requestId, frame.input, context, frame.requestId);
                 return;
             }
             const requestContext = async (executionSignal) => {
@@ -601,7 +709,6 @@ async function connect(options) {
         shutdown();
     try {
         await closed;
-        await Promise.allSettled([...active.values()].map((entry) => entry.promise));
     }
     finally {
         clearTimeout(readyTimer);

package/dist/runtime/harnesses/chained-transcript.d.ts

@@ -0,0 +1,24 @@
+import type { ContentBlock, LocalHarness } from "@neta-art/cohub";
+import type { JsonRecord } from "../json-rpc.js";
+import { type NativeTranscriptTurn, type TranscriptLine } from "../native/transcript.js";
+import type { SessionHeader } from "./types.js";
+/**
+ * `<data root>/projects/<project>/<session id>.jsonl`; sub-agent files live in deeper directories. A
+ * subdirectory's project name extends its parent's, so a prefix admits them; the header decides ownership.
+ */
+export declare function projectTranscript(path: string, root: string, project: string): boolean;
+export declare function projectDirectory(path: string, root: string, project: string): boolean;
+/** The session id is the file name; the first record carrying a `cwd` names the project. */
+export declare function chainedSessionHeader(path: string, harness: LocalHarness, signal?: AbortSignal): Promise<SessionHeader | null>;
+export declare function readChainedLines(path: string, signal?: AbortSignal): Promise<{
+    lines: TranscriptLine[];
+    prefixes: Map<number, string>;
+}>;
+/**
+ * The branch ending at the file's last linked record, oldest first. These formats only append, so a
+ * parent is the latest earlier record with that id: a rewound or repeated id never forms a cycle.
+ */
+export declare function chainBranch(lines: TranscriptLine[], id: (value: JsonRecord) => string, parent: (value: JsonRecord) => string): TranscriptLine[];
+export declare function startTurn(line: TranscriptLine, key: string, parentKey: string | null, userContent: ContentBlock[], cloudTurnId: string): NativeTranscriptTurn;
+/** Every branch record extends the Turn's bytes; only conversation records extend its content. */
+export declare function extendTurn(turn: NativeTranscriptTurn, line: TranscriptLine, content: boolean): void;

package/dist/runtime/harnesses/chained-transcript.js

@@ -0,0 +1,62 @@
+import { createReadStream } from "node:fs";
+import { basename, dirname } from "node:path";
+import { iso, readFirstMatchingRecord, readTranscriptLines } from "../native/transcript.js";
+import { text } from "./process.js";
+/**
+ * `<data root>/projects/<project>/<session id>.jsonl`; sub-agent files live in deeper directories. A
+ * subdirectory's project name extends its parent's, so a prefix admits them; the header decides ownership.
+ */
+export function projectTranscript(path, root, project) {
+    return path.endsWith(".jsonl") && projectDirectory(dirname(path), root, project);
+}
+export function projectDirectory(path, root, project) {
+    return dirname(path) === root && basename(path).startsWith(project);
+}
+/** The session id is the file name; the first record carrying a `cwd` names the project. */
+export async function chainedSessionHeader(path, harness, signal) {
+    const value = await readFirstMatchingRecord(createReadStream(path, { signal }), (entry) => Boolean(text(entry.cwd)) && Boolean(text(entry.sessionId)));
+    return value ? { harness, nativeSessionId: basename(path, ".jsonl"), cwd: text(value.cwd), thread: "user" } : null;
+}
+export async function readChainedLines(path, signal) {
+    const read = await readTranscriptLines(createReadStream(path, { signal }));
+    if (!read.lines.length)
+        throw new Error("Native transcript is empty");
+    return read;
+}
+/**
+ * The branch ending at the file's last linked record, oldest first. These formats only append, so a
+ * parent is the latest earlier record with that id: a rewound or repeated id never forms a cycle.
+ */
+export function chainBranch(lines, id, parent) {
+    const latest = new Map();
+    const parents = [];
+    let leaf = -1;
+    lines.forEach((line, index) => {
+        const own = id(line.value);
+        parents[index] = -1;
+        if (!own)
+            return;
+        const before = latest.get(parent(line.value));
+        parents[index] = before ?? -1;
+        latest.set(own, index);
+        leaf = index;
+    });
+    const branch = [];
+    for (let index = leaf; index >= 0; index = parents[index] ?? -1)
+        branch.push(lines[index]);
+    return branch.reverse();
+}
+export function startTurn(line, key, parentKey, userContent, cloudTurnId) {
+    return {
+        key, parentKey, ...(cloudTurnId ? { cloudTurnId } : {}), userContent, messages: [], startedAt: iso(line.value.timestamp),
+        startBytes: line.startBytes, endBytes: line.endBytes, contentEndBytes: line.endBytes, boundaries: {}, sha256: line.sha256, result: null,
+    };
+}
+/** Every branch record extends the Turn's bytes; only conversation records extend its content. */
+export function extendTurn(turn, line, content) {
+    turn.endBytes = line.endBytes;
+    turn.sha256 = line.sha256;
+    turn.boundaries[line.endBytes] = line.sha256;
+    if (content)
+        turn.contentEndBytes = line.endBytes;
+}

package/dist/runtime/harnesses/claude-transcript.d.ts

@@ -0,0 +1,8 @@
+import { type NativeTranscript } from "../native/transcript.js";
+export declare const CLAUDE_REPLY_ENDED: string[];
+/**
+ * Claude Code appends one record per content block, linked by `parentUuid` (`logicalParentUuid`
+ * across a compaction). A Turn starts at a prompt; its tool results and an interruption share the
+ * prompt's `promptId`. Interactive sessions record each end (`turn_duration`), `-p` sessions do not.
+ */
+export declare function readClaudeTranscript(path: string, nativeSessionId: string, signal?: AbortSignal): Promise<NativeTranscript>;