@parcha/agentrun-kernel 0.0.0-stage → 0.1.0-beta.29

package/dist/process/journal.d.ts

@@ -0,0 +1,111 @@
+import { blobStreamName, type DriveContext, readBlobs } from '../kernel/index.js';
+import { type JournalRecord, type TranscriptEntry } from './records.js';
+/**
+ * Records longer than this (as JSON text) go to the blob stream instead of
+ * the log. The log is folded whole on every cold drive and polled by every
+ * viewer, so it should stay lean. The World's own limit is far higher (see
+ * the README, "Payload limits").
+ */
+export declare const DEFAULT_INLINE_MAX_BYTES: number;
+/**
+ * The session's blob stream (harness-world's `blobs.ts`): content-addressed,
+ * append-only, one line per blob (or per piece of one). Shared with the
+ * document-backed workspace, which keeps its large files there.
+ */
+export { blobStreamName, readBlobs };
+export interface NativeJournalOptions {
+    /** Offload records whose JSON text is longer than this. Default `DEFAULT_INLINE_MAX_BYTES`. */
+    inlineMaxBytes?: number;
+    /**
+     * Called once, with the error, when a batch write fails or is refused.
+     * Default: `ctx.halt(err)`, which stops the drive (and so kills the child
+     * a `ProcessHost` spawned with `ctx.signal`).
+     */
+    onPoison?: (err: unknown) => void;
+    /** Characters per blob chunk. Default 2M. */
+    blobPieceChars?: number;
+}
+/**
+ * The writer (and reader) of a process harness's native journal, for one drive.
+ *
+ * `append` queues a record; the journal keeps one batch in flight and
+ * commits everything queued behind it as the next batch (group commit), one
+ * record-only effect `journal:<n>` per batch. `flush()` is the barrier: it
+ * resolves once every record appended before it is committed. Call it before
+ * a `replay: 'never'` tool runs (the tool bridge's `beforeNever`) and at the
+ * end of a turn.
+ *
+ * Under run-ahead durability (`DriverOptions.runAhead`) a batch is issued,
+ * not yet durable, when its effect returns; the kernel waits for it at its
+ * own barriers (before a `never` effect, before the drive goes idle), so
+ * `flush()` before a `never` tool still means "in the log before the tool".
+ *
+ * The journal's writes are in-band writes of the drive: they go through
+ * `ctx.effect`, so the writer fence (once a newer drive opens the session,
+ * this drive's writes are refused: a `Restart`), first-writer-wins per key and the
+ * outcome rules apply. A failed or refused write poisons the journal
+ * (`append` becomes a no-op, `flush` rejects) and halts the drive. So does a
+ * batch number another writer took first (two drives of one session, the
+ * other's batch already in this drive's fold, where `ctx.effect` would hand
+ * back its result as if it were this batch's): that is a `Restart`, and the
+ * drive rebuilds from the log instead of losing the batch's records.
+ */
+export declare class NativeJournal {
+    private readonly ctx;
+    private readonly inlineMax;
+    private readonly onPoison;
+    private readonly pieceChars;
+    /** The next batch number. */
+    private n;
+    /** Next position per stream (log plus queue). */
+    private readonly next;
+    /** Record ids in the log or queued. */
+    private readonly ids;
+    /** Blobs known to be in the blob stream. */
+    private readonly blobs;
+    private queue;
+    private inflight;
+    private appended;
+    private written;
+    private waiters;
+    private failure;
+    /** This writer, in each batch's output: a batch is this journal's only if it says so. */
+    private readonly writer;
+    constructor(ctx: DriveContext, options?: NativeJournalOptions);
+    /** The error that poisoned this journal, if one did. */
+    get poisoned(): unknown;
+    /** How many records `stream` has (committed plus queued). */
+    length(stream: string): number;
+    /** Whether a record with this id is in the log or queued. */
+    has(id: string): boolean;
+    /**
+     * Queue a record (a JSON value) on `stream`. Returns `false` when it was
+     * not queued: a record with the same `id` is already in the log or queued
+     * (dedupe), or the journal is poisoned.
+     */
+    append(stream: string, data: unknown, options?: {
+        id?: string;
+    }): boolean;
+    /** Append an entry to the normalized transcript. */
+    message(entry: TranscriptEntry): boolean;
+    /** Resolves once every record appended so far is committed; rejects if the journal is poisoned. */
+    flush(): Promise<void>;
+    /** The records of `stream` (or every stream) in the log, in order. Offloaded ones have `data: undefined`. */
+    records<T = unknown>(stream?: string): JournalRecord<T>[];
+    /** The same records with their blobs read back from the blob stream and checked against their hashes. */
+    read<T = unknown>(stream?: string): Promise<JournalRecord<T>[]>;
+    private pump;
+    private settleWaiters;
+    private poison;
+    private write;
+    /** A record as the batch stores it: inline, or offloaded to the blob stream (written before the batch). */
+    private store;
+}
+/**
+ * Read a session's journal with offloaded records resolved: the blob stream
+ * is read once and every blob is checked against its hash. A blob the log
+ * names but the stream does not hold is `Fatal` (the batch commits only
+ * after its blobs are written, so the session cannot continue); a read that
+ * fails is thrown as it is (the delivery is retried).
+ */
+export declare function readJournal<T = unknown>(ctx: Pick<DriveContext, 'world' | 'runId' | 'state'>, stream?: string): Promise<JournalRecord<T>[]>;

package/dist/process/journal.js

@@ -0,0 +1,232 @@
+// Copyright 2026 Vercel Inc. Licensed under the Apache License, Version 2.0; see LICENSE in this package.
+// From github.com/vercel-labs/durable-harness, packages/harness-process/src/journal.ts at ea8aa4060c (UPSTREAM.json records its blob and sha256).
+// Changed by Parcha, imports rewritten for AgentRun; patches: 002-message-prefix, 004-comments-name-the-session-writer
+import { randomUUID } from 'node:crypto';
+import { BLOB_PIECE_CHARS, blobStreamName, Fatal, readBlobs, Restart, sha256Hex, writeBlob } from '../kernel/index.js';
+import { JOURNAL, journalBatches, journalKey, journalRecords, TRANSCRIPT, } from './records.js';
+/**
+ * Records longer than this (as JSON text) go to the blob stream instead of
+ * the log. The log is folded whole on every cold drive and polled by every
+ * viewer, so it should stay lean. The World's own limit is far higher (see
+ * the README, "Payload limits").
+ */
+export const DEFAULT_INLINE_MAX_BYTES = 32 * 1024;
+/**
+ * The session's blob stream (harness-world's `blobs.ts`): content-addressed,
+ * append-only, one line per blob (or per piece of one). Shared with the
+ * document-backed workspace, which keeps its large files there.
+ */
+export { blobStreamName, readBlobs };
+const encoder = new TextEncoder();
+/**
+ * The writer (and reader) of a process harness's native journal, for one drive.
+ *
+ * `append` queues a record; the journal keeps one batch in flight and
+ * commits everything queued behind it as the next batch (group commit), one
+ * record-only effect `journal:<n>` per batch. `flush()` is the barrier: it
+ * resolves once every record appended before it is committed. Call it before
+ * a `replay: 'never'` tool runs (the tool bridge's `beforeNever`) and at the
+ * end of a turn.
+ *
+ * Under run-ahead durability (`DriverOptions.runAhead`) a batch is issued,
+ * not yet durable, when its effect returns; the kernel waits for it at its
+ * own barriers (before a `never` effect, before the drive goes idle), so
+ * `flush()` before a `never` tool still means "in the log before the tool".
+ *
+ * The journal's writes are in-band writes of the drive: they go through
+ * `ctx.effect`, so the writer fence (once a newer drive opens the session,
+ * this drive's writes are refused: a `Restart`), first-writer-wins per key and the
+ * outcome rules apply. A failed or refused write poisons the journal
+ * (`append` becomes a no-op, `flush` rejects) and halts the drive. So does a
+ * batch number another writer took first (two drives of one session, the
+ * other's batch already in this drive's fold, where `ctx.effect` would hand
+ * back its result as if it were this batch's): that is a `Restart`, and the
+ * drive rebuilds from the log instead of losing the batch's records.
+ */
+export class NativeJournal {
+    ctx;
+    inlineMax;
+    onPoison;
+    pieceChars;
+    /** The next batch number. */
+    n;
+    /** Next position per stream (log plus queue). */
+    next = new Map();
+    /** Record ids in the log or queued. */
+    ids = new Set();
+    /** Blobs known to be in the blob stream. */
+    blobs = new Set();
+    queue = [];
+    inflight;
+    appended = 0;
+    written = 0;
+    waiters = [];
+    failure;
+    /** This writer, in each batch's output: a batch is this journal's only if it says so. */
+    writer = randomUUID();
+    constructor(ctx, options = {}) {
+        this.ctx = ctx;
+        this.inlineMax = options.inlineMaxBytes ?? DEFAULT_INLINE_MAX_BYTES;
+        this.onPoison = options.onPoison ?? ((err) => ctx.halt?.(err));
+        this.pieceChars = options.blobPieceChars ?? BLOB_PIECE_CHARS;
+        const state = ctx.state();
+        this.n = journalBatches(state).length;
+        for (const r of journalRecords(state)) {
+            this.next.set(r.stream, r.seq + 1);
+            if (r.id !== undefined)
+                this.ids.add(r.id);
+            if (r.blob)
+                this.blobs.add(r.blob);
+        }
+    }
+    /** The error that poisoned this journal, if one did. */
+    get poisoned() {
+        return this.failure?.err;
+    }
+    /** How many records `stream` has (committed plus queued). */
+    length(stream) {
+        return this.next.get(stream) ?? 0;
+    }
+    /** Whether a record with this id is in the log or queued. */
+    has(id) {
+        return this.ids.has(id);
+    }
+    /**
+     * Queue a record (a JSON value) on `stream`. Returns `false` when it was
+     * not queued: a record with the same `id` is already in the log or queued
+     * (dedupe), or the journal is poisoned.
+     */
+    append(stream, data, options = {}) {
+        if (this.failure)
+            return false;
+        if (options.id !== undefined) {
+            if (this.ids.has(options.id))
+                return false;
+            this.ids.add(options.id);
+        }
+        const seq = this.next.get(stream) ?? 0;
+        this.next.set(stream, seq + 1);
+        this.queue.push({ stream, seq, data, ...(options.id !== undefined ? { id: options.id } : {}) });
+        this.appended++;
+        this.pump();
+        return true;
+    }
+    /** Append an entry to the normalized transcript. */
+    message(entry) {
+        return this.append(TRANSCRIPT, entry);
+    }
+    /** Resolves once every record appended so far is committed; rejects if the journal is poisoned. */
+    flush() {
+        if (this.failure)
+            return Promise.reject(this.failure.err);
+        if (this.written >= this.appended)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => this.waiters.push({ target: this.appended, resolve, reject }));
+    }
+    /** The records of `stream` (or every stream) in the log, in order. Offloaded ones have `data: undefined`. */
+    records(stream) {
+        return journalRecords(this.ctx.state(), stream);
+    }
+    /** The same records with their blobs read back from the blob stream and checked against their hashes. */
+    read(stream) {
+        return readJournal(this.ctx, stream);
+    }
+    pump() {
+        if (this.inflight)
+            return;
+        this.inflight = (async () => {
+            // Let a synchronous burst of appends ride in one batch.
+            await Promise.resolve();
+            while (this.queue.length > 0 && !this.failure) {
+                const batch = this.queue;
+                this.queue = [];
+                try {
+                    await this.write(batch);
+                }
+                catch (err) {
+                    this.poison(err);
+                    return;
+                }
+                this.written += batch.length;
+                this.settleWaiters();
+            }
+        })().finally(() => {
+            this.inflight = undefined;
+            if (this.queue.length > 0 && !this.failure)
+                this.pump();
+        });
+    }
+    settleWaiters() {
+        const still = [];
+        for (const w of this.waiters) {
+            if (this.written >= w.target)
+                w.resolve();
+            else
+                still.push(w);
+        }
+        this.waiters = still;
+    }
+    poison(err) {
+        if (this.failure)
+            return;
+        this.failure = { err };
+        this.queue = [];
+        for (const w of this.waiters.splice(0))
+            w.reject(err);
+        this.onPoison(err);
+    }
+    async write(queued) {
+        const streams = {};
+        for (const q of queued) {
+            const part = (streams[q.stream] ??= { from: q.seq, entries: [] });
+            part.entries.push(await this.store(q));
+        }
+        const n = this.n;
+        const batch = { v: 1, n, streams };
+        const writer = this.writer;
+        const out = await this.ctx.effect(journalKey(n), { name: JOURNAL, replay: 'safe', input: batch }, async () => ({ n, records: queued.length, writer }));
+        if (out?.writer !== writer)
+            throw new Restart(`agentrun-kernel: journal batch ${n} was written by another drive`);
+        this.n = n + 1;
+    }
+    /** A record as the batch stores it: inline, or offloaded to the blob stream (written before the batch). */
+    async store(q) {
+        const id = q.id !== undefined ? { id: q.id } : {};
+        // The transcript is what UIs read from the fold: it always stays inline.
+        if (q.stream === TRANSCRIPT)
+            return { ...id, data: q.data };
+        const text = JSON.stringify(q.data);
+        if (text === undefined)
+            throw new TypeError(`agentrun-kernel: journal record on ${q.stream} is not JSON`);
+        const bytes = encoder.encode(text).length;
+        if (bytes <= this.inlineMax)
+            return { ...id, data: q.data };
+        const hash = await sha256Hex(text);
+        if (!this.blobs.has(hash)) {
+            await writeBlob(this.ctx.world, this.ctx.runId, text, { hash, pieceChars: this.pieceChars });
+            this.blobs.add(hash);
+        }
+        return { ...id, blob: hash, bytes };
+    }
+}
+/**
+ * Read a session's journal with offloaded records resolved: the blob stream
+ * is read once and every blob is checked against its hash. A blob the log
+ * names but the stream does not hold is `Fatal` (the batch commits only
+ * after its blobs are written, so the session cannot continue); a read that
+ * fails is thrown as it is (the delivery is retried).
+ */
+export async function readJournal(ctx, stream) {
+    const records = journalRecords(ctx.state(), stream);
+    if (!records.some((r) => r.blob))
+        return records;
+    const blobs = await readBlobs(ctx.world, ctx.runId);
+    return records.map((r) => {
+        if (!r.blob)
+            return r;
+        const text = blobs.get(r.blob);
+        if (text === undefined)
+            throw new Fatal(`agentrun-kernel: journal blob ${r.blob} (${r.stream} #${r.seq}) is missing from ${blobStreamName(ctx.runId)}`);
+        return { ...r, data: JSON.parse(text) };
+    });
+}

package/dist/process/records.d.ts

@@ -0,0 +1,143 @@
+import type { EffectRecord, SessionState } from '../kernel/index.js';
+/**
+ * The shape of a process harness's records in the run's log, and the pure
+ * readers for it. No Node imports: UIs (the demo's transcript, in a browser
+ * tab) read sessions with this module.
+ *
+ * A process harness mirrors its native session state (Codex's rollout) into
+ * the log as **journal batches**: record-only effects named `journal`, keyed
+ * `journal:<n>`, each carrying the records appended since the last batch,
+ * grouped by stream. The kernel's rules make the batches linear: the first
+ * committed step per key wins, a stale driver's step is fenced (its writer is
+ * refused once a newer drive opens the session), and a batch
+ * counts only once its outcome is committed. Every reader, the writer
+ * included, sees the same records in the same order.
+ *
+ * Next to its native streams, every process harness writes one normalized
+ * stream, `transcript` (`TranscriptEntry`), so one view renders any of them.
+ */
+/** The effect name of every journal batch (`step//harness-world//journal` in dashboards). */
+export declare const JOURNAL = "journal";
+/** The normalized transcript's stream name. */
+export declare const TRANSCRIPT = "transcript";
+/** The memo key of batch `n`. */
+export declare const journalKey: (n: number) => string;
+/**
+ * One record as a batch stores it: its JSON value inline (`data`), or, when
+ * it is large, the SHA-256 of its JSON text (`blob`), whose bytes are in the
+ * session's blob stream (see `NativeJournal`).
+ */
+export interface StoredEntry {
+    /** The harness's own id for the record, if it has one (dedupe). */
+    id?: string;
+    data?: unknown;
+    blob?: string;
+    /** Length of the offloaded JSON text. */
+    bytes?: number;
+}
+/** A `journal` effect's input. */
+export interface JournalBatch {
+    v: 1;
+    /** This batch's number: it is the `n`-th accepted batch of the session. */
+    n: number;
+    /** Records per stream, with the stream position of the first. */
+    streams: Record<string, {
+        from: number;
+        entries: StoredEntry[];
+    }>;
+}
+/** A record read back from the log. */
+export interface JournalRecord<T = unknown> {
+    stream: string;
+    /** 0-based position in its stream. */
+    seq: number;
+    id?: string;
+    /** The record. `undefined` for an offloaded one read here; `NativeJournal.read` resolves blobs. */
+    data: T;
+    blob?: string;
+    /** The batch it arrived in. */
+    batch: number;
+    stepId: string;
+    /** The batch's index in `SessionState.effectOrder` (to relate records to other effects). */
+    at: number;
+}
+/** A tool call an assistant message made. Its effect is `tool:<id>` (see `toolBridge`). */
+export interface TranscriptToolCall {
+    id: string;
+    name: string;
+}
+/**
+ * The normalized transcript. User prompts are not here: they appear through
+ * the submissions the harness placed (`placeSubmissions`). What is here:
+ *
+ * - `message` / `assistant`: the model's text, and the tool calls it made
+ *   (their inputs and results are the tool effects themselves);
+ * - `message` / `user` with `synthetic`: a message the harness sent itself,
+ *   such as a recovery note;
+ * - `turn`: a turn boundary. A turn is open from the first placement after
+ *   the last `turn` entry until the next one.
+ */
+export type TranscriptEntry = {
+    type: 'message';
+    role: 'assistant';
+    text: string;
+    toolCalls?: TranscriptToolCall[];
+} | {
+    type: 'message';
+    role: 'user';
+    text: string;
+    synthetic: string;
+} | {
+    type: 'turn';
+    status: 'completed' | 'failed' | 'interrupted';
+    error?: string;
+};
+export interface BatchRef {
+    batch: JournalBatch;
+    record: EffectRecord;
+    /** Index in `effectOrder`. */
+    at: number;
+}
+/**
+ * The accepted batches, in order: `journal:0`, `journal:1`, ... up to the
+ * first that has no committed outcome. A batch whose intent landed but whose
+ * outcome did not (its writer died between the two writes) does not count;
+ * the next writer reuses its key.
+ */
+export declare function journalBatches(state: SessionState): BatchRef[];
+/** Every record of `stream` (or of every stream), in log order. Offloaded records have `data: undefined`. */
+export declare function journalRecords<T = unknown>(state: SessionState, stream?: string): JournalRecord<T>[];
+/** The normalized transcript, in log order. */
+export declare function transcriptOf(state: SessionState): JournalRecord<TranscriptEntry>[];
+/**
+ * Where the last turn ended: the `effectOrder` index of the batch holding
+ * the last `turn` entry, or of the last `unavailable` fact (a turn the
+ * harness could not run: it is over, with an error, and nothing in it is
+ * recovered), or -1 if no turn has ended yet. Everything after it belongs to
+ * the current (or an interrupted) turn.
+ */
+export declare function lastTurnEnd(state: SessionState): number;
+/**
+ * A batch input for UIs: the transcript entries as they are, every other
+ * stream as a count (native records can be large, and a page polling a
+ * session should not carry them).
+ */
+export declare function summarizeBatch(input: unknown): unknown;
+/** The transcript entries of one batch input (inline only; transcript entries are never offloaded). */
+export declare function batchTranscript(input: unknown): TranscriptEntry[];
+export interface OpenTurn {
+    /** `effectOrder` index of the batch that ended the previous turn (-1: none ended yet). */
+    since: number;
+    /** Submissions placed in this turn. */
+    placed: string[];
+    /** Tool calls made in it. */
+    calls: EffectRecord[];
+    /** Transcript entries written in it (assistant text, earlier recovery notes). */
+    entries: JournalRecord<TranscriptEntry>[];
+}
+/**
+ * The turn that has not ended: everything after the last `turn` entry of
+ * the transcript. `undefined` when the last turn ended and nothing happened
+ * since (nothing to recover; new submissions start a new turn as usual).
+ */
+export declare function openTurn(state: SessionState): OpenTurn | undefined;

package/dist/process/records.js

@@ -0,0 +1,142 @@
+/**
+ * The shape of a process harness's records in the run's log, and the pure
+ * readers for it. No Node imports: UIs (the demo's transcript, in a browser
+ * tab) read sessions with this module.
+ *
+ * A process harness mirrors its native session state (Codex's rollout) into
+ * the log as **journal batches**: record-only effects named `journal`, keyed
+ * `journal:<n>`, each carrying the records appended since the last batch,
+ * grouped by stream. The kernel's rules make the batches linear: the first
+ * committed step per key wins, a stale driver's step is fenced (its writer is
+ * refused once a newer drive opens the session), and a batch
+ * counts only once its outcome is committed. Every reader, the writer
+ * included, sees the same records in the same order.
+ *
+ * Next to its native streams, every process harness writes one normalized
+ * stream, `transcript` (`TranscriptEntry`), so one view renders any of them.
+ */
+/** The effect name of every journal batch (`step//harness-world//journal` in dashboards). */
+export const JOURNAL = 'journal';
+/** The normalized transcript's stream name. */
+export const TRANSCRIPT = 'transcript';
+/** The memo key of batch `n`. */
+export const journalKey = (n) => `${JOURNAL}:${n}`;
+/**
+ * The accepted batches, in order: `journal:0`, `journal:1`, ... up to the
+ * first that has no committed outcome. A batch whose intent landed but whose
+ * outcome did not (its writer died between the two writes) does not count;
+ * the next writer reuses its key.
+ */
+export function journalBatches(state) {
+    const index = new Map();
+    state.effectOrder.forEach((r, i) => index.set(r, i));
+    const out = [];
+    for (let n = 0;; n++) {
+        const record = state.effects.get(journalKey(n));
+        if (!record || record.status !== 'completed' || record.name !== JOURNAL)
+            break;
+        out.push({ batch: record.input, record, at: index.get(record) ?? -1 });
+    }
+    return out;
+}
+/** Every record of `stream` (or of every stream), in log order. Offloaded records have `data: undefined`. */
+export function journalRecords(state, stream) {
+    const out = [];
+    const seqs = new Map();
+    for (const { batch, record, at } of journalBatches(state)) {
+        for (const [name, part] of Object.entries(batch.streams ?? {})) {
+            if (stream !== undefined && name !== stream)
+                continue;
+            for (const entry of part.entries) {
+                const seq = seqs.get(name) ?? 0;
+                seqs.set(name, seq + 1);
+                out.push({
+                    stream: name,
+                    seq,
+                    ...(entry.id !== undefined ? { id: entry.id } : {}),
+                    data: entry.data,
+                    ...(entry.blob ? { blob: entry.blob } : {}),
+                    batch: batch.n,
+                    stepId: record.stepId,
+                    at,
+                });
+            }
+        }
+    }
+    return out;
+}
+/** The normalized transcript, in log order. */
+export function transcriptOf(state) {
+    return journalRecords(state, TRANSCRIPT);
+}
+/**
+ * The `effectOrder` index of the last `unavailable` fact (harness-world's
+ * `lastUnavailable`, spelled here so this module stays type-only on the
+ * kernel), or -1.
+ */
+function lastUnavailable(state) {
+    for (let i = state.effectOrder.length - 1; i >= 0; i--)
+        if (state.effectOrder[i].name === 'unavailable')
+            return i;
+    return -1;
+}
+/**
+ * Where the last turn ended: the `effectOrder` index of the batch holding
+ * the last `turn` entry, or of the last `unavailable` fact (a turn the
+ * harness could not run: it is over, with an error, and nothing in it is
+ * recovered), or -1 if no turn has ended yet. Everything after it belongs to
+ * the current (or an interrupted) turn.
+ */
+export function lastTurnEnd(state) {
+    let at = -1;
+    for (const r of transcriptOf(state))
+        if (r.data?.type === 'turn')
+            at = r.at;
+    return Math.max(at, lastUnavailable(state));
+}
+/**
+ * A batch input for UIs: the transcript entries as they are, every other
+ * stream as a count (native records can be large, and a page polling a
+ * session should not carry them).
+ */
+export function summarizeBatch(input) {
+    const batch = input;
+    if (!batch || typeof batch !== 'object' || !batch.streams)
+        return input;
+    const streams = {};
+    for (const [name, part] of Object.entries(batch.streams)) {
+        streams[name] =
+            name === TRANSCRIPT
+                ? part
+                : {
+                    from: part.from,
+                    count: part.entries.length,
+                    blobs: part.entries.filter((e) => e.blob).length,
+                };
+    }
+    return { v: batch.v, n: batch.n, streams };
+}
+/** The transcript entries of one batch input (inline only; transcript entries are never offloaded). */
+export function batchTranscript(input) {
+    const part = input?.streams?.[TRANSCRIPT];
+    return (part?.entries ?? []).map((e) => e.data).filter(Boolean);
+}
+/**
+ * The turn that has not ended: everything after the last `turn` entry of
+ * the transcript. `undefined` when the last turn ended and nothing happened
+ * since (nothing to recover; new submissions start a new turn as usual).
+ */
+export function openTurn(state) {
+    const transcript = transcriptOf(state);
+    const end = transcript.findLast((r) => r.data?.type === 'turn');
+    const failed = lastUnavailable(state);
+    const since = Math.max(end?.at ?? -1, failed);
+    const after = state.effectOrder.slice(since + 1);
+    // A crash drill's own step places its chaos submission: that is not a turn.
+    const placed = after.filter((e) => e.placed.length > 0 && !e.name.startsWith('tool.') && e.name !== 'chaos').flatMap((e) => e.placed);
+    const calls = after.filter((e) => e.name.startsWith('tool.'));
+    const entries = transcript.filter((r) => (end ? r.seq > end.seq : true) && r.at > failed);
+    if (placed.length === 0 && calls.length === 0 && entries.length === 0)
+        return undefined;
+    return { since, placed, calls, entries };
+}