narraeon 0.1.1 → 0.2.0

package/dist/node/runtime/play/PlayCallChain.js

@@ -1,14 +1,19 @@
 import { createHash } from "node:crypto";
+import { equalModelHostBinding, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "../model/ModelHost.js";
 import { FileNativePromptCompiler, } from "../prompt/FileNativePromptCompiler.js";
 import { runPlayFollowupRequests, } from "./PlayFollowupRequests.js";
-import { FileNativePlayDocuments, fingerprintControl, isPlayDocumentAuthorizationCheckpoint, } from "./PlayDocumentTools.js";
+import { FileNativePlayDocuments, fingerprintControl, } from "./PlayDocumentTools.js";
 const callChainToolNames = new Set([
+    "state_list",
+    "history_list",
+    // Kept executable only for contexts whose frozen tool universe contains it.
     "context_list",
     "context_search",
     "context_read",
     "world_patch",
     "world_create",
 ]);
+const projectedEventTail = 40;
 export class PlayCallChainError extends Error {
     constructor(message) {
         super(message);
@@ -17,8 +22,10 @@ export class PlayCallChainError extends Error {
 }
 /**
  * The production play loop: one durable logical context, no Runtime-authored
- * adjudication/narration phases, and immediate Authority commits after every
- * completed model response that contains visible text or world changes.
+ * adjudication/narration phases. Responses with tool calls are intermediate
+ * tool steps: their Provider-native payload remains appendable, while only
+ * their world changes may advance Authority. A tool-free response is the sole
+ * response shape whose non-empty text can become committed narrative.
  */
 export class PlayCallChain {
     #worlds;
@@ -27,6 +34,7 @@ export class PlayCallChain {
     #failureLog;
     #active = new Map();
     #worldChains = new Map();
+    #loadedCursors = new Map();
     constructor(worlds, compiler = new FileNativePromptCompiler(), artifacts, failureLog) {
         this.#worlds = worlds;
         this.#compiler = compiler;
@@ -37,6 +45,7 @@ export class PlayCallChain {
         validateIdentity(input.chainId, "call-chain ID");
         validateIdentity(input.exchangeId, "exchange ID");
         validatePlayerText(input.playerText);
+        assertModelHostBinding(input.modelBinding, input.modelHost);
         const existing = await this.#readPersisted(input.worldId);
         if (existing?.chainId === input.chainId) {
             const duplicate = duplicatePlayerExchange(existing, input.exchangeId, input.playerText, "fresh");
@@ -70,16 +79,14 @@ export class PlayCallChain {
         documents.bindBootstrap(bootstrap);
         const now = Date.now();
         const session = {
-            schemaVersion: 1,
+            schemaVersion: 3,
             kind: "play_call_chain",
             chainId: input.chainId,
             worldId: input.worldId,
-            previousContexts: existing === null
-                ? []
-                : [
-                    ...(existing.previousContexts ?? []).map((context) => structuredClone(context)),
-                    snapshotCurrentContext(existing),
-                ],
+            previousContexts: [],
+            previousChainId: existing?.chainId ?? null,
+            timelineGeneration: existing?.timelineGeneration ??
+                this.#worlds.playTimeline.newGeneration(),
             baselineHead: binding.parentHead,
             baselineHistoryLength: Object.keys(binding.history).length,
             parentHead: binding.parentHead,
@@ -90,6 +97,7 @@ export class PlayCallChain {
             },
             followups: structuredClone(compilation.followups ?? []),
             playPresetScriptsEnabled: input.playPreset.scriptsEnabled,
+            modelBinding: structuredClone(input.modelBinding),
             status: "ready",
             canRetry: false,
             bootstrap,
@@ -114,6 +122,12 @@ export class PlayCallChain {
             documents,
             history: historyEntries(binding.history),
             completedToolMap: new Map(),
+            persistenceCursor: {
+                eventCount: 0,
+                transcriptCount: 0,
+                completedToolCount: 0,
+                authorizationCheckpointCount: 0,
+            },
         };
         if (activeId !== undefined)
             this.#active.delete(activeId);
@@ -126,6 +140,7 @@ export class PlayCallChain {
         validateIdentity(input.exchangeId, "exchange ID");
         const session = await this.#requireChain(input.worldId, input.chainId);
         await this.#assertCurrentHead(session);
+        assertSessionModelHostBinding(session, input.modelHost);
         if (input.playerText.trim().length === 0) {
             if (session.status === "running")
                 throw new PlayCallChainError("A model request is still running.");
@@ -148,31 +163,21 @@ export class PlayCallChain {
     async inspectWorld(worldId) {
         const activeId = this.#worldChains.get(worldId);
         const active = activeId === undefined ? undefined : this.#active.get(activeId);
-        if (active !== undefined)
+        if (active !== undefined) {
+            await this.#reconcileSessionAdvance(active);
             return projectView(active);
+        }
         const persisted = await this.#readPersisted(worldId);
         if (persisted === null)
             return null;
-        if (persisted.status === "running") {
-            const streaming = persisted.events.findLast((event) => event.kind === "assistant" && event.status === "streaming");
-            if (streaming !== undefined)
-                streaming.status = "interrupted";
-            const canRetry = persisted.lastRequest !== null;
-            const message = canRetry
-                ? "The service stopped before the model request completed; the same request can be retried."
-                : "The service stopped before dispatching the model request; use a fresh context.";
-            persisted.events.push({
-                id: persisted.nextEventId++,
-                kind: "failure",
-                message,
-            });
-            persisted.status = "interrupted";
-            persisted.canRetry = canRetry;
-            persisted.lastFailure = message;
-            persisted.updatedAt = Date.now();
-            await this.#worlds.writePlayCallChain(worldId, persisted);
-        }
-        return projectView(persisted);
+        const advance = await this.#worlds.playAdvances.readCurrent(worldId, persisted.chainId);
+        const session = await this.#hydrateSession(persisted, advance);
+        this.#active.set(session.chainId, session);
+        this.#worldChains.set(worldId, session.chainId);
+        await this.#reconcileSessionAdvance(session, advance);
+        if (session.status === "running")
+            await this.#interruptAbandonedDispatch(session);
+        return projectView(session);
     }
     async forkToDerivedWorld(input) {
         const existing = await this.#readPersisted(input.targetWorldId);
@@ -181,7 +186,7 @@ export class PlayCallChain {
         const source = await this.#readPersisted(input.sourceWorldId);
         if (source === null)
             return null;
-        const sourceContexts = persistedContexts(source);
+        const sourceContexts = await this.#worlds.playTimeline.readAllContexts(input.sourceWorldId);
         const selectedContextIndex = sourceContexts.findIndex(({ events }) => eventsThroughHead(events, input.sourceHead) !== null);
         if (selectedContextIndex < 0)
             return null;
@@ -216,7 +221,7 @@ export class PlayCallChain {
         const source = await this.#readPersisted(input.worldId);
         if (source === null)
             throw new PlayCallChainError("The current world has no model call chain to revise.");
-        const sourceContexts = persistedContexts(source);
+        const sourceContexts = await this.#worlds.playTimeline.readAllContexts(input.worldId);
         const appliedEvent = sourceContexts
             .flatMap(({ events }) => events)
             .find((event) => event.kind === "player" &&
@@ -311,13 +316,15 @@ export class PlayCallChain {
             throw new PlayCallChainError("The timeline revision was committed, but current-world materialization has not reached the new endpoint.");
         const documents = restorePlayDocuments(binding.files, sourceContext, prefixEvents);
         const revised = {
-            schemaVersion: 1,
+            schemaVersion: 3,
             kind: "play_call_chain",
             chainId: derivedChainId(sourceContext.chainId, "timeline-revision:" + request.operationId, request.worldId),
             worldId: request.worldId,
-            previousContexts: input.sourceContexts
-                .slice(0, input.selectedContextIndex)
-                .map((context) => independentContextCopy(context)),
+            previousContexts: [],
+            previousChainId: input.selectedContextIndex === 0
+                ? null
+                : input.sourceContexts[input.selectedContextIndex - 1].chainId,
+            timelineGeneration: this.#worlds.playTimeline.newGeneration(),
             baselineHead: sourceContext.baselineHead,
             baselineHistoryLength: sourceContext.baselineHistoryLength ?? baseline.history.length,
             parentHead: outcome.head,
@@ -330,6 +337,9 @@ export class PlayCallChain {
                 : {
                     playPresetScriptsEnabled: sourceContext.playPresetScriptsEnabled,
                 }),
+            ...(sourceContext.modelBinding === undefined
+                ? {}
+                : { modelBinding: structuredClone(sourceContext.modelBinding) }),
             status: "ready",
             canRetry: false,
             bootstrap: structuredClone(sourceContext.bootstrap),
@@ -351,7 +361,7 @@ export class PlayCallChain {
             lastFailure: null,
             updatedAt: Date.now(),
         };
-        await this.#worlds.writePlayCallChain(request.worldId, structuredClone(revised));
+        await this.#worlds.playTimeline.persist(structuredClone(revised));
         const activeId = this.#worldChains.get(request.worldId);
         if (activeId !== undefined)
             this.#active.delete(activeId);
@@ -380,14 +390,32 @@ export class PlayCallChain {
         const derivedBinding = await this.#worlds.bindPlayCallChain(input.targetWorldId);
         const derivedDocuments = restorePlayDocuments(derivedBinding.files, sourceContext, input.sourceEvents);
         const now = Date.now();
+        const timelineGeneration = this.#worlds.playTimeline.newGeneration();
+        let previousChainId = null;
+        for (const [index, context] of input.sourceContexts
+            .slice(0, input.selectedContextIndex)
+            .entries()) {
+            const chainId = derivedChainId(context.chainId, `prefix:${input.branchIdentity}:${index}`, input.targetWorldId);
+            await this.#worlds.playTimeline.persist({
+                ...independentContextCopy(context),
+                schemaVersion: 3,
+                kind: "play_call_chain",
+                worldId: input.targetWorldId,
+                chainId,
+                previousContexts: [],
+                previousChainId,
+                timelineGeneration,
+            });
+            previousChainId = chainId;
+        }
         const derived = {
-            schemaVersion: 1,
+            schemaVersion: 3,
             kind: "play_call_chain",
             chainId: derivedChainId(sourceContext.chainId, input.branchIdentity, input.targetWorldId),
             worldId: input.targetWorldId,
-            previousContexts: input.sourceContexts
-                .slice(0, input.selectedContextIndex)
-                .map((context) => independentContextCopy(context)),
+            previousContexts: [],
+            previousChainId,
+            timelineGeneration,
             baselineHead: sourceContext.baselineHead,
             baselineHistoryLength: sourceContext.baselineHistoryLength ?? baseline.history.length,
             parentHead: input.sourceHead,
@@ -400,6 +428,9 @@ export class PlayCallChain {
                 : {
                     playPresetScriptsEnabled: sourceContext.playPresetScriptsEnabled,
                 }),
+            ...(sourceContext.modelBinding === undefined
+                ? {}
+                : { modelBinding: structuredClone(sourceContext.modelBinding) }),
             status: "ready",
             canRetry: false,
             bootstrap: structuredClone(sourceContext.bootstrap),
@@ -421,7 +452,7 @@ export class PlayCallChain {
             lastFailure: null,
             updatedAt: now,
         };
-        await this.#worlds.writePlayCallChain(input.targetWorldId, structuredClone(derived));
+        await this.#worlds.playTimeline.persist(structuredClone(derived));
         return projectView(derived);
     }
     forgetWorld(worldId) {
@@ -438,17 +469,44 @@ export class PlayCallChain {
             return projectView(session);
         if (session.status === "running")
             throw new PlayCallChainError("The call chain is waiting for the model to return.");
-        session.status = "running";
-        session.lastFailure = null;
-        let committed;
+        const exchange = session.exchange + 1;
+        const nextRequest = createRequest(session, modelHost, exchange, [
+            ...session.transcript,
+            { kind: "player", text: playerText },
+        ]);
+        const operationKey = `player:${exchangeId}`;
+        const playerOperationId = operationId(session.chainId, operationKey);
+        const advance = {
+            schemaVersion: 1,
+            kind: "play_advance",
+            advanceKind: "player",
+            worldId: session.worldId,
+            chainId: session.chainId,
+            advanceId: playerOperationId,
+            operationId: playerOperationId,
+            parentHead: session.parentHead,
+            eventId: session.nextEventId,
+            exchangeId,
+            playerText,
+            context,
+            transcriptStart: session.transcript.length,
+            exchange,
+            nextRequest: structuredClone(nextRequest),
+            createdAt: Date.now(),
+        };
+        await this.#worlds.playAdvances.begin(advance);
         try {
-            committed = await this.#commitStep(session, {
-                operationKey: `player:${exchangeId}`,
-                historyAppend: [{ role: "player", exactText: playerText }],
-                stateChanges: [],
-            });
+            await this.#settlePlayerAdvance(session, advance);
         }
         catch (error) {
+            const accepted = await this.#worlds
+                .getOperationOutcome(advance.operationId)
+                .catch(() => ({ outcome: "not_started" }));
+            if (accepted.outcome === "committed" ||
+                accepted.outcome === "committed_materialization_pending") {
+                await this.#settlePlayerAdvance(session, advance);
+                return this.#dispatch(session, modelHost, structuredClone(nextRequest), 1, observer);
+            }
             const message = error instanceof Error
                 ? error.message
                 : "Failed to write the original player text.";
@@ -461,22 +519,272 @@ export class PlayCallChain {
             session.canRetry = false;
             session.lastFailure = message;
             await this.#persist(session);
+            await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
             throw new PlayCallChainError(message);
         }
-        session.transcript.push({ kind: "player", text: playerText });
-        session.events.push({
-            id: session.nextEventId++,
-            kind: "player",
-            exchangeId,
-            text: playerText,
-            context,
-            committedHead: committed.head,
+        return this.#dispatch(session, modelHost, structuredClone(nextRequest), 1, observer);
+    }
+    async #settlePlayerAdvance(session, advance) {
+        const outcome = await this.#worlds.commitPlayStep({
+            operationId: advance.operationId,
+            worldId: session.worldId,
+            parentHead: advance.parentHead,
+            historyAppend: [{ role: "player", exactText: advance.playerText }],
+            nextMaterials: structuredClone(session.nextMaterials),
+            stateChanges: [],
         });
+        if (outcome.worldId !== session.worldId ||
+            outcome.parentHead !== advance.parentHead)
+            throw new PlayCallChainError("The recovered player advance belongs to a different world endpoint.");
+        const playerEvent = {
+            id: advance.eventId,
+            kind: "player",
+            exchangeId: advance.exchangeId,
+            text: advance.playerText,
+            context: advance.context,
+            committedHead: outcome.head,
+        };
+        session.events = [
+            ...session.events.filter(({ id }) => id < advance.eventId),
+            playerEvent,
+        ];
+        if (session.transcript.length < advance.transcriptStart)
+            throw new PlayCallChainError("The recovered call-chain transcript is shorter than its player prefix.");
+        session.transcript = [
+            ...session.transcript.slice(0, advance.transcriptStart),
+            { kind: "player", text: advance.playerText },
+        ];
+        session.nextEventId = advance.eventId + 1;
+        session.parentHead = outcome.head;
+        appendCommittedHistory(session, outcome.head, outcome.historyAppend);
+        session.exchange = advance.exchange;
+        session.lastRequest = structuredClone(advance.nextRequest);
+        session.lastRequestAttempt = 0;
+        session.status = "interrupted";
+        session.canRetry = true;
+        session.lastFailure =
+            "The player message is committed; the frozen model request is ready to continue.";
         await this.#persist(session);
-        notifySnapshot(observer, session);
-        session.exchange += 1;
-        const request = createRequest(session, modelHost, session.exchange);
-        return this.#dispatch(session, modelHost, request, 1, observer);
+        crashAtPlayAdvanceEdge("after_timeline_settled");
+        await this.#worlds.playAdvances.markSettled(advance, outcome.head);
+    }
+    #prepareResponseSettlement(session, advance, response) {
+        const existing = session.events.find(({ id }) => id === advance.eventId);
+        if (existing?.kind !== "assistant")
+            throw new PlayCallChainError("The durable Provider result no longer matches its assistant event.");
+        const calls = response.toolCalls ?? [];
+        const text = response.text ?? existing.text;
+        const hasText = text.trim().length > 0;
+        const responseKind = calls.length > 0 ? "tool_step" : hasText ? "narrative" : "empty";
+        const assistantEvent = {
+            id: advance.eventId,
+            kind: "assistant",
+            text,
+            status: "completed",
+            responseKind,
+            exchange: advance.exchange,
+            attempt: advance.attempt,
+            ...(response.reasoningContent === undefined
+                ? existing.reasoning === undefined
+                    ? {}
+                    : { reasoning: existing.reasoning }
+                : { reasoning: response.reasoningContent }),
+            ...(response.usage === undefined
+                ? {}
+                : { usage: structuredClone(response.usage) }),
+            ...(response.stopReason === undefined
+                ? {}
+                : { stopReason: response.stopReason }),
+            continuation: response.providerState === undefined ? "unavailable" : "available",
+        };
+        const workingTools = new Map(session.completedToolMap);
+        const prepared = [];
+        const trailingEvents = [];
+        let nextEventId = advance.eventId + 1;
+        for (const call of calls) {
+            const item = prepareTool(session, workingTools, advance.exchange, call);
+            prepared.push(item);
+            trailingEvents.push({
+                id: nextEventId++,
+                kind: "tool_call",
+                callId: call.id,
+                name: call.name,
+                arguments: structuredClone(call.arguments),
+                replayed: item.replayed,
+            });
+            item.event.id = nextEventId++;
+            trailingEvents.push(structuredClone(item.event));
+        }
+        const stateChanges = session.documents.stateChanges();
+        const visibleText = responseKind === "narrative";
+        const assistantItem = {
+            kind: "assistant",
+            text,
+            ...(response.reasoningContent === undefined
+                ? {}
+                : { reasoningContent: response.reasoningContent }),
+            ...(response.providerState === undefined
+                ? {}
+                : { providerState: response.providerState }),
+            toolCalls: structuredClone(calls),
+        };
+        return {
+            assistantEvent,
+            trailingEvents,
+            transcriptStart: session.transcript.length,
+            transcriptAppend: [
+                ...(calls.length > 0 ||
+                    visibleText ||
+                    response.providerState !== undefined
+                    ? [assistantItem]
+                    : []),
+                ...prepared.map(({ transcript }) => structuredClone(transcript)),
+            ],
+            completedTools: [...workingTools.values()].map((item) => structuredClone(item)),
+            authorizationCheckpoint: session.documents.authorizationCheckpoint(),
+            stateChanges: structuredClone(stateChanges),
+            visibleText,
+        };
+    }
+    async #settleResponseAdvance(session, advance, prepared) {
+        const settlement = structuredClone(prepared);
+        const hasToolCalls = settlement.trailingEvents.some(({ kind }) => kind === "tool_call");
+        // A legacy prepared fact has no responseKind. Its visibleText decision is
+        // already part of an immutable recovery operation and must be replayed as
+        // recorded; every newly prepared fact is checked against the current rule.
+        if (settlement.assistantEvent.responseKind !== undefined) {
+            const expectedResponseKind = hasToolCalls
+                ? "tool_step"
+                : settlement.assistantEvent.text.trim().length > 0
+                    ? "narrative"
+                    : "empty";
+            if (settlement.assistantEvent.responseKind !== expectedResponseKind ||
+                settlement.visibleText !== (expectedResponseKind === "narrative"))
+                throw new PlayCallChainError("The prepared response settlement has an inconsistent narrative classification.");
+        }
+        let committedHead;
+        if (settlement.visibleText || settlement.stateChanges.length > 0) {
+            const outcome = await this.#worlds.commitPlayStep({
+                operationId: advance.operationId,
+                worldId: session.worldId,
+                parentHead: advance.parentHead,
+                historyAppend: settlement.visibleText
+                    ? [
+                        {
+                            role: "narrator",
+                            exactText: settlement.assistantEvent.text,
+                        },
+                    ]
+                    : [],
+                nextMaterials: structuredClone(session.nextMaterials),
+                stateChanges: structuredClone(settlement.stateChanges),
+            });
+            committedHead = outcome.head;
+            settlement.assistantEvent.committedHead = outcome.head;
+            crashAtPlayAdvanceEdge("after_authority_accepted");
+            appendCommittedHistory(session, outcome.head, outcome.historyAppend);
+        }
+        finalizePreparedReceipts(settlement);
+        session.events = [
+            ...session.events.filter(({ id }) => id < advance.eventId),
+            structuredClone(settlement.assistantEvent),
+            ...structuredClone(settlement.trailingEvents),
+        ];
+        session.nextEventId =
+            Math.max(advance.eventId, ...settlement.trailingEvents.map(({ id }) => id)) + 1;
+        if (session.transcript.length < settlement.transcriptStart)
+            throw new PlayCallChainError("The recovered call-chain transcript is shorter than its settlement prefix.");
+        session.transcript = [
+            ...session.transcript.slice(0, settlement.transcriptStart),
+            ...structuredClone(settlement.transcriptAppend),
+        ];
+        session.completedTools = structuredClone(settlement.completedTools);
+        session.completedToolMap = new Map(settlement.completedTools.map((item) => [
+            item.key,
+            structuredClone(item),
+        ]));
+        const lastToolEventId = settlement.trailingEvents.findLast(({ kind }) => kind === "tool_result")?.id;
+        if (lastToolEventId !== undefined) {
+            session.documentAuthorizationCheckpoints =
+                session.documentAuthorizationCheckpoints.filter(({ afterEventId }) => afterEventId < advance.eventId);
+            session.documentAuthorizationCheckpoints.push({
+                afterEventId: lastToolEventId,
+                authorization: structuredClone(settlement.authorizationCheckpoint),
+            });
+        }
+        if (committedHead !== undefined)
+            session.parentHead = committedHead;
+        if (settlement.stateChanges.length > 0) {
+            const currentAuthorization = session.documents.authorizationCheckpoint();
+            if (currentAuthorization.stateFingerprint ===
+                settlement.authorizationCheckpoint.stateFingerprint)
+                session.documents.acceptCommittedState();
+            else {
+                const binding = await this.#worlds.bindPlayCallChain(session.worldId);
+                session.documents = new FileNativePlayDocuments(binding.files);
+                session.documents.restoreAuthorizationCheckpoint(settlement.authorizationCheckpoint);
+                session.history = historyEntries(binding.history);
+                session.nextMaterials = structuredClone(binding.additionalMaterials);
+            }
+            mergeChangedDocuments(session, settlement.stateChanges);
+        }
+        session.exchange = Math.max(session.exchange, advance.exchange);
+        session.canRetry = false;
+        session.lastFailure = null;
+        let result;
+        if (settlement.assistantEvent.continuation !== "available") {
+            const message = "The complete model response has no provider-native continuation payload; use a fresh context.";
+            session.events.push({
+                id: session.nextEventId++,
+                kind: "failure",
+                message,
+            });
+            session.status = "interrupted";
+            session.lastFailure = message;
+            result = { kind: "terminal", status: "interrupted" };
+        }
+        else if (hasToolCalls) {
+            session.exchange += 1;
+            const nextRequest = createRequestWithMaxOutputTokens(session, session.lastRequest?.maxOutputTokens ?? 1, session.exchange);
+            session.lastRequest = structuredClone(nextRequest);
+            session.lastRequestAttempt = 0;
+            session.status = "interrupted";
+            session.canRetry = true;
+            session.lastFailure =
+                "The completed tool response is settled; its frozen continuation request is ready.";
+            result = { kind: "continue", nextRequest };
+        }
+        else {
+            session.status = settlement.visibleText ? "ready" : "interrupted";
+            if (!settlement.visibleText) {
+                const message = "The model returned neither text nor a complete tool call.";
+                session.events.push({
+                    id: session.nextEventId++,
+                    kind: "failure",
+                    message,
+                });
+                session.lastFailure = message;
+            }
+            result = { kind: "terminal", status: session.status };
+        }
+        await this.#persist(session);
+        crashAtPlayAdvanceEdge("after_timeline_settled");
+        await this.#worlds.playAdvances.markSettled(advance, committedHead ?? session.parentHead);
+        return result;
+    }
+    async #recoverAcceptedResponseAdvance(session, advance) {
+        const outcome = await this.#worlds
+            .getOperationOutcome(advance.operationId)
+            .catch(() => ({ outcome: "not_started" }));
+        if (outcome.outcome !== "committed" &&
+            outcome.outcome !== "committed_materialization_pending")
+            return null;
+        const current = await this.#worlds.playAdvances.readCurrent(advance.worldId, advance.chainId);
+        if (current?.base.advanceKind !== "response" ||
+            current.base.advanceId !== advance.advanceId ||
+            current.settlementPrepared === null)
+            throw new PlayCallChainError("Authority accepted a response whose durable settlement is missing.");
+        return this.#settleResponseAdvance(session, advance, current.settlementPrepared.settlement);
     }
     async #dispatch(session, modelHost, firstRequest, firstAttempt, observer) {
         let request = structuredClone(firstRequest);
@@ -493,11 +801,29 @@ export class PlayCallChain {
                 kind: "assistant",
                 text: "",
                 status: "streaming",
+                responseKind: "pending",
                 exchange: responseExchange,
                 attempt,
             };
             session.events.push(event);
             await this.#persist(session);
+            const responseOperationId = operationId(session.chainId, `response:${responseExchange}:attempt:${attempt}`);
+            const advance = {
+                schemaVersion: 1,
+                kind: "play_advance",
+                advanceKind: "response",
+                worldId: session.worldId,
+                chainId: session.chainId,
+                advanceId: responseOperationId,
+                operationId: responseOperationId,
+                parentHead: session.parentHead,
+                eventId: event.id,
+                exchange: responseExchange,
+                attempt,
+                createdAt: Date.now(),
+            };
+            await this.#worlds.playAdvances.begin(advance);
+            crashAtPlayAdvanceEdge("after_response_advance_began");
             notifySnapshot(observer, session);
             let response;
             try {
@@ -532,53 +858,24 @@ export class PlayCallChain {
                     message,
                 });
                 session.status = "interrupted";
-                session.canRetry = true;
+                const requiresFreshContext = error instanceof ModelHostContinuationError ||
+                    error instanceof ModelHostOutcomeUnknownError;
+                session.canRetry =
+                    !requiresFreshContext && error instanceof ModelHostFailureError;
                 session.lastFailure = message;
                 await this.#persist(session);
+                await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
                 notifySnapshot(observer, session);
                 return projectView(session);
             }
-            event.status = "completed";
-            session.canRetry = false;
-            event.text = response.text ?? event.text;
-            if (response.reasoningContent !== undefined)
-                event.reasoning = response.reasoningContent;
-            delete event.toolFragment;
-            if (response.usage !== undefined)
-                event.usage = {
-                    inputTokens: response.usage.inputTokens,
-                    outputTokens: response.usage.outputTokens,
-                };
-            const calls = response.toolCalls ?? [];
-            const assistantItem = {
-                kind: "assistant",
-                text: response.text ?? "",
-                ...(response.reasoningContent === undefined
-                    ? {}
-                    : { reasoningContent: response.reasoningContent }),
-                ...(response.providerState === undefined
-                    ? {}
-                    : { providerState: response.providerState }),
-                toolCalls: structuredClone(calls),
-            };
+            const durableResponse = durableModelResponse(response);
             try {
-                const workingTools = new Map(session.completedToolMap);
-                const prepared = [];
-                for (const call of calls) {
-                    const item = prepareTool(session, workingTools, responseExchange, call);
-                    prepared.push(item);
-                    session.events.push({
-                        id: session.nextEventId++,
-                        kind: "tool_call",
-                        callId: call.id,
-                        name: call.name,
-                        arguments: structuredClone(call.arguments),
-                        replayed: item.replayed,
-                    });
-                    item.event.id = session.nextEventId++;
-                    session.events.push(item.event);
-                }
-                const failedTools = prepared.filter(({ result }) => !result.ok);
+                await this.#worlds.playAdvances.recordProviderCompleted(advance, durableResponse);
+                crashAtPlayAdvanceEdge("after_provider_completed");
+                const settlement = this.#prepareResponseSettlement(session, advance, durableResponse);
+                await this.#worlds.playAdvances.recordSettlementPrepared(advance, settlement);
+                crashAtPlayAdvanceEdge("after_settlement_prepared");
+                const failedTools = settlement.trailingEvents.filter((candidate) => candidate.kind === "tool_result" && !candidate.ok);
                 if (failedTools.length > 0 && response.diagnostics !== undefined)
                     await this.#failureLog?.recordFailure({
                         exchange: response.diagnostics,
@@ -587,66 +884,20 @@ export class PlayCallChain {
                                 kind: "tool_execution",
                                 message: "A Runtime tool call from the model was rejected.",
                                 details: {
-                                    calls: failedTools.map(({ call, result, replayed }) => ({
-                                        id: call.id,
-                                        name: call.name,
-                                        arguments: structuredClone(call.arguments),
+                                    calls: failedTools.map((result) => ({
+                                        id: result.callId,
+                                        name: result.name,
                                         ok: result.ok,
-                                        failureKind: result.failureKind,
                                         markdown: result.markdown,
-                                        replayed,
+                                        replayed: result.replayed,
                                     })),
                                 },
                             },
                         ],
                     });
-                const stateChanges = session.documents.stateChanges();
-                const visibleText = (response.text ?? "").trim().length > 0;
-                let committedHead;
-                if (visibleText || stateChanges.length > 0) {
-                    const committed = await this.#commitStep(session, {
-                        operationKey: `response:${responseExchange}:attempt:${attempt}`,
-                        historyAppend: visibleText
-                            ? [{ role: "narrator", exactText: response.text ?? "" }]
-                            : [],
-                        stateChanges,
-                    });
-                    committedHead = committed.head;
-                    event.committedHead = committed.head;
-                    if (stateChanges.length > 0) {
-                        session.documents.acceptCommittedState();
-                        mergeChangedDocuments(session, stateChanges);
-                    }
-                }
-                const committedWriteRefs = new Set(stateChanges.map(({ stableShortRef }) => stableShortRef));
-                for (const item of prepared) {
-                    const candidateWrite = item.result.candidateWrite;
-                    if (!item.result.ok || candidateWrite === undefined)
-                        continue;
-                    const markdown = candidateWrite.changed &&
-                        committedWriteRefs.has(candidateWrite.shortRef)
-                        ? `@${candidateWrite.shortRef} write succeeded`
-                        : `@${candidateWrite.shortRef} unchanged`;
-                    item.result.markdown = markdown;
-                    delete item.result.candidateWrite;
-                    item.event.markdown = markdown;
-                    item.transcript.markdown = markdown;
-                    const completed = workingTools.get(item.key);
-                    if (completed !== undefined)
-                        completed.result = structuredClone(item.result);
-                }
-                if (calls.length > 0 || visibleText)
-                    session.transcript.push(assistantItem);
-                session.transcript.push(...prepared.map(({ transcript }) => transcript));
-                session.completedToolMap = workingTools;
-                session.completedTools = [...workingTools.values()].map((item) => structuredClone(item));
-                const lastToolEventId = prepared.at(-1)?.event.id;
-                if (lastToolEventId !== undefined)
-                    recordDocumentAuthorizationCheckpoint(session, lastToolEventId);
-                if (committedHead !== undefined)
-                    session.parentHead = committedHead;
-                if (calls.length === 0) {
-                    if (!visibleText) {
+                const settled = await this.#settleResponseAdvance(session, advance, settlement);
+                if (settled.kind === "terminal") {
+                    if (!settlement.visibleText) {
                         const message = "The model returned neither text nor a complete tool call.";
                         if (response.diagnostics !== undefined)
                             await this.#failureLog?.recordFailure({
@@ -658,15 +909,10 @@ export class PlayCallChain {
                                     },
                                 ],
                             });
-                        session.events.push({
-                            id: session.nextEventId++,
-                            kind: "failure",
-                            message,
-                        });
-                        session.status = "interrupted";
-                        session.canRetry = false;
-                        session.lastFailure = message;
-                        await this.#persist(session);
+                        notifySnapshot(observer, session);
+                        return projectView(session);
+                    }
+                    if (settled.status !== "ready") {
                         notifySnapshot(observer, session);
                         return projectView(session);
                     }
@@ -686,13 +932,22 @@ export class PlayCallChain {
                     notifySnapshot(observer, session);
                     return projectView(session);
                 }
-                await this.#persist(session);
                 notifySnapshot(observer, session);
-                session.exchange = Math.max(session.exchange, responseExchange) + 1;
-                request = createRequest(session, modelHost, session.exchange);
+                request = settled.nextRequest;
                 attempt = 1;
             }
             catch (error) {
+                const recovered = await this.#recoverAcceptedResponseAdvance(session, advance);
+                if (recovered !== null) {
+                    if (recovered.kind === "continue") {
+                        request = recovered.nextRequest;
+                        attempt = 1;
+                        notifySnapshot(observer, session);
+                        continue;
+                    }
+                    notifySnapshot(observer, session);
+                    return projectView(session);
+                }
                 const message = error instanceof Error
                     ? error.message
                     : "Call-chain processing failed.";
@@ -789,56 +1044,44 @@ export class PlayCallChain {
             touch(session);
         }
     }
-    async #commitStep(session, input) {
-        const parentHead = session.parentHead;
-        const outcome = await this.#worlds.commitPlayStep({
-            operationId: operationId(session.chainId, input.operationKey),
-            worldId: session.worldId,
-            parentHead,
-            historyAppend: structuredClone(input.historyAppend),
-            nextMaterials: structuredClone(session.nextMaterials),
-            stateChanges: structuredClone(input.stateChanges),
-        });
-        session.parentHead = outcome.head;
-        const sequence = Number(outcome.head.slice("commit:".length));
-        for (const [index, message] of input.historyAppend.entries())
-            session.history.push({
-                path: `${session.worldId}.message.${sequence}.${index + 1}.${message.role}`,
-                contents: message.exactText,
-            });
-        return outcome;
-    }
     async #requireChain(worldId, chainId) {
         validateIdentity(chainId, "call-chain ID");
         const active = this.#active.get(chainId);
         if (active !== undefined) {
             if (active.worldId !== worldId)
                 throw new PlayCallChainError("The call chain does not belong to this world.");
+            await this.#reconcileSessionAdvance(active);
             return active;
         }
         const persisted = await this.#readPersisted(worldId);
         if (persisted?.chainId !== chainId)
             throw new PlayCallChainError("The call chain does not exist; start from the latest world state.");
-        if (persisted.status === "running") {
-            persisted.status = "interrupted";
-            persisted.canRetry = persisted.lastRequest !== null;
-            persisted.lastFailure = persisted.canRetry
-                ? "The service stopped before the model request completed; the same request can be retried."
-                : "The service stopped before dispatching the model request; use a fresh context.";
-            const streaming = persisted.events.findLast((event) => event.kind === "assistant" && event.status === "streaming");
-            if (streaming !== undefined)
-                streaming.status = "interrupted";
-            persisted.events.push({
-                id: persisted.nextEventId++,
-                kind: "failure",
-                message: persisted.lastFailure,
-            });
-        }
-        const binding = await this.#worlds.bindPlayCallChain(worldId);
-        if (binding.parentHead !== persisted.parentHead)
+        const advance = await this.#worlds.playAdvances.readCurrent(worldId, chainId);
+        const session = await this.#hydrateSession(persisted, advance);
+        this.#active.set(chainId, session);
+        this.#worldChains.set(worldId, chainId);
+        await this.#reconcileSessionAdvance(session, advance);
+        if (session.status === "running")
+            await this.#interruptAbandonedDispatch(session);
+        const currentHead = await this.#worlds.currentHead(worldId);
+        if (currentHead !== session.parentHead)
             throw new PlayCallChainError("The call-chain record differs from the current world endpoint; use a fresh context.");
-        const documents = restorePlayDocuments(binding.files, persisted, persisted.events);
-        const session = {
+        return session;
+    }
+    async #hydrateSession(persisted, advance) {
+        const binding = await this.#worlds.bindPlayCallChain(persisted.worldId);
+        let documents;
+        try {
+            documents = restorePlayDocuments(binding.files, persisted, persisted.events);
+        }
+        catch (error) {
+            const prepared = advance?.settlementPrepared?.settlement;
+            if (prepared === undefined)
+                throw error;
+            documents = new FileNativePlayDocuments(binding.files);
+            documents.restoreAuthorizationCheckpoint(prepared.authorizationCheckpoint);
+        }
+        return {
             ...structuredClone(persisted),
             documentAuthorizationCheckpoints: persisted.documentAuthorizationCheckpoints?.map((checkpoint) => structuredClone(checkpoint)) ?? [],
             nextMaterials: structuredClone(binding.additionalMaterials),
@@ -848,32 +1091,79 @@ export class PlayCallChain {
                 item.key,
                 structuredClone(item),
             ])),
+            persistenceCursor: this.#loadedCursors.get(persisted.chainId) ?? {
+                eventCount: 0,
+                transcriptCount: 0,
+                completedToolCount: 0,
+                authorizationCheckpointCount: 0,
+            },
         };
-        this.#active.set(chainId, session);
-        this.#worldChains.set(worldId, chainId);
-        if (persisted.status === "interrupted")
-            await this.#persist(session);
-        return session;
+    }
+    async #reconcileSessionAdvance(session, loaded) {
+        const current = loaded ??
+            (await this.#worlds.playAdvances.readCurrent(session.worldId, session.chainId));
+        if (current?.settled !== null)
+            return;
+        if (current.base.advanceKind === "player") {
+            await this.#settlePlayerAdvance(session, current.base);
+            return;
+        }
+        if (current.providerCompleted === null) {
+            await this.#interruptAbandonedDispatch(session, current.base);
+            await this.#worlds.playAdvances.markSettled(current.base, session.parentHead);
+            return;
+        }
+        let settlement = current.settlementPrepared?.settlement;
+        if (settlement === undefined) {
+            settlement = this.#prepareResponseSettlement(session, current.base, current.providerCompleted.response);
+            await this.#worlds.playAdvances.recordSettlementPrepared(current.base, settlement);
+        }
+        await this.#settleResponseAdvance(session, current.base, settlement);
+    }
+    async #interruptAbandonedDispatch(session, advance) {
+        const streaming = session.events.findLast((event) => event.kind === "assistant" &&
+            event.status === "streaming" &&
+            (advance === undefined || event.id === advance.eventId));
+        if (streaming !== undefined)
+            streaming.status = "interrupted";
+        const dispatchMayHaveStarted = advance !== undefined;
+        const canRetry = !dispatchMayHaveStarted && session.lastRequest !== null;
+        const message = dispatchMayHaveStarted
+            ? "The service stopped after model dispatch may have started; the outcome is unknown and the request cannot be replayed. Use a fresh context."
+            : canRetry
+                ? "The service stopped before model dispatch; the frozen request can be retried."
+                : "The service stopped before preparing a model request; use a fresh context.";
+        session.events.push({
+            id: session.nextEventId++,
+            kind: "failure",
+            message,
+        });
+        session.status = "interrupted";
+        session.canRetry = canRetry;
+        session.lastFailure = message;
+        await this.#persist(session);
     }
     async #assertCurrentHead(session) {
         if ((await this.#worlds.currentHead(session.worldId)) !== session.parentHead)
             throw new PlayCallChainError("Another operation has advanced the current world; use a fresh context.");
     }
     async #readPersisted(worldId) {
-        const value = await this.#worlds.readPlayCallChain(worldId);
-        if (value === null)
+        await this.#worlds.ensureCurrentStorage(worldId);
+        const loaded = await this.#worlds.playTimeline.readCurrent(worldId);
+        if (loaded === null)
             return null;
-        assertPersistedPlayCallChain(value, worldId);
-        return { ...structuredClone(value), schemaVersion: 1 };
+        this.#loadedCursors.set(loaded.value.chainId, loaded.cursor);
+        return structuredClone(loaded.value);
     }
     async #persist(session) {
         touch(session);
         session.completedTools = [...session.completedToolMap.values()].map((item) => structuredClone(item));
-        const { documents: _documents, history: _history, completedToolMap: _completedToolMap, ...persisted } = session;
+        const { documents: _documents, history: _history, completedToolMap: _completedToolMap, persistenceCursor: _persistenceCursor, ...persisted } = session;
         void _documents;
         void _history;
         void _completedToolMap;
-        await this.#worlds.writePlayCallChain(session.worldId, structuredClone(persisted));
+        void _persistenceCursor;
+        session.persistenceCursor = await this.#worlds.playTimeline.persist(structuredClone(persisted), session.persistenceCursor);
     }
 }
 /**
@@ -884,21 +1174,72 @@ export class PlayCallChain {
 function followupOperationId(session) {
     return `${session.chainId}:followup:${session.parentHead}`;
 }
-function createRequest(session, modelHost, exchange) {
+function createRequest(session, modelHost, exchange, appended = session.transcript) {
+    return createRequestWithMaxOutputTokens(session, modelHost.binding().maxOutputTokens, exchange, appended);
+}
+function createRequestWithMaxOutputTokens(session, maxOutputTokens, exchange, appended = session.transcript) {
     return {
         bootstrap: structuredClone(session.bootstrap),
         tools: structuredClone(session.tools),
         toolUniverse: structuredClone(session.tools),
         allowedTools: session.tools.map(({ name }) => name),
         toolStrategy: session.bootstrap.toolStrategy,
-        appended: structuredClone(session.transcript),
+        appended: structuredClone([...appended]),
         requestId: "play_call_chain",
         operationId: session.chainId,
         requestAttempt: 1,
         exchange,
-        maxOutputTokens: modelHost.binding().maxOutputTokens,
+        maxOutputTokens,
     };
 }
+function durableModelResponse(response) {
+    const { diagnostics: _diagnostics, ...durable } = response;
+    void _diagnostics;
+    return structuredClone(durable);
+}
+function finalizePreparedReceipts(settlement) {
+    const committedWriteRefs = new Set(settlement.stateChanges.map(({ stableShortRef }) => stableShortRef));
+    const markdownByCall = new Map();
+    for (const completed of settlement.completedTools) {
+        const candidateWrite = completed.result.candidateWrite;
+        if (!completed.result.ok || candidateWrite === undefined)
+            continue;
+        const markdown = candidateWrite.changed && committedWriteRefs.has(candidateWrite.shortRef)
+            ? `@${candidateWrite.shortRef} write succeeded`
+            : `@${candidateWrite.shortRef} unchanged`;
+        completed.result.markdown = markdown;
+        delete completed.result.candidateWrite;
+        const callId = completed.key.slice(completed.key.indexOf(":") + 1);
+        markdownByCall.set(callId, markdown);
+    }
+    for (const event of settlement.trailingEvents) {
+        if (event.kind !== "tool_result")
+            continue;
+        const markdown = markdownByCall.get(event.callId);
+        if (markdown !== undefined)
+            event.markdown = markdown;
+    }
+    for (const item of settlement.transcriptAppend) {
+        if (item.kind !== "tool")
+            continue;
+        const markdown = markdownByCall.get(item.toolCallId);
+        if (markdown !== undefined)
+            item.markdown = markdown;
+    }
+}
+function appendCommittedHistory(session, head, messages) {
+    const sequence = Number(head.slice("commit:".length));
+    for (const [index, message] of messages.entries()) {
+        const path = `${session.worldId}.message.${sequence}.${index + 1}.${message.role}`;
+        const existing = session.history.find((item) => item.path === path);
+        if (existing !== undefined) {
+            if (existing.contents !== message.exactText)
+                throw new PlayCallChainError("Recovered Authority history conflicts with the call-chain history.");
+            continue;
+        }
+        session.history.push({ path, contents: message.exactText });
+    }
+}
 function prepareTool(session, working, exchange, call) {
     const key = `${exchange}:${call.id}`;
     const signature = JSON.stringify(call.arguments);
@@ -916,7 +1257,8 @@ function prepareTool(session, working, exchange, call) {
                     markdown: "# Runtime tool rejected\n\nThe same tool-call ID is already bound to another tool name or argument set.",
                 };
     }
-    else if (!callChainToolNames.has(call.name)) {
+    else if (!callChainToolNames.has(call.name) ||
+        !session.tools.some(({ name }) => name === call.name)) {
         result = {
             ok: false,
             failureKind: "protocol",
@@ -960,6 +1302,7 @@ function prepareTool(session, working, exchange, call) {
             kind: "tool",
             toolCallId: call.id,
             markdown: result.markdown,
+            ...(result.ok ? {} : { isError: true }),
         },
     };
 }
@@ -999,19 +1342,6 @@ function restorePlayDocuments(files, context, events) {
     }
     return documents;
 }
-function recordDocumentAuthorizationCheckpoint(session, afterEventId) {
-    const authorization = session.documents.authorizationCheckpoint();
-    const previous = session.documentAuthorizationCheckpoints.at(-1);
-    if (previous !== undefined &&
-        JSON.stringify(previous.authorization) === JSON.stringify(authorization))
-        return;
-    if (previous !== undefined && afterEventId <= previous.afterEventId)
-        throw new PlayCallChainError("Call-chain document authorization checkpoints are out of order.");
-    session.documentAuthorizationCheckpoints.push({
-        afterEventId,
-        authorization,
-    });
-}
 function documentAuthorizationThroughEvents(context, events) {
     const checkpoints = context.documentAuthorizationCheckpoints;
     if (checkpoints === undefined || checkpoints.length === 0)
@@ -1023,20 +1353,6 @@ function documentAuthorizationThroughEvents(context, events) {
     // old recovery behavior and rebuild only bootstrap authorization.
     return selected === undefined ? undefined : structuredClone(selected);
 }
-function snapshotCurrentContext(session) {
-    const { schemaVersion: _schemaVersion, kind: _kind, worldId: _worldId, previousContexts: _previousContexts, ...context } = session;
-    void _schemaVersion;
-    void _kind;
-    void _worldId;
-    void _previousContexts;
-    return structuredClone(context);
-}
-function persistedContexts(session) {
-    return [
-        ...(session.previousContexts ?? []).map((context) => structuredClone(context)),
-        snapshotCurrentContext(session),
-    ];
-}
 function independentContextCopy(source) {
     const context = structuredClone(source);
     delete context.derivedFrom;
@@ -1068,12 +1384,41 @@ function projectContext(context) {
         playPreset: structuredClone(context.playPreset),
         status: context.status,
         canRetry: context.canRetry,
-        events: structuredClone(context.events),
+        events: context.events
+            .slice(-projectedEventTail)
+            .map((event) => projectActivityEvent(event)),
         changedDocuments: structuredClone(context.changedDocuments),
         lastFailure: context.lastFailure,
         updatedAt: context.updatedAt,
     };
 }
+function projectActivityEvent(event) {
+    if (event.kind === "player" || event.kind === "failure")
+        return structuredClone(event);
+    if (event.kind === "assistant") {
+        const { reasoning, toolFragment, usage, ...summary } = event;
+        void reasoning;
+        void toolFragment;
+        void usage;
+        return structuredClone(summary);
+    }
+    if (event.kind === "tool_call")
+        return { ...structuredClone(event), arguments: null };
+    if (event.kind === "tool_result")
+        return { ...structuredClone(event), markdown: "" };
+    const { reasoning, usage, ...summary } = event;
+    void reasoning;
+    void usage;
+    return {
+        ...structuredClone(summary),
+        text: "",
+        toolCalls: event.toolCalls.map((call) => ({
+            ...structuredClone(call),
+            arguments: null,
+            markdown: "",
+        })),
+    };
+}
 function projectView(session) {
     return {
         ...projectContext(session),
@@ -1111,7 +1456,9 @@ function transcriptThroughEvents(transcript, events) {
                 .find((candidate) => candidate.kind === "player" ||
                 candidate.kind === "assistant" ||
                 candidate.kind === "tool_call");
-            const recorded = event.text.trim().length > 0 || hasToolCall?.kind === "tool_call";
+            const recorded = event.text.trim().length > 0 ||
+                hasToolCall?.kind === "tool_call" ||
+                transcript[cursor]?.kind === "assistant";
             if (!recorded)
                 continue;
             const item = transcript[cursor];
@@ -1168,84 +1515,14 @@ function operationId(chainId, key) {
         .update(`${chainId}\0${key}`)
         .digest("hex")}`;
 }
-function assertPersistedPlayCallChain(value, worldId) {
-    if (!isRecord(value) ||
-        (value.schemaVersion !== 1 && value.schemaVersion !== 2) ||
-        value.kind !== "play_call_chain" ||
-        value.worldId !== worldId ||
-        !isPersistedPlayCallChainContext(value) ||
-        (value.previousContexts !== undefined &&
-            (!Array.isArray(value.previousContexts) ||
-                value.previousContexts.some((context) => !isPersistedPlayCallChainContext(context)))))
-        throw new PlayCallChainError("The persisted call-chain record does not match the current format and cannot be read.");
+function assertModelHostBinding(frozen, modelHost) {
+    if (!equalModelHostBinding(frozen, modelHost.binding()))
+        throw new PlayCallChainError("The selected model connection does not match the frozen model binding; start a fresh context.");
 }
-function isPersistedPlayCallChainContext(value) {
-    if (!isRecord(value))
-        return false;
-    return (typeof value.chainId === "string" &&
-        typeof value.baselineHead === "string" &&
-        (value.baselineHistoryLength === undefined ||
-            (typeof value.baselineHistoryLength === "number" &&
-                Number.isSafeInteger(value.baselineHistoryLength) &&
-                value.baselineHistoryLength >= 0)) &&
-        typeof value.parentHead === "string" &&
-        (value.derivedFrom === undefined ||
-            (isRecord(value.derivedFrom) &&
-                typeof value.derivedFrom.worldId === "string" &&
-                typeof value.derivedFrom.chainId === "string" &&
-                typeof value.derivedFrom.head === "string")) &&
-        (value.branchedBeforePlayer === undefined ||
-            (isRecord(value.branchedBeforePlayer) &&
-                typeof value.branchedBeforePlayer.worldId === "string" &&
-                typeof value.branchedBeforePlayer.chainId === "string" &&
-                Number.isSafeInteger(value.branchedBeforePlayer.eventId) &&
-                value.branchedBeforePlayer.eventId > 0)) &&
-        isRecord(value.playPreset) &&
-        (value.followups === undefined || Array.isArray(value.followups)) &&
-        (value.playPresetScriptsEnabled === undefined ||
-            typeof value.playPresetScriptsEnabled === "boolean") &&
-        (value.status === "ready" ||
-            value.status === "running" ||
-            value.status === "interrupted") &&
-        typeof value.canRetry === "boolean" &&
-        isRecord(value.bootstrap) &&
-        Array.isArray(value.tools) &&
-        Array.isArray(value.transcript) &&
-        Array.isArray(value.events) &&
-        Array.isArray(value.completedTools) &&
-        (value.documentAuthorizationCheckpoints === undefined ||
-            isPersistedDocumentAuthorizationHistory(value.documentAuthorizationCheckpoints, value.events)) &&
-        Array.isArray(value.changedDocuments) &&
-        Array.isArray(value.nextMaterials) &&
-        Number.isSafeInteger(value.nextEventId) &&
-        Number.isSafeInteger(value.exchange) &&
-        (value.lastRequest === null || isRecord(value.lastRequest)) &&
-        Number.isSafeInteger(value.lastRequestAttempt) &&
-        (value.lastFailure === null || typeof value.lastFailure === "string") &&
-        typeof value.updatedAt === "number");
-}
-function isPersistedDocumentAuthorizationHistory(value, events) {
-    if (!Array.isArray(value) || value.length > 100_000)
-        return false;
-    const eventIds = new Set(events.flatMap((event) => isRecord(event) && Number.isSafeInteger(event.id) && Number(event.id) > 0
-        ? [Number(event.id)]
-        : []));
-    let previousEventId = -1;
-    for (const checkpoint of value) {
-        if (!isRecord(checkpoint) ||
-            Object.keys(checkpoint).length !== 2 ||
-            !Object.hasOwn(checkpoint, "afterEventId") ||
-            !Object.hasOwn(checkpoint, "authorization") ||
-            !Number.isSafeInteger(checkpoint.afterEventId) ||
-            Number(checkpoint.afterEventId) < 0 ||
-            Number(checkpoint.afterEventId) <= previousEventId ||
-            (Number(checkpoint.afterEventId) !== 0 &&
-                !eventIds.has(Number(checkpoint.afterEventId))) ||
-            !isPlayDocumentAuthorizationCheckpoint(checkpoint.authorization))
-            return false;
-        previousEventId = Number(checkpoint.afterEventId);
-    }
-    return true;
+function assertSessionModelHostBinding(session, modelHost) {
+    if (session.modelBinding === undefined)
+        throw new PlayCallChainError("This model context predates durable provider continuation bindings; start a fresh context.");
+    assertModelHostBinding(session.modelBinding, modelHost);
 }
 function validateIdentity(value, label) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/u.test(value))
@@ -1275,6 +1552,8 @@ function notifyAssistantDelta(observer, delta) {
         // See notifySnapshot: the Provider exchange outlives its browser stream.
     }
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+function crashAtPlayAdvanceEdge(edge) {
+    if (process.env.NODE_ENV === "test" &&
+        process.env.NARRAEON_INTERNAL_TEST_CRASH_AT_PLAY_ADVANCE_EDGE === edge)
+        throw new Error(`Simulated process exit at play advance edge: ${edge}`);
 }