narraeon 0.5.6 → 0.6.0

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

@@ -1,3 +1,6 @@
+import { projectLegacyModelBindingFailure } from "./LegacyModelBindingFailure.js";
+import { classifyPlayFailure } from "./PlayFailure.js";
+import { isResolutionTool, resolutionMarkdown, resolutionToolNames, resolveTabletop, seededRandom, } from "./TabletopResolution.js";
 import { captureNarrativeOrigin, snapshotBackground, narrativeBackground, } from "../history/HistoryBackground.js";
 import { isDeepStrictEqual } from "node:util";
 import { hasLegacyHistoryTools } from "../prompt/FileNativeToolRegistry.js";
@@ -10,12 +13,13 @@ import { completedPlayerRounds, continuationNotice, playerInputAppend, toolStepN
 import { renderFreshContextCoverage } from "../prompt/WorldMaterialCoverage.js";
 import { renderWriteSizeAdvice, readDeclaredWorldClock, } from "../prompt/WorldMaintenanceReport.js";
 import { WorldDocumentStore } from "../world/WorldDocumentStore.js";
-import { equalModelHostBinding, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, modelHostFailureRequiresFreshContext, } from "../model/ModelHost.js";
+import { equalModelHostBinding, ModelHostBindingMismatchError, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, modelHostFailureRequiresFreshContext, } from "../model/ModelHost.js";
 import { FileNativePromptCompiler, } from "../prompt/FileNativePromptCompiler.js";
 import { parsePlayPresetFiles, } from "./FileNativePlayPresetStore.js";
 import { runPlayFollowupRequests, } from "./PlayFollowupRequests.js";
 import { FileNativePlayDocuments, fingerprintControl, } from "./PlayDocumentTools.js";
 const callChainToolNames = new Set([
+    ...resolutionToolNames,
     "state_list",
     "history_list",
     "history_search",
@@ -162,6 +166,7 @@ export class PlayCallChain {
         this.#active.set(session.chainId, session);
         this.#worldChains.set(session.worldId, session.chainId);
         await this.#persist(session);
+        await this.#worlds.completeArchiveFreshContext(session.worldId);
         return this.#submitPlayer(session, input.exchangeId, input.playerText, "fresh", input.modelHost, signal, input.observer);
     }
     async append(input) {
@@ -169,6 +174,8 @@ export class PlayCallChain {
     }
     async #append(input, signal) {
         validateIdentity(input.exchangeId, "exchange ID");
+        if (await this.#worlds.archiveNeedsFreshContext(input.worldId))
+            throw new PlayCallChainError("This world was imported from a backup; start a fresh context before continuing.");
         const session = await this.#requireChain(input.worldId, input.chainId);
         await this.#assertCurrentHead(session);
         assertSessionModelHostBinding(session, input.modelHost);
@@ -178,6 +185,11 @@ export class PlayCallChain {
             if (session.status === "interrupted") {
                 if (!session.canRetry || session.lastRequest === null)
                     throw new PlayCallChainError("The current model context cannot continue; use a fresh context.");
+                // Pre-snapshot requests have only a binding fingerprint. Do not invent
+                // their original encoding settings from a newly selected connection.
+                if (session.lastRequest.modelConfig === undefined &&
+                    !equalModelHostBinding(session.modelBinding, input.modelHost.binding()))
+                    throw new PlayCallChainError("This older saved request has no model configuration snapshot. Restore its original settings to retry it, or start a fresh context.");
                 return this.#dispatch(session, input.modelHost, structuredClone(session.lastRequest), session.lastRequestAttempt + 1, signal, input.observer);
             }
             await this.#refreshPrompt(session, input);
@@ -464,7 +476,8 @@ export class PlayCallChain {
             chainId: session.chainId,
             baselineHead: session.baselineHead,
             parentHead: session.parentHead,
-            stale: session.parentHead !== worldHead,
+            stale: session.parentHead !== worldHead ||
+                (await this.#worlds.archiveNeedsFreshContext(worldId)),
             playPreset: structuredClone(recordedPlayPrompt(session).playPreset),
             updatedAt: session.updatedAt,
             bootstrap: {
@@ -477,17 +490,25 @@ export class PlayCallChain {
     async deriveWorld(input) {
         const result = await this.#worlds.deriveWorld({
             ...input,
-            stageTarget: async ({ targetWorldRoot, targetWorldId, binding }) => {
+            stageTarget: async ({ targetWorldRoot, targetWorldId, binding, sourceHead, }) => {
                 await this.stageForkToDerivedWorld({
                     sourceWorldId: input.sourceWorldId,
-                    sourceHead: input.sourceHead,
+                    sourceHead,
                     targetWorldId,
                     targetWorldRoot,
                     targetBinding: binding,
+                    ...(input.retainCompleteTimeline
+                        ? { retainCompleteTimeline: true }
+                        : {}),
+                    ...(input.identityPrefix === "import"
+                        ? { markImportedContexts: true }
+                        : {}),
                 });
             },
         });
-        if ((await this.inspectWorld(result.world.worldId)) === null)
+        if (input.targetDataRoot === undefined &&
+            input.publish !== false &&
+            (await this.inspectWorld(result.world.worldId)) === null)
             await this.forkToDerivedWorld({
                 sourceWorldId: input.sourceWorldId,
                 sourceHead: input.sourceHead,
@@ -523,10 +544,14 @@ export class PlayCallChain {
         if (source === null)
             return null;
         const sourceContexts = await this.#worlds.playTimeline.readAllContexts(input.sourceWorldId);
-        const selectedContextIndex = sourceContexts.findIndex(({ events }) => eventsThroughHead(events, input.sourceHead) !== null);
+        const selectedContextIndex = input.retainCompleteTimeline
+            ? sourceContexts.length - 1
+            : sourceContexts.findIndex(({ events }) => eventsThroughHead(events, input.sourceHead) !== null);
         if (selectedContextIndex < 0)
             return null;
-        const sourceEvents = eventsThroughHead(sourceContexts[selectedContextIndex].events, input.sourceHead);
+        const sourceEvents = input.retainCompleteTimeline
+            ? sourceContexts[selectedContextIndex].events
+            : eventsThroughHead(sourceContexts[selectedContextIndex].events, input.sourceHead);
         return this.#forkSelectionToDerivedWorld({
             sourceWorldId: input.sourceWorldId,
             sourceContexts,
@@ -537,6 +562,8 @@ export class PlayCallChain {
             branchIdentity: input.sourceHead,
             targetWorldRoot: input.targetWorldRoot,
             targetBinding: input.targetBinding,
+            ...(input.retainCompleteTimeline ? { retainCompleteTimeline: true } : {}),
+            ...(input.markImportedContexts ? { markImportedContexts: true } : {}),
         });
     }
     /**
@@ -604,6 +631,9 @@ export class PlayCallChain {
         if (selectedContextIndex < 0)
             throw new PlayCallChainError("The model context to revise does not exist.");
         const sourceContext = sourceContexts[selectedContextIndex];
+        if (input.continuation === "continue_context" &&
+            sourceContext.importedFromArchive)
+            throw new PlayCallChainError("This model context was imported from a backup; start a fresh context before continuing.");
         const selectedEventIndex = sourceContext.events.findIndex((event) => event.id === input.eventId);
         const selectedEvent = sourceContext.events[selectedEventIndex];
         if (selectedEventIndex < 0 ||
@@ -632,10 +662,15 @@ export class PlayCallChain {
         const timelineGeneration = playerRevisionTimelineGeneration(input.source.timelineGeneration, request.operationId, request.worldId, request.continuation);
         const requestFingerprint = playerRevisionRequestFingerprint(request, input.selectedEvent.committedHead, restoresHead);
         const traceRetention = preparePlayerRevisionTrace(sourceContext, input.selectedEventIndex);
+        // A timeline revision appends on the current audit head and restores the
+        // selected message's logical parent, so a chain that lags the world (an
+        // out-of-story world revision, or an earlier revision whose chain was not
+        // published) must not block it. The commit still rechecks this head under
+        // the world lock.
         const outcome = await this.#worlds.reviseTimeline({
             operationId: request.operationId,
             worldId: request.worldId,
-            expectedCurrentHead: input.source.parentHead,
+            expectedCurrentHead: await this.#worlds.currentHead(request.worldId),
             restoresHead,
             replacesHead: input.selectedEvent.committedHead,
             replacementText: request.replacementText,
@@ -646,11 +681,10 @@ export class PlayCallChain {
             this.#worlds.recoverEndpoint(request.worldId, restoresHead),
             this.#worlds.bindPlayCallChain(request.worldId),
         ]);
-        const continuedTrace = traceRetention.withReplacement(selected, {
+        const continuedTrace = traceRetention.withReplacement({
             head: outcome.head,
             exchangeId: request.replacementExchangeId,
             text: request.replacementText,
-            locale: this.#compiler.locale,
         });
         if (binding.parentHead !== outcome.head)
             throw new PlayCallChainError("The timeline revision was committed, but current-world materialization has not reached the new endpoint.");
@@ -672,6 +706,7 @@ export class PlayCallChain {
                 freshPreparation,
             });
             await this.#worlds.playTimeline.persist(structuredClone(revised));
+            await this.#worlds.completeArchiveFreshContext(request.worldId);
             const activeId = this.#worldChains.get(request.worldId);
             if (activeId !== undefined)
                 this.#active.delete(activeId);
@@ -799,13 +834,7 @@ export class PlayCallChain {
                 layout: "world_state",
                 files: Object.entries(input.binding.files).map(([path, contents]) => ({ path, contents })),
             }), 1),
-            transcript: playerInputAppend({
-                history: fresh.binding.history,
-                checkpoint: fresh.binding.narrativeCheckpoint,
-                text: request.replacementText,
-                locale: this.#compiler.locale,
-                checkpointAvailable: fresh.tools.some(({ name }) => name === "world_checkpoint"),
-            }),
+            transcript: playerInputAppend(request.replacementText),
             events: [
                 {
                     id: 1,
@@ -843,22 +872,30 @@ export class PlayCallChain {
         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.targetWorldRoot === undefined
-                ? input.targetWorldId
-                : input.sourceWorldId, sourceContext.baselineHead),
-            this.#worlds.recoverEndpoint(input.targetWorldRoot === undefined
-                ? input.targetWorldId
-                : input.sourceWorldId, input.sourceHead),
-        ]);
-        const traceRetention = prepareForkTrace(sourceContext, input.sourceEvents);
-        const derivedBinding = input.targetBinding ??
-            (await this.#worlds.bindPlayCallChain(input.targetWorldId));
-        const retainedTrace = traceRetention.atEndpoint({
-            baseline,
-            selected,
-            binding: derivedBinding,
-        });
+        let retainedTrace;
+        if (input.retainCompleteTimeline) {
+            // A backup retains the current page closure, even when its last context
+            // precedes a correction or contains an uncommitted response diagnostic.
+            retainedTrace = independentContextCopy(sourceContext);
+        }
+        else {
+            const [baseline, selected] = await Promise.all([
+                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 traceRetention = prepareForkTrace(sourceContext, input.sourceEvents);
+            const derivedBinding = input.targetBinding ??
+                (await this.#worlds.bindPlayCallChain(input.targetWorldId));
+            retainedTrace = traceRetention.atEndpoint({
+                baseline,
+                selected,
+                binding: derivedBinding,
+            });
+        }
         const now = Date.now();
         const timelineGeneration = this.#worlds.playTimeline.newGeneration();
         let previousChainId = null;
@@ -868,6 +905,7 @@ export class PlayCallChain {
             const chainId = derivedChainId(context.chainId, `prefix:${input.branchIdentity}:${index}`, input.targetWorldId);
             const previousContext = {
                 ...independentContextCopy(context),
+                ...(input.markImportedContexts ? { importedFromArchive: true } : {}),
                 schemaVersion: 3,
                 kind: "play_call_chain",
                 worldId: input.targetWorldId,
@@ -884,11 +922,15 @@ export class PlayCallChain {
                     targetWorldRoot: input.targetWorldRoot,
                     source: context,
                     target: previousContext,
+                    ...(input.retainCompleteTimeline
+                        ? { retainCompleteContext: true }
+                        : {}),
                 });
             previousChainId = chainId;
         }
         const derived = {
             ...retainedTrace,
+            ...(input.markImportedContexts ? { importedFromArchive: true } : {}),
             schemaVersion: 3,
             kind: "play_call_chain",
             chainId: derivedChainId(sourceContext.chainId, input.branchIdentity, input.targetWorldId),
@@ -896,7 +938,9 @@ export class PlayCallChain {
             previousContexts: [],
             previousChainId,
             timelineGeneration,
-            parentHead: input.sourceHead,
+            parentHead: input.retainCompleteTimeline
+                ? sourceContext.parentHead
+                : input.sourceHead,
             updatedAt: now,
         };
         if (input.targetWorldRoot === undefined)
@@ -907,6 +951,9 @@ export class PlayCallChain {
                 targetWorldRoot: input.targetWorldRoot,
                 source: sourceContext,
                 target: structuredClone(derived),
+                ...(input.retainCompleteTimeline
+                    ? { retainCompleteContext: true }
+                    : {}),
             });
         if (input.targetWorldRoot !== undefined) {
             const retainedContexts = [
@@ -960,13 +1007,7 @@ export class PlayCallChain {
         const exchange = session.exchange + 1;
         const nextRequest = createRequest(session, modelHost, exchange, [
             ...session.transcript,
-            ...playerInputAppend({
-                history: Object.fromEntries(session.history.map(({ path, contents }) => [path, contents])),
-                checkpoint: session.narrativeCheckpoint,
-                text: playerText,
-                locale: this.#compiler.locale,
-                checkpointAvailable: currentPlayPrompt(session).tools.some(({ name }) => name === "world_checkpoint"),
-            }),
+            ...playerInputAppend(playerText),
         ]);
         const operationKey = `player:${exchangeId}`;
         const playerOperationId = operationId(session.chainId, operationKey);
@@ -1006,14 +1047,17 @@ export class PlayCallChain {
             const message = error instanceof Error
                 ? error.message
                 : "Failed to write the original player text.";
+            const failureKind = classifyPlayFailure(error, false);
             session.events.push({
                 id: session.nextEventId++,
                 kind: "failure",
                 message,
+                failureKind,
             });
             session.status = "interrupted";
             session.canRetry = false;
             session.lastFailure = message;
+            session.lastFailureKind = failureKind;
             await this.#persist(session);
             await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
             throw new PlayCallChainError(message);
@@ -1077,6 +1121,7 @@ export class PlayCallChain {
         session.canRetry = true;
         session.lastFailure =
             "The player message is committed; the frozen model request is ready to continue.";
+        session.lastFailureKind = "retryable";
         await this.#persist(session);
         crashAtPlayAdvanceEdge("after_timeline_settled");
         await this.#worlds.playAdvances.markSettled(advance, outcome.head);
@@ -1114,8 +1159,15 @@ export class PlayCallChain {
         const prepared = [];
         const trailingEvents = [];
         let nextEventId = advance.eventId + 1;
+        // One persisted seed per advance: every resolution call draws from it by
+        // call identity, so recovery reproduces the same receipts.
+        const resolutionSeed = calls.some(({ name }) => isResolutionTool(name))
+            ? await this.#worlds.playAdvances.resolutionSeed(advance)
+            : undefined;
         for (const call of calls) {
-            const item = prepareTool(session, workingTools, advance.exchange, call, this.#compiler.locale);
+            const item = prepareTool(session, workingTools, advance.exchange, call, this.#compiler.locale, resolutionSeed);
+            if (item.result.resolution !== undefined)
+                crashAtPlayAdvanceEdge("after_resolution");
             prepared.push(item);
             trailingEvents.push({
                 id: nextEventId++,
@@ -1343,6 +1395,7 @@ export class PlayCallChain {
         session.exchange = Math.max(session.exchange, advance.exchange);
         session.canRetry = false;
         session.lastFailure = null;
+        delete session.lastFailureKind;
         let result;
         if (settlement.assistantEvent.continuation !== "available") {
             const message = "The complete model response has no provider-native continuation payload; use a fresh context.";
@@ -1350,20 +1403,25 @@ export class PlayCallChain {
                 id: session.nextEventId++,
                 kind: "failure",
                 message,
+                failureKind: "context_unavailable",
             });
             session.status = "interrupted";
             session.lastFailure = message;
+            session.lastFailureKind = "context_unavailable";
             result = { kind: "terminal", status: "interrupted" };
         }
         else if (hasToolCalls) {
             session.exchange += 1;
             const nextRequest = createRequestWithMaxOutputTokens(session, session.lastRequest?.maxOutputTokens ?? 1, session.exchange);
+            if (session.lastRequest?.modelConfig !== undefined)
+                nextRequest.modelConfig = structuredClone(session.lastRequest.modelConfig);
             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.";
+            session.lastFailureKind = "retryable";
             result = { kind: "continue", nextRequest };
         }
         else {
@@ -1374,8 +1432,10 @@ export class PlayCallChain {
                     id: session.nextEventId++,
                     kind: "failure",
                     message,
+                    failureKind: "other",
                 });
                 session.lastFailure = message;
+                session.lastFailureKind = "other";
             }
             result = { kind: "terminal", status: session.status };
         }
@@ -1399,7 +1459,7 @@ export class PlayCallChain {
         return this.#settleResponseAdvance(session, advance, current.settlementPrepared.settlement);
     }
     async #dispatch(session, modelHost, firstRequest, firstAttempt, signal, observer) {
-        let request = structuredClone(firstRequest);
+        let request = modelHost.freezeRequest?.(firstRequest) ?? structuredClone(firstRequest);
         let attempt = firstAttempt;
         for (;;) {
             this.#setInvocationAbortable(session.chainId, true);
@@ -1409,6 +1469,7 @@ export class PlayCallChain {
             session.status = "running";
             session.canRetry = false;
             session.lastFailure = null;
+            delete session.lastFailureKind;
             session.lastRequest = structuredClone(request);
             session.lastRequestAttempt = attempt;
             const responseExchange = request.exchange ?? session.exchange;
@@ -1500,20 +1561,31 @@ export class PlayCallChain {
                 const message = error instanceof Error
                     ? error.message
                     : "The model request was interrupted.";
-                session.events.push({
-                    id: session.nextEventId++,
-                    kind: error instanceof ModelHostCancelledError
-                        ? "cancellation"
-                        : "failure",
-                    message,
-                });
                 session.status = "interrupted";
-                const requiresFreshContext = error instanceof ModelHostContinuationError ||
+                const requiresFreshContext = error instanceof ModelHostBindingMismatchError ||
+                    error instanceof ModelHostContinuationError ||
                     error instanceof ModelHostOutcomeUnknownError ||
                     modelHostFailureRequiresFreshContext(error);
                 session.canRetry =
                     !requiresFreshContext && error instanceof ModelHostFailureError;
                 session.lastFailure = message;
+                if (error instanceof ModelHostCancelledError) {
+                    delete session.lastFailureKind;
+                    session.events.push({
+                        id: session.nextEventId++,
+                        kind: "cancellation",
+                        message,
+                    });
+                }
+                else {
+                    session.lastFailureKind = classifyPlayFailure(error, session.canRetry);
+                    session.events.push({
+                        id: session.nextEventId++,
+                        kind: "failure",
+                        message,
+                        failureKind: session.lastFailureKind,
+                    });
+                }
                 await this.#persist(session);
                 await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
                 this.#notifySnapshot(observer, session);
@@ -1631,14 +1703,17 @@ export class PlayCallChain {
                             },
                         ],
                     });
+                const failureKind = classifyPlayFailure(error, false);
                 session.events.push({
                     id: session.nextEventId++,
                     kind: "failure",
                     message,
+                    failureKind,
                 });
                 session.status = "interrupted";
                 session.canRetry = false;
                 session.lastFailure = message;
+                session.lastFailureKind = failureKind;
                 await this.#persist(session);
                 this.#notifySnapshot(observer, session);
                 return projectView(session);
@@ -1662,6 +1737,7 @@ export class PlayCallChain {
         session.lastRequest = structuredClone(request);
         session.lastRequestAttempt = Math.max(0, attempt - 1);
         session.lastFailure = message;
+        delete session.lastFailureKind;
         await this.#persist(session);
         if (advance !== undefined)
             await this.#worlds.playAdvances.markSettled(advance, session.parentHead);
@@ -1881,14 +1957,21 @@ export class PlayCallChain {
             : 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.";
+        const failureKind = dispatchMayHaveStarted
+            ? "outcome_unknown"
+            : canRetry
+                ? "retryable"
+                : "other";
         session.events.push({
             id: session.nextEventId++,
             kind: "failure",
             message,
+            failureKind,
         });
         session.status = "interrupted";
         session.canRetry = canRetry;
         session.lastFailure = message;
+        session.lastFailureKind = failureKind;
         await this.#persist(session);
     }
     async #assertCurrentHead(session) {
@@ -1923,7 +2006,8 @@ function followupOperationId(session) {
     return `${session.chainId}:followup:${session.parentHead}`;
 }
 function createRequest(session, modelHost, exchange, appended = session.transcript) {
-    return createRequestWithMaxOutputTokens(session, modelHost.binding().maxOutputTokens, exchange, appended);
+    const request = createRequestWithMaxOutputTokens(session, modelHost.binding().maxOutputTokens, exchange, appended);
+    return modelHost.freezeRequest?.(request) ?? request;
 }
 function createRequestWithMaxOutputTokens(session, maxOutputTokens, exchange, appended = session.transcript) {
     return {
@@ -1998,7 +2082,7 @@ function appendCommittedHistory(session, head, messages) {
         });
     }
 }
-function prepareTool(session, working, exchange, call, locale) {
+function prepareTool(session, working, exchange, call, locale, resolutionSeed) {
     const key = `${exchange}:${call.id}`;
     const signature = JSON.stringify(call.arguments);
     const completed = working.get(key);
@@ -2025,8 +2109,9 @@ function prepareTool(session, working, exchange, call, locale) {
     }
     else {
         try {
-            result =
-                call.name === "world_checkpoint"
+            result = isResolutionTool(call.name)
+                ? resolutionToolResult(call.name, call.arguments, resolutionSeed, key, locale)
+                : call.name === "world_checkpoint"
                     ? typeof call.arguments === "object" &&
                         call.arguments !== null &&
                         !Array.isArray(call.arguments) &&
@@ -2069,6 +2154,9 @@ function prepareTool(session, working, exchange, call, locale) {
         name: call.name,
         ok: result.ok,
         markdown: result.markdown,
+        ...(result.resolution === undefined
+            ? {}
+            : { resolution: structuredClone(result.resolution) }),
         replayed,
     };
     return {
@@ -2108,7 +2196,9 @@ function mergeChangedDocuments(session, changes) {
     }
 }
 function projectContext(context) {
+    const response = context.events.findLast((event) => event.kind === "assistant" && event.status === "completed");
     return {
+        ...(context.importedFromArchive ? { requiresFreshContext: true } : {}),
         chainId: context.chainId,
         baselineHead: context.baselineHead,
         ...(context.baselineHistoryLength === undefined
@@ -2116,6 +2206,22 @@ function projectContext(context) {
             : { baselineHistoryLength: context.baselineHistoryLength }),
         parentHead: context.parentHead,
         playPreset: structuredClone(recordedPlayPrompt(context).playPreset),
+        ...(context.modelBinding === undefined
+            ? {}
+            : {
+                contextWindowTokens: context.lastRequest?.modelConfig?.contextWindowTokens ??
+                    context.modelBinding.contextWindowTokens,
+            }),
+        ...(response?.kind !== "assistant"
+            ? {}
+            : {
+                latestCompletedResponse: {
+                    id: response.id,
+                    ...(response.usage === undefined
+                        ? {}
+                        : { usage: structuredClone(response.usage) }),
+                },
+            }),
         status: context.status,
         canRetry: context.canRetry,
         events: context.events
@@ -2123,6 +2229,9 @@ function projectContext(context) {
             .map((event) => projectActivityEvent(event)),
         changedDocuments: structuredClone(context.changedDocuments),
         lastFailure: context.lastFailure,
+        ...(context.lastFailureKind === undefined
+            ? {}
+            : { lastFailureKind: context.lastFailureKind }),
         updatedAt: context.updatedAt,
     };
 }
@@ -2130,7 +2239,7 @@ function projectActivityEvent(event) {
     if (event.kind === "player" ||
         event.kind === "failure" ||
         event.kind === "cancellation")
-        return structuredClone(event);
+        return structuredClone(projectLegacyModelBindingFailure(event));
     if (event.kind === "assistant") {
         const { reasoning, toolFragment, usage, ...summary } = event;
         void reasoning;
@@ -2296,7 +2405,8 @@ function assertModelHostBinding(frozen, modelHost) {
 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);
+    if (session.modelBinding.provider !== modelHost.binding().provider)
+        throw new PlayCallChainError("The selected model protocol differs from this context. Switch back to its original protocol to continue, or start a fresh context.", "model_protocol_mismatch");
 }
 function validateIdentity(value, label) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/u.test(value))
@@ -2317,6 +2427,16 @@ function notifyAssistantDelta(observer, delta) {
         // Like snapshot projection, the Provider exchange outlives its browser stream.
     }
 }
+function resolutionToolResult(name, args, seed, identity, locale) {
+    if (seed === undefined)
+        throw new Error("The resolution seed for this advance is unavailable.");
+    const resolution = resolveTabletop(name, args, seededRandom(seed, identity));
+    return {
+        ok: true,
+        markdown: resolutionMarkdown(resolution, locale),
+        resolution,
+    };
+}
 function crashAtPlayAdvanceEdge(edge) {
     if (process.env.NODE_ENV === "test" &&
         process.env.NARRAEON_INTERNAL_TEST_CRASH_AT_PLAY_ADVANCE_EDGE === edge)

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

@@ -1,6 +1,8 @@
 export class PlayCallChainError extends Error {
-    constructor(message) {
+    code;
+    constructor(message, code = "invalid_request") {
         super(message);
         this.name = "PlayCallChainError";
+        this.code = code;
     }
 }

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

@@ -28,16 +28,7 @@ export function checkpointHistory(history, checkpoint) {
         .slice(cutoff + 1)
         .filter(([id]) => !id.includes("message.genesis"));
 }
-export function playerRoundMarker(rounds, hasCheckpoint, locale) {
-    const markdown = locale === "zh-CN"
-        ? `距上次检查点已完成 ${rounds} 回合。${hasCheckpoint ? "" : "当前尚无检查点，以世界起点计数。"}`
-        : `Completed player rounds since the last checkpoint: ${rounds}.${hasCheckpoint ? "" : " No checkpoint yet; counting from the world origin."}`;
-    return {
-        kind: "runtime_notice",
-        notice: "checkpoint_rounds",
-        text: `${locale === "zh-CN" ? "[Runtime 回合提示]" : "[Runtime round marker]"}\n${markdown}`,
-    };
-}
+/** Retain released markers when reconstructing frozen transcript prefixes. */
 export function isPlayerRoundMarker(item) {
     return item?.kind === "runtime_notice" && item.notice === "checkpoint_rounds";
 }
@@ -59,16 +50,8 @@ export function toolStepNotice(locale) {
             : "[Runtime settlement]\nThe previous response called tools, so its text has not yet been displayed or committed as final story. The tools have settled as their receipts state. Use those receipts to present this turn’s still-unshown content in nonempty final prose with no tool calls, consistent with committed state. Tool settlement does not require advancing the story beyond that content.",
     };
 }
-export function playerInputAppend(input) {
-    return [
-        ...(input.text.trim().length > 0 && input.checkpointAvailable
-            ? [
-                playerRoundMarker(completedPlayerRounds(input.history) -
-                    (input.checkpoint?.completedPlayerRounds ?? 0), input.checkpoint !== undefined, input.locale),
-            ]
-            : []),
-        { kind: "player", text: input.text },
-    ];
+export function playerInputAppend(text) {
+    return [{ kind: "player", text }];
 }
 export function checkpointReplayBlocks(history, checkpoint, locale, excluded = new Set(), snapshot = new HistoryQuery("checkpoint-replay", historyInputs(Object.entries(history).map(([path, contents]) => ({ path, contents }))))) {
     const eligible = checkpointHistory(history, checkpoint);

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

@@ -0,0 +1,20 @@
+import { ModelHostBindingMismatchError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, modelHostFailureRequiresFreshContext, } from "../model/ModelHost.js";
+/** Classification does not grant permission to replay a request. */
+export function classifyPlayFailure(error, canRetry) {
+    if (error instanceof ModelHostOutcomeUnknownError)
+        return "outcome_unknown";
+    if (error instanceof ModelHostContinuationError ||
+        error instanceof ModelHostBindingMismatchError)
+        return "context_unavailable";
+    if (error instanceof ModelHostFailureError) {
+        if (typeof error.details === "object" &&
+            error.details !== null &&
+            "code" in error.details &&
+            error.details.code === "model_output_limit")
+            return "output_limit";
+        if (modelHostFailureRequiresFreshContext(error))
+            return "context_limit";
+        return canRetry ? "retryable" : "provider_error";
+    }
+    return canRetry ? "retryable" : "other";
+}