@nylorun/runtime 0.15.1-beta → 0.16.0-beta

package/dist/tenant/effects.js

@@ -1,58 +1,20 @@
 import { embeddedAgent, flowDelegateManifest, hashManifest, isWorkflowManifestV2, } from "@nylorun/core/define";
-import { countActiveFlowWork, deriveAgentEffectSessionId, isFlowEffect, isFlowToolEffect, isWorkflowManifest, linkedMessageKey, linkedTurnEnd, } from "../core/flow-host.js";
+import { countActiveFlowWork, deriveAgentEffectSessionId, isFlowToolEffect, isWorkflowManifest, linkedMessageKey, linkedTurnEnd, } from "../core/flow-host.js";
 import { mayDispatchMore } from "../core/limits.js";
-import { canonical } from "../store/canonical.js";
-import { isOwnershipLost } from "../store/ownership.js";
 import { scrub } from "../redact.js";
-import { findServer, serversOf } from "../mcp/pool.js";
-import { sandboxCapabilityOf } from "../sandbox/manager.js";
+import { isRemoteMcpCall } from "../harness/calls.js";
 import { owningSandboxSessionId, sandboxSpecOf, sessionSandboxSpec, } from "../sandbox/share.js";
 import { withSandboxCapability } from "../sandbox/session-sandbox.js";
 import { loadSession, ownedSession, sandboxLookup, sessionOf, } from "./context.js";
 import { fail } from "./http.js";
-import { actionTarget, linkedAgentOutput, manifestFor, mcpToolOf, pinnedTool, turnManifestOf, } from "./session.js";
+import { linkedAgentOutput, turnManifestOf } from "./session.js";
 import { command } from "./commands.js";
 import { offerAction } from "./delivery.js";
-import { assistantMessage, contextCompacted, modelFailed, toolCompleted, toolIds, } from "./transcript.js";
-import { classifyThrown } from "../model/classify.js";
-import { abortKind } from "./worker.js";
-/**
- * Call the model for one effect. A provider failure comes back as a failure outcome
- * (Model Calls §6), whichever provider serves the call; only an abort throws, and the
- * advance decides what the abort means.
- */
-export async function invokeModel(ctx, request, signal, model) {
-    try {
-        if (model)
-            return await model(request, signal);
-        if (!ctx.useVaultModel)
-            return await ctx.modelProvider(request, signal);
-        return await ctx.modelGate.call({
-            tenantId: ctx.config.tenantId,
-            sessionId: request.sessionId,
-            turnId: request.turnId,
-            agentId: request.agentId,
-            effectId: request.effectId,
-            invocationId: String(request.context.invocationId),
-            call: request.input,
-        }, signal);
-    }
-    catch (error) {
-        if (signal.aborted) {
-            // A call that outlives this process stops only when told to: on a user cancel. After a
-            // shutdown or a lost lease the next owner re-sends it and picks up its outcome (P1.2).
-            if (!model && ctx.useVaultModel && abortKind(signal) === "cancel" && ctx.modelGate.cancel)
-                await ctx.modelGate.cancel({ tenantId: ctx.config.tenantId, effectId: request.effectId });
-            throw error;
-        }
-        return classifyThrown(error);
-    }
-}
 /**
  * The outcome of a flow `agent` effect once the linked turn it started ended, or undefined
  * while it has not. The linked session may still show an earlier iteration's turn.
  */
-async function linkedOutcome(t, effect, agent) {
+export async function linkedOutcome(t, effect, agent) {
     const end = await linkedTurnEnd(t, effect, agent);
     if (!end || !agent)
         return undefined;
@@ -79,13 +41,7 @@ export function recoversMcpCalls(ctx) {
 }
 /** True when `request` calls a tool of a remote (`streamable-http` or `sse`) MCP server. */
 export function isRemoteMcpEffect(s, request) {
-    if (request.kind !== "tool")
-        return false;
-    const tool = mcpToolOf(s, request);
-    if (!tool)
-        return false;
-    const declared = findServer(s.manifest, tool.agentId, tool.capabilityId, tool.serverName);
-    return declared !== undefined && declared.server.type !== "stdio";
+    return isRemoteMcpCall({ rootManifest: s.manifest, mcpSnapshot: s.mcpSnapshot }, request);
 }
 /**
  * True when this Tenant's vault-backed model calls outlive the process that sent them (the
@@ -95,242 +51,6 @@ export function isRemoteMcpEffect(s, request) {
 export function recoversModelCalls(ctx) {
     return ctx.useVaultModel && ctx.modelGate.recovers === true;
 }
-/**
- * What an effect's journal row must match on replay. A delegation's context carries only the
- * parent's tool call id, for its events; rows journaled before it existed still match.
- */
-function requestIdentity(request) {
-    if (request.kind !== "delegation")
-        return request;
-    const { context: _, ...identity } = request;
-    return identity;
-}
-function delegationCallId(request) {
-    const callId = request.context?.callId;
-    return typeof callId === "string" ? { callId } : {};
-}
-export async function resolveEffect(ctx, request, signal, lease, segment = {}) {
-    const { store } = ctx;
-    const journaled = await store.tx(async (t) => {
-        const s = await ownedSession(t, lease, request.sessionId);
-        if (s.status === "cancelled" || s.activeTurnId !== request.turnId)
-            throw new Error("Turn cancelled");
-        // An aborted advance starts no effect; the advance decides what the abort means.
-        signal.throwIfAborted();
-        const resolved = (resolution) => ({
-            kind: "resolved",
-            resolution,
-        });
-        const existing = await t.get("effects", request.effectId);
-        if (existing) {
-            if (canonical(requestIdentity(existing.request)) !== canonical(requestIdentity(request)))
-                throw new Error("Effect identity request drift");
-            if (existing.status === "completed")
-                return resolved({ status: "completed", outcome: existing.outcome });
-            // A model call its previous owner left running at the gate: re-send it, same key and
-            // request, to join it or collect its outcome.
-            if (existing.status === "invoking" &&
-                request.kind === "model" &&
-                recoversModelCalls(ctx))
-                return { kind: "invoke", invoke: "model", journaled: existing.request };
-            // A remote MCP call its previous owner left running at the gate: the same, by effect id.
-            if (existing.status === "invoking" &&
-                recoversMcpCalls(ctx) &&
-                isRemoteMcpEffect(s, existing.request))
-                return {
-                    kind: "invoke",
-                    invoke: "mcp",
-                    journaled: existing.request,
-                    remote: true,
-                };
-            if (request.kind === "agent" && existing.status === "pending") {
-                const agentSessionId = existing.agentSessionId;
-                if (agentSessionId) {
-                    const agent = await t.get("sessions", agentSessionId);
-                    const outcome = await linkedOutcome(t, existing, agent);
-                    if (outcome) {
-                        existing.status = "completed";
-                        existing.outcome = outcome;
-                        await t.put("effects", request.effectId, existing);
-                        return resolved({ status: "completed", outcome });
-                    }
-                }
-            }
-            return resolved({
-                status: existing.status === "uncertain" || existing.status === "invoking"
-                    ? "uncertain"
-                    : "pending",
-            });
-        }
-        if (request.kind === "agent" ||
-            request.kind === "fn" ||
-            request.kind === "verify" ||
-            isFlowToolEffect(request)) {
-            // Handled outside the agent-manifest path below.
-            return { kind: "flow" };
-        }
-        if (request.kind === "delegation") {
-            // Lifecycle points of an agent used as a tool: journaled once, so replays never re-emit.
-            const outcome = { value: null };
-            await t.put("effects", request.effectId, {
-                request,
-                status: "completed",
-                outcome,
-            });
-            const settled = request.effectId.endsWith(":settled");
-            await t.event(s.id, s.activeTurnId, settled ? "delegation.completed" : "delegation.started", {
-                agent: request.agent,
-                ...delegationCallId(request),
-                ...request.input,
-            });
-            return resolved({ status: "completed", outcome });
-        }
-        const agentManifest = manifestFor(s.manifest, request.agent);
-        if (!agentManifest)
-            throw new Error(`Agent '${request.agent?.id ?? ""}' is not used as a tool`);
-        const mcpTool = request.kind === "tool" ? mcpToolOf(s, request) : undefined;
-        const sandboxTool = request.kind === "tool" && !mcpTool
-            ? sandboxCapabilityOf(agentManifest, request.capabilityId, request.toolName)
-            : undefined;
-        await t.put("effects", request.effectId, {
-            request,
-            status: request.kind === "model" || mcpTool || sandboxTool
-                ? "invoking"
-                : "pending",
-        });
-        if (request.kind === "model" || mcpTool || sandboxTool)
-            return {
-                kind: "invoke",
-                invoke: mcpTool ? "mcp" : sandboxTool ? "sandbox" : "model",
-                ...(mcpTool && isRemoteMcpEffect(s, request) ? { remote: true } : {}),
-            };
-        const tool = request.kind === "tool"
-            ? pinnedTool(agentManifest, request.capabilityId, request.toolName)
-            : undefined;
-        const base = {
-            actionId: request.effectId,
-            sessionId: request.sessionId,
-            turnId: request.turnId,
-            agentId: request.agentId,
-            manifestHash: request.manifestHash,
-            implementationVersion: s.implementationVersion,
-            input: request.input,
-            context: request.context,
-            status: "pending",
-            generation: 0,
-            ...(request.agent ? { agent: request.agent } : {}),
-        };
-        const action = request.kind === "hook"
-            ? {
-                ...base,
-                kind: "hook",
-                hook: {
-                    at: request.hook.at,
-                    scope: request.hook.scope,
-                    capabilityIds: [...request.hook.capabilityIds],
-                },
-            }
-            : {
-                ...base,
-                kind: "tool",
-                capabilityId: request.capabilityId,
-                toolName: request.toolName,
-                ...(tool?.inputSchema ? { inputSchema: tool.inputSchema } : {}),
-                ...(tool?.outputSchema ? { outputSchema: tool.outputSchema } : {}),
-            };
-        await t.put("actions", action.actionId, action);
-        await t.event(s.id, s.activeTurnId, "action.pending", {
-            actionId: action.actionId,
-            kind: action.kind,
-            ...actionTarget(action),
-            ...(action.kind === "tool" ? toolIds(request.context) : {}),
-            input: action.input,
-        });
-        await offerAction(t, ctx, action);
-        return resolved({ status: "pending" });
-    });
-    if (journaled.kind === "resolved")
-        return journaled.resolution;
-    if (journaled.kind === "flow") {
-        if (isFlowEffect(request))
-            return resolveNewFlowEffect(ctx, request, signal, lease);
-        return { status: "pending" };
-    }
-    const invoke = journaled.invoke;
-    try {
-        // The intent is committed; the call itself runs outside any transaction.
-        const value = invoke === "mcp"
-            ? await callMcpTool(ctx, journaled.journaled ?? request, abortOn(signal, journaled.remote && recoversMcpCalls(ctx) ? ["cancel", "shutdown"] : ["cancel"]))
-            : invoke === "sandbox"
-                ? await callSandboxTool(ctx, request, signal)
-                : await invokeModel(ctx, journaled.journaled ?? request, signal, segment.model);
-        return await store.tx(async (t) => {
-            const s = await ownedSession(t, lease, request.sessionId);
-            // Only a cancel discards an outcome in hand (§10.7). After any other abort (shutdown,
-            // deadline) it is recorded, so the next advance replays it instead of calling again.
-            if (s.status === "cancelled" ||
-                s.activeTurnId !== request.turnId ||
-                abortKind(signal) === "cancel")
-                throw new Error("Turn cancelled");
-            const effect = await t.get("effects", request.effectId);
-            effect.status = "completed";
-            effect.outcome = { value };
-            await t.put("effects", request.effectId, effect);
-            const failed = invoke === "model" ? modelFailed(request, value) : undefined;
-            // A summary call is never an assistant message; the last one publishes context.compacted.
-            const summarizing = invoke === "model" && Boolean(request.context.compaction);
-            const compacted = summarizing && !failed ? contextCompacted(request, value) : undefined;
-            const transcript = failed || summarizing
-                ? undefined
-                : invoke === "model"
-                    ? assistantMessage(request, value)
-                    : toolCompleted(request, value);
-            if (failed)
-                await t.event(s.id, request.turnId, "model.failed", failed);
-            if (compacted)
-                await t.event(s.id, request.turnId, "context.compacted", compacted);
-            if (transcript && invoke === "model")
-                await t.event(s.id, request.turnId, "message.assistant", transcript);
-            else if (transcript)
-                await t.event(s.id, request.turnId, "tool.completed", transcript);
-            return { status: "completed", outcome: effect.outcome };
-        });
-    }
-    catch (error) {
-        // A lost epoch writes nothing: the new owner decides what the effect became.
-        if (isOwnershipLost(error))
-            throw error;
-        // A shutdown leaves a model call running at the gate, still `invoking`: the next advance
-        // re-sends it (P1.2). The segment stops for the shutdown as usual.
-        if (invoke === "model" && recoversModelCalls(ctx) && abortKind(signal) === "shutdown")
-            throw error;
-        // The same for a remote MCP call at the Tool Gate (G3). A user cancel stops it there: a
-        // keyed call outlives the request that sent it.
-        if (invoke === "mcp" && journaled.remote && recoversMcpCalls(ctx)) {
-            if (abortKind(signal) === "shutdown")
-                throw error;
-            if (abortKind(signal) === "cancel" && ctx.toolGate.cancel)
-                await ctx.toolGate.cancel({ tenantId: ctx.config.tenantId, effectId: request.effectId });
-        }
-        await store.tx(async (t) => {
-            const s = request.sessionId === lease.sessionId
-                ? await t.assertEpoch(request.sessionId, lease.epoch)
-                : await t.lockSession(request.sessionId);
-            const effect = await t.get("effects", request.effectId);
-            if (!effect)
-                return;
-            effect.status = "uncertain";
-            effect.error = error instanceof Error ? error.message : String(error);
-            await t.put("effects", request.effectId, effect);
-            if (s && s.status !== "cancelled" && s.activeTurnId === request.turnId)
-                await t.event(s.id, request.turnId, "effect.uncertain", {
-                    effectId: request.effectId,
-                    message: effect.error,
-                });
-        });
-        return { status: "uncertain" };
-    }
-}
 /** Journal and dispatch a new flow effect (agent / tool node / fn / verify). */
 export async function resolveNewFlowEffect(ctx, request, signal, lease) {
     const { store } = ctx;
@@ -551,91 +271,6 @@ export async function resolveNewFlowEffect(ctx, request, signal, lease) {
         return { status: "pending" };
     });
 }
-/** Discover the session's MCP tools once, or reconnect and refresh diagnostics. */
-export async function prepareMcp(ctx, lease, signal) {
-    const { store } = ctx;
-    const id = lease.sessionId;
-    const s = await loadSession(ctx, id);
-    if (serversOf(s.manifest).length === 0)
-        return;
-    if (!s.mcpSnapshot) {
-        const found = await ctx.mcp.discover({
-            sessionId: id,
-            manifest: s.manifest,
-            manifestHash: s.manifestHash,
-            pluginRoots: s.pluginRoots ?? {},
-            signal,
-        });
-        await store.tx(async (t) => {
-            const current = await ownedSession(t, lease, id);
-            if (current.mcpSnapshot)
-                return;
-            current.mcpSnapshot = found.snapshot;
-            current.mcpDiagnostics = found.diagnostics;
-            await t.put("sessions", id, current);
-        });
-        return;
-    }
-    const diagnostics = await ctx.mcp.reconnect({
-        sessionId: id,
-        manifest: s.manifest,
-        pluginRoots: s.pluginRoots ?? {},
-        tools: s.mcpSnapshot.mcpTools,
-        signal,
-    });
-    if (diagnostics.length === 0)
-        return;
-    await store.tx(async (t) => {
-        const current = await ownedSession(t, lease, id);
-        const prior = [...(current.mcpDiagnostics ?? [])];
-        for (const item of diagnostics) {
-            const index = prior.findIndex((existing) => existing.capabilityId === item.capabilityId &&
-                existing.serverName === item.serverName);
-            if (index >= 0)
-                prior[index] = item;
-            else
-                prior.push(item);
-        }
-        current.mcpDiagnostics = prior;
-        await t.put("sessions", id, current);
-    });
-}
-/**
- * A signal that follows `signal` only for the abort kinds in `kinds`. An MCP call stops on a
- * cancel; at the Tool Gate it also stops waiting on a shutdown, since the gate keeps the call
- * for the next owner. Otherwise a shutdown or a deadline lets the call finish and records it,
- * so the next advance replays it.
- */
-function abortOn(signal, kinds) {
-    const controller = new AbortController();
-    const follow = () => {
-        if (kinds.includes(abortKind(signal)))
-            controller.abort(signal.reason);
-    };
-    if (signal.aborted)
-        follow();
-    else
-        signal.addEventListener("abort", follow, { once: true });
-    return controller.signal;
-}
-async function callMcpTool(ctx, request, signal) {
-    const s = await loadSession(ctx, request.sessionId);
-    const tool = mcpToolOf(s, request);
-    if (!tool)
-        throw new Error(`MCP tool '${request.toolName ?? ""}' is not in the session snapshot`);
-    return ctx.mcp.call({
-        sessionId: s.id,
-        ...(tool.agentId === undefined ? {} : { agentId: tool.agentId }),
-        capabilityId: tool.capabilityId,
-        serverName: tool.serverName,
-        serverToolName: tool.serverToolName,
-        args: request.input,
-        manifest: s.manifest,
-        pluginRoots: s.pluginRoots ?? {},
-        effectId: request.effectId,
-        signal,
-    });
-}
 /**
  * The sandbox a linked session inherits from its tree's owner when that sandbox was chosen at
  * open (pinned on the owner). A definition that declares its own sandbox keeps it, as before.
@@ -651,18 +286,6 @@ function inheritedSandbox(owner, definition) {
         throw new Error(sandboxed.message);
     return { spec, manifest: sandboxed.manifest, manifestHash: sandboxed.manifestHash };
 }
-async function callSandboxTool(ctx, request, signal) {
-    const { s, ownerId } = await ctx.store.tx(async (t) => {
-        const s = await sessionOf(t, request.sessionId);
-        // Agents used as tools share the session's sandbox; the tree declares one sandbox spec.
-        const lookup = await sandboxLookup(t, s.id);
-        return { s, ownerId: owningSandboxSessionId(s, lookup) };
-    });
-    const capability = sandboxCapabilityOf(manifestFor(s.manifest, request.agent), request.capabilityId, request.toolName);
-    if (!capability)
-        throw new Error(`'${request.toolName ?? ""}' is not a sandbox tool`);
-    return ctx.sandbox.run({ id: ownerId, activeTurnId: s.activeTurnId, manifest: s.manifest }, capability, request.toolName, request.input, signal);
-}
 /** Vault authorization for an MCP server request made on behalf of a session. */
 export async function authorize(ctx, sessionId, request) {
     const s = await loadSession(ctx, sessionId);

package/dist/tenant/history.d.ts

@@ -10,18 +10,13 @@
  *   restore the transcript from before that turn's first edit, as cancel and failure restore
  *   `turnStartState`.
  * - **Lean rows.** The session row stores the engine state with an empty transcript
- *   (`leanState`). `runSegment` folds the record from `Session.history.from` and hands the
+ *   (`leanState`). The advance (`harness-api/start.ts`) folds the record from `Session.history.from` and hands the
  *   engine the full transcript (`withTranscript`).
  * - **Shadow mode** (on in the runtime's tests, `test/setup/transcript-shadow.ts`) keeps the
  *   transcript on the row too and checks the fold against it at every segment start.
  */
 import type { LiveEvent } from "@nylorun/core/contracts";
-/** The payload of one `transcript.updated` event. */
-export interface TranscriptUpdate {
-    keep: number;
-    entries: unknown[];
-    length: number;
-}
+export { CHUNK_BYTES, TranscriptFoldError, applyUpdate, applyUpdates, transcriptOf, transcriptUpdates, withTranscript, type TranscriptUpdate, } from "@nylorun/core/harness-api";
 /** Where a session's fold starts. */
 export interface SessionHistory {
     /** The fold reads the record from this seq: a snapshot at or before the turn's start. */
@@ -29,36 +24,31 @@ export interface SessionHistory {
     /** The latest snapshot (`keep: 0`), which `from` moves to when the next turn starts. */
     snapshot?: number;
 }
-/** An edit's entries are split so each event stays well under S2's 1 MiB record limit. */
-export declare const CHUNK_BYTES: number;
 /** Shadow mode: keep the transcript on the session row and check the fold against it. */
 export declare function transcriptShadow(): boolean;
 /** Tests switch shadow mode off to exercise lean rows. Returns the previous setting. */
 export declare function setTranscriptShadow(on: boolean): boolean;
-export declare class TranscriptFoldError extends Error {
-    constructor(message: string);
-}
 /** The fold and the transcript on the row differ (shadow mode only). */
 export declare class TranscriptParityError extends Error {
     constructor(sessionId: string, at: number, folded: number, stored: number);
 }
-/** The engine state's transcript, or none. */
-export declare function transcriptOf(state: unknown): unknown[];
-/**
- * The edits from `before` to `after`, split into chunks of at most `CHUNK_BYTES` of entries.
- * Empty when nothing changed.
- */
-export declare function transcriptUpdates(before: readonly unknown[], after: readonly unknown[], chunkBytes?: number): TranscriptUpdate[];
-/** Applies one edit. Throws `TranscriptFoldError` when it does not fit the transcript. */
-export declare function applyUpdate(transcript: readonly unknown[], update: TranscriptUpdate): unknown[];
 /**
  * Folds a session's events, from the start of its record or from a snapshot, into the
  * transcript the engine resumes from.
  */
 export declare function foldTranscript(events: Iterable<Pick<LiveEvent, "type" | "turnId" | "payload">>): unknown[];
+/**
+ * `foldTranscript`, and the cursor of the fold: the `seq` of the last event that changed it
+ * (`transcript.updated`, `turn.cancelled`, `turn.failed`), or -1. A harness that holds the
+ * transcript at the same cursor holds this one.
+ */
+export declare function foldTranscriptWithCursor(events: Iterable<Pick<LiveEvent, "type" | "turnId" | "payload"> & {
+    seq?: number;
+}>): {
+    transcript: unknown[];
+    cursor: number;
+};
 /** `state` with an empty transcript (what the session row stores outside shadow mode). */
 export declare function leanState<T>(state: T): T;
-/** `state` with `transcript` (what the engine runs on). */
-export declare function withTranscript<T>(state: T, transcript: readonly unknown[]): T;
 /** In shadow mode, checks the fold against the transcript the row kept. */
 export declare function checkParity(sessionId: string, folded: readonly unknown[], stored: readonly unknown[]): void;

package/dist/tenant/history.js

@@ -1,5 +1,5 @@
-/** An edit's entries are split so each event stays well under S2's 1 MiB record limit. */
-export const CHUNK_BYTES = 256 * 1024;
+import { applyUpdate, transcriptOf } from "@nylorun/core/harness-api";
+export { CHUNK_BYTES, TranscriptFoldError, applyUpdate, applyUpdates, transcriptOf, transcriptUpdates, withTranscript, } from "@nylorun/core/harness-api";
 let shadow = false;
 /** Shadow mode: keep the transcript on the session row and check the fold against it. */
 export function transcriptShadow() {
@@ -11,12 +11,6 @@ export function setTranscriptShadow(on) {
     shadow = on;
     return previous;
 }
-export class TranscriptFoldError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "TranscriptFoldError";
-    }
-}
 /** The fold and the transcript on the row differ (shadow mode only). */
 export class TranscriptParityError extends Error {
     constructor(sessionId, at, folded, stored) {
@@ -26,59 +20,21 @@ export class TranscriptParityError extends Error {
     }
 }
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-/** The engine state's transcript, or none. */
-export function transcriptOf(state) {
-    const transcript = state?.transcript;
-    return Array.isArray(transcript) ? transcript : [];
-}
-/**
- * The edits from `before` to `after`, split into chunks of at most `CHUNK_BYTES` of entries.
- * Empty when nothing changed.
- */
-export function transcriptUpdates(before, after, chunkBytes = CHUNK_BYTES) {
-    let keep = 0;
-    while (keep < before.length && keep < after.length && same(before[keep], after[keep]))
-        keep += 1;
-    if (keep === before.length && keep === after.length)
-        return [];
-    const added = after.slice(keep);
-    if (added.length === 0)
-        return [{ keep, entries: [], length: keep }];
-    const updates = [];
-    let chunk = [];
-    let bytes = 0;
-    let base = keep;
-    const flush = () => {
-        updates.push({ keep: base, entries: chunk, length: base + chunk.length });
-        base += chunk.length;
-        chunk = [];
-        bytes = 0;
-    };
-    for (const entry of added) {
-        const size = JSON.stringify(entry).length;
-        if (chunk.length > 0 && bytes + size > chunkBytes)
-            flush();
-        chunk.push(entry);
-        bytes += size;
-    }
-    flush();
-    return updates;
-}
-/** Applies one edit. Throws `TranscriptFoldError` when it does not fit the transcript. */
-export function applyUpdate(transcript, update) {
-    if (update.keep > transcript.length)
-        throw new TranscriptFoldError(`transcript.updated keeps ${update.keep} entries of ${transcript.length}`);
-    const next = [...transcript.slice(0, update.keep), ...update.entries];
-    if (next.length !== update.length)
-        throw new TranscriptFoldError(`transcript.updated should give ${update.length} entries, not ${next.length}`);
-    return next;
-}
 /**
  * Folds a session's events, from the start of its record or from a snapshot, into the
  * transcript the engine resumes from.
  */
 export function foldTranscript(events) {
+    return foldTranscriptWithCursor(events).transcript;
+}
+/**
+ * `foldTranscript`, and the cursor of the fold: the `seq` of the last event that changed it
+ * (`transcript.updated`, `turn.cancelled`, `turn.failed`), or -1. A harness that holds the
+ * transcript at the same cursor holds this one.
+ */
+export function foldTranscriptWithCursor(events) {
     let transcript = [];
+    let cursor = -1;
     // The transcript before the current turn's first edit: what a cancel or failure restores.
     let turn;
     for (const event of events) {
@@ -86,16 +42,18 @@ export function foldTranscript(events) {
             if (!turn || turn.id !== event.turnId)
                 turn = { id: event.turnId, before: transcript };
             transcript = applyUpdate(transcript, event.payload);
+            cursor = event.seq ?? cursor;
         }
         else if (event.type === "turn.cancelled" || event.type === "turn.failed") {
             if (turn && turn.id === event.turnId)
                 transcript = turn.before;
             turn = undefined;
+            cursor = event.seq ?? cursor;
         }
         else if (event.type === "turn.completed")
             turn = undefined;
     }
-    return transcript;
+    return { transcript, cursor };
 }
 /** `state` with an empty transcript (what the session row stores outside shadow mode). */
 export function leanState(state) {
@@ -103,12 +61,6 @@ export function leanState(state) {
         return state;
     return { ...state, transcript: [] };
 }
-/** `state` with `transcript` (what the engine runs on). */
-export function withTranscript(state, transcript) {
-    if (!state)
-        return state;
-    return { ...state, transcript: [...transcript] };
-}
 /** In shadow mode, checks the fold against the transcript the row kept. */
 export function checkParity(sessionId, folded, stored) {
     if (!shadow)