@abot-ai/runtime 1.8.1 → 2.0.0

package/dist/src/web-ui/app/lib/role-delegation-event.d.ts

@@ -0,0 +1,18 @@
+export interface RoleDelegation {
+  id: string;
+  generation: string;
+  callerCallId: string;
+  callerRole: "supervisor";
+  childCallId: string;
+  childRole: "planner" | "worker" | "researcher" | "reviewer";
+  objective: string;
+}
+
+export declare function isRoleDelegationEvent(event: unknown): boolean;
+export declare function projectRoleDelegationEvent(
+  event: Record<string, unknown>,
+): RoleDelegation | null;
+export declare function hasRecordedRoleDelegation(
+  events: Record<string, unknown>[],
+  delegation: RoleDelegation,
+): boolean;

package/dist/src/web-ui/app/lib/role-delegation-event.js

@@ -0,0 +1,47 @@
+const DELEGATED_ROLES = new Set([
+  "planner", "worker", "researcher", "reviewer",
+]);
+
+export function isRoleDelegationEvent(event) {
+  return (event?.eventName || event?.name || event?.rawType || event?.type)
+    === "role.delegated";
+}
+
+function hasDelegationIdentity(value) {
+  if (typeof value !== "string") return false;
+  return value.trim().length > 0;
+}
+
+function hasDelegationObjective(value) {
+  if (typeof value !== "string") return false;
+  if (value.length > 8_192) return false;
+  return value.trim().length > 0;
+}
+
+/** Explicit committed delegation evidence, without inferred role or objective data. */
+export function projectRoleDelegationEvent(event) {
+  if (!isRoleDelegationEvent(event)) return null;
+  const source = event.roleDelegation || event;
+  if (source.callerRole !== "supervisor") return null;
+  if (!DELEGATED_ROLES.has(source.childRole)) return null;
+  if (!hasDelegationIdentity(event.requestId)) return null;
+  if (!hasDelegationIdentity(source.callerCallId)) return null;
+  if (!hasDelegationIdentity(source.childCallId)) return null;
+  if (!hasDelegationObjective(source.objective)) return null;
+  if (source.generation !== undefined && typeof source.generation !== "string")
+    return null;
+  const generation = source.generation || "";
+  return {
+    id: JSON.stringify([event.requestId, generation, source.childCallId]),
+    generation,
+    callerCallId: source.callerCallId,
+    callerRole: source.callerRole,
+    childCallId: source.childCallId,
+    childRole: source.childRole,
+    objective: source.objective,
+  };
+}
+
+export function hasRecordedRoleDelegation(events, delegation) {
+  return events.some((event) => event.roleDelegation?.id === delegation.id);
+}

package/dist/src/web-ui/app/lib/role-return-event.d.ts

@@ -0,0 +1,19 @@
+export interface RoleReturn {
+  id: string;
+  generation: string;
+  callerCallId: string;
+  callerRole: "supervisor";
+  childCallId: string;
+  childRole: "planner";
+  outcome: "completed" | "failed";
+  summary: string;
+}
+
+export declare function isRoleReturnEvent(event: unknown): boolean;
+export declare function projectRoleReturnEvent(
+  event: Record<string, unknown>,
+): RoleReturn | null;
+export declare function hasRecordedRoleReturn(
+  events: Record<string, unknown>[],
+  receipt: RoleReturn,
+): boolean;

package/dist/src/web-ui/app/lib/role-return-event.js

@@ -0,0 +1,36 @@
+export function isRoleReturnEvent(event) {
+  return (event?.eventName || event?.name || event?.rawType || event?.type)
+    === "role.returned";
+}
+
+function hasReturnIdentity(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+export function projectRoleReturnEvent(event) {
+  if (!isRoleReturnEvent(event)) return null;
+  const source = event.roleReturn || event;
+  if (source.callerRole !== "supervisor") return null;
+  if (source.childRole !== "planner") return null;
+  if (source.outcome !== "completed" && source.outcome !== "failed") return null;
+  if (!hasReturnIdentity(event.requestId)) return null;
+  if (!hasReturnIdentity(source.callerCallId)) return null;
+  if (!hasReturnIdentity(source.childCallId)) return null;
+  if (typeof source.summary !== "string" || !source.summary.trim()) return null;
+  if (source.generation !== undefined && typeof source.generation !== "string") return null;
+  const generation = source.generation || "";
+  return {
+    id: JSON.stringify([event.requestId, generation, source.childCallId]),
+    generation,
+    callerCallId: source.callerCallId,
+    callerRole: source.callerRole,
+    childCallId: source.childCallId,
+    childRole: source.childRole,
+    outcome: source.outcome,
+    summary: source.summary,
+  };
+}
+
+export function hasRecordedRoleReturn(events, receipt) {
+  return events.some((event) => event.roleReturn?.id === receipt.id);
+}

package/dist/src/web-ui/app/lib/session-composer-queue.d.ts

@@ -1,3 +1,5 @@
+import type { ModelReasoningPreference } from "../../../shared/model-reasoning.js";
+
 export interface SessionComposerQueueScope {
   environmentId: string;
   sessionId: string;
@@ -10,6 +12,7 @@ export interface SessionComposerQueueItem {
   waitForRequestId: string;
   text: string;
   attachments: SessionComposerAttachmentRef[];
+  reasoningPreference?: ModelReasoningPreference;
   agentMode: string;
   toolPermissionMode: string;
   modelPreference: SessionComposerModelPreference | null;
@@ -19,6 +22,7 @@ export interface SessionComposerQueueItemInput {
   waitForRequestId: string;
   text: string;
   attachments: SessionComposerAttachmentRef[];
+  reasoningPreference?: ModelReasoningPreference;
   agentMode: string;
   toolPermissionMode: string;
   modelPreference?: SessionComposerModelPreference | null;

package/dist/src/web-ui/app/lib/session-composer-queue.js

@@ -1,3 +1,4 @@
+import { isReasoningPreference } from "./reasoning-preference.js";
 import { hasValidQueueOwnership, canUpdateBlockedRelease, canBindBlockedRelease, createQueueOwnership } from "./session-composer-queue-ownership.js";
 
 export const SESSION_COMPOSER_QUEUE_STORAGE_KEY =
@@ -53,6 +54,8 @@ function isQueueItem(value) {
     value.attachments.every(isAttachmentRef) &&
     isNonEmptyString(value.agentMode) &&
     isNonEmptyString(value.toolPermissionMode) &&
+    (value.reasoningPreference === undefined || (isReasoningPreference(value.reasoningPreference)
+      && value.reasoningPreference.profileId === value.modelPreference?.profileId)) &&
     (value.modelPreference === null ||
       (isRecord(value.modelPreference) && isJsonValue(value.modelPreference))),
   );
@@ -114,6 +117,7 @@ function snapshotQueueItem(item) {
     agentMode: item?.agentMode,
     toolPermissionMode: item?.toolPermissionMode,
     modelPreference: item?.modelPreference ?? null,
+    ...(item?.reasoningPreference !== undefined ? { reasoningPreference: item.reasoningPreference } : {}),
   };
   if (!isQueueItem(snapshot)) {
     throw new TypeError("Invalid session composer queue item");

package/dist/src/web-ui/app/lib/session-project-groups.js

@@ -0,0 +1,28 @@
+export function sessionProjectId(session, deletedProjectIds = []) {
+  const projectId = session.projectId || session.project?.id;
+  if (deletedProjectIds.includes(projectId)) return undefined;
+  return projectId;
+}
+
+/** Group by actual project identity without changing session workspace bindings. */
+export function projectSessionDisplayGroups(projects, sessions, deletedProjectIds = []) {
+  const deletedProjects = new Set(deletedProjectIds);
+  const groups = new Map(projects.filter((project) => !deletedProjects.has(project.id))
+    .map((project) => [project.id, { ...project, sessions: [] }]));
+  const ordinary = [];
+  for (const session of sessions) {
+    const projectId = sessionProjectId(session);
+    const isOrdinarySession = !projectId || deletedProjects.has(projectId);
+    if (isOrdinarySession) {
+      ordinary.push(session);
+      continue;
+    }
+    const group = groups.get(projectId) ?? {
+      id: projectId, name: session.project?.name || "Project",
+      directory: session.project?.directory || "", sessions: [],
+    };
+    group.sessions.push(session);
+    groups.set(projectId, group);
+  }
+  return { groups: [...groups.values()], ordinary };
+}

package/dist/src/web-ui/app/lib/session-sidebar-order.js

@@ -1,15 +1,17 @@
-export function sessionSidebarGroup(session, pinnedSessionIds) {
+import { sessionProjectId } from "./session-project-groups.js";
+
+export function sessionSidebarGroup(session, pinnedSessionIds, deletedProjectIds = []) {
   if (pinnedSessionIds.includes(session.id)) return "pinned";
-  const projectId = session.projectId || session.project?.id;
+  const projectId = sessionProjectId(session, deletedProjectIds);
   if (projectId) return `project:${projectId}`;
   return "ordinary";
 }
 
-export function canReorderSidebarSessions(source, target, pinnedSessionIds) {
+export function canReorderSidebarSessions(source, target, pinnedSessionIds, deletedProjectIds = []) {
   if (!source || !target) return false;
   if (source.id === target.id) return false;
-  return sessionSidebarGroup(source, pinnedSessionIds) ===
-    sessionSidebarGroup(target, pinnedSessionIds);
+  return sessionSidebarGroup(source, pinnedSessionIds, deletedProjectIds) ===
+    sessionSidebarGroup(target, pinnedSessionIds, deletedProjectIds);
 }
 
 export function orderSidebarSessions(sessions, pinnedSessionIds, orderedSessionIds) {

package/dist/src/web-ui/app/lib/tool-activity-event.d.ts

@@ -3,6 +3,7 @@ import type { ToolActivityField } from "./tool-activity-model.js";
 
 export interface ToolActivityEvent {
   fileReference?: ConversationFileReference;
+  skillRead?: true;
   name: string;
   tool: string;
   activityTitle?: string;

package/dist/src/web-ui/app/lib/tool-activity-event.js

@@ -2,6 +2,7 @@ import { getRecord, titleCaseEventValue } from "./event-presentation.js";
 import { projectConversationFileReference } from "./conversation-file-reference.js";
 import { computerInputFields } from "./tool-computer-activity-fields.js";
 import { automationActivityFields } from "./tool-automation-activity-fields.js";
+import { skillActivityFields } from "./tool-skill-activity-fields.js";
 import {
   processInputFields,
   processResultFields,
@@ -193,10 +194,12 @@ export function projectToolActivityEvent(message) {
   const params = getRecord(meta.params);
   const inputMeta = { ...meta, params };
   const fileReference = projectConversationFileReference(message);
-  const automation = automationActivityFields(meta, tool);
+  const skill = skillActivityFields(meta, tool, completed, message.ok);
+  const activity = skill ?? automationActivityFields(meta, tool);
   return {
     ...(fileReference ? { fileReference } : {}),
-    ...(automation?.activityTitle ? { activityTitle: automation.activityTitle } : {}),
+    ...(skill?.skillRead ? { skillRead: true } : {}),
+    ...(activity?.activityTitle ? { activityTitle: activity.activityTitle } : {}),
     name,
     tool,
     executionId: boundedText(message.executionId, 200).trim(),
@@ -206,7 +209,7 @@ export function projectToolActivityEvent(message) {
     beforeExternalExecution: message.stage === "before_external_execution",
     intent: boundedText(message.intent || meta.intent),
     target: boundedText(
-      automation?.target ||
+      activity?.target ||
         meta.source ||
         meta.displayTarget ||
         meta.path ||
@@ -215,10 +218,10 @@ export function projectToolActivityEvent(message) {
         meta.id ||
         meta.savedId,
     ),
-    sent: [...inputFields(inputMeta, completed, tool), ...(automation?.sent || [])],
+    sent: [...inputFields(inputMeta, completed, tool), ...(activity?.sent || [])],
     received: terminal ? resultFields(meta, tool, message.ok) : [],
-    preview: terminal ? boundedText(meta.outputPreview, 1_200) : "",
-    previewTruncated: terminal && hasClippedPreview(meta),
+    preview: terminal && !skill ? boundedText(meta.outputPreview, 1_200) : "",
+    previewTruncated: terminal && !skill && hasClippedPreview(meta),
     partial: terminal && hasPartialSource(meta),
     outcome: completedOutcome(meta),
     ok: typeof message.ok === "boolean" ? message.ok : null,

package/dist/src/web-ui/app/lib/tool-activity-model.d.ts

@@ -6,6 +6,7 @@ export interface ToolActivityField {
 
 export interface ConversationToolAction {
   fileReference?: ConversationFileReference;
+  skillRead?: true;
   id: string;
   tool: string;
   executorRole?: string;

package/dist/src/web-ui/app/lib/tool-activity-model.js

@@ -95,6 +95,7 @@ function applyPhase(action, evidence) {
 
 function applyEvidence(action, evidence) {
   if (evidence.activityTitle) action.title = evidence.activityTitle;
+  if (evidence.skillRead) action.skillRead = true;
   if (isSettledToolEvent(evidence)) delete action.fileReference;
   if (evidence.fileReference) action.fileReference = evidence.fileReference;
   if (evidence.executorRole) action.executorRole = evidence.executorRole;

package/dist/src/web-ui/app/lib/tool-approval-rejection-drafts.js

@@ -0,0 +1,45 @@
+/** Window-local drafts belong to the exact action, never to a conversation outbox. */
+export function approvalRejectionIdentity(approval) {
+  return JSON.stringify([
+    approval.environmentId,
+    approval.sessionId,
+    approval.requestId,
+    approval.approvalId,
+    approval.generation,
+    approval.waitId,
+  ]);
+}
+
+export function createApprovalRejectionDrafts() {
+  const drafts = new Map();
+
+  function get(approval) {
+    const key = approvalRejectionIdentity(approval);
+    if (!drafts.has(key)) drafts.set(key, { text: "", expanded: false });
+    return drafts.get(key);
+  }
+
+  function promoteBoundApprovalDraft(approval) {
+    const key = approvalRejectionIdentity(approval);
+    if (drafts.has(key)) return;
+    const liveKey = approvalRejectionIdentity({
+      ...approval,
+      generation: undefined,
+      waitId: undefined,
+    });
+    const liveDraft = drafts.get(liveKey);
+    if (!liveDraft) return;
+    drafts.set(key, liveDraft);
+    drafts.delete(liveKey);
+  }
+
+  function retain(approvals) {
+    for (const approval of approvals) promoteBoundApprovalDraft(approval);
+    const pending = new Set(approvals.map(approvalRejectionIdentity));
+    for (const key of drafts.keys()) {
+      if (!pending.has(key)) drafts.delete(key);
+    }
+  }
+
+  return { get, retain, clear: () => drafts.clear() };
+}

package/dist/src/web-ui/app/lib/tool-skill-activity-fields.js

@@ -0,0 +1,50 @@
+const ACTION_TITLES = Object.freeze({
+  list_skills: "List skills",
+  read_skill: "Read skill",
+  read_skills: "Read skills",
+  create_skill: "Create skill",
+  update_skill: "Edit skill",
+});
+
+function boundedSkillText(value, limit) {
+  if (typeof value !== "string") return "";
+  const text = value.trim();
+  if (text.length <= limit) return text;
+  return `${text.slice(0, limit - 1)}…`;
+}
+
+function isSkillReadAction(action) {
+  return action === "read_skill" || action === "read_skills";
+}
+
+function hasSuccessfulSkillResult(action, completed, ok) {
+  if (action === "list_skills" || !Object.hasOwn(ACTION_TITLES, action)) return false;
+  if (!completed) return false;
+  return ok === true;
+}
+
+/** Decode declared display metadata only; never inspect a Skill body or tool output. */
+export function skillActivityFields(meta, tool, completed, ok) {
+  if (tool !== "abot_skills") return null;
+  const action = boundedSkillText(meta.skillAction, 128);
+  const activityTitle = Object.hasOwn(ACTION_TITLES, action)
+    ? ACTION_TITLES[action]
+    : "";
+  const sent = [];
+  if (activityTitle) sent.push({ label: "Action", value: activityTitle });
+  if (action === "list_skills" || !activityTitle) return { activityTitle, target: "", sent };
+
+  const readAction = isSkillReadAction(action);
+  const referenceLimit = readAction ? 160 : 128;
+  const referenceLabel = readAction ? "Skill reference" : "Skill ID";
+  const skillId = action === "read_skills"
+    ? boundedSkillText(Array.isArray(meta.skillIds)
+      ? meta.skillIds.slice(0, 8).map((id) => boundedSkillText(id, referenceLimit)).filter(Boolean).join(", ")
+      : "", 160)
+    : boundedSkillText(meta.skillId, referenceLimit) || (completed && ok === true ? boundedSkillText(meta.savedSkillId, 128) : "");
+  const skillTitle = hasSuccessfulSkillResult(action, completed, ok)
+    ? boundedSkillText(meta.skillTitle, 160)
+    : "";
+  if (skillId) sent.push({ label: action === "read_skills" ? "Skill references" : referenceLabel, value: skillId });
+  return { activityTitle, target: skillTitle || boundedSkillText(meta.skillName, 160) || skillId, sent, skillRead: readAction };
+}

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

@@ -8,6 +8,7 @@ const WORKSPACE_PATHS = Object.freeze({
   automations: "/automations",
   learning: "/learning",
   memory: "/memory",
+  skills: "/skills",
   models: "/models",
   plugins: "/plugins",
   config: "/system",

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

@@ -17,8 +17,13 @@ export function createNotificationsFeature({ dom, state, client, shell, getEnvir
   let environmentRevision = 0;
   const homeEntry = createHomeNotificationsEntry({
     homePanel: dom.homeWorkspacePanel,
-    onOpen: () => {
-      if (!shell.activateWorkspace("notifications")) return;
+    onOpen: async () => {
+      const environment = getEnvironmentId();
+      const revision = environmentRevision;
+      const activate = await shell.prepareWorkspaceActivation("notifications");
+      if (!activate || revision !== environmentRevision) return;
+      if (environment !== getEnvironmentId()) return;
+      if (!activate()) return;
       controller.setFilter("unread");
     },
   });
@@ -53,14 +58,17 @@ export function createNotificationsFeature({ dom, state, client, shell, getEnvir
     if (!source) return;
     const environmentVersion = environmentRevision;
     const navigationVersion = shell.navigationRevision();
+    const navigationRequest = shell.navigationRequestRevision?.();
     await controller.markRead(item.id, true);
     if (!canOpenNotificationSource(item)) return;
     if (environmentVersion !== environmentRevision) return;
     if (navigationVersion !== shell.navigationRevision()) return;
+    if (navigationRequest !== shell.navigationRequestRevision?.()) return;
     if (await openCompanionSource(item, source)) return;
     if (!canOpenNotificationSource(item)) return;
     if (environmentVersion !== environmentRevision) return;
     if (navigationVersion !== shell.navigationRevision()) return;
+    if (navigationRequest !== shell.navigationRequestRevision?.()) return;
     window.location.assign(source);
   }
   function refreshAvailability() {

package/dist/src/web-ui/app/passive-learning-feature.js

@@ -47,8 +47,8 @@ export function createPassiveLearningFeature({
   home = createPassiveLearningHome({
     actions,
     openLearning,
-    openSetup: () => {
-      if (openLearning() === false) return;
+    openSetup: async () => {
+      if (await openLearning() === false) return;
       if (learningRoot) selectLearningView(learningRoot, "settings");
     },
   });

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

@@ -6,6 +6,8 @@ import { renderProjectSessionGroups } from "./components/project-session-groups.
 export function createProjectsFeature({
   dom,
   state,
+  preferences,
+  confirmAction,
   client,
   shell,
   selectedEnvironmentId,
@@ -23,6 +25,7 @@ export function createProjectsFeature({
   const expandedProjectSessionIds = new Set();
   const controller = createProjectsController({
     client,
+    confirmAction,
     getEnvironmentId: selectedEnvironmentId,
     isRuntimeReady,
     getConversationRevision: () =>
@@ -76,21 +79,40 @@ export function createProjectsFeature({
 
   function syncProjectGroupEnvironment() {
     const environmentId = selectedEnvironmentId();
-    if (groupEnvironmentId === environmentId) return;
-    groupEnvironmentId = environmentId;
+    if (groupEnvironmentId !== environmentId) {
+      groupEnvironmentId = environmentId;
+      collapsedProjectIds.clear();
+      expandedProjectSessionIds.clear();
+    }
+    const saved = preferences?.loadCollapsedProjectIds?.(environmentId);
+    if (!saved) return;
     collapsedProjectIds.clear();
-    expandedProjectSessionIds.clear();
+    for (const projectId of saved) collapsedProjectIds.add(projectId);
   }
 
-  function rememberProjectGroupCollapse(projectId, collapsed) {
+  async function rememberProjectGroupCollapse(projectId, collapsed) {
     syncProjectGroupEnvironment();
     const isSearchingSessions = Boolean(String(state.sessionQuery ?? "").trim());
     if (isSearchingSessions) return;
-    if (collapsed) {
-      collapsedProjectIds.add(projectId);
-      return;
-    }
     collapsedProjectIds.delete(projectId);
+    if (collapsed) collapsedProjectIds.add(projectId);
+    try {
+      await preferences?.saveCollapsedProjectIds?.(groupEnvironmentId, [...collapsedProjectIds]);
+    } catch {
+      renderSessions();
+      shell.showToast("Could not save project visibility in ABot", "failed");
+    }
+  }
+
+  async function requestProjectDeletion(projectId, projectName) {
+    const environmentId = selectedEnvironmentId();
+    await controller.deleteProject(projectId, projectName);
+    if (selectedEnvironmentId() !== environmentId) return;
+    if (dom.sessionsPanel.hidden) return;
+    const documentRoot = dom.sessionsList.ownerDocument;
+    if (!documentRoot) return;
+    if (documentRoot.activeElement !== documentRoot.body) return;
+    dom.newProjectButton.focus();
   }
 
   function rememberProjectSessionExpansion(projectId, expanded) {
@@ -117,6 +139,7 @@ export function createProjectsFeature({
 
   return {
     load: controller.load,
+    getDeletedProjectIds: controller.getDeletedProjectIds,
     refreshAvailability,
     runtimeAvailabilityChanged() {
       refreshAvailability();
@@ -139,21 +162,28 @@ export function createProjectsFeature({
         root,
         sessions,
         createSessionItem,
+        newProjectButton: dom.newProjectButton,
         ...controller.snapshot(),
+        deletedProjectIds: controller.getDeletedProjectIds(),
         query: state.sessionQuery,
         collapsedProjectIds,
         expandedProjectSessionIds,
         onToggleGroup: rememberProjectGroupCollapse,
         onToggleProjectSessions: rememberProjectSessionExpansion,
         onNewConversation: controller.newConversation,
+        onDeleteProject: requestProjectDeletion,
         onRetry: () => void controller.load(),
       });
       return true;
     },
     bind() {
-      dom.newProjectButton.addEventListener("click", () => {
+      dom.newProjectButton.addEventListener("click", async () => {
         if (!canUseProjects()) return;
-        if (!shell.activateWorkspace("chat", { focus: false })) return;
+        const environmentId = selectedEnvironmentId();
+        const conversationRevision = JSON.stringify([state.currentSessionId, state.sessionViewVersion]);
+        if (!await shell.activateWorkspace("chat", { focus: false })) return;
+        if (environmentId !== selectedEnvironmentId() || !canUseProjects()) return;
+        if (conversationRevision !== JSON.stringify([state.currentSessionId, state.sessionViewVersion])) return;
         shell.setSessionsDrawerOpen(false);
         closeFilePreview();
         controller.openCreate();

package/dist/src/web-ui/app/runtime-onboarding-feature.js

@@ -37,6 +37,7 @@ export function createRuntimeOnboardingFeature({
     return createRuntimeSetupGuide({
       ...common,
       loadSetup: () => runtimeClient.getRuntimeSetup(),
+      inspectConnection: (input) => runtimeClient.inspectModelConnection(input, selectedEnvironmentId()),
       openConfiguration: () => dom.modelsWorkspaceButton?.click(),
       saveSetup: (input) => runtimeClient.saveRuntimeSetup(input),
       applySetup: () =>

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

@@ -19,6 +19,7 @@ export function createSchedulesFeature({
   let view;
   let active = false;
   let navigationRevision = 0;
+  let navigationRequest = 0;
   let runtimeReady = isRuntimeReady();
   const controller = createSchedulesController({
     client,
@@ -56,6 +57,7 @@ export function createSchedulesFeature({
     root: dom.schedulesRoot,
     actions: controller,
     getCurrentSessionId,
+    getEnvironmentId: selectedEnvironmentId,
     getAgentModes,
   });
   view.render(controller.snapshot());
@@ -78,7 +80,7 @@ export function createSchedulesFeature({
       if (destination !== "schedules") return true;
       return client.supportsSchedules();
     },
-    prepareLeave: view.prepareLeave,
+    prepareLeave: view.prepareEnvironmentChange,
     prepareEnvironmentChange: view.prepareEnvironmentChange,
     navigationRevision: () => navigationRevision,
     selectedJobId: () => controller.snapshot().selectedId,
@@ -88,18 +90,39 @@ export function createSchedulesFeature({
     },
     async openJob(jobId) {
       if (!client.supportsSchedules()) return false;
-      if (!view.prepareLeave()) return false;
-      if (!shell.activateWorkspace("schedules")) return false;
+      if (!await commitScheduleNavigation()) return false;
       await controller.openJob(jobId);
       return true;
     },
-    createJob(initialValues) {
+    async createJob(initialValues) {
       if (!client.supportsSchedules()) return;
-      if (!shell.activateWorkspace("schedules")) return;
+      if (!await commitScheduleNavigation()) return;
       void controller.openCreate(initialValues);
     },
   };
 
+  async function commitScheduleNavigation() {
+    const request = ++navigationRequest;
+    const environment = selectedEnvironmentId();
+    const revision = navigationRevision;
+    const workspaceRequest = shell.navigationRequestRevision?.();
+    const preparedDiscard = await view.prepareEnvironmentChange();
+    if (!preparedDiscard) return false;
+    if (!isCurrentScheduleNavigation()) return false;
+    if (workspaceRequest !== shell.navigationRequestRevision?.()) return false;
+    const activate = await shell.prepareWorkspaceActivation("schedules");
+    if (!activate || !isCurrentScheduleNavigation()) return false;
+    if (activate.canCommit?.() === false) return false;
+    if (!preparedDiscard()) return false;
+    return activate();
+    function isCurrentScheduleNavigation() {
+      if (request !== navigationRequest) return false;
+      if (environment !== selectedEnvironmentId()) return false;
+      if (revision !== navigationRevision) return false;
+      return preparedDiscard.canCommit() !== false;
+    }
+  }
+
   function isScheduleSurfaceReady() {
     if (documentRoot?.visibilityState === "hidden") return false;
     return isRuntimeReady();

package/dist/src/web-ui/app/services/client-preferences.d.ts

@@ -1,3 +1,4 @@
+import type { ConversationReasoningPreferences } from "./conversation-reasoning-preferences.js";
 import type { ToolPermissionMode } from "../lib/tool-permission-mode.js";
 
 type PreferenceMap = Record<string, unknown>;
@@ -15,11 +16,13 @@ type PreferenceStorage = {
   snapshot?(): { preferences: Record<string, string> } | null;
 };
 
-export declare function createClientPreferences(storage: PreferenceStorage): {
+export declare function createClientPreferences(storage: PreferenceStorage): ConversationReasoningPreferences & {
   subscribe(listener: () => void): (() => void) | undefined;
   flush(): Promise<void> | undefined;
   loadSessionSidebar(environmentId: string): SessionSidebarPreferences;
   saveSessionSidebar(environmentId: string, value: SessionSidebarPreferences): void | Promise<unknown>;
+  loadCollapsedProjectIds(environmentId: string): string[];
+  saveCollapsedProjectIds(environmentId: string, ids: readonly string[]): void | Promise<unknown>;
   loadPinnedSessions(): string[];
   savePinnedSessions(sessionIds: readonly string[]): void | Promise<unknown>;
   loadSessionModes(normalize: (value: unknown) => ToolPermissionMode): SessionModeMap;

package/dist/src/web-ui/app/services/client-preferences.js

@@ -1,3 +1,4 @@
+import { createConversationReasoningPreferences } from "./conversation-reasoning-preferences.js";
 import { createSessionSidebarPreferences } from "./session-sidebar-preferences.js";
 
 const storageKeys = {
@@ -39,6 +40,7 @@ export function createClientPreferences(storage) {
     subscribe: (listener) => storage.subscribe?.(listener),
     flush: () => storage.flush?.(),
     ...createSessionSidebarPreferences(storage),
+    ...createConversationReasoningPreferences(storage),
     loadPinnedSessions() {
       try {
         const acknowledged = storage.snapshot?.();