narraeon 0.7.9 → 0.8.0

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

@@ -1,5 +1,7 @@
+import { builtinAuthorPrompts } from "../../shared/ordered-author-prompts.js";
+import { expandRetiredPrompts, customizePromptArrangement, resolvePromptArrangement, retiredBuiltinReplacements, } from "../../shared/prompt-arrangement.js";
 import { createHash } from "node:crypto";
-import { isMap, isSeq, parseDocument } from "yaml";
+import { isMap, parseDocument } from "yaml";
 import { builtinPlayPrompts, isPromptMessageRole, isTurnGuideLine, promptGroups, } from "../../shared/ordered-play-prompts.js";
 const promptName = /^[^\r\n\0]{1,160}$/u;
 /** The same strict permission gate is used by portable imports and structured saves. */
@@ -86,24 +88,22 @@ export function parseOrderedPlayPrompts(value, catalog = builtinPlayPrompts("en"
             ? retiredBuiltinReplacements[item.builtin]
             : undefined;
         if (retired !== undefined &&
-            exact(["id", "kind", "builtin", "enabled"]) &&
+            exact(["id", "kind", "builtin", "enabled"], ["turnGuide"]) &&
+            validTurnGuide &&
             typeof item.enabled === "boolean") {
-            const enabled = item.enabled;
-            return retired.flatMap(({ builtin, selected }) => {
-                if (builtins.has(builtin) || ids.has(builtin))
-                    return [];
-                builtins.add(builtin);
-                ids.add(builtin);
-                return [
-                    {
-                        id: builtin,
-                        kind: "builtin",
-                        builtin,
-                        enabled: selected === false ? false : enabled,
-                        ...messageRole,
-                    },
-                ];
-            });
+            if (builtins.has(item.builtin))
+                return fail();
+            builtins.add(item.builtin);
+            return [
+                {
+                    id: item.id,
+                    kind: "builtin",
+                    builtin: item.builtin,
+                    enabled: item.enabled,
+                    ...messageRole,
+                    ...turnGuide,
+                },
+            ];
         }
         const builtin = catalog.find((entry) => entry.id === item.builtin);
         if (item.kind !== "builtin" ||
@@ -128,10 +128,29 @@ export function parseOrderedPlayPrompts(value, catalog = builtinPlayPrompts("en"
             },
         ];
     });
+    const expanded = expandRetiredPrompts(entries);
     if (worlds !== (worldRequired ? 1 : 0) ||
-        catalog.some((item) => item.required && !builtins.has(item.id)))
+        catalog.some((item) => {
+            if (!item.required)
+                return false;
+            const entry = expanded.find((entry) => entry.kind === "builtin" && entry.builtin === item.id);
+            return (entry?.kind !== "builtin" ||
+                !entry.enabled ||
+                (entry.messageRole !== undefined && entry.messageRole !== "system"));
+        }))
         return fail();
-    return entries;
+    return expanded;
+}
+/** The required identities are part of each released list-format contract.
+ * New catalog requirements apply after conversion, never while validating old bytes. */
+export function releasedPromptRequiredIdentities(worldRequired) {
+    return worldRequired
+        ? ["play.mechanics"]
+        : ["author.mechanics", "author.target"];
+}
+export function parseReleasedOrderedPrompts(value, catalog = builtinPlayPrompts("en"), worldRequired = true) {
+    const required = releasedPromptRequiredIdentities(worldRequired);
+    return parseOrderedPlayPrompts(value, catalog.map((item) => ({ ...item, required: required.includes(item.id) })), worldRequired);
 }
 function orderedPresetDocument(files) {
     const source = files["preset.yaml"];
@@ -145,165 +164,104 @@ function orderedPresetDocument(files) {
         return undefined;
     return document;
 }
-/**
- * Insert the tabletop builtins that an ordered preset does not list yet.
- * play.tabletop goes just before the world placeholder and author.tabletop just
- * after author.guidance. Files that are not ordered v2 or do not parse come back
- * unchanged, and nothing else in them is rewritten. The same object is returned
- * when nothing needs inserting, so callers can detect a change by identity.
- */
-export function withTabletopPromptBuiltins(files) {
-    const document = orderedPresetDocument(files);
-    if (document === undefined)
-        return files;
-    let changed = false;
-    const playPrompts = document.get("playPrompts", true);
-    if (isSeq(playPrompts) && !hasEntry(playPrompts, "play.tabletop")) {
-        const world = playPrompts.items.findIndex((item) => entryField(item, "kind") === "world");
-        playPrompts.items.splice(world < 0 ? playPrompts.items.length : world, 0, document.createNode({
-            id: "play.tabletop",
-            kind: "builtin",
-            builtin: "play.tabletop",
-            enabled: true,
-        }));
-        changed = true;
-    }
-    const authorPrompts = document.get("authorPrompts", true);
-    if (isSeq(authorPrompts) && !hasEntry(authorPrompts, "author.tabletop")) {
-        const guidance = authorPrompts.items.findIndex((item) => entryField(item, "id") === "author.guidance");
-        authorPrompts.items.splice(guidance < 0 ? authorPrompts.items.length : guidance + 1, 0, document.createNode({
-            id: "author.tabletop",
-            kind: "builtin",
-            builtin: "author.tabletop",
-            enabled: true,
-        }));
-        changed = true;
-    }
-    return changed ? { ...files, "preset.yaml": document.toString() } : files;
-}
-/**
- * The retired composite builtins and the blocks that replaced each of them.
- * A stored entry for a retired builtin is replaced in place by its successors,
- * which inherit its enabled state and message role; the unselected members of
- * a choice group arrive disabled. User copies of the old text are not touched.
- */
-const retiredBuiltinReplacements = {
-    "play.style": [{ builtin: "play.prose" }, { builtin: "play.scene" }],
-    "play.adjudication": [
-        { builtin: "play.agency-default" },
-        { builtin: "play.agency-strict", selected: false },
-        { builtin: "play.agency-open", selected: false },
-        { builtin: "play.facts" },
-        { builtin: "play.npc" },
-    ],
-    "play.narrative": [
-        { builtin: "play.stop-beat" },
-        { builtin: "play.stop-scene", selected: false },
-        { builtin: "play.ending" },
-        { builtin: "play.output" },
-    ],
-    "play.state": [
-        { builtin: "play.save-timing" },
-        { builtin: "play.ownership" },
-        { builtin: "play.situation" },
-        { builtin: "play.checkpoint-policy" },
-    ],
-};
 export const retiredPlayBuiltins = Object.keys(retiredBuiltinReplacements);
-/**
- * Replace the retired composite builtins (style, adjudication, narrative and
- * state) with the single-rule blocks that succeeded them, each at the old
- * entry's position. Same identity contract as the other insertions.
- */
-export function withRestructuredPromptBuiltins(files) {
+/** One-time released v2 -> v3 encoding conversion, never a catalog migration. */
+export function upgradeOrderedPromptFormat(files) {
     const document = orderedPresetDocument(files);
-    if (document === undefined)
+    if (!document)
         return files;
-    const playPrompts = document.get("playPrompts", true);
-    if (!isSeq(playPrompts))
-        return files;
-    let changed = false;
-    for (const [retired, replacements] of Object.entries(retiredBuiltinReplacements)) {
-        const at = playPrompts.items.findIndex((item) => entryField(item, "kind") === "builtin" &&
-            entryField(item, "builtin") === retired);
-        if (at < 0)
-            continue;
-        const old = playPrompts.items[at];
-        const enabled = entryField(old, "enabled") === true;
-        const messageRole = entryField(old, "messageRole");
-        const successors = replacements
-            .filter(({ builtin }) => !hasEntry(playPrompts, builtin))
-            .map(({ builtin, selected }) => document.createNode({
-            id: builtin,
-            kind: "builtin",
-            builtin,
-            enabled: selected === false ? false : enabled,
-            ...(typeof messageRole === "string" ? { messageRole } : {}),
-        }));
-        playPrompts.items.splice(at, 1, ...successors);
-        changed = true;
+    try {
+        const source = document.toJS();
+        document.set("playPrompts", customizePromptArrangement(parseReleasedOrderedPrompts(source.playPrompts), builtinPlayPrompts("en")));
+        const author = document.get("authorPrompts");
+        if (author !== undefined)
+            document.set("authorPrompts", customizePromptArrangement(parseReleasedOrderedPrompts(source.authorPrompts, builtinAuthorPrompts("en"), false), builtinAuthorPrompts("en"), false));
+        document.set("format", "narraeon.play-preset/v3");
+        return { ...files, "preset.yaml": document.toString() };
     }
-    return changed ? { ...files, "preset.yaml": document.toString() } : files;
-}
-const alternativeGroups = () => {
-    const members = (group) => builtinPlayPrompts("en")
-        .filter((item) => item.group === group)
-        .map(({ id }) => id);
-    const order = promptGroups.map((group) => members(group));
-    // The default list runs mechanics, then the choice groups in `promptGroups`
-    // order, then the policy blocks: a missing group lands after the previous
-    // group (or mechanics), else ahead of the first later group or policy block.
-    return promptGroups.map((group, index) => ({
-        after: [...order.slice(0, index).flat().reverse(), "play.mechanics"],
-        before: [
-            ...order.slice(index + 1).flat(),
-            "play.prose",
-            "play.scene",
-            "play.ending",
-            "play.output",
-            "play.facts",
-            "play.tabletop",
-        ],
-        entries: groupPromptEntries(group),
-    }));
-};
-/**
- * Insert the choice-group builtins (person, continuation, agency, stopping)
- * that an ordered preset does not list yet. Same identity contract as the
- * tabletop insertion.
- */
-export function withAlternativePromptBuiltins(files) {
-    const document = orderedPresetDocument(files);
-    if (document === undefined)
-        return files;
-    const playPrompts = document.get("playPrompts", true);
-    if (!isSeq(playPrompts))
+    catch {
+        // Invalid drafts stay repairable, without dropping their original bytes.
         return files;
-    let changed = false;
-    for (const group of alternativeGroups()) {
-        if (group.entries.some((entry) => hasEntry(playPrompts, entry.id)))
-            continue;
-        const anchor = group.after
-            .map((id) => playPrompts.items.findIndex((item) => entryField(item, "id") === id))
-            .find((index) => index >= 0);
-        const fallback = playPrompts.items.findIndex((item) => {
-            const id = entryField(item, "id");
-            return ((typeof id === "string" && group.before.includes(id)) ||
-                entryField(item, "kind") === "world");
-        });
-        const at = anchor !== undefined
-            ? anchor + 1
-            : fallback >= 0
-                ? fallback
-                : playPrompts.items.length;
-        playPrompts.items.splice(at, 0, ...group.entries.map((entry) => document.createNode(entry)));
-        changed = true;
     }
-    return changed ? { ...files, "preset.yaml": document.toString() } : files;
 }
-/** Every builtin upgrade a stored or imported ordered preset must receive. */
-export function withCurrentPromptBuiltins(files) {
-    return withAlternativePromptBuiltins(withRestructuredPromptBuiltins(withTabletopPromptBuiltins(files)));
+/** Decode portable customizations through the same resolver used by every caller. */
+export function parsePromptArrangement(value, catalog = builtinPlayPrompts("en"), worldRequired = true) {
+    const record = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+    const fail = () => {
+        throw new Error("Invalid prompt customizations");
+    };
+    if (!record(value) ||
+        Object.keys(value).some((k) => !["entries", "overrides", "order", "groups"].includes(k)))
+        return fail();
+    if (value.entries !== undefined &&
+        (!Array.isArray(value.entries) ||
+            value.entries.length > 256 ||
+            value.entries.some((e) => !record(e) || e.kind === "builtin")))
+        return fail();
+    const entries = (value.entries ?? []);
+    const entryIds = new Set(entries.map((e) => e.id));
+    if (entryIds.size !== entries.length ||
+        entries.filter((e) => e.kind === "world").length > (worldRequired ? 1 : 0))
+        return fail();
+    if (value.overrides !== undefined) {
+        if (!Array.isArray(value.overrides) || value.overrides.length > 256)
+            return fail();
+        const seen = new Set();
+        const overrideIds = new Set();
+        for (const o of value.overrides) {
+            if (!record(o) ||
+                typeof o.builtin !== "string" ||
+                seen.has(o.builtin) ||
+                (!catalog.some((c) => c.id === o.builtin) &&
+                    !retiredBuiltinReplacements[o.builtin]) ||
+                Object.keys(o).some((k) => !["builtin", "id", "enabled", "messageRole", "turnGuide"].includes(k)) ||
+                (o.enabled !== undefined && typeof o.enabled !== "boolean") ||
+                (o.messageRole !== undefined && !isPromptMessageRole(o.messageRole)) ||
+                (o.turnGuide !== undefined &&
+                    (typeof o.turnGuide !== "string" || !isTurnGuideLine(o.turnGuide))) ||
+                (o.id !== undefined && typeof o.id !== "string"))
+                return fail();
+            if (typeof o.id === "string") {
+                if (entryIds.has(o.id) || overrideIds.has(o.id))
+                    return fail();
+                overrideIds.add(o.id);
+            }
+            seen.add(o.builtin);
+        }
+    }
+    if (value.order !== undefined &&
+        (!Array.isArray(value.order) ||
+            value.order.length > 512 ||
+            value.order.some((k) => typeof k !== "string") ||
+            new Set(value.order).size !== value.order.length))
+        return fail();
+    if (Array.isArray(value.order) &&
+        value.order.some((key) => {
+            if (typeof key !== "string")
+                return true;
+            if (key.startsWith("entry:"))
+                return (!entryIds.has(key.slice(6)) &&
+                    !(worldRequired && key === "entry:world"));
+            return (!key.startsWith("builtin:") ||
+                (!catalog.some((c) => c.id === key.slice(8)) &&
+                    !retiredBuiltinReplacements[key.slice(8)]));
+        }))
+        return fail();
+    if (value.groups !== undefined) {
+        if (!record(value.groups))
+            return fail();
+        for (const [group, ids] of Object.entries(value.groups)) {
+            if (!promptGroups.some((item) => item === group) ||
+                !Array.isArray(ids) ||
+                ids.some((id) => typeof id !== "string" ||
+                    !catalog.some((c) => (c.id === id ||
+                        retiredBuiltinReplacements[id]?.some((r) => r.builtin === c.id)) &&
+                        c.group === group)) ||
+                new Set(ids).size !== ids.length)
+                return fail();
+        }
+    }
+    return parseOrderedPlayPrompts(resolvePromptArrangement(value, catalog, worldRequired), catalog, worldRequired);
 }
 /** A choice group's entries: the first member enabled, the rest disabled. */
 function groupPromptEntries(group) {
@@ -316,12 +274,6 @@ function groupPromptEntries(group) {
         enabled: index === 0,
     }));
 }
-function hasEntry(sequence, id) {
-    return sequence.items.some((item) => entryField(item, "id") === id);
-}
-function entryField(item, key) {
-    return isMap(item) ? item.get(key) : undefined;
-}
 /** Recognized v1 content becomes user text, never a locked builtin inferred from a path. */
 export function migrateLegacyPlayPrompts(files, narrative, excludedPaths = []) {
     const document = parseDocument(files["frame.yaml"] ?? "", {
@@ -447,5 +399,14 @@ export function migrateLegacyPlayPrompts(files, narrative, excludedPaths = []) {
         builtin: "play.tabletop",
         enabled: true,
     });
+    const listed = new Set(entries.flatMap((entry) => entry.kind === "builtin" ? [entry.builtin] : []));
+    entries.splice(entries.findIndex((entry) => entry.kind === "builtin" && entry.builtin === "play.tabletop"), 0, ...builtinPlayPrompts("en")
+        .filter((item) => !listed.has(item.id))
+        .map((item) => ({
+        id: item.id,
+        kind: "builtin",
+        builtin: item.id,
+        enabled: false,
+    })));
     return entries;
 }

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

@@ -10,6 +10,7 @@ const messages = {
     serviceStoppedAfterHead: "The service stopped after the world was updated; use a fresh context.",
     serviceStoppedSavingPlayer: "The service stopped while saving the player message; use a fresh context.",
     serviceStoppedRetryable: "The service stopped while the model request was in progress; retry to call the model again.",
+    serviceStoppedUnknown: "The service stopped after the model request may have been dispatched; its outcome is unknown. Use a fresh context.",
     serviceStoppedNoRequest: "The service stopped before preparing a model request; use a fresh context.",
     dispatchInterrupted: "The model request was interrupted.",
 };
@@ -43,29 +44,52 @@ export class PlayAdvanceLifecycle {
         notify?.();
     }
     /**
-     * Ends an advance that a process exit cut off (ADR-0044). Nothing is
-     * replayed: the exchange is interrupted, and only the chain's own frozen
-     * request can be retried, and only while the world has not moved on.
+     * Recovers an advance cut off by a process exit. A persisted ending wins;
+     * otherwise Google requests that may have been dispatched cannot be replayed
+     * (ADR-0035), while other recovery follows ADR-0044.
      */
     async recoverAbandoned(session, advance, headMoved) {
+        // Endings are persisted before their marker is cleared. If the process
+        // stopped in that gap, keep the durable ending rather than inventing a
+        // new retry decision for an advance that already settled.
+        if (advance !== null &&
+            session.status !== "running" &&
+            !(advance.advanceKind === "player" && session.status === "ready") &&
+            !headMoved) {
+            await this.#ports.clearMarker(advance);
+            return;
+        }
         const playerPhase = advance?.advanceKind === "player";
         const streaming = playerPhase
             ? undefined
             : session.events.findLast((event) => event.kind === "assistant" &&
                 event.status === "streaming" &&
                 (advance === null || event.id === advance.eventId));
-        const canRetry = !headMoved && !playerPhase && session.lastRequest !== null;
+        const unknownGoogleDispatch = advance?.advanceKind === "response" &&
+            session.status === "running" &&
+            (session.lastRequest?.modelConfig?.provider ??
+                session.modelBinding?.provider) === "google_interactions";
+        const canRetry = !headMoved &&
+            !playerPhase &&
+            !unknownGoogleDispatch &&
+            session.lastRequest !== null;
         const message = headMoved
             ? messages.serviceStoppedAfterHead
             : playerPhase
                 ? messages.serviceStoppedSavingPlayer
-                : canRetry
-                    ? messages.serviceStoppedRetryable
-                    : messages.serviceStoppedNoRequest;
+                : unknownGoogleDispatch
+                    ? messages.serviceStoppedUnknown
+                    : canRetry
+                        ? messages.serviceStoppedRetryable
+                        : messages.serviceStoppedNoRequest;
         await this.end(session, {
             kind: "failed",
             message,
-            failureKind: canRetry ? "retryable" : "other",
+            failureKind: unknownGoogleDispatch
+                ? "outcome_unknown"
+                : canRetry
+                    ? "retryable"
+                    : "other",
             canRetry,
             streamingEventId: streaming?.id,
         }, advance);
@@ -203,7 +227,7 @@ function interruptStreamingEvent(session, eventId) {
     if (eventId === undefined)
         return;
     const event = session.events.find(({ id }) => id === eventId);
-    if (event?.kind === "assistant")
+    if (event?.kind === "assistant" && event.status === "streaming")
         event.status = "interrupted";
 }
 function errorMessage(error, fallback) {

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

@@ -16,7 +16,8 @@ import { turnGuideWithTurnNote } from "../../shared/turn-guide.js";
 import { completedPlayerRounds, continuationNotice, playerInputAppend, toolStepNotice, turnGuideNotice, } from "./PlayContinuity.js";
 import { renderWriteSizeAdvice, readDeclaredWorldClock, } from "../prompt/WorldMaintenanceReport.js";
 import { WorldDocumentStore } from "../world/WorldDocumentStore.js";
-import { equalModelHostBinding, ModelHostCancelledError, } from "../model/ModelHost.js";
+import { equalModelHostBinding, ModelHostCancelledError, ModelHostOutcomeUnknownError, } from "../model/ModelHost.js";
+import { validGoogleInteractionsContinuation } from "../model/ProviderExchangeState.js";
 import { FileNativePromptCompiler, } from "../prompt/FileNativePromptCompiler.js";
 import { parsePlayPresetFiles, } from "./FileNativePlayPresetStore.js";
 import { runPlayFollowupRequests, } from "./PlayFollowupRequests.js";
@@ -234,6 +235,12 @@ export class PlayCallChain {
         const session = await this.#requireChain(input.worldId, input.chainId);
         await this.#assertCurrentHead(session);
         assertSessionModelHostBinding(session, input.modelHost);
+        if (session.status === "ready" &&
+            session.modelBinding?.provider === "google_interactions" &&
+            session.transcript.some((item) => item.kind === "assistant" &&
+                (item.providerState?.protocol !== "google_interactions" ||
+                    !validGoogleInteractionsContinuation(item.providerState.steps))))
+            throw new PlayCallChainError("The Google Interactions continuation is missing or corrupted; start a fresh context.");
         if (input.playerText.trim().length === 0) {
             if (session.status === "running")
                 throw new PlayCallChainError("A model request is still running.");
@@ -869,6 +876,10 @@ export class PlayCallChain {
                 updatedAt: Date.now(),
             };
         }
+        if (intent.continuation === "continue_context")
+            await this.#worlds.playTimeline
+                .copyRetainedEncodings(worldId, sourceContext.chainId, revised)
+                .catch(() => forgetFollowupPreviews(revised));
         await this.#worlds.playTimeline.persist(revised);
         if (intent.continuation === "fresh_context")
             await this.#worlds.completeArchiveFreshContext(worldId);
@@ -965,6 +976,9 @@ export class PlayCallChain {
                 parentHead: intent.restoresHead,
                 updatedAt: Date.now(),
             };
+            await this.#worlds.playTimeline
+                .copyRetainedEncodings(intent.worldId, sourceContext.chainId, prefix)
+                .catch(() => forgetFollowupPreviews(prefix));
             await this.#worlds.playTimeline.persistDetached(structuredClone(prefix));
             previousChainId = prefix.chainId;
         }
@@ -1254,6 +1268,19 @@ export class PlayCallChain {
         if (existing?.kind !== "assistant")
             throw new PlayCallChainError("The durable Provider result no longer matches its assistant event.");
         const calls = durable.toolCalls ?? [];
+        if ((session.lastRequest?.modelConfig?.provider ??
+            session.modelBinding?.provider) === "google_interactions" &&
+            calls.length > 0) {
+            const boundary = session.events.findLastIndex((event) => event.kind === "player" ||
+                (event.kind === "assistant" &&
+                    event.status === "completed" &&
+                    event.responseKind === "narrative"));
+            if (session.events
+                .slice(boundary + 1)
+                .some((event) => event.kind === "tool_call" &&
+                calls.some((call) => call.id === event.callId)))
+                throw new ModelHostOutcomeUnknownError("Google Interactions repeated a tool-call ID during the same send; its outcome cannot be safely settled. Use a fresh context.");
+        }
         const text = durable.text ?? existing.text;
         const hasText = text.trim().length > 0;
         const responseKind = calls.length > 0 ? "tool_step" : hasText ? "narrative" : "empty";
@@ -1561,6 +1588,8 @@ export class PlayCallChain {
                 }
                 response = await modelHost.exchange(request, {
                     signal,
+                    diagnosticAttempt: attempt,
+                    onGoogleHop: (hop) => this.#worlds.playTimeline.recordGoogleHop(session.worldId, session.chainId, session.promptRuns?.at(-1)?.exchange ?? 1, hop),
                     onDelta: (delta) => {
                         this.#observeInvocation(session.chainId, delta.kind, {
                             ...(delta.kind === "reasoning"
@@ -1661,7 +1690,7 @@ export class PlayCallChain {
                             },
                         ],
                     });
-                await this.#advances.end(session, ending, advance, () => this.#notifySnapshot(observer, session));
+                await this.#advances.end(session, { ...ending, streamingEventId: event.id }, advance, () => this.#notifySnapshot(observer, session));
                 return projectView(session);
             }
         }
@@ -1691,6 +1720,13 @@ export class PlayCallChain {
             event.committedHead === session.parentHead);
         if (reply === undefined)
             throw new PlayCallChainError("Follow-up reply is not committed");
+        const run = session.promptRuns?.at(-1);
+        const runReplies = session.events.filter((event) => event.kind === "assistant" &&
+            event.responseKind === "narrative" &&
+            event.committedHead !== undefined &&
+            event.id >= (run?.firstEventId ?? 1));
+        // Without a new prompt run there is no distinct bounded encoding slot.
+        const previewExchange = runReplies.length === 1 ? (run?.exchange ?? 1) : undefined;
         const observeFollowupDelta = (delta) => {
             this.#observeInvocation(session.chainId, "followup", {
                 ...(delta.kind === "reasoning"
@@ -1715,6 +1751,14 @@ export class PlayCallChain {
                     ? {}
                     : { reasoning: outcome.reasoning }),
                 ...(outcome.usage === undefined ? {} : { usage: outcome.usage }),
+                ...(outcome.requestPreviewRecorded !== true ||
+                    outcome.requestPreviewStatus === undefined ||
+                    previewExchange === undefined
+                    ? {}
+                    : {
+                        requestPreviewExchange: previewExchange,
+                        requestPreviewStatus: outcome.requestPreviewStatus,
+                    }),
                 toolCalls: structuredClone(outcome.toolCalls),
                 ...(outcome.failure === undefined ? {} : { failure: outcome.failure }),
             });
@@ -1757,6 +1801,21 @@ export class PlayCallChain {
                     ? {}
                     : { failureLog: this.#failureLog }),
                 observer: {
+                    onGoogleHop: async (id, hop) => {
+                        if (previewExchange !== undefined)
+                            await this.#worlds.playTimeline.recordGoogleHop(session.worldId, session.chainId, previewExchange, hop, id);
+                    },
+                    onRequest: async (id, request) => {
+                        if (previewExchange === undefined)
+                            return false;
+                        // Only Google currently has a continuation-redacting encoder.
+                        const preview = modelHost.binding().provider === "google_interactions"
+                            ? modelHost.previewAuthoringRequest?.(request)
+                            : undefined;
+                        if (preview === undefined)
+                            return false;
+                        return this.#worlds.playTimeline.recordFollowupEncoding(session.worldId, session.chainId, previewExchange, id, preview);
+                    },
                     onProviderDispatch: () => {
                         this.#setInvocationAbortable(session.chainId, true);
                         this.#observeInvocation(session.chainId, "followup", {
@@ -1837,8 +1896,9 @@ export class PlayCallChain {
     }
     /**
      * An in-progress advance, or a session still marked running, means a model
-     * dispatch or settlement was cut off by a process exit. Nothing is replayed:
-     * the exchange is interrupted and the player retries (ADR-0044).
+     * dispatch or settlement was cut off by a process exit. Recovery preserves
+     * persisted endings and applies the protocol's retry boundary (ADR-0035,
+     * ADR-0044).
      */
     async #reconcileSessionAdvance(session, loaded) {
         const advance = loaded === undefined
@@ -2364,6 +2424,9 @@ function assertSessionModelHostBinding(session, modelHost) {
         throw new PlayCallChainError("This model context predates durable provider continuation bindings; start a fresh context.");
     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");
+    if (session.modelBinding.provider === "google_interactions" &&
+        !equalModelHostBinding(session.modelBinding, modelHost.binding()))
+        throw new PlayCallChainError("The selected model connection does not match the frozen Google binding; start a fresh context.");
 }
 function validateIdentity(value, label) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/u.test(value))
@@ -2398,6 +2461,15 @@ function turnNoteField(turnNote) {
 function touch(session) {
     session.updatedAt = Date.now();
 }
+/** Failed diagnostic copies cannot attach unrelated encodings to retained events. */
+function forgetFollowupPreviews(session) {
+    for (const event of session.events) {
+        if (event.kind !== "followup")
+            continue;
+        delete event.requestPreviewExchange;
+        delete event.requestPreviewStatus;
+    }
+}
 function notifyAssistantDelta(observer, delta) {
     try {
         observer?.onAssistantDelta?.(structuredClone(delta));