@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/web-ui/app/controllers/conversation-navigation-intent.js

@@ -0,0 +1,15 @@
+/** Session opens and New conversation share the latest navigation intent. */
+export function beginConversationNavigation(state) {
+  const revision = (state.conversationNavigationRevision ?? 0) + 1;
+  state.conversationNavigationRevision = revision;
+  return () => state.conversationNavigationRevision === revision;
+}
+
+/** The selector may name a target whose recovered drafts are not saved yet. */
+export function canNavigateConversation(state) {
+  return hasCommittedConversationEnvironment(state);
+}
+
+export function hasCommittedConversationEnvironment(state) {
+  return state.environmentChangePending !== true;
+}

package/dist/src/web-ui/app/controllers/conversation-read-state-controller.d.ts

@@ -20,4 +20,5 @@ export declare function createConversationReadStateController(
   options: ConversationReadStateControllerOptions,
 ): {
   markCurrentSessionReadSoon(): void;
+  markDisplayedMessagesReadSoon(messages: ConversationSessionState["messages"]): void;
 };

package/dist/src/web-ui/app/controllers/conversation-read-state-controller.js

@@ -66,14 +66,14 @@ export function createConversationReadStateController({
     }
   }
 
-  function markCurrentSessionReadSoon() {
+  function markDisplayedMessagesReadSoon(messages) {
     const scope = {
       environmentId: selectedEnvironmentId(),
       sessionId: state.currentSessionId,
       viewVersion: state.sessionViewVersion,
     };
     if (!canMarkConversationRead(scope)) return;
-    const boundary = displayedAssistantReadBoundary(state.messages);
+    const boundary = displayedAssistantReadBoundary(messages);
     if (!boundary) return;
     scheduleTask(() => {
       if (!canMarkConversationRead(scope)) return;
@@ -81,5 +81,9 @@ export function createConversationReadStateController({
     });
   }
 
-  return { markCurrentSessionReadSoon };
+  function markCurrentSessionReadSoon() {
+    markDisplayedMessagesReadSoon(state.messages);
+  }
+
+  return { markCurrentSessionReadSoon, markDisplayedMessagesReadSoon };
 }

package/dist/src/web-ui/app/controllers/conversation-request-hydration.js

@@ -0,0 +1,91 @@
+import { isStoppedRequest, restoreStoppedResponses } from "../lib/request-stop-state.js";
+import { isApprovalPresentation, rememberRequestLifecycle } from "../lib/request-lifecycle-view.js";
+import { textOf } from "../lib/text-format.js";
+import { canRestoreSnapshotQueue } from "./history-pagination.js";
+
+function isBindableResponse(message) {
+  if (message.role !== "assistant" || !message.requestId) return false;
+  return !isApprovalPresentation(message);
+}
+function isStreamingRequest(request) {
+  if (!request.requestId) return false;
+  return request.status === "streaming";
+}
+function isQueuedTerminalRequest(request, queued) {
+  if (textOf(request.requestId) !== queued?.waitForRequestId) return false;
+  return request.status === "completed" || request.status === "failed";
+}
+function mergeRefreshedRequests(previous, fresh) {
+  // A latest-page fetch includes every active request. Keep metadata for the
+  // displayed historical page, but never revive an older active projection.
+  const requests = new Map(previous
+    .filter((request) => !isStreamingRequest(request) && request.status !== "awaiting_approval")
+    .map((request) => [request.requestId, request]));
+  for (const request of fresh) requests.set(request.requestId, request);
+  return [...requests.values()];
+}
+function requestsForEventRestoration(requests, streamingRequestIds, appendEvents) {
+  if (!appendEvents) return requests;
+  // Existing live rows already contain received tokens. Resume their events only after lastSeq.
+  return requests.map((request) => streamingRequestIds.has(request.requestId) ? { ...request, events: [] } : request);
+}
+
+/** Shared snapshot lifecycle restoration; the caller owns the visible history window. */
+export function createConversationRequestHydration({
+  state, client, selectedEnvironmentId, sessionQueue, applyConversationChrome, renderSessions,
+  updateComposerSendState, reportQueueFailure, activeAssistantForRequest, restoreSessionEventState,
+  subscribeSession, subscribeRequest, replayRequestEvents, resumeRequest, recoverBlockedQueue, drainQueuedMessage, renderMessages,
+}) {
+  function isCurrentHydration(scope, viewVersion) {
+    if (scope.environmentId !== selectedEnvironmentId()) return false;
+    if (scope.sessionId !== state.currentSessionId) return false;
+    return viewVersion === state.sessionViewVersion;
+  }
+  async function restore(requests, { appendEvents = false } = {}) {
+    const scope = { environmentId: selectedEnvironmentId(), sessionId: state.currentSessionId };
+    const viewVersion = state.sessionViewVersion;
+    await sessionQueue.refresh?.();
+    if (!isCurrentHydration(scope, viewVersion)) return false;
+    const waitingRequestId = sessionQueue.peek(scope)?.waitForRequestId;
+    if (!canRestoreSnapshotQueue({ requests }, waitingRequestId)) {
+      const snapshot = await client.loadSession(scope.sessionId, scope.environmentId, { waitingRequestId });
+      if (!isCurrentHydration(scope, viewVersion)) return false;
+      requests = mergeRefreshedRequests(requests, snapshot.requests || []);
+    }
+    for (const message of state.messages) {
+      if (!isBindableResponse(message)) continue;
+      state.requestMessages.set(message.requestId, message.id);
+    }
+    for (const request of requests) rememberRequestLifecycle(state, request.lifecycle);
+    applyConversationChrome();
+    renderSessions();
+    const streamingRequestIds = new Set(requests
+      .filter(isStreamingRequest)
+      .map((request) => textOf(request.requestId)));
+    state.activeRequestId = [...streamingRequestIds][0] || "";
+    updateComposerSendState();
+    for (const requestId of streamingRequestIds) activeAssistantForRequest(requestId);
+    restoreStoppedResponses(state.messages, requests);
+    restoreSessionEventState(requestsForEventRestoration(requests, streamingRequestIds, appendEvents), streamingRequestIds, appendEvents);
+    for (const requestId of streamingRequestIds) {
+      subscribeRequest(requestId);
+      await replayRequestEvents(requestId, viewVersion);
+      if (!isCurrentHydration(scope, viewVersion)) return false;
+      resumeRequest(requestId);
+    }
+    if (state.activeRequestId) { renderMessages(); return true; }
+    await recoverBlockedQueue(scope);
+    if (!isCurrentHydration(scope, viewVersion)) return false;
+    const queued = sessionQueue.peek(scope);
+    const terminal = requests.find((request) => isQueuedTerminalRequest(request, queued));
+    if (terminal) await drainQueuedMessage({ ...scope, terminalRequestId: terminal.requestId, cancelled: isStoppedRequest(terminal) });
+    if (!isCurrentHydration(scope, viewVersion)) return false;
+    renderMessages();
+    return true;
+  }
+  async function rehydrate(requests) {
+    subscribeSession(state.currentSessionId);
+    return restore(requests, { appendEvents: true });
+  }
+  return { restore, rehydrate };
+}

package/dist/src/web-ui/app/controllers/conversation-session-controller.d.ts

@@ -47,10 +47,11 @@ export interface ConversationSessionClient {
     readThroughMessageId: number | string | null;
     readThroughRequestId?: string;
   }): Promise<Record<string, unknown>>;
-  listSessions(environmentId: string): Promise<Record<string, unknown>>;
+  listSessions(environmentId: string, page?: Record<string, unknown>): Promise<Record<string, unknown>>;
   loadSession(
     sessionId: string,
     environmentId: string,
+    page?: Record<string, unknown>,
   ): Promise<Record<string, unknown>>;
   fetchRequestEvents(options: {
     requestId: string;
@@ -85,7 +86,6 @@ export interface ConversationSessionControllerOptions {
   };
   conversationView: { reset(): void };
   selectedEnvironmentId(): string;
-  clearPendingAttachments(): void;
   applyConversationChrome(): void;
   applyModelSelection(): void;
   renderSessions(): void;
@@ -125,6 +125,7 @@ export declare function normalizeConversationMessage(
 export declare function createConversationSessionController(
   options: ConversationSessionControllerOptions,
 ): {
+  history: { load(direction?: "older" | "newer"): Promise<void>; latest(): Promise<void>; hasNewer(): boolean };
   activateRequestForScope(
     scope: { environmentId: string; sessionId: string },
     requestId: string,
@@ -135,7 +136,7 @@ export declare function createConversationSessionController(
     text: string;
     attachments: unknown[];
     requestId?: string;
-  }): void;
+  }): () => void;
   appendRequestError(error: unknown): void;
   applySessionReadState(sessionId: string, readState: unknown): void;
   applySessionTitleUpdate(sessionId: string, title: unknown): void;
@@ -150,12 +151,16 @@ export declare function createConversationSessionController(
   invalidateEnvironmentLoads(): void;
   loadSessions(): Promise<ConversationSession[]>;
   markCurrentSessionReadSoon(): void;
+  rehydrateRequests(requests: Record<string, unknown>[]): Promise<boolean>;
   normalizeMessage(raw: unknown): ConversationMessage;
   openSession(
     sessionId: string,
     options?: {
-      isRouteCurrent(): boolean;
-      commitRouteNavigation(): boolean;
+      isRouteCurrent?(): boolean;
+      commitRouteNavigation?(): boolean;
+      snapshot?: Record<string, unknown>;
+      page?: Record<string, unknown>;
+      preserveCurrentWindow?: boolean;
     },
   ): Promise<void>;
   requestBelongsToCurrentView(requestId: string): boolean;

package/dist/src/web-ui/app/controllers/conversation-session-controller.js

@@ -1,28 +1,28 @@
+import { beginConversationNavigation, canNavigateConversation } from "./conversation-navigation-intent.js";
 import {
   captureContextReplayScope,
   bindContextReplayEvents,
   isContextReplayCurrent,
 } from "../lib/context-window-replay.js";
 import { synchronizeContextRequestLifecycle } from "../lib/context-window-state.js";
-import { mergeSessionListReadState } from "../lib/session-read-state.js";
+import { createSessionListPagination } from "./session-list-pagination.js";
+import { createHistoryPagination, canRestoreSnapshotQueue } from "./history-pagination.js";
 import { createConversationReadStateController } from "./conversation-read-state-controller.js";
+import { createConversationRequestHydration } from "./conversation-request-hydration.js";
 import { normalizeScheduleReference } from "../lib/schedule-message.js";
-import { createWebSessionId, escapeHtml, textOf } from "../lib/text-format.js";
+import { createWebSessionId, textOf } from "../lib/text-format.js";
 import { insertRequestUserMessageBeforeAssistant } from "../ui-behavior.js";
 import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
 import {
   sparkProposalId,
   sparkHandoffAvailable,
 } from "../lib/spark-proposal-message.js";
-import {
-  isStoppedRequest,
-  restoreStoppedResponses,
-} from "../lib/request-stop-state.js";
 import {
   isApprovalPresentation,
   requestLifecycles,
   rememberRequestLifecycle,
   sameConversationMessage,
+  mergeConversationMessage,
 } from "../lib/request-lifecycle-view.js";
 
 export function normalizeConversationMessage(raw, fallbackIndex = 0) {
@@ -59,7 +59,6 @@ export function createConversationSessionController({
   sessionQueue,
   conversationView,
   selectedEnvironmentId,
-  clearPendingAttachments,
   applyConversationChrome,
   applyModelSelection,
   renderSessions,
@@ -82,13 +81,21 @@ export function createConversationSessionController({
   onSessionCreated = () => {},
 }) {
   let environmentLoadRevision = 0;
-  let sessionListRevision = 0;
+  const listPagination = createSessionListPagination({ state, dom, client, sessions, selectedEnvironmentId, renderSessions, onSessionListState });
+  const history = createHistoryPagination({ state, dom, client, selectedEnvironmentId,
+    normalizeMessage: normalizeConversationMessage, renderMessages, conversationView, applyReadState: sessions.applyReadState,
+    onRequests: (requests) => restoreSessionEventState(requests, new Set(), true),
+    loadLatest: () => openSession(state.currentSessionId, { preserveCurrentWindow: true }),
+    onNewerPage: (messages) => markDisplayedMessagesReadSoon(messages),
+  });
   let sessionRestoreRevision = 0;
 
   function invalidateEnvironmentLoads() {
     environmentLoadRevision += 1;
-    sessionListRevision += 1;
+    listPagination.invalidate();
+    history.reset();
     sessionRestoreRevision += 1;
+    beginConversationNavigation(state);
     state.sessions = [];
     onSessionListState({ status: "loading", sessions: [] });
     renderSessions();
@@ -98,7 +105,7 @@ export function createConversationSessionController({
     return normalizeConversationMessage(raw, state.messages.length);
   }
 
-  const { markCurrentSessionReadSoon } = createConversationReadStateController({
+  const { markCurrentSessionReadSoon, markDisplayedMessagesReadSoon } = createConversationReadStateController({
     state,
     client,
     selectedEnvironmentId,
@@ -107,6 +114,11 @@ export function createConversationSessionController({
     isConversationVisible,
     scheduleTask,
   });
+  const requestHydration = createConversationRequestHydration({
+    state, client, selectedEnvironmentId, sessionQueue, applyConversationChrome, renderSessions,
+    updateComposerSendState, reportQueueFailure, activeAssistantForRequest, restoreSessionEventState,
+    subscribeSession, subscribeRequest, replayRequestEvents, resumeRequest, recoverBlockedQueue, drainQueuedMessage, renderMessages,
+  });
 
   function addOrMergeMessage(message) {
     const id = textOf(message.id);
@@ -115,13 +127,7 @@ export function createConversationSessionController({
       sameConversationMessage(item, message),
     );
     if (existingIndex >= 0) {
-      state.messages[existingIndex] = {
-        ...state.messages[existingIndex],
-        ...message,
-        text: message.text || state.messages[existingIndex].text,
-        thinkingText:
-          message.thinkingText || state.messages[existingIndex].thinkingText,
-      };
+      state.messages[existingIndex] = mergeConversationMessage(state.messages[existingIndex], message);
     } else {
       state.messages.push(message);
     }
@@ -156,11 +162,11 @@ export function createConversationSessionController({
   }
 
   function resetLiveRequestView() {
+    history.reset();
     state.events = [];
     state.taskProgressByRequest.clear();
     state.contextWindowByRequest.clear();
     state.activeRequestId = "";
-    state.composerSending = false;
     conversationView.reset();
     state.submittedToolApprovalIds.clear();
     state.requestMessages.clear();
@@ -172,9 +178,10 @@ export function createConversationSessionController({
   }
 
   function clearCurrentSessionView() {
+    sessionRestoreRevision += 1;
+    beginConversationNavigation(state);
     state.currentSessionId = "";
     state.messages = [];
-    clearPendingAttachments();
     resetLiveRequestView();
     dom.sessionTitle.textContent = "New conversation";
     applyConversationChrome();
@@ -183,7 +190,6 @@ export function createConversationSessionController({
 
   function clearSessionMessagesView() {
     state.messages = [];
-    clearPendingAttachments();
     resetLiveRequestView();
     applyConversationChrome();
     renderMessages();
@@ -253,12 +259,16 @@ export function createConversationSessionController({
   function restoreSessionEventState(
     requests = [],
     hydrateRequestIds = new Set(),
+    append = false,
   ) {
-    state.events = [];
-    state.taskProgressByRequest.clear();
-    state.contextWindowByRequest.clear();
+    if (!append) {
+      state.events = [];
+      state.taskProgressByRequest.clear();
+      state.contextWindowByRequest.clear();
+    }
     const requestEvents = [];
     for (const request of requests) {
+      rememberRequestLifecycle(state, request.lifecycle);
       if (!Array.isArray(request.events)) continue;
       const replayScope = captureContextReplayScope(
         state,
@@ -372,46 +382,7 @@ export function createConversationSessionController({
       handleRealtimeMessage(event);
   }
 
-  async function loadSessions() {
-    const environmentRevision = environmentLoadRevision;
-    const requestRevision = ++sessionListRevision;
-    const environmentId = selectedEnvironmentId();
-    onSessionListState({ status: "loading", sessions: state.sessions });
-    try {
-      const payload = await client.listSessions(environmentId);
-      if (
-        environmentRevision !== environmentLoadRevision ||
-        requestRevision !== sessionListRevision ||
-        environmentId !== selectedEnvironmentId()
-      ) {
-        return [];
-      }
-      state.sessions = mergeSessionListReadState(
-        Array.isArray(payload.sessions) ? payload.sessions : [],
-        state.sessions,
-      );
-      onSessionListState({ status: "ready", sessions: state.sessions });
-      renderSessions();
-      return state.sessions;
-    } catch (error) {
-      if (
-        environmentRevision !== environmentLoadRevision ||
-        requestRevision !== sessionListRevision ||
-        environmentId !== selectedEnvironmentId()
-      ) {
-        return [];
-      }
-      onSessionListState({
-        status: "error",
-        sessions: state.sessions,
-        error: error instanceof Error ? error.message : String(error),
-      });
-      dom.sessionsList.innerHTML = `<div class="empty-state error-text">${escapeHtml(
-        error instanceof Error ? error.message : String(error),
-      )}</div>`;
-      return [];
-    }
-  }
+  const loadSessions = () => listPagination.load();
 
   async function restoreLastSession() {
     const environmentRevision = environmentLoadRevision;
@@ -422,47 +393,70 @@ export function createConversationSessionController({
       environmentRevision !== environmentLoadRevision ||
       restoreRevision !== sessionRestoreRevision ||
       environmentId !== selectedEnvironmentId() ||
-      availableSessions.length === 0 ||
       state.currentSessionId
     ) {
       return;
     }
     const savedSessionId = preferences.sessionIdForEnvironment(environmentId);
-    const targetSession =
-      availableSessions.find((session) => session.id === savedSessionId) ||
-      availableSessions[0];
-    if (targetSession?.id) await openSession(targetSession.id);
+    const targetId = savedSessionId || availableSessions[0]?.id;
+    if (!targetId) return;
+    try { await openSession(targetId); }
+    catch (error) {
+      if (error.code !== "session_not_found") throw error;
+      if (availableSessions[0]?.id && availableSessions[0].id !== targetId) await openSession(availableSessions[0].id);
+    }
   }
 
   async function openSession(
     sessionId,
-    { isRouteCurrent, commitRouteNavigation } = {},
+    { isRouteCurrent, commitRouteNavigation, snapshot, page, preserveCurrentWindow = false } = {},
   ) {
+    if (!canNavigateConversation(state)) {
+      setMessageStatus("Wait for the environment change to finish before opening a conversation.");
+      return false;
+    }
+    sessionRestoreRevision += 1;
+    const isCurrentOpen = beginConversationNavigation(state);
     const routeOwned = typeof commitRouteNavigation === "function";
+    const loadBeforeReset = routeOwned || preserveCurrentWindow;
     let payload;
-    if (routeOwned) {
+    const pageOptions = { ...page, waitingRequestId: sessionQueue.peek({ environmentId: selectedEnvironmentId(), sessionId })?.waitForRequestId };
+    let prefetched = canRestoreSnapshotQueue(snapshot, pageOptions.waitingRequestId) ? snapshot : undefined;
+    if (loadBeforeReset) {
       const environmentId = selectedEnvironmentId();
       const viewVersion = state.sessionViewVersion;
       const currentSessionId = state.currentSessionId;
-      payload = await client.loadSession(sessionId, environmentId);
-      if (environmentId !== selectedEnvironmentId()) return;
-      if (viewVersion !== state.sessionViewVersion) return;
-      if (currentSessionId !== state.currentSessionId) return;
-      if (isRouteCurrent?.() !== true) return;
+      payload = prefetched ?? await client.loadSession(sessionId, environmentId, pageOptions);
+      if (!isCurrentOpen()) return false;
+      if (environmentId !== selectedEnvironmentId()) return false;
+      if (viewVersion !== state.sessionViewVersion) return false;
+      if (currentSessionId !== state.currentSessionId) return false;
+      if (routeOwned && isRouteCurrent?.() !== true) return false;
     }
-    if (
-      state.currentSessionId &&
-      state.currentSessionId !== sessionId &&
-      !suspendQueueRecovery()
-    ) {
-      return;
+    if (state.currentSessionId) {
+      const previousSessionId = state.currentSessionId;
+      const environmentId = selectedEnvironmentId();
+      const canSuspendRecovery = () => {
+        if (!canNavigateConversation(state)) return false;
+        if (!isCurrentOpen()) return false;
+        if (selectedEnvironmentId() !== environmentId) return false;
+        if (state.currentSessionId !== previousSessionId) return false;
+        if (routeOwned && isRouteCurrent?.() !== true) return false;
+        return true;
+      };
+      let prepared = suspendQueueRecovery(canSuspendRecovery);
+      if (typeof prepared?.then === "function") {
+        prepared = await prepared;
+        payload = undefined;
+        prefetched = undefined;
+      }
+      if (!prepared || !canSuspendRecovery()) return false;
     }
-    if (routeOwned && commitRouteNavigation() !== true) return;
+    if (routeOwned && commitRouteNavigation() !== true) return false;
     const viewVersion = state.sessionViewVersion + 1;
     state.currentSessionId = sessionId;
     preferences.saveSessionIdForEnvironment(selectedEnvironmentId(), sessionId);
     state.messages = [];
-    clearPendingAttachments();
     resetLiveRequestView();
     state.sessionViewVersion = viewVersion;
     sessions.setCurrentTitle(
@@ -474,96 +468,28 @@ export function createConversationSessionController({
     renderMessages();
     subscribeSession(sessionId);
 
-    if (!routeOwned) {
-      payload = await client.loadSession(sessionId, selectedEnvironmentId());
+    if (!payload) {
+      payload = prefetched ?? await client.loadSession(sessionId, selectedEnvironmentId(), pageOptions);
     }
     if (
+      !isCurrentOpen() ||
       state.currentSessionId !== sessionId ||
       state.sessionViewVersion !== viewVersion
     ) {
-      return;
+      return false;
     }
+    history.adopt(payload);
     const rawMessages = Array.isArray(payload.messages) ? payload.messages : [];
-    const scope = { environmentId: selectedEnvironmentId(), sessionId };
     state.messages = rawMessages.map((message, index) =>
       normalizeConversationMessage(message, index),
     );
+    const displayedPage = [...state.messages];
     sessions.applyTitle(sessionId, payload.title);
     sessions.applyReadState(sessionId, payload.readState);
-    for (const message of state.messages) {
-      if (
-        message.role === "assistant" &&
-        message.requestId &&
-        !isApprovalPresentation(message)
-      ) {
-        state.requestMessages.set(message.requestId, message.id);
-      }
-    }
     const requests = Array.isArray(payload.requests) ? payload.requests : [];
-    for (const request of requests)
-      rememberRequestLifecycle(state, request.lifecycle);
-    applyConversationChrome();
-    renderSessions();
-    const streamingRequestIds = new Set(
-      requests
-        .filter(
-          (request) => request.status === "streaming" && request.requestId,
-        )
-        .map((request) => textOf(request.requestId)),
-    );
-    if (streamingRequestIds.size === 1) {
-      const [streamingRequestId] = streamingRequestIds;
-      try {
-        sessionQueue.rebindBlocked(scope, streamingRequestId);
-      } catch (error) {
-        reportQueueFailure(
-          scope,
-          `The active request was restored, but the remaining Send next queue is paused: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        );
-      }
-    }
-    state.activeRequestId = [...streamingRequestIds][0] || "";
-    updateComposerSendState();
-    for (const requestId of streamingRequestIds) {
-      activeAssistantForRequest(requestId);
-    }
-    restoreStoppedResponses(state.messages, requests);
-    restoreSessionEventState(requests, streamingRequestIds);
-    for (const request of requests) {
-      if (request.status === "streaming" && request.requestId) {
-        subscribeRequest(request.requestId);
-        await replayRequestEvents(request.requestId, viewVersion);
-        if (
-          state.currentSessionId !== sessionId ||
-          state.sessionViewVersion !== viewVersion
-        ) {
-          return;
-        }
-        resumeRequest(request.requestId);
-      }
-    }
-    if (!state.activeRequestId) {
-      recoverBlockedQueue(scope);
-      const queued = sessionQueue.peek(scope);
-      const terminal = queued
-        ? requests.find(
-            (request) =>
-              textOf(request.requestId) === queued.waitForRequestId &&
-              (request.status === "completed" || request.status === "failed"),
-          )
-        : null;
-      if (terminal) {
-        await drainQueuedMessage({
-          ...scope,
-          terminalRequestId: terminal.requestId,
-          cancelled: isStoppedRequest(terminal),
-        });
-      }
-    }
-    renderMessages();
-    markCurrentSessionReadSoon();
+    if (!await requestHydration.restore(requests)) return false;
+    markDisplayedMessagesReadSoon(displayedPage);
+    return true;
   }
 
   function ensureSession() {
@@ -580,7 +506,7 @@ export function createConversationSessionController({
   }
 
   function appendLocalUserMessage({ text, attachments, requestId = "" }) {
-    state.messages.push({
+    const message = {
       id: `user-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
       role: "user",
       text,
@@ -588,8 +514,15 @@ export function createConversationSessionController({
       requestId,
       streaming: false,
       attachments,
-    });
+    };
+    state.messages.push(message);
     renderMessages();
+    return () => {
+      const index = state.messages.indexOf(message);
+      if (index < 0) return;
+      state.messages.splice(index, 1);
+      renderMessages();
+    };
   }
 
   function insertSteerMessage({ steerId, requestId, text }) {
@@ -628,6 +561,7 @@ export function createConversationSessionController({
   }
 
   return {
+    history,
     activateRequestForScope,
     activeAssistantForRequest,
     addOrMergeMessage,
@@ -642,6 +576,7 @@ export function createConversationSessionController({
     invalidateEnvironmentLoads,
     loadSessions,
     markCurrentSessionReadSoon,
+    rehydrateRequests: requestHydration.rehydrate,
     normalizeMessage,
     openSession,
     requestBelongsToCurrentView,

package/dist/src/web-ui/app/controllers/conversation-workspace-activation.js

@@ -0,0 +1,27 @@
+import { canNavigateConversation } from "./conversation-navigation-intent.js";
+
+/** Navigation commits only after the recovered draft is saved for the same view. */
+export function createConversationWorkspaceActivation({ state, shell, composerQueue, selectedEnvironmentId }) {
+  return async () => {
+    if (!canNavigateConversation(state)) {
+      shell.showToast?.("Wait for the environment change to finish before opening a conversation.", "neutral");
+      return false;
+    }
+    const environment = selectedEnvironmentId();
+    const session = state.currentSessionId;
+    const version = state.sessionViewVersion;
+    const navigationRevision = shell.navigationRevision?.();
+    const recovery = await composerQueue.prepareRecoveryForNavigation();
+    if (!recovery || recovery.canCommit?.() === false) return false;
+    if (!canNavigateConversation(state)) return false;
+    const hasCurrentWorkspaceNavigation = navigationRevision === shell.navigationRevision?.();
+    if (!hasCurrentWorkspaceNavigation) return false;
+    if (environment !== selectedEnvironmentId()) return false;
+    if (session !== state.currentSessionId) return false;
+    if (version !== state.sessionViewVersion) return false;
+    const activate = shell.prepareWorkspaceActivation("chat", { focus: false });
+    if (!activate) return false;
+    recovery();
+    return activate() !== false;
+  };
+}