@markusylisiurunen/tau 0.3.42 → 0.3.44

package/dist/host/local_session_host.js

@@ -9,11 +9,11 @@ import { SUBAGENT_ACTIVITY_FACET_KIND } from "../core/subagents/types.js";
 import { buildToolRunPresentation, TOOL_UI_FACET_VERSION } from "../core/tools/presentation.js";
 import { appendUsageLogEntry, getUsageCostTotal, getUsageTotals, } from "../core/usage/logs.js";
 import { filterProjectPathAutocompleteEntries, loadProjectPathAutocompleteEntriesWithBackend, } from "../core/utils/project_files.js";
-import { hasAutoCompactionContinuationMetadata, hasGoalTurnMetadata, isTauUserMessageHidden, } from "../core/utils/user_metadata.js";
-import { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, } from "../protocol/session_protocol.js";
-import { LEGACY_SESSION_CONTEXT_EPOCH } from "../store/session_snapshot_migrations.js";
+import { hasGoalTurnMetadata } from "../core/utils/user_metadata.js";
+import { applySessionProtocolDelta, createSessionProtocolDeltaMessage, createSessionProtocolEphemeralMessage, projectSessionProtocolNoticePresentation, } from "../protocol/session_protocol.js";
+import { LEGACY_SESSION_MODEL_CONTEXT_KEY } from "../store/session_snapshot_migrations.js";
 import { ClientToolBroker } from "./client_tool_broker.js";
-import { createExecutionEnvironmentSubagentRuntimeResolver } from "./execution_runtime.js";
+import { createExecutionEnvironmentSubagentPromptResolver } from "./execution_runtime.js";
 import { HostedEphemeralAgentSession } from "./hosted_ephemeral_agent_session.js";
 import { SessionExecBusyError, SessionRetryUnavailableError, } from "./session_host.js";
 const PATH_AUTOCOMPLETE_CACHE_TTL_MS = 5_000;
@@ -76,7 +76,7 @@ export class LocalSessionHost {
             const agentRecovery = hostedSession.runtime.restoreState({
                 agentId: recovered.snapshot.sessionId,
                 revision: recovered.snapshot.agentState.revision,
-                contextEpoch: recovered.snapshot.agentState.contextEpoch,
+                modelContextKey: recovered.snapshot.agentState.modelContextKey,
                 historyEntries: recovered.snapshot.messages.flatMap((entry) => entry.modelVisible && isCoreMessage(entry.message)
                     ? [{ id: entry.id, message: entry.message }]
                     : []),
@@ -124,7 +124,7 @@ export class LocalSessionHost {
             backend: executionEnvironment.getToolExecutionBackend(),
             clientTools: (sessionId) => this.clientToolBroker.getToolDefinitions(sessionId),
             modelResolver: bootstrap.modelResolver,
-            resolveSubagentRuntime: createExecutionEnvironmentSubagentRuntimeResolver({
+            resolveSubagentPrompts: createExecutionEnvironmentSubagentPromptResolver({
                 executionEnvironment,
                 includeAgentContext: this.sessionOptions.includeAgentContext,
                 now: this.sessionOptions.environment.now,
@@ -344,6 +344,9 @@ export class LocalSessionHost {
         return false;
     }
 }
+function normalizeDeltaCause(cause) {
+    return typeof cause === "string" ? { type: cause } : cause;
+}
 class LocalHostedSessionHandle {
     runtime;
     promptBootstrap;
@@ -364,11 +367,11 @@ class LocalHostedSessionHandle {
     persistedSnapshot;
     draftAssistantMessage;
     messageStates = new Map();
-    turnOutcomes = new Map();
-    restoredMessageIds;
-    restoredTimelineMessageIds;
-    timelineExtras = [];
+    timeline = { epoch: 1, sequence: 0, items: [] };
+    turns = new Map();
+    pendingAcceptedTurnHistoryEntryIds = new Set();
     tools = new Map();
+    operations = new Map();
     agents = new Map();
     agentCostTotals = new Map();
     facets = new Map();
@@ -484,19 +487,14 @@ class LocalHostedSessionHandle {
                 this.pendingGoalCommit = goal;
             });
             try {
-                const { userHistoryEntryId } = await this.record({
+                const { userHistoryEntryId } = await this.acceptTurn({
                     text: prependGoalPolicy(goal.objective, goal),
                 });
-                if (logicalTurn.cancellationRequested) {
-                    return {
-                        userHistoryEntryId,
-                        turn: await this.cancelLogicalTurn(userHistoryEntryId),
-                    };
-                }
-                return {
-                    userHistoryEntryId,
-                    turn: await this.runTurnNow(logicalTurn, userHistoryEntryId),
-                };
+                const turn = logicalTurn.cancellationRequested
+                    ? await this.cancelLogicalTurn()
+                    : await this.runTurnNow(logicalTurn, userHistoryEntryId);
+                await this.settleTurn(userHistoryEntryId, turn);
+                return { userHistoryEntryId, turn };
             }
             catch (error) {
                 if (this.pendingGoalCommit === goal) {
@@ -525,13 +523,14 @@ class LocalHostedSessionHandle {
                     await this.blockActiveGoal();
                     return { turn: abortedTurnOutcome() };
                 }
-                const { userHistoryEntryId } = await this.record({
+                const { userHistoryEntryId } = await this.acceptTurn({
                     text: buildGoalContinuationText(goal),
                 });
-                if (logicalTurn.cancellationRequested) {
-                    return { turn: await this.cancelLogicalTurn(userHistoryEntryId) };
-                }
-                return { turn: await this.runTurnNow(logicalTurn, userHistoryEntryId) };
+                const turn = logicalTurn.cancellationRequested
+                    ? await this.cancelLogicalTurn()
+                    : await this.runTurnNow(logicalTurn, userHistoryEntryId);
+                await this.settleTurn(userHistoryEntryId, turn);
+                return { turn };
             }
             catch (error) {
                 await this.blockActiveGoal().catch(() => undefined);
@@ -549,15 +548,83 @@ class LocalHostedSessionHandle {
     }
     async record(options) {
         this.assertActive();
-        const userHistoryEntryId = await this.session.commitUserText(options.text, options.historyEntryId ? { historyEntryId: options.historyEntryId } : undefined);
+        const historyEntryId = options.historyEntryId === undefined
+            ? undefined
+            : normalizeExplicitHistoryEntryId(options.historyEntryId);
+        if (historyEntryId !== undefined &&
+            (this.turns.has(historyEntryId) ||
+                this.pendingAcceptedTurnHistoryEntryIds.has(historyEntryId))) {
+            throw new Error(`history entry id '${historyEntryId}' belongs to an accepted turn`);
+        }
+        const userHistoryEntryId = await this.session.commitUserText(options.text, historyEntryId === undefined ? undefined : { historyEntryId });
         return {
             snapshot: await this.snapshot(),
             userHistoryEntryId,
         };
     }
+    async acceptTurn(options) {
+        this.assertActive();
+        const userHistoryEntryId = this.createTurnHistoryEntryId(options.historyEntryId);
+        this.pendingAcceptedTurnHistoryEntryIds.add(userHistoryEntryId);
+        try {
+            await this.session.commitUserText(options.text, { historyEntryId: userHistoryEntryId });
+            return { snapshot: await this.snapshot(), userHistoryEntryId };
+        }
+        finally {
+            this.pendingAcceptedTurnHistoryEntryIds.delete(userHistoryEntryId);
+        }
+    }
+    createTurnHistoryEntryId(preferredId) {
+        if (preferredId !== undefined) {
+            const normalizedId = normalizeExplicitHistoryEntryId(preferredId);
+            if (this.turns.has(normalizedId) ||
+                this.pendingAcceptedTurnHistoryEntryIds.has(normalizedId)) {
+                throw new Error(`turn '${normalizedId}' was already accepted`);
+            }
+            return normalizedId;
+        }
+        let id = `history-${randomUUID()}`;
+        const historyEntryIds = new Set(this.session.rawHistoryEntries.map((entry) => entry.id));
+        while (this.turns.has(id) ||
+            this.pendingAcceptedTurnHistoryEntryIds.has(id) ||
+            historyEntryIds.has(id)) {
+            id = `history-${randomUUID()}`;
+        }
+        return id;
+    }
+    async runAcceptedTurn(userHistoryEntryId) {
+        const acceptedTurn = this.turns.get(userHistoryEntryId);
+        if (!acceptedTurn)
+            throw new Error(`turn '${userHistoryEntryId}' was not accepted`);
+        if (acceptedTurn.state === "settled") {
+            throw new Error(`turn '${userHistoryEntryId}' was already settled`);
+        }
+        const turn = await this.runLogicalTurn((logicalTurn) => this.runTurnNow(logicalTurn, userHistoryEntryId));
+        await this.settleTurn(userHistoryEntryId, turn);
+        return { userHistoryEntryId, turn };
+    }
     async runTurn() {
         return await this.runLogicalTurn((logicalTurn) => this.runTurnNow(logicalTurn));
     }
+    async settleTurn(userHistoryEntryId, outcome) {
+        await this.enqueueMutation(async () => {
+            const existing = this.turns.get(userHistoryEntryId);
+            if (!existing) {
+                throw new Error(`turn '${userHistoryEntryId}' was not accepted`);
+            }
+            if (existing.state === "settled") {
+                if (isDeepStrictEqual(existing.outcome, outcome))
+                    return;
+                throw new Error(`turn '${userHistoryEntryId}' was already settled`);
+            }
+            const turn = { userHistoryEntryId, state: "settled", outcome };
+            this.turns.set(userHistoryEntryId, turn);
+            const delta = await this.commitSnapshotPatch("assistant-message", [
+                { type: "turn.set", turn },
+            ]);
+            this.emitDelta(delta);
+        });
+    }
     async retryTurn() {
         const userMessage = this.session.rawHistoryEntries.findLast((entry) => entry.message.role === "user");
         if (userMessage && hasGoalTurnMetadata(userMessage.message)) {
@@ -602,7 +669,7 @@ class LocalHostedSessionHandle {
         let goalRootHistoryEntryId = this.goal?.status === "active" ? rootUserMessage.id : undefined;
         while (true) {
             if (logicalTurn.cancellationRequested) {
-                return await this.cancelLogicalTurn(rootUserMessage.id);
+                return await this.cancelLogicalTurn();
             }
             const committedSteering = [];
             try {
@@ -610,11 +677,7 @@ class LocalHostedSessionHandle {
                     committedSteering.push(await this.commitBufferedLogicalSteering(logicalTurn));
                 }
                 if (logicalTurn.cancellationRequested) {
-                    return await this.cancelLogicalTurn(rootUserMessage.id, committedSteering);
-                }
-                const userMessage = this.session.rawHistoryEntries.findLast((entry) => entry.message.role === "user");
-                if (!userMessage) {
-                    throw new Error("cannot run a turn without a user message");
+                    return await this.cancelLogicalTurn(committedSteering);
                 }
                 const result = await this.runtime.runTurn();
                 const terminalResult = result.terminalResult;
@@ -624,24 +687,17 @@ class LocalHostedSessionHandle {
                 const initialOutcome = turnOutcomeFromResult(result, result.finalMessage);
                 const terminalOutcome = turnOutcomeFromResult(terminalResult, terminalResult.finalMessage);
                 await this.enqueueMutation(async () => {
-                    this.turnOutcomes.set(userMessage.id, initialOutcome);
-                    for (const steering of committedSteering) {
-                        this.turnOutcomes.set(steering.historyEntryId, initialOutcome);
-                    }
                     if (this.goal?.status === "active") {
                         goalRootHistoryEntryId ??= rootUserMessage.id;
                     }
-                    if (goalRootHistoryEntryId) {
-                        this.turnOutcomes.set(goalRootHistoryEntryId, terminalOutcome);
-                    }
                     if (terminalOutcome.status !== "completed" && this.goal?.status === "active") {
                         this.goal = { ...this.goal, status: "blocked" };
                     }
                     await this.emitSnapshotResetIfChanged("assistant-message");
                 });
-                this.resolveCommittedLogicalSteering(committedSteering, initialOutcome);
+                await this.resolveCommittedLogicalSteering(committedSteering, initialOutcome);
                 if (logicalTurn.cancellationRequested) {
-                    return await this.cancelLogicalTurn(rootUserMessage.id);
+                    return await this.cancelLogicalTurn();
                 }
                 if (terminalOutcome.status !== "completed" || this.goal?.status !== "active") {
                     return goalRootHistoryEntryId ? terminalOutcome : initialOutcome;
@@ -652,9 +708,15 @@ class LocalHostedSessionHandle {
                 await this.session.commitUserText(buildGoalContinuationText(this.goal));
             }
             catch (error) {
-                this.rejectCommittedLogicalSteering(committedSteering, error);
-                await this.cleanupFailedTurn(rootUserMessage.id, committedSteering, error).catch(() => undefined);
-                throw error;
+                try {
+                    const outcome = await this.cleanupFailedTurn(rootUserMessage.id, error);
+                    await this.resolveCommittedLogicalSteering(committedSteering, outcome);
+                    return outcome;
+                }
+                catch {
+                    this.rejectCommittedLogicalSteering(committedSteering, error);
+                    throw error;
+                }
             }
         }
     }
@@ -706,11 +768,8 @@ class LocalHostedSessionHandle {
                 })),
                 result: submission.result.then(async (association) => {
                     const turn = turnOutcomeFromResult(association.result, association.result.finalMessage);
-                    await this.commitSteeringTurnOutcome(association.historyEntryId, turn);
-                    return {
-                        userHistoryEntryId: association.historyEntryId,
-                        turn,
-                    };
+                    await this.settleTurn(association.historyEntryId, turn);
+                    return { userHistoryEntryId: association.historyEntryId, turn };
                 }),
             };
         }
@@ -784,7 +843,7 @@ class LocalHostedSessionHandle {
                     sessionId: snapshot.sessionId,
                     fromRevision,
                     toRevision: snapshot.revision,
-                    reason: "configuration",
+                    cause: { type: "configuration" },
                     delta: {
                         type: "snapshot.patch",
                         changes: [{ type: "settings.set", settings: snapshot.settings }],
@@ -926,16 +985,11 @@ class LocalHostedSessionHandle {
                 signal,
             });
             signal.throwIfAborted();
-            return await this.enqueueMutation(async () => {
-                this.reconcileProjections();
-                const snapshot = await this.commitSnapshot();
-                this.emitSnapshotReset("maintenance", snapshot);
-                return {
-                    snapshot,
-                    compactionMessage: result.compactionMessage,
-                    includedLastAssistant: result.includedLastAssistant,
-                };
-            });
+            return {
+                snapshot: await this.snapshot(),
+                compactionMessage: result.compactionMessage,
+                includedLastAssistant: result.includedLastAssistant,
+            };
         });
     }
     async runMaintenance(operation) {
@@ -979,6 +1033,9 @@ class LocalHostedSessionHandle {
     }
     async rewindToHistoryEntryId(historyEntryId) {
         this.assertActive();
+        if (!this.timeline.items.some((item) => item.type === "message" && item.messageId === historyEntryId)) {
+            throw new Error("rewind failed");
+        }
         const result = await this.session.rewindToHistoryEntryId(historyEntryId);
         if (!result) {
             throw new Error("rewind failed");
@@ -1180,7 +1237,14 @@ class LocalHostedSessionHandle {
             if (goal?.status !== "active") {
                 throw new Error("cannot commit logical steering without an active goal");
             }
-            const historyEntryId = await this.session.commitUserText(prependGoalPolicy(formatSteeringUserMessage(submissions.map((submission) => submission.text)), goal));
+            const historyEntryId = this.createTurnHistoryEntryId();
+            this.pendingAcceptedTurnHistoryEntryIds.add(historyEntryId);
+            try {
+                await this.session.commitUserText(prependGoalPolicy(formatSteeringUserMessage(submissions.map((submission) => submission.text)), goal), { historyEntryId });
+            }
+            finally {
+                this.pendingAcceptedTurnHistoryEntryIds.delete(historyEntryId);
+            }
             for (const submission of submissions) {
                 submission.resolveApplied({ userHistoryEntryId: historyEntryId });
             }
@@ -1195,8 +1259,9 @@ class LocalHostedSessionHandle {
             throw error;
         }
     }
-    resolveCommittedLogicalSteering(committed, turn) {
+    async resolveCommittedLogicalSteering(committed, turn) {
         for (const { historyEntryId, submissions } of committed) {
+            await this.settleTurn(historyEntryId, turn);
             for (const submission of submissions) {
                 submission.resolveResult({ userHistoryEntryId: historyEntryId, turn });
             }
@@ -1216,23 +1281,20 @@ class LocalHostedSessionHandle {
             submission.rejectResult(error);
         }
     }
-    async cancelLogicalTurn(rootHistoryEntryId, committedSteering = []) {
+    async cancelLogicalTurn(committedSteering = []) {
         const outcome = abortedTurnOutcome();
         await this.enqueueMutation(async () => {
-            this.turnOutcomes.set(rootHistoryEntryId, outcome);
-            for (const steering of committedSteering) {
-                this.turnOutcomes.set(steering.historyEntryId, outcome);
-            }
             if (this.goal?.status === "active") {
                 this.goal = { ...this.goal, status: "blocked" };
             }
             await this.emitSnapshotResetIfChanged("assistant-message");
         });
-        this.resolveCommittedLogicalSteering(committedSteering, outcome);
+        await this.resolveCommittedLogicalSteering(committedSteering, outcome);
         return outcome;
     }
     async commitSnapshot() {
         this.assertNotDisposed();
+        this.reconcileProjections();
         const draft = this.buildSnapshotDraft();
         await this.switchSnapshotSession(draft.sessionId);
         const snapshot = {
@@ -1265,7 +1327,7 @@ class LocalHostedSessionHandle {
         this.persistedSnapshot = cloneSessionProtocolSnapshot(snapshot);
         return snapshot;
     }
-    async commitSnapshotPatch(reason, changes) {
+    async commitSnapshotPatch(cause, changes) {
         this.assertNotDisposed();
         const current = this.committedSnapshot;
         if (!current) {
@@ -1275,7 +1337,7 @@ class LocalHostedSessionHandle {
             sessionId: current.sessionId,
             fromRevision: current.revision,
             toRevision: current.revision + 1,
-            reason,
+            cause: normalizeDeltaCause(cause),
             delta: { type: "snapshot.patch", changes },
         });
         const snapshot = applySessionProtocolDelta(current, delta);
@@ -1300,10 +1362,8 @@ class LocalHostedSessionHandle {
     reconcileProjections(options = {}) {
         const messageIds = new Set(this.session.rawHistoryEntries.map((entry) => entry.id));
         messageIds.add("system");
-        for (const id of this.turnOutcomes.keys()) {
-            if (!messageIds.has(id)) {
-                this.turnOutcomes.delete(id);
-            }
+        if (this.draftAssistantMessage) {
+            messageIds.add(this.draftAssistantMessage.id);
         }
         for (const [id, tool] of this.tools) {
             const messageId = tool.status === "streaming" ? tool.origin.messageId : tool.call.messageId;
@@ -1322,13 +1382,36 @@ class LocalHostedSessionHandle {
                 }
             }
         }
-        const operationIds = new Set(this.timelineExtras.filter((item) => item.type === "operation").map((item) => item.id));
+        for (const id of this.operations.keys()) {
+            const hasTimelineItem = this.timeline.items.some((item) => item.type === "operation" && item.operationId === id);
+            if (!hasTimelineItem) {
+                this.operations.delete(id);
+            }
+        }
+        this.timeline.items = this.timeline.items.filter((item) => {
+            switch (item.type) {
+                case "message":
+                    return messageIds.has(item.messageId);
+                case "tool":
+                    return this.tools.has(item.toolId);
+                case "notice":
+                    return (item.notice.subject.type === "session" ||
+                        (item.notice.subject.type === "message" && messageIds.has(item.notice.subject.id)) ||
+                        (item.notice.subject.type === "tool" && this.tools.has(item.notice.subject.id)) ||
+                        (item.notice.subject.type === "agent" && this.agents.has(item.notice.subject.id)) ||
+                        (item.notice.subject.type === "operation" &&
+                            this.operations.has(item.notice.subject.id)));
+                case "operation":
+                    return this.operations.has(item.operationId);
+            }
+            return false;
+        });
         for (const [id, facet] of this.facets) {
             const subjectExists = facet.subject.type === "session" ||
                 (facet.subject.type === "message" && messageIds.has(facet.subject.id)) ||
                 (facet.subject.type === "tool" && this.tools.has(facet.subject.id)) ||
                 (facet.subject.type === "agent" && this.agents.has(facet.subject.id)) ||
-                (facet.subject.type === "operation" && operationIds.has(facet.subject.id));
+                (facet.subject.type === "operation" && this.operations.has(facet.subject.id));
             if (!subjectExists) {
                 this.facets.delete(id);
             }
@@ -1343,7 +1426,7 @@ class LocalHostedSessionHandle {
             createdAt: this.createdAt,
             agentState: {
                 revision: agentState.revision,
-                contextEpoch: agentState.contextEpoch,
+                modelContextKey: agentState.modelContextKey,
                 ...(agentState.usageCheckpoint
                     ? { usageCheckpoint: { ...agentState.usageCheckpoint } }
                     : {}),
@@ -1370,8 +1453,10 @@ class LocalHostedSessionHandle {
             catalog: structuredClone(this.catalog),
             executionEnvironment: this.executionEnvironment.snapshot(),
             messages,
-            timeline: this.buildTimeline(messages),
+            turns: Object.fromEntries(this.turns),
+            timeline: structuredClone(this.timeline),
             tools: Object.fromEntries(this.tools),
+            operations: Object.fromEntries(this.operations),
             agents: Object.fromEntries(this.agents),
             facets: Object.fromEntries(this.facets),
         };
@@ -1387,64 +1472,90 @@ class LocalHostedSessionHandle {
                 timestamp: 0,
             },
         };
-        const historyMessages = this.session.rawHistoryEntries.map((entry) => {
-            const turn = this.turnOutcomes.get(entry.id);
-            return {
-                id: entry.id,
-                state: this.messageStates.get(entry.id) ?? "committed",
-                modelVisible: true,
-                message: entry.message,
-                ...(turn ? { turn } : {}),
-            };
-        });
+        const historyMessages = this.session.rawHistoryEntries.map((entry) => ({
+            id: entry.id,
+            state: this.messageStates.get(entry.id) ?? "committed",
+            modelVisible: true,
+            message: entry.message,
+        }));
         return [
             systemMessage,
             ...historyMessages,
             ...(this.draftAssistantMessage ? [structuredClone(this.draftAssistantMessage)] : []),
         ];
     }
-    buildTimeline(messages) {
-        const messageItems = messages
-            .filter((message) => this.shouldIncludeMessageInTimeline(message))
-            .map((message) => ({
+    nextTimelineItemBase(id, createdAt) {
+        this.timeline.sequence += 1;
+        return { id, sequence: this.timeline.sequence, createdAt };
+    }
+    appendMessageTimelineItem(messageId, createdAt) {
+        const item = {
+            ...this.nextTimelineItemBase(`timeline-message-${messageId}`, createdAt),
             type: "message",
-            id: `timeline-${message.id}`,
-            messageId: message.id,
-        }));
-        return [...messageItems, ...structuredClone(this.timelineExtras)];
+            messageId,
+        };
+        this.timeline.items.push(item);
+        return item;
     }
-    shouldIncludeMessageInTimeline(message) {
-        if (message.id === "system") {
-            return false;
-        }
-        if (isCoreMessage(message.message) &&
-            (isTauUserMessageHidden(message.message) ||
-                hasAutoCompactionContinuationMetadata(message.message))) {
-            return false;
-        }
-        if (!this.restoredTimelineMessageIds || !this.restoredMessageIds) {
-            return true;
-        }
-        return (this.restoredTimelineMessageIds.has(message.id) || !this.restoredMessageIds.has(message.id));
+    appendToolTimelineItem(toolId, createdAt) {
+        const item = {
+            ...this.nextTimelineItemBase(`timeline-tool-${toolId}`, createdAt),
+            type: "tool",
+            toolId,
+        };
+        this.timeline.items.push(item);
+        return item;
+    }
+    appendNoticeTimelineItem(id, createdAt, notice) {
+        const item = {
+            ...this.nextTimelineItemBase(id, createdAt),
+            type: "notice",
+            notice,
+        };
+        this.timeline.items.push(item);
+        return item;
+    }
+    appendTurnFailureTimelineItem(historyEntryId, failure) {
+        const blocked = failure.reason === "auto-compaction-failed";
+        return this.appendNoticeTimelineItem(`turn-${blocked ? "blocked" : "failed"}-${randomUUID()}`, Date.now(), {
+            kind: blocked ? "tau.turn.blocked" : "tau.turn.failed",
+            version: 1,
+            severity: "error",
+            subject: { type: "message", id: historyEntryId },
+            presentation: projectSessionProtocolNoticePresentation(blocked ? "turn blocked" : "turn failed", [failure.message]),
+            data: { reason: failure.reason },
+        });
     }
-    clearRunningAutoCompactionOperations() {
-        this.timelineExtras.splice(0, this.timelineExtras.length, ...this.timelineExtras.filter((item) => item.type !== "operation" ||
-            item.operation.kind !== "auto-compaction" ||
-            item.operation.status !== "running"));
+    appendOperationTimelineItem(operation) {
+        const item = {
+            ...this.nextTimelineItemBase(`timeline-operation-${operation.id}`, operation.startedAt),
+            type: "operation",
+            operationId: operation.id,
+        };
+        this.operations.set(operation.id, operation);
+        this.timeline.items.push(item);
+        return item;
+    }
+    removeTimelineItem(id) {
+        this.timeline.items = this.timeline.items.filter((item) => item.id !== id);
     }
     restoreProtocolState(snapshot) {
         if (!snapshot) {
             return;
         }
-        this.restoredMessageIds = new Set(snapshot.messages.map((message) => message.id));
-        this.restoredTimelineMessageIds = new Set(snapshot.timeline.filter((item) => item.type === "message").map((item) => item.messageId));
-        this.timelineExtras.splice(0, this.timelineExtras.length, ...snapshot.timeline
-            .filter((item) => item.type !== "message")
-            .map((item) => structuredClone(item)));
+        this.timeline = structuredClone(snapshot.timeline);
+        this.turns.clear();
+        for (const [id, turn] of Object.entries(snapshot.turns)) {
+            this.turns.set(id, structuredClone(turn));
+        }
         this.tools.clear();
         for (const [id, tool] of Object.entries(snapshot.tools)) {
             this.tools.set(id, structuredClone(tool));
         }
+        this.operations.clear();
+        for (const [id, operation] of Object.entries(snapshot.operations)) {
+            this.operations.set(id, structuredClone(operation));
+        }
         this.agents.clear();
         this.agentCostTotals.clear();
         for (const [id, agent] of Object.entries(snapshot.agents)) {
@@ -1459,14 +1570,10 @@ class LocalHostedSessionHandle {
         const historyEntryIds = new Set(this.session.rawHistoryEntries.map((entry) => entry.id));
         this.draftAssistantMessage = snapshot.messages.find((message) => message.state === "draft" && !historyEntryIds.has(message.id));
         this.messageStates.clear();
-        this.turnOutcomes.clear();
         for (const message of snapshot.messages) {
             if (message.state !== "committed" && message.state !== "draft") {
                 this.messageStates.set(message.id, message.state);
             }
-            if (message.turn) {
-                this.turnOutcomes.set(message.id, message.turn);
-            }
         }
     }
     enqueueMutation(mutation) {
@@ -1514,47 +1621,34 @@ class LocalHostedSessionHandle {
     async enqueueRuntimeEvent(event) {
         await this.enqueueMutation(() => this.recordRuntimeEvent(event));
     }
-    async commitSteeringTurnOutcome(historyEntryId, turn) {
-        await this.enqueueMutation(async () => {
-            this.turnOutcomes.set(historyEntryId, turn);
-            const message = this.committedSnapshot?.messages.find((candidate) => candidate.id === historyEntryId);
-            if (!message) {
-                throw new Error(`missing steering user message '${historyEntryId}'`);
-            }
-            if (isDeepStrictEqual(message.turn, turn)) {
-                return;
-            }
-            await this.emitPatch("assistant-message", [
-                {
-                    type: "message.replace",
-                    message: { ...structuredClone(message), turn },
-                },
-            ]);
-        });
-    }
     removeToolRun(tool, changes) {
         this.tools.delete(tool.id);
+        const timelineItemId = `timeline-tool-${tool.id}`;
+        this.removeTimelineItem(timelineItemId);
         for (const facetId of tool.facetIds) {
             this.facets.delete(facetId);
             changes.push({ type: "facet.remove", id: facetId });
         }
-        changes.push({ type: "tool.remove", id: tool.id });
+        changes.push({ type: "tool.remove", id: tool.id }, { type: "timeline.remove", id: timelineItemId });
     }
     async recordHistoryFailure(reason) {
-        if (!reason || this.timelineExtras.some((item) => item.id === HISTORY_UNAVAILABLE_NOTICE_ID)) {
+        if (!reason || this.timeline.items.some((item) => item.id === HISTORY_UNAVAILABLE_NOTICE_ID)) {
             return;
         }
-        const item = {
-            type: "notice",
-            id: HISTORY_UNAVAILABLE_NOTICE_ID,
-            notice: {
-                severity: "warn",
-                text: `Session history is unavailable: ${reason}. This session will continue without durable history recording or recall.`,
-                timestamp: Date.now(),
-            },
-        };
-        this.timelineExtras.push(item);
-        await this.emitPatch("notice", [{ type: "timeline.append", item: structuredClone(item) }]);
+        const item = this.appendNoticeTimelineItem(HISTORY_UNAVAILABLE_NOTICE_ID, Date.now(), {
+            kind: "tau.history.unavailable",
+            version: 1,
+            severity: "warn",
+            subject: { type: "session" },
+            presentation: projectSessionProtocolNoticePresentation("session history is unavailable", [
+                reason,
+                "this session will continue without durable history recording or recall",
+            ]),
+            data: {},
+        });
+        await this.emitPatch({ type: "notice" }, [
+            { type: "timeline.append", item: structuredClone(item) },
+        ]);
     }
     async appendToolHistory(tool, resultHistoryEntryId, result) {
         const callMessage = this.committedSnapshot?.messages.find((message) => message.id === tool.call.messageId);
@@ -1583,7 +1677,7 @@ class LocalHostedSessionHandle {
             type: "agent-state.set",
             agentState: {
                 revision: state.revision,
-                contextEpoch: state.contextEpoch,
+                modelContextKey: state.modelContextKey,
                 ...(state.usageCheckpoint ? { usageCheckpoint: { ...state.usageCheckpoint } } : {}),
             },
         };
@@ -1597,13 +1691,13 @@ class LocalHostedSessionHandle {
                     modelVisible: false,
                     message: { role: "assistant", content: [], timestamp: Date.now() },
                 };
-                const timelineItem = timelineItemForMessage(this.draftAssistantMessage.id);
+                const timelineItem = this.appendMessageTimelineItem(this.draftAssistantMessage.id, this.draftAssistantMessage.message.timestamp);
                 await this.emitPatch("assistant-stream", [
                     {
                         type: "message.append",
                         message: structuredClone(this.draftAssistantMessage),
-                        timelineItem,
                     },
+                    { type: "timeline.append", item: structuredClone(timelineItem) },
                     { type: "lifecycle.set", lifecycle: "running" },
                 ], { persist: false });
                 return;
@@ -1651,7 +1745,8 @@ class LocalHostedSessionHandle {
                 };
                 this.tools.set(tool.id, tool);
                 this.facets.set(facet.id, facet);
-                changes.push({ type: "tool.set", tool: structuredClone(tool) }, { type: "facet.set", facet: structuredClone(facet) });
+                const timelineItem = this.appendToolTimelineItem(tool.id, Date.now());
+                changes.push({ type: "tool.set", tool: structuredClone(tool) }, { type: "facet.set", facet: structuredClone(facet) }, { type: "timeline.append", item: structuredClone(timelineItem) });
                 await this.emitPatch("tool-run", changes, { persist: false });
                 return;
             }
@@ -1706,11 +1801,24 @@ class LocalHostedSessionHandle {
             }
             case "user_message": {
                 const pendingGoal = this.pendingGoalCommit;
+                const acceptsTurn = this.pendingAcceptedTurnHistoryEntryIds.has(event.historyEntryId) ||
+                    event.origin === "steering";
+                const turn = acceptsTurn
+                    ? { userHistoryEntryId: event.historyEntryId, state: "running" }
+                    : undefined;
+                if (turn) {
+                    if (this.turns.has(event.historyEntryId)) {
+                        throw new Error(`turn '${event.historyEntryId}' was already accepted`);
+                    }
+                    this.turns.set(event.historyEntryId, turn);
+                }
+                const timelineItem = this.appendMessageTimelineItem(event.historyEntryId, event.message.timestamp);
                 await this.emitPatch("user-message", [
                     this.agentStateChange(),
                     ...(pendingGoal
                         ? [{ type: "goal.set", goal: structuredClone(pendingGoal) }]
                         : []),
+                    ...(turn ? [{ type: "turn.set", turn }] : []),
                     {
                         type: "message.append",
                         message: {
@@ -1719,20 +1827,31 @@ class LocalHostedSessionHandle {
                             modelVisible: true,
                             message: event.message,
                         },
-                        timelineItem: timelineItemForMessage(event.historyEntryId),
                     },
+                    { type: "timeline.append", item: structuredClone(timelineItem) },
                 ], { persist: true });
+                if (turn) {
+                    this.pendingAcceptedTurnHistoryEntryIds.delete(event.historyEntryId);
+                }
                 await this.recordHistoryFailure(this.history.append(this.sessionId, [userHistoryEntry(event.historyEntryId, event.message)], this.historyRemote));
                 if (pendingGoal && this.pendingGoalCommit === pendingGoal) {
                     this.pendingGoalCommit = undefined;
                 }
                 return;
             }
-            case "history_rewound":
+            case "history_rewound": {
+                const rewindItem = this.timeline.items.find((item) => item.type === "message" && item.messageId === event.historyEntryId);
+                if (!rewindItem) {
+                    throw new Error(`missing timeline item for rewind message '${event.historyEntryId}'`);
+                }
+                const cutoffSequence = rewindItem.sequence - 1;
+                this.timeline.items = this.timeline.items.filter((item) => item.sequence <= cutoffSequence);
                 this.reconcileProjections({ removeMissingAgents: true });
-                await this.emitSnapshotResetIfChanged("maintenance");
+                const snapshot = await this.commitSnapshot();
+                this.emitSnapshotReset({ type: "rewind", epoch: this.timeline.epoch, cutoffSequence }, snapshot);
                 await this.recordHistoryFailure(this.history.truncateFromSources(this.sessionId, event.removedEntryIds, this.historyRemote));
                 return;
+            }
             case "assistant_final": {
                 this.draftAssistantMessage = undefined;
                 const messageState = event.message.stopReason === "aborted" ? "interrupted" : "committed";
@@ -1833,7 +1952,6 @@ class LocalHostedSessionHandle {
                                 modelVisible: true,
                                 message: event.message,
                             },
-                            timelineItem: timelineItemForMessage(event.historyEntryId),
                         },
                         { type: "tool.set", tool: structuredClone(nextTool) },
                     ]);
@@ -1850,7 +1968,6 @@ class LocalHostedSessionHandle {
                             modelVisible: true,
                             message: event.message,
                         },
-                        timelineItem: timelineItemForMessage(event.historyEntryId),
                     },
                 ]);
                 return;
@@ -1884,52 +2001,137 @@ class LocalHostedSessionHandle {
                     changes.push({ type: "tool.set", tool: structuredClone(nextTool) });
                     historyTools.push({ tool: existing, result: toolResult });
                 }
-                await this.emitPatch("recovery", changes);
+                await this.emitPatch({ type: "resync" }, changes);
                 for (const { tool, result } of historyTools) {
                     await this.appendToolHistory(tool, event.historyEntryId, result);
                 }
                 return;
             }
-            case "notice": {
+            case "feedback": {
+                if (event.presentation === "footer") {
+                    this.emitEphemeral(createSessionProtocolEphemeralMessage({
+                        sessionId: this.sessionId,
+                        event: {
+                            type: "feedback.notice",
+                            title: projectSessionProtocolNoticePresentation(event.title).title,
+                            tone: event.tone,
+                            presentation: "footer",
+                            durationMs: event.durationMs,
+                        },
+                    }));
+                    return;
+                }
+                const createdAt = Date.now();
                 const item = {
+                    ...this.nextTimelineItemBase(`ephemeral-notice-${randomUUID()}`, createdAt),
                     type: "notice",
-                    id: `notice-${Date.now()}-${this.timelineExtras.length}`,
                     notice: {
-                        severity: event.severity,
-                        text: event.text,
-                        timestamp: Date.now(),
+                        kind: "tau.runtime.feedback",
+                        version: 1,
+                        severity: event.tone === "error" ? "error" : "info",
+                        subject: { type: "session" },
+                        presentation: projectSessionProtocolNoticePresentation(event.title, event.content),
+                        data: {},
                     },
                 };
-                this.timelineExtras.push(item);
-                await this.emitPatch("notice", [{ type: "timeline.append", item: structuredClone(item) }]);
+                await this.emitPatch("notice", [
+                    {
+                        type: "timeline.advance",
+                        epoch: this.timeline.epoch,
+                        sequence: item.sequence,
+                    },
+                ]);
+                this.emitEphemeral(createSessionProtocolEphemeralMessage({
+                    sessionId: this.sessionId,
+                    event: { type: "timeline.item", epoch: this.timeline.epoch, item },
+                }));
                 return;
             }
             case "compaction_start": {
-                const item = {
-                    type: "operation",
-                    id: `operation-auto-compaction-${Date.now()}`,
-                    operation: {
-                        kind: "auto-compaction",
-                        status: "running",
-                        startedAt: Date.now(),
-                    },
+                const kind = event.reason === "manual" ? "manual-compaction" : "auto-compaction";
+                const operation = {
+                    id: `${kind}-${randomUUID()}`,
+                    kind,
+                    status: "running",
+                    startedAt: Date.now(),
                 };
-                this.timelineExtras.push(item);
+                const item = this.appendOperationTimelineItem(operation);
                 await this.emitPatch("maintenance", [
+                    { type: "operation.set", operation: structuredClone(operation) },
                     { type: "timeline.append", item: structuredClone(item) },
                 ]);
                 return;
             }
-            case "compaction_end":
-                this.clearRunningAutoCompactionOperations();
-                this.reconcileProjections();
-                await this.emitSnapshotReset("maintenance", await this.commitSnapshot());
+            case "compaction_end": {
+                const operation = [...this.operations.values()].findLast((candidate) => (candidate.kind === "auto-compaction" || candidate.kind === "manual-compaction") &&
+                    candidate.status === "running");
+                if (operation) {
+                    const finishedAt = Date.now();
+                    const finishedOperation = event.outcome === "compacted"
+                        ? { ...operation, status: "succeeded", finishedAt }
+                        : event.outcome === "failed"
+                            ? {
+                                ...operation,
+                                status: "failed",
+                                finishedAt,
+                                error: event.errorMessage,
+                            }
+                            : event.outcome === "skipped"
+                                ? {
+                                    ...operation,
+                                    status: "skipped",
+                                    finishedAt,
+                                    reason: "no-eligible-history",
+                                }
+                                : {
+                                    ...operation,
+                                    status: "cancelled",
+                                    finishedAt,
+                                    reason: "interrupted",
+                                };
+                    this.operations.set(operation.id, finishedOperation);
+                    await this.emitPatch("maintenance", [
+                        { type: "operation.set", operation: structuredClone(finishedOperation) },
+                    ]);
+                }
+                if (event.outcome !== "compacted") {
+                    return;
+                }
+                const previousEpoch = this.timeline.epoch;
+                this.timeline = { epoch: previousEpoch + 1, sequence: 0, items: [] };
+                this.tools.clear();
+                this.operations.clear();
+                this.facets.clear();
+                this.draftAssistantMessage = undefined;
+                this.reconcileProjections({ removeMissingAgents: true });
+                const summary = this.session.rawHistoryEntries.find((entry) => entry.id === event.result.summaryHistoryEntryId);
+                if (!summary) {
+                    throw new Error(`missing compaction summary '${event.result.summaryHistoryEntryId}' in runtime history`);
+                }
+                this.appendMessageTimelineItem(summary.id, summary.message.timestamp);
+                const snapshot = await this.commitSnapshot();
+                this.emitSnapshotReset({
+                    type: "compaction",
+                    previousEpoch,
+                    epoch: this.timeline.epoch,
+                    kind: event.reason === "manual" ? "manual" : "auto",
+                    cutType: event.result.cutType,
+                    retainedMessageCount: event.result.retainedMessageCount,
+                }, snapshot);
                 return;
+            }
             case "tool_activity":
                 await this.recordToolUiEvent(event.activity);
                 return;
+            case "turn_finished": {
+                if (!event.failure) {
+                    return;
+                }
+                const item = this.appendTurnFailureTimelineItem(event.historyEntryId, event.failure);
+                await this.emitPatch("notice", [{ type: "timeline.append", item: structuredClone(item) }]);
+                return;
+            }
             case "turn_started":
-            case "turn_finished":
             case "tool_call_admitted":
             case "model_retry_scheduled":
             case "model_retry_started":
@@ -2001,12 +2203,13 @@ class LocalHostedSessionHandle {
     }
     buildAssistantPartialChanges(previousDraft, nextDraft) {
         if (!previousDraft) {
+            const timelineItem = this.appendMessageTimelineItem(nextDraft.id, nextDraft.message.timestamp);
             return [
                 {
                     type: "message.append",
                     message: structuredClone(nextDraft),
-                    timelineItem: timelineItemForMessage(nextDraft.id),
                 },
+                { type: "timeline.append", item: structuredClone(timelineItem) },
             ];
         }
         const appendChange = buildAssistantContentAppendChange(previousDraft, nextDraft);
@@ -2018,7 +2221,7 @@ class LocalHostedSessionHandle {
         }
         return [{ type: "message.replace", message: structuredClone(nextDraft) }];
     }
-    async emitPatch(reason, changes, options = {}) {
+    async emitPatch(cause, changes, options = {}) {
         if (changes.length === 0) {
             return;
         }
@@ -2026,44 +2229,44 @@ class LocalHostedSessionHandle {
             if (options.persist === false) {
                 const snapshot = { ...this.buildSnapshotDraft(), revision: 1 };
                 this.committedSnapshot = snapshot;
-                this.emitSnapshotReset(reason, snapshot);
+                this.emitSnapshotReset(cause, snapshot);
                 return;
             }
             const snapshot = await this.commitSnapshot();
-            this.emitSnapshotReset(reason, snapshot);
+            this.emitSnapshotReset(cause, snapshot);
             return;
         }
         if (options.persist !== false) {
-            this.emitDelta(await this.commitSnapshotPatch(reason, changes));
+            this.emitDelta(await this.commitSnapshotPatch(cause, changes));
             return;
         }
         const delta = createSessionProtocolDeltaMessage({
             sessionId: this.committedSnapshot.sessionId,
             fromRevision: this.committedSnapshot.revision,
             toRevision: this.committedSnapshot.revision + 1,
-            reason,
+            cause: normalizeDeltaCause(cause),
             delta: { type: "snapshot.patch", changes },
         });
         this.committedSnapshot = applySessionProtocolDelta(this.committedSnapshot, delta);
         this.emitDelta(delta);
     }
-    emitSnapshotReset(reason, snapshot) {
+    emitSnapshotReset(cause, snapshot) {
         this.emitDelta(createSessionProtocolDeltaMessage({
             sessionId: snapshot.sessionId,
             fromRevision: null,
             toRevision: snapshot.revision,
-            reason,
+            cause: normalizeDeltaCause(cause),
             delta: { type: "snapshot.reset", snapshot },
         }));
     }
-    async enqueueSnapshotResetIfChanged(reason) {
-        await this.enqueueMutation(() => this.emitSnapshotResetIfChanged(reason));
+    async enqueueSnapshotResetIfChanged(cause) {
+        await this.enqueueMutation(() => this.emitSnapshotResetIfChanged(cause));
     }
-    async emitSnapshotResetIfChanged(reason) {
+    async emitSnapshotResetIfChanged(cause) {
         const previousRevision = this.committedSnapshot?.revision;
         const snapshot = await this.commitSnapshot();
         if (snapshot.revision !== previousRevision) {
-            this.emitSnapshotReset(reason, snapshot);
+            this.emitSnapshotReset(cause, snapshot);
         }
     }
     emitDelta(delta) {
@@ -2113,6 +2316,10 @@ class LocalHostedSessionHandle {
                 };
             this.tools.set(content.id, nextTool);
             changes.push({ type: "tool.set", tool: structuredClone(nextTool) });
+            if (!existing) {
+                const timelineItem = this.appendToolTimelineItem(content.id, Date.now());
+                changes.push({ type: "timeline.append", item: structuredClone(timelineItem) });
+            }
         }
         return changes;
     }
@@ -2124,21 +2331,16 @@ class LocalHostedSessionHandle {
         const interruptedMessage = createInterruptedAssistantMessage(draft, this.runtime.persona.model);
         await this.session.commitInterruptedAssistant(interruptedMessage, draft.id);
     }
-    async cleanupFailedTurn(rootHistoryEntryId, committedSteering, error) {
+    async cleanupFailedTurn(rootHistoryEntryId, error) {
         if (this.draftAssistantMessage) {
             await this.interruptDraftAssistantMessage().catch(() => undefined);
         }
         const diagnostic = formatErrorDiagnostic(error);
         await this.enqueueMutation(async () => {
-            const outcome = {
-                status: "failed",
-                stopReason: "error",
-                errorMessage: diagnostic,
-            };
-            this.turnOutcomes.set(rootHistoryEntryId, outcome);
-            for (const steering of committedSteering) {
-                this.turnOutcomes.set(steering.historyEntryId, outcome);
-            }
+            this.appendTurnFailureTimelineItem(rootHistoryEntryId, {
+                reason: "runtime-error",
+                message: diagnostic,
+            });
             if (this.goal?.status === "active") {
                 this.goal = { ...this.goal, status: "blocked" };
             }
@@ -2156,8 +2358,16 @@ class LocalHostedSessionHandle {
             }
             await this.emitSnapshotResetIfChanged("assistant-message");
         });
+        return { status: "failed", stopReason: "error", errorMessage: diagnostic };
     }
 }
+function normalizeExplicitHistoryEntryId(historyEntryId) {
+    const normalizedId = historyEntryId.trim();
+    if (!normalizedId) {
+        throw new Error("history entry id must not be empty");
+    }
+    return normalizedId;
+}
 function formatErrorDiagnostic(error) {
     const messages = [];
     const seen = new Set();
@@ -2260,9 +2470,19 @@ function getAssistantDraftBlockText(message, type) {
 }
 function normalizeRecoveredSnapshot(snapshot) {
     const recovered = cloneSessionProtocolSnapshot(snapshot);
-    const legacyAgentState = recovered.agentState.contextEpoch === LEGACY_SESSION_CONTEXT_EPOCH;
+    const legacyAgentState = recovered.agentState.modelContextKey === LEGACY_SESSION_MODEL_CONTEXT_KEY;
     let changed = recovered.lifecycle !== "idle" || legacyAgentState;
     recovered.lifecycle = "idle";
+    for (const [id, turn] of Object.entries(recovered.turns)) {
+        if (turn.state === "running") {
+            changed = true;
+            recovered.turns[id] = {
+                userHistoryEntryId: id,
+                state: "settled",
+                outcome: abortedTurnOutcome(),
+            };
+        }
+    }
     if (recovered.goal?.status === "active") {
         changed = true;
         recovered.goal.status = "blocked";
@@ -2272,6 +2492,19 @@ function normalizeRecoveredSnapshot(snapshot) {
         recovered.agents = {};
         recovered.facets = Object.fromEntries(Object.entries(recovered.facets).filter(([, facet]) => facet.subject.type !== "agent"));
     }
+    const recoveredAt = Date.now();
+    for (const [id, operation] of Object.entries(recovered.operations)) {
+        if (operation.status !== "running") {
+            continue;
+        }
+        changed = true;
+        recovered.operations[id] = {
+            ...operation,
+            status: "cancelled",
+            finishedAt: recoveredAt,
+            reason: "session-recovered",
+        };
+    }
     const streamingToolIds = new Set(Object.values(recovered.tools)
         .filter((tool) => tool.status === "streaming")
         .map((tool) => tool.id));
@@ -2279,6 +2512,10 @@ function normalizeRecoveredSnapshot(snapshot) {
         changed = true;
         recovered.tools = Object.fromEntries(Object.entries(recovered.tools).filter(([id]) => !streamingToolIds.has(id)));
         recovered.facets = Object.fromEntries(Object.entries(recovered.facets).filter(([, facet]) => facet.subject.type !== "tool" || !streamingToolIds.has(facet.subject.id)));
+        recovered.timeline.items = recovered.timeline.items.filter((item) => !(item.type === "tool" && streamingToolIds.has(item.toolId)) &&
+            !(item.type === "notice" &&
+                item.notice.subject.type === "tool" &&
+                streamingToolIds.has(item.notice.subject.id)));
     }
     let recoveredAgentHistory = false;
     recovered.messages = recovered.messages.map((message) => {
@@ -2297,7 +2534,7 @@ function normalizeRecoveredSnapshot(snapshot) {
     if (recoveredAgentHistory) {
         recovered.agentState = {
             revision: recovered.agentState.revision + 1,
-            contextEpoch: recovered.agentState.contextEpoch,
+            modelContextKey: recovered.agentState.modelContextKey,
             ...(recovered.agentState.usageCheckpoint
                 ? { usageCheckpoint: { ...recovered.agentState.usageCheckpoint } }
                 : {}),
@@ -2319,13 +2556,6 @@ function promptCompositionFromSnapshot(snapshot) {
 function cloneSubagentPrompts(subagentPrompts) {
     return { ...subagentPrompts };
 }
-function timelineItemForMessage(messageId) {
-    return {
-        type: "message",
-        id: `timeline-${messageId}`,
-        messageId,
-    };
-}
 function isCoreMessage(message) {
     switch (message.role) {
         case "user":