@abot-ai/runtime 1.8.1 → 2.0.0

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

@@ -1,3 +1,4 @@
+import { confirmDialog } from "../components/confirmation-dialog.js";
 import { createSessionPinUpdates } from "./session-pin-updates.js";
 import {
   isOlderSessionReadState,
@@ -8,12 +9,14 @@ import { matchesSessionQuery } from "../ui-behavior.js";
 import { escapeAttribute, escapeHtml, textOf } from "../lib/text-format.js";
 import { getNumber } from "../lib/event-presentation.js";
 import { createSessionSidebarController } from "./session-sidebar-controller.js";
+import { captureSessionListViewport, restoreSessionListViewport } from "../components/session-list-viewport.js";
 
 export function createSessionController({
   state,
   dom,
   sessionActionsMenu,
   renderGroups = () => false,
+  getDeletedProjectIds = () => [],
   shell,
   preferences,
   client,
@@ -26,7 +29,7 @@ export function createSessionController({
   onReload,
   onControlEvent,
   onSidebarChange,
-  confirmAction = window.confirm.bind(window),
+  confirmAction = confirmDialog,
   copyText = (value) => navigator.clipboard.writeText(value),
 }) {
   let pagination;
@@ -39,7 +42,7 @@ export function createSessionController({
   const sidebar = createSessionSidebarController({
     state, preferences, updatePinnedSessions, selectedEnvironmentId, showToast: shell?.showToast,
     render: () => { (onSidebarChange ?? render)(); void pagination?.load(); }, getFilteredSessions: filtered,
-    getPageInfo: () => pagination?.info(),
+    getPageInfo: () => pagination?.info(), getDeletedProjectIds,
   });
 
   function filtered() {
@@ -56,14 +59,14 @@ export function createSessionController({
   }
 
   function render() {
-    const scrollTop = dom.sessionsList.scrollTop;
+    const viewportScope = JSON.stringify([selectedEnvironmentId(), state.sessionQuery, sidebar.isArchiveView()]);
+    captureSessionListViewport(dom.sessionsList, viewportScope);
     sessionActionsMenu.reset();
     dom.sessionsList.innerHTML = "";
     const sessions = filtered();
-    dom.sessionsCount.textContent = String(pagination?.info().total ?? sessions.length);
     sidebar.renderSections({ root: dom.sessionsList, sessions, createSessionItem, renderGroups });
     pagination?.renderFooter();
-    dom.sessionsList.scrollTop = scrollTop;
+    restoreSessionListViewport(dom.sessionsList);
   }
 
   function createSessionItem(session, sessionIndex) {
@@ -251,15 +254,34 @@ export function createSessionController({
     }
   }
 
+  function captureSessionMutationTarget(sessionId) {
+    const session = byId(sessionId);
+    return { environmentId: selectedEnvironmentId(), sessionId,
+      currentSessionId: state.currentSessionId, viewVersion: state.sessionViewVersion,
+      recordRevision: JSON.stringify([Boolean(session), session?.title, session?.updatedAt, session?.latestMessageId]) };
+  }
+
+  function isCurrentSessionMutationTarget(target) {
+    if (selectedEnvironmentId() !== target.environmentId) return false;
+    if (state.currentSessionId !== target.currentSessionId) return false;
+    if (state.sessionViewVersion !== target.viewVersion) return false;
+    if (state.busySessionIds.has(target.sessionId)) return false;
+    const session = byId(target.sessionId);
+    return JSON.stringify([Boolean(session), session?.title, session?.updatedAt, session?.latestMessageId]) === target.recordRevision;
+  }
+
   async function clearMessages(sessionId) {
     if (!sessionId || state.busySessionIds.has(sessionId)) return;
+    const target = captureSessionMutationTarget(sessionId);
     if (
-      !confirmAction(
+      !await confirmAction(
         `Clear all messages in "${sessionId}"? The session will stay in the list.`,
+        { title: "Clear conversation", confirmLabel: "Clear messages", tone: "danger" },
       )
     )
       return;
-    const scope = { environmentId: selectedEnvironmentId(), sessionId };
+    if (!isCurrentSessionMutationTarget(target)) return;
+    const scope = { environmentId: target.environmentId, sessionId };
     setBusy(sessionId, true);
     try {
       await client.clearSessionMessages(sessionId, scope.environmentId);
@@ -284,13 +306,16 @@ export function createSessionController({
 
   async function deleteSession(sessionId) {
     if (!sessionId || state.busySessionIds.has(sessionId)) return;
+    const target = captureSessionMutationTarget(sessionId);
     if (
-      !confirmAction(
+      !await confirmAction(
         `Delete "${sessionId}" from this environment and the server?`,
+        { title: "Delete conversation", confirmLabel: "Delete conversation", tone: "danger" },
       )
     )
       return;
-    const scope = { environmentId: selectedEnvironmentId(), sessionId };
+    if (!isCurrentSessionMutationTarget(target)) return;
+    const scope = { environmentId: target.environmentId, sessionId };
     setBusy(sessionId, true);
     try {
       await client.deleteSession(sessionId, scope.environmentId);

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

@@ -7,6 +7,7 @@ import { filterSessionsByArchiveState } from "../lib/session-archive-visibility.
 
 export function createSessionSidebarController({
   state, preferences, updatePinnedSessions, selectedEnvironmentId = () => "", render, showToast, getFilteredSessions, getPageInfo = () => undefined,
+  getDeletedProjectIds = () => [],
 }) {
   let showingArchived = false;
   let environmentId = selectedEnvironmentId();
@@ -38,7 +39,7 @@ export function createSessionSidebarController({
     return canReorderSidebarSessions(
       sessions.find((session) => session.id === sourceId),
       sessions.find((session) => session.id === targetId),
-      state.pinnedSessionIds,
+      state.pinnedSessionIds, getDeletedProjectIds(),
     );
   }
 
@@ -74,9 +75,9 @@ export function createSessionSidebarController({
   }
 
   async function moveInDirection(session, direction) {
-    const group = sessionSidebarGroup(session, state.pinnedSessionIds);
+    const group = sessionSidebarGroup(session, state.pinnedSessionIds, getDeletedProjectIds());
     const siblings = getFilteredSessions().filter(isSessionVisibleInSidebar).filter((candidate) =>
-      sessionSidebarGroup(candidate, state.pinnedSessionIds) === group,
+      sessionSidebarGroup(candidate, state.pinnedSessionIds, getDeletedProjectIds()) === group,
     );
     const index = siblings.findIndex((candidate) => candidate.id === session.id);
     if (index < 0) return;

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

@@ -0,0 +1,254 @@
+import { confirmDialog } from "../components/confirmation-dialog.js";
+/** Owns personal Skill drafts and environment-bound reads/mutations. */
+export function createSkillsController({ client, getEnvironmentId, render,
+  confirmDiscard = (message) => confirmDialog(message, { title: "Unsaved Skill", confirmLabel: "Discard changes", tone: "danger" }) }) {
+  const state = { items: [], skill: null, draft: "", archived: false, creating: false, name: "", description: "",
+    loading: false, reading: false, mutation: "", error: "", message: "" };
+  let epoch = 0;
+  let listRead = 0;
+  let detailRead = 0;
+  let draftRevision = 0;
+  let leaveRevision = 0;
+  let active = false;
+  const snapshot = () => ({ ...state, items: [...state.items], dirty: isDirty() });
+  const publish = () => render(snapshot());
+  function isDirty() {
+    if (state.creating) return Boolean(state.name || state.description || state.draft);
+    return Boolean(state.skill && state.draft !== state.skill.content);
+  }
+  const capture = () => ({ epoch, environmentId: getEnvironmentId() });
+  function isCurrent(scope) {
+    if (scope.epoch !== epoch) return false;
+    return scope.environmentId === getEnvironmentId();
+  }
+  function clearEditor() {
+    detailRead += 1;
+    draftRevision += 1;
+    state.skill = null;
+    state.creating = false;
+    state.name = "";
+    state.description = "";
+    state.draft = "";
+    state.reading = false;
+  }
+  function canEdit() {
+    if (state.mutation || state.reading) return false;
+    if (state.creating) return true;
+    if (!state.skill || state.skill.archived) return false;
+    return state.skill.source === "personal";
+  }
+  async function prepareLeave() {
+    const request = ++leaveRevision;
+    if (state.mutation) return false;
+    if (!isDirty()) return true;
+    const revision = draftRevision;
+    const scope = capture();
+    if (!await confirmDiscard("Discard unsaved Skill changes?")) return false;
+    if (!isCurrent(scope) || revision !== draftRevision) return false;
+    const commit = () => {
+      if (!commit.canCommit()) return false;
+      if (state.creating) clearEditor();
+      else { state.draft = state.skill.content; draftRevision += 1; }
+      publish();
+      return true;
+    };
+    commit.canCommit = () => {
+      if (state.mutation) return false;
+      if (request !== leaveRevision) return false;
+      if (!isCurrent(scope)) return false;
+      return revision === draftRevision;
+    };
+    return commit;
+  }
+  async function acceptLeave() {
+    const scope = capture();
+    const revision = draftRevision;
+    const pending = prepareLeave();
+    const request = leaveRevision;
+    const prepared = await pending;
+    if (request !== leaveRevision) return false;
+    if (!isCurrent(scope) || revision !== draftRevision) return false;
+    if (state.mutation) return false;
+    if (prepared === false || prepared?.canCommit?.() === false) return false;
+    if (typeof prepared === "function") prepared();
+    return true;
+  }
+  async function refresh() {
+    if (!client.supportsSkills()) return;
+    const scope = capture();
+    const read = ++listRead;
+    state.loading = true;
+    publish();
+    try {
+      const result = await client.listPersonalSkills(scope.environmentId);
+      if (!isCurrent(scope) || read !== listRead) return;
+      state.items = result.items.filter((item) => item.source === "personal");
+    } catch (error) {
+      if (!isCurrent(scope) || read !== listRead) return;
+      state.error = error.message || String(error);
+    } finally {
+      if (isCurrent(scope) && read === listRead) { state.loading = false; publish(); }
+    }
+  }
+  async function select(skillId) {
+    if (state.skill?.skillId === skillId) return true;
+    if (!await acceptLeave()) return false;
+    if (!state.items.some((item) => item.skillId === skillId)) return false;
+    return loadSkill(skillId);
+  }
+  async function loadSkill(skillId) {
+    const scope = capture();
+    clearEditor();
+    const read = detailRead;
+    state.error = "";
+    state.message = "";
+    state.reading = true;
+    publish();
+    try {
+      const { skill } = await client.readPersonalSkill(skillId, scope.environmentId);
+      if (!isCurrent(scope) || read !== detailRead) return false;
+      if (skill.source !== "personal" || skill.skillId !== skillId) throw new Error("This personal Skill is unavailable.");
+      state.skill = skill;
+      state.draft = skill.content;
+      draftRevision += 1;
+      return true;
+    } catch (error) {
+      if (isCurrent(scope) && read === detailRead) state.error = error.message || String(error);
+      return false;
+    } finally {
+      if (isCurrent(scope) && read === detailRead) { state.reading = false; publish(); }
+    }
+  }
+  function setDraft(content) {
+    if (!canEdit()) return;
+    state.draft = content;
+    draftRevision += 1;
+    state.message = "";
+    publish();
+  }
+  async function beginCreate() {
+    if (!await acceptLeave()) return false;
+    clearEditor();
+    Object.assign(state, { creating: true, archived: false, error: "", message: "" });
+    publish();
+    return true;
+  }
+  function setCreationField(field, value) {
+    if (!state.creating || !canEdit()) return;
+    if (field !== "name" && field !== "description") return;
+    state[field] = value;
+    draftRevision += 1;
+    state.message = "";
+    publish();
+  }
+  async function cancelCreate() {
+    if (!state.creating || !await acceptLeave()) return false;
+    clearEditor();
+    state.error = "";
+    publish();
+    return true;
+  }
+  function creationValidationMessage() {
+    if (!state.name.trim() || state.name.length > 160) return "Enter a name of up to 160 characters.";
+    if (!state.description.trim() || state.description.length > 512) return "Enter a description of up to 512 characters.";
+    if (!state.draft.trim()) return "Enter the Skill content.";
+    if (new TextEncoder().encode(state.draft).length > 65_536) return "Skill content must be no larger than 64 KiB.";
+    return "";
+  }
+  async function create() {
+    if (!state.creating || !canEdit()) return false;
+    state.error = creationValidationMessage();
+    if (state.error) { publish(); return false; }
+    const scope = capture();
+    const input = { name: state.name, description: state.description, content: state.draft };
+    state.mutation = "create";
+    state.message = "";
+    publish();
+    try {
+      const { skill } = await client.createPersonalSkill(input, scope.environmentId);
+      if (!isCurrent(scope)) return false;
+      clearEditor();
+      Object.assign(state, { skill, draft: skill.content, archived: false, message: "Skill created." });
+      state.items = [...state.items.filter((item) => item.skillId !== skill.skillId), skill];
+      await refresh();
+      return true;
+    } catch (error) {
+      if (!isCurrent(scope)) return false;
+      state.error = error.message || String(error);
+      return false;
+    } finally {
+      if (isCurrent(scope)) { state.mutation = ""; publish(); }
+    }
+  }
+  async function setArchived(archived) {
+    if (state.archived === archived) return true;
+    if (!await acceptLeave()) return false;
+    state.archived = archived;
+    state.error = "";
+    state.message = "";
+    clearEditor();
+    publish();
+    return true;
+  }
+  async function reloadSelected() {
+    if (!state.skill || !await acceptLeave()) return false;
+    return loadSkill(state.skill.skillId);
+  }
+  async function mutate(action) {
+    const skill = state.skill;
+    if (!skill || skill.source !== "personal" || state.mutation || state.reading) return false;
+    if (action === "save" && (!canEdit() || !isDirty() || !state.draft.trim())) return false;
+    if (action === "archive" && skill.archived) return false;
+    if (action === "restore" && !skill.archived) return false;
+    const scope = capture();
+    const content = state.draft;
+    state.mutation = action;
+    state.error = "";
+    state.message = "";
+    publish();
+    try {
+      const mutations = {
+        save: () => client.updatePersonalSkill(skill.skillId, content, skill.revision, scope.environmentId),
+        archive: () => client.archivePersonalSkill(skill.skillId, skill.revision, scope.environmentId),
+        restore: () => client.restorePersonalSkill(skill.skillId, skill.revision, scope.environmentId),
+      };
+      const result = await mutations[action]();
+      if (!isCurrent(scope)) return false;
+      if (action === "save") {
+        state.skill = result.skill;
+        state.draft = result.skill.content;
+        draftRevision += 1;
+      } else {
+        clearEditor();
+      }
+      state.message = { save: "Skill saved.", archive: "Skill archived.", restore: "Skill restored." }[action];
+      await refresh();
+      return true;
+    } catch (error) {
+      if (!isCurrent(scope)) return false;
+      state.error = error.code === "knowledge_skill_revision_conflict"
+        ? "This Skill changed elsewhere. Your draft is kept. Copy it before reloading the latest version."
+        : error.message || String(error);
+      return false;
+    } finally {
+      if (isCurrent(scope)) { state.mutation = ""; publish(); }
+    }
+  }
+  function environmentChanged() {
+    epoch += 1;
+    listRead += 1;
+    clearEditor();
+    Object.assign(state, { items: [], archived: false, loading: false, mutation: "", error: "", message: "" });
+    publish();
+    if (active) void refresh();
+  }
+  function setActive(value) {
+    const entering = value && !active;
+    active = value;
+    if (entering) void refresh();
+  }
+  return { snapshot, refresh, select, setDraft, setArchived, reloadSelected, prepareLeave,
+    isDirty, environmentChanged, setActive, beginCreate, setCreationField, cancelCreate,
+    save: () => state.creating ? create() : mutate("save"),
+    archive: () => mutate("archive"), restore: () => mutate("restore") };
+}

package/dist/src/web-ui/app/controllers/spark-chat-sync.js

@@ -111,7 +111,7 @@ export function createSparkChatSync({
         onHistoryReset();
       }
       if (hasReadableGeneration(result.readState)) readGeneration = result.readState.readGeneration;
-      onConfiguration({ ...result, supportsImageInput, supportsThinking: profile?.supportsThinking === true, modelAvailable: Boolean(profile) });
+      onConfiguration({ ...result, supportsImageInput, supportsThinking: profile?.supportsThinking === true, reasoningControls: profile?.reasoningControls, modelAvailable: Boolean(profile) });
       onReadState(result.readState);
       const snapshot = result.snapshot;
       if (shouldHydrateSparkConversation(initialized, rehydrate, snapshot, state)) {

package/dist/src/web-ui/app/controllers/spark-handoff-navigation.js

@@ -5,8 +5,10 @@ export function createSparkHandoffNavigation({ state, getEnvironmentId, shell, c
     const sessionId = state.currentSessionId;
     const viewVersion = state.sessionViewVersion;
     const workspace = shell.activeWorkspace();
+    let navigationRequest = shell.navigationRequestRevision?.();
     function navigationIsCurrent() {
       if (environmentId !== getEnvironmentId()) return false;
+      if (navigationRequest !== shell.navigationRequestRevision?.()) return false;
       if (sessionId !== state.currentSessionId || viewVersion !== state.sessionViewVersion) return false;
       return workspace === shell.activeWorkspace();
     }
@@ -14,12 +16,16 @@ export function createSparkHandoffNavigation({ state, getEnvironmentId, shell, c
       if (!targetSessionId || !navigationIsCurrent()) return false;
       await conversation.loadSessions();
       if (!navigationIsCurrent()) return false;
+      const activate = await shell.prepareWorkspaceActivation("chat");
+      if (!activate || activate.canCommit?.() === false) return false;
+      navigationRequest = shell.navigationRequestRevision?.();
+      if (!navigationIsCurrent()) return false;
       let committed = false;
       await conversation.openSession(targetSessionId, {
         isRouteCurrent: navigationIsCurrent,
         commitRouteNavigation() {
           if (!navigationIsCurrent()) return false;
-          committed = shell.activateWorkspace("chat") !== false;
+          committed = activate() !== false;
           return committed;
         },
       });

package/dist/src/web-ui/app/controllers/tool-approval-controller.d.ts

@@ -5,6 +5,7 @@ import type {
 
 export interface ToolApprovalControllerState {
   connected: boolean;
+  currentSessionId?: string;
   events: ToolApprovalEvent[];
   submittedToolApprovalIds: Set<string>;
   messages?: Array<Record<string, unknown>>;
@@ -27,5 +28,5 @@ export declare function createToolApprovalController(
   isPending(event: ToolApprovalEvent | undefined): boolean;
   pendingEvent(): ToolApprovalEvent | undefined;
   pendingEvents(): ToolApprovalEvent[];
-  submit(approvalId: string, approved: boolean): boolean;
+  submit(approvalId: string, approved: boolean, reason?: string): boolean;
 };

package/dist/src/web-ui/app/controllers/tool-approval-controller.js

@@ -2,6 +2,10 @@ import { textOf } from "../lib/text-format.js";
 import { requestLifecycles } from "../lib/request-lifecycle-view.js";
 import { approvalDecisionCommand } from "../lib/approval-decision-command.js";
 import { projectToolActivityEvent } from "../lib/tool-activity-event.js";
+import {
+  approvalRejectionIdentity,
+  createApprovalRejectionDrafts,
+} from "../lib/tool-approval-rejection-drafts.js";
 
 export function createToolApprovalController({
   state,
@@ -11,6 +15,16 @@ export function createToolApprovalController({
   recordControlEvent,
   createCard: createApprovalCard,
 }) {
+  const rejectionDrafts = createApprovalRejectionDrafts();
+
+  function approvalScope(event) {
+    return {
+      ...event,
+      environmentId: selectedEnvironmentId(),
+      sessionId: event?.sessionId || state.currentSessionId,
+    };
+  }
+
   function isResolved(approvalId) {
     for (const lifecycle of requestLifecycles(state).values()) {
       if (
@@ -76,10 +90,12 @@ export function createToolApprovalController({
         });
       }
     }
-    return [...pending.values()];
+    const events = [...pending.values()];
+    rejectionDrafts.retain(events.map(approvalScope));
+    return events;
   }
 
-  function submit(approvalId, approved) {
+  function submit(approvalId, approved, reason) {
     if (!state.connected) {
       recordControlEvent({
         type: "control",
@@ -99,6 +115,7 @@ export function createToolApprovalController({
       type: "tool_approval_response",
       approvalId,
       approved,
+      ...(reason !== undefined ? { reason } : {}),
       environment: selectedEnvironmentId(),
       ...(pending.waitId
         ? {
@@ -113,11 +130,27 @@ export function createToolApprovalController({
     return sent !== false;
   }
 
+  function canSubmitFromCard(scope) {
+    const pending = pendingEvents().find(
+      (event) => event.approvalId === scope.approvalId,
+    );
+    if (!pending) return false;
+    return (
+      approvalRejectionIdentity(scope) ===
+      approvalRejectionIdentity(approvalScope(pending))
+    );
+  }
+
   function createCard(event) {
+    const scope = approvalScope(event);
     return createApprovalCard({
       event,
+      rejectionDraft: rejectionDrafts.get(scope),
       submitted: state.submittedToolApprovalIds.has(textOf(event?.approvalId)),
-      onDecision: submit,
+      onDecision: (approvalId, approved, reason) => {
+        if (!canSubmitFromCard(scope)) return false;
+        return submit(approvalId, approved, reason);
+      },
     });
   }
 

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

@@ -8,11 +8,17 @@ export function createWorkspaceConversationOpener({ state, shell, openSession })
       shell.showToast?.("Wait for the environment change to finish before opening a conversation.", "neutral");
       return false;
     }
-    const activate = shell.prepareWorkspaceActivation("chat");
-    if (!activate) return false;
     let navigationRevision = shell.navigationRevision?.();
+    const sessionIdBefore = state.currentSessionId;
+    const viewVersion = state.sessionViewVersion;
+    const activate = await shell.prepareWorkspaceActivation("chat");
+    if (!activate) return false;
+    if (navigationRevision !== shell.navigationRevision?.()) return false;
+    if (sessionIdBefore !== state.currentSessionId) return false;
+    if (viewVersion !== state.sessionViewVersion) return false;
     function isConversationWorkspaceNavigationCurrent() {
       if (!canNavigateConversation(state)) return false;
+      if (!committed && activate.canCommit?.() === false) return false;
       return shell.navigationRevision?.() === navigationRevision;
     }
     let committed = false;

package/dist/src/web-ui/app/controllers/workspace-route-controller.js

@@ -109,6 +109,7 @@ export function createWorkspaceRouteController({
   function routeNavigationRevisions() {
     return {
       shell: shell.navigationRevision(),
+      shellRequest: shell.navigationRequestRevision?.() || 0,
       configuration: configuration.navigationRevision(),
       schedules: schedules.navigationRevision(),
       automations: automations?.navigationRevision() || 0,
@@ -117,6 +118,7 @@ export function createWorkspaceRouteController({
 
   function hasCurrentRouteNavigation(revisions) {
     if (shell.navigationRevision() !== revisions.shell) return false;
+    if ((shell.navigationRequestRevision?.() || 0) !== revisions.shellRequest) return false;
     if (configuration.navigationRevision() !== revisions.configuration)
       return false;
     if (schedules.navigationRevision() !== revisions.schedules) return false;
@@ -129,6 +131,7 @@ export function createWorkspaceRouteController({
     environmentId,
     routeActivationIsCurrent,
     commitLinkedConversationRoute,
+    reloadSessionList,
   ) {
     if (route.workspace === "chat" && route.automationRun) return true;
     if (!routeCarriesConversation(route)) {
@@ -136,7 +139,7 @@ export function createWorkspaceRouteController({
       return true;
     }
     if (route.session === getSessionId()) return true;
-    await loadSessions();
+    if (reloadSessionList) await loadSessions();
     if (!routeActivationIsCurrent()) return false;
     if (environmentId !== getEnvironmentId()) return false;
     let routeCommitted = false;
@@ -161,7 +164,10 @@ export function createWorkspaceRouteController({
   }
 
   async function applyRoute(route, { initial = false } = {}) {
-    if (automations?.prepareRouteChange?.(route) === false) return false;
+    const navigationRevisions = routeNavigationRevisions();
+    const preparedRouteChange = await automations?.prepareRouteChange?.(route);
+    if (preparedRouteChange === false || preparedRouteChange === null) return false;
+    if (!hasCurrentRouteNavigation(navigationRevisions)) return false;
     if (!routeEnvironmentIsAvailable(route)) {
       shell.showToast("This environment is no longer available.", "failed");
       return false;
@@ -170,12 +176,22 @@ export function createWorkspaceRouteController({
       shell.showToast("This workspace is unavailable with the current backend.", "failed");
       return false;
     }
-    const navigationRevisions = routeNavigationRevisions();
-    if (routeChangesEnvironment(route, getEnvironmentId())) {
-      if (
-        !(await changeEnvironment(route.environment, { restoreSession: false }))
-      )
-        return false;
+    let routeChangeCommitted = false;
+    const environmentChanged = routeChangesEnvironment(route, getEnvironmentId());
+    if (environmentChanged) {
+      const commitRouteChange = () => {
+        if (preparedRouteChange?.canCommit?.() === false) return false;
+        if (typeof preparedRouteChange === "function" && preparedRouteChange() === false) return false;
+        routeChangeCommitted = true;
+        return true;
+      };
+      commitRouteChange.canCommit = () => hasCurrentRouteNavigation(navigationRevisions) &&
+        preparedRouteChange?.canCommit?.() !== false;
+      const options = { restoreSession: false, commitEnvironmentOptions: commitRouteChange };
+      if (!await changeEnvironment(route.environment, options)) return false;
+      if (shell.navigationRevision() !== navigationRevisions.shell) return false;
+      if ((shell.navigationRequestRevision?.() || 0) !== navigationRevisions.shellRequest) return false;
+      Object.assign(navigationRevisions, routeNavigationRevisions());
     }
     if (!hasCurrentRouteNavigation(navigationRevisions)) return false;
     if (!routeWorkspaceIsAvailable(route)) {
@@ -186,18 +202,26 @@ export function createWorkspaceRouteController({
       return false;
     }
     const environmentId = getEnvironmentId();
-    const activate = shell.prepareWorkspaceActivation(route.workspace, {
+    const activate = await shell.prepareWorkspaceActivation(route.workspace, {
       focus: false,
     });
     if (!activate) return false;
+    if (activate.canCommit?.() === false) return false;
+    navigationRevisions.shellRequest = shell.navigationRequestRevision?.() || 0;
+    if (!hasCurrentRouteNavigation(navigationRevisions)) return false;
+    if (environmentId !== getEnvironmentId()) return false;
     let linkedConversationActivated = false;
     function routeActivationIsCurrent() {
       if (!hasCurrentRouteNavigation(navigationRevisions)) return false;
+      if (!routeChangeCommitted && preparedRouteChange?.canCommit?.() === false) return false;
       if (environmentId !== getEnvironmentId()) return false;
       return !initialRouteWasSuperseded(initial, pendingInitialHistory);
     }
     function commitLinkedConversationRoute() {
       if (!routeActivationIsCurrent()) return false;
+      if (activate.canCommit?.() === false) return false;
+      if (!routeChangeCommitted && typeof preparedRouteChange === "function" && preparedRouteChange() === false) return false;
+      routeChangeCommitted = true;
       if (!activate()) return false;
       navigationRevisions.shell = shell.navigationRevision();
       linkedConversationActivated = true;
@@ -210,11 +234,12 @@ export function createWorkspaceRouteController({
         environmentId,
         routeActivationIsCurrent,
         commitLinkedConversationRoute,
+        shouldReloadRouteSessionList(initial, environmentChanged, shell.activeWorkspace()),
       ))
     )
       return false;
     if (!routeActivationIsCurrent()) return false;
-    if (!linkedConversationActivated && !activate()) return false;
+    if (!linkedConversationActivated && !commitLinkedConversationRoute()) return false;
     const category = configurationCategoryForWorkspace(route.workspace);
     if (category) {
       if (configuration.activateCategory(category) === false)
@@ -356,3 +381,9 @@ function initialRouteWasSuperseded(initial, pendingHistory) {
   if (!initial) return false;
   return Boolean(pendingHistory);
 }
+
+function shouldReloadRouteSessionList(initial, environmentChanged, currentWorkspace) {
+  if (initial) return true;
+  if (environmentChanged) return true;
+  return currentWorkspace !== "chat";
+}