@neta-art/cohub-cli 8.2.0 → 8.3.0

package/dist/runtime/session-store.js

@@ -1,601 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { mkdir, open, readFile, readdir, realpath, rename, rm } from "node:fs/promises";
-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 { 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";
-import { readNativeTranscript } from "./native-transcript.js";
-export class ContextRequiredError extends Error {
-}
-/** Reverse lookup for native clients; the existing Runtime state remains authoritative. */
-export async function findRuntimeNativeSession(root, harness, nativeSessionId, path) {
-    const directory = join(root, harness);
-    const names = await readdir(directory).catch((error) => { if (error.code === "ENOENT")
-        return []; throw error; });
-    const matches = [];
-    for (const name of names) {
-        if (!name.endsWith(".json"))
-            continue;
-        const state = JSON.parse(await readFile(join(directory, name), "utf8"));
-        if (state.version === 1 && state.harness === harness && state.nativeSessionId === nativeSessionId)
-            matches.push(state);
-    }
-    if (path && matches.length) {
-        const canonical = await realpath(path);
-        const exact = [];
-        for (const state of matches) {
-            const candidate = await realpath(state.path).catch((error) => { if (error.code === "ENOENT")
-                return null; throw error; });
-            if (candidate === canonical)
-                exact.push(state);
-        }
-        if (exact.length === 1)
-            return exact[0] ?? null;
-    }
-    if (matches.length > 1)
-        throw new Error("Native Session has ambiguous Runtime bindings");
-    return matches[0] ?? null;
-}
-const checksum = (data) => createHash("sha256").update(data).digest("hex");
-const missing = (error) => error?.code === "ENOENT";
-class CaptureUnavailableError extends Error {
-}
-function piSessionDirectory(cwd) {
-    const custom = process.env.PI_CODING_AGENT_SESSION_DIR?.trim();
-    if (custom)
-        return custom;
-    const agentDir = process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
-    const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-    return join(agentDir, "sessions", safePath);
-}
-function codexSessionPath(id) {
-    const timestamp = new Date().toISOString().replace(/\.\d{3}Z$/, "").replaceAll(":", "-");
-    const root = process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
-    return join(root, "sessions", timestamp.slice(0, 4), timestamp.slice(5, 7), timestamp.slice(8, 10), `rollout-${timestamp}-${id}.jsonl`);
-}
-/** Local references are hints validated against actual native files, never cloud existence claims. */
-export class RuntimeSessionStore {
-    root;
-    archives;
-    archiveFlush = null;
-    diagnostics = null;
-    nativeWrites = new Map();
-    projectionStore;
-    constructor(spaceId, options) {
-        this.root = join(options.stateRoot ?? join(homedir(), ".local", "state", "cohub", "runtime"), spaceId);
-        this.archives = new RuntimeArchiveStore(join(this.root, "archives"), options.archiveTransport);
-        this.projectionStore = new ProjectionStore(options.projectionSource);
-    }
-    setDiagnostics(diagnostics) {
-        this.diagnostics = diagnostics;
-        this.archives.setErrorReporter((error, index) => diagnostics.log("warn", "archive.upload_pending", { error: serializeDiagnosticError(error) }, {
-            component: "archive",
-            sessionId: index?.sessionId,
-            turnId: index?.turnId,
-            harness: index?.harness,
-        }));
-    }
-    statePath(input) { return join(this.root, input.harness, `${input.sessionId}.json`); }
-    nativePath(input, nativeSessionId, cwd) {
-        if (input.harness === "pi")
-            return join(piSessionDirectory(cwd), `${nativeSessionId}.jsonl`);
-        return codexSessionPath(nativeSessionId);
-    }
-    async withNativeWrite(path, write) {
-        const previous = this.nativeWrites.get(path) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(write);
-        this.nativeWrites.set(path, current);
-        try {
-            await current;
-        }
-        finally {
-            if (this.nativeWrites.get(path) === current)
-                this.nativeWrites.delete(path);
-        }
-    }
-    async syncParentDirectory(path) {
-        if (process.platform === "win32")
-            return;
-        const directory = await open(dirname(path), "r");
-        try {
-            await directory.sync();
-        }
-        finally {
-            await directory.close();
-        }
-    }
-    async writeNativeFile(path, data) {
-        await this.withNativeWrite(path, async () => {
-            await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-            const temporary = `${path}.${randomUUID()}.projection`;
-            try {
-                const file = await open(temporary, "wx", 0o600);
-                try {
-                    await file.writeFile(data, "utf8");
-                    await file.sync();
-                }
-                finally {
-                    await file.close();
-                }
-                await rename(temporary, path);
-                await this.syncParentDirectory(path);
-            }
-            finally {
-                await rm(temporary, { force: true });
-            }
-        });
-    }
-    async appendNativeFile(path, data, expectedChecksum) {
-        if (!data)
-            return;
-        await this.withNativeWrite(path, async () => {
-            const file = await open(path, "r+", 0o600);
-            try {
-                const bytes = await file.readFile();
-                if (expectedChecksum && checksum(bytes) !== expectedChecksum)
-                    throw new Error("Native session changed outside Cohub; original data was preserved");
-                const prefix = bytes.length > 0 && bytes.at(-1) !== 10 ? "\n" : "";
-                await file.write(`${prefix}${data}`, bytes.length, "utf8");
-                await file.sync();
-            }
-            finally {
-                await file.close();
-            }
-            await this.syncParentDirectory(path);
-        });
-    }
-    async lastNativeRecordId(path) {
-        const file = await open(path, "r");
-        try {
-            let position = (await file.stat()).size;
-            let tail = "";
-            while (position > 0) {
-                const size = Math.min(position, 64 * 1024);
-                position -= size;
-                const chunk = Buffer.alloc(size);
-                await file.read(chunk, 0, size, position);
-                tail = chunk.toString("utf8") + tail;
-                const candidate = tail.trimEnd();
-                const newline = candidate.lastIndexOf("\n");
-                if (newline >= 0) {
-                    const record = JSON.parse(candidate.slice(newline + 1));
-                    return typeof record.id === "string" ? record.id : null;
-                }
-            }
-            const record = JSON.parse(tail.trim());
-            return typeof record.id === "string" ? record.id : null;
-        }
-        finally {
-            await file.close();
-        }
-    }
-    reportProjectionWarnings(input, warnings) {
-        if (warnings.length === 0)
-            return;
-        this.diagnostics?.log("warn", "runtime.projection_loss", { warningCount: warnings.length, warnings: warnings.slice(0, 100), truncated: warnings.length > 100 }, { component: "projection", sessionId: input.sessionId, turnId: input.turnId, harness: input.harness });
-    }
-    async syncNativeProjection(input, cwd, previous, signal) {
-        const existing = previous && (previous.checksum.length > 0 || previous.sourceSequence != null || previous.pendingTurnId != null) ? previous : null;
-        const projection = await this.projectionStore.project({
-            spaceId: input.spaceId,
-            sessionId: input.sessionId,
-            turnId: input.turnId,
-            nativeSessionId: existing?.nativeSessionId ?? randomUUID(),
-            cwd,
-            provider: input.provider,
-            target: input.harness,
-            throughTurnId: input.context.throughTurnId,
-            cursor: existing ? {
-                throughSequence: existing.sourceSequence ?? null,
-                throughTurnId: existing.sourceTurnId ?? null,
-                sourceFingerprint: existing.sourceFingerprint ?? null,
-            } : null,
-        }, signal);
-        if (existing && projection.append && projection.turns.length === 0)
-            return { state: existing, resume: "native" };
-        const replacing = existing !== null && !projection.append;
-        const id = replacing || !existing ? randomUUID() : existing.nativeSessionId;
-        const path = replacing || !existing ? this.nativePath(input, id, cwd) : existing.path;
-        const materialized = replacing ? rebindProjectionNativeSession(projection, id) : projection;
-        this.reportProjectionWarnings(input, materialized.projection.warnings);
-        const turns = materialized.turns;
-        const next = {
-            ...(replacing || !existing ? { version: 1, sessionId: input.sessionId, harness: input.harness, nativeSessionId: id, path, cwd, throughTurnId: null, revision: input.context.revision, checksum: "", pendingTurnId: null } : existing),
-            projectionVersion: 1,
-            nativeSessionId: id,
-            path,
-            cwd,
-            sourceSequence: materialized.cursor.throughSequence,
-            sourceTurnId: materialized.cursor.throughTurnId,
-            sourceFingerprint: materialized.cursor.sourceFingerprint,
-            throughTurnId: input.context.throughTurnId,
-            revision: input.context.revision,
-        };
-        const serialized = serializeProjectionRecords(materialized.projection.records);
-        if (input.harness === "codex" && turns.length === 0 && !existing)
-            return { state: next, resume: "new" };
-        if (materialized.append && existing) {
-            let suffix = serialized;
-            let leafId = existing.nativeLeafId ?? null;
-            if (input.harness === "pi") {
-                leafId = await this.lastNativeRecordId(existing.path);
-                if (leafId) {
-                    let rebound = false;
-                    const records = materialized.projection.records.map((entry) => {
-                        if (rebound || !("parentId" in entry.record))
-                            return entry;
-                        rebound = true;
-                        return { ...entry, record: { ...entry.record, parentId: leafId } };
-                    });
-                    suffix = serializeProjectionRecords(records);
-                }
-            }
-            await this.appendNativeFile(existing.path, suffix, existing.checksum);
-            const projectedLeaf = materialized.projection.records.at(-1)?.record.id;
-            if (typeof projectedLeaf === "string")
-                leafId = projectedLeaf;
-            next.nativeLeafId = leafId;
-        }
-        else {
-            await this.writeNativeFile(path, serialized);
-            const projectedLeaf = materialized.projection.records.at(-1)?.record.id;
-            next.nativeLeafId = typeof projectedLeaf === "string" ? projectedLeaf : null;
-        }
-        next.checksum = await checksumNativeFile(path);
-        if (existing)
-            await atomicJson(this.statePath(next), next);
-        return { state: next, resume: existing ? "handoff" : (turns.length ? "handoff" : "new") };
-    }
-    async *pendingExecutionBatches() {
-        let batch = [];
-        for (const harness of ["pi", "codex"]) {
-            const directory = join(this.root, harness);
-            const names = await readdir(directory).catch((error) => { if (missing(error))
-                return []; throw error; });
-            for (const name of names) {
-                if (!name.endsWith(".json"))
-                    continue;
-                try {
-                    const state = JSON.parse(await readFile(join(directory, name), "utf8"));
-                    if (state.version !== 1 || state.harness !== harness || !state.sessionId || !state.pendingTurnId)
-                        continue;
-                    batch.push({ sessionId: state.sessionId, turnId: state.pendingTurnId, harness });
-                    if (batch.length >= RUNTIME_RECOVERY_BATCH_SIZE) {
-                        yield batch;
-                        batch = [];
-                    }
-                }
-                catch (error) {
-                    this.diagnostics?.log("error", "runtime.session_state_unreadable", { path: join(directory, name), error: serializeDiagnosticError(error) });
-                }
-            }
-        }
-        if (batch.length)
-            yield batch;
-    }
-    async flushArchives(signal) {
-        this.archiveFlush ??= this.flushArchiveOutbox(signal).finally(() => { this.archiveFlush = null; });
-        return this.archiveFlush;
-    }
-    async flushArchiveOutbox(signal) {
-        if (!this.archives.hasTransport && await this.archives.pendingCount() > 0) {
-            this.diagnostics?.log("debug", "archive.transport_absent", { note: "captures stay local" }, { component: "archive" });
-        }
-        const captures = join(this.archives.root, "captures");
-        const names = await readdir(captures).catch((error) => { if (missing(error))
-            return []; throw error; });
-        for (const name of names) {
-            signal.throwIfAborted();
-            if (!name.endsWith(".json"))
-                continue;
-            let receipt;
-            try {
-                receipt = await readFile(join(captures, name), "utf8");
-                let state;
-                try {
-                    state = JSON.parse(receipt);
-                }
-                catch {
-                    throw new CaptureUnavailableError("Invalid capture receipt");
-                }
-                const turnId = state?.archivePendingTurnId;
-                if (typeof turnId !== "string" || typeof state?.path !== "string" || typeof state.resultChecksum !== "string") {
-                    throw new CaptureUnavailableError("Invalid capture receipt");
-                }
-                if (!await this.archives.hasCapture(turnId)) {
-                    const digest = await checksumNativeFile(state.path).catch((error) => {
-                        if (missing(error))
-                            throw new CaptureUnavailableError("Native session missing");
-                        throw error;
-                    });
-                    if (digest !== state.resultChecksum)
-                        throw new CaptureUnavailableError("Native session changed; original files retained");
-                    signal.throwIfAborted();
-                    await this.archives.stage(state, turnId);
-                }
-                await rm(join(captures, name), { force: true });
-            }
-            catch (error) {
-                signal.throwIfAborted();
-                if (error instanceof CaptureUnavailableError && receipt !== undefined) {
-                    // Preserve the exact receipt before retiring it from the retry queue. Never alter native files.
-                    await atomicJson(join(this.archives.root, "failed", "captures", `${name}.${checksum(receipt)}.json`), {
-                        receipt, reason: error.message, failedAt: new Date().toISOString(),
-                    });
-                    await rm(join(captures, name), { force: true });
-                    this.diagnostics?.log("error", "archive.capture_unavailable", { reason: error.message, receipt: true }, { component: "archive" });
-                }
-                else {
-                    this.diagnostics?.log("warn", "archive.capture_pending", { error: serializeDiagnosticError(error) }, { component: "archive" });
-                }
-            }
-        }
-        await this.archives.flush(signal);
-    }
-    async pendingTurnIds(sessionId) {
-        const ids = [];
-        for (const harness of ["pi", "codex"]) {
-            try {
-                const state = JSON.parse(await readFile(this.statePath({ sessionId, harness }), "utf8"));
-                if (state.sessionId !== sessionId || state.harness !== harness)
-                    throw new Error("Local session identity mismatch");
-                if (state.pendingTurnId)
-                    ids.push(state.pendingTurnId);
-            }
-            catch (error) {
-                if (!missing(error))
-                    throw error;
-            }
-        }
-        return ids;
-    }
-    async prepare(input, cwd, signal) {
-        let previous = null;
-        try {
-            previous = JSON.parse(await readFile(this.statePath(input), "utf8"));
-        }
-        catch (error) {
-            if (!missing(error))
-                throw new Error("Local session state is unreadable; original files were preserved", { cause: error });
-        }
-        if (previous) {
-            if (previous.sessionId !== input.sessionId || previous.harness !== input.harness)
-                throw new Error("Local session identity mismatch");
-            const pending = previous.pendingTurnId;
-            if (pending) {
-                const resolved = input.context.resolvedTurnIds?.includes(pending) === true;
-                const settled = input.context.settledTurnIds?.includes(pending) === true;
-                const lostAcknowledgement = Boolean(previous.resultChecksum) && pending === input.context.throughTurnId && pending !== input.turnId;
-                // A human-confirmed stop is authoritative: rebuild from durable history instead of
-                // resuming a native projection whose outcome the server never recorded.
-                const retire = resolved || (settled && !lostAcknowledgement);
-                const nativeChecksum = await checksumNativeFile(previous.path).catch((error) => { if (missing(error))
-                    return null; throw error; });
-                if (previous.resultChecksum && (settled || resolved) && nativeChecksum && nativeChecksum !== previous.resultChecksum) {
-                    throw new Error("Native session changed outside Cohub; original data was preserved");
-                }
-                if (retire) {
-                    // The server reached a terminal state for this turn. Archive the local projection and
-                    // rebuild from durable context; native files are never deleted, so nothing is lost.
-                    const receipt = await readFile(this.resultPath(previous), "utf8").catch((error) => { if (missing(error))
-                        return null; throw error; });
-                    const retired = { state: previous, receipt };
-                    await atomicJson(join(this.root, "retired", `${pending}.${checksum(JSON.stringify(retired))}.json`), retired);
-                    previous = null;
-                }
-                else if (lostAcknowledgement) {
-                    // The server already persisted this turn; only our acknowledgement was lost.
-                    await this.acknowledge(previous, pending, input.context.revision);
-                }
-                else if (input.context.complete === false) {
-                    throw new ContextRequiredError("Server resolution is required for the pending native execution");
-                }
-                else {
-                    throw new Error(`Local turn ${pending} has unconfirmed results; reconcile it before continuing`);
-                }
-            }
-        }
-        if (previous) {
-            const previousPath = previous.path;
-            const canonical = await realpath(previousPath).catch((error) => { if (missing(error))
-                return previousPath; throw error; });
-            const externallyOwned = await readFile(join(this.root, "native-owners", `${checksum(canonical)}.json`), "utf8").then(() => true).catch((error) => { if (missing(error))
-                return false; throw error; });
-            // Interactive clients own their native files, including symlink aliases. Use an independent projection.
-            if (externallyOwned)
-                previous = null;
-        }
-        if (previous) {
-            try {
-                const nativeChecksum = await checksumNativeFile(previous.path);
-                if (nativeChecksum !== previous.checksum) {
-                    this.diagnostics?.log("warn", "runtime.projection_rebuilt", { reason: "native file changed outside Cohub" }, { component: "projection", sessionId: input.sessionId, turnId: input.turnId, harness: input.harness });
-                    return await this.syncNativeProjection(input, cwd, null, signal);
-                }
-                if (previous.archivePendingTurnId) {
-                    await this.archives.stage(previous, previous.archivePendingTurnId);
-                    previous.archivePendingTurnId = undefined;
-                    await atomicJson(this.statePath(previous), previous);
-                }
-                if (input.harness === "codex" && !previous.codexTokenTotals)
-                    previous.codexTokenTotals = await readCodexArchiveTotals(previous.path);
-                return await this.syncNativeProjection(input, cwd, previous?.cwd === cwd ? previous : null, signal);
-            }
-            catch (error) {
-                if (!missing(error))
-                    throw error;
-            }
-        }
-        const id = randomUUID();
-        const path = this.nativePath(input, id, cwd);
-        const archive = input.context.archive;
-        const restore = archive?.harness === input.harness && archive.sessionId === input.sessionId && archive.turnId === input.context.throughTurnId;
-        const rawPath = join(this.root, "archives", "restored", `${id}.jsonl`);
-        const state = {
-            version: 1, harness: input.harness, sessionId: input.sessionId, nativeSessionId: id,
-            path, cwd, throughTurnId: input.context.throughTurnId, revision: input.context.revision, checksum: "", pendingTurnId: null,
-            projectionVersion: 1, sourceSequence: null, sourceTurnId: null, sourceFingerprint: null,
-        };
-        if (restore) {
-            // 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);
-    }
-    async started(state, turnId) { state.pendingTurnId = turnId; state.resultChecksum = undefined; await atomicJson(this.statePath(state), state); }
-    resultPath(state) { return join(this.root, "results", `${state.sessionId}.${state.harness}.json`); }
-    async recordResult(state, requestId, events, options) {
-        if (!state.pendingTurnId)
-            throw new Error("Cannot record a result for an idle native session");
-        if (state.harness === "pi")
-            state.nativeLeafId = await this.lastNativeRecordId(state.path);
-        state.resultChecksum = await checksumNativeFile(state.path);
-        if (state.archivePendingTurnId)
-            await atomicJson(join(this.archives.root, "captures", `${state.archivePendingTurnId}.json`), state);
-        await atomicJson(this.resultPath(state), { requestId, state, events, ...(options?.uncertainCleanup ? { uncertainCleanup: options.uncertainCleanup } : {}) });
-        await atomicJson(this.statePath(state), state);
-    }
-    async recoverResult(input, requestId) {
-        try {
-            const saved = JSON.parse(await readFile(this.resultPath(input), "utf8"));
-            if (saved.state.sessionId !== input.sessionId || saved.state.harness !== input.harness)
-                throw new Error("Runtime result identity mismatch");
-            if (saved.state.pendingTurnId !== input.turnId)
-                return this.reconstructResult(input);
-            if (requestId && saved.requestId != null && saved.requestId !== requestId)
-                throw new Error("Runtime result execution identity mismatch");
-            // A quiescent process group upgrades the receipt to confirmed; a live one stays uncertain.
-            if (saved.uncertainCleanup && !saved.uncertainCleanup.confirmedAt) {
-                if (!(await confirmQuiescentProcessGroup(saved.uncertainCleanup.processGroupId)))
-                    return null;
-                saved.uncertainCleanup.confirmedAt = new Date().toISOString();
-                await atomicJson(this.resultPath(input), saved);
-            }
-            return { state: saved.state, events: saved.events.map((event) => runtimeEventSchema.parse(event)) };
-        }
-        catch (error) {
-            if (missing(error))
-                return this.reconstructResult(input);
-            throw error;
-        }
-    }
-    /**
-     * Receipt-less recovery: the native file is the authority. When a Turn completed but no
-     * receipt survived (a crash between native completion and recordResult), rebuild the
-     * result from transcript bytes appended after the Turn started, without ever rewriting
-     * native data. Anything ambiguous stays unrecovered.
-     */
-    async reconstructResult(input) {
-        const statePath = this.statePath(input);
-        let state;
-        try {
-            state = JSON.parse(await readFile(statePath, "utf8"));
-        }
-        catch (error) {
-            if (missing(error))
-                return null;
-            throw error;
-        }
-        if (state.sessionId !== input.sessionId || state.harness !== input.harness || state.pendingTurnId !== input.turnId)
-            return null;
-        let transcript;
-        try {
-            transcript = await readNativeTranscript(state.path, state.harness, { settled: state.harness === "pi" });
-        }
-        catch {
-            return null;
-        }
-        // The Turn must start at the byte boundary the file had when the Turn began.
-        const boundary = state.checksum
-            ? [...transcript.prefixes].find(([, sha]) => sha === state.checksum)?.[0]
-            : 0;
-        if (boundary === undefined)
-            return null;
-        const turns = transcript.turns.filter((turn) => turn.startBytes >= boundary);
-        const completed = turns.length === 1 ? turns[0] : null;
-        const result = completed?.result ?? null;
-        // An interrupted Turn may still be executing in a surviving native process.
-        if (!completed || !result || result.status === "interrupted")
-            return null;
-        const messages = result.messages.filter((message) => message.content.length);
-        if (!messages.length)
-            return null;
-        const last = messages.at(-1);
-        const asRuntimeMessage = (message, ordinal) => ({
-            ordinal,
-            content: message.content,
-            ...(message.provider != null ? { provider: message.provider } : {}),
-            ...(message.model != null ? { model: message.model } : {}),
-            ...(message.usage != null ? { usage: message.usage } : {}),
-            ...(message.stopReason != null ? { stopReason: message.stopReason } : {}),
-            ...(message.errorMessage != null ? { errorMessage: message.errorMessage } : {}),
-        });
-        const events = messages.slice(0, -1).map((message, index) => ({ type: "message.commit", message: asRuntimeMessage(message, index + 1) }));
-        const archive = await this.archive(state, input.turnId, { component: "recovery", sessionId: input.sessionId, turnId: input.turnId, harness: input.harness }).catch(() => null);
-        const final = { type: "turn.end", message: asRuntimeMessage(last, messages.length), archive, resume: "native" };
-        await this.recordResult(state, null, [...events, final]);
-        this.diagnostics?.log("warn", "runtime.result_reconstructed", {
-            startBytes: completed.startBytes,
-            messageCount: messages.length,
-            status: result.status,
-        }, { component: "recovery", sessionId: input.sessionId, turnId: input.turnId, harness: input.harness });
-        return { state, events: [...events, final] };
-    }
-    async archive(state, turnId, diagnosticContext = {}) {
-        if (!state.path)
-            return null;
-        state.archivePendingTurnId = turnId;
-        try {
-            const reference = await this.archives.stage(state, turnId);
-            state.archivePendingTurnId = undefined;
-            return reference;
-        }
-        catch (error) {
-            this.diagnostics?.log("warn", "archive.capture_failed", { error: serializeDiagnosticError(error) }, { ...diagnosticContext, component: "archive", turnId, harness: state.harness });
-            throw error;
-        }
-    }
-    async acknowledge(state, turnId, revision) {
-        if (state.pendingTurnId !== turnId)
-            throw new Error("Runtime acknowledgement identity mismatch");
-        const currentChecksum = await checksumNativeFile(state.path).catch((error) => { if (missing(error))
-            return state.resultChecksum ?? state.checksum; throw error; });
-        if (state.resultChecksum && currentChecksum !== state.resultChecksum)
-            throw new Error("Native data changed before acknowledgement; files preserved");
-        let sourceSequence = state.sourceSequence ?? null;
-        let sourceTurnId = state.sourceTurnId ?? null;
-        let sourceFingerprint = state.sourceFingerprint ?? null;
-        const projectionCursor = await this.projectionStore.cursorForTurn(state.sessionId, turnId);
-        sourceSequence = projectionCursor.throughSequence;
-        sourceTurnId = projectionCursor.throughTurnId;
-        sourceFingerprint = projectionCursor.sourceFingerprint;
-        const acknowledged = { ...state, checksum: currentChecksum, pendingTurnId: null, resultChecksum: undefined, throughTurnId: turnId, revision, sourceSequence, sourceTurnId, sourceFingerprint };
-        await atomicJson(this.statePath(state), acknowledged);
-        Object.assign(state, acknowledged);
-    }
-}