narraeon 0.5.6 → 0.6.0

package/dist/node/runtime/content/CurrentTreeContentLibrary.js

@@ -4,6 +4,7 @@ import { readFileSync, unlinkSync } from "node:fs";
 import { link, open, mkdir, readFile, readdir, rename, rm, stat, unlink, } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, posix, win32 } from "node:path";
 import { portableContentTreePathKey } from "../../protocol/contentTree.js";
+import { assertSameGameplayMode, gameplayFile, gameplayPath, readGameplay, } from "../../protocol/gameplay.js";
 import { defaultContentWorkspaceLimits, } from "./ContentLimits.js";
 import { inspectContentPackageCurrentTree, isContentPackageWorldDocumentPath, worldDocumentTextRequirement, } from "./FileNativeContentTree.js";
 const localIdPattern = /^package-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
@@ -228,6 +229,29 @@ export class CurrentTreeContentLibrary {
             }
         });
     }
+    /**
+     * Change only the resolution scheme of a tabletop package. The edit reads the
+     * tree under the same lease as ordinary saves, so it publishes atomically and
+     * follows the same conflict rules.
+     */
+    setGameplayScheme(localId, scheme, options = {}) {
+        return this.#mutate(async () => {
+            const lease = await this.acquireOperationLease(localId, {
+                wait: options.waitForLease !== false,
+            });
+            try {
+                options.signal?.throwIfAborted();
+                const current = lease.package;
+                if (current.gameplay.mode !== "tabletop")
+                    throw new InvalidContentTreeError("Only a tabletop content package has a resolution scheme / 只有跑团内容包有判定方案");
+                const replacement = gameplayFile({ mode: "tabletop", scheme });
+                return await lease.replace(current.files.map((file) => file.path === gameplayPath ? replacement : file), options);
+            }
+            finally {
+                lease.release();
+            }
+        });
+    }
     async acquireOperationLease(localId, options = {}) {
         this.#packageRoot(localId);
         await mkdir(this.#locksRoot, { recursive: true, mode: 0o700 });
@@ -281,6 +305,7 @@ export class CurrentTreeContentLibrary {
                         throw new CurrentTreeContentPackageBusyError();
                     options.signal?.throwIfAborted();
                     const normalized = normalizeCurrentContentTreeFiles(files, this.#limits);
+                    assertGameplayModeUnchanged(package_.files, normalized);
                     return this.#replaceNormalizedCurrentTree(localId, package_.title, normalized, options.signal);
                 },
                 release: () => {
@@ -476,7 +501,7 @@ export class CurrentTreeContentLibrary {
 }
 function detail(localId, title, files, inspection) {
     return {
-        ...summary(localId, title, inspection),
+        ...summary(localId, title, readGameplay(files), inspection),
         files: files.map((file) => ({ ...file })),
         documents: structuredClone(inspection.documents),
         issues: structuredClone(inspection.issues),
@@ -484,8 +509,9 @@ function detail(localId, title, files, inspection) {
         control: structuredClone(inspection.control),
     };
 }
-function summary(localId, title, inspection) {
+function summary(localId, title, gameplay, inspection) {
     return {
+        gameplay: { ...gameplay },
         localId,
         title,
         status: inspection.status,
@@ -495,6 +521,7 @@ function summary(localId, title, inspection) {
 }
 function packageSummary(package_) {
     return {
+        gameplay: { ...package_.gameplay },
         localId: package_.localId,
         title: package_.title,
         status: package_.status,
@@ -547,8 +574,22 @@ export function normalizeCurrentContentTreeFiles(files, limits = defaultLimits)
             ...(file.encoding === undefined ? {} : { encoding: file.encoding }),
         });
     }
+    try {
+        readGameplay(normalized);
+    }
+    catch (error) {
+        throw new InvalidContentTreeError(error instanceof Error ? error.message : "Invalid gameplay identity");
+    }
     return normalized.sort((left, right) => compareStrings(left.path, right.path));
 }
+function assertGameplayModeUnchanged(before, after) {
+    try {
+        assertSameGameplayMode(before, after);
+    }
+    catch (error) {
+        throw new InvalidContentTreeError(error instanceof Error ? error.message : "Gameplay mode is fixed");
+    }
+}
 function decodeCanonicalBase64(contents, path) {
     if (contents.length % 4 !== 0 ||
         !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(contents)) {

package/dist/node/runtime/content/FileNativeContentTree.js

@@ -1,3 +1,4 @@
+import { gameplayPath, readGameplay } from "../../protocol/gameplay.js";
 import { readPackageFollowups } from "./PackageFollowups.js";
 import { parseDocument } from "yaml";
 import { WorldDocumentStore, } from "../world/WorldDocumentStore.js";
@@ -45,7 +46,7 @@ export function inspectContentPackageCurrentTree(files, options = {}) {
     }
     const unsupportedPaths = new Set();
     for (const file of snapshotFiles) {
-        if (/\.json$/iu.test(file.path)) {
+        if (/\.json$/iu.test(file.path) && file.path !== gameplayPath) {
             unsupportedPaths.add(file.path);
             issue(issues, "unsupported_content_file", file.path, "The current content package does not accept manifest, seven-field JSON, schema, record, or revision files");
         }
@@ -116,6 +117,12 @@ export function inspectContentPackageCurrentTree(files, options = {}) {
                 issue(issues, "invalid_player_view", "control/player-views.yaml", `${formatProblems.length - maxReportedPlayerViewProblems} more player-view issues were omitted`);
         }
     }
+    try {
+        readGameplay(snapshotFiles);
+    }
+    catch (error) {
+        issue(issues, "invalid_gameplay", gameplayPath, error instanceof Error ? error.message : "Invalid gameplay");
+    }
     try {
         readPackageFollowups(snapshotFiles);
     }

package/dist/node/runtime/history/StoryExport.js

@@ -0,0 +1,33 @@
+export function exportStory(title, messages, format, locale) {
+    const player = locale === "zh-CN" ? "我" : "Me";
+    const separator = locale === "zh-CN" ? "：" : ": ";
+    const blocks = messages.map(({ role, text }) => {
+        if (role === "narrator")
+            return text;
+        if (format === "text")
+            return `${player}${separator}${text}`;
+        return text
+            .split("\n")
+            .map((line, index) => index === 0 ? `> **${player}**${separator}${line}` : `> ${line}`)
+            .join("\n");
+    });
+    return {
+        fileName: storyFileName(title, format),
+        content: [format === "markdown" ? `# ${title}` : title, ...blocks].join("\n\n"),
+    };
+}
+function storyFileName(title, format) {
+    const extension = format === "markdown" ? ".md" : ".txt";
+    let stem = title
+        .replace(/[<>:"/\\|?*\p{Cc}]/gu, "")
+        .trim()
+        .replace(/[. ]+$/u, "");
+    if (/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/iu.test(stem))
+        stem = `_${stem}`;
+    const characters = Array.from(stem).slice(0, 80 - extension.length);
+    // Also fit filesystems that limit a filename to 255 UTF-8 bytes.
+    while (Buffer.byteLength(characters.join("") + extension, "utf8") > 255)
+        characters.pop();
+    stem = characters.join("").replace(/[. ]+$/u, "");
+    return `${stem || "story"}${extension}`;
+}

package/dist/node/runtime/model/FileNativeModelAdapters.js

@@ -1,8 +1,9 @@
+var _a;
 import { createHash } from "node:crypto";
 import { appendFile, chmod, mkdir, stat } from "node:fs/promises";
 import { dirname } from "node:path";
 import { hasCLIProxyThinkingSuffix, modelReasoningPolicyIssue, } from "../../protocol/modelConnections.js";
-import { ModelHostBindingMismatchError, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "./ModelHost.js";
+import { assertModelOutputComplete, ModelHostBindingMismatchError, ModelHostCancelledError, ModelHostContinuationError, ModelHostFailureError, ModelHostOutcomeUnknownError, } from "./ModelHost.js";
 import { renderPromptDeltaMessage, } from "../prompt/FileNativePromptCompiler.js";
 import { aggregateAnthropicModelStream, aggregateChatModelStream, aggregateResponsesModelStream, } from "./ModelHostStream.js";
 import { defaultRuntimeToolDefinitionStrategy, portableRuntimeToolInputSchema, } from "../prompt/FileNativeToolRegistry.js";
@@ -77,7 +78,31 @@ export class FileNativeModelHost {
                 .digest("hex"),
         };
     }
-    async exchange(request, observer) {
+    freezeRequest(request) {
+        const frozen = structuredClone(request);
+        if (frozen.modelConfig === undefined) {
+            const { baseUrl: _baseUrl, apiKey: _apiKey, ...config } = this.#connection;
+            void _baseUrl;
+            void _apiKey;
+            frozen.modelConfig = config;
+        }
+        return frozen;
+    }
+    #requestHost(request) {
+        if (request.modelConfig === undefined)
+            return this;
+        if (request.modelConfig.provider !== this.#connection.provider)
+            throw new ModelHostBindingMismatchError("The request protocol does not match the selected model host");
+        return new _a({
+            ...request.modelConfig,
+            baseUrl: this.#connection.baseUrl,
+            apiKey: this.#connection.apiKey,
+        }, this.#fetch, this.#failureLog);
+    }
+    exchange(request, observer) {
+        return this.#requestHost(request).#exchange(request, observer);
+    }
+    async #exchange(request, observer) {
         assertExchangeCompatibility(this.#connection, request);
         await trace("model_host_exchange", modelHostTrace(request));
         const signal = observer?.signal;
@@ -99,6 +124,9 @@ export class FileNativeModelHost {
     }
     /** Uses the production encoders and deliberately omits credentials. */
     previewRequest(request) {
+        return this.#requestHost(request).#previewRequest(request);
+    }
+    #previewRequest(request) {
         assertExchangeCompatibility(this.#connection, request);
         const provider = this.#connection.provider;
         const body = provider === "chat_completions"
@@ -183,6 +211,7 @@ export class FileNativeModelHost {
             await trace("chat_response", payload);
             const message = payload.choices?.[0]?.message;
             const finishReason = payload.choices?.[0]?.finish_reason;
+            assertModelOutputComplete(finishReason);
             if (message === undefined)
                 throw unknownProviderResponse("Chat Completions");
             if (finishReason !== undefined &&
@@ -271,6 +300,7 @@ export class FileNativeModelHost {
             if (!isRecord(rawPayload) || !Array.isArray(rawPayload.content))
                 throw unknownProviderResponse("Anthropic Messages");
             const payload = rawPayload;
+            assertModelOutputComplete(payload.stop_reason);
             const content = payload.content;
             if (!validAnthropicContent(content))
                 throw unknownProviderResponse("Anthropic Messages");
@@ -310,6 +340,7 @@ export class FileNativeModelHost {
         });
     }
 }
+_a = FileNativeModelHost;
 function assertExchangeCompatibility(connection, request) {
     if (request.bootstrap.provider.protocol !== connection.provider)
         throw new ModelHostBindingMismatchError("The compiled prompt protocol does not match the selected model host");
@@ -1048,6 +1079,7 @@ async function openAIResponsesRequest(input) {
         await trace(`${input.tracePrefix}_response`, payload);
         if (!isRecord(payload) || !Array.isArray(payload.output))
             throw unknownProviderResponse("Responses API");
+        assertModelOutputComplete(responsesStopReason(payload));
         const output = cloneResponseOutput(payload.output);
         if (!validResponsesOutput(output))
             throw unknownProviderResponse("Responses API");

package/dist/node/runtime/model/ModelHost.js

@@ -33,10 +33,21 @@ export class ModelHostFailureError extends Error {
             this.details = options.details;
     }
 }
-/** A Provider has rejected the complete request because its context is full. */
+/** Reject provider-confirmed truncation before accepting text or tool calls. */
+export function assertModelOutputComplete(stopReason) {
+    if (stopReason === "length" ||
+        stopReason === "max_tokens" ||
+        stopReason === "max_output_tokens" ||
+        stopReason === "incomplete:max_output_tokens") {
+        throw new ModelHostFailureError("The model response reached the output token limit before completion. Increase maxOutputTokens and start a fresh context; reasoning may also consume the output budget.", { details: { code: "model_output_limit", stopReason } });
+    }
+}
+/** Replaying the frozen request cannot recover a context or output limit. */
 export function modelHostFailureRequiresFreshContext(error) {
     if (!(error instanceof ModelHostFailureError))
         return false;
+    if (failureDetailStrings(error.details).includes("model_output_limit"))
+        return true;
     const evidence = [error.message, ...failureDetailStrings(error.details)]
         .join("\n")
         .toLocaleLowerCase("und");

package/dist/node/runtime/model/ModelHostStream.js

@@ -1,4 +1,4 @@
-import { ModelHostFailureError } from "./ModelHost.js";
+import { assertModelOutputComplete, ModelHostFailureError, } from "./ModelHost.js";
 import { providerStreamEvents } from "./ProviderStream.js";
 export async function aggregateChatModelStream(body, onDelta) {
     let content = "";
@@ -110,6 +110,7 @@ export async function aggregateChatModelStream(body, onDelta) {
     }
     if (!completed || !sawPayload)
         throw new Error("Chat SSE ended before a complete response");
+    assertModelOutputComplete(stopReason);
     const toolCalls = [...calls.entries()]
         .sort(([left], [right]) => left - right)
         .map(([, call]) => {
@@ -259,8 +260,6 @@ export async function aggregateAnthropicModelStream(body, onDelta) {
                 if (block === undefined || block.stopped)
                     throw new Error("Anthropic SSE content block stop is invalid");
                 block.stopped = true;
-                if (block.value.type === "tool_use" && block.partialJson !== "")
-                    block.value.input = parseStreamJson(block.partialJson);
                 break;
             }
             case "message_delta": {
@@ -289,11 +288,14 @@ export async function aggregateAnthropicModelStream(body, onDelta) {
     }
     if (!started || !stopped)
         throw new Error("Anthropic SSE ended before a complete response");
+    assertModelOutputComplete(stopReason);
     const content = [...blocks.entries()]
         .sort(([left], [right]) => left - right)
         .map(([, block]) => {
         if (!block.stopped)
             throw new Error("Anthropic SSE content block did not end");
+        if (block.value.type === "tool_use" && block.partialJson !== "")
+            block.value.input = parseStreamJson(block.partialJson);
         return block.value;
     });
     const text = content
@@ -364,6 +366,12 @@ export async function aggregateResponsesModelStream(body, onDelta) {
             payload.type === "response.incomplete" ||
             payload.type === "response.cancelled" ||
             payload.type === "error") {
+            if (payload.type === "response.incomplete" &&
+                isRecord(payload.response)) {
+                const details = payload.response.incomplete_details;
+                if (isRecord(details))
+                    assertModelOutputComplete(details.reason);
+            }
             throw new ModelHostFailureError("Responses SSE returned an explicit failure");
         }
     }

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

@@ -1,5 +1,5 @@
 import { isNarrativeOrigin, isHistoryBackground, } from "../history/HistoryBackground.js";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { link, mkdir, open, readFile, rename, rm, writeFile, } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
@@ -57,6 +57,33 @@ export class FileNativePlayAdvanceStore {
             recordedAt: durableBase.createdAt,
         });
     }
+    /**
+     * Return the advance's secret resolution seed, creating it on first need.
+     * Recovery reads the same fact, so every tool call in the advance draws from
+     * one persisted stream and a crashed batch cannot resample.
+     */
+    async resolutionSeed(base) {
+        const durableBase = await this.#assertCurrent(base);
+        const path = this.#factPath(base, "resolution-seed.json");
+        if ((await readOptionalJson(path)) === null) {
+            try {
+                await publishImmutableJson(path, {
+                    schemaVersion: 1,
+                    stage: "resolution_seed",
+                    seed: randomBytes(32).toString("hex"),
+                    recordedAt: durableBase.createdAt,
+                });
+            }
+            catch (error) {
+                // A concurrent writer may have published first; the stored fact wins.
+                if ((await readOptionalJson(path)) === null)
+                    throw error;
+            }
+        }
+        const fact = await readJson(path);
+        assertResolutionSeedFact(fact);
+        return fact.seed;
+    }
     async markSettled(base, head) {
         const durableBase = await this.#assertCurrent(base);
         await publishImmutableJson(this.#factPath(base, "settled.json"), {
@@ -115,6 +142,15 @@ function sameAdvanceBase(left, right) {
     void rightCreatedAt;
     return isDeepStrictEqual(leftIdentity, rightIdentity);
 }
+function assertResolutionSeedFact(value) {
+    if (!isRecord(value) ||
+        value.schemaVersion !== 1 ||
+        value.stage !== "resolution_seed" ||
+        typeof value.seed !== "string" ||
+        !/^[a-f0-9]{64}$/.test(value.seed) ||
+        typeof value.recordedAt !== "number")
+        throw new Error("Invalid persisted resolution seed");
+}
 function assertBase(value) {
     if (!isRecord(value) ||
         value.schemaVersion !== 1 ||

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

@@ -3,7 +3,7 @@ export { validatePlayPresetArtifactPayload } from "../../shared/artifact-payload
 import { defaultFollowupItems, } from "../../shared/ordered-followups.js";
 import { parseFollowupItems } from "./OrderedFollowups.js";
 import { builtinAuthorPrompts, defaultOrderedAuthorPrompts, } from "../../shared/ordered-author-prompts.js";
-import { parseOrderedPlayPrompts, migrateLegacyPlayPrompts, } from "./OrderedPlayPrompts.js";
+import { parseOrderedPlayPrompts, migrateLegacyPlayPrompts, withTabletopPromptBuiltins, } from "./OrderedPlayPrompts.js";
 import { defaultOrderedPlayPrompts, } from "../../shared/ordered-play-prompts.js";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
@@ -203,12 +203,17 @@ export class FileNativePlayPresetStore {
         };
         this.#locale = options.locale ?? (() => defaultAppLocale);
     }
+    /**
+     * Startup is the only place that upgrades stored presets. Reads never write:
+     * list, bind and freeze observe the library as it was last saved.
+     */
     async initialize() {
         await this.#change(async () => {
             const document = await this.#read();
             const migrated = this.#markLegacyBuiltinDefault(document);
             const synchronized = this.#synchronizeBuiltinDefault(document);
-            if (migrated || synchronized)
+            const tabletop = this.#migrateTabletopPromptBuiltins(document);
+            if (migrated || synchronized || tabletop)
                 await this.#write(document);
         });
     }
@@ -452,7 +457,8 @@ export class FileNativePlayPresetStore {
             .map((path) => ({ path, contents: binding.files[path] }));
     }
     async importPortable(input) {
-        const files = toFileMap(input.files, this.#limits);
+        // A released preset gains the tabletop builtins at import, as at upgrade.
+        const files = withTabletopPromptBuiltins(toFileMap(input.files, this.#limits));
         const parsed = parsePlayPresetFiles(files, this.#limits);
         if (parsed.kind === "invalid")
             throw parsed.error;
@@ -561,6 +567,45 @@ export class FileNativePlayPresetStore {
         preset.builtinDefault = true;
         return true;
     }
+    /**
+     * One-time upgrade for ordered presets saved before the tabletop builtins
+     * existed. An affected revision is replaced by a new revision that inserts
+     * them; the old revision stays for frozen requests. A pending draft gets the
+     * same insertion, because a draft that kept the old list would fail the
+     * builtin-retention rule on save. The library is one atomically written file,
+     * so an interrupted upgrade leaves the released bytes and reruns cleanly.
+     */
+    #migrateTabletopPromptBuiltins(document) {
+        let changed = false;
+        for (const stored of document.presets) {
+            const current = stored.revisions[stored.currentRevision];
+            if (current !== undefined) {
+                const migrated = withTabletopPromptBuiltins(current);
+                if (migrated !== current) {
+                    const revision = revisionForFiles(migrated, this.#limits);
+                    stored.revisions[revision] = cloneFiles(migrated);
+                    stored.currentRevision = revision;
+                    changed = true;
+                }
+            }
+            const draft = stored.draftRevision === undefined
+                ? undefined
+                : stored.revisions[stored.draftRevision];
+            if (draft !== undefined) {
+                const migrated = withTabletopPromptBuiltins(draft);
+                if (migrated !== draft) {
+                    const revision = revisionForFiles(migrated, this.#limits);
+                    stored.revisions[revision] = cloneFiles(migrated);
+                    if (revision === stored.currentRevision)
+                        delete stored.draftRevision;
+                    else
+                        stored.draftRevision = revision;
+                    changed = true;
+                }
+            }
+        }
+        return changed;
+    }
     #synchronizeBuiltinDefault(document) {
         const preset = document.presets.find(({ builtinDefault }) => builtinDefault === true);
         if (preset === undefined || preset.draftRevision !== undefined)

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

@@ -1,3 +1,6 @@
+import { isResolutionReceipt } from "../../protocol/resolution.js";
+import { legacyModelBindingFailure, projectLegacyModelBindingFailure, } from "./LegacyModelBindingFailure.js";
+import { isPlayFailureKind, } from "../../protocol/playFailure.js";
 import { isNarrativeOrigin, } from "../history/HistoryBackground.js";
 import { encodePlayPromptRun, decodePlayPromptRun, } from "./PlayPromptRun.js";
 import { createHash, randomUUID } from "node:crypto";
@@ -71,7 +74,8 @@ export class FileNativePlayTimelineStore {
         const eventCount = prefixLength(input.source.events, input.target.events);
         const completedToolCount = prefixLength(input.source.completedTools, input.target.completedTools);
         const authorizationCheckpointCount = prefixLength(input.source.documentAuthorizationCheckpoints ?? [], input.target.documentAuthorizationCheckpoints ?? []);
-        if (input.target.events.some((event) => event.kind === "assistant" && event.status === "completed")) {
+        if (input.retainCompleteContext ||
+            input.target.events.some((event) => event.kind === "assistant" && event.status === "completed")) {
             const encoding = await this.readInitialEncoding(input.sourceWorldId, input.source.chainId).catch(() => null);
             if (encoding !== null)
                 await publishImmutableJson(join(targetRoot, "initial-request-encoding.json"), encoding);
@@ -207,6 +211,9 @@ export class FileNativePlayTimelineStore {
             continuationDigest,
             lastRequestAttempt: value.lastRequestAttempt,
             lastFailure: value.lastFailure,
+            ...(value.lastFailureKind === undefined
+                ? {}
+                : { lastFailureKind: value.lastFailureKind }),
             updatedAt: value.updatedAt,
         };
         await publishJson(join(root, "state.json"), state);
@@ -235,6 +242,20 @@ export class FileNativePlayTimelineStore {
             throw new Error("Play timeline head generation is inconsistent");
         return loaded;
     }
+    /** Read only the small active context index, never its transcript or bootstrap. */
+    async currentContextRequiresFreshContext(worldId) {
+        assertIdentity(worldId, "World ID");
+        const head = await this.#readTimelineHead(worldId);
+        if (head === null)
+            return false;
+        const index = await readJson(join(this.#contextRoot(worldId, head.chainId), "index.json"));
+        assertContextIndex(index);
+        if (index.worldId !== worldId ||
+            index.chainId !== head.chainId ||
+            index.timelineGeneration !== head.generation)
+            throw new Error("Play context durable identity is inconsistent");
+        return index.importedFromArchive === true;
+    }
     async readContext(worldId, chainId) {
         assertIdentity(worldId, "World ID");
         assertIdentity(chainId, "Call-chain ID");
@@ -277,6 +298,7 @@ export class FileNativePlayTimelineStore {
             chainId,
             previousChainId: indexValue.previousChainId,
             timelineGeneration: indexValue.timelineGeneration,
+            ...(indexValue.importedFromArchive ? { importedFromArchive: true } : {}),
             ...(baseValue.continuityContextId === undefined
                 ? {}
                 : { continuityContextId: baseValue.continuityContextId }),
@@ -327,6 +349,9 @@ export class FileNativePlayTimelineStore {
             lastRequest,
             lastRequestAttempt: stateValue.lastRequestAttempt,
             lastFailure: stateValue.lastFailure,
+            ...(stateValue.lastFailureKind === undefined
+                ? {}
+                : { lastFailureKind: stateValue.lastFailureKind }),
             updatedAt: stateValue.updatedAt,
         };
         return {
@@ -445,7 +470,10 @@ export class FileNativePlayTimelineStore {
                     kind: "event",
                     chainId: pointer.chainId,
                     current: pointer.chainId === head?.chainId,
-                    event: summary,
+                    ...(context.index.importedFromArchive
+                        ? { requiresFreshContext: true }
+                        : {}),
+                    event: projectLegacyModelBindingFailure(summary),
                 });
                 pointer = { ...pointer, eventId: pointer.eventId - 1 };
                 continue;
@@ -498,6 +526,9 @@ export class FileNativePlayTimelineStore {
             activeStatus: active?.state.status ?? null,
             activeCanRetry: active?.state.canRetry ?? false,
             activeLastFailure: active?.state.lastFailure ?? null,
+            ...(active?.state.lastFailureKind === undefined
+                ? {}
+                : { activeLastFailureKind: active.state.lastFailureKind }),
             items: reverse.reverse(),
             nextCursor: pointer.chainId === null && pointer.genesisIndex < 0
                 ? null
@@ -516,7 +547,7 @@ export class FileNativePlayTimelineStore {
         assertPlayEvent(event);
         if (event.id !== eventId)
             throw new Error("Play timeline event identity is inconsistent");
-        return normalizePlayEvent(event);
+        return projectLegacyModelBindingFailure(normalizePlayEvent(event));
     }
     newGeneration() {
         return `timeline:${randomUUID()}`;
@@ -597,11 +628,48 @@ export class FileNativePlayTimelineStore {
             indexValue.chainId !== chainId ||
             stateValue.chainId !== chainId)
             throw new Error("Play context durable identity is inconsistent");
+        // Old versions persisted a configuration preflight failure as a terminal
+        // context failure. Recover only the disposition proven by its event prefix.
+        // Archive contexts and genuine provider failures retain their restrictions.
+        if (!indexValue.importedFromArchive &&
+            stateValue.status === "interrupted" &&
+            stateValue.lastFailure === legacyModelBindingFailure &&
+            (stateValue.lastFailureKind === undefined ||
+                stateValue.lastFailureKind === "context_unavailable")) {
+            for (let id = stateValue.eventCount; id > 0; id -= 1) {
+                const event = await readJson(join(root, "events", numbered(id)));
+                assertPlayEvent(event);
+                if (event.kind === "followup" ||
+                    (event.kind === "failure" &&
+                        event.message === legacyModelBindingFailure))
+                    continue;
+                if (event.kind === "assistant" &&
+                    event.status === "completed" &&
+                    event.responseKind === "narrative" &&
+                    event.continuation === "available" &&
+                    event.committedHead === stateValue.parentHead) {
+                    stateValue.status = "ready";
+                    stateValue.canRetry = false;
+                    stateValue.lastFailure = null;
+                    delete stateValue.lastFailureKind;
+                }
+                else if (event.kind === "failure") {
+                    stateValue.canRetry = event.failureKind === "retryable";
+                    stateValue.lastFailure = event.message;
+                    if (event.failureKind === undefined)
+                        delete stateValue.lastFailureKind;
+                    else
+                        stateValue.lastFailureKind = event.failureKind;
+                }
+                break;
+            }
+        }
         return { root, index: indexValue, state: stateValue };
     }
 }
 function contextIndex(value) {
     return {
+        ...(value.importedFromArchive ? { importedFromArchive: true } : {}),
         schemaVersion: 3,
         kind: "play_context_index",
         worldId: value.worldId,
@@ -724,6 +792,8 @@ function assertContextIndex(value) {
     if (!isRecord(value) ||
         value.schemaVersion !== 3 ||
         value.kind !== "play_context_index" ||
+        (value.importedFromArchive !== undefined &&
+            value.importedFromArchive !== true) ||
         typeof value.worldId !== "string" ||
         typeof value.chainId !== "string" ||
         (value.previousChainId !== null &&
@@ -769,6 +839,8 @@ function assertContextState(value) {
         !/^[a-f0-9]{64}$/u.test(value.continuationDigest) ||
         !validCount(value.lastRequestAttempt) ||
         (value.lastFailure !== null && typeof value.lastFailure !== "string") ||
+        (value.lastFailureKind !== undefined &&
+            !isPlayFailureKind(value.lastFailureKind)) ||
         typeof value.updatedAt !== "number")
         throw new Error("Play context state has an invalid shape");
 }
@@ -839,6 +911,8 @@ function isReleasedPlayContext(value) {
         (value.lastRequest !== null && !isRecord(value.lastRequest)) ||
         !validCount(value.lastRequestAttempt) ||
         (value.lastFailure !== null && typeof value.lastFailure !== "string") ||
+        (value.lastFailureKind !== undefined &&
+            !isPlayFailureKind(value.lastFailureKind)) ||
         typeof value.updatedAt !== "number")
         return false;
     try {
@@ -955,6 +1029,9 @@ function assertPlayEvent(value) {
         return;
     }
     if (value.kind === "tool_result") {
+        if (value.resolution !== undefined &&
+            !isResolutionReceipt(value.resolution))
+            throw new Error("Invalid resolution receipt");
         if (typeof value.callId !== "string" ||
             typeof value.name !== "string" ||
             typeof value.ok !== "boolean" ||
@@ -976,7 +1053,10 @@ function assertPlayEvent(value) {
         return;
     }
     if ((value.kind !== "failure" && value.kind !== "cancellation") ||
-        typeof value.message !== "string")
+        typeof value.message !== "string" ||
+        (value.kind === "failure" &&
+            value.failureKind !== undefined &&
+            !isPlayFailureKind(value.failureKind)))
         throw new Error("Play timeline event has an invalid kind");
 }
 function assertTimelineEventSummary(value) {
@@ -1015,6 +1095,9 @@ function assertTimelineEventSummary(value) {
         return;
     }
     if (value.kind === "tool_result") {
+        if (value.resolution !== undefined &&
+            !isResolutionReceipt(value.resolution))
+            throw new Error("Invalid resolution receipt");
         if (typeof value.callId !== "string" ||
             typeof value.name !== "string" ||
             typeof value.ok !== "boolean" ||

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

@@ -0,0 +1,10 @@
+export const legacyModelBindingFailure = "The selected model connection does not match the frozen model binding; start a fresh context.";
+/** Presentation only: immutable historical events remain unchanged on disk. */
+export function projectLegacyModelBindingFailure(event) {
+    if (event.kind === "failure" &&
+        event.message === legacyModelBindingFailure &&
+        (event.failureKind === undefined ||
+            event.failureKind === "context_unavailable"))
+        return { ...event, failureKind: "configuration_mismatch" };
+    return event;
+}