narraeon 0.2.0 → 0.3.1

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { equalModelHostBinding, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "../model/ModelHost.js";
+import { equalModelHostBinding, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "../model/ModelHost.js";
 import { FileNativePromptCompiler, } from "../prompt/FileNativePromptCompiler.js";
 import { runPlayFollowupRequests, } from "./PlayFollowupRequests.js";
 import { FileNativePlayDocuments, fingerprintControl, } from "./PlayDocumentTools.js";
@@ -35,6 +35,7 @@ export class PlayCallChain {
     #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;
@@ -42,6 +43,9 @@ 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);
@@ -134,9 +138,12 @@ export class PlayCallChain {
         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);
@@ -147,10 +154,10 @@ export class PlayCallChain {
             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);
@@ -158,14 +165,100 @@ 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) {
-            await this.#reconcileSessionAdvance(active);
-            return projectView(active);
+            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)
@@ -177,7 +270,28 @@ export class PlayCallChain {
         await this.#reconcileSessionAdvance(session, advance);
         if (session.status === "running")
             await this.#interruptAbandonedDispatch(session);
-        return projectView(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,
+            });
+        return result;
     }
     async forkToDerivedWorld(input) {
         const existing = await this.#readPersisted(input.targetWorldId);
@@ -193,12 +307,34 @@ export class PlayCallChain {
         const sourceContext = sourceContexts[selectedContextIndex];
         const sourceEvents = eventsThroughHead(sourceContext.events, input.sourceHead);
         return this.#forkSelectionToDerivedWorld({
+            sourceWorldId: input.sourceWorldId,
+            sourceContexts,
+            selectedContextIndex,
+            sourceEvents,
+            sourceHead: input.sourceHead,
+            targetWorldId: input.targetWorldId,
+            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,
         });
     }
     /**
@@ -232,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",
@@ -374,20 +514,36 @@ 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();
@@ -396,7 +552,7 @@ export class PlayCallChain {
             .slice(0, input.selectedContextIndex)
             .entries()) {
             const chainId = derivedChainId(context.chainId, `prefix:${input.branchIdentity}:${index}`, input.targetWorldId);
-            await this.#worlds.playTimeline.persist({
+            const previousContext = {
                 ...independentContextCopy(context),
                 schemaVersion: 3,
                 kind: "play_call_chain",
@@ -405,7 +561,16 @@ export class PlayCallChain {
                 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 = {
@@ -438,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),
@@ -452,7 +617,15 @@ export class PlayCallChain {
             lastFailure: null,
             updatedAt: now,
         };
-        await this.#worlds.playTimeline.persist(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) {
@@ -464,7 +637,7 @@ 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")
@@ -505,7 +678,7 @@ export class PlayCallChain {
             if (accepted.outcome === "committed" ||
                 accepted.outcome === "committed_materialization_pending") {
                 await this.#settlePlayerAdvance(session, advance);
-                return this.#dispatch(session, modelHost, structuredClone(nextRequest), 1, observer);
+                return this.#dispatch(session, modelHost, structuredClone(nextRequest), 1, signal, observer);
             }
             const message = error instanceof Error
                 ? error.message
@@ -522,7 +695,7 @@ export class PlayCallChain {
             await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
             throw new PlayCallChainError(message);
         }
-        return this.#dispatch(session, modelHost, structuredClone(nextRequest), 1, observer);
+        return this.#dispatch(session, modelHost, structuredClone(nextRequest), 1, signal, observer);
     }
     async #settlePlayerAdvance(session, advance) {
         const outcome = await this.#worlds.commitPlayStep({
@@ -786,10 +959,14 @@ export class PlayCallChain {
             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) {
+    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;
@@ -824,11 +1001,22 @@ export class PlayCallChain {
             };
             await this.#worlds.playAdvances.begin(advance);
             crashAtPlayAdvanceEdge("after_response_advance_began");
-            notifySnapshot(observer, session);
+            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")
@@ -844,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);
             }
@@ -854,7 +1049,9 @@ 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";
@@ -865,7 +1062,7 @@ export class PlayCallChain {
                 session.lastFailure = message;
                 await this.#persist(session);
                 await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
-                notifySnapshot(observer, session);
+                this.#notifySnapshot(observer, session);
                 return projectView(session);
             }
             const durableResponse = durableModelResponse(response);
@@ -909,11 +1106,11 @@ export class PlayCallChain {
                                     },
                                 ],
                             });
-                        notifySnapshot(observer, session);
+                        this.#notifySnapshot(observer, session);
                         return projectView(session);
                     }
                     if (settled.status !== "ready") {
-                        notifySnapshot(observer, session);
+                        this.#notifySnapshot(observer, session);
                         return projectView(session);
                     }
                     // The exchange has settled: no tool call is pending and the narrative
@@ -926,13 +1123,31 @@ 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);
                 }
-                notifySnapshot(observer, session);
+                this.#notifySnapshot(observer, session);
                 request = settled.nextRequest;
                 attempt = 1;
             }
@@ -942,10 +1157,10 @@ export class PlayCallChain {
                     if (recovered.kind === "continue") {
                         request = recovered.nextRequest;
                         attempt = 1;
-                        notifySnapshot(observer, session);
+                        this.#notifySnapshot(observer, session);
                         continue;
                     }
-                    notifySnapshot(observer, session);
+                    this.#notifySnapshot(observer, session);
                     return projectView(session);
                 }
                 const message = error instanceof Error
@@ -970,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.
      *
@@ -983,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",
@@ -1002,7 +1253,7 @@ export class PlayCallChain {
                 ...(outcome.failure === undefined ? {} : { failure: outcome.failure }),
             });
             touch(session);
-            notifySnapshot(observer, session);
+            this.#notifySnapshot(observer, session);
         };
         try {
             await runPlayFollowupRequests({
@@ -1027,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) {
@@ -1230,7 +1493,7 @@ function finalizePreparedReceipts(settlement) {
 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 path = `message.${sequence}.${index + 1}.${message.role}`;
         const existing = session.history.find((item) => item.path === path);
         if (existing !== undefined) {
             if (existing.contents !== message.exactText)
@@ -1393,7 +1656,9 @@ function projectContext(context) {
     };
 }
 function projectActivityEvent(event) {
-    if (event.kind === "player" || event.kind === "failure")
+    if (event.kind === "player" ||
+        event.kind === "failure" ||
+        event.kind === "cancellation")
         return structuredClone(event);
     if (event.kind === "assistant") {
         const { reasoning, toolFragment, usage, ...summary } = event;
@@ -1535,21 +1800,12 @@ 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 crashAtPlayAdvanceEdge(edge) {