narraeon 0.7.10 → 0.8.1

package/dist/node/runtime/world-revision/WorldRevisionSession.js

@@ -1,15 +1,37 @@
+import { completedAuthoringEdit, planAuthoringEdit, revertAuthoringChanges, } from "../authoring/AuthoringEditPlan.js";
+import { canRetryAuthoringDispatch, checkpointNextAuthoringDispatch, recoverAuthoringDispatch, } from "../authoring/AuthoringRetry.js";
 import { authoringRequestPreviews } from "../authoring/AuthoringRequestSnapshot.js";
 import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { emptyAggregatedModelUsage } from "../../protocol/modelUsage.js";
-import { appendAuthoringUserMessage, ModelToolConversation, rememberAuthoringRequest, resumePausedAuthoringConversation, } from "../authoring/ModelToolConversation.js";
+import { appendAuthoringUserMessage, authoringExchange, ModelToolConversation, rememberAuthoringRequest, resumePausedAuthoringConversation, } from "../authoring/ModelToolConversation.js";
 import { contentTreeFingerprint } from "../content/ContentTreeFingerprint.js";
 import { equalModelHostBinding } from "../model/ModelHost.js";
 import { settingImprovementPromptForBinding, } from "../play/FileNativePlayPresetStore.js";
 import { authoringPreloadAuthorization, buildAuthoringPreload, worldRevisionAuthoringSurface, } from "../setting/SettingAuthoringTransaction.js";
 import { WorldDocumentStore } from "../world/WorldDocumentStore.js";
-import { WorldRevisionAuthoringTransaction, worldRevisionRuntimeContract, worldRevisionToolDefinitions, } from "./WorldRevisionAuthoringTransaction.js";
+import { WorldRevisionAuthoringTransaction, inspectWorldRevisionFiles, worldRevisionRuntimeContract, worldRevisionToolDefinitions, } from "./WorldRevisionAuthoringTransaction.js";
 import { WorldRevisionWorkspaceError } from "./WorldRevisionWorkspace.js";
 import { historyEntries } from "../history/HistoryTools.js";
+export class WorldRevisionMessageEditError extends Error {
+    reason;
+    paths;
+    constructor(reason, paths = []) {
+        super(reason === "sealed"
+            ? "Changes in a sealed revision cannot be reverted; keep current files to continue"
+            : reason === "conflict"
+                ? `Cannot revert changed files: ${paths.join(", ")}`
+                : `Reverting would make the revision invalid: ${paths.join(", ")}`);
+        this.name = "WorldRevisionMessageEditError";
+        this.reason = reason;
+        this.paths = paths;
+    }
+}
+const liveScopes = new Map();
+const releaseScope = new FinalizationRegistry(({ scope, reference }) => {
+    if (liveScopes.get(scope) === reference)
+        liveScopes.delete(scope);
+});
 /** Conversation orchestration over the shared locked revision worktree. */
 export class WorldRevisionSession {
     #store;
@@ -21,9 +43,9 @@ export class WorldRevisionSession {
     #bindExistingModelHost;
     #bindPlayPreset;
     #preview;
-    #conversation = new ModelToolConversation();
+    #live;
+    #conversation;
     #changed;
-    #mutationTail = Promise.resolve();
     constructor(input) {
         this.#changed =
             input.changed ??
@@ -31,6 +53,21 @@ export class WorldRevisionSession {
                     /* No observers attached. */
                 });
         this.#store = input.store;
+        let live = liveScopes.get(input.store.sessionScope)?.deref();
+        if (live === undefined) {
+            live = {
+                conversation: new ModelToolConversation(),
+                mutationTail: Promise.resolve(),
+            };
+            const reference = new WeakRef(live);
+            liveScopes.set(input.store.sessionScope, reference);
+            releaseScope.register(live, {
+                scope: input.store.sessionScope,
+                reference,
+            });
+        }
+        this.#live = live;
+        this.#conversation = live.conversation;
         this.#workspace = input.workspace;
         this.#worlds = input.worlds;
         this.#compiler = input.compiler;
@@ -55,19 +92,21 @@ export class WorldRevisionSession {
     }
     async overview(worldId) {
         return this.#mutate(async () => {
-            const activeEpoch = await this.#workspace.active(worldId);
-            const [sessions, sealedEpochs] = await Promise.all([
-                this.#recoverWorldSessions(worldId),
+            const sessions = await this.#recoverWorldSessions(worldId);
+            const [activeEpoch, sealedEpochs] = await Promise.all([
+                this.#workspace.active(worldId),
                 this.#workspace.sealed(worldId),
             ]);
-            const latest = sessions[0] ?? null;
+            const latest = sessions.find((session) => !session.damagedContinuation) ?? null;
             const shownEpoch = activeEpoch ?? (await this.#workspace.latest(worldId));
             return {
                 epoch: shownEpoch === null
                     ? null
                     : this.#workspace.view(shownEpoch, activeEpoch?.epochId === shownEpoch.epochId),
                 sealedEpochs,
-                latest: latest === null ? null : this.#view(latest),
+                latest: latest === null
+                    ? null
+                    : this.#view(latest, activeEpoch?.epochId ?? null),
                 history: sessions.map(historyItem),
             };
         });
@@ -89,6 +128,7 @@ export class WorldRevisionSession {
     }
     async status(worldId, sessionId) {
         return this.#mutate(async () => {
+            await this.#workspace.active(worldId);
             const sessions = await this.#store.listSessions(worldId);
             const selectedIndex = sessionId === undefined
                 ? sessions.length === 0
@@ -115,7 +155,8 @@ export class WorldRevisionSession {
         return this.#mutate(async () => {
             const session = await this.#store.readSession(sessionId);
             assertWorld(session, worldId);
-            return this.#view(await this.#recoverIfNeeded(session));
+            const recovered = await this.#recoverIfNeeded(session);
+            return this.#view(recovered, (await this.#workspace.active(worldId))?.epochId ?? null);
         });
     }
     async deleteSession(worldId, sessionId) {
@@ -188,19 +229,30 @@ export class WorldRevisionSession {
                         throw new Error("Another message in this world-revision conversation is still running");
                     return { session, run: running.promise };
                 }
+                if (session.googleOutcomeUnknown)
+                    throw new Error("The Google request outcome is unknown; start a fresh model context.");
+                if (session.runStatus === "paused")
+                    throw new Error("Resume the paused authoring request before sending another message");
             }
             await this.#assertNoRunningConversation(input.worldId, session?.sessionId);
+            let host;
+            if (session !== null) {
+                host = await this.#bindExistingModelHost(session.modelBinding);
+                if (!equalModelHostBinding(session.modelBinding, host.binding()))
+                    throw new Error("No saved model connection matches this world-revision conversation");
+            }
             const epoch = await this.#workspace.open(input.worldId);
             session ??= await this.#create(input.worldId, epoch, requestId);
             if (session.epochId !== epoch.epochId) {
                 retargetSession(session, epoch, this.#locale());
                 await this.#store.saveSession(session);
             }
-            const host = await this.#bindExistingModelHost(session.modelBinding);
+            host ??= await this.#bindExistingModelHost(session.modelBinding);
             if (!equalModelHostBinding(session.modelBinding, host.binding()))
                 throw new Error("No saved model connection matches this world-revision conversation");
             const { playPreset, bootstrap, preload } = await this.#compileCurrent(input.worldId, session.modelBinding);
-            session.schemaVersion = 2;
+            session.schemaVersion = 3;
+            delete session.retryDispatch;
             session.requests ??= [];
             session.requests.push({
                 requestId,
@@ -214,13 +266,127 @@ export class WorldRevisionSession {
             if (preload !== null)
                 session.authorization = authoringPreloadAuthorization(session.authorization, preload.record);
             appendAuthoringUserMessage(session, message, requestId);
+            checkpointNextAuthoringDispatch(session, "dispatching");
+            if (session.modelBinding.provider === "google_interactions")
+                session.googleOutcomeUnknown = false;
+            const boundaries = host.binding().provider === "google_interactions"
+                ? await this.#validatedEpochBoundaries(session)
+                : undefined;
+            if (boundaries !== undefined &&
+                host.previewAuthoringRequest !== undefined)
+                session.requests.at(-1).wireRequest = host.previewAuthoringRequest(authoringExchange(session, requestId, boundaries));
             await this.#store.saveSession(session);
             return {
                 session,
-                run: this.#startRun(session, host, requestId),
+                run: this.#startRun(session, host, requestId, boundaries),
             };
         });
-        return prepared.run ?? this.#view(prepared.session);
+        return (prepared.run ??
+            this.#view(prepared.session, (await this.#workspace.active(input.worldId))?.epochId ?? null));
+    }
+    async editMessage(input) {
+        const message = requiredMessage(input.message);
+        const requestId = requiredRequestId(input.requestId);
+        if (input.filePolicy !== "keep" && input.filePolicy !== "revert")
+            throw new Error("Invalid file policy");
+        const prepared = await this.#mutate(async () => {
+            // Recover the epoch intent before reading the conversation it may replace.
+            let epoch = await this.#workspace.active(input.worldId);
+            let session = await this.#store.readSession(input.sessionId);
+            assertWorld(session, input.worldId);
+            session = await this.#recoverIfNeeded(session);
+            const edit = {
+                requestId,
+                messageId: input.messageId,
+                message,
+                filePolicy: input.filePolicy,
+            };
+            if (completedAuthoringEdit(session, edit))
+                return { session, run: null };
+            const running = this.#conversation.running(session.sessionId);
+            if (running !== null) {
+                if (running.requestId !== requestId)
+                    throw new Error("Another message in this world-revision conversation is still running");
+                return { session, run: running.promise };
+            }
+            if (session.googleOutcomeUnknown)
+                throw new Error("The Google request outcome is unknown; start a fresh model context.");
+            await this.#assertNoRunningConversation(input.worldId, session.sessionId);
+            const host = await this.#bindExistingModelHost(session.modelBinding);
+            if (!equalModelHostBinding(session.modelBinding, host.binding()))
+                throw new Error("No saved model connection matches this world-revision conversation");
+            const { tail, next } = planAuthoringEdit(session, edit);
+            if (input.filePolicy === "revert") {
+                const activeChangeIds = new Set(epoch?.changes.map(({ changeSetId }) => changeSetId) ?? []);
+                if (tail.some((item) => item.kind === "tool" &&
+                    !item.isError &&
+                    item.changes.length > 0 &&
+                    (item.changeSetId === null ||
+                        !activeChangeIds.has(item.changeSetId))))
+                    throw new WorldRevisionMessageEditError("sealed");
+            }
+            epoch ??= await this.#workspace.open(input.worldId);
+            const reverted = input.filePolicy === "revert"
+                ? revertAuthoringChanges(epoch.files, tail)
+                : { files: epoch.files, conflicts: [] };
+            if (reverted.conflicts.length > 0)
+                throw new WorldRevisionMessageEditError("conflict", reverted.conflicts);
+            const afterFiles = reverted.files;
+            if (input.filePolicy === "revert") {
+                const inspection = inspectWorldRevisionFiles(afterFiles, epoch.baseFiles);
+                if (inspection.status !== "usable")
+                    throw new WorldRevisionMessageEditError("invalid_tree", [...new Set(inspection.diagnostics.map(({ path }) => path))].sort());
+            }
+            const candidate = {
+                ...epoch,
+                files: afterFiles,
+                revision: contentTreeFingerprint(afterFiles),
+            };
+            const { playPreset, bootstrap, preload } = await this.#compileCurrent(input.worldId, session.modelBinding, candidate);
+            next.schemaVersion = 3;
+            if (session.epochId !== epoch.epochId ||
+                tail.some((item) => item.kind === "prompt_delta" &&
+                    item.logicalMessages.some((entry) => entry.blocks.some((block) => block.source.startsWith("runtime:world-revision-epoch:")))))
+                retargetSession(next, epoch, this.#locale());
+            next.epochId = epoch.epochId;
+            next.requests.push({
+                requestId,
+                modelItemStart: next.modelItems.length,
+                bootstrap,
+                playPreset: structuredClone(playPreset),
+                ...(preload === null
+                    ? {}
+                    : { preload: structuredClone(preload.record) }),
+            });
+            next.authorization =
+                preload === null
+                    ? null
+                    : authoringPreloadAuthorization(null, preload.record);
+            appendAuthoringUserMessage(next, message, requestId);
+            checkpointNextAuthoringDispatch(next, "dispatching");
+            if (next.modelBinding.provider === "google_interactions")
+                next.googleOutcomeUnknown = false;
+            const boundaries = host.binding().provider === "google_interactions"
+                ? await this.#validatedEpochBoundaries(next)
+                : undefined;
+            if (boundaries !== undefined &&
+                host.previewAuthoringRequest !== undefined)
+                next.requests.at(-1).wireRequest = host.previewAuthoringRequest(authoringExchange(next, requestId, boundaries));
+            await this.#workspace.publishEdit({
+                worldId: input.worldId,
+                epochId: epoch.epochId,
+                expectedRevision: epoch.revision,
+                files: afterFiles,
+                session: next,
+            });
+            this.#changed(input.worldId, true);
+            return {
+                session: next,
+                run: this.#startRun(next, host, requestId, boundaries),
+            };
+        });
+        return (prepared.run ??
+            this.#view(prepared.session, (await this.#workspace.active(input.worldId))?.epochId ?? null));
     }
     /** Continues a paused conversation within the revision it paused in. */
     async resume(input) {
@@ -244,11 +410,25 @@ export class WorldRevisionSession {
             const host = await this.#bindExistingModelHost(session.modelBinding);
             if (!equalModelHostBinding(session.modelBinding, host.binding()))
                 throw new Error("No saved model connection matches this world-revision conversation");
-            resumePausedAuthoringConversation(session);
+            if (canRetryAuthoringDispatch(session)) {
+                session.runStatus = "running";
+                session.activeRequestId = session.requests?.at(-1)?.requestId ?? null;
+                session.lastFailure = null;
+                session.updatedAt = Date.now();
+            }
+            else
+                resumePausedAuthoringConversation(session);
+            const boundaries = host.binding().provider === "google_interactions"
+                ? await this.#validatedEpochBoundaries(session)
+                : undefined;
             await this.#store.saveSession(session);
-            return { session, run: this.#startRun(session, host, requestId) };
+            return {
+                session,
+                run: this.#startRun(session, host, requestId, boundaries),
+            };
         });
-        return prepared.run ?? this.#view(prepared.session);
+        return (prepared.run ??
+            this.#view(prepared.session, (await this.#workspace.active(input.worldId))?.epochId ?? null));
     }
     async preview(worldId, sessionId) {
         const session = sessionId === undefined ? null : await this.#store.readSession(sessionId);
@@ -263,8 +443,8 @@ export class WorldRevisionSession {
         const { bootstrap } = await this.#compileCurrent(worldId, host.binding());
         return bootstrap;
     }
-    async #compileCurrent(worldId, modelBinding) {
-        const epoch = await this.#workspace.active(worldId);
+    async #compileCurrent(worldId, modelBinding, overrideEpoch) {
+        const epoch = overrideEpoch ?? (await this.#workspace.active(worldId));
         const worlds = await this.#worlds.listWorlds();
         const playPreset = await this.#bindPlayPreset();
         const locale = this.#locale();
@@ -361,7 +541,8 @@ export class WorldRevisionSession {
         });
         const now = Date.now();
         const session = {
-            schemaVersion: 1,
+            schemaVersion: 3,
+            requests: [],
             sessionId: this.#store.createSessionId(),
             worldId,
             worldTitle,
@@ -385,27 +566,58 @@ export class WorldRevisionSession {
             authorization: null,
             pendingSettlement: null,
         };
-        await this.#store.saveSession(session);
         return session;
     }
-    #startRun(session, host, requestId) {
+    #startRun(session, host, requestId, worldRevisionBoundaries) {
         let activeTransaction = null;
         return this.#conversation.run({
             changed: (durable) => this.#changed(session.worldId, durable),
             session,
             host,
             requestId,
+            exchangeRequestId: session.activeRequestId ?? requestId,
+            ...(worldRevisionBoundaries === undefined
+                ? {}
+                : { worldRevisionBoundaries }),
             save: (next) => this.#store.saveSession(next),
+            recordGoogleHop: (id, hop) => this.#store.recordGoogleHop(session.sessionId, id, hop),
             settleToolResponse: async (next, assistantItemIndex, calls) => {
                 activeTransaction = await this.#settleToolResponse(next, assistantItemIndex, calls, activeTransaction);
             },
             view: (next) => this.#view(next),
+            retrySupported: session.schemaVersion === 3,
             failure: {
                 cancelled: "The world-revision response was cancelled. Settled worktree changes were retained.",
                 interrupted: "The world-revision response was interrupted",
             },
         });
     }
+    async #validatedEpochBoundaries(session) {
+        const entries = [];
+        for (const [itemIndex, item] of session.modelItems.entries()) {
+            if (item.kind !== "prompt_delta")
+                continue;
+            const source = item.logicalMessages[0]?.blocks[0]?.source;
+            if (source?.startsWith("runtime:world-revision-epoch:") !== true)
+                continue;
+            const epochId = source.slice("runtime:world-revision-epoch:".length);
+            const epoch = await this.#store.readEpoch(epochId);
+            if (epoch.worldId !== session.worldId)
+                throw new Error("World-revision epoch boundary belongs to another world");
+            const valid = ["en", "zh-CN"].some((locale) => isDeepStrictEqual(item, epochBoundaryItem(epoch, locale)));
+            if (!valid)
+                throw new Error("World-revision epoch boundary is damaged");
+            entries.push({
+                itemIndex,
+                epochId,
+                baseHead: epoch.baseHead,
+                markdown: item.logicalMessages[0].markdown,
+            });
+        }
+        if (entries.length > 0 && entries.at(-1)?.epochId !== session.epochId)
+            throw new Error("World-revision epoch boundary does not match the current epoch");
+        return { currentEpochId: session.epochId, entries };
+    }
     async #settleToolResponse(session, assistantItemIndex, calls, active) {
         const epoch = await this.#requiredActiveEpoch(session);
         const beforeRevision = epoch.revision;
@@ -455,6 +667,8 @@ export class WorldRevisionSession {
             toolResults,
         });
         finalizeSettlement(session, prepared);
+        if (session.schemaVersion === 3)
+            checkpointNextAuthoringDispatch(session, "dispatching");
         session.updatedAt = Date.now();
         await this.#store.saveSession(session);
         return { revision: afterRevision, transaction };
@@ -512,27 +726,66 @@ export class WorldRevisionSession {
         }
     }
     async #recoverIfNeeded(session) {
+        if (session.damagedContinuation)
+            return session;
         if (this.#conversation.isRunning(session.sessionId))
             return session;
+        await this.#workspace.active(session.worldId);
+        session = await this.#store.readSession(session.sessionId);
+        const lastItem = session.modelItems.at(-1);
+        if (session.pendingSettlement === null &&
+            session.modelBinding.provider === "google_interactions" &&
+            session.runStatus === "interrupted" &&
+            session.googleOutcomeUnknown === undefined &&
+            (lastItem?.kind === "user" || lastItem?.kind === "tool")) {
+            session.googleOutcomeUnknown = true;
+            session.lastFailure =
+                "The Google request outcome is unknown; start a fresh model context.";
+            session.updatedAt = Date.now();
+            await this.#store.saveSession(session);
+            return session;
+        }
+        if (session.pendingSettlement === null &&
+            lastItem?.kind === "assistant" &&
+            lastItem.toolCalls.length > 0) {
+            finalizeUnconfirmed(session, session.modelItems.length - 1, new Error("Runtime found a complete tool response without a persisted worktree settlement intent"));
+            if (session.modelBinding.provider === "google_interactions")
+                session.googleOutcomeUnknown = false;
+            const requestId = session.activeRequestId;
+            session.runStatus = "interrupted";
+            session.activeRequestId = null;
+            if (requestId !== null)
+                session.completedRequestIds = rememberAuthoringRequest(session.completedRequestIds, requestId);
+            session.lastFailure =
+                "The complete tool response could not be settled; its calls received failure receipts. Re-read the worktree before editing.";
+            session.updatedAt = Date.now();
+            await this.#store.saveSession(session);
+            return session;
+        }
+        if (session.runStatus === "running" &&
+            session.pendingSettlement === null &&
+            session.modelBinding.provider === "google_interactions" &&
+            session.googleOutcomeUnknown !== false)
+            session.googleOutcomeUnknown = true;
+        const recoveringSettlement = session.pendingSettlement !== null;
+        let settlementPublished = false;
         if (session.pendingSettlement !== null) {
+            if (session.modelBinding.provider === "google_interactions")
+                session.googleOutcomeUnknown = false;
             const pending = session.pendingSettlement;
             if (pending.phase === "publication_prepared") {
                 const active = await this.#workspace.active(session.worldId);
                 if (active?.epochId === pending.epochId) {
-                    try {
-                        await this.#workspace.publishAi({
-                            worldId: session.worldId,
-                            epochId: pending.epochId,
-                            expectedRevision: pending.beforeRevision,
-                            afterRevision: pending.afterRevision,
-                            files: pending.afterFiles,
-                            toolResults: pending.toolResults,
-                        });
-                        finalizeSettlement(session, pending);
-                    }
-                    catch (error) {
-                        finalizeUnconfirmed(session, pending.assistantItemIndex, error);
-                    }
+                    await this.#workspace.publishAi({
+                        worldId: session.worldId,
+                        epochId: pending.epochId,
+                        expectedRevision: pending.beforeRevision,
+                        afterRevision: pending.afterRevision,
+                        files: pending.afterFiles,
+                        toolResults: pending.toolResults,
+                    });
+                    finalizeSettlement(session, pending);
+                    settlementPublished = true;
                 }
                 else
                     finalizeUnconfirmed(session, pending.assistantItemIndex, new Error("The revision epoch ended before tool publication recovered"));
@@ -540,15 +793,27 @@ export class WorldRevisionSession {
             else
                 finalizeUnconfirmed(session, pending.assistantItemIndex, new Error("Runtime restarted before the complete tool response was prepared"));
         }
-        if (session.runStatus !== "running" && session.pendingSettlement === null)
+        if (session.runStatus !== "running" && !recoveringSettlement)
             return session;
         const requestId = session.activeRequestId;
-        session.runStatus = "interrupted";
+        if (settlementPublished &&
+            session.modelBinding.provider !== "google_interactions" &&
+            session.requests?.at(-1) !== undefined) {
+            session.schemaVersion = 3;
+            checkpointNextAuthoringDispatch(session, "retryable");
+        }
+        recoverAuthoringDispatch(session);
+        session.runStatus =
+            session.modelBinding.provider === "google_interactions" &&
+                session.googleOutcomeUnknown === false
+                ? "paused"
+                : "interrupted";
         session.activeRequestId = null;
         if (requestId !== null)
             session.completedRequestIds = rememberAuthoringRequest(session.completedRequestIds, requestId);
-        session.lastFailure =
-            "The previous model request stopped after its last settled worktree change. Continue this conversation when ready.";
+        session.lastFailure = session.googleOutcomeUnknown
+            ? "The Google request outcome is unknown; start a fresh model context."
+            : "The previous model request stopped after its last settled worktree change. Continue this conversation when ready.";
         session.updatedAt = Date.now();
         await this.#store.saveSession(session);
         return session;
@@ -571,7 +836,7 @@ export class WorldRevisionSession {
             this.#conversation.isRunning(sessionId)))
             throw new WorldRevisionWorkspaceError("Wait for or cancel the running AI response before changing the revision");
     }
-    #view(session) {
+    #view(session, activeEpochId = session.epochId) {
         const streaming = session.runStatus === "running"
             ? this.#conversation.streaming(session.sessionId)
             : null;
@@ -591,6 +856,7 @@ export class WorldRevisionSession {
                 updatedAt: session.updatedAt,
             },
             lastFailure: session.lastFailure,
+            canRetry: activeEpochId === session.epochId && canRetryAuthoringDispatch(session),
         };
     }
     #statusView(session) {
@@ -609,9 +875,9 @@ export class WorldRevisionSession {
         };
     }
     async #mutate(operation) {
-        const previous = this.#mutationTail;
+        const previous = this.#live.mutationTail;
         let release = () => undefined;
-        this.#mutationTail = new Promise((resolveMutation) => {
+        this.#live.mutationTail = new Promise((resolveMutation) => {
             release = resolveMutation;
         });
         await previous;
@@ -624,10 +890,18 @@ export class WorldRevisionSession {
     }
 }
 function retargetSession(session, epoch, locale) {
+    session.modelItems.push(epochBoundaryItem(epoch, locale));
+    session.epochId = epoch.epochId;
+    session.authorization = null;
+    session.pendingSettlement = null;
+    session.lastFailure = null;
+    session.updatedAt = Date.now();
+}
+function epochBoundaryItem(epoch, locale) {
     const markdown = locale === "zh-CN"
         ? `# 新的世界修订 epoch\n\n上一轮修订已经应用或放弃。当前工作树是 ${epoch.epochId}，从世界端点 ${epoch.baseHead} 重新建立。此前全部 search cursor 和 read 写授权已失效；修改前必须重新读取。`
         : `# New world-revision epoch\n\nThe previous revision was applied or discarded. Worktree ${epoch.epochId} was rebuilt from world endpoint ${epoch.baseHead}. Every prior search cursor and read authorization is invalid; re-read before writing.`;
-    session.modelItems.push({
+    return {
         kind: "prompt_delta",
         logicalMessages: [
             {
@@ -641,12 +915,7 @@ function retargetSession(session, epoch, locale) {
                 ],
             },
         ],
-    });
-    session.epochId = epoch.epochId;
-    session.authorization = null;
-    session.pendingSettlement = null;
-    session.lastFailure = null;
-    session.updatedAt = Date.now();
+    };
 }
 function finalizeSettlement(session, pending) {
     for (const result of pending.toolResults)
@@ -745,6 +1014,11 @@ function historyItem(session) {
     const changed = new Set(session.modelItems.flatMap((item) => item.kind === "tool" ? item.changes.map(({ path }) => path) : []));
     return {
         sessionId: session.sessionId,
+        ...(session.damagedContinuation
+            ? {
+                unavailableReason: "Google continuation is damaged; start a fresh model context.",
+            }
+            : {}),
         epochId: session.epochId,
         runStatus: session.runStatus,
         createdAt: session.createdAt,

package/dist/node/runtime/world-revision/WorldRevisionWorkspace.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
 import { contentTreeFingerprint } from "../content/ContentTreeFingerprint.js";
 import { readDeclaredWorldClock } from "../prompt/WorldMaintenanceReport.js";
 import { WorldOperationClaimLostError } from "../world/WorldOperationCoordinator.js";
@@ -125,6 +126,47 @@ export class WorldRevisionWorkspace {
             return epoch;
         });
     }
+    async publishEdit(input) {
+        const handle = revisionHandle(input);
+        await this.#withMutableEpoch(handle, async (epoch) => {
+            assertExpectedRevision(epoch, input.expectedRevision);
+            const files = cloneFiles(input.files);
+            assertUsableWorldRevisionFiles(files, epoch.baseFiles);
+            const changes = fileDiff(epoch.files, files);
+            if (changes.length > 0)
+                epoch.changes.push({
+                    changeSetId: this.#store.createChangeSetId(),
+                    source: "rollback",
+                    createdAt: Date.now(),
+                    changes,
+                });
+            epoch.files = files;
+            epoch.revision = contentTreeFingerprint(files);
+            epoch.updatedAt = Date.now();
+            await this.#store.prepareEdit({
+                beforeRevision: input.expectedRevision,
+                epoch,
+                session: input.session,
+            });
+            await this.#finishEdit(handle);
+        });
+    }
+    async #finishEdit(handle) {
+        const pending = await this.#store.readEdit(handle.epochId);
+        if (pending === null)
+            return;
+        if (pending.epoch.worldId !== handle.worldId)
+            throw new WorldRevisionWorkspaceError("Pending edit belongs to another world");
+        const current = await this.#store.readEpoch(handle.epochId);
+        if (!isDeepStrictEqual(current, pending.epoch)) {
+            if (current.lifecycle !== "active" ||
+                current.revision !== pending.beforeRevision)
+                throw new WorldRevisionWorkspaceError("Pending world-revision edit conflicts with the worktree");
+            await this.#store.saveEpoch(pending.epoch);
+        }
+        await this.#store.saveSession(pending.session);
+        await this.#store.removeEdit(handle.epochId);
+    }
     async rollback(input) {
         const handle = revisionHandle(input);
         return this.#withMutableEpoch(handle, async (epoch) => {
@@ -227,6 +269,7 @@ export class WorldRevisionWorkspace {
         };
     }
     async #resumeLocked(handle) {
+        await this.#withRevisionOwnership(handle, () => Promise.resolve());
         let epoch = await this.#store.readEpochIfPresent(handle.epochId);
         if (epoch === null) {
             const binding = await this.#worlds.bindWorldRevision(handle);
@@ -336,7 +379,10 @@ export class WorldRevisionWorkspace {
     }
     async #withRevisionOwnership(handle, action) {
         try {
-            return await this.#worlds.operations.withWorldRevisionLock(handle, action);
+            return await this.#worlds.operations.withWorldRevisionLock(handle, async () => {
+                await this.#finishEdit(handle);
+                return action();
+            });
         }
         catch (error) {
             if (error instanceof WorldOperationClaimLostError)