narraeon 0.1.1 → 0.3.0

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

@@ -1,14 +1,19 @@
 import { createHash } from "node:crypto";
+import { equalModelHostBinding, ModelHostCancelledError, 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,8 @@ export class PlayCallChain {
     #failureLog;
     #active = new Map();
     #worldChains = new Map();
+    #loadedCursors = new Map();
+    #activeInvocations = new Map();
     constructor(worlds, compiler = new FileNativePromptCompiler(), artifacts, failureLog) {
         this.#worlds = worlds;
         this.#compiler = compiler;
@@ -34,9 +43,13 @@ export class PlayCallChain {
         this.#failureLog = failureLog;
     }
     async start(input) {
+        return this.#runInvocation(input, (signal) => this.#start(input, signal));
+    }
+    async #start(input, signal) {
         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 +83,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 +101,7 @@ export class PlayCallChain {
             },
             followups: structuredClone(compilation.followups ?? []),
             playPresetScriptsEnabled: input.playPreset.scriptsEnabled,
+            modelBinding: structuredClone(input.modelBinding),
             status: "ready",
             canRetry: false,
             bootstrap,
@@ -114,28 +126,38 @@ 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);
         this.#active.set(session.chainId, session);
         this.#worldChains.set(session.worldId, session.chainId);
         await this.#persist(session);
-        return this.#submitPlayer(session, input.exchangeId, input.playerText, "fresh", input.modelHost, input.observer);
+        return this.#submitPlayer(session, input.exchangeId, input.playerText, "fresh", input.modelHost, signal, input.observer);
     }
     async append(input) {
+        return this.#runInvocation(input, (signal) => this.#append(input, signal));
+    }
+    async #append(input, signal) {
         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.");
             if (session.status === "interrupted") {
                 if (!session.canRetry || session.lastRequest === null)
                     throw new PlayCallChainError("Call-chain processing failed, and there is no model context to continue.");
-                return this.#dispatch(session, input.modelHost, structuredClone(session.lastRequest), session.lastRequestAttempt + 1, input.observer);
+                return this.#dispatch(session, input.modelHost, structuredClone(session.lastRequest), session.lastRequestAttempt + 1, signal, input.observer);
             }
             session.exchange += 1;
-            return this.#dispatch(session, input.modelHost, createRequest(session, input.modelHost, session.exchange), 1, input.observer);
+            return this.#dispatch(session, input.modelHost, createRequest(session, input.modelHost, session.exchange), 1, signal, input.observer);
         }
         if (duplicatePlayerExchange(session, input.exchangeId, input.playerText, "append"))
             return projectView(session);
@@ -143,36 +165,133 @@ export class PlayCallChain {
             throw new PlayCallChainError(session.canRetry
                 ? "The call chain has an incomplete model response; clear the input and append a continuation, or use a fresh context."
                 : "The call chain was interrupted; use a fresh context.");
-        return this.#submitPlayer(session, input.exchangeId, input.playerText, "append", input.modelHost, input.observer);
+        return this.#submitPlayer(session, input.exchangeId, input.playerText, "append", input.modelHost, signal, input.observer);
+    }
+    cancel(input) {
+        validateIdentity(input.worldId, "world ID");
+        validateIdentity(input.chainId, "call-chain ID");
+        validateIdentity(input.exchangeId, "exchange ID");
+        const active = this.#activeInvocations.get(input.chainId);
+        if (active?.worldId !== input.worldId ||
+            active?.exchangeId !== input.exchangeId ||
+            active?.abortable !== true)
+            return { outcome: "not_running" };
+        if (!active.controller.signal.aborted) {
+            active.phase = "cancelling";
+            active.lastActivityAt = Date.now();
+            active.controller.abort();
+        }
+        return { outcome: "cancellation_requested" };
+    }
+    async #runInvocation(input, run) {
+        validateIdentity(input.worldId, "world ID");
+        validateIdentity(input.chainId, "call-chain ID");
+        validateIdentity(input.exchangeId, "exchange ID");
+        if (this.#activeInvocations.has(input.chainId) ||
+            [...this.#activeInvocations.values()].some(({ worldId }) => worldId === input.worldId))
+            throw new PlayCallChainError("A model request is already running for this world or call chain.");
+        const startedAt = Date.now();
+        const invocation = {
+            worldId: input.worldId,
+            chainId: input.chainId,
+            exchangeId: input.exchangeId,
+            phase: "preparing",
+            startedAt,
+            lastActivityAt: startedAt,
+            reasoningChars: 0,
+            textChars: 0,
+            toolChars: 0,
+            toolCalls: 0,
+            dispatches: 0,
+            controller: new AbortController(),
+            abortable: true,
+        };
+        this.#activeInvocations.set(input.chainId, invocation);
+        try {
+            return await run(invocation.controller.signal);
+        }
+        finally {
+            if (this.#activeInvocations.get(input.chainId) === invocation)
+                this.#activeInvocations.delete(input.chainId);
+        }
+    }
+    #observeInvocation(chainId, phase, increments = {}) {
+        const active = this.#activeInvocations.get(chainId);
+        if (active === undefined || active.phase === "cancelling")
+            return;
+        active.phase = phase;
+        active.lastActivityAt = Date.now();
+        active.reasoningChars += increments.reasoningChars ?? 0;
+        active.textChars += increments.textChars ?? 0;
+        active.toolChars += increments.toolChars ?? 0;
+        active.toolCalls += increments.toolCalls ?? 0;
+        active.dispatches += increments.dispatches ?? 0;
+    }
+    #setInvocationAbortable(chainId, abortable) {
+        const active = this.#activeInvocations.get(chainId);
+        if (active !== undefined)
+            active.abortable = abortable;
+    }
+    #projectActiveView(session) {
+        const view = projectView(session);
+        const active = this.#activeInvocations.get(session.chainId);
+        if (active?.worldId !== session.worldId)
+            return view;
+        const { controller: _controller, worldId: _worldId, abortable: _abortable, ...progress } = active;
+        void _controller;
+        void _worldId;
+        void _abortable;
+        return { ...view, activeInvocation: structuredClone(progress) };
+    }
+    #notifySnapshot(observer, session) {
+        try {
+            observer?.onSnapshot?.(this.#projectActiveView(session));
+        }
+        catch {
+            // A browser stream may disconnect while the durable model request keeps
+            // running. Presentation failure never cancels or changes play Authority.
+        }
     }
     async inspectWorld(worldId) {
         const activeId = this.#worldChains.get(worldId);
         const active = activeId === undefined ? undefined : this.#active.get(activeId);
-        if (active !== undefined)
-            return projectView(active);
+        if (active !== undefined) {
+            if (this.#activeInvocations.get(active.chainId)?.worldId !== active.worldId)
+                await this.#reconcileSessionAdvance(active);
+            return this.#projectActiveView(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,
+        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 this.#projectActiveView(session);
+    }
+    async deriveWorld(input) {
+        const result = await this.#worlds.deriveWorld({
+            ...input,
+            stageTarget: async ({ targetWorldRoot, targetWorldId, binding }) => {
+                await this.stageForkToDerivedWorld({
+                    sourceWorldId: input.sourceWorldId,
+                    sourceHead: input.sourceHead,
+                    targetWorldId,
+                    targetWorldRoot,
+                    targetBinding: binding,
+                });
+            },
+        });
+        if ((await this.inspectWorld(result.world.worldId)) === null)
+            await this.forkToDerivedWorld({
+                sourceWorldId: input.sourceWorldId,
+                sourceHead: input.sourceHead,
+                targetWorldId: result.world.worldId,
             });
-            persisted.status = "interrupted";
-            persisted.canRetry = canRetry;
-            persisted.lastFailure = message;
-            persisted.updatedAt = Date.now();
-            await this.#worlds.writePlayCallChain(worldId, persisted);
-        }
-        return projectView(persisted);
+        return result;
     }
     async forkToDerivedWorld(input) {
         const existing = await this.#readPersisted(input.targetWorldId);
@@ -181,13 +300,14 @@ 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;
         const sourceContext = sourceContexts[selectedContextIndex];
         const sourceEvents = eventsThroughHead(sourceContext.events, input.sourceHead);
         return this.#forkSelectionToDerivedWorld({
+            sourceWorldId: input.sourceWorldId,
             sourceContexts,
             selectedContextIndex,
             sourceEvents,
@@ -196,6 +316,27 @@ export class PlayCallChain {
             branchIdentity: input.sourceHead,
         });
     }
+    async stageForkToDerivedWorld(input) {
+        const source = await this.#readPersisted(input.sourceWorldId);
+        if (source === null)
+            return null;
+        const sourceContexts = await this.#worlds.playTimeline.readAllContexts(input.sourceWorldId);
+        const selectedContextIndex = sourceContexts.findIndex(({ events }) => eventsThroughHead(events, input.sourceHead) !== null);
+        if (selectedContextIndex < 0)
+            return null;
+        const sourceEvents = eventsThroughHead(sourceContexts[selectedContextIndex].events, input.sourceHead);
+        return this.#forkSelectionToDerivedWorld({
+            sourceWorldId: input.sourceWorldId,
+            sourceContexts,
+            selectedContextIndex,
+            sourceEvents,
+            sourceHead: input.sourceHead,
+            targetWorldId: input.targetWorldId,
+            branchIdentity: input.sourceHead,
+            targetWorldRoot: input.targetWorldRoot,
+            targetBinding: input.targetBinding,
+        });
+    }
     /**
      * Revise one committed player message in place. Authority remains
      * append-only: one timeline-revision commit restores the player's logical
@@ -216,7 +357,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" &&
@@ -227,8 +368,12 @@ export class PlayCallChain {
                 throw new PlayCallChainError("The same replacement exchange ID is already bound to different player text.");
             const authority = await this.#worlds.readAuthorityHistory(input.worldId);
             const commit = authority.commits.find(({ head }) => head === appliedEvent.committedHead);
-            if (commit?.operationId !== input.operationId ||
-                commit.mode !== "timeline_revision")
+            const operation = await this.#worlds.getOperationOutcome(input.operationId);
+            if (commit?.mode !== "timeline_revision" ||
+                (operation.outcome !== "committed" &&
+                    operation.outcome !== "committed_materialization_pending") ||
+                operation.worldId !== input.worldId ||
+                operation.head !== appliedEvent.committedHead)
                 throw new PlayCallChainError("The replacement exchange ID is already used by another commit.");
             return {
                 outcome: "revised",
@@ -311,13 +456,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 +477,9 @@ export class PlayCallChain {
                 : {
                     playPresetScriptsEnabled: sourceContext.playPresetScriptsEnabled,
                 }),
+            ...(sourceContext.modelBinding === undefined
+                ? {}
+                : { modelBinding: structuredClone(sourceContext.modelBinding) }),
             status: "ready",
             canRetry: false,
             bootstrap: structuredClone(sourceContext.bootstrap),
@@ -351,7 +501,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);
@@ -364,30 +514,73 @@ export class PlayCallChain {
         };
     }
     async #forkSelectionToDerivedWorld(input) {
-        const existing = await this.#readPersisted(input.targetWorldId);
-        if (existing !== null)
-            return projectView(existing);
+        if (input.targetWorldRoot === undefined) {
+            const existing = await this.#readPersisted(input.targetWorldId);
+            if (existing !== null)
+                return projectView(existing);
+        }
         const sourceContext = input.sourceContexts[input.selectedContextIndex];
-        if ((await this.#worlds.currentHead(input.targetWorldId)) !== input.sourceHead)
+        if (input.targetWorldRoot === undefined &&
+            (await this.#worlds.currentHead(input.targetWorldId)) !== input.sourceHead)
             throw new PlayCallChainError("The forked world's Authority does not match the selected history endpoint, so the call chain cannot be written.");
         const [baseline, selected] = await Promise.all([
-            this.#worlds.recoverEndpoint(input.targetWorldId, sourceContext.baselineHead),
-            this.#worlds.recoverEndpoint(input.targetWorldId, input.sourceHead),
+            this.#worlds.recoverEndpoint(input.targetWorldRoot === undefined
+                ? input.targetWorldId
+                : input.sourceWorldId, sourceContext.baselineHead),
+            this.#worlds.recoverEndpoint(input.targetWorldRoot === undefined
+                ? input.targetWorldId
+                : input.sourceWorldId, input.sourceHead),
         ]);
-        const transcript = transcriptThroughEvents(sourceContext.transcript, input.sourceEvents);
-        const completedKeys = completedToolKeys(input.sourceEvents);
+        const selectsCompleteContext = input.sourceEvents.length === sourceContext.events.length;
+        // A complete context already defines the selected trace closure. Preserve
+        // its model transcript verbatim instead of reconstructing it from the
+        // independently persisted page-event projection.
+        const transcript = selectsCompleteContext
+            ? structuredClone(sourceContext.transcript)
+            : transcriptThroughEvents(sourceContext.transcript, input.sourceEvents);
+        const completedKeys = selectsCompleteContext
+            ? null
+            : completedToolKeys(input.sourceEvents);
         const events = structuredClone(input.sourceEvents);
-        const derivedBinding = await this.#worlds.bindPlayCallChain(input.targetWorldId);
+        const derivedBinding = input.targetBinding ??
+            (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);
+            const previousContext = {
+                ...independentContextCopy(context),
+                schemaVersion: 3,
+                kind: "play_call_chain",
+                worldId: input.targetWorldId,
+                chainId,
+                previousContexts: [],
+                previousChainId,
+                timelineGeneration,
+            };
+            if (input.targetWorldRoot === undefined)
+                await this.#worlds.playTimeline.persist(previousContext);
+            else
+                await this.#worlds.playTimeline.cloneContextPrefixToStaging({
+                    sourceWorldId: input.sourceWorldId,
+                    targetWorldRoot: input.targetWorldRoot,
+                    source: context,
+                    target: previousContext,
+                });
+            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 +593,9 @@ export class PlayCallChain {
                 : {
                     playPresetScriptsEnabled: sourceContext.playPresetScriptsEnabled,
                 }),
+            ...(sourceContext.modelBinding === undefined
+                ? {}
+                : { modelBinding: structuredClone(sourceContext.modelBinding) }),
             status: "ready",
             canRetry: false,
             bootstrap: structuredClone(sourceContext.bootstrap),
@@ -407,7 +603,7 @@ export class PlayCallChain {
             transcript,
             events,
             completedTools: sourceContext.completedTools
-                .filter(({ key }) => completedKeys.has(key))
+                .filter(({ key }) => completedKeys === null || completedKeys.has(key))
                 .map((item) => structuredClone(item)),
             documentAuthorizationCheckpoints: authorizationCheckpointsThroughEvents(sourceContext, events, derivedDocuments.authorizationCheckpoint()),
             changedDocuments: changedDocumentsAtHead(sourceContext.changedDocuments, baseline.state, selected.state),
@@ -421,7 +617,15 @@ export class PlayCallChain {
             lastFailure: null,
             updatedAt: now,
         };
-        await this.#worlds.writePlayCallChain(input.targetWorldId, structuredClone(derived));
+        if (input.targetWorldRoot === undefined)
+            await this.#worlds.playTimeline.persist(structuredClone(derived));
+        else
+            await this.#worlds.playTimeline.cloneContextPrefixToStaging({
+                sourceWorldId: input.sourceWorldId,
+                targetWorldRoot: input.targetWorldRoot,
+                source: sourceContext,
+                target: structuredClone(derived),
+            });
         return projectView(derived);
     }
     forgetWorld(worldId) {
@@ -433,22 +637,49 @@ export class PlayCallChain {
             this.#active.delete(activeId);
         this.#worldChains.delete(worldId);
     }
-    async #submitPlayer(session, exchangeId, playerText, context, modelHost, observer) {
+    async #submitPlayer(session, exchangeId, playerText, context, modelHost, signal, observer) {
         if (duplicatePlayerExchange(session, exchangeId, playerText, context))
             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, signal, observer);
+            }
             const message = error instanceof Error
                 ? error.message
                 : "Failed to write the original player text.";
@@ -461,27 +692,281 @@ 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, signal, 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 #dispatch(session, modelHost, firstRequest, firstAttempt, observer) {
+    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, signal, observer) {
         let request = structuredClone(firstRequest);
         let attempt = firstAttempt;
         for (;;) {
+            this.#setInvocationAbortable(session.chainId, true);
+            if (signal.aborted)
+                return this.#cancelBeforeProviderDispatch(session, request, attempt, observer);
+            this.#observeInvocation(session.chainId, "waiting");
             session.status = "running";
             session.canRetry = false;
             session.lastFailure = null;
@@ -493,16 +978,45 @@ export class PlayCallChain {
                 kind: "assistant",
                 text: "",
                 status: "streaming",
+                responseKind: "pending",
                 exchange: responseExchange,
                 attempt,
             };
             session.events.push(event);
             await this.#persist(session);
-            notifySnapshot(observer, 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");
+            this.#notifySnapshot(observer, session);
+            if (signal.aborted)
+                return this.#cancelBeforeProviderDispatch(session, request, attempt, observer, advance);
             let response;
             try {
+                this.#observeInvocation(session.chainId, "waiting", { dispatches: 1 });
                 response = await modelHost.exchange(request, {
+                    signal,
                     onDelta: (delta) => {
+                        this.#observeInvocation(session.chainId, delta.kind, {
+                            ...(delta.kind === "reasoning"
+                                ? { reasoningChars: delta.text.length }
+                                : delta.kind === "text"
+                                    ? { textChars: delta.text.length }
+                                    : { toolChars: delta.text.length }),
+                        });
                         if (delta.kind === "text")
                             event.text += delta.text;
                         else if (delta.kind === "reasoning")
@@ -518,6 +1032,13 @@ export class PlayCallChain {
                         });
                     },
                 });
+                if (signal.aborted)
+                    throw new ModelHostCancelledError("The player cancelled the dispatched model request; its response was not committed and cannot be replayed.");
+                this.#setInvocationAbortable(session.chainId, false);
+                if ((response.toolCalls?.length ?? 0) > 0)
+                    this.#observeInvocation(session.chainId, "tool", {
+                        toolCalls: response.toolCalls?.length ?? 0,
+                    });
                 if (response.diagnostics !== undefined)
                     await this.#failureLog?.recordExchangeIfActive(response.diagnostics);
             }
@@ -528,57 +1049,30 @@ export class PlayCallChain {
                     : "The model request was interrupted.";
                 session.events.push({
                     id: session.nextEventId++,
-                    kind: "failure",
+                    kind: error instanceof ModelHostCancelledError
+                        ? "cancellation"
+                        : "failure",
                     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);
-                notifySnapshot(observer, session);
+                await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
+                this.#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 +1081,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,16 +1106,11 @@ 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);
+                        this.#notifySnapshot(observer, session);
+                        return projectView(session);
+                    }
+                    if (settled.status !== "ready") {
+                        this.#notifySnapshot(observer, session);
                         return projectView(session);
                     }
                     // The exchange has settled: no tool call is pending and the narrative
@@ -680,19 +1123,46 @@ export class PlayCallChain {
                             message: "The play call chain recovered during a later model exchange and completed.",
                             details: { parentHead: session.parentHead },
                         });
-                    await this.#runFollowups(session, modelHost, observer);
+                    if ((session.followups?.length ?? 0) > 0) {
+                        // Follow-up artifacts are part of this player-visible invocation.
+                        // Keep `running` ephemeral: the settled main response remains the
+                        // durable recovery point if this Runtime process stops here.
+                        session.status = "running";
+                        this.#observeInvocation(session.chainId, "followup");
+                        this.#setInvocationAbortable(session.chainId, true);
+                        this.#notifySnapshot(observer, session);
+                    }
+                    await this.#runFollowups(session, modelHost, signal, observer);
+                    this.#setInvocationAbortable(session.chainId, false);
+                    if (signal.aborted) {
+                        session.events.push({
+                            id: session.nextEventId++,
+                            kind: "cancellation",
+                            message: "The player cancelled the remaining follow-up generation after the narrative was committed.",
+                        });
+                        touch(session);
+                    }
                     session.status = "ready";
                     await this.#persist(session);
-                    notifySnapshot(observer, session);
+                    this.#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);
+                this.#notifySnapshot(observer, session);
+                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;
+                        this.#notifySnapshot(observer, session);
+                        continue;
+                    }
+                    this.#notifySnapshot(observer, session);
+                    return projectView(session);
+                }
                 const message = error instanceof Error
                     ? error.message
                     : "Call-chain processing failed.";
@@ -715,11 +1185,34 @@ export class PlayCallChain {
                 session.canRetry = false;
                 session.lastFailure = message;
                 await this.#persist(session);
-                notifySnapshot(observer, session);
+                this.#notifySnapshot(observer, session);
                 return projectView(session);
             }
         }
     }
+    async #cancelBeforeProviderDispatch(session, request, attempt, observer, advance) {
+        if (advance !== undefined) {
+            const streaming = session.events.find((event) => event.kind === "assistant" && event.id === advance.eventId);
+            if (streaming !== undefined)
+                streaming.status = "interrupted";
+        }
+        const message = "The player cancelled before the next Provider dispatch; the frozen request can be resumed without replaying a completed model result.";
+        session.events.push({
+            id: session.nextEventId++,
+            kind: "cancellation",
+            message,
+        });
+        session.status = "interrupted";
+        session.canRetry = true;
+        session.lastRequest = structuredClone(request);
+        session.lastRequestAttempt = Math.max(0, attempt - 1);
+        session.lastFailure = message;
+        await this.#persist(session);
+        if (advance !== undefined)
+            await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
+        this.#notifySnapshot(observer, session);
+        return projectView(session);
+    }
     /**
      * Dispatch the frozen follow-ups once against the settled exchange.
      *
@@ -728,11 +1221,24 @@ export class PlayCallChain {
      * player nothing more than a missing panel. Failures are recorded in the
      * trace and the chain still returns to `ready`.
      */
-    async #runFollowups(session, modelHost, observer) {
+    async #runFollowups(session, modelHost, signal, observer) {
         const followups = session.followups ?? [];
         if (this.#artifacts === undefined || followups.length === 0)
             return;
+        const observeFollowupDelta = (delta) => {
+            this.#observeInvocation(session.chainId, "followup", {
+                ...(delta.kind === "reasoning"
+                    ? { reasoningChars: delta.text.length }
+                    : delta.kind === "text"
+                        ? { textChars: delta.text.length }
+                        : { toolChars: delta.text.length }),
+            });
+            this.#notifySnapshot(observer, session);
+        };
         const record = (outcome) => {
+            this.#observeInvocation(session.chainId, "followup", {
+                toolCalls: outcome.toolCalls.length,
+            });
             session.events.push({
                 id: session.nextEventId++,
                 kind: "followup",
@@ -747,7 +1253,7 @@ export class PlayCallChain {
                 ...(outcome.failure === undefined ? {} : { failure: outcome.failure }),
             });
             touch(session);
-            notifySnapshot(observer, session);
+            this.#notifySnapshot(observer, session);
         };
         try {
             await runPlayFollowupRequests({
@@ -772,10 +1278,22 @@ export class PlayCallChain {
                 },
                 head: session.parentHead,
                 maxOutputTokens: modelHost.binding().maxOutputTokens,
+                signal,
                 ...(this.#failureLog === undefined
                     ? {}
                     : { failureLog: this.#failureLog }),
-                observer: { onOutcome: record },
+                observer: {
+                    onProviderDispatch: () => {
+                        this.#setInvocationAbortable(session.chainId, true);
+                        this.#observeInvocation(session.chainId, "followup", {
+                            dispatches: 1,
+                        });
+                        this.#notifySnapshot(observer, session);
+                    },
+                    onProviderDelta: observeFollowupDelta,
+                    onProviderSettled: () => this.#setInvocationAbortable(session.chainId, false),
+                    onOutcome: record,
+                },
             });
         }
         catch (error) {
@@ -789,56 +1307,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 +1354,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 +1437,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 = `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 +1520,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 +1565,7 @@ function prepareTool(session, working, exchange, call) {
             kind: "tool",
             toolCallId: call.id,
             markdown: result.markdown,
+            ...(result.ok ? {} : { isError: true }),
         },
     };
 }
@@ -999,19 +1605,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 +1616,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 +1647,43 @@ 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" ||
+        event.kind === "cancellation")
+        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 +1721,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 +1780,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 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 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 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))
@@ -1258,23 +1800,16 @@ function validatePlayerText(value) {
 function touch(session) {
     session.updatedAt = Date.now();
 }
-function notifySnapshot(observer, session) {
-    try {
-        observer?.onSnapshot?.(projectView(session));
-    }
-    catch {
-        // A browser stream may disconnect while the durable model request keeps
-        // running. Presentation failure never cancels or changes play Authority.
-    }
-}
 function notifyAssistantDelta(observer, delta) {
     try {
         observer?.onAssistantDelta?.(structuredClone(delta));
     }
     catch {
-        // See notifySnapshot: the Provider exchange outlives its browser stream.
+        // Like snapshot projection, 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}`);
 }