@abot-ai/runtime 1.9.0 → 2.0.0

package/dist/src/web-ui/app/components/workspace-shell.js

@@ -1,6 +1,5 @@
 import {
   createInitialWorkspaceShellState,
-  normalizeWorkspaceDestination,
   toggleWorkspaceSheet,
 } from "../ui-behavior.js";
 import { createOnboardingWorkspaceAccess } from "./onboarding-workspace-access.js";
@@ -10,6 +9,8 @@ import {
   resolveConversationSidebarLayout,
 } from "./conversation-sidebar-layout.js";
 import { createOperationsSection } from "./operations-section.js";
+import { createWorkspaceTransitions } from "./workspace-transitions.js";
+import { captureSessionListViewport, restoreSessionListViewport } from "./session-list-viewport.js";
 import { isConfigurationWorkspace, renderConfigurationPageHeading } from "../lib/configuration-pages.js";
 
 export function createWorkspaceShell({
@@ -31,6 +32,12 @@ export function createWorkspaceShell({
   const workspaceListeners = new Set();
   const runtimeAvailabilityListeners = new Set();
   const workspaceGuards = new Set();
+  const transitions = createWorkspaceTransitions({
+    getWorkspace: () => shellState.workspace,
+    getNavigationRevision: () => navigationRevision,
+    isAvailable: workspaceAccess.isAvailable,
+    getGuards: () => [beforeWorkspaceChange, ...workspaceGuards],
+  });
   function notifyWorkspaceListeners(workspace) {
     onWorkspaceChange(workspace);
     for (const listener of workspaceListeners) listener(workspace);
@@ -66,6 +73,7 @@ export function createWorkspaceShell({
   }
 
   function syncShell() {
+    captureSessionListViewport(dom.sessionsList);
     workspaceAccess.render();
     const homeWorkspace = shellState.workspace === "home";
     const chatWorkspace = shellState.workspace === "chat";
@@ -142,6 +150,7 @@ export function createWorkspaceShell({
     }
     setCurrentPage(dom.notificationsWorkspaceButton, notificationsWorkspace);
     dom.sessionsPanel.hidden = !sessions.visible;
+    restoreSessionListViewport(dom.sessionsList);
     dom.sessionsPanel.inert = !sessions.visible;
     dom.sessionsPanel.setAttribute(
       "aria-hidden",
@@ -183,7 +192,7 @@ export function createWorkspaceShell({
       dom.closeSessionsButton.focus();
       return;
     }
-    const sidebarControl = dom.sessionSearchInput ?? dom.refreshSessionsButton;
+    const sidebarControl = dom.sessionSearchToggleButton ?? dom.refreshSessionsButton;
     (sidebarControl ?? dom.chatWorkspaceButton).focus();
   }
 
@@ -218,35 +227,9 @@ export function createWorkspaceShell({
     visibleNavigationButton.focus();
   }
 
-  function prepareWorkspaceTransition(destination) {
-    const nextWorkspace = normalizeWorkspaceDestination(destination);
-    if (!workspaceAccess.isAvailable(nextWorkspace)) return null;
-    if (nextWorkspace === shellState.workspace) {
-      return { nextWorkspace, commitBeforeChange: () => {} };
-    }
-    const preparedChange = beforeWorkspaceChange({
-      from: shellState.workspace,
-      to: nextWorkspace,
-    });
-    if (preparedChange === false || preparedChange === null) return null;
-    const additionalChanges = [];
-    for (const guard of workspaceGuards) {
-      const change = guard({ from: shellState.workspace, to: nextWorkspace });
-      if (change === false || change === null) return null;
-      if (typeof change === "function") additionalChanges.push(change);
-    }
-    return {
-      nextWorkspace,
-      commitBeforeChange() {
-        if (typeof preparedChange === "function") preparedChange();
-        for (const change of additionalChanges) change();
-      },
-    };
-  }
-
   function commitWorkspaceActivation(preparedTransition, options = {}) {
     if (!workspaceAccess.isAvailable(preparedTransition.nextWorkspace)) return false;
-    preparedTransition.commitBeforeChange();
+    if (!preparedTransition.commitBeforeChange()) return false;
     const nextWorkspace = preparedTransition.nextWorkspace;
     const previousWorkspace = shellState.workspace;
     const previousSheet = shellState.activeSheet;
@@ -285,27 +268,34 @@ export function createWorkspaceShell({
     return true;
   }
 
-  function prepareWorkspaceActivation(destination, options = {}) {
-    const preparedTransition = prepareWorkspaceTransition(destination);
+  async function prepareWorkspaceActivation(destination, options = {}) {
+    const preparedTransition = await transitions.prepare(destination);
     if (!preparedTransition) return null;
     let committed = false;
-    return () => {
+    const activate = () => {
       if (committed) return true;
       const activated = commitWorkspaceActivation(preparedTransition, options);
       committed = activated;
       return activated;
     };
+    activate.canCommit = () => committed || preparedTransition.canCommit();
+    return activate;
   }
 
-  function activateWorkspace(destination, options = {}) {
-    const preparedActivation = prepareWorkspaceActivation(destination, options);
+  async function activateWorkspace(destination, options = {}) {
+    const preparedActivation = await prepareWorkspaceActivation(destination, options);
     return preparedActivation ? preparedActivation() : false;
   }
 
   function setSessionsDrawerOpen(open, options = {}) {
-    const preparedTransition = prepareWorkspaceTransition("chat");
-    if (!preparedTransition) return false;
-    preparedTransition.commitBeforeChange();
+    if (shellState.workspace === "chat") return commitSessionsDrawer(open, options);
+    return transitions.prepare("chat").then((prepared) => {
+      if (!prepared?.commitBeforeChange()) return false;
+      return commitSessionsDrawer(open, options);
+    });
+  }
+
+  function commitSessionsDrawer(open, options) {
     const wasOpen = shellState.activeSheet === "sessions";
     shellState.workspace = "chat";
     const useDrawer = open && sidebarViewport?.matches !== true;
@@ -351,7 +341,8 @@ export function createWorkspaceShell({
       return true;
     }
     if (["config", "models", "plugins", "schedules", "automations", "learning", "memory", "skills", "notifications"].includes(shellState.workspace)) {
-      return activateWorkspace("chat");
+      void activateWorkspace("chat");
+      return true;
     }
     return false;
   }
@@ -433,6 +424,7 @@ export function createWorkspaceShell({
     runtimeAvailabilityChanged,
     workspaceUnavailableMessage: workspaceAccess.unavailableMessage,
     navigationRevision: () => navigationRevision,
+    navigationRequestRevision: transitions.requestRevision,
     subscribeRuntimeAvailabilityChange(listener) {
       runtimeAvailabilityListeners.add(listener);
       return () => runtimeAvailabilityListeners.delete(listener);

package/dist/src/web-ui/app/components/workspace-transitions.js

@@ -0,0 +1,42 @@
+import { normalizeWorkspaceDestination } from "../ui-behavior.js";
+
+export function createWorkspaceTransitions({ getWorkspace, getNavigationRevision, isAvailable, getGuards }) {
+  let requestRevision = 0;
+  async function prepare(destination) {
+    const request = ++requestRevision;
+    const from = getWorkspace();
+    const revision = getNavigationRevision();
+    const nextWorkspace = normalizeWorkspaceDestination(destination);
+    const changes = [];
+    function isCurrentTransitionRequest() {
+      if (request !== requestRevision) return false;
+      if (from !== getWorkspace()) return false;
+      if (revision !== getNavigationRevision()) return false;
+      return isAvailable(nextWorkspace);
+    }
+    function canCommitTransition() {
+      if (!isCurrentTransitionRequest()) return false;
+      return changes.every((change) => change?.canCommit?.() !== false);
+    }
+    if (!isCurrentTransitionRequest()) return null;
+    const guards = nextWorkspace === from ? [] : getGuards();
+    for (const guard of guards) {
+      const change = await guard({ from, to: nextWorkspace });
+      if (!canCommitTransition()) return null;
+      if (change === false || change === null) return null;
+      changes.push(change);
+    }
+    if (!canCommitTransition()) return null;
+    return {
+      nextWorkspace, canCommit: canCommitTransition,
+      commitBeforeChange() {
+        if (!canCommitTransition()) return false;
+        for (const change of changes) {
+          if (typeof change === "function" && change() === false) return false;
+        }
+        return true;
+      },
+    };
+  }
+  return { prepare, requestRevision: () => requestRevision };
+}

package/dist/src/web-ui/app/configuration-feature.js

@@ -6,6 +6,7 @@ import { createHomeGuidance } from "./components/home-guidance/home-guidance.js"
 import { createConfigWorkspace } from "./components/config-workspace.js";
 import { createModelRemovalController } from "./components/config-workspace/model-removal.js";
 import { createLongTermMemorySetup } from "./components/long-term-memory-setup.js";
+import { createMemoryEmbeddingConnectionFeature } from "./components/long-term-memory/embedding-connection-feature.js";
 import { createLongTermMemoryManager } from "./components/long-term-memory/manager.js";
 import { createMemoryWorkspace } from "./components/long-term-memory/workspace.js";
 import { createLongTermMemoryController } from "./controllers/long-term-memory/controller.js";
@@ -28,7 +29,24 @@ export function createConfigurationFeature({
   let activation;
   let modelSetup;
   let modelRemoval;
+  const memoryConnection = createMemoryEmbeddingConnectionFeature({
+    root: dom.memoryWorkspacePanel,
+    runtimeClient,
+    getEnvironmentId: selectedEnvironmentId,
+    getWorkspace: () => configWorkspace,
+    canOpen: () => !modelSetup?.isOpen() && !pluginManager.hasConfigurationDraft(),
+    refreshMemory: () => longTermMemorySetup.load({ preserveInputs: false }),
+    onSaved: () => activation?.markPending(),
+    onApplied: async () => {
+      activation?.markApplied();
+      pluginManager.markApplied?.();
+      await onConfigurationApplied();
+    },
+    onClosed: () => onConfigurationSettled(),
+  });
   const longTermMemorySetup = createLongTermMemorySetup({
+    onAddConnection: (options) => memoryConnection.open(options),
+    onEnvironmentChanged: () => memoryConnection.environmentChanged(),
     getEnvironmentId: selectedEnvironmentId,
     loadStatus: (environmentId) =>
       runtimeClient.loadLongTermMemoryStatus(environmentId),
@@ -45,6 +63,10 @@ export function createConfigurationFeature({
       activation?.markPending();
       return result;
     },
+    saveProfile: (input, environmentId) =>
+      runtimeClient.saveMemoryEmbeddingProfile(input, environmentId),
+    removeProfile: (input, environmentId) =>
+      runtimeClient.removeMemoryEmbeddingProfile(input, environmentId),
     disableMemory: async (environmentId) => {
       const result = await runtimeClient.disableLongTermMemory(environmentId);
       activation?.markPending();
@@ -67,6 +89,7 @@ export function createConfigurationFeature({
   });
   longTermMemoryManager = createLongTermMemoryManager({
     actions: longTermMemoryController,
+    getEnvironmentId: selectedEnvironmentId,
   });
   longTermMemorySetup.mount(dom.memorySetupRoot);
   longTermMemoryManager.mount(dom.memoryManagementRoot);
@@ -140,7 +163,7 @@ export function createConfigurationFeature({
     getOperationsSummary,
     onNavigationChange,
     onRemoveModel: (model) => {
-      if (modelSetup?.isOpen()) return;
+      if (modelSetup?.isOpen() || memoryConnection.isOpen()) return;
       return modelRemoval.remove(model);
     },
     dom: {
@@ -164,7 +187,7 @@ export function createConfigurationFeature({
       return result;
     },
     onAddModel: async (options) => {
-      if (modelSetup?.isOpen()) return;
+      if (modelSetup?.isOpen() || memoryConnection.isOpen()) return;
       if (!configWorkspace.beginExternalRuntimeMutation("model setup")) return;
       configWorkspace.endExternalRuntimeMutation();
       try {
@@ -215,6 +238,7 @@ export function createConfigurationFeature({
     root: dom.configDashboard.parentElement,
     getEnvironmentId: selectedEnvironmentId,
     loadSetup: () => runtimeClient.loadModelSetup(selectedEnvironmentId()),
+    inspectConnection: (input) => runtimeClient.inspectModelConnection(input, selectedEnvironmentId()),
     saveModel: (input) =>
       runtimeClient.addRuntimeModel(input, selectedEnvironmentId()),
     applySetup: () =>
@@ -269,7 +293,7 @@ export function createConfigurationFeature({
       void longTermMemoryController.setOriginFilter("passive_observation");
       longTermMemoryManager.focus();
     },
-    prepareDiscardChanges: (...args) => {
+    prepareDiscardChanges: async (...args) => {
       if (pluginManager.hasConfigurationDraft()) {
         dom.configStatus.textContent =
           "Finish or cancel plugin configuration before leaving.";
@@ -280,12 +304,18 @@ export function createConfigurationFeature({
           "Finish or cancel model setup before leaving configuration.";
         return null;
       }
-      const prepared = prepareDiscardChanges(...args);
+      if (memoryConnection.isOpen()) {
+        dom.configStatus.textContent =
+          "Finish or cancel embedding connection setup before leaving.";
+        return null;
+      }
+      const prepared = await prepareDiscardChanges(...args);
       if (typeof prepared !== "function") return prepared;
       const commit = () => prepared();
       commit.canCommit = () => {
         if (pluginManager.hasConfigurationDraft()) return false;
         if (modelSetup.isOpen()) return false;
+        if (memoryConnection.isOpen()) return false;
         return prepared.canCommit?.() !== false;
       };
       return commit;

package/dist/src/web-ui/app/controllers/app-event-bindings.js

@@ -1,3 +1,5 @@
+import { bindSessionSearchDisclosure } from "../components/session-search-disclosure.js";
+import { bindReasoningBudgetMenu } from "./reasoning-budget-menu-events.js";
 import { beginConversationNavigation, canNavigateConversation } from "./conversation-navigation-intent.js";
 import {
   focusSelectedMenuItem,
@@ -34,6 +36,7 @@ export function createAppEventBindings({
     }
     const isCurrentNavigation = beginConversationNavigation(state);
     const navigationRevision = shell.navigationRevision?.();
+    const navigationRequest = shell.navigationRequestRevision?.();
     const environment = actions.selectedEnvironmentId?.();
     const session = state.currentSessionId;
     const prepared = await prepareQueueRecovery();
@@ -43,6 +46,7 @@ export function createAppEventBindings({
     if (prepared?.canCommit?.() === false) return false;
     const hasCurrentWorkspaceNavigation = navigationRevision === shell.navigationRevision?.();
     if (!hasCurrentWorkspaceNavigation) return false;
+    if (navigationRequest !== shell.navigationRequestRevision?.()) return false;
     if (actions.selectedEnvironmentId?.() !== environment) return false;
     if (state.currentSessionId !== session) return false;
     return () => {
@@ -57,7 +61,42 @@ export function createAppEventBindings({
     };
   }
 
+  async function newConversation({ canCommit = () => true } = {}) {
+    if (!canCommit()) return false;
+    const recovery = await prepareCurrentQueueRecovery();
+    if (!recovery || !canCommit()) return false;
+    const preparedWorkspaceActivation = await shell.prepareWorkspaceActivation(
+      "chat",
+      { focus: false },
+    );
+    if (!preparedWorkspaceActivation || !canCommit()) return false;
+    if (preparedWorkspaceActivation.canCommit?.() === false) return false;
+    if (recovery() === false) return false;
+    if (preparedWorkspaceActivation() === false) return false;
+    state.currentSessionId = createWebSessionId();
+    onSessionCreated(state.currentSessionId);
+    actions.saveSessionId(
+      actions.selectedEnvironmentId(),
+      state.currentSessionId,
+    );
+    actions.rememberModelSelection();
+    state.messages = [];
+    actions.resetLiveRequestView();
+    actions.setCurrentSessionTitle(state.currentSessionId);
+    actions.applyConversationChrome();
+    actions.subscribeSession(state.currentSessionId);
+    actions.renderSessions();
+    actions.renderMessages();
+    shell.setSessionsDrawerOpen(false);
+    dom.composerInput.focus();
+    return true;
+  }
+
   function bind() {
+    bindReasoningBudgetMenu({ state, dom, actions, modelSelector, documentRoot });
+    bindSessionSearchDisclosure({
+      toggle: dom.sessionSearchToggleButton, field: dom.sessionSearchField, input: dom.sessionSearchInput,
+    });
     let searchTimer;
     dom.sessionSearchInput.addEventListener("input", () => {
       state.sessionQuery = dom.sessionSearchInput.value;
@@ -69,33 +108,7 @@ export function createAppEventBindings({
       "click",
       () => void actions.loadSessions(),
     );
-    dom.newSessionButton.addEventListener("click", async () => {
-      const recovery = await prepareCurrentQueueRecovery();
-      if (!recovery) return;
-      const preparedWorkspaceActivation = shell.prepareWorkspaceActivation(
-        "chat",
-        { focus: false },
-      );
-      if (!preparedWorkspaceActivation) return;
-      if (recovery() === false) return;
-      if (preparedWorkspaceActivation() === false) return;
-      state.currentSessionId = createWebSessionId();
-      onSessionCreated(state.currentSessionId);
-      actions.saveSessionId(
-        actions.selectedEnvironmentId(),
-        state.currentSessionId,
-      );
-      actions.rememberModelSelection();
-      state.messages = [];
-      actions.resetLiveRequestView();
-      actions.setCurrentSessionTitle(state.currentSessionId);
-      actions.applyConversationChrome();
-      actions.subscribeSession(state.currentSessionId);
-      actions.renderSessions();
-      actions.renderMessages();
-      shell.setSessionsDrawerOpen(false);
-      dom.composerInput.focus();
-    });
+    dom.newSessionButton.addEventListener("click", () => newConversation());
     dom.environmentSelect.addEventListener("change", environmentTransition.onSelectChange, true);
     dom.agentPickerButton.addEventListener("click", (event) => {
       event.stopPropagation();
@@ -199,7 +212,9 @@ export function createAppEventBindings({
         actions.renderPermissionMode();
       }
       actions.renderAgentMode();
-      if (state.agentModeMenuOpen) focusSelectedMenuItem(dom.agentModeMenu);
+      if (state.agentModeMenuOpen) {
+        focusSelectedMenuItem(dom.agentModeMenu);
+      }
     });
     dom.agentModeButton.addEventListener("keydown", (event) => {
       if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
@@ -218,7 +233,7 @@ export function createAppEventBindings({
       event.stopPropagation(),
     );
     dom.agentModeMenu.addEventListener("keydown", (event) => {
-      handleMenuNavigation(event, dom.agentModeMenu);
+      if (event.target.closest?.("[data-mode]")) handleMenuNavigation(event, dom.agentModeMenu);
     });
     documentRoot.addEventListener("click", (event) => {
       if (
@@ -306,6 +321,7 @@ export function createAppEventBindings({
 
   return {
     bind,
+    newConversation,
     ...environmentTransition,
   };
 }

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

@@ -0,0 +1,105 @@
+import { isColorPaletteId, PALETTE_PREFERENCE_KEY, savedColorPalette } from "../lib/color-palettes.js";
+import { isNavigationMode, NAVIGATION_PREFERENCE_KEY, savedNavigationMode } from "../lib/navigation-display.js";
+
+export function createAppearanceController({ storage, applyPalette, applyNavigationMode = () => {}, onChange = () => {} }) {
+  let savedId = savedColorPalette(storage);
+  let selectedId = savedId;
+  let savedNavigation = savedNavigationMode(storage);
+  let selectedNavigation = savedNavigation;
+  let open = false;
+  let pending = false;
+  let error = "";
+  const state = () => ({ savedId, selectedId, savedNavigationMode: savedNavigation, selectedNavigationMode: selectedNavigation, open, pending, error });
+  const render = () => onChange(state());
+  const canPreviewAppearance = () => open && !pending;
+  applyPalette(savedId);
+  applyNavigationMode(savedNavigation);
+
+  function restoreAcknowledgedAppearance() {
+    savedId = savedColorPalette(storage);
+    selectedId = savedId;
+    savedNavigation = savedNavigationMode(storage);
+    selectedNavigation = savedNavigation;
+    applyPalette(savedId);
+    applyNavigationMode(savedNavigation);
+  }
+
+  const unsubscribe = storage.subscribe?.(() => {
+    const previousSavedId = savedId;
+    const previousSavedNavigation = savedNavigation;
+    savedId = savedColorPalette(storage);
+    savedNavigation = savedNavigationMode(storage);
+    if (followsSavedAppearance(open, selectedId, previousSavedId)) {
+      selectedId = savedId;
+      applyPalette(savedId);
+    }
+    if (followsSavedAppearance(open, selectedNavigation, previousSavedNavigation)) {
+      selectedNavigation = savedNavigation;
+      applyNavigationMode(savedNavigation);
+    }
+    render();
+  });
+
+  return {
+    state,
+    open() {
+      if (open) return;
+      restoreAcknowledgedAppearance();
+      error = "";
+      open = true;
+      render();
+    },
+    select(id) {
+      if (!canPreviewAppearance()) return;
+      if (!isColorPaletteId(id)) return;
+      selectedId = id;
+      error = "";
+      applyPalette(id);
+      render();
+    },
+    selectNavigationMode(mode) {
+      if (!canPreviewAppearance()) return;
+      if (!isNavigationMode(mode)) return;
+      selectedNavigation = mode;
+      error = "";
+      applyNavigationMode(mode);
+      render();
+    },
+    close() {
+      if (pending) return false;
+      open = false;
+      restoreAcknowledgedAppearance();
+      render();
+      return true;
+    },
+    async save() {
+      if (!canPreviewAppearance()) return;
+      const paletteToSave = selectedId;
+      const navigationToSave = selectedNavigation;
+      pending = true;
+      error = "";
+      render();
+      try {
+        if (paletteToSave !== savedColorPalette(storage))
+          await storage.setItem(PALETTE_PREFERENCE_KEY, paletteToSave);
+        if (navigationToSave !== savedNavigationMode(storage))
+          await storage.setItem(NAVIGATION_PREFERENCE_KEY, navigationToSave);
+        open = false;
+      } catch (failure) {
+        error = failure?.message || "Could not save appearance settings. Reload and try again.";
+      } finally {
+        pending = false;
+        restoreAcknowledgedAppearance();
+        render();
+      }
+    },
+    destroy() {
+      unsubscribe?.();
+      restoreAcknowledgedAppearance();
+    },
+  };
+}
+
+function followsSavedAppearance(open, selected, previouslySaved) {
+  return !open || selected === previouslySaved;
+}

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

@@ -380,8 +380,16 @@ export function createAutomationsController({
     eventRefresh.schedule();
   }
 
+  function captureActionScope() {
+    const continuation = captureView().captureContinuation();
+    const draftRevision = state.draft?.revision;
+    const publishedRevision = state.publishedDefinition?.revision;
+    return () => continuation.isCurrent() && draftRevision === state.draft?.revision &&
+      publishedRevision === state.publishedDefinition?.revision;
+  }
+
   return {
-    snapshot, openRoute, refresh, create,
+    snapshot, openRoute, refresh, create, captureActionScope,
     createTemplate: (templateId) => create(templateId), deleteDraft, mutateDraft, saveDefinition,
     saveNode, saveAgent, validate, publishDefinition, setActive, undoDraftMove, restorePublishedDraft,
     archive: () => changeArchiveState(true), restore: () => changeArchiveState(false),

package/dist/src/web-ui/app/controllers/composer-feature.d.ts

@@ -52,7 +52,7 @@ export interface ComposerFeatureOptions {
   recordControlEvent: ReturnType<typeof createRealtimeEventController>["recordControlEvent"];
   drafts?: ComposerDrafts;
   onChange?(): void;
-  confirmReview?(message: string): boolean;
+  confirmReview?(message: string, options?: { title: string; confirmLabel: string }): boolean | Promise<boolean>;
 }
 export interface ComposerFeature extends ComposerSurface {
   queue: ComposerQueueController;

package/dist/src/web-ui/app/controllers/composer-feature.js

@@ -1,3 +1,4 @@
+import { confirmDialog } from "../components/confirmation-dialog.js";
 import { createComposerDrafts } from "./composer-drafts.js";
 import { createComposerSubmissionLifecycle, ComposerSubmissionRefused } from "./composer-submission-lifecycle.js";
 import { createComposerAttachmentsController } from "./composer-attachments-controller.js";
@@ -14,7 +15,7 @@ export function createComposerFeature({
   getSubmissionBlock, onSubmissionBlocked, isVisible = () => true,
   renderSessions, renderMessages, applyConversationChrome, setMessageStatus, recordControlEvent,
   drafts = createComposerDrafts(), onChange = () => {},
-  confirmReview = (message) => globalThis.confirm?.(message) === true,
+  confirmReview = confirmDialog,
 }) {
   const surfaces = [];
   let queue;
@@ -49,7 +50,12 @@ export function createComposerFeature({
       canDeleteAttachment: (file) => !drafts.contains(file) && !lifecycle.ownsAttachment(file) && !queue.ownsAttachment(file),
     });
     const notice = createComposerSubmissionNotice({ form: surfaceDom.composerForm, review: async (attempt) => {
-      if (!confirmReview("Check the conversation first: this message may already have been sent. Restore it for manual review? Sending it again may repeat its actions.")) return;
+      const draft = currentDraft();
+      const revision = draft.revision;
+      if (!await confirmReview("Check the conversation first: this message may already have been sent. Restore it for manual review? Sending it again may repeat its actions.",
+        { title: "Review paused message", confirmLabel: "Restore for review" })) return;
+      if (!visible() || currentDraft() !== draft || draft.revision !== revision) return;
+      if (!lifecycle.paused(draft.scope).includes(attempt)) return;
       try { await lifecycle.restoreForManualReview(attempt.id, queue.authorizeReview); }
       catch (error) { reportFailure(attempt.payload.scope, error.message); }
     }, recover: async (scope) => {
@@ -75,7 +81,8 @@ export function createComposerFeature({
     function send(action) {
       let draft = currentDraft();
       draft.text = surfaceDom.composerInput.value.trim();
-      const settings = getSettings();
+      const configured = getSettings();
+      const settings = { ...configured, ...(configured.reasoningPreference ? { reasoningPreference: { ...configured.reasoningPreference } } : {}) };
       if (!draft.scope.sessionId) { ensureBoundSession(); draft = currentDraft(); }
       const activeRequestId = allowsActiveRequest ? state.activeRequestId : "";
       return lifecycle.submit({ draft, action, settings,

package/dist/src/web-ui/app/controllers/composer-queue-controller.d.ts

@@ -22,7 +22,7 @@ export interface ComposerQueueControllerOptions {
   reportFailure(scope: ComposerScope, summary: string): void;
   reportRecovery?(scope: ComposerScope, summary: string): void;
   onChange?(): void;
-  confirmTakeover?(message: string): boolean;
+  confirmTakeover?(message: string, options?: { title: string; confirmLabel: string }): boolean | Promise<boolean>;
 }
 
 export interface ComposerQueueController {

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

@@ -1,3 +1,4 @@
+import { confirmDialog } from "../components/confirmation-dialog.js";
 import { ComposerSubmissionRefused, isDefiniteSubmissionRefusal } from "./composer-submission-lifecycle.js";
 
 const scopeKey = (scope) => JSON.stringify([scope.environmentId, scope.sessionId]);
@@ -11,7 +12,7 @@ function hasConversationQueueScope(scope) {
 export function createComposerQueueController({
   queue, drafts, lifecycle, getDraft, requests, getSettings,
   isCurrentScope, reportFailure, reportRecovery = () => {}, onChange = () => {},
-  confirmTakeover = (message) => globalThis.confirm?.(message) === true,
+  confirmTakeover = confirmDialog,
 }) {
   const processing = new Map();
   const bindings = new Map();
@@ -112,8 +113,13 @@ export function createComposerQueueController({
     }
     let claimed = await queue.claimBlockedRelease(scope, release.releaseToken);
     if (!claimed) {
-      const approved = confirmTakeover("This queued message may have been sent or may belong to another window. Close that window and check the conversation before taking ownership for manual review. Sending it again may repeat its actions. Continue?");
+      if (!isCurrentScope(scope)) return false;
+      const revision = draft.revision;
+      const approved = await confirmTakeover("This queued message may have been sent or may belong to another window. Close that window and check the conversation before taking ownership for manual review. Sending it again may repeat its actions. Continue?",
+        { title: "Review queued message", confirmLabel: "Take ownership" });
       if (!approved) return false;
+      if (!isCurrentScope(scope) || draft.revision !== revision) return false;
+      if (queue.getBlockedRelease(scope)?.releaseToken !== release.releaseToken) return false;
       claimed = await queue.claimBlockedRelease(scope, release.releaseToken, { takeover: true });
     }
     if (!claimed) throw new Error("This queued message changed before it could be recovered.");
@@ -168,7 +174,7 @@ export function createComposerQueueController({
     const item = released.item;
     const attempt = await lifecycle.submitCaptured({
       action: "send", payload: { scope, text: item.text, attachments: item.attachments, release: released },
-      settings: { agentMode: item.agentMode, toolPermissionMode: item.toolPermissionMode, modelPreference: item.modelPreference },
+      settings: { agentMode: item.agentMode, toolPermissionMode: item.toolPermissionMode, modelPreference: item.modelPreference, ...(item.reasoningPreference ? { reasoningPreference: item.reasoningPreference } : {}) },
       prepare: async (submission) => { await prepareManualSend(submission); requests.prepareView(submission); },
       execute: send, accepted: bindAccepted, prepareRestore,
     });

package/dist/src/web-ui/app/controllers/composer-submission-lifecycle.d.ts

@@ -2,7 +2,7 @@ import type { SessionComposerQueueItem, ReleasedSessionComposerQueueItem } from
 import type { ComposerAttachment, ComposerDraft, ComposerDraftSnapshot, ComposerDrafts, ComposerScope } from "./composer-drafts.js";
 
 export type ComposerSubmissionAction = "send" | "send_next" | "steer";
-export type ComposerSubmissionSettings = Pick<SessionComposerQueueItem, "agentMode" | "toolPermissionMode" | "modelPreference">;
+export type ComposerSubmissionSettings = Pick<SessionComposerQueueItem, "agentMode" | "toolPermissionMode" | "modelPreference" | "reasoningPreference">;
 export type ComposerSubmissionPhase = "preparing" | "sending" | "accepted" | "refused" | "uncertain" | "restored";
 
 export interface ComposerSubmissionAttempt<Settings = unknown, Result = unknown> {