Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
198 KB
Raw Blame
/** @jsxImportSource react */
import { isProviderLocked, providerLockAnswered, providerLockMessage, useProviderLock } from "@/app/lib/provider-lock";
import { useEditorStore } from "../domains/session/editor/editor-store";
import { isElectronRuntime } from "../../app/utils";
import {
  useCallback,
  useEffect,
  useMemo,
  useReducer,
  useRef,
  useState,
} from "react";
import { useLocation, useNavigate } from "react-router";
import { Archive, ArchiveRestore } from "lucide-react";
import { toast } from "@/components/ui/sonner";
import { closeWorkspaceTerminals } from "../domains/session/terminal/terminal-runtime";
import type { ProviderListResponse } from "@opencode-ai/sdk/v2/client";

import { captureAnalyticsEvent, markTaskRunStart } from "@/app/lib/analytics";
import { noteNewBuildathonProject } from "@/app/lib/buildathon";
import { trackSessionActive, trackTaskStarted } from "@/app/lib/den-telemetry";
import { buildDiagnosticsBundleJson } from "@/app/lib/diagnostics-bundle";
import { downloadTextAsFile } from "@/app/lib/download";
import { canCreateWorkspaces } from "@/app/lib/workspace-creation-policy";
import { useQueryClient } from "@tanstack/react-query";
import { isPromptAdmissionUnknown, unwrap } from "@/app/lib/opencode";
import { createClientV2 } from "@/app/lib/opencode-v2-adapter";
import { abortSessionSafe, forkSession, listCommands, revertSession, setSessionArchived, shellInSession, unrevertSession } from "@/app/lib/opencode-session";
import { getNativeSessionMessages } from "@/app/lib/opencode-session-native";
import { copySessionId } from "@/react-app/domains/session/sidebar/copy-session-id";
import { useSessionManagementStore as sessionManagementStore } from "@/react-app/domains/session/sidebar/session-management-store";
import { getSessionDescendantIds } from "@/react-app/domains/session/sidebar/utils";
import {
  buildOmniRushWorkspaceBaseUrl,
  readOmniRushServerSettings,
} from "@/app/lib/omnirush-server";
import {
  workspaceServerId,
  type ResolvedWorkspaceEndpoint,
} from "@/app/lib/workspace-endpoint";
import { buildOmniRushEnvRuntimeKey } from "@/app/lib/omnirush-env-runtime";
import {
  getDesktopHomeDir,
  joinDesktopPath,
  revealDesktopItemInDir,
  pickDirectory,
  resolveWorkspaceListSelectedId,
  workspaceBootstrap,
  workspaceCreateRemote,
  workspaceForget,
  workspaceSetRuntimeActive,
  workspaceSetSelected,
  type OmniRushServerInfo,
  type WorkspaceInfo,
  type WorkspaceList,
} from "@/app/lib/desktop";
import type {
  ComposerAttachment,
  ComposerDraft,
  ModelOption,
  ModelRef,
  SlashCommandOption,
  WorkspacePreset,
  WorkspaceConnectionState,
  Client,
  ProviderListItem,
  PendingPermission,
  WorkspaceDisplay,
  WorkspaceSessionGroup,
} from "@/app/types";
import { buildFeedbackUrl } from "@/app/lib/feedback";
import { openFeedbackDialog, setFeedbackCurrentSession } from "@/app/lib/in-app-feedback";
import {
  getWorkspaceTaskLoadErrorDisplay,
  isDesktopRuntime,
  isSandboxWorkspace,
  normalizeDirectoryPath,
  normalizeSessionStatus,
  resolveModelDisplayName,
  safeStringify,
} from "@/app/utils";
import { t } from "@/i18n";
import {
  type RouteWorkspace,
  type RouteSession,
  describeRouteError,
  describeTaskCreateFailure,
  describeTaskCreateRetry,
  describeWorkspaceCreateError,
  createRouteSession,
  deleteRouteSession,
  removeRouteWorkspace,
  downloadWorkspaceJson,
  folderNameFromPath,
  getSessionStatus,
  isActiveSessionStatus,
  isTransientStartupError,
  mapDesktopWorkspace,
  mergeRouteWorkspaces,
  orderRouteWorkspaces,
  TASK_CREATE_RETRY_DELAYS_MS,
  toSessionGroups,
  withTransientEngineRetry,
  workspaceExportFilename,
  workspaceLabel,
} from "@/react-app/shell/route-workspaces";
import { reloadEngineWithDesktopFallback } from "@/react-app/shell/engine-reload-escalation";
import { useLocal } from "@/react-app/kernel/local-provider";
import { projectModelKey, rememberProjectModel, useProjectModelLocal } from "./project-model-prefs";
import { usePlatform } from "@/react-app/kernel/platform";
import {
  SessionPage,
  type OpenSessionTab,
  type SessionPagePaneRuntime,
} from "@/react-app/domains/session/chat/session-page";
import { AutomationsPage } from "@/react-app/domains/automations/automations-page";
import { isWorkModeShortcut, shownInMode, useWorkModeStore, useWorkState, WORK_CONNECTORS_ROUTE, WORK_HOME_ROUTE, WORK_KNOWLEDGE_ROUTE, WORK_PRESET, type AppMode } from "@/react-app/domains/work/work-mode";
import { WorkKnowledgePage } from "@/react-app/domains/work/knowledge-views";
import { WorkConnectorsPage, WorkHome, WorkModeToggle } from "@/react-app/domains/work/work-views";
import { AppsPage } from "@/react-app/domains/apps/apps-page";
import { DashboardPage } from "@/react-app/domains/dashboard/dashboard-page";
import { useDashboardDeploymentAvailability } from "@/react-app/domains/dashboard/dashboard-availability";
import { useAutomationDeploymentEnabled } from "@/react-app/domains/automations/automation-availability";
import { automationsStateChangedEvent } from "@/react-app/domains/automations/automation-events";
import type {
  NewTaskComposerContext,
  NewTaskComposerHandoff,
} from "@/react-app/domains/session/chat/new-task-composer";
import { isDesktopProviderBlocked } from "@/app/cloud/desktop-app-restrictions";
import { useCheckDesktopRestriction } from "@/react-app/domains/cloud/desktop-config-provider";
import { useRestrictionNotice } from "@/react-app/domains/cloud/restriction-notice-provider";
import { ReactSessionRuntime } from "@/react-app/domains/session/sync/runtime-sync";
import { useSessionActivityStore } from "@/react-app/domains/session/status/session-activity-store";
import { buildOmniRushSessionSystemContext } from "@/react-app/domains/session/sync/env-context";
import {
  applySessionRevert,
  applySessionUnrevert,
  permissionKey,
} from "@/react-app/domains/session/sync/session-sync";
import { draftToParts } from "@/react-app/domains/session/sync/draft-parts";
import { useSessionInteractions } from "@/react-app/domains/session/sync/use-session-interactions";
import { useModelBehavior } from "@/react-app/domains/session/surface/use-model-behavior";
import { getModelBehaviorSummary, nextModelBehaviorValue, previousModelBehaviorValue } from "@/app/lib/model-behavior";
import { computeModelAvailability, createUnavailableConfirmationGate, sessionModelFallback, type ModelAvailability } from "@/react-app/domains/session/surface/model-availability";
import { useSessionFindStore } from "@/react-app/domains/session/surface/find-store";
import { useModelPicker } from "@/react-app/domains/session/modals/use-model-picker";
import { getSessionModelSelection, resolveSendVariant, useSessionModelStore } from "@/react-app/domains/session/surface/session-model-store";
import { chatStarted, markChatStarted, useProjectModelModes } from "@/react-app/domains/session/surface/model-modes";
import { claudeModelName, decideModelPick, isClaudeModel, newChatPrompt, setUpClaudeSandbox, useClaudeModels, useClaudeModelSync, useModelPickGate } from "@/react-app/domains/session/surface/claude-models";
import { ConfirmModal } from "@/react-app/design-system/modals/confirm-modal";
import { useWorkbenchStore } from "@/react-app/domains/session/chat/workbench-store";
import { resolveWorkbenchPaneEndpoint } from "@/react-app/domains/session/chat/pane-runtime";
import {
  nextFavoriteModel,
  useModelCollectionsStore,
} from "@/react-app/domains/session/models/model-collections-store";
import { openModelPickerEvent, openProviderAuthEvent } from "@/react-app/shell/new-providers-listener";
import {
  composerAutoSendScopeKey,
  markComposerAutoSend,
} from "@/react-app/domains/session/surface/composer-auto-send";
import { sendWithRevertRollback } from "@/react-app/domains/session/surface/safe-edit-resend";
import { assertQueuedSendCurrent, getQueuedSendGeneration } from "@/react-app/domains/session/surface/queued-drain-machine";
import { CreateRemoteWorkspaceModal } from "@/react-app/domains/workspace/create-remote-workspace-modal";
import { CreateWorkspaceModal } from "@/react-app/domains/workspace/create-workspace-modal";
import type { CreateWorkspaceOptions } from "@/react-app/domains/workspace/types";
import { isCloudManagedProviderKey } from "@/react-app/domains/connections/provider-auth/cloud-provider-config";
import { assignedModelOptions } from "@/react-app/domains/connections/provider-auth/assigned-model-options";
import {
  filterEntitledModelOptions,
  resolveEntitledOrgDefaultModel,
  type ModelEntitlementOption,
} from "@/react-app/domains/connections/provider-auth/provider-policy";
import {
  isOrganizationModelsEmpty,
  shouldAutoOpenUnavailableModelPicker,
} from "@/react-app/domains/connections/provider-auth/managed-models-recovery";
import { useSessionProviderAuth } from "@/react-app/domains/connections/provider-auth/use-session-provider-auth";
import {
  disabledProvidersFromConfig,
  updateManagedDisabledProviders,
} from "@/react-app/domains/connections/managed-engine-config";
import { useMcpConnectedCount } from "@/react-app/domains/connections/use-mcp-connected-count";
import { useSessionMcpMaintenance } from "@/react-app/domains/connections/use-session-mcp-maintenance";
import { useCloudMcpSubmitReadiness } from "@/react-app/domains/connections/use-cloud-mcp-submit-readiness";
import {
  IDLE_CLOUD_MCP_SUBMISSION_GATE_STATE,
  type CloudMcpSubmissionResult,
} from "@/react-app/domains/connections/cloud-mcp-submit-readiness";
import { useRemoteAccessRestart } from "@/react-app/domains/workspace/remote-access-restart";
import { RenameWorkspaceModal } from "@/react-app/domains/workspace/rename-workspace-modal";
import { useRemoteWorkspaceConnectionEditor } from "@/react-app/domains/workspace/use-remote-workspace-connection-editor";
import { useDenAuth } from "@/react-app/domains/cloud/den-auth-provider";
import {
  hasOmniRushModelsAvailable,
  shouldShowOmniRushModelsSyncing,
} from "@/react-app/domains/cloud/omnirush-models-promo";
import {
  diagnoseRemoteWorkspaceTaskLoadFailure,
  getRemoteWorkspaceConnectionKey,
  testRemoteWorkspaceConnection,
} from "@/react-app/domains/workspace/remote-workspace-diagnostics";
import { useShareWorkspaceState } from "@/react-app/domains/workspace/share-workspace-state";
import { ModelPickerModal, MODEL_PICKER_UNAVAILABLE_SUBTITLE } from "@/react-app/domains/session/modals/model-picker-modal";
import { CommandPalette, type PaletteItem, type SessionGroupOption } from "./command-palette";
import { buildCommandPaletteSessions, buildCopySessionIdPaletteItem } from "./command-palette-sessions";
import { requestRenameSession } from "./session-actions-bus";
import type { ThinkingModeShortcutDirection } from "./thinking-mode-shortcut";
import { SessionSearchDialog } from "./session-search-dialog";
import type { SessionMessageFetcher } from "@/react-app/domains/session/search/session-search";
import { useBootState } from "./boot-state";
import {
  forgetWorkspaceMemory,
  readLastSessionFor,
  readWorkspaceProjectDimension,
  readWorkspaceOrderIds,
  writeActiveWorkspaceId,
  writeLastSessionFor,
  writeWorkspaceProjectDimension,
  writeWorkspaceOrderIds,
} from "./session-memory";
import {
  publishInspectorSlice,
  recordInspectorEvent,
} from "../../app/lib/app-inspector";
import {
  resolveSessionDraftScope,
  saveSessionDraft,
  sessionDraftScopeKey,
} from "@/react-app/domains/session/sync/draft-store";
import {
  claimComposerSessionDraftScope,
  persistableComposerDraftText,
  snapshotComposerSessionState,
  useComposerStateStore,
} from "@/react-app/domains/session/surface/composer-state-store";
import { useControlAction, type OmniRushControlAction } from "./control/control-provider";
import { useReactRenderWatchdog } from "./react-render-watchdog";
import { useBootOverlayVisible } from "./boot-state";

import {
  createDenClient,
  isDenOrgAdminRole,
  readDenSettings,
  type DenOrgRole,
} from "@/app/lib/den";
import { denSessionUpdatedEvent, denSettingsChangedEvent } from "@/app/lib/den-session-events";

import { filterProviderList } from "@/app/utils/providers";
import { ensureDesktopLocalOmniRushConnection } from "./desktop-local-omnirush";
import { resolveOmniRushConnection } from "./omnirush-connection";
import { useReloadCoordinator } from "./reload-coordinator";
import { useShellConfig } from "./shell-config";
import { useShellShortcuts } from "./use-shell-shortcuts";
import { useEngineReload } from "./use-engine-reload";
import { useSessionGroupSync } from "./use-session-group-sync";
import { useUiStateStore } from "./ui-state-store";
import { useWorkspaceRouteState } from "./use-workspace-route-state";
import { CloudWorkspaceBootTakeover, useCloudWorkspaceStatus } from "./cloud-workspace-overlay";
import {
  cloudWorkspaceStatusHasReadyContent,
  mapCloudWorkspaceMainContentDecision,
  shouldRefetchCloudWorkspaceOnReadyTransition,
} from "./cloud-workspace-status";
import { getReactQueryClient } from "@/react-app/infra/query-client";
import { useSessionControlActions } from "@/react-app/domains/session/control/session-control-actions";
import { openComposerConfigure, isLibraryAgent, type ComposerSettingsSection } from "@/react-app/domains/settings/library";
import {
  globalExtensionsRoute,
  legacySessionRoute,
  mergeWorkspaceRouteSession,
  automationsRoute,
  dashboardRoute,
  workspaceExtensionsRoute,
  workspaceSessionRoute,
  workspaceSettingsRoute,
  workspaceTasksRoute,
} from "./workspace-routes";
import { TasksBoardPage } from "@/react-app/domains/workspace/tasks/tasks-board-page";
import { runningTaskCount, useWorkspaceTasks, workspaceTasksQueryKey } from "@/react-app/domains/workspace/tasks/workspace-tasks-query";
import type { HomeViewContext } from "@/react-app/domains/session/home/home-recent";
import { WorkspaceProvider } from "./workspace-provider";
import type { OpenTarget } from "@/react-app/domains/session/artifacts/open-target";
import { SettingsSurface } from "./settings-route";
import { writeStoredDefaultModel } from "@/react-app/kernel/model-config";
import {
  ensureProviderListQuery,
  getConnectedProviderItems,
  refreshProviderListQueries,
  useProviderListQuery,
} from "@/react-app/infra/provider-list-query";

/**
 * Serialize an SDK error value into a string that parseSessionError can parse.
 * Preserves the original shape (name, data, message) as JSON when possible,
 * so the session surface can detect ProviderModelNotFoundError and offer
 * recovery actions like "Change model".
 */
function serializeSDKError(error: unknown): string {
  if (error instanceof Error) return error.message;
  if (typeof error === "string") return error;
  if (typeof error === "object" && error !== null) {
    try {
      return JSON.stringify(error);
    } catch {
      const msg = (error as Record<string, unknown>).message;
      return typeof msg === "string" ? msg : String(error);
    }
  }
  return String(error);
}

function describeTaskCreateError(error: unknown) {
  const message = describeRouteError(error);
  let serializedCode: unknown = null;
  try {
    const payload: unknown = JSON.parse(message);
    serializedCode = typeof payload === "object" && payload !== null
      ? Reflect.get(payload, "code")
      : null;
  } catch {
    // The normal error path is plain text, not a wire payload.
  }
  const directCode = typeof error === "object" && error !== null
    ? Reflect.get(error, "code")
    : null;
  const code = typeof directCode === "string" ? directCode : serializedCode;
  if (code === "opencode_unconfigured") {
    return "Choose a model for this workspace, then try again.";
  }
  const lower = message.toLowerCase();
  if (
    lower.includes("failed to fetch") ||
    lower.includes("connection") ||
    lower.includes("fetch failed") ||
    lower.includes("econnrefused") ||
    lower.includes("connection lost") ||
    lower.includes("internal_error") ||
    lower.includes("unexpected server error")
  ) {
    return "omnirush.ai is unavailable for this workspace. Retry once it restarts, or restart omnirush.ai if the problem continues.";
  }
  return message;
}

function providerListModelEntitlementOptions(
  providerList: ProviderListResponse | null | undefined,
): ModelEntitlementOption[] {
  return getConnectedProviderItems(providerList).flatMap((provider) =>
    Object.keys(provider.models ?? {}).map((modelID) => ({
      providerID: provider.id,
      modelID,
    })),
  );
}

function taskCreateUnavailableToastId(workspaceId: string) {
  return `opencode-unavailable:${workspaceId}`;
}

function focusPromptSoon() {
  if (typeof window === "undefined") return;
  const focus = () => window.dispatchEvent(new Event("omnirush:focusPrompt"));
  [0, 80, 240, 600].forEach((delay) => window.setTimeout(focus, delay));
}

const EVAL_UNAVAILABLE_PROVIDER_ID = "eval-unavailable-provider";

function nextEvalUnavailableModel(current: ModelRef | null | undefined) {
  return {
    providerID: EVAL_UNAVAILABLE_PROVIDER_ID,
    modelID: current?.providerID === EVAL_UNAVAILABLE_PROVIDER_ID && current.modelID === "eval-unavailable-model-a"
      ? "eval-unavailable-model-b"
      : "eval-unavailable-model-a",
  } satisfies ModelRef;
}

function singlePickedDirectory(selection: string | string[] | null) {
  return typeof selection === "string"
    ? selection
    : Array.isArray(selection)
      ? selection[0] ?? null
      : null;
}

function focusedWorkbenchPaneOwner() {
  const workbench = useWorkbenchStore.getState();
  const focused = workbench.focusedPane === "secondary" ? workbench.secondary : workbench.primary;
  return focused
    ? JSON.stringify([workbench.focusedPane, focused.workspaceId, focused.sessionId])
    : null;
}

export function SessionRoute() {
  const navigate = useNavigate();
  const location = useLocation();
  const queryClient = useQueryClient();
  const appsRouteActive = /^(?:\/apps|\/dashboard\/apps)(?:\/|$)/.test(location.pathname);
  const automationsRouteRequested = /^\/automations(?:\/|$)/.test(location.pathname);
  const dashboardRouteRequested = /^\/dashboard(?:\/|$)/.test(location.pathname);
  const tasksRouteActive = /^\/workspace\/[^/]+\/tasks(?:\/|$)/.test(location.pathname);
  // Work mode's home and Connectors page (domains/work); hidden unless the server turns Work on.
  const workRouteRequested = /^\/work(?:\/|$)/.test(location.pathname);
  const {
    enabled: mcpAppsDashboardEnabled,
    loading: dashboardAvailabilityLoading,
  } = useDashboardDeploymentAvailability();
  const dashboardRouteActive = mcpAppsDashboardEnabled && dashboardRouteRequested;
  const dashboardWorkspaceRoute = dashboardRouteRequested
    && (dashboardAvailabilityLoading || mcpAppsDashboardEnabled);
  const platform = usePlatform();
  const toggleSidebar = useUiStateStore((state) => state.toggleSidebar);
  const denAuth = useDenAuth();
  const { config: shellConfig } = useShellConfig();
  const appLocal = useLocal();
  const automationDeploymentEnabled = useAutomationDeploymentEnabled();
  // Desktop and Web share one Automations surface; the runtime only decides
  // the placement of what each creates. Den's deployment flag stays the gate.
  const automationsEnabled = automationDeploymentEnabled;
  const automationsRouteActive = automationsEnabled && automationsRouteRequested;
  const denSettings = readDenSettings();
  const sessionDraftScope = resolveSessionDraftScope({
    hasCloudCredential: Boolean(denSettings.authToken?.trim()),
    verifiedIdentity: denAuth.verifiedIdentity,
  });
  const [automationsSupported, setAutomationsSupported] = useState(false);
  const [automationsNeedAttention, setAutomationsNeedAttention] = useState(false);
  useEffect(() => {
    if (!automationsRouteRequested || automationsEnabled) return;
    navigate("/", { replace: true });
  }, [automationsEnabled, automationsRouteRequested, navigate]);
  useEffect(() => {
    if (!dashboardRouteRequested || dashboardAvailabilityLoading || mcpAppsDashboardEnabled) return;
    navigate("/", { replace: true });
  }, [dashboardAvailabilityLoading, dashboardRouteRequested, mcpAppsDashboardEnabled, navigate]);
  useEffect(() => {
    const authToken = denSettings.authToken?.trim();
    const organizationId = denSettings.activeOrgId?.trim();
    if (!automationsEnabled || !denAuth.isSignedIn || !authToken || !organizationId) {
      setAutomationsSupported(false);
      setAutomationsNeedAttention(false);
      return;
    }
    let cancelled = false;
    const client = createDenClient({ baseUrl: denSettings.baseUrl, token: authToken });
    const refreshAutomationState = () => {
      void client.listAutomations(organizationId, { limit: 100 })
        .then((result) => {
          if (cancelled) return;
          setAutomationsSupported(true);
          setAutomationsNeedAttention(result.items.some((item) => item.automation.state === "needs_attention"));
        })
        .catch(() => {
          if (cancelled) return;
          setAutomationsSupported(false);
          setAutomationsNeedAttention(false);
        });
    };
    refreshAutomationState();
    const interval = window.setInterval(refreshAutomationState, 5 * 60_000);
    window.addEventListener(automationsStateChangedEvent, refreshAutomationState);
    return () => {
      cancelled = true;
      window.clearInterval(interval);
      window.removeEventListener(automationsStateChangedEvent, refreshAutomationState);
    };
  }, [
    automationsEnabled,
    denAuth.isSignedIn,
    denAuth.status,
    denSettings.activeOrgId,
    denSettings.authToken,
    denSettings.baseUrl,
  ]);
  const automationsNavigationAvailable = automationsEnabled && automationsSupported;
  const reloadCoordinator = useReloadCoordinator();
  const checkDesktopRestriction = useCheckDesktopRestriction();
  const restrictionNotice = useRestrictionNotice();
  const [activeOrganizationRole, setActiveOrganizationRole] = useState<DenOrgRole | null>(null);
  const [omnirushServerHostInfoState, setOmniRushServerHostInfoState] = useState<OmniRushServerInfo | null>(null);
  const [omnirushServerSettingsVersion, setOmniRushServerSettingsVersion] = useState(0);

  const [developerMode, setDeveloperMode] = useState(() => {
    if (typeof window === "undefined") return false;
    return window.localStorage.getItem("omnirush.developerMode") === "1";
  });
  const {
    navigateToWorkspaceSession,
    routeWorkspaceId,
    selectedSessionId,
    loading,
    effectiveLoading,
    client,
    baseUrl,
    token,
    workspaces,
    setWorkspaces,
    workspacesRef,
    workspaceOrderIds,
    setWorkspaceOrderIds,
    workspaceOrderIdsRef,
    sessionsByWorkspaceId,
    setSessionsByWorkspaceId,
    sessionsByWorkspaceIdRef,
    errorsByWorkspaceId,
    setErrorsByWorkspaceId,
    sessionListErrorsByWorkspaceId,
    workspaceConnectionOverrides,
    routeError,
    setRouteError,
    legacySelectedWorkspaceId,
    setLegacySelectedWorkspaceId,
    retryingWorkspaceIds,
    setRetryingWorkspaceIds,
    startupRetryTimerRef,
    selectedWorkspaceId,
    selectedWorkspace,
    selectedWorkspaceRoot,
    selectedWorkspaceEndpoint,
    selectedWorkspaceServerToken,
    opencodeBaseUrl,
    opencodeClient,
    selectedWorkspaceIsLoading,
    selectedWorkspaceError,
    routeNotFoundMessage,
    endpointForWorkspace,
    refreshRouteState,
    reloadWorkspaceSessions,
    retryWorkspaceSessions,
    rememberPendingCreatedSession,
    handleRuntimeSessionCreated,
    handleRuntimeSessionUpdated,
    handleRuntimeSessionDeleted,
    forgetDeletedSession,
    forgetMissingSession,
    handleRemoteWorkspaceConnectionSaved,
    runRemoteWorkspaceConnectionCheck,
  } = useWorkspaceRouteState({
    developerMode,
    workspaceRoute: workRouteRequested ? "work" : tasksRouteActive ? "tasks" : appsRouteActive ? "apps" : automationsRouteActive ? "automations" : dashboardWorkspaceRoute ? "dashboard" : "session",
    onServerSettingsChanged: () => setOmniRushServerSettingsVersion((value) => value + 1),
    onHostInfo: setOmniRushServerHostInfoState,
  });
  // Model picks here are the open project's own (project-model-prefs.ts); Settings keeps the app default.
  const local = useProjectModelLocal(appLocal, selectedWorkspaceId);
  // Work mode: Code (today's app) or Work (business chats in the app-managed Work workspace). The mode
  // follows the route; the last one picked is remembered and reopened at start.
  const workState = useWorkState(client ?? null);
  const workEnabled = workState.data?.enabled === true;
  const storedAppMode = useWorkModeStore((state) => state.mode);
  const workWorkspace = workspaces.find((workspace) => workspace.preset === WORK_PRESET && workspace.workspaceType !== "remote") ?? null;
  const workChatActive = workEnabled && Boolean(selectedWorkspace && selectedWorkspace.preset === WORK_PRESET) && !workRouteRequested;
  const workRouteActive = workEnabled && workRouteRequested;
  const appMode: AppMode = workRouteActive || workChatActive ? "work" : "code";
  const appModeRestored = useRef(false);
  useEffect(() => {
    if (workState.isPending) return;
    if (workRouteRequested && !workEnabled) {
      navigate("/session", { replace: true });
      return;
    }
    // Work off: its workspace is no project; leave it for a Code one (never open it with the IDE).
    if (!workEnabled && selectedWorkspace?.preset === WORK_PRESET) {
      const codeWorkspace = workspaces.find((workspace) => workspace.preset !== WORK_PRESET && !workspace.task);
      if (codeWorkspace) navigateToWorkspaceSession(codeWorkspace.id, readLastSessionFor(codeWorkspace.id));
      else navigate("/session", { replace: true });
      return;
    }
    if (appModeRestored.current || !workEnabled) return;
    appModeRestored.current = true;
    if (storedAppMode === "work" && appMode === "code" && !routeWorkspaceId) navigate(WORK_HOME_ROUTE, { replace: true });
  }, [appMode, navigate, navigateToWorkspaceSession, routeWorkspaceId, selectedWorkspace?.preset, storedAppMode, workEnabled, workRouteRequested, workState.isPending, workspaces]);
  // The Work workspace is made on the first visit to Work (the server picks its folder).
  const workWorkspaceRequested = useRef(false);
  useEffect(() => {
    if (!workRouteActive || workWorkspace || !client || workWorkspaceRequested.current) return;
    workWorkspaceRequested.current = true;
    void client.ensureWorkWorkspace()
      .then(() => refreshRouteState())
      .catch((error: unknown) => {
        workWorkspaceRequested.current = false;
        toast.error(error instanceof Error ? error.message : "Work could not be set up.");
      });
  }, [client, refreshRouteState, workRouteActive, workWorkspace]);
  const switchAppMode = useCallback((mode: AppMode) => {
    useWorkModeStore.getState().setMode(mode);
    if (mode === "work") {
      navigate(WORK_HOME_ROUTE);
      return;
    }
    const codeWorkspace = workspaces.find((workspace) => workspace.preset !== WORK_PRESET && !workspace.task);
    if (codeWorkspace) navigateToWorkspaceSession(codeWorkspace.id, readLastSessionFor(codeWorkspace.id));
    else navigate("/session");
  }, [navigate, navigateToWorkspaceSession, workspaces]);
  useEffect(() => {
    if (!workEnabled) return;
    const mac = typeof navigator !== "undefined" && /Mac/i.test(navigator.platform);
    const handler = (event: KeyboardEvent) => {
      if (!isWorkModeShortcut(event, mac)) return;
      event.preventDefault();
      switchAppMode(appMode === "work" ? "code" : "work");
    };
    window.addEventListener("keydown", handler);
    return () => window.removeEventListener("keydown", handler);
  }, [appMode, switchAppMode, workEnabled]);
  // "Send feedback" from a menu that does not know the open session (Help menu, sidebar).
  useEffect(() => {
    setFeedbackCurrentSession(selectedSessionId ?? null);
    return () => setFeedbackCurrentSession(null);
  }, [selectedSessionId]);
  const routeNavigationRef = useRef({ locationKey: location.key, generation: 0 });
  if (routeNavigationRef.current.locationKey !== location.key) {
    routeNavigationRef.current = {
      locationKey: location.key,
      generation: routeNavigationRef.current.generation + 1,
    };
  }
  const selectedConversationRef = useRef({
    workspaceId: selectedWorkspaceId,
    sessionId: selectedSessionId,
    draftScope: sessionDraftScope,
    location: `${location.pathname}${location.search}`,
    locationKey: location.key,
    navigationGeneration: routeNavigationRef.current.generation,
  });
  selectedConversationRef.current = {
    workspaceId: selectedWorkspaceId,
    sessionId: selectedSessionId,
    draftScope: sessionDraftScope,
    location: `${location.pathname}${location.search}`,
    locationKey: location.key,
    navigationGeneration: routeNavigationRef.current.generation,
  };
  // Archiving is the app's own flag on 2.x (the server keeps it): always available.
  const archiveDisabledReason: string | undefined = undefined;
  // The dashboard is user-scoped while MCP servers are workspace-scoped: the
  // selected workspace's runtime is primary, and every other available one is
  // a per-tile fallback so tiles keep working when the selected workspace does
  // not configure their server.
  const dashboardEndpoints = useMemo(() => {
    if (!dashboardRouteActive) return [];
    const endpoints: ResolvedWorkspaceEndpoint[] = [];
    if (selectedWorkspaceEndpoint) endpoints.push(selectedWorkspaceEndpoint);
    for (const workspace of workspaces) {
      const endpoint = endpointForWorkspace(workspace);
      if (endpoint && !endpoints.some((existing) => existing.workspaceId === endpoint.workspaceId)) {
        endpoints.push(endpoint);
      }
    }
    return endpoints;
  }, [dashboardRouteActive, endpointForWorkspace, selectedWorkspaceEndpoint, workspaces]);
  const dashboardEndpoint = dashboardEndpoints[0] ?? null;
  const dashboardFallbackEndpoints = useMemo(
    () => dashboardEndpoints.slice(1).map((endpoint) => ({
      client: endpoint.client,
      workspaceId: endpoint.workspaceId,
    })),
    [dashboardEndpoints],
  );
  const cloudWorkspace = useCloudWorkspaceStatus();
  const bootOverlayVisible = useBootOverlayVisible();
  const previousCloudWorkspaceStatusRef = useRef<typeof cloudWorkspace.viewModel.variant | null>(null);
  useEffect(() => {
    const previousStatus = previousCloudWorkspaceStatusRef.current;
    previousCloudWorkspaceStatusRef.current = cloudWorkspace.viewModel.variant;
    if (!shouldRefetchCloudWorkspaceOnReadyTransition({
      previousStatus,
      nextStatus: cloudWorkspace.viewModel.variant,
      gatewayMode: cloudWorkspace.gatewayMode && cloudWorkspace.visible,
    })) return;
    void refreshRouteState({ supersede: true });
  }, [cloudWorkspace.gatewayMode, cloudWorkspace.viewModel.variant, cloudWorkspace.visible, refreshRouteState]);
  const cloudMcpProviderModel = useMemo(() => local.prefs.defaultModel
    ? {
        provider: local.prefs.defaultModel.providerID,
        model: local.prefs.defaultModel.modelID,
      }
    : undefined, [local.prefs.defaultModel?.modelID, local.prefs.defaultModel?.providerID]);
  const sessionMcpMaintenance = useSessionMcpMaintenance({
    enabled: false,
    cloudSignedIn: denAuth.isSignedIn,
    client: selectedWorkspaceEndpoint?.client ?? null,
    workspaceId: selectedWorkspaceEndpoint?.workspaceId ?? null,
    opencodeClient,
    directory: selectedWorkspaceRoot,
    engineReloadBusy: reloadCoordinator.reloadBusy,
    providerModel: cloudMcpProviderModel,
  });
  const {
    state: cloudMcpSubmissionState,
    submit: submitWithCloudMcpReadiness,
    clearFailure: clearCloudMcpSubmissionFailure,
  } = useCloudMcpSubmitReadiness({
    enabled: false,
    cloudAuthStatus: denAuth.status,
    client: selectedWorkspaceEndpoint?.client ?? null,
    workspaceId: selectedWorkspaceEndpoint?.workspaceId ?? null,
    providerModel: cloudMcpProviderModel,
  });
  // Agent selection is persisted in local prefs (like the model variant) so
  // it survives reloads instead of silently falling back to "build" (#2101).
  const selectedAgent = local.prefs.selectedAgent;
  const setSelectedAgent = useCallback(
    (agent: string | null) => {
      local.setPrefs((previous) => ({ ...previous, selectedAgent: agent }));
    },
    [local.setPrefs],
  );
  // One-way latch for "a refreshRouteState is currently running"; prevents
  // overlapping route refreshes from queueing up when the user clicks fast.
  const [createWorkspaceOpen, setCreateWorkspaceOpen] = useState(false);
  const [createWorkspaceBusy, setCreateWorkspaceBusy] = useState(false);
  const [createWorkspaceError, setCreateWorkspaceError] = useState<string | null>(null);
  const [createWorkspaceRemoteBusy, setCreateWorkspaceRemoteBusy] = useState(false);
  const [createWorkspaceRemoteError, setCreateWorkspaceRemoteError] = useState<string | null>(null);
  const [renameWorkspaceId, setRenameWorkspaceId] = useState<string | null>(null);
  const [renameWorkspaceTitle, setRenameWorkspaceTitle] = useState("");
  const [renameWorkspaceBusy, setRenameWorkspaceBusy] = useState(false);
  const [paletteAccessibleTargets, setPaletteAccessibleTargets] = useState<OpenTarget[]>([]);
  const [providers, setProviders] = useState<ProviderListItem[]>([]);
  const [providerDefaults, setProviderDefaults] = useState<Record<string, string>>({});
  const [providerConnectedIds, setProviderConnectedIds] = useState<string[]>([]);
  const [disabledProviderIds, setDisabledProviderIds] = useState<string[]>([]);
  // Bump to re-filter provider list when den session changes (sign-in/out)
  const [denSessionVersion, setDenSessionVersion] = useState(0);
  useEffect(() => {
    const handler = () => setDenSessionVersion((v) => v + 1);
    window.addEventListener(denSessionUpdatedEvent, handler);
    window.addEventListener(denSettingsChangedEvent, handler);
    return () => {
      window.removeEventListener(denSessionUpdatedEvent, handler);
      window.removeEventListener(denSettingsChangedEvent, handler);
    };
  }, []);

  // Provider IDs that were just added — used to highlight them as
  useEffect(() => {
    setPaletteAccessibleTargets([]);
  }, [selectedSessionId, selectedWorkspaceId]);

  // Provider catalog cache. Used to compute the reasoning/thinking variant
  // options for whichever model is currently selected so the composer's
  // behavior pill actually shows its options (bug: was empty before).

  const omnirushServerSettings = useMemo(
    () => readOmniRushServerSettings(),
    [omnirushServerSettingsVersion],
  );

  const activeReloadBlockingSessions = useMemo(
    () =>
      Object.values(sessionsByWorkspaceId)
        .flat()
        .flatMap((session) => {
          if (!isActiveSessionStatus(getSessionStatus(session))) return [];
          const id = String(session?.id ?? "");
          if (!id) return [];
          return [{
            id,
            title:
              String(session?.title ?? session?.slug ?? session?.id ?? "").trim() ||
              t("session.untitled"),
          }];
        }),
    [sessionsByWorkspaceId],
  );
  const selectedInteractionSessionIds = useMemo(() => {
    const selected = selectedSessionId?.trim();
    if (!selected) return [];
    const sessions = sessionsByWorkspaceId[selectedWorkspaceId] ?? [];
    return [selected, ...getSessionDescendantIds(sessions, selected)];
  }, [selectedSessionId, selectedWorkspaceId, sessionsByWorkspaceId]);
  const activeSelectedWorkspaceSessionIds = useMemo(
    () => Array.from(new Set([
      ...selectedInteractionSessionIds,
      ...(sessionsByWorkspaceId[selectedWorkspaceId] ?? []).flatMap((session) => {
        if (!isActiveSessionStatus(getSessionStatus(session))) return [];
        const id = String(session?.id ?? "").trim();
        return id ? [id] : [];
      }),
    ])),
    [selectedInteractionSessionIds, selectedWorkspaceId, sessionsByWorkspaceId],
  );
  const remoteAccessRestart = useRemoteAccessRestart({
    isEnabled: () => omnirushServerSettings.remoteAccessEnabled === true,
    onHostInfo: setOmniRushServerHostInfoState,
    onSettingsChanged: () => setOmniRushServerSettingsVersion((value) => value + 1),
  });

  const { engineReloadVersion, routeEngineInfo, reloadWorkspaceEngineFromUi } = useEngineReload({
    client,
    workspaceId: selectedWorkspaceId,
    workspace: selectedWorkspace,
    endpointForWorkspace,
    activeReloadBlockingSessions,
    onError: setRouteError,
    refreshRouteState,
  });

  const environmentRuntimeKey = useMemo(
    () => buildOmniRushEnvRuntimeKey({
      baseUrl: client?.baseUrl ?? null,
      pid: omnirushServerHostInfoState?.pid ?? null,
      port: omnirushServerHostInfoState?.port ?? null,
    }),
    [client?.baseUrl, omnirushServerHostInfoState?.pid, omnirushServerHostInfoState?.port],
  );

  const handleApplyEnvironmentChanges = useCallback(async () => {
    if (!isDesktopRuntime()) {
      throw new Error(t("settings.environment.apply_unavailable"));
    }
    if (activeReloadBlockingSessions.length > 0) {
      throw new Error(t("settings.environment.apply_blocked_active_tasks"));
    }
    if (!selectedWorkspaceRoot) {
      throw new Error(t("settings.environment.apply_no_local_workspace"));
    }
    const reloaded = await reloadWorkspaceEngineFromUi();
    if (!reloaded) {
      throw new Error(t("app.error_connect_first"));
    }
  }, [activeReloadBlockingSessions.length, reloadWorkspaceEngineFromUi, selectedWorkspaceRoot]);

  const shareWorkspaceState = useShareWorkspaceState({
    workspaces,
    omnirushServerHostInfo: omnirushServerHostInfoState,
    omnirushServerSettings,
    engineInfo: routeEngineInfo,
    exportWorkspaceBusy: false,
    openLink: (url) => platform.openLink(url),
    workspaceLabel,
  });


  const remoteWorkspaceConnectionEditor = useRemoteWorkspaceConnectionEditor({
    workspaces,
    client,
    onSaved: handleRemoteWorkspaceConnectionSaved,
  });


  const workspaceSessionGroups = useMemo(
    () => toSessionGroups(
      workspaces,
      sessionsByWorkspaceId,
      errorsByWorkspaceId,
      new Set(retryingWorkspaceIds),
      sessionListErrorsByWorkspaceId,
    ),
    [errorsByWorkspaceId, retryingWorkspaceIds, sessionListErrorsByWorkspaceId, sessionsByWorkspaceId, workspaces],
  );
  useSessionGroupSync({ workspaces, endpointForWorkspace });
  // A parallel task's own workspace is listed on its repository's board, not in the sidebar (unless it is open).
  const sidebarWorkspaceSessionGroups = useMemo(
    () => workspaceSessionGroups
      .filter((group) => !group.workspace.task || group.workspace.id === selectedWorkspaceId)
      // Work lists only the Work workspace's chats; Code (and the app while Work is off) never lists it.
      .filter((group) => shownInMode(group.workspace, workEnabled, appMode)),
    [appMode, selectedWorkspaceId, workEnabled, workspaceSessionGroups],
  );
  const tasksBoardWorkspaceId = selectedWorkspace?.task && workspaces.some((workspace) => workspace.id === selectedWorkspace.task?.parentWorkspaceId)
    ? selectedWorkspace.task.parentWorkspaceId
    : selectedWorkspaceId;
  const tasksAvailable = Boolean(selectedWorkspace && selectedWorkspace.workspaceType !== "remote" && tasksBoardWorkspaceId);
  const workspaceTasksQuery = useWorkspaceTasks(client, tasksBoardWorkspaceId, tasksAvailable);
  const tasksRunningCount = runningTaskCount(workspaceTasksQuery.data);
  const selectedWorkspaceGroupState = sessionManagementStore((state) => (
    selectedWorkspaceId ? state.groupsByWorkspace[selectedWorkspaceId] : undefined
  ));
  const assignSessionToGroup = sessionManagementStore((state) => state.assignGroup);
  const currentSessionPinned = sessionManagementStore((state) => (
    selectedSessionId ? state.pinnedIds.includes(selectedSessionId) : false
  ));
  const seedWorkspaceActivitySessions = useSessionActivityStore((state) => state.seedWorkspaceSessions);
  const sessionActivityByWorkspaceId = useSessionActivityStore((state) => state.statusesByWorkspaceId);

  useEffect(() => {
    for (const group of workspaceSessionGroups) {
      seedWorkspaceActivitySessions(group.workspace.id, group.sessions);
      const serverId = workspaceServerId(group.workspace);
      if (serverId && serverId !== group.workspace.id) {
        seedWorkspaceActivitySessions(serverId, group.sessions);
      }
    }
  }, [seedWorkspaceActivitySessions, workspaceSessionGroups]);

  const sidebarSessionStatusById = useMemo(() => {
    const next: Record<string, string> = {};
    for (const group of workspaceSessionGroups) {
      const serverId = workspaceServerId(group.workspace);
      const workspaceStatuses = {
        ...(sessionActivityByWorkspaceId[group.workspace.id] ?? {}),
        ...(serverId ? sessionActivityByWorkspaceId[serverId] ?? {} : {}),
      };
      for (const session of group.sessions) {
        const status = workspaceStatuses[session.id];
        if (status) next[session.id] = status;
      }
    }
    return next;
  }, [sessionActivityByWorkspaceId, workspaceSessionGroups]);

  const sidebarActiveWorkspaceId = useMemo(() => {
    const sessionId = selectedSessionId?.trim() ?? "";
    if (sessionId) {
      const owner = workspaceSessionGroups.find((group) =>
        group.sessions.some((session) => session?.id === sessionId),
      );
      if (owner?.workspace.id) return owner.workspace.id;
    }
    return selectedWorkspaceId;
  }, [selectedSessionId, selectedWorkspaceId, workspaceSessionGroups]);

  const workspaceConnectionStateById = useMemo(() => {
    const next: Record<string, WorkspaceConnectionState> = { ...workspaceConnectionOverrides };
    for (const workspace of workspaces) {
      if (workspace.workspaceType !== "remote") continue;
      const error = errorsByWorkspaceId[workspace.id]?.trim();
      if (!error || next[workspace.id]?.status === "connecting") continue;
      next[workspace.id] ??= {
        status: "error",
        message: getWorkspaceTaskLoadErrorDisplay(workspace, error).message || error,
        checkedAt: null,
      };
    }
    return next;
  }, [errorsByWorkspaceId, workspaceConnectionOverrides, workspaces]);

  const mcpConnectedCount = useMcpConnectedCount(opencodeClient, selectedWorkspaceRoot);
  const providerListQuery = useProviderListQuery({
    client: opencodeClient,
    baseUrl: opencodeBaseUrl,
    directory: selectedWorkspaceRoot || undefined,
  });
  const { providerCatalog, modelVariantLabel, modelBehaviorOptions, modelVariantValue } =
    useModelBehavior({
      providerList: providerListQuery.data,
      defaultModel: local.prefs.defaultModel,
      modelVariant: local.prefs.modelVariant ?? null,
    });
  const {
    store: sessionProviderAuthStore,
    snapshot: sessionProviderAuthSnapshot,
    cloudProviderSyncReady,
    cloudProviderList,
    refreshCloudProviderSync,
  } = useSessionProviderAuth({
    opencodeClient,
    opencodeBaseUrl,
    providers,
    providerDefaults,
    providerConnectedIds,
    disabledProviderIds,
    selectedWorkspace,
    selectedWorkspaceEndpoint,
    selectedWorkspaceRoot,
    selectedWorkspaceId,
    localServerHostToken: omnirushServerHostInfoState?.hostToken?.trim() ?? "",
    setProviders,
    setProviderDefaults,
    setProviderConnectedIds,
    setDisabledProviderIds,
  });
  const organizationAssignedModelOptions = useMemo(
    () => assignedModelOptions(sessionProviderAuthSnapshot.cloudOrgProviders),
    [sessionProviderAuthSnapshot.cloudOrgProviders],
  );
  useEffect(() => {
    if (!denAuth.isSignedIn) {
      setActiveOrganizationRole(null);
      return;
    }

    const settings = readDenSettings();
    const tokenValue = settings.authToken?.trim() ?? "";
    const activeOrgId = settings.activeOrgId?.trim() ?? "";
    const activeOrgSlug = settings.activeOrgSlug?.trim() ?? "";
    if (!tokenValue || (!activeOrgId && !activeOrgSlug)) {
      setActiveOrganizationRole(null);
      return;
    }

    let cancelled = false;
    void createDenClient({ baseUrl: settings.baseUrl, token: tokenValue })
      .listOrgs()
      .then((response) => {
        if (cancelled) return;
        const active = response.orgs.find((org) =>
          org.id === activeOrgId || org.slug === activeOrgSlug,
        );
        setActiveOrganizationRole(active?.role ?? null);
      })
      .catch(() => {
        if (!cancelled) setActiveOrganizationRole(null);
      });

    return () => {
      cancelled = true;
    };
  }, [denAuth.isSignedIn, denAuth.status, denSessionVersion]);
  const handleModelPickerOpen = useCallback(() => {
    void refreshCloudProviderSync("model_picker_open");
  }, [refreshCloudProviderSync]);
  const omniRushModelsEntitled = useMemo(() => {
    if (!denAuth.isSignedIn) return false;
    const fromOrg = sessionProviderAuthSnapshot.cloudOrgProviders.some(
      (provider) =>
        [provider.providerId, provider.source].some(
          (value) => value?.trim().toLowerCase() === "omnirush",
        ),
    );
    const fromImport = Object.values(sessionProviderAuthSnapshot.importedCloudProviders ?? {}).some(
      (provider) =>
        [provider.providerId, provider.source, provider.sourceProviderId].some(
          (value) => value?.trim().toLowerCase() === "omnirush",
        ),
    );
    return fromOrg || fromImport;
  }, [
    denAuth.isSignedIn,
    sessionProviderAuthSnapshot.cloudOrgProviders,
    sessionProviderAuthSnapshot.importedCloudProviders,
  ]);
  const refreshOrganizationModelAccess = useCallback(async () => {
    await refreshCloudProviderSync("manual");
  }, [refreshCloudProviderSync]);
  useEffect(() => {
    if (!cloudProviderSyncReady || !cloudProviderList) return;
    clearCloudMcpSubmissionFailure();
  }, [clearCloudMcpSubmissionFailure, cloudProviderList, cloudProviderSyncReady]);
  const organizationModelsSettingsUrl = useMemo(() => {
    if (!isDenOrgAdminRole(activeOrganizationRole)) {
      return undefined;
    }
    return new URL("/dashboard/custom-llm-providers", readDenSettings().baseUrl).toString();
  }, [activeOrganizationRole, denSessionVersion]);
  const restrictToCloudProviders = checkDesktopRestriction({ restriction: "allowCustomProviders" });
  const entitledModelOptions = useMemo(() => {
    const runtimeOptions = providerListModelEntitlementOptions(
      cloudProviderList ?? providerListQuery.data,
    );
    return filterEntitledModelOptions(
      runtimeOptions.length > 0 ? runtimeOptions : organizationAssignedModelOptions,
      {
        restrictToCloud: restrictToCloudProviders,
        checkRestriction: checkDesktopRestriction,
      },
    );
  }, [
    checkDesktopRestriction,
    cloudProviderList,
    organizationAssignedModelOptions,
    providerListQuery.data,
    restrictToCloudProviders,
  ]);
  const omniRushModelsAvailable = hasOmniRushModelsAvailable({
    providerConnectedIds,
    providers,
  });
  const omniRushModelsSyncing = shouldShowOmniRushModelsSyncing({
    entitled: omniRushModelsEntitled,
    available: omniRushModelsAvailable,
    workspaceReady: Boolean(selectedWorkspaceId && opencodeClient),
    reloadPending: sessionProviderAuthSnapshot.cloudProviderServerSync?.reloadPending === true,
  });
  const organizationModelsEmpty = isOrganizationModelsEmpty({
    workspaceReady: Boolean(selectedWorkspaceId && opencodeClient),
    loading,
    restrictToCloud: restrictToCloudProviders,
    cloudProviderSyncReady,
    entitledModelCount: entitledModelOptions.length,
  });
  // The open project's mode (sandbox or not) and the models it allows (model-modes.ts).
  const modelModes = useProjectModelModes(selectedWorkspaceEndpoint?.client ?? null, selectedWorkspaceEndpoint?.workspaceId ?? null, selectedSessionId || null);
  const modelModesRef = useRef(modelModes);
  modelModesRef.current = modelModes;
  useClaudeModelSync(selectedWorkspaceEndpoint?.client ?? null, selectedWorkspaceEndpoint?.workspaceId ?? null);
  // The default as this project may use it: one its mode does not allow moves to the allowed default.
  const projectDefaultModel = modelModes.fallback(local.prefs.defaultModel ?? null) ?? local.prefs.defaultModel ?? null;
  /**
   * The model a send in the open project goes out on. A chat's model is fixed
   * once it sent a prompt: if its project's mode no longer allows it (the
   * sandbox turned on or off since), nothing is sent and the person is told to
   * start a new chat. Only a new chat moves to the allowed default, with a note.
   */
  const modeSendModel = (model: ModelRef | null | undefined, sessionId: string | null): ModelRef | null => {
    const rules = modelModesRef.current;
    if (!model) return null;
    if (sessionId && chatStarted(sessionId)) {
      if (!rules.allows(model)) throw new Error(rules.chatNote(model));
      return model;
    }
    if (rules.allowsNew(model)) return model;
    const next = rules.fallback(model);
    if (!next) return model;
    toast(rules.note(model, next), { id: `model-mode:${sessionId ?? "new"}` });
    if (sessionId) useSessionModelStore.getState().setModel(sessionId, next, null);
    return next;
  };
  const modelPicker = useModelPicker({
    client: opencodeClient,
    baseUrl: opencodeBaseUrl,
    workspaceRoot: selectedWorkspaceRoot,
    onOpen: handleModelPickerOpen,
    fallbackOptions: organizationAssignedModelOptions,
    cloudProvidersEnabled: denAuth.isSignedIn,
  });
  // Which session the open model picker targets. Selecting a model while a
  // session is targeted remembers it for that conversation only; null means
  // the picker edits the global default (e.g. opened from the new-providers
  // toast). Composer "All models" carries the session id on the open event.
  const [modelPickerSessionId, setModelPickerSessionId] = useState<string | null>(null);
  useEffect(() => {
    const handler = (event: Event) => {
      const detail = (event as CustomEvent<{ sessionId?: string }>).detail;
      setModelPickerSessionId(typeof detail?.sessionId === "string" ? detail.sessionId : null);
    };
    window.addEventListener(openModelPickerEvent, handler);
    return () => window.removeEventListener(openModelPickerEvent, handler);
  }, []);
  const entitledOrgDefaultModel = useMemo(() => {
    const runtimeOptions = providerListModelEntitlementOptions(
      cloudProviderList ?? providerListQuery.data,
    );
    return resolveEntitledOrgDefaultModel(
      runtimeOptions.length > 0 ? runtimeOptions : organizationAssignedModelOptions,
      {
        currentDefault: local.prefs.defaultModel,
        restrictToCloud: restrictToCloudProviders,
        checkRestriction: checkDesktopRestriction,
      },
    );
  }, [
    checkDesktopRestriction,
    cloudProviderList,
    local.prefs.defaultModel,
    organizationAssignedModelOptions,
    providerListQuery.data,
    restrictToCloudProviders,
  ]);
  useEffect(() => {
    if (entitledOrgDefaultModel) writeStoredDefaultModel(entitledOrgDefaultModel);
  }, [entitledOrgDefaultModel]);
  // Availability is resolved per effective model identity: the New Task
  // composer validates the global default while each conversation validates
  // its OWN remembered provider/model against the current workspace's
  // catalogs. The provider-list query is keyed by server + workspace
  // directory, so a workspace switch supersedes the old catalog (the new key
  // reads as unsettled → pending) instead of judging the new workspace with
  // stale data.
  //
  // Catalog denials are additionally confirmation-gated: Settings visits and
  // engine reload churn can settle a momentarily incomplete catalog, and a
  // denial younger than the confirmation window renders as pending instead of
  // flashing "Model no longer available" during the transition. The recheck
  // tick re-evaluates tracked denials so a genuine one still surfaces once it
  // matures, even without further catalog changes.
  const modelAvailabilityGate = useMemo(() => createUnavailableConfirmationGate(), []);
  const [availabilityRecheckTick, bumpAvailabilityRecheck] = useReducer(
    (value: number) => value + 1,
    0,
  );
  const resolveModelAvailability = useCallback((model: ModelRef | null): ModelAvailability =>
    modelAvailabilityGate.confirm(model, computeModelAvailability(model, {
      workspaceReady: Boolean(selectedWorkspaceId && opencodeClient),
      loading,
      signedIn: denAuth.isSignedIn,
      cloudProviderSyncReady,
      omniRushModelsSyncing,
      restrictToCloud: restrictToCloudProviders,
      checkRestriction: checkDesktopRestriction,
      cloudProviderList,
      providerList: providerListQuery.data,
    })), [
    // The tick only forces re-evaluation of denials tracked by the gate.
    availabilityRecheckTick,
    checkDesktopRestriction,
    cloudProviderList,
    cloudProviderSyncReady,
    denAuth.isSignedIn,
    loading,
    modelAvailabilityGate,
    opencodeClient,
    omniRushModelsSyncing,
    providerListQuery.data,
    restrictToCloudProviders,
    selectedWorkspaceId,
  ]);
  useEffect(() => {
    const delay = modelAvailabilityGate.nextRecheckDelay();
    if (delay === null) return;
    const timer = window.setTimeout(() => bumpAvailabilityRecheck(), delay + 16);
    return () => window.clearTimeout(timer);
  }, [modelAvailabilityGate, resolveModelAvailability]);
  const selectedModelUnavailable =
    resolveModelAvailability(local.prefs.defaultModel ?? null).status === "unavailable";
  // The composer the user is looking at: the selected conversation's
  // remembered model when it has one, otherwise the global default.
  const selectedSessionModelSelection = useSessionModelStore((state) =>
    (selectedSessionId ? state.bySessionId[selectedSessionId] ?? null : null),
  );
  const activeComposerModel = selectedSessionModelSelection?.model ?? projectDefaultModel;
  const activeComposerAvailability = resolveModelAvailability(activeComposerModel);
  const activeComposerTargetsSession = Boolean(selectedSessionModelSelection && selectedSessionId);
  const selectedModelUnavailableKey = activeComposerAvailability.status === "unavailable" && activeComposerModel
    ? `${activeComposerTargetsSession ? selectedSessionId : "default"}:${activeComposerModel.providerID}:${activeComposerModel.modelID}`
    : null;
  const autoOpenedUnavailableModelRef = useRef<string | null>(null);
  // A conversation whose remembered model can no longer be used (its provider is
  // locked or blocked, or the model left the catalog: e.g. a chat from before an
  // update) moves to the working default with a notice, instead of a disabled
  // composer and a picker to sort out.
  // Re-renders when the server's lock answer arrives (providerLockAnswered below).
  useProviderLock();
  const sessionFallbackModel = activeComposerTargetsSession
    ? sessionModelFallback({
      sessionModel: selectedSessionModelSelection?.model,
      sessionAvailability: activeComposerAvailability,
      defaultModel: local.prefs.defaultModel,
      defaultAvailability: resolveModelAvailability(local.prefs.defaultModel ?? null),
      lockAnswered: providerLockAnswered(),
    })
    : null;
  const sessionFallbackKey = sessionFallbackModel && selectedSessionId && selectedSessionModelSelection
    ? `${selectedSessionId}:${selectedSessionModelSelection.model.providerID}:${selectedSessionModelSelection.model.modelID}`
    : null;
  useEffect(() => {
    if (!sessionFallbackKey || !sessionFallbackModel || !selectedSessionId) return;
    const previous = getSessionModelSelection(selectedSessionId)?.model;
    if (!previous) return;
    useSessionModelStore.getState().setModel(selectedSessionId, sessionFallbackModel, local.prefs.modelVariant ?? null);
    const providerItem = (id: string) => providers.find((item) => item.id === id);
    const fallbackProvider = providerItem(sessionFallbackModel.providerID);
    const modelName = resolveModelDisplayName(
      sessionFallbackModel.modelID,
      fallbackProvider?.models?.[sessionFallbackModel.modelID]?.name ?? null,
    );
    const providerName = providerItem(previous.providerID)?.name?.trim() || previous.providerID;
    toast(t("models.switched_unavailable", { model: modelName, provider: providerName }), {
      id: `session-model-switched:${selectedSessionId}`,
    });
    // Keyed on the session and the model it remembered: one switch and one notice each.
  }, [sessionFallbackKey]);

  useEffect(() => {
    // The conversation is about to move to the default model (above): no picker for it.
    if (sessionFallbackKey) return;
    if (!selectedModelUnavailableKey) {
      // The active composer's model is fine (or pending). If the picker was
      // auto-opened for a previously broken composer — e.g. the New Task
      // default — do not let that recovery modal follow the user into a
      // conversation whose own model is valid.
      if (autoOpenedUnavailableModelRef.current) {
        modelPicker.setOpen(false);
      }
      autoOpenedUnavailableModelRef.current = null;
      return;
    }
    if (!shouldAutoOpenUnavailableModelPicker({
      selectedModelUnavailableKey,
      signedIn: denAuth.isSignedIn,
      cloudProviderSyncReady,
      // Silent default repair only applies when the broken selection IS the
      // default. A conversation's own unavailable model moves to the default
      // with a notice when that is definite (sessionModelFallback: a blocked
      // provider, a retired OmniRush model); otherwise the picker surfaces
      // for that conversation.
      entitledOrgDefaultModel: activeComposerTargetsSession ? false : Boolean(entitledOrgDefaultModel),
      organizationModelsEmpty,
      autoOpenedUnavailableModelKey: autoOpenedUnavailableModelRef.current,
    })) return;
    if (!activeComposerTargetsSession && entitledOrgDefaultModel) {
      writeStoredDefaultModel(entitledOrgDefaultModel);
      return;
    }

    autoOpenedUnavailableModelRef.current = selectedModelUnavailableKey;
    setModelPickerSessionId(activeComposerTargetsSession ? selectedSessionId : null);
    modelPicker.setQuery("");
    modelPicker.setRecentProviderIds(new Set());
    modelPicker.setCompactOpen(false);
    modelPicker.setOpen(true);
  }, [activeComposerTargetsSession, cloudProviderSyncReady, denAuth.isSignedIn, entitledOrgDefaultModel, modelPicker.setCompactOpen, modelPicker.setOpen, modelPicker.setQuery, modelPicker.setRecentProviderIds, organizationModelsEmpty, selectedModelUnavailableKey, selectedSessionId, sessionFallbackKey]);

  // Optimistic model selection: a remembered model is treated as valid until
  // the availability gate CONFIRMS it absent (selectedModelUnavailable).
  // A merely-pending verdict (cloud sync settling, catalog reloading) never
  // blocks task creation or paints loading chrome — if the optimism turns out
  // wrong, the send-time re-check and the composer's model-unavailable pill
  // surface it where the person can act on it.
  const hasUsableModel = Boolean(
    local.prefs.defaultModel &&
      !selectedModelUnavailable,
  );
  const canCreateTask = Boolean(
    opencodeClient &&
      selectedWorkspaceId &&
      !loading &&
      !selectedWorkspaceError &&
      !selectedModelUnavailable,
  );

  const {
    activePermission,
    permissionReplyBusy,
    respondPermission,
    activeQuestion,
    questionReplyBusy,
    respondQuestion,
    todos,
  } = useSessionInteractions({
    client: opencodeClient,
    // Match ReactSessionRuntime and SessionSurface: remote route IDs can carry
    // a client-only prefix, while interaction caches use the server workspace.
    workspaceId: selectedWorkspaceEndpoint?.workspaceId ?? selectedWorkspaceId,
    sessionId: selectedSessionId,
    interactionSessionIds: selectedInteractionSessionIds,
    workspaceRoot: selectedWorkspaceRoot,
  });
  const activePermissionSourceTitle = useMemo(() => {
    if (!activePermission || activePermission.sessionID === selectedSessionId) return null;
    const source = (sessionsByWorkspaceId[selectedWorkspaceId] ?? []).find(
      (session) => session.id === activePermission.sessionID,
    );
    return String(source?.title ?? source?.slug ?? "").trim() || t("session.subagent_task");
  }, [activePermission, selectedSessionId, selectedWorkspaceId, sessionsByWorkspaceId]);
  const modelUnavailableMessage = organizationModelsEmpty
    ? t("models.organization_models_empty")
    : selectedModelUnavailable
      ? t("models.model_unavailable_short")
      : null;
  useEffect(() => {
    if (!opencodeClient) {
      setProviders([]);
      setProviderDefaults({});
      setProviderConnectedIds([]);
      return;
    }

    let cancelled = false;

    const applyProviderState = (value: ProviderListResponse) => {
      if (cancelled) return;
      // When not signed in, filter out every cloud-managed provider key so
      // stale org imports and the hosted `omnirush` catalog do not reappear.
      const hasCloudAuth = !!readDenSettings().authToken?.trim();
      const all = hasCloudAuth
        ? ((value.all ?? []) as ProviderListItem[])
        : ((value.all ?? []) as ProviderListItem[]).filter(
            (provider) => !isCloudManagedProviderKey(provider.id ?? ""),
          );
      const connected = hasCloudAuth
        ? (value.connected ?? [])
        : (value.connected ?? []).filter((id) => !isCloudManagedProviderKey(id));
      setProviders(all);
      setProviderConnectedIds(connected);
      // New-provider detection is handled globally by the provider auth
      // store's applyProviderListState, which fires dispatchNewProviders.
    };

    void (async () => {
      let disabledProviders: string[] = [];
      try {
        const config = unwrap(
          await opencodeClient.config.get({
            directory: selectedWorkspaceRoot || undefined,
          }),
        );
        disabledProviders = disabledProvidersFromConfig(config);
        if (!cancelled) setDisabledProviderIds(disabledProviders);
      } catch {
        // ignore config read failures and continue with provider discovery
      }

      try {
        applyProviderState(
          filterProviderList(
            await ensureProviderListQuery(getReactQueryClient(), {
              client: opencodeClient,
              baseUrl: opencodeBaseUrl,
              directory: selectedWorkspaceRoot || undefined,
            }),
            disabledProviders,
          ),
        );
      } catch {
        if (cancelled) return;
        setProviders([]);
        setProviderDefaults({});
        setProviderConnectedIds([]);
      }
    })();

    return () => {
      cancelled = true;
    };
  }, [opencodeBaseUrl, opencodeClient, selectedWorkspaceRoot, denSessionVersion]);

  const modelLabel = local.prefs.defaultModel
    ? resolveModelDisplayName(local.prefs.defaultModel.modelID)
    : t("session.default_model");

  const listSlashCommands = useCallback(async (): Promise<SlashCommandOption[]> => {
    // engineReloadVersion is included so the callback identity changes after
    // an engine reload, which invalidates the composer's command list cache
    // and causes it to re-fetch (picking up newly created skills).
    void engineReloadVersion;
    if (!opencodeClient) return [];
    return listCommands(opencodeClient, selectedWorkspaceRoot || undefined);
  }, [engineReloadVersion, opencodeClient, selectedWorkspaceRoot]);

  // Shared by the composer (plug menu, @ mentions) and the command palette.
  // Hidden and subagent-only entries are excluded — those are task-tool
  // delegation targets, not agents the user can run a session as.
  const listAgents = useCallback(async () => {
    // Include engineReloadVersion so the composer refetches after newly added
    // agent files become available, even when the inline picker is hidden.
    void engineReloadVersion;
    if (!opencodeClient) return [];
    const list = unwrap(await opencodeClient.app.agents());
    return list.filter(isLibraryAgent);
  }, [engineReloadVersion, opencodeClient]);

  const handleOpenSettings = useCallback((route = "/settings/general", workspaceId = sidebarActiveWorkspaceId) => {
    const sessionId = workspaceId === sidebarActiveWorkspaceId ? selectedSessionId : null;
    const tab = route.replace(/^\/settings\/?/, "").replace(/^\/+|\/+$/g, "") || "general";
    const target = workspaceId ? workspaceSettingsRoute(workspaceId, tab) : route;
    writeActiveWorkspaceId(workspaceId || null);
    navigate(target, { state: { workspaceId, sessionId } });
  }, [navigate, selectedSessionId, sidebarActiveWorkspaceId]);

  const handleOpenExtensions = useCallback((path = "", workspaceId = sidebarActiveWorkspaceId) => {
    const sessionId = workspaceId === sidebarActiveWorkspaceId ? selectedSessionId : null;
    const extensionPath = path
      .replace(/^\/settings\/extensions\/?/, "")
      .replace(/^\/extensions\/?/, "")
      .replace(/^\/+|\/+$/g, "")
      .replace(/^mcp$/, "mcps");
    const target = workspaceId
      ? workspaceExtensionsRoute(workspaceId, extensionPath)
      : globalExtensionsRoute(extensionPath);
    writeActiveWorkspaceId(workspaceId || null);
    navigate(target, { state: { workspaceId, sessionId } });
  }, [navigate, selectedSessionId, sidebarActiveWorkspaceId]);

  const extensionsMainOpen = /^\/(?:workspace\/[^/]+\/)?extensions(?:\/|$)/.test(location.pathname);

  const surfaceProps = useMemo(() => {
    if (!client || !selectedWorkspaceId || !selectedSessionId || !opencodeBaseUrl || !token || !opencodeClient) {
      return null;
    }

    // Transient-safety: when the user switches workspaces the URL-driven
    // selectedSessionId may still point at a session from the old workspace
    // for one render tick. Only block rendering when we KNOW the session
    // belongs to a different workspace (i.e., it exists in another
    // workspace's list). A brand-new session that hasn't been refreshed
    // into any list yet must still render so "New task" feels instant.
    let sessionOwnedByOtherWorkspace = false;
    for (const [workspaceId, sessions] of Object.entries(sessionsByWorkspaceId)) {
      if (workspaceId === selectedWorkspaceId) continue;
      if ((sessions ?? []).some((session) => session?.id === selectedSessionId)) {
        sessionOwnedByOtherWorkspace = true;
        break;
      }
    }
    if (sessionOwnedByOtherWorkspace) {
      return null;
    }

    // Note: do NOT include `client`, `workspaceId`, `sessionId`,
    // `opencodeBaseUrl`, or `omnirushToken` here. SessionPage forwards those
    // explicitly to SessionSurface from the per-workspace endpoint resolved
    // by `resolveWorkspaceEndpoint`. If we leak them in here, the spread of
    // `surfaceProps` in SessionPage overrides those correct values with the
    // local server's, and remote workspaces silently end up calling the
    // local server with the local `rem_*` id.
    return {
      mcpDisabled: true,
      workspaceRoot: selectedWorkspaceRoot,
      draftScope: sessionDraftScope,
      developerMode,
      modelLabel,
      onModelClick: (sessionId?: string) => {
        setModelPickerSessionId(sessionId ?? null);
        modelPicker.setQuery("");
        modelPicker.setOpen(true);
      },
      providerCatalog,
      modelPickerOpen: modelPicker.compactOpen,
      // Legacy fallback only; each surface resolves availability for its own
      // effective session model through `resolveModelAvailability`.
      modelUnavailable: selectedModelUnavailable,
      modelUnavailableMessage,
      resolveModelAvailability,
      organizationModelsEmpty,
      selectedModel: projectDefaultModel ?? { providerID: "", modelID: "" },
      omniRushModelsEntitled,
      omniRushModelsSyncing,
      onRefreshOrganizationModels: refreshOrganizationModelAccess,
      onModelPickerOpenChange: (open: boolean) => {
        modelPicker.setCompactOpen(open);
        if (open) {
          void refreshCloudProviderSync("model_picker_open");
        }
      },
      onModelChange: (model: ModelRef, variant?: string | null) => {
        local.setPrefs((previous) => ({
          ...previous,
          defaultModel: model,
          modelVariant: variant !== undefined
            ? variant
            : previous.defaultModel?.providerID === model.providerID && previous.defaultModel.modelID === model.modelID
              ? previous.modelVariant
              : null,
        }));
        modelPicker.setCompactOpen(false);
      },
      providerConnectedCount: hasUsableModel ? 1 : providerConnectedIds.length,
      onOpenSettingsSection: (section: ComposerSettingsSection) => {
        openComposerConfigure(section, {
          openLibrary: handleOpenExtensions,
          openSettings: handleOpenSettings,
        });
      },
      onSendDraft: async (draft: ComposerDraft, sessionId: string, onPrepared?: () => void): Promise<CloudMcpSubmissionResult> => {
        const targetSessionId = sessionId.trim() || selectedSessionId;
        if (!targetSessionId) return { outcome: "cancelled", reason: "context_changed" };
        const generation = getQueuedSendGeneration(targetSessionId);
        const assertCurrent = () => assertQueuedSendCurrent(targetSessionId, generation);
        const text = (draft.resolvedText ?? draft.text).trim();
        if (!text && draft.attachments.length === 0) {
          return { outcome: "cancelled", reason: "context_changed" };
        }
        // Per-conversation model memory: a session that picked its own model
        // sends with it (and its variant) instead of the global default.
        const sessionModelSelection = getSessionModelSelection(targetSessionId);
        const configuredSendModel = modeSendModel(sessionModelSelection?.model ?? local.prefs.defaultModel, targetSessionId);
        const sendModel = configuredSendModel;
        // The effort the picker shows for this model, never a null it hides.
        const sendVariant = resolveSendVariant(sendModel, sessionModelSelection ? sessionModelSelection.variant : modelVariantValue);
        // Send-time validation targets the exact provider/model identity this
        // conversation displays and will submit — not the global default.
        if (resolveModelAvailability(sendModel ?? null).status === "unavailable") {
          throw new Error("Selected model is unavailable. Choose another model before sending.");
        }

        return submitWithCloudMcpReadiness({
          // Temporarily bypass the pre-send Cloud MCP gate: it blocks every
          // message, including tasks that do not use connected services.
          skipGate: true,
          send: async () => {
            await sendWithRevertRollback({
              assertCurrent,
              revertMessageId: draft.revertMessageId,
              abort: () => abortSessionSafe(opencodeClient, targetSessionId, selectedWorkspaceRoot || undefined, {
                source: "session.edit_resend.before_revert",
                initiator: "user",
                reason: "abort active run before replacing a reverted message",
              }),
              revert: async (messageId) => {
                const reverted = await revertSession(opencodeClient, targetSessionId, messageId);
                applySessionRevert(selectedWorkspaceId, reverted);
              },
              prompt: async () => {
                captureAnalyticsEvent("task_message_sent", {
                  mode: draft.mode ?? "prompt",
                  is_command: Boolean(draft.command),
                  attachment_count: draft.attachments.length,
                  text_length: text.length,
                  workspace_type: selectedWorkspace?.workspaceType ?? "unknown",
                  provider_id: sendModel?.providerID ?? null,
                  model_id: sendModel?.modelID ?? null,
                });
                markTaskRunStart(targetSessionId);
                // Den org adoption signals (auth-gated inside; no-op when signed out).
                // This remains inside the post-readiness send closure so a blocked
                // Cloud submission cannot create a run or report that one started.
                const projectDimension = readWorkspaceProjectDimension(selectedWorkspaceId);
                const modelSelection = sessionModelSelection ? "manual" : "default";
                const telemetryDimensions = [
                  ...(projectDimension ? [{
                    type: "project",
                    label: projectDimension.label,
                  }] : []),
                  ...(sendModel ? [{
                    type: "model",
                    value: `${sendModel.providerID}/${sendModel.modelID}`,
                    label: `${sendModel.providerID}/${sendModel.modelID}`,
                  }] : []),
                  {
                    type: "model_selection",
                    value: modelSelection,
                    label: modelSelection,
                  },
                ];
                trackSessionActive(targetSessionId, telemetryDimensions);
                trackTaskStarted(targetSessionId, telemetryDimensions);

                if (draft.mode === "shell") {
                  onPrepared?.();
                  await shellInSession(opencodeClient, targetSessionId, text, { messageID: draft.messageId });
                  return;
                }

                if (draft.command) {
                  onPrepared?.();
                  const result = await opencodeClient.session.command({
                    sessionID: targetSessionId,
                    messageID: draft.messageId,
                    command: draft.command.name,
                    arguments: draft.command.arguments,
                    ...(sendVariant ? { variant: sendVariant } : {}),
                  });
                  if (result.error) {
                    throw new Error(serializeSDKError(result.error));
                  }
                  return;
                }

                const parts = await draftToParts(draft, selectedWorkspaceRoot, targetSessionId, selectedWorkspaceEndpoint);
                assertCurrent();
                const system = await buildOmniRushSessionSystemContext(client, {
                  workspaceId: selectedWorkspaceId,
                  cacheKey: targetSessionId,
                  runtimeKey: environmentRuntimeKey,
                });
                assertCurrent();
                onPrepared?.();
                const result = await opencodeClient.session.promptAsync({
                  sessionID: targetSessionId,
                  messageID: draft.messageId,
                  parts,
                  model: sendModel ?? undefined,
                  agent: selectedAgent ?? undefined,
                  ...(sendVariant ? { variant: sendVariant } : {}),
                  system,
                });
                if (result.error) {
                  if (isPromptAdmissionUnknown(result.error)) throw result.error;
                  throw new Error(serializeSDKError(result.error));
                }
                // Remember what this conversation used last so returning to it
                // (or splitting it beside another session) keeps its own model.
                if (sendModel && getQueuedSendGeneration(targetSessionId) === generation) {
                  useSessionModelStore.getState().setModel(targetSessionId, sendModel, sendVariant ?? null);
                }
                // Its first prompt went out: the chat keeps this model from now on.
                markChatStarted(targetSessionId);
              },
              unrevert: async () => {
                try {
                  await unrevertSession(opencodeClient, targetSessionId);
                } finally {
                  applySessionUnrevert(selectedWorkspaceId, targetSessionId);
                }
              },
              onUnrevertError: (error) => console.warn("[edit-resend] rollback failed", error),
            });
          },
        });
      },
      cloudMcpSubmissionState,
      onOpenConnect: () => handleOpenExtensions(),
      onDraftChange: () => {
        // Draft persistence will be wired once the full React shell owns session state.
      },
      attachmentsEnabled: true,
      attachmentsDisabledReason: null,
      modelVariantLabel,
      modelVariant: modelVariantValue,
      modelBehaviorOptions,
      onModelVariantChange: (value: string | null) => {
        local.setPrefs((previous) => ({ ...previous, modelVariant: value }));
      },
      agentLabel: selectedAgent ? selectedAgent.charAt(0).toUpperCase() + selectedAgent.slice(1) : t("session.default_agent"),
      selectedAgent,
      listAgents,
      onSelectAgent: (agent: string | null) => setSelectedAgent(agent),
      listCommands: listSlashCommands,
      recentFiles: [],
      searchFiles: async (query: string) => {
        const trimmed = query.trim();
        if (!trimmed) return [];
        const result = unwrap(
          await opencodeClient.find.files({
            query: trimmed,
            dirs: "true",
            limit: 50,
            directory: selectedWorkspaceRoot || undefined,
          }),
        );
        return result;
      },
      isRemoteWorkspace: selectedWorkspace?.workspaceType === "remote",
      isSandboxWorkspace: selectedWorkspace ? isSandboxWorkspace(selectedWorkspace) : false,
      onRevertToMessage: async (messageId: string, sessionId: string) => {
        const targetSessionId = sessionId.trim() || selectedSessionId;
        if (!targetSessionId) return false;
        try {
          // Abort any running generation first; OpenCode rejects revert on busy sessions.
          await abortSessionSafe(opencodeClient, targetSessionId, selectedWorkspaceRoot || undefined, {
            source: "session.revert_to_message.before_revert",
            initiator: "user",
            reason: "abort active run before reverting transcript",
          });
          const reverted = await revertSession(opencodeClient, targetSessionId, messageId);
          // Stamp the revert cursor into the local caches so the transcript
          // rewinds immediately instead of waiting for a full reload.
          applySessionRevert(selectedWorkspaceId, reverted);
          return true;
        } catch (error) {
          console.warn("[revert] failed", error);
          toast.error(t("session.revert_failed"));
          return false;
        }
      },
      onRestoreRevertedSession: async (sessionId: string) => {
        const targetSessionId = sessionId.trim() || selectedSessionId;
        if (!targetSessionId) return false;
        try {
          await unrevertSession(opencodeClient, targetSessionId);
          applySessionUnrevert(selectedWorkspaceId, targetSessionId);
          return true;
        } catch (error) {
          console.warn("[unrevert] failed", error);
          toast.error(t("session.restore_failed"));
          return false;
        }
      },
      onForkAtMessage: (messageId: string | null, sessionId: string) => {
        void (async () => {
          const targetSessionId = sessionId.trim() || selectedSessionId;
          if (!targetSessionId) return;
          try {
            const forked = await forkSession(opencodeClient, targetSessionId, messageId ?? undefined);
            writeLastSessionFor(selectedWorkspaceId, forked.id);
            rememberPendingCreatedSession(selectedWorkspaceId, forked.id);
            setSessionsByWorkspaceId((current) => ({
              ...current,
              [selectedWorkspaceId]: mergeWorkspaceRouteSession(current[selectedWorkspaceId] ?? [], forked),
            }));
            navigateToWorkspaceSession(selectedWorkspaceId, forked.id);
            void refreshRouteState();
          } catch (error) {
            console.warn("[fork] failed", error);
            toast.error(t("session.branch_failed"));
          }
        })();
      },
      onChangeModel: (model: { providerID: string; modelID: string }) => {
        local.setPrefs((previous) => ({
          ...previous,
          defaultModel: model,
          modelVariant: previous.defaultModel?.providerID === model.providerID && previous.defaultModel.modelID === model.modelID
            ? previous.modelVariant
            : null,
        }));
      },
      environmentRuntimeKey,
      onApplyEnvironmentChanges: isDesktopRuntime() && selectedWorkspace?.workspaceType !== "remote"
        ? handleApplyEnvironmentChanges
        : undefined,
      onSessionMissing: forgetMissingSession,
    };
  }, [
    client,
    forgetMissingSession,
    modelPicker.compactOpen,
    handleOpenExtensions,
    handleOpenSettings,
    hasUsableModel,
    handleApplyEnvironmentChanges,
    environmentRuntimeKey,
    local,
    listAgents,
    listSlashCommands,
    modelBehaviorOptions,
    cloudMcpSubmissionState,
    developerMode,
    modelLabel,
    modelUnavailableMessage,
    organizationModelsEmpty,
    projectDefaultModel,
    modelVariantLabel,
    modelVariantValue,
    navigate,
    providerCatalog,
    omniRushModelsEntitled,
    omniRushModelsSyncing,
    refreshCloudProviderSync,
    refreshOrganizationModelAccess,
    resolveModelAvailability,
    opencodeBaseUrl,
    opencodeClient,
    providerConnectedIds,
    selectedAgent,
    selectedSessionId,
    sessionDraftScope,
    selectedModelUnavailable,
    selectedWorkspace,
    selectedWorkspaceId,
    selectedWorkspaceRoot,
    sessionsByWorkspaceId,
    submitWithCloudMcpReadiness,
    token,
  ]);
  const resolvePaneRuntime = useCallback((session: OpenSessionTab): SessionPagePaneRuntime => {
    const candidateWorkspace = workspaces.find((candidate) => candidate.id === session.workspaceId);
    const workspaceTitle = session.workspaceTitle?.trim()
      || (candidateWorkspace ? workspaceLabel(candidateWorkspace) : session.workspaceId);
    const connection = candidateWorkspace ? workspaceConnectionStateById[candidateWorkspace.id] : undefined;
    const workspaceError = candidateWorkspace ? errorsByWorkspaceId[candidateWorkspace.id]?.trim() : undefined;
    const paneEndpoint = resolveWorkbenchPaneEndpoint({
      workspaceId: session.workspaceId,
      workspaceTitle,
      workspace: candidateWorkspace,
      endpoint: endpointForWorkspace(candidateWorkspace),
      connectionError: connection?.status === "error" ? connection.message : workspaceError,
    });
    if (paneEndpoint.status === "unavailable") return paneEndpoint;
    const { endpoint, workspace } = paneEndpoint;

    if (paneEndpoint.workspaceId === selectedWorkspaceId && surfaceProps) {
      return {
        status: "ready",
        workspaceId: paneEndpoint.workspaceId,
        workspaceTitle: paneEndpoint.workspaceTitle,
        workspaceRoot: selectedWorkspaceRoot,
        workspaceType: paneEndpoint.workspaceType,
        runtimeWorkspaceId: endpoint.workspaceId,
        opencodeBaseUrl: endpoint.opencodeBaseUrl,
        omnirushToken: endpoint.token,
        client: endpoint.client,
        environmentClient: client,
        surface: surfaceProps,
      };
    }

    if (!surfaceProps) {
      return {
        status: "unavailable",
        workspaceId: paneEndpoint.workspaceId,
        workspaceTitle: paneEndpoint.workspaceTitle,
        message: "The session runtime is still preparing.",
      };
    }

    const workspaceRoot = paneEndpoint.workspaceRoot;
    const workspaceOpencodeClient = createClientV2(
      endpoint.opencodeBaseUrl,
      workspaceRoot || undefined,
      { token: endpoint.token },
    );
    const scopedSurface = {
      ...surfaceProps,
      workspaceRoot,
      modelUnavailable: false,
      modelUnavailableMessage: null,
      resolveModelAvailability: undefined,
      cloudMcpSubmissionState: IDLE_CLOUD_MCP_SUBMISSION_GATE_STATE,
      onOpenSettingsSection: (section: ComposerSettingsSection) => {
        openComposerConfigure(section, {
          openLibrary: (path) => handleOpenExtensions(path, workspace.id),
          openSettings: (path) => handleOpenSettings(path, workspace.id),
        });
      },
      onOpenConnect: () => handleOpenExtensions("", workspace.id),
      listCommands: async (): Promise<SlashCommandOption[]> => {
        void engineReloadVersion;
        return listCommands(workspaceOpencodeClient, workspaceRoot || undefined);
      },
      listAgents: async () => {
        void engineReloadVersion;
        return unwrap(await workspaceOpencodeClient.app.agents()).filter(isLibraryAgent);
      },
      searchFiles: async (query: string) => {
        const trimmed = query.trim();
        if (!trimmed) return [];
        return unwrap(await workspaceOpencodeClient.find.files({
          query: trimmed,
          dirs: "true",
          limit: 50,
          directory: workspaceRoot || undefined,
        }));
      },
      isRemoteWorkspace: workspace.workspaceType === "remote",
      isSandboxWorkspace: isSandboxWorkspace(workspace),
      environmentRuntimeKey: workspace.workspaceType === "remote" ? null : environmentRuntimeKey,
      onApplyEnvironmentChanges: undefined,
      onSendDraft: async (draft: ComposerDraft, sessionId: string, onPrepared?: () => void): Promise<CloudMcpSubmissionResult> => {
        const targetSessionId = sessionId.trim() || session.sessionId;
        const generation = getQueuedSendGeneration(targetSessionId);
        const assertCurrent = () => assertQueuedSendCurrent(targetSessionId, generation);
        const text = (draft.resolvedText ?? draft.text).trim();
        if (!targetSessionId || (!text && draft.attachments.length === 0)) {
          return { outcome: "cancelled", reason: "context_changed" };
        }
        const sessionModelSelection = getSessionModelSelection(targetSessionId);
        const remembered = sessionModelSelection?.model ?? local.prefs.defaultModel;
        // The open project's mode rules apply to its own chats (another project's go to the broker, which refuses).
        const configuredSendModel = workspace.id === selectedWorkspaceId ? modeSendModel(remembered, targetSessionId) : remembered;
        const sendModel = configuredSendModel;
        // The effort the picker shows for this model, never a null it hides.
        const sendVariant = resolveSendVariant(sendModel, sessionModelSelection ? sessionModelSelection.variant : modelVariantValue);
        return submitWithCloudMcpReadiness({
          skipGate: true,
          send: async () => {
            await sendWithRevertRollback({
              assertCurrent,
              revertMessageId: draft.revertMessageId,
              abort: () => abortSessionSafe(workspaceOpencodeClient, targetSessionId, workspaceRoot || undefined, {
                source: "session.edit_resend.before_revert",
                initiator: "user",
                reason: "abort active run before replacing a reverted message",
              }),
              revert: async (messageId) => {
                const reverted = await revertSession(workspaceOpencodeClient, targetSessionId, messageId);
                applySessionRevert(endpoint.workspaceId, reverted);
              },
              prompt: async () => {
                captureAnalyticsEvent("task_message_sent", {
                  mode: draft.mode ?? "prompt",
                  is_command: Boolean(draft.command),
                  attachment_count: draft.attachments.length,
                  text_length: text.length,
                  workspace_type: workspace.workspaceType ?? "unknown",
                  provider_id: sendModel?.providerID ?? null,
                  model_id: sendModel?.modelID ?? null,
                });
                markTaskRunStart(targetSessionId);
                const projectDimension = readWorkspaceProjectDimension(workspace.id);
                const modelSelection = sessionModelSelection ? "manual" : "default";
                const telemetryDimensions = [
                  ...(projectDimension ? [{ type: "project", label: projectDimension.label }] : []),
                  ...(sendModel ? [{
                    type: "model",
                    value: `${sendModel.providerID}/${sendModel.modelID}`,
                    label: `${sendModel.providerID}/${sendModel.modelID}`,
                  }] : []),
                  { type: "model_selection", value: modelSelection, label: modelSelection },
                ];
                trackSessionActive(targetSessionId, telemetryDimensions);
                trackTaskStarted(targetSessionId, telemetryDimensions);
                if (draft.mode === "shell") {
                  onPrepared?.();
                  await shellInSession(workspaceOpencodeClient, targetSessionId, text, { messageID: draft.messageId });
                  return;
                }
                if (draft.command) {
                  onPrepared?.();
                  const result = await workspaceOpencodeClient.session.command({
                    sessionID: targetSessionId,
                    messageID: draft.messageId,
                    command: draft.command.name,
                    arguments: draft.command.arguments,
                    ...(sendVariant ? { variant: sendVariant } : {}),
                  });
                  if (result.error) throw new Error(serializeSDKError(result.error));
                  return;
                }
                const parts = await draftToParts(draft, workspaceRoot, targetSessionId, endpoint);
                assertCurrent();
                const system = await buildOmniRushSessionSystemContext(endpoint.client, {
                  workspaceId: workspace.id,
                  cacheKey: targetSessionId,
                  runtimeKey: workspace.workspaceType === "remote" ? null : environmentRuntimeKey,
                });
                assertCurrent();
                onPrepared?.();
                const result = await workspaceOpencodeClient.session.promptAsync({
                  sessionID: targetSessionId,
                  messageID: draft.messageId,
                  parts,
                  model: sendModel ?? undefined,
                  agent: selectedAgent ?? undefined,
                  ...(sendVariant ? { variant: sendVariant } : {}),
                  system,
                });
                if (result.error) {
                  if (isPromptAdmissionUnknown(result.error)) throw result.error;
                  throw new Error(serializeSDKError(result.error));
                }
                if (sendModel && getQueuedSendGeneration(targetSessionId) === generation) {
                  useSessionModelStore.getState().setModel(targetSessionId, sendModel, sendVariant ?? null);
                }
                // Its first prompt went out: the chat keeps this model from now on.
                markChatStarted(targetSessionId);
              },
              unrevert: async () => {
                try {
                  await unrevertSession(workspaceOpencodeClient, targetSessionId);
                } finally {
                  applySessionUnrevert(endpoint.workspaceId, targetSessionId);
                }
              },
              onUnrevertError: (error) => console.warn("[edit-resend] rollback failed", error),
            });
          },
        });
      },
      onRevertToMessage: async (messageId: string, sessionId: string) => {
        const targetSessionId = sessionId.trim() || session.sessionId;
        try {
          await abortSessionSafe(workspaceOpencodeClient, targetSessionId, workspaceRoot || undefined, {
            source: "session.revert_to_message.before_revert",
            initiator: "user",
            reason: "abort active run before reverting transcript",
          });
          const reverted = await revertSession(workspaceOpencodeClient, targetSessionId, messageId);
          applySessionRevert(endpoint.workspaceId, reverted);
          return true;
        } catch (error) {
          console.warn("[revert] failed", error);
          toast.error(t("session.revert_failed"));
          return false;
        }
      },
      onRestoreRevertedSession: async (sessionId: string) => {
        const targetSessionId = sessionId.trim() || session.sessionId;
        try {
          await unrevertSession(workspaceOpencodeClient, targetSessionId);
          applySessionUnrevert(endpoint.workspaceId, targetSessionId);
          return true;
        } catch (error) {
          console.warn("[unrevert] failed", error);
          toast.error(t("session.restore_failed"));
          return false;
        }
      },
      onForkAtMessage: (messageId: string | null, sessionId: string) => {
        void (async () => {
          const targetSessionId = sessionId.trim() || session.sessionId;
          try {
            const forked = await forkSession(workspaceOpencodeClient, targetSessionId, messageId ?? undefined);
            writeLastSessionFor(workspace.id, forked.id);
            rememberPendingCreatedSession(workspace.id, forked.id);
            setSessionsByWorkspaceId((current) => ({
              ...current,
              [workspace.id]: mergeWorkspaceRouteSession(current[workspace.id] ?? [], forked),
            }));
            navigateToWorkspaceSession(workspace.id, forked.id);
            void refreshRouteState();
          } catch (error) {
            console.warn("[fork] failed", error);
            toast.error(t("session.branch_failed"));
          }
        })();
      },
    };
    return {
      status: "ready",
      workspaceId: paneEndpoint.workspaceId,
      workspaceTitle: paneEndpoint.workspaceTitle,
      workspaceRoot,
      workspaceType: paneEndpoint.workspaceType,
      runtimeWorkspaceId: endpoint.workspaceId,
      opencodeBaseUrl: endpoint.opencodeBaseUrl,
      omnirushToken: endpoint.token,
      client: endpoint.client,
      environmentClient: client,
      surface: scopedSurface,
    };
  }, [
    client,
    endpointForWorkspace,
    engineReloadVersion,
    environmentRuntimeKey,
    errorsByWorkspaceId,
    handleOpenExtensions,
    handleOpenSettings,
    local.prefs.defaultModel,
    modelVariantValue,
    navigateToWorkspaceSession,
    refreshRouteState,
    rememberPendingCreatedSession,
    selectedAgent,
    selectedWorkspaceId,
    selectedWorkspaceRoot,
    setSessionsByWorkspaceId,
    submitWithCloudMcpReadiness,
    surfaceProps,
    workspaceConnectionStateById,
    workspaces,
  ]);
  const cloudWorkspaceMainContentDecision = mapCloudWorkspaceMainContentDecision({
    status: cloudWorkspace.viewModel.variant,
    hasWorkspaces: Boolean(surfaceProps),
    gatewayMode: cloudWorkspace.gatewayMode && cloudWorkspace.visible,
  });
  const cloudWorkspaceReadyForRouteErrors =
    !cloudWorkspace.gatewayMode ||
    !cloudWorkspace.visible ||
    cloudWorkspaceStatusHasReadyContent(cloudWorkspace.viewModel.variant);
  const cloudWorkspaceMainContentTakeover = cloudWorkspaceMainContentDecision === "takeover" ? (
    <CloudWorkspaceBootTakeover decision={cloudWorkspaceMainContentDecision} />
  ) : null;
  const gatedRouteNotFoundMessage = cloudWorkspaceReadyForRouteErrors ? routeNotFoundMessage : null;

  // Workspace-scoped wiring for the empty-state hero's full composer. Unlike
  // `surfaceProps` this exists without a selected session, so the hero offers
  // the same skills/commands/agent/model controls before the session is
  // created. Model and agent choices land in the same route-level state the
  // session composer reads, so they carry into the created session.
  const newTaskComposerContext = useMemo<NewTaskComposerContext | null>(() => {
    return {
      client,
      workspaceId: selectedWorkspaceId || null,
      draftOwnerKey: JSON.stringify([
        sessionDraftScope,
        selectedWorkspaceEndpoint?.opencodeBaseUrl ?? null,
        selectedWorkspaceId || null,
      ]),
      draftScope: sessionDraftScope,
      selectedModel: local.prefs.defaultModel ?? { providerID: "", modelID: "" },
      modelOptions: organizationAssignedModelOptions,
      modelUnavailable: selectedModelUnavailable,
      modelUnavailableMessage,
      organizationModelsEmpty,
      onRefreshOrganizationModels: refreshOrganizationModelAccess,
      modelPickerOpen: modelPicker.compactOpen,
      onModelPickerOpenChange: (open: boolean) => {
        modelPicker.setCompactOpen(open);
        if (open) {
          void sessionProviderAuthStore.refreshCloudOrgProviders({ force: true }).catch(() => undefined);
          void refreshCloudProviderSync("model_picker_open");
        }
      },
      onModelChange: (model: ModelRef, variant?: string | null) => {
        local.setPrefs((previous) => ({
          ...previous,
          defaultModel: model,
          modelVariant: variant !== undefined
            ? variant
            : previous.defaultModel?.providerID === model.providerID && previous.defaultModel.modelID === model.modelID
              ? previous.modelVariant
              : null,
        }));
        modelPicker.setCompactOpen(false);
      },
      omniRushModelsEntitled,
      omniRushModelsSyncing,
      modelVariantLabel,
      modelVariant: modelVariantValue,
      modelBehaviorOptions,
      onModelVariantChange: (value: string | null) => {
        local.setPrefs((previous) => ({ ...previous, modelVariant: value }));
      },
      agentLabel: selectedAgent ? selectedAgent.charAt(0).toUpperCase() + selectedAgent.slice(1) : t("session.default_agent"),
      selectedAgent,
      listAgents,
      onSelectAgent: (agent: string | null) => setSelectedAgent(agent),
      listCommands: listSlashCommands,
      searchFiles: async (query: string) => {
        const trimmed = query.trim();
        if (!trimmed || !opencodeClient) return [];
        const result = unwrap(
          await opencodeClient.find.files({
            query: trimmed,
            dirs: "true",
            limit: 50,
            directory: selectedWorkspaceRoot || undefined,
          }),
        );
        return result;
      },
      isRemoteWorkspace: selectedWorkspace?.workspaceType === "remote",
      isSandboxWorkspace: selectedWorkspace ? isSandboxWorkspace(selectedWorkspace) : false,
      onOpenSettingsSection: (section: ComposerSettingsSection) => {
        openComposerConfigure(section, {
          openLibrary: handleOpenExtensions,
          openSettings: handleOpenSettings,
        });
      },
    };
  }, [
    client,
    handleOpenExtensions,
    handleOpenSettings,
    listAgents,
    listSlashCommands,
    local,
    modelUnavailableMessage,
    modelBehaviorOptions,
    modelPicker,
    modelVariantLabel,
    modelVariantValue,
    opencodeClient,
    omniRushModelsEntitled,
    omniRushModelsSyncing,
    organizationAssignedModelOptions,
    organizationModelsEmpty,
    refreshCloudProviderSync,
    refreshOrganizationModelAccess,
    selectedAgent,
    selectedModelUnavailable,
    selectedWorkspace,
    selectedWorkspaceEndpoint,
    selectedWorkspaceId,
    selectedWorkspaceRoot,
    sessionDraftScope,
    sessionProviderAuthStore,
    setSelectedAgent,
  ]);

  const handleOpenCreateWorkspace = useCallback(() => {
    if (!canCreateWorkspaces()) return;
    // Respect the org-level `allowMultipleWorkspaces` restriction (dev
    // #1505). If the checker returns true, the admin has disabled
    // adding further workspaces; surface a friendly notice instead of
    // opening the modal.
    if (
      workspaces.length > 0 &&
      checkDesktopRestriction({ restriction: "allowMultipleWorkspaces" })
    ) {
      restrictionNotice.show({
        title: "Additional workspaces are restricted",
        message:
          "Your organization administrator has restricted access to adding additional workspaces.",
      });
      return;
    }
    setCreateWorkspaceRemoteError(null);
    setCreateWorkspaceOpen(true);
  }, [checkDesktopRestriction, restrictionNotice, workspaces.length]);

  const handleOpenRenameWorkspace = useCallback((workspaceId: string) => {
    const workspace = workspaces.find((item) => item.id === workspaceId);
    if (!workspace) return;
    setRenameWorkspaceId(workspaceId);
    setRenameWorkspaceTitle(
      workspace.displayName?.trim() ||
        workspace.name?.trim() ||
        workspace.path?.trim() ||
        "",
    );
  }, [workspaces]);

  const handleSaveRenameWorkspace = useCallback(async () => {
    if (!renameWorkspaceId) return;
    const trimmed = renameWorkspaceTitle.trim();
    if (!trimmed) return;
    setRenameWorkspaceBusy(true);
    try {
      if (!client) {
        toast.error("omnirush.ai server is unavailable. Reconnect the server before renaming workspaces.");
        return;
      }
      await client.updateWorkspaceDisplayName(renameWorkspaceId, trimmed);
      setRenameWorkspaceId(null);
      setRenameWorkspaceTitle("");
      await refreshRouteState();
    } catch (error) {
      toast.error("Workspace rename failed", {
        description: describeRouteError(error),
      });
    } finally {
      setRenameWorkspaceBusy(false);
    }
  }, [client, refreshRouteState, renameWorkspaceId, renameWorkspaceTitle]);

  const handleRevealWorkspace = useCallback(async (workspaceId: string) => {
    const workspace = workspaces.find((item) => item.id === workspaceId);
    const path = workspace?.path?.trim();
    if (!path || !isDesktopRuntime()) return;
    try {
      await revealDesktopItemInDir(path);
    } catch {
      // ignore
    }
  }, [workspaces]);

  const handleShareWorkspace = useCallback((workspaceId: string) => {
    shareWorkspaceState.openShareWorkspace(workspaceId);
  }, [shareWorkspaceState]);

  const handleSaveShareRemoteAccess = useCallback(
    async (enabled: boolean) => {
      if (!isDesktopRuntime()) return;
      await remoteAccessRestart.save(enabled);
    },
    [remoteAccessRestart],
  );

  const handleExportWorkspaceConfig = useCallback(
    async (workspaceId: string) => {
      const workspace = workspaces.find((item) => item.id === workspaceId) ?? null;
      if (!workspace) return;
      const endpoint = endpointForWorkspace(workspace);
      if (endpoint) {
        const payload = await endpoint.client.exportWorkspace(endpoint.workspaceId);
        downloadWorkspaceJson(workspaceExportFilename(workspace), payload);
        return;
      }
      throw new Error("omnirush.ai server is unavailable. Reconnect the server before exporting workspace config.");
    },
    [endpointForWorkspace, workspaces],
  );

  const removeWorkspaceConfirmed = useCallback(
    async (workspaceId: string): Promise<void> => {
      // Remove from both stores so the next refresh can't resurrect the row
      // from whichever list wins the merge.
      try {
        await removeRouteWorkspace({
          workspaceId,
          deleteFromServer: client ? (id) => client.deleteWorkspace(id) : null,
          forgetOnDesktop: isDesktopRuntime() ? workspaceForget : null,
          closeTerminals: closeWorkspaceTerminals,
        });
      } catch (error) {
        console.error("[session-route] remove workspace failed", error);
        toast.error(t("workspace_list.remove_failed"), {
          id: `workspace-remove:${workspaceId}`,
          duration: 30_000,
          description: describeRouteError(error),
          action: { label: t("common.retry"), onClick: () => void removeWorkspaceConfirmed(workspaceId) },
        });
        await refreshRouteState();
        return;
      }
      if (selectedWorkspaceId === workspaceId) {
        setLegacySelectedWorkspaceId("");
        writeActiveWorkspaceId(null);
        navigate(legacySessionRoute());
      }
      forgetWorkspaceMemory(workspaceId);
      sessionManagementStore.getState().forgetWorkspace(workspaceId);
      await refreshRouteState();
    },
    [client, navigate, refreshRouteState, selectedWorkspaceId],
  );

  const handleForgetWorkspace = useCallback(
    async (workspaceId: string) => {
      if (typeof window !== "undefined") {
        const message =
          t("workspace_list.remove_confirm") ||
          "Remove this workspace from the sidebar?";
        if (!window.confirm(message)) return;
      }
      await removeWorkspaceConfirmed(workspaceId);
    },
    [removeWorkspaceConfirmed],
  );


  const applyLastUsedModelToSession = useCallback((sessionId: string, workspaceId: string) => {
    // The open chat's model carries over only inside its own project; another project starts on its own pick or the app default.
    const previous = selectedSessionId && workspaceId === selectedWorkspaceId ? getSessionModelSelection(selectedSessionId) : null;
    const own = previous ?? getSessionModelSelection(projectModelKey(workspaceId));
    const model = own?.model ?? appLocal.prefs.defaultModel;
    if (!model?.providerID || !model.modelID) return;
    const variant = own ? own.variant : (appLocal.prefs.modelVariant ?? null);
    useSessionModelStore.getState().setModel(sessionId, model, variant);
    if (previous) rememberProjectModel(workspaceId, previous);
  }, [appLocal.prefs.defaultModel, appLocal.prefs.modelVariant, selectedSessionId, selectedWorkspaceId]);

  const handleCreateTaskInWorkspaceWithOpenMode = useCallback(async (
    workspaceId: string,
    openAs: "primary" | "split",
    source: "new_task" | "new_split" = openAs === "split" ? "new_split" : "new_task",
  ): Promise<string | null> => {
    const sideChatOwner = openAs === "split" ? useWorkbenchStore.getState().primary : null;
    if (openAs === "split" && !sideChatOwner) return null;
    const workspace = workspaces.find((item) => item.id === workspaceId);
    if (
      !workspace ||
      loading ||
      retryingWorkspaceIds.includes(workspaceId)
    ) {
      return null;
    }
    const endpoint = endpointForWorkspace(workspace);
    if (!endpoint || !endpoint.token) {
      return null;
    }
    const toastId = taskCreateUnavailableToastId(workspaceId);
    const attempts = TASK_CREATE_RETRY_DELAYS_MS.length + 1;
    try {
      setErrorsByWorkspaceId((current) => ({ ...current, [workspaceId]: null }));
      setRouteError(null);
      // A stalled engine (rollover, overload) misses the 10 s request timeout
      // and used to surface as a dead-end "unavailable" toast that only Cmd+R
      // seemed to fix. Retry transient failures with a visible countdown first.
      const session = await withTransientEngineRetry({
        load: () => createRouteSession(endpoint, workspace.path?.trim() || undefined),
        retryDelaysMs: TASK_CREATE_RETRY_DELAYS_MS,
        onRetry: (attempt) => {
          const notice = describeTaskCreateRetry({ developerMode, attempt, attempts });
          toast.info(notice.title, {
            id: toastId,
            description: notice.description,
            duration: Infinity,
          });
        },
      });
      if (workspaceId === selectedWorkspaceId) {
        void refreshCloudProviderSync("new_chat");
      }
      captureAnalyticsEvent("task_created", {
        source,
        workspace_type: workspace.workspaceType ?? "unknown",
      });
      toast.dismiss(taskCreateUnavailableToastId(workspaceId));
      toast.dismiss();
      if (openAs === "primary") {
        setLegacySelectedWorkspaceId(workspaceId);
        writeActiveWorkspaceId(workspaceId || null);
        writeLastSessionFor(workspaceId, session.id);
      }
      useComposerStateStore.setState({ pendingFocusSessionId: session.id });
      rememberPendingCreatedSession(workspaceId, session.id);
      applyLastUsedModelToSession(session.id, workspaceId);
      setSessionsByWorkspaceId((current) => {
        const next = {
          ...current,
          [workspaceId]: mergeWorkspaceRouteSession(current[workspaceId] ?? [], session),
        };
        sessionsByWorkspaceIdRef.current = next;
        return next;
      });
      if (openAs === "primary") {
        navigateToWorkspaceSession(workspaceId, session.id);
      } else {
        const tab = {
          workspaceId,
          workspaceTitle: workspace.displayNameResolved.trim() || workspaceId,
          sessionId: session.id,
          title: session.title,
        };
        const workbench = useWorkbenchStore.getState();
        workbench.openTab(tab);
        if (sideChatOwner) {
          workbench.setSideChat(sideChatOwner, tab);
        }
      }
      return session.id;
    } catch (error) {
      const message = describeTaskCreateError(error);
      setRouteError(message);
      setErrorsByWorkspaceId((current) => ({ ...current, [workspaceId]: message }));
      const failure = describeTaskCreateFailure(error, attempts);
      toast.error(failure.title, {
        id: toastId,
        description: failure.description,
        action: {
          label: "Retry",
          onClick: () => void handleCreateTaskInWorkspaceWithOpenMode(workspaceId, openAs, source),
        },
        // A blue/green reload brings up a fresh engine without killing live
        // sessions; the full desktop restart stays a last resort elsewhere.
        ...(failure.kind === "not_responding"
          ? {
              cancel: {
                label: t("session.engine_reload_action"),
                onClick: () => {
                  void reloadEngineWithDesktopFallback(endpoint.client, endpoint.workspaceId)
                    .then(() => handleCreateTaskInWorkspaceWithOpenMode(workspaceId, openAs, source))
                    .catch(() => undefined);
                },
              },
            }
          : {}),
        duration: Infinity,
      });
      if (isTransientStartupError(message)) {
        setRetryingWorkspaceIds((current) => Array.from(new Set([...current, workspaceId])));
        if (startupRetryTimerRef.current === null) {
          startupRetryTimerRef.current = window.setTimeout(() => {
            startupRetryTimerRef.current = null;
            void refreshRouteState({ supersede: true });
          }, 1_000);
        }
      }
      return null;
    }
  }, [applyLastUsedModelToSession, developerMode, endpointForWorkspace, loading, navigateToWorkspaceSession, refreshCloudProviderSync, refreshRouteState, rememberPendingCreatedSession, retryingWorkspaceIds, selectedWorkspaceId, workspaces]);

  const handleCreateTaskInWorkspace = useCallback((workspaceId: string): Promise<string | null> => {
    const { focusedPane, secondary } = useWorkbenchStore.getState();
    const openAs = focusedPane === "secondary" && secondary ? "split" : "primary";
    return handleCreateTaskInWorkspaceWithOpenMode(workspaceId, openAs, "new_task");
  }, [handleCreateTaskInWorkspaceWithOpenMode]);

  const handleCreateSplitTaskInWorkspace = useCallback(
    (workspaceId: string): Promise<string | null> => handleCreateTaskInWorkspaceWithOpenMode(workspaceId, "split"),
    [handleCreateTaskInWorkspaceWithOpenMode],
  );

  // Latest session-list state for prev/next session tab navigation. The
  // `options` field is updated by `onSessionTabsChange` from SessionPage so we
  // only cycle through tabs the user actually opened (not artifact sessions).
  // The remaining fields are refreshed during render.
  const sessionTabNavRef = useRef<{
    options: OpenSessionTab[];
    workspaceId: string;
    sessionId: string | null;
    navigate: (workspaceId: string, sessionId?: string | null) => void;
  }>({ options: [], workspaceId: "", sessionId: null, navigate: () => {} });

  const goToSessionTabByOffset = useCallback((offset: number) => {
    const { options, workspaceId, sessionId, navigate } = sessionTabNavRef.current;
    const scoped = options.filter((option) => option.workspaceId === workspaceId);
    if (scoped.length === 0) return;
    const currentIndex = sessionId
      ? scoped.findIndex((option) => option.sessionId === sessionId)
      : -1;
    const nextIndex = currentIndex === -1
      ? offset > 0 ? 0 : scoped.length - 1
      : (currentIndex + offset + scoped.length) % scoped.length;
    const target = scoped[nextIndex];
    if (!target || target.sessionId === sessionId) return;
    navigate(target.workspaceId, target.sessionId);
  }, []);

  const goToNextSessionTab = useCallback(() => goToSessionTabByOffset(1), [goToSessionTabByOffset]);
  const goToPrevSessionTab = useCallback(() => goToSessionTabByOffset(-1), [goToSessionTabByOffset]);

  const cycleThinkingMode = useCallback((direction: ThinkingModeShortcutDirection = "forward") => {
    const workbench = useWorkbenchStore.getState();
    const activeSessionId = workbench.focusedPane === "secondary" && workbench.secondary
      ? workbench.secondary.sessionId
      : selectedSessionId;
    const selection = activeSessionId ? getSessionModelSelection(activeSessionId) : null;
    const summary = selection
      ? (() => {
          const model = providerCatalog?.[selection.model.providerID]?.[selection.model.modelID];
          return model
            ? getModelBehaviorSummary(selection.model.providerID, model, selection.variant)
            : null;
        })()
      : null;
    const options = selection ? (summary?.options ?? []) : modelBehaviorOptions;
    const current = selection ? (summary?.value ?? selection.variant) : modelVariantValue;
    const next = direction === "reverse"
      ? previousModelBehaviorValue(options, current)
      : nextModelBehaviorValue(options, current);
    if (!next) return null;

    if (activeSessionId && selection) {
      useSessionModelStore.getState().setVariant(activeSessionId, next);
    }
    // Match the composer's existing variant change path: session overrides are
    // remembered per conversation and the global fallback follows the choice.
    local.setPrefs((previous) => ({ ...previous, modelVariant: next }));
    return options.find((option) => option.value === next)?.label ?? next;
  }, [local, modelBehaviorOptions, modelVariantValue, providerCatalog, selectedSessionId]);

  const cycleThinkingModeControlAction = useMemo<OmniRushControlAction>(() => ({
    id: "session.model_variant.cycle",
    label: "Cycle thinking mode",
    description: "Advance the focused conversation to its next available thinking or reasoning effort.",
    sideEffect: "mutation",
    execute: () => {
      const label = cycleThinkingMode();
      return label ? { ok: true, label } : { ok: false, error: "The focused model has fewer than two thinking modes." };
    },
  }), [cycleThinkingMode]);
  useControlAction(cycleThinkingModeControlAction);

  const cycleFavoriteModel = useCallback(() => {
    const workbench = useWorkbenchStore.getState();
    const activeSessionId = workbench.focusedPane === "secondary" && workbench.secondary
      ? workbench.secondary.sessionId
      : selectedSessionId;
    const selection = activeSessionId ? getSessionModelSelection(activeSessionId) : null;
    const currentModel = selection?.model ?? local.prefs.defaultModel ?? null;
    const next = nextFavoriteModel(useModelCollectionsStore.getState().favorites, currentModel);
    if (!next) return null;

    const providerModel = providerCatalog?.[next.providerID]?.[next.modelID];
    const summary = providerModel
      ? getModelBehaviorSummary(next.providerID, providerModel, selection?.variant ?? modelVariantValue)
      : null;
    const variant = summary && summary.options.length > 0 ? summary.value : null;
    if (activeSessionId) {
      useSessionModelStore.getState().setModel(activeSessionId, next, variant);
    }
    useModelCollectionsStore.getState().recordRecent(next);
    local.setPrefs((previous) => ({ ...previous, defaultModel: next, modelVariant: variant }));
    return resolveModelDisplayName(next.modelID, providerModel?.name);
  }, [local, modelVariantValue, providerCatalog, selectedSessionId]);

  const cycleFavoriteModelControlAction = useMemo<OmniRushControlAction>(() => ({
    id: "session.favorite_model.cycle",
    label: "Cycle favorite model",
    description: "Switch the focused conversation to its next favorite model.",
    sideEffect: "mutation",
    execute: () => {
      const label = cycleFavoriteModel();
      return label ? { ok: true, label } : { ok: false, error: "Add a favorite model before cycling favorites." };
    },
  }), [cycleFavoriteModel]);
  useControlAction(cycleFavoriteModelControlAction);

  const {
    commandPaletteOpen,
    setCommandPaletteOpen,
    sessionSearchOpen,
    setSessionSearchOpen,
    terminalOpen,
    setTerminalOpen,
    sessionNumberShortcuts,
  } = useShellShortcuts({
    canCreateTask,
    workspaceId: selectedWorkspaceId,
    onCreateTask: (workspaceId: string) => void handleCreateTaskInWorkspace(workspaceId),
    onNextSessionTab: goToNextSessionTab,
    onPrevSessionTab: goToPrevSessionTab,
    onCycleThinkingMode: cycleThinkingMode,
    onCycleFavoriteModel: cycleFavoriteModel,
  });
  useReactRenderWatchdog("SessionRoute", {
    selectedSessionId,
    selectedWorkspaceId,
    loading,
    workspaceCount: workspaces.length,
    sessionGroupCount: Object.keys(sessionsByWorkspaceId).length,
    commandPaletteOpen,
    modelPickerOpen: modelPicker.open,
  });

  const navigateToSessionForControl = useCallback((sessionId: string) => {
    const owner = Object.entries(sessionsByWorkspaceId).find(([, sessions]) =>
      (sessions ?? []).some((session) => session?.id === sessionId),
    )?.[0];
    navigateToWorkspaceSession(owner || selectedWorkspaceId, sessionId);
  }, [navigateToWorkspaceSession, selectedWorkspaceId, sessionsByWorkspaceId]);

  const navigateToSessionRootForControl = useCallback(() => {
    navigateToWorkspaceSession(selectedWorkspaceId);
  }, [navigateToWorkspaceSession, selectedWorkspaceId]);

  const openModelPickerForControl = useCallback(() => {
    // Opened while a conversation is visible: target that conversation so the
    // picker's checkmark and the selection it writes match the composer.
    setModelPickerSessionId(selectedSessionId || null);
    modelPicker.setOpen(true);
  }, [selectedSessionId]);

  useSessionControlActions({
    workspaces,
    sessionsByWorkspaceId,
    selectedWorkspaceId,
    selectedWorkspaceRoot,
    selectedSessionId,
    canCreateTask,
    omnirushClient: client,
    opencodeClient,
    archiveDisabledReason,
    endpointForWorkspace,
    navigateToSession: navigateToSessionForControl,
    navigateToSessionRoot: navigateToSessionRootForControl,
    createTaskInWorkspace: handleCreateTaskInWorkspace,
    openModelPicker: openModelPickerForControl,
    refreshRouteState,
    forgetDeletedSession,
  });

  const seedUnavailableModelControlAction = useMemo<OmniRushControlAction | null>(() => {
    if (!import.meta.env.DEV) return null;
    return {
      id: "eval.model_not_available.seed",
      label: "Seed an unavailable selected model",
      description: "Dev-only eval hook that selects a missing model and returns an available model to recover with. scope=default leaves the open conversation's remembered model untouched.",
      sideEffect: "mutation",
      disabled: !opencodeClient,
      args: [{ name: "scope", type: "string", description: "default | both (default: both)" }],
      execute: async (args) => {
        if (!opencodeClient) return { ok: false, error: "omnirush.ai client is not connected." };
        const scope = (args && typeof args === "object" && Reflect.get(args, "scope") === "default")
          ? "default"
          : "both";

        const providerList = await ensureProviderListQuery(getReactQueryClient(), {
          client: opencodeClient,
          baseUrl: opencodeBaseUrl,
          directory: selectedWorkspaceRoot || undefined,
          force: true,
        });
        const filteredProviderList = filterProviderList(providerList, disabledProviderIds);
        const availableProvider = getConnectedProviderItems(filteredProviderList)
          .filter((provider) => !isDesktopProviderBlocked({
            providerId: provider.id,
            checkRestriction: checkDesktopRestriction,
          }))
          .find((provider) => Object.keys(provider.models ?? {}).length > 0);
        const availableModelId = availableProvider ? Object.keys(availableProvider.models ?? {})[0] : undefined;
        const availableModel = availableProvider && availableModelId
          ? availableProvider.models[availableModelId]
          : undefined;

        if (!availableProvider || !availableModelId || !availableModel) {
          return { ok: false, error: "No available connected model found for eval recovery." };
        }

        const unavailableModel = nextEvalUnavailableModel(local.prefs.defaultModel);
        modelPicker.setQuery("");
        modelPicker.setRecentProviderIds(new Set());
        local.setPrefs((previous) => ({
          ...previous,
          defaultModel: unavailableModel,
          modelVariant: null,
        }));
        // Per-conversation memory is session-scoped: seeding "both" makes the
        // open conversation's own model unavailable; "default" reproduces the
        // workspace-switch state where only the global default is missing.
        if (scope === "both" && selectedSessionId) {
          useSessionModelStore.getState().setModel(selectedSessionId, unavailableModel, null);
        }

        return {
          scope,
          unavailableModel,
          availableModel: {
            providerID: availableProvider.id,
            providerName: availableProvider.name || availableProvider.id,
            modelID: availableModelId,
            title: availableModel.name || availableModelId,
          },
          sessionId: selectedSessionId,
          workspaceId: selectedWorkspaceId,
        };
      },
    };
  }, [checkDesktopRestriction, disabledProviderIds, local, modelPicker.setQuery, modelPicker.setRecentProviderIds, opencodeBaseUrl, opencodeClient, selectedSessionId, selectedWorkspaceId, selectedWorkspaceRoot]);
  useControlAction(seedUnavailableModelControlAction);

  const seedActiveSessionSidebarControlAction = useMemo<OmniRushControlAction | null>(() => {
    if (!import.meta.env.DEV) return null;
    return {
      id: "eval.session_sidebar.seed_active",
      label: "Show the selected session as active",
      description: "Dev-only eval hook that displays the selected session activity spinner.",
      sideEffect: "mutation",
      disabled: !selectedWorkspaceId || !selectedSessionId,
      execute: () => {
        if (!selectedWorkspaceId || !selectedSessionId) {
          return { ok: false, error: "No session is selected." };
        }
        useSessionActivityStore.getState().setRunStatus(selectedWorkspaceId, selectedSessionId, "running");
        return { workspaceId: selectedWorkspaceId, sessionId: selectedSessionId };
      },
    };
  }, [selectedSessionId, selectedWorkspaceId]);
  useControlAction(seedActiveSessionSidebarControlAction);

  const seedChildPermissionControlAction = useMemo<OmniRushControlAction | null>(() => {
    if (!import.meta.env.DEV) return null;
    return {
      id: "eval.child_permission.seed",
      label: "Seed a child session permission request",
      description: "Dev-only eval hook that creates a child session blocked on a permission request.",
      sideEffect: "mutation",
      disabled: !selectedWorkspaceId || !selectedSessionId,
      execute: (args) => {
        if (!selectedWorkspaceId || !selectedSessionId) {
          return { ok: false, error: "No session is selected." };
        }
        const parent = (sessionsByWorkspaceId[selectedWorkspaceId] ?? []).find(
          (session) => session.id === selectedSessionId,
        );
        if (!parent) return { ok: false, error: "The selected session is unavailable." };

        const browserBranding = typeof args === "object" && args !== null
          && Reflect.get(args, "browserBranding") === true;
        const browserTool = "opencode-chrome-devtools_browser_open";

        const childSessionId = `${selectedSessionId}:eval-child`;
        // Match a real session.created event: a concurrent list snapshot must
        // not remove this newly seeded child before its approval is answered.
        rememberPendingCreatedSession(selectedWorkspaceId, childSessionId);
        const request: PendingPermission = {
          id: `${selectedSessionId}:eval-child-permission`,
          sessionID: childSessionId,
          permission: browserBranding ? browserTool : "bash",
          patterns: browserBranding ? [browserTool] : ["git status --short --branch"],
          metadata: browserBranding ? {
            tool: browserTool,
            description: "OpenCode browser access",
          } : {
            command: "git status --short --branch",
            description: "Inspect the delegated task workspace",
          },
          always: [],
          // Keep this deterministic proof request newer than any concurrent
          // snapshot so the dev seam behaves like a live post-snapshot event.
          receivedAt: Number.MAX_SAFE_INTEGER,
          protocol: "legacy",
          evaluation: true,
        };
        setSessionsByWorkspaceId((current) => ({
          ...current,
          [selectedWorkspaceId]: [
            ...(current[selectedWorkspaceId] ?? []).filter((session) => session.id !== childSessionId),
            {
              ...parent,
              id: childSessionId,
              title: "Investigate the deployment failure",
              parentID: selectedSessionId,
              time: { ...parent.time, created: Date.now(), updated: Date.now() },
            },
          ],
        }));
        const runtimeWorkspaceId = selectedWorkspaceEndpoint?.workspaceId ?? selectedWorkspaceId;
        getReactQueryClient().setQueryData<PendingPermission[]>(
          permissionKey(runtimeWorkspaceId, childSessionId),
          [request],
        );
        useSessionActivityStore.getState().setWaitingRequest(
          runtimeWorkspaceId,
          childSessionId,
          "permission",
          request.id,
          true,
        );
        return { childSessionId };
      },
    };
  }, [rememberPendingCreatedSession, selectedSessionId, selectedWorkspaceEndpoint?.workspaceId, selectedWorkspaceId, sessionsByWorkspaceId, setSessionsByWorkspaceId]);
  useControlAction(seedChildPermissionControlAction);

  const commandPaletteControlAction = useMemo<OmniRushControlAction>(() => ({
    id: "command_palette.open",
    label: "Open the command palette",
    description: "Open the in-app command palette so the next choice is visible.",
    effects: { data: "none", ui: "dialog", external: false },
    sideEffect: "none",
    execute: () => setCommandPaletteOpen(true),
  }), []);
  useControlAction(commandPaletteControlAction);

  const addProviderControlAction = useMemo<OmniRushControlAction>(() => ({
    id: "settings.provider.add",
    label: "Add a model provider",
    description: "Open the provider connection modal, optionally pre-filtered to a specific provider.",
    sideEffect: "mutation",
    requiresArgs: false,
    args: [
      { name: "providerId", type: "string" as const, required: false, description: "Provider id to pre-select, e.g. 'anthropic', 'openai', 'google'." },
    ],
    execute: async (rawArgs: unknown) => {
      const providerId = typeof rawArgs === "object" && rawArgs !== null
        ? (rawArgs as Record<string, unknown>).providerId
        : undefined;
      const preferred = typeof providerId === "string" ? providerId.trim() : undefined;
      if (sessionProviderAuthStore.isProviderAddRestricted(preferred)) {
        return { ok: false, error: isProviderLocked() ? providerLockMessage() : t("providers.custom_providers_disabled") };
      }
      await sessionProviderAuthStore.openProviderAuthModal(
        preferred ? { preferredProviderId: preferred } : undefined,
      );
      return { ok: true, opened: "provider_auth_modal", preferredProviderId: preferred ?? null };
    },
  }), [sessionProviderAuthStore]);
  useControlAction(addProviderControlAction);

  const handleOpenProviderAuth = useCallback(() => {
    if (sessionProviderAuthStore.isProviderAddRestricted()) {
      restrictionNotice.show({
        title: t("restrictions.add_custom_providers_disabled_title"),
        message: isProviderLocked() ? providerLockMessage() : t("restrictions.add_custom_providers_disabled_message"),
      });
      return;
    }

    // Pre-workspace (chat-first) there is no opencode client yet, so the
    // modal cannot load auth methods — fall back to the AI Providers page.
    void sessionProviderAuthStore.openProviderAuthModal({ returnFocusTarget: "composer" }).catch(() => {
      handleOpenSettings("/settings/ai");
    });
  }, [handleOpenSettings, restrictionNotice, sessionProviderAuthStore]);

  // "Connect more providers" in the compact model picker (and anything else
  // outside this route's prop tree) requests the provider auth modal here.
  useEffect(() => {
    const handler = () => handleOpenProviderAuth();
    window.addEventListener(openProviderAuthEvent, handler);
    return () => window.removeEventListener(openProviderAuthEvent, handler);
  }, [handleOpenProviderAuth]);

  const paletteSessionOptions = useMemo(
    // Chats of the mode in view only (recent chats on the start screen, the palette).
    () => buildCommandPaletteSessions(workspaces.filter((workspace) => shownInMode(workspace, workEnabled, appMode)), sessionsByWorkspaceId, selectedWorkspaceId),
    [appMode, sessionsByWorkspaceId, selectedWorkspaceId, workEnabled, workspaces],
  );

  const paletteSessionModelSelection = selectedSessionId
    ? getSessionModelSelection(selectedSessionId)
    : null;
  const paletteSelectedModel = paletteSessionModelSelection?.model
    ?? local.prefs.defaultModel
    ?? undefined;
  const paletteSelectedModelBehavior = paletteSessionModelSelection
    ? (() => {
        const selected = paletteSessionModelSelection.model;
        const model = providerCatalog?.[selected.providerID]?.[selected.modelID];
        return model
          ? getModelBehaviorSummary(
              paletteSessionModelSelection.model.providerID,
              model,
              paletteSessionModelSelection.variant,
            ).value
          : paletteSessionModelSelection.variant;
      })()
    : modelVariantValue;

  // Every list the route shows: the project's allowed models (Claude's come from the engine's Claude provider).
  const pickerOptions = useMemo(
    () => modelPicker.options.filter((option) => modelModes.allowsNew(option)),
    [modelModes, modelPicker.options],
  );
  // A pick the picker should not just switch to (claude-models.ts decideModelPick).
  const [newChatOffer, setNewChatOffer] = useState<{ next: ModelRef; current: ModelRef } | null>(null);
  const modelTitle = (ref: ModelRef) => isClaudeModel(ref)
    ? claudeModelName(useClaudeModels.getState(), ref.modelID)
    : modelPicker.options.find((option) => option.providerID === ref.providerID && option.modelID === ref.modelID)?.title ?? resolveModelDisplayName(ref.modelID);
  /** Claude runs in the sandbox: set the project's sandbox up (as the required sandbox does) before its first turn. */
  const setUpSandboxForClaude = () => {
    const endpoint = selectedWorkspaceEndpoint;
    if (!endpoint?.client) return;
    void setUpClaudeSandbox(endpoint.client, endpoint.workspaceId).catch(() => {
      toast.error("The sandbox could not be set up for Claude. Check Settings > General > Sandbox.", { id: "claude-sandbox" });
    });
  };
  const handleModelPick = (next: ModelRef, sessionId: string | null): boolean => {
    const current = sessionId ? getSessionModelSelection(sessionId)?.model ?? null : null;
    const pick = decideModelPick({ next, current, started: Boolean(sessionId && chatStarted(sessionId)), claude: useClaudeModels.getState(), switchable: modelModesRef.current.switchable });
    if (pick.kind === "unavailable") toast(pick.message, { id: `claude-unavailable:${next.modelID}` });
    else if (pick.kind === "new_chat" && current) setNewChatOffer({ next, current });
    else if (pick.kind === "claude") setUpSandboxForClaude();
    // A Claude pick in a fresh chat is a plain switch once the sandbox is on its way.
    return pick.kind !== "switch" && pick.kind !== "same" && pick.kind !== "claude";
  };
  const modelPickRef = useRef(handleModelPick);
  modelPickRef.current = handleModelPick;
  useEffect(() => {
    useModelPickGate.setState({ intercept: (next, sessionId) => modelPickRef.current(next, sessionId) });
    return () => useModelPickGate.setState({ intercept: () => false });
  }, []);
  const confirmNewChat = async () => {
    const offer = newChatOffer;
    setNewChatOffer(null);
    if (!offer || !selectedWorkspaceId) return;
    if (isClaudeModel(offer.next)) setUpSandboxForClaude();
    const sessionId = await handleCreateTaskInWorkspace(selectedWorkspaceId);
    if (!sessionId) return;
    useSessionModelStore.getState().setModel(sessionId, offer.next, null);
    local.setPrefs((previous) => ({ ...previous, defaultModel: offer.next, modelVariant: null }));
  };

  const applySessionRouteModelSelection = useCallback((
    next: ModelRef,
    targetSessionId: string | null,
    behavior?: { value: string | null },
  ) => {
    const explicitBehavior = behavior !== undefined;
    // One provider per chat (a started chat offers a new one for another provider), and Claude opens its own chat.
    if (modelPickRef.current(next, targetSessionId)) return;
    useModelCollectionsStore.getState().recordRecent(next);
    if (targetSessionId) {
      const sessionStore = useSessionModelStore.getState();
      sessionStore.setModel(targetSessionId, next, explicitBehavior ? behavior.value : undefined);
      if (explicitBehavior) sessionStore.setVariant(targetSessionId, behavior.value);
    }
    local.setPrefs((previous) => ({
      ...previous,
      defaultModel: next,
      modelVariant: explicitBehavior
        ? behavior.value
        : previous.defaultModel?.providerID === next.providerID && previous.defaultModel.modelID === next.modelID
          ? previous.modelVariant
          : null,
    }));
    focusPromptSoon();
  }, [local]);

  // Refresh the non-tab fields of the nav ref during render. The `options`
  // field is maintained by the `onSessionTabsChange` callback from SessionPage.
  sessionTabNavRef.current = {
    options: sessionTabNavRef.current.options,
    workspaceId: selectedWorkspaceId,
    sessionId: selectedSessionId,
    navigate: navigateToWorkspaceSession,
  };

  const paletteSessionGroups = useMemo<SessionGroupOption[]>(
    () => selectedWorkspaceGroupState?.groups ?? [],
    [selectedWorkspaceGroupState?.groups],
  );

  const currentSessionForGroupMove = useMemo(() => {
    if (!selectedWorkspaceId || !selectedSessionId) return null;
    return paletteSessionOptions.find(
      (session) => session.workspaceId === selectedWorkspaceId && session.sessionId === selectedSessionId,
    ) ?? null;
  }, [paletteSessionOptions, selectedSessionId, selectedWorkspaceId]);

  const currentSessionActionPaletteItems = useMemo<PaletteItem[]>(() => {
    if (!selectedSessionId || !selectedWorkspaceId || !currentSessionForGroupMove) return [];
    const items: PaletteItem[] = [{
      id: "session.pin.toggle",
      title: currentSessionPinned
        ? t("session_management.unpin_session")
        : t("session_management.pin_session"),
      detail: currentSessionForGroupMove.title,
      meta: "Session",
      keywords: ["pin", "unpin", "favorite", "star", "keep on top", "sidebar"],
      group: "actions",
      action: () => {
        setCommandPaletteOpen(false);
        sessionManagementStore.getState().togglePin(selectedSessionId);
      },
    }];
    if (opencodeClient) {
      items.push({
        id: "session.rename",
        title: "Rename session…",
        detail: currentSessionForGroupMove.title,
        meta: "Session",
        keywords: ["rename", "title", "name", "edit title"],
        group: "actions",
        action: () => {
          setCommandPaletteOpen(false);
          requestRenameSession(selectedSessionId);
        },
      });
    }
    return items;
  }, [currentSessionForGroupMove, currentSessionPinned, opencodeClient, selectedSessionId, selectedWorkspaceId]);

  const currentSessionGroupId = selectedSessionId
    ? selectedWorkspaceGroupState?.assignments[selectedSessionId] ?? null
    : null;

  const handleMoveCurrentSessionToGroup = useCallback((groupId: string) => {
    if (!selectedWorkspaceId || !selectedSessionId) return;
    assignSessionToGroup(selectedWorkspaceId, selectedSessionId, groupId);
  }, [assignSessionToGroup, selectedSessionId, selectedWorkspaceId]);

  const sessionSearchFetcher = useMemo<SessionMessageFetcher | null>(() => {
    if (!client) return null;
    // Cap the transcript fetch to keep multi-workspace scans fast; matches in
    // anything older than the most recent 400 messages are traded away for
    // responsiveness.
    return async (workspaceId: string, sessionId: string) => {
      const workspace = workspaces.find((item) => item.id === workspaceId);
      const endpoint = endpointForWorkspace(workspace);
      if (!endpoint) throw new Error("Workspace runtime is not connected.");
      return getNativeSessionMessages(endpoint, sessionId, { limit: 400 });
    };
  }, [client, endpointForWorkspace, workspaces]);

  // The start screen (no chat open): a quiet row of recent chats to continue and the chat search.
  const homeView = useMemo<HomeViewContext>(() => ({
    sessions: paletteSessionOptions,
    workspaces: workspaces.map((workspace) => ({ id: workspace.id, name: workspace.displayNameResolved, task: Boolean(workspace.task) })),
    onOpenSearch: () => setSessionSearchOpen(true),
    onOpenSession: (workspaceId, sessionId) => {
      setLegacySelectedWorkspaceId(workspaceId);
      writeActiveWorkspaceId(workspaceId);
      writeLastSessionFor(workspaceId, sessionId);
      navigateToWorkspaceSession(workspaceId, sessionId);
    },
  }), [navigateToWorkspaceSession, paletteSessionOptions, setLegacySelectedWorkspaceId, setSessionSearchOpen, workspaces]);

  const tasksPaletteItems = useMemo<PaletteItem[]>(() => tasksAvailable ? [{
    id: "tasks.open",
    title: "Open parallel tasks",
    detail: tasksRunningCount ? `${tasksRunningCount} running` : "Tasks that run in their own copy of this repository",
    meta: "Tasks",
    searchText: "parallel tasks agents worktree board background",
    action: () => {
      setCommandPaletteOpen(false);
      navigate(workspaceTasksRoute(tasksBoardWorkspaceId));
    },
  }, {
    id: "tasks.new",
    title: "New parallel task…",
    detail: "Run a prompt in a separate copy of this repository",
    meta: "Tasks",
    searchText: "new parallel task agent worktree branch background",
    action: () => {
      setCommandPaletteOpen(false);
      navigate(`${workspaceTasksRoute(tasksBoardWorkspaceId)}?new=1`);
    },
  }] : [], [navigate, tasksAvailable, tasksBoardWorkspaceId, tasksRunningCount]);

  const sessionSearchPaletteItem = useMemo<PaletteItem>(() => ({
    id: "session-search.open",
    title: "Search session messages",
    detail: "Deep search every session, including message content",
    meta: "Cmd/Ctrl+Shift+F",
    searchText: "search find sessions messages history transcript content",
    action: () => {
      setCommandPaletteOpen(false);
      setSessionSearchOpen(true);
    },
  }), []);

  const sessionFindPaletteItem = useMemo<PaletteItem | null>(() => {
    if (!selectedSessionId) return null;
    return {
      id: "session-find.open",
      title: "Find in conversation",
      detail: "Search within the current conversation",
      meta: "Cmd/Ctrl+F",
      searchText: "find search current conversation session messages transcript",
      action: () => {
        setCommandPaletteOpen(false);
        useSessionFindStore.getState().openFind({ sessionId: selectedSessionId });
      },
    };
  }, [selectedSessionId]);

  const editorLanguageFeatures = useEditorStore((state) => state.languageFeatures);
  const layoutModeName = useEditorStore((state) => (selectedWorkspaceId ? state.modeByWorkspace[selectedWorkspaceId] : undefined) ?? "chat");
  const layoutAvailable = isElectronRuntime() && Boolean(selectedWorkspace) && selectedWorkspace?.workspaceType !== "remote";
  const layoutPaletteItems = useMemo<PaletteItem[]>(() => layoutAvailable ? [
    {
      id: "layout.toggle",
      title: layoutModeName === "ide" ? "Switch to Chat layout" : "Switch to IDE layout",
      detail: "Chat: sessions and the conversation. IDE: files, editor and terminal, with the chat on the right",
      meta: "Cmd/Ctrl+Shift+Y",
      searchText: "layout ide editor chat mode code files switch toggle",
      action: () => {
        setCommandPaletteOpen(false);
        useEditorStore.getState().requestModeToggle();
      },
    },
    ...(layoutModeName === "ide" ? ([
      ["editor.search", "Search in files", "Find and replace across the project", "Cmd/Ctrl+Shift+F", "search"],
      ["editor.problems", "Show problems", "Errors and warnings from the language servers", "Cmd+Shift+M (macOS)", "problems"],
      ["editor.quick-open", "Go to file", "Open a project file by name", "Cmd/Ctrl+P", "quick-open"],
      ["editor.symbol", "Go to symbol in file", "Jump to a function, class or variable", "Cmd/Ctrl+Shift+O", "symbol"],
      ["editor.outline", "Show outline", "The active file's symbols, under Files", "", "outline"],
      ["editor.split", "Split editor", "Open the current file in a second editor group", "Cmd/Ctrl+\\", "split"],
      ["editor.preview", "Open Markdown preview to the side", "The current Markdown file, rendered in the other group", "Cmd/Ctrl+Shift+V", "preview-side"],
      ["editor.preview-here", "Open Markdown preview", "The current Markdown file, rendered in this group", "", "preview-here"],
      ["editor.focus-other-group", "Focus the other editor group", "Move the keyboard to the other side of a split editor", "", "focus-other-group"],
    ] as const).map(([id, title, detail, meta, command]) => ({
      id,
      title,
      detail,
      meta,
      searchText: `editor ide ${title} ${detail}`.toLowerCase(),
      action: () => {
        setCommandPaletteOpen(false);
        window.dispatchEvent(new CustomEvent("omnirush:editor-command", { detail: command }));
      },
    })) : []),
    ...(layoutModeName === "ide" ? [{
      id: "editor.language-features",
      title: editorLanguageFeatures ? "Turn off language features in the editor" : "Turn on language features in the editor",
      detail: "Problems, hover, go to definition, rename and outline from the project's language servers",
      meta: "",
      searchText: "editor ide language features lsp problems hover rename outline server off on",
      action: () => {
        setCommandPaletteOpen(false);
        useEditorStore.getState().setLanguageFeatures(!editorLanguageFeatures);
      },
    }, {
      id: "layout.chat-panel",
      title: "Show or hide the chat",
      detail: "Fold the chat panel of the IDE layout away, or bring it back",
      meta: "Cmd/Ctrl+Shift+H",
      searchText: "chat panel hide show collapse ide",
      action: () => {
        setCommandPaletteOpen(false);
        useEditorStore.getState().requestChatToggle();
      },
    }] : []),
  ] : [], [layoutAvailable, layoutModeName]);

  const terminalPaletteItems = useMemo<PaletteItem[]>(() => platform.capabilities.terminal ? [
    {
      id: "terminal.toggle",
      title: terminalOpen ? "Hide terminal" : "Show terminal",
      detail: "Toggle the integrated terminal panel for this workspace",
      meta: "Cmd/Ctrl+J",
      searchText: "terminal shell command line console show hide toggle",
      action: () => {
        setCommandPaletteOpen(false);
        setTerminalOpen((value) => !value);
      },
    },
  ] : [], [platform.capabilities.terminal, terminalOpen]);

  const developerModePaletteItem = useMemo<PaletteItem>(() => ({
    id: "developer-mode.toggle",
    title: developerMode ? t("settings.disable_developer_mode") : t("settings.enable_developer_mode"),
    detail: t("settings.developer_mode_desc"),
    meta: developerMode ? "On" : "Off",
    searchText: "developer dev mode debug diagnostics toggle enable disable",
    action: () => {
      setCommandPaletteOpen(false);
      setDeveloperMode((current) => {
        const next = !current;
        try { window.localStorage.setItem("omnirush.developerMode", next ? "1" : "0"); } catch {}
        return next;
      });
    },
  }), [developerMode]);

  // A focused side chat is the conversation people are looking at, so its ID is
  // the one to copy and report. It only shows beside the route's own session.
  const focusedSideChat = useWorkbenchStore((state) => (
    state.focusedPane === "secondary"
    && state.primary?.workspaceId === selectedWorkspaceId
    && state.primary.sessionId === selectedSessionId
      ? state.secondary
      : null
  ));
  const focusedSession = useMemo(() => (
    focusedSideChat ?? (selectedSessionId ? { workspaceId: selectedWorkspaceId, sessionId: selectedSessionId } : null)
  ), [focusedSideChat, selectedSessionId, selectedWorkspaceId]);

  const buildCommandDiagnosticsBundle = useCallback(() => buildDiagnosticsBundleJson({
    anyActiveRuns: activeReloadBlockingSessions.length > 0,
    canReloadWorkspace: reloadCoordinator.canReloadWorkspaceEngine,
    clientConnected: canCreateTask,
    developerMode,
    hostInfo: omnirushServerHostInfoState,
    omnirushServerStatus: client ? "connected" : "disconnected",
    omnirushServerUrl: baseUrl,
    runtimeWorkspaceId: selectedWorkspaceEndpoint?.workspaceId ?? null,
    focusedSession,
    selectedWorkspaceId,
  }), [
    activeReloadBlockingSessions.length,
    baseUrl,
    canCreateTask,
    client,
    developerMode,
    focusedSession,
    omnirushServerHostInfoState,
    reloadCoordinator.canReloadWorkspaceEngine,
    selectedWorkspaceEndpoint?.workspaceId,
    selectedWorkspaceId,
  ]);

  const copySessionIdPaletteItem = useMemo(() => buildCopySessionIdPaletteItem(focusedSession?.sessionId, (sessionId) => {
    setCommandPaletteOpen(false);
    void copySessionId(sessionId);
  }), [focusedSession?.sessionId]);

  const diagnosticsCopyPaletteItem = useMemo<PaletteItem>(() => ({
    id: "diagnostics.copy",
    title: t("session.cmd_diagnostics_copy_title"),
    detail: t("session.cmd_diagnostics_copy_detail"),
    searchText: "logs share diagnostics debug support bundle troubleshoot copy report issue",
    action: async () => {
      setCommandPaletteOpen(false);
      try {
        const json = await buildCommandDiagnosticsBundle();
        await navigator.clipboard.writeText(json);
        toast.success(t("session.diagnostics_copied"));
      } catch (error) {
        toast.error(t("session.diagnostics_failed"), { description: describeRouteError(error) });
      }
    },
  }), [buildCommandDiagnosticsBundle]);

  const diagnosticsExportPaletteItem = useMemo<PaletteItem>(() => ({
    id: "diagnostics.export",
    title: t("session.cmd_diagnostics_export_title"),
    detail: t("session.cmd_diagnostics_export_detail"),
    searchText: "logs export diagnostics debug support bundle save file json download",
    action: async () => {
      setCommandPaletteOpen(false);
      try {
        const json = await buildCommandDiagnosticsBundle();
        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
        downloadTextAsFile(`omnirush-diagnostics-${timestamp}.json`, json, "application/json");
        toast.success(t("session.diagnostics_exported"));
      } catch (error) {
        toast.error(t("session.diagnostics_failed"), { description: describeRouteError(error) });
      }
    },
  }), [buildCommandDiagnosticsBundle]);

  const nextSessionTabPaletteItem = useMemo<PaletteItem>(() => ({
    id: "session-tab.next",
    title: "Next session tab",
    detail: "Switch to the next session in this workspace",
    meta: "Cmd/Ctrl+T",
    searchText: "next session tab switch forward",
    action: () => {
      setCommandPaletteOpen(false);
      goToNextSessionTab();
    },
  }), [goToNextSessionTab]);

  const prevSessionTabPaletteItem = useMemo<PaletteItem>(() => ({
    id: "session-tab.previous",
    title: "Previous session tab",
    detail: "Switch to the previous session in this workspace",
    meta: "Cmd/Ctrl+Shift+T",
    searchText: "previous session tab switch back",
    action: () => {
      setCommandPaletteOpen(false);
      goToPrevSessionTab();
    },
  }), [goToPrevSessionTab]);

  const reloadConfigPaletteItem = useMemo<PaletteItem>(() => ({
    id: "reload-opencode-config",
    title: t("session.cmd_reload_config_title"),
    detail: t("session.cmd_reload_config_detail"),
    meta: reloadCoordinator.canReloadWorkspaceEngine
      ? t("config.reload_engine")
      : t("system.reload_unavailable"),
    searchText: "reload opencode config providers models mcp jsonc refresh re-read engine restart",
    action: () => {
      setCommandPaletteOpen(false);
      if (!reloadCoordinator.canReloadWorkspaceEngine) return;
      void reloadCoordinator.reloadWorkspaceEngine();
    },
  }), [reloadCoordinator.canReloadWorkspaceEngine, reloadCoordinator.reloadWorkspaceEngine]);

  const handleReorderWorkspaces = useCallback((workspaceIds: string[]) => {
    const activeWorkspaceIds = new Set(workspacesRef.current.map((workspace) => workspace.id));
    const nextOrderIds: string[] = [];
    const nextOrderIdSet = new Set<string>();

    for (const id of workspaceIds) {
      if (!activeWorkspaceIds.has(id) || nextOrderIdSet.has(id)) continue;
      nextOrderIds.push(id);
      nextOrderIdSet.add(id);
    }

    for (const workspace of workspacesRef.current) {
      if (nextOrderIdSet.has(workspace.id)) continue;
      nextOrderIds.push(workspace.id);
      nextOrderIdSet.add(workspace.id);
    }

    workspaceOrderIdsRef.current = nextOrderIds;
    setWorkspaceOrderIds(nextOrderIds);
    writeWorkspaceOrderIds(nextOrderIds);
    setWorkspaces((current) => orderRouteWorkspaces(current, nextOrderIds));
  }, []);

  const handleArchiveSession = useCallback(
    async (sessionId: string, archived: boolean) => {
      if (!opencodeClient) return;
      // The sidebar lists sessions from every workspace, so resolve the
      // session's owning workspace instead of assuming the selected one —
      // session.update needs the directory the session actually lives in.
      const ownerWorkspace = workspaceSessionGroups.find((group) =>
        group.sessions.some((session) => session?.id === sessionId),
      )?.workspace;
      const apply = async (nextArchived: boolean) => {
        try {
          await setSessionArchived(
            opencodeClient,
            sessionId,
            nextArchived,
            ownerWorkspace?.path || selectedWorkspaceRoot || undefined,
          );
          if (ownerWorkspace) await reloadWorkspaceSessions(ownerWorkspace.id);
          await refreshRouteState();
          return true;
        } catch (error) {
          console.error("[session-route] archive session failed", error);
          toast.error(
            nextArchived
              ? t("session_management.archive_failed")
              : t("session_management.unarchive_failed"),
            { description: describeRouteError(error) },
          );
          return false;
        }
      };
      if (!(await apply(archived))) return;
      // Archiving is easy to hit by accident from the row's hover actions, so
      // confirm it quietly with a way back. Undo reuses the same owner
      // workspace and does not announce itself again.
      toast.undo(
        archived
          ? t("session_management.session_archived")
          : t("session_management.session_unarchived"),
        {
          id: `session-archive:${sessionId}`,
          icon: archived ? Archive : ArchiveRestore,
          undo: { label: t("common.undo"), onClick: () => void apply(!archived) },
          view: ownerWorkspace
            ? { label: t("common.view"), onClick: () => navigateToWorkspaceSession(ownerWorkspace.id, sessionId) }
            : undefined,
          closeLabel: t("common.close"),
        },
      );
    },
    [navigateToWorkspaceSession, opencodeClient, refreshRouteState, reloadWorkspaceSessions, selectedWorkspaceRoot, workspaceSessionGroups],
  );

  const handleCreateWorkspace = useCallback(async (
    preset: WorkspacePreset,
    folder: string | null,
    options?: CreateWorkspaceOptions,
  ) => {
    if (!folder) return;
    const projectLabel = options?.projectLabel?.trim() ?? "";
    setCreateWorkspaceBusy(true);
    setCreateWorkspaceError(null);
    try {
      const workspaceName = folderNameFromPath(folder);
      let list: WorkspaceList | null = null;
      let createdOnServer = false;
      if (client) {
        list = await client
          .createLocalWorkspace({ folderPath: folder, name: workspaceName, preset })
          .then((serverList) => {
            createdOnServer = true;
            return serverList;
          })
          .catch(() => null);
      }
      if (!list) {
        throw new Error("omnirush.ai server is unavailable. Start or reconnect the server before creating a workspace.");
      }
      const createdId = resolveWorkspaceListSelectedId(list) || list.workspaces[list.workspaces.length - 1]?.id || "";
      let targetWorkspaceId = createdId;
      let targetWorkspace = list.workspaces.find((workspace: WorkspaceInfo) => workspace.id === createdId) ?? null;
      if (createdId) {
        await workspaceSetSelected(createdId).catch(() => undefined);
        await workspaceSetRuntimeActive(createdId).catch(() => undefined);
      }
      // First workspace on a fresh install: the omnirush.ai server was started
      // engine-less (it only spawns OpenCode at boot when a workspace already
      // exists), so sessions would hang forever. This boots the engine when
      // it isn't running, same as the old /welcome flow did.
      let sessionBaseUrl = baseUrl;
      let sessionToken = token;
      if (targetWorkspace && isDesktopRuntime()) {
        await ensureDesktopLocalOmniRushConnection({
          route: "session",
          workspace: targetWorkspace,
          allWorkspaces: list.workspaces,
        }).catch(() => undefined);
        // The engine boot can restart the server with fresh tokens; re-resolve
        // so the first-session creation below doesn't use stale credentials.
        const fresh = await resolveOmniRushConnection().catch(() => null);
        if (fresh?.normalizedBaseUrl && fresh.resolvedToken) {
          sessionBaseUrl = fresh.normalizedBaseUrl;
          sessionToken = fresh.resolvedToken;
        }
      }
      setCreateWorkspaceOpen(false);
      // Mark onboarding complete so the /welcome redirect never fires again.
      local.setPrefs((prev) => ({ ...prev, hasCompletedOnboarding: true }));
      await refreshRouteState();
      if (targetWorkspaceId) {
        const workspacePath = targetWorkspace?.path?.trim() || folder;
        const firstTaskPrompt = options?.firstTaskPrompt?.trim() ?? "";
        const firstTaskAttachments = options?.firstTaskAttachments ?? [];
        // A workspace registry mutation must not eagerly instantiate an
        // OpenCode directory. Chat-first creation still needs a session for
        // its supplied prompt; ordinary creation lands on the New task state.
        const session = createdOnServer && sessionBaseUrl && sessionToken && (firstTaskPrompt || firstTaskAttachments.length > 0)
          ? await createClientV2(
              `${(buildOmniRushWorkspaceBaseUrl(sessionBaseUrl, targetWorkspaceId) ?? sessionBaseUrl).replace(/\/+$/, "")}/opencode2`,
              workspacePath || undefined,
              { token: sessionToken },
            ).session.create({ directory: workspacePath || undefined })
              .then((result) => unwrap(result))
          : null;
        // A supplied prompt never just disappears: without its chat it goes back to the composer with this error.
        if (!session && (firstTaskPrompt || firstTaskAttachments.length > 0)) {
          throw new Error("The project was added but its chat could not be started yet. Send the message again.");
        }
        setLegacySelectedWorkspaceId(targetWorkspaceId);
        writeActiveWorkspaceId(targetWorkspaceId);
        if (projectLabel) {
          writeWorkspaceProjectDimension(targetWorkspaceId, {
            label: projectLabel,
          });
        }
        captureAnalyticsEvent("workspace_created", { workspace_type: "local" });
        noteNewBuildathonProject(workspacePath, targetWorkspace?.displayName ?? targetWorkspace?.name ?? null);
        if (session?.id) {
          captureAnalyticsEvent("task_created", { source: "workspace_created", workspace_type: "local" });
          if (firstTaskPrompt || firstTaskAttachments.length) {
            // Attachment chips only survive in-memory (File objects), so the
            // persisted fallback draft drops their tokens.
            saveSessionDraft(sessionDraftScope, targetWorkspaceId, session.id, { text: firstTaskPrompt.replace(/\[attachment [^\]]+\]/g, "").trim(), mode: "prompt" });
            claimComposerSessionDraftScope(
              session.id,
              sessionDraftScopeKey(sessionDraftScope, targetWorkspaceId, session.id),
            );
            // The composer reads its draft from the composer state store, not
            // the persisted draft store — seed both so the prompt shows up.
            useComposerStateStore.getState().setDraft(session.id, firstTaskPrompt);
            if (firstTaskAttachments.length) {
              useComposerStateStore.getState().setAttachments(session.id, firstTaskAttachments);
            }
            // One-step run: the session surface sends the seeded draft itself.
            markComposerAutoSend(session.id);
          }
          writeLastSessionFor(targetWorkspaceId, session.id);
          rememberPendingCreatedSession(targetWorkspaceId, session.id);
          setSessionsByWorkspaceId((current) => {
            const next = {
              ...current,
              [targetWorkspaceId]: mergeWorkspaceRouteSession(current[targetWorkspaceId] ?? [], session),
            };
            sessionsByWorkspaceIdRef.current = next;
            return next;
          });
        }
        navigateToWorkspaceSession(targetWorkspaceId, session?.id ?? null, { replace: true });
        if (session?.id) focusPromptSoon();
      }
    } catch (error) {
      setCreateWorkspaceError(describeWorkspaceCreateError(error));
      if (options?.firstTaskPrompt || options?.firstTaskAttachments?.length) throw error;
    } finally {
      setCreateWorkspaceBusy(false);
    }
  }, [baseUrl, client, local, navigateToWorkspaceSession, refreshRouteState, rememberPendingCreatedSession, token]);

  /**
   * A parallel task: the server makes its worktree and workspace, then its
   * chat is created there and the prompt sent the way the composer sends one
   * (same model, agent and context), so it is captured like any chat.
   */
  const startParallelTask = useCallback(async (workspaceId: string, prompt: string) => {
    if (!client || !baseUrl || !token) throw new Error("omnirush.ai server is unavailable.");
    // The board has no chat open: a task started there has no parent chat.
    const created = await client.createWorkspaceTask(workspaceId, { prompt, parentSessionId: tasksRouteActive ? null : selectedSessionId });
    const taskWorkspace = created.workspace;
    await refreshRouteState();
    void queryClient.invalidateQueries({ queryKey: workspaceTasksQueryKey(workspaceId) });
    const opencodeUrl = `${(buildOmniRushWorkspaceBaseUrl(baseUrl, taskWorkspace.id) ?? baseUrl).replace(/\/+$/, "")}/opencode2`;
    const engine = createClientV2(opencodeUrl, taskWorkspace.path || undefined, { token });
    const session = unwrap(await engine.session.create({ directory: taskWorkspace.path || undefined }));
    const system = await buildOmniRushSessionSystemContext(client, {
      workspaceId: taskWorkspace.id,
      cacheKey: session.id,
      runtimeKey: environmentRuntimeKey,
    });
    const model = local.prefs.defaultModel;
    const variant = resolveSendVariant(model, modelVariantValue);
    const result = await engine.session.promptAsync({
      sessionID: session.id,
      parts: [{ type: "text", text: prompt }],
      model: model ?? undefined,
      agent: selectedAgent ?? undefined,
      ...(variant ? { variant } : {}),
      system,
    });
    if (result.error) throw new Error(serializeSDKError(result.error));
    if (model) useSessionModelStore.getState().setModel(session.id, model, variant);
    writeLastSessionFor(taskWorkspace.id, session.id);
    void queryClient.invalidateQueries({ queryKey: workspaceTasksQueryKey(workspaceId) });
    return created.task;
  }, [baseUrl, client, environmentRuntimeKey, local.prefs.defaultModel, modelVariantValue, queryClient, refreshRouteState, selectedAgent, selectedSessionId, tasksRouteActive, token]);

  // The new task's folder, picked above its composer: switch to another
  // workspace, or open a folder as a new one (the sidebar's "+" in one step).
  const openProjectFolder = useCallback(async () => {
    if (workspaces.length > 0 && checkDesktopRestriction({ restriction: "allowMultipleWorkspaces" })) {
      restrictionNotice.show({
        title: "Additional workspaces are restricted",
        message: "Your organization administrator has restricted access to adding additional workspaces.",
      });
      return;
    }
    const folder = singlePickedDirectory(await pickDirectory({ title: t("onboarding.authorize_folder") }));
    await handleCreateWorkspace("starter", folder);
  }, [checkDesktopRestriction, handleCreateWorkspace, restrictionNotice, workspaces.length]);
  // "Choose another folder" on a chat stopped because its folder is not writable (session-surface.tsx).
  useEffect(() => {
    if (!platform.capabilities.nativeFilePicker || !canCreateWorkspaces()) return;
    const open = () => void openProjectFolder().catch(() => undefined);
    window.addEventListener("omnirush-open-project-folder", open);
    return () => window.removeEventListener("omnirush-open-project-folder", open);
  }, [openProjectFolder, platform.capabilities.nativeFilePicker]);
  // A Work chat has no project folder to pick; Code's picker never lists the Work workspace.
  const newTaskComposerWithProjects = useMemo<NewTaskComposerContext | null>(() => newTaskComposerContext && (workChatActive ? newTaskComposerContext : {
    ...newTaskComposerContext,
    projectPicker: {
      workspaces: workspaces.filter((workspace) => shownInMode(workspace, workEnabled, "code")).map((workspace) => ({ id: workspace.id, name: workspace.displayNameResolved, path: workspace.path || null })),
      selectedId: selectedWorkspaceId || null,
      onSelect: (workspaceId: string) => {
        setLegacySelectedWorkspaceId(workspaceId);
        writeActiveWorkspaceId(workspaceId);
        navigateToWorkspaceSession(workspaceId);
        focusPromptSoon();
      },
      onOpenFolder: platform.capabilities.nativeFilePicker && canCreateWorkspaces() ? openProjectFolder : null,
    },
  }), [navigateToWorkspaceSession, newTaskComposerContext, openProjectFolder, platform.capabilities.nativeFilePicker, selectedWorkspaceId, setLegacySelectedWorkspaceId, workChatActive, workEnabled, workspaces]);

  /**
   * Chat-first onboarding: the empty-state composer creates a default chat
   * workspace under the user's home folder instead of asking where to put
   * it. Falls back to the create-workspace modal off desktop.
   */
  const handleChatFirstTask = useCallback(async (prompt: string, attachments?: ComposerAttachment[]) => {
    if (!isDesktopRuntime()) {
      // The cloud workspace is provisioned by Den; boot takeover covers the pre-attach state.
      if (!canCreateWorkspaces()) throw new Error("Workspace creation is unavailable.");
      handleOpenCreateWorkspace();
      throw new Error("Choose a workspace before sending this message.");
    }
    const home = await getDesktopHomeDir().catch(() => "");
    if (!home) {
      handleOpenCreateWorkspace();
      throw new Error("Choose a workspace before sending this message.");
    }
    const folder = await joinDesktopPath(home, "omnirush.ai").catch(() => "");
    if (!folder) {
      handleOpenCreateWorkspace();
      throw new Error("Choose a workspace before sending this message.");
    }
    await handleCreateWorkspace("starter", folder, { firstTaskPrompt: prompt, firstTaskAttachments: attachments ?? [] });
  }, [handleCreateWorkspace, handleOpenCreateWorkspace]);

  const createWorkspaceControlAction = useMemo<OmniRushControlAction>(() => ({
    id: "workspace.create",
    label: "Create a local workspace",
    description: "Create a workspace at the given folder path without showing the file picker dialog, optionally labeling its project for analytics.",
    sideEffect: "mutation",
    requiresArgs: true,
    args: [
      { name: "path", type: "string", required: true, description: "Absolute folder path for the new workspace." },
      { name: "projectLabel", type: "string", required: false, description: "Optional project name used to group the workspace's sessions in analytics." },
    ],
    execute: async (args) => {
      if (!canCreateWorkspaces()) return { ok: false, error: "workspace creation is unavailable" };
      const parsed = args as { path?: string; projectLabel?: string } | undefined;
      const folder = parsed?.path?.trim();
      if (!folder) return { ok: false, error: "path is required" };
      const trimmedLabel = parsed?.projectLabel?.trim() ?? "";
      await handleCreateWorkspace("starter", folder, trimmedLabel ? { projectLabel: trimmedLabel } : undefined);
      return { path: folder };
    },
  }), [handleCreateWorkspace]);
  useControlAction(createWorkspaceControlAction);

  // Sessions created outside this window (server-side session.create, other
  // clients) never reach a non-selected workspace's cached list, so callers
  // that create them ask the sidebar to refetch that one workspace.
  const reloadWorkspaceSessionsControlAction = useMemo<OmniRushControlAction>(() => ({
    id: "workspace.reload_sessions",
    label: "Reload a workspace's sessions",
    description: "Refetch the session list of one workspace so sessions created outside this window appear in the sidebar.",
    sideEffect: "mutation",
    requiresArgs: true,
    args: [
      { name: "workspaceId", type: "string", required: true, description: "Workspace id whose session list should be refetched." },
    ],
    execute: async (args) => {
      const candidate = typeof args === "object" && args !== null && "workspaceId" in args ? args.workspaceId : undefined;
      const workspaceId = typeof candidate === "string" ? candidate.trim() : "";
      if (!workspaceId) return { ok: false, error: "workspaceId is required" };
      if (!workspaces.some((workspace) => workspace.id === workspaceId)) {
        return { ok: false, error: `No workspace matched ${workspaceId}` };
      }
      await reloadWorkspaceSessions(workspaceId);
      return { workspaceId };
    },
  }), [reloadWorkspaceSessions, workspaces]);
  useControlAction(reloadWorkspaceSessionsControlAction);

  const handleCreateRemoteWorkspace = useCallback(async (input: {
    omnirushHostUrl?: string | null;
    omnirushToken?: string | null;
    directory?: string | null;
    displayName?: string | null;
  }) => {
    const baseUrlValue = input.omnirushHostUrl?.trim() ?? "";
    if (!baseUrlValue) return false;
    setCreateWorkspaceRemoteBusy(true);
    setCreateWorkspaceRemoteError(null);
    try {
      const remoteType: "omnirush" = "omnirush";
      const payload = {
        baseUrl: baseUrlValue,
        omnirushHostUrl: baseUrlValue,
        omnirushToken: input.omnirushToken?.trim() || null,
        displayName: input.displayName?.trim() || null,
        directory: input.directory?.trim() || null,
        remoteType,
      };
      let list: WorkspaceList | null = null;
      if (isDesktopRuntime()) {
        list = await workspaceCreateRemote(payload);
      } else if (client) {
        list = await client.createRemoteWorkspace(payload).catch(() => null);
      }
      if (!list) {
        throw new Error("omnirush.ai server is unavailable. Start or reconnect the server before connecting a remote workspace.");
      }
      const createdId = resolveWorkspaceListSelectedId(list) || list.workspaces[list.workspaces.length - 1]?.id || "";
      if (createdId) {
        await workspaceSetSelected(createdId).catch(() => undefined);
        await workspaceSetRuntimeActive(createdId).catch(() => undefined);
      }
      setCreateWorkspaceOpen(false);
      // Mark onboarding complete so the /welcome redirect never fires again.
      local.setPrefs((prev) => ({ ...prev, hasCompletedOnboarding: true }));
      await refreshRouteState();
      return true;
    } catch (error) {
      setCreateWorkspaceRemoteError(error instanceof Error ? error.message : t("app.unknown_error"));
      return false;
    } finally {
      setCreateWorkspaceRemoteBusy(false);
    }
  }, [client, local, refreshRouteState]);

  const startWorkChat = async (prompt: string) => {
    const workspaceId = workWorkspace?.id;
    if (!workspaceId) throw new Error("Work is still getting ready. Try again in a moment.");
    const sessionId = await handleCreateTaskInWorkspaceWithOpenMode(workspaceId, "primary");
    if (!sessionId) throw new Error("Could not start a chat. Try again in a moment.");
    saveSessionDraft(sessionDraftScope, workspaceId, sessionId, { text: prompt, mode: "prompt" });
    useComposerStateStore.getState().setDraft(sessionId, prompt);
    markComposerAutoSend(sessionId);
  };

  const startAppConversation = async (prompt: string) => {
    const sessionId = await handleCreateTaskInWorkspaceWithOpenMode(selectedWorkspaceId, "primary");
    if (!sessionId) throw new Error("Could not start a conversation. Check that your workspace is connected.");
    saveSessionDraft(sessionDraftScope, selectedWorkspaceId, sessionId, { text: prompt, mode: "prompt" });
    focusPromptSoon();
  };

  return (
    <WorkspaceProvider
      client={opencodeClient}
      opencodeBaseUrl={opencodeBaseUrl}
      omnirushServerClient={selectedWorkspaceEndpoint?.client ?? null}
      workspaceId={selectedWorkspaceEndpoint?.workspaceId ?? ""}
      selectedWorkspaceRoot={selectedWorkspaceRoot}
    >
    {opencodeClient && selectedWorkspaceEndpoint && opencodeBaseUrl && selectedWorkspaceServerToken ? (
      <ReactSessionRuntime
        // Use the server-side workspace id (the one without the `rem_`
        // prefix) so the React Query cache keys session-sync writes match
        // the keys SessionSurface reads from. Otherwise events arrive but
        // the UI never sees them and gets stuck on "thinking".
        workspaceId={selectedWorkspaceEndpoint.workspaceId}
        sessionId={selectedSessionId}
        activeSessionIds={activeSelectedWorkspaceSessionIds}
        opencodeBaseUrl={opencodeBaseUrl}
        omnirushToken={selectedWorkspaceServerToken}
        onSessionCreated={handleRuntimeSessionCreated}
        onSessionUpdated={handleRuntimeSessionUpdated}
        onSessionDeleted={handleRuntimeSessionDeleted}
      />
    ) : null}
    <SessionPage
      sessionNumberShortcuts={sessionNumberShortcuts}
      selectedSessionId={selectedSessionId}
      selectedWorkspaceId={selectedWorkspaceId}
      selectedWorkspaceDisplay={selectedWorkspace ? {
        id: selectedWorkspace.id,
        name: selectedWorkspace.name ?? undefined,
        displayName: selectedWorkspace.displayNameResolved,
        workspaceType: selectedWorkspace.workspaceType,
      } : { workspaceType: "local" }}
      selectedWorkspaceRoot={selectedWorkspaceRoot}
      selectedWorkspaceError={selectedWorkspaceError}
      runtimeWorkspaceId={selectedWorkspaceEndpoint?.workspaceId || null}
      opencodeBaseUrl={opencodeBaseUrl}
      workspaces={workspaces}
      clientConnected={canCreateTask}
      omnirushServerStatus={client ? "connected" : "disconnected"}
      omnirushServerClient={selectedWorkspaceEndpoint?.client ?? client}
      environmentClient={client}
      omnirushServerToken={selectedWorkspaceServerToken}
      developerMode={developerMode}
      headerStatus={
        canCreateTask || (activeComposerTargetsSession && !selectedWorkspaceError && activeComposerAvailability.status === "available")
          ? t("status.connected")
          : (modelUnavailableMessage ?? t("session.loading_detail"))
      }
      busyHint={organizationModelsEmpty ? t("models.organization_models_empty") : effectiveLoading ? t("session.loading_detail") : null}
      startupPhase={effectiveLoading ? "nativeInit" : "ready"}
      providerConnectedIds={providerConnectedIds}
      hasUsableModel={hasUsableModel}
      providers={providers}
      mcpConnectedCount={mcpConnectedCount}
      onSendFeedback={() => {
        // The desktop sends it to the OmniRush team (in-app); elsewhere the public issue form.
        if (isDesktopRuntime()) {
          openFeedbackDialog({ trigger: "menu", sessionId: selectedSessionId ?? null });
          return;
        }
        platform.openLink(
          buildFeedbackUrl({
            entrypoint: "status-bar",
          }),
        );
      }}
      onOpenSettings={() => handleOpenSettings("/settings/general")}
      onOpenExtensions={() => handleOpenExtensions()}
      onOpenProviderAuth={handleOpenProviderAuth}
      onChatFirstTask={handleChatFirstTask}
      chatFirstBusy={createWorkspaceBusy}
      newTaskComposer={newTaskComposerWithProjects}
      home={homeView}
      providerAuthModal={sessionProviderAuthSnapshot.providerAuthModalOpen ? {
        open: true,
        loading: false,
        submitting: sessionProviderAuthSnapshot.providerAuthBusy,
        error: sessionProviderAuthSnapshot.providerAuthError,
        preferredProviderId: sessionProviderAuthSnapshot.providerAuthPreferredProviderId,
        workerType: sessionProviderAuthSnapshot.providerAuthWorkerType,
        providers: sessionProviderAuthSnapshot.providerAuthProviders.filter(
          (provider) => !isDesktopProviderBlocked({ providerId: provider.id, checkRestriction: checkDesktopRestriction }),
        ),
        connectedProviderIds: providerConnectedIds,
        authMethods: Object.fromEntries(
          Object.entries(sessionProviderAuthSnapshot.providerAuthMethods).filter(
            ([providerId]) => !isDesktopProviderBlocked({ providerId, checkRestriction: checkDesktopRestriction }),
          ),
        ),
        onSelect: sessionProviderAuthStore.startProviderAuth,
        onSubmitApiKey: async (providerId, apiKey) => {
          const result = await sessionProviderAuthStore.submitProviderApiKey(providerId, apiKey);
          modelPicker.setRecentProviderIds(new Set([providerId]));
          modelPicker.setQuery("");
          modelPicker.setOpen(true);
          return result;
        },
        onSubmitOAuth: sessionProviderAuthStore.completeProviderAuthOAuth,
        onRefreshProviders: sessionProviderAuthStore.refreshProviders,
        onClose: () => sessionProviderAuthStore.closeProviderAuthModal(),
      } : null}
      settingsSlot={
        <SettingsSurface
          embedded
          initialPath="extensions"
          workspaceId={selectedWorkspaceId}
          onClose={() => {
            try {
              window.dispatchEvent(new CustomEvent("omnirush-close-right-pane"));
            } catch {
              // ignore
            }
          }}
        />
      }
      primaryTitle={workRouteActive ? (location.pathname.startsWith(WORK_CONNECTORS_ROUTE) ? "Connectors" : location.pathname.startsWith(WORK_KNOWLEDGE_ROUTE) ? "Knowledge" : "Work") : appsRouteActive ? "Dashboard" : automationsRouteActive ? "Automations" : dashboardRouteActive ? "Dashboard" : tasksRouteActive ? "Parallel tasks" : undefined}
      workChat={workChatActive}
      primarySlot={workRouteActive ? (
        location.pathname.startsWith(WORK_CONNECTORS_ROUTE) ? (
          <WorkConnectorsPage client={client ?? null} openLink={(url) => platform.openLink(url)} onBack={() => navigate(WORK_HOME_ROUTE)} />
        ) : location.pathname.startsWith(WORK_KNOWLEDGE_ROUTE) ? (
          <WorkKnowledgePage client={client ?? null} openLink={(url) => platform.openLink(url)} onAsk={startWorkChat} onBack={() => navigate(WORK_HOME_ROUTE)} />
        ) : (
          <WorkHome
            busy={!workWorkspace}
            message={workState.data?.message ?? null}
            onStart={startWorkChat}
            onOpenConnectors={() => navigate(WORK_CONNECTORS_ROUTE)}
          />
        )
      ) : tasksRouteActive && tasksAvailable ? (
        <TasksBoardPage
          client={client}
          workspaceId={tasksBoardWorkspaceId}
          workspaceName={workspaces.find((workspace) => workspace.id === tasksBoardWorkspaceId)?.displayNameResolved ?? ""}
          onStartTask={(prompt) => startParallelTask(tasksBoardWorkspaceId, prompt)}
          onOpenChat={(workspaceId, sessionId) => {
            setLegacySelectedWorkspaceId(workspaceId);
            writeActiveWorkspaceId(workspaceId);
            if (sessionId) writeLastSessionFor(workspaceId, sessionId);
            navigateToWorkspaceSession(workspaceId, sessionId);
          }}
          onWorkspacesChanged={() => void refreshRouteState()}
        />
      ) : tasksRouteActive && selectedWorkspace?.workspaceType === "remote" ? (
        <div className="mx-auto max-w-xl p-6 pt-16 text-center" data-testid="tasks-remote">
          <h2 className="text-base font-medium">Parallel tasks run on this computer</h2>
          <p className="mt-2 text-sm text-muted-foreground">
            This workspace is on a remote worker. Open a project folder on this computer to start tasks in their own copies of it.
          </p>
        </div>
      ) : appsRouteActive ? (
        <AppsPage onNewApp={startAppConversation} />
      ) : automationsRouteActive ? (
        <AutomationsPage providerCatalog={providerCatalog} workspaceId={selectedWorkspaceId} />
      ) : dashboardRouteActive ? (
        <WorkspaceProvider
          client={opencodeClient}
          opencodeBaseUrl={opencodeBaseUrl}
          omnirushServerClient={dashboardEndpoint?.client ?? null}
          workspaceId={dashboardEndpoint?.workspaceId ?? ""}
          selectedWorkspaceRoot={selectedWorkspaceRoot}
        >
          <DashboardPage fallbackEndpoints={dashboardFallbackEndpoints} onCreateApp={startAppConversation} />
        </WorkspaceProvider>
      ) : undefined}
      terminalOpen={terminalOpen && !workChatActive}
      onTerminalOpenChange={setTerminalOpen}
      opencodeClient={opencodeClient}
      onSessionTabsChange={(tabs) => {
        sessionTabNavRef.current = { ...sessionTabNavRef.current, options: tabs };
      }}
      sidebar={{
        workspaceSessionGroups: sidebarWorkspaceSessionGroups,
        modeToggle: workEnabled ? <WorkModeToggle mode={appMode} onChange={switchAppMode} shortcut={/Mac/i.test(typeof navigator === "undefined" ? "" : navigator.platform) ? "⌘⇧K" : "Ctrl+Shift+K"} /> : undefined,
        workNavigation: appMode === "work" ? { onOpenHome: () => navigate(WORK_HOME_ROUTE), onOpenConnectors: () => navigate(WORK_CONNECTORS_ROUTE), connectorsActive: location.pathname.startsWith(WORK_CONNECTORS_ROUTE), onOpenKnowledge: () => navigate(WORK_KNOWLEDGE_ROUTE), knowledgeActive: location.pathname.startsWith(WORK_KNOWLEDGE_ROUTE) } : undefined,
        selectedWorkspaceId,
        selectedSessionId,
        developerMode: false,
        sessionStatusById: sidebarSessionStatusById,
        connectingWorkspaceId: null,
        workspaceConnectionStateById,
        newTaskDisabled: !canCreateTask,
        sidebarHydratedFromCache: Object.values(sessionsByWorkspaceId).some((list) => list.length > 0),
        startupPhase: effectiveLoading ? "nativeInit" : "ready",
        automationsActive: automationsRouteActive,
        automationsNeedAttention,
        onOpenAutomations: automationsNavigationAvailable
          ? () => {
              navigate(automationsRoute());
            }
          : undefined,
        dashboardActive: dashboardRouteActive || appsRouteActive,
        tasksActive: tasksRouteActive,
        tasksRunningCount,
        onOpenTasksForWorkspace: (workspaceId: string) => navigate(workspaceTasksRoute(workspaceId)),
        onOpenTasks: tasksAvailable ? () => navigate(workspaceTasksRoute(tasksBoardWorkspaceId)) : undefined,
        onOpenDashboard: mcpAppsDashboardEnabled
          ? () => {
              navigate(dashboardRoute());
            }
          : undefined,
        onSelectWorkspace: async (workspaceId) => {
          if (workspaceId === selectedWorkspaceId) return true;
          setLegacySelectedWorkspaceId(workspaceId);
          writeActiveWorkspaceId(workspaceId || null);
          // Route adoption owns desktop persistence and server activation.
          // Centralizing those effects lets rapid navigation coalesce to the
          // last route instead of racing stale IPC and engine reloads.
          // If we remember what the user last opened here and that session
          // still exists in our local list, navigate. Otherwise stay put.
          const remembered = readLastSessionFor(workspaceId);
          if (remembered && remembered !== selectedSessionId) {
            const known = sessionsByWorkspaceId[workspaceId];
            if (known?.some((session) => session?.id === remembered)) {
              navigateToWorkspaceSession(workspaceId, remembered);
            } else {
              navigateToWorkspaceSession(workspaceId);
            }
          } else {
            navigateToWorkspaceSession(workspaceId);
          }
          return true;
        },
        onOpenSession: (workspaceId, sessionId) => {
          setLegacySelectedWorkspaceId(workspaceId);
          writeActiveWorkspaceId(workspaceId || null);
          writeLastSessionFor(workspaceId, sessionId);
          navigateToWorkspaceSession(workspaceId, sessionId);
        },
        onPrefetchSession: () => {},
        onCreateTaskInWorkspace: (workspaceId, groupId) => {
          // A new Work chat starts from the Work home (templates); Code is unchanged.
          if (appMode === "work") {
            navigate(WORK_HOME_ROUTE);
            return;
          }
          const { focusedPane, secondary } = useWorkbenchStore.getState();
          const hasWorkspaceError = Boolean(errorsByWorkspaceId[workspaceId]?.trim())
            || workspaceConnectionStateById[workspaceId]?.status === "error";
          if (!groupId && !hasWorkspaceError && !(focusedPane === "secondary" && secondary)) {
            // The empty composer creates its session on submit. Opening it must
            // not wait for an engine request, especially on a cold v2 runtime.
            setLegacySelectedWorkspaceId(workspaceId);
            writeActiveWorkspaceId(workspaceId);
            navigateToWorkspaceSession(workspaceId);
            focusPromptSoon();
            return;
          }
          void handleCreateTaskInWorkspace(workspaceId).then((sessionId) => {
            if (sessionId && groupId) {
              sessionManagementStore.getState().assignGroup(workspaceId, sessionId, groupId);
            }
          });
        },
        onCreateSplitTaskInWorkspace: (workspaceId) => {
          void handleCreateSplitTaskInWorkspace(workspaceId);
        },
        onCreateTaskWithPrompt: async (
          workspaceId,
          prompt,
          attachments,
          handoff?: NewTaskComposerHandoff,
        ) => {
          const navigationOwner = {
            ...selectedConversationRef.current,
            paneOwner: focusedWorkbenchPaneOwner(),
          };
          const workspace = workspaces.find((item) => item.id === workspaceId);
          if (!workspace) throw new Error("Workspace is unavailable. Try again.");
          const endpoint = endpointForWorkspace(workspace);
          if (!endpoint?.token) throw new Error("Workspace is disconnected. Reconnect and try again.");
          const session = await createRouteSession(endpoint, workspace.path?.trim() || undefined);
          const continuation = handoff
            ? snapshotComposerSessionState(handoff.getContinuation())
            : null;
          if (workspaceId === selectedWorkspaceId) {
            void refreshCloudProviderSync("new_chat");
          }
          const firstTaskPrompt = prompt.trim();
          if (firstTaskPrompt || attachments?.length) {
            const firstTaskAttachments = attachments ?? [];
            const destinationScopeKey = sessionDraftScopeKey(sessionDraftScope, workspaceId, session.id);
            if (handoff && continuation) {
              // The source composer remains live while session creation is in
              // flight. Seed its latest continuation in the destination, but
              // send the immutable submitted snapshot through the scoped mark.
              saveSessionDraft(sessionDraftScope, workspaceId, session.id, {
                text: persistableComposerDraftText(continuation.draft, continuation.pasteParts),
                mode: "prompt",
              });
              claimComposerSessionDraftScope(session.id, destinationScopeKey);
              useComposerStateStore.setState((state) => ({
                sessions: {
                  ...state.sessions,
                  [session.id]: continuation,
                },
              }));
              markComposerAutoSend(session.id, {
                scopeKey: composerAutoSendScopeKey({
                  draftScope: sessionDraftScope,
                  opencodeBaseUrl: endpoint.opencodeBaseUrl,
                  workspaceId,
                  sessionId: session.id,
                }),
                composer: handoff.submitted,
              });
            } else {
              // Attachment chips only survive in-memory (File objects), so the
              // persisted fallback draft drops their tokens.
              saveSessionDraft(sessionDraftScope, workspaceId, session.id, { text: firstTaskPrompt.replace(/\[attachment [^\]]+\]/g, "").trim(), mode: "prompt" });
              claimComposerSessionDraftScope(session.id, destinationScopeKey);
              // The composer reads its draft from the composer state store,
              // not the persisted draft store — seed both.
              useComposerStateStore.getState().setDraft(session.id, firstTaskPrompt);
              if (firstTaskAttachments.length) {
                useComposerStateStore.getState().setAttachments(session.id, firstTaskAttachments);
              }
              // Legacy callers still seed the submitted draft directly.
              markComposerAutoSend(session.id);
            }
          }
          rememberPendingCreatedSession(workspaceId, session.id);
          applyLastUsedModelToSession(session.id, workspaceId);
          setSessionsByWorkspaceId((current) => ({
            ...current,
            [workspaceId]: mergeWorkspaceRouteSession(current[workspaceId] ?? [], session),
          }));
          const stillOwnsNavigation = navigationOwner.workspaceId === workspaceId
            && selectedConversationRef.current.workspaceId === navigationOwner.workspaceId
            && selectedConversationRef.current.sessionId === navigationOwner.sessionId
            && selectedConversationRef.current.draftScope === navigationOwner.draftScope
            && selectedConversationRef.current.location === navigationOwner.location
            && selectedConversationRef.current.locationKey === navigationOwner.locationKey
            && selectedConversationRef.current.navigationGeneration === navigationOwner.navigationGeneration
            && focusedWorkbenchPaneOwner() === navigationOwner.paneOwner;
          if (stillOwnsNavigation) {
            writeActiveWorkspaceId(workspaceId || null);
            writeLastSessionFor(workspaceId, session.id);
            navigateToWorkspaceSession(workspaceId, session.id);
            focusPromptSoon();
          }
        },
        onOpenRenameWorkspace: handleOpenRenameWorkspace,
        onShareWorkspace: handleShareWorkspace,
        onRevealWorkspace: (id) => void handleRevealWorkspace(id),
        onRecoverWorkspace: (workspaceId) => runRemoteWorkspaceConnectionCheck(workspaceId, "recover"),
        onTestWorkspaceConnection: (workspaceId) => runRemoteWorkspaceConnectionCheck(workspaceId, "test"),
        onRetryWorkspaceTasks: retryWorkspaceSessions,
        onEditWorkspaceConnection: remoteWorkspaceConnectionEditor.open,
        onForgetWorkspace: (id) => void handleForgetWorkspace(id),
        onOpenCreateWorkspace: handleOpenCreateWorkspace,
        onOpenSessionSearch: () => setSessionSearchOpen(true),
        onReorderWorkspaces: handleReorderWorkspaces,
      }}
      surface={surfaceProps}
      resolvePaneRuntime={resolvePaneRuntime}
      history={{
        canUndo: false,
        canRedo: false,
        busyAction: null,
        onUndo: () => {},
        onRedo: () => {},
      }}
      todos={todos}
      sessionLoadingById={(sessionId) => effectiveLoading && Boolean(sessionId && sessionId === selectedSessionId)}
      shareWorkspaceModal={
        shareWorkspaceState.shareWorkspaceOpen
          ? {
              open: true,
              onClose: shareWorkspaceState.closeShareWorkspace,
              workspaceName: shareWorkspaceState.shareWorkspaceName,
              workspaceDetail: shareWorkspaceState.shareWorkspaceDetail,
              fields: shareWorkspaceState.shareFields,
              remoteAccess:
                isDesktopRuntime() && shareWorkspaceState.shareWorkspace?.workspaceType === "local"
                  ? {
                      enabled: omnirushServerSettings.remoteAccessEnabled === true,
                      busy: remoteAccessRestart.busy,
                      error: remoteAccessRestart.error,
                      status: remoteAccessRestart.status,
                      onSave: handleSaveShareRemoteAccess,
                    }
                  : undefined,
              note: shareWorkspaceState.shareNote,
              onExportConfig:
                shareWorkspaceState.exportDisabledReason === null
                  ? () => {
                      const id = shareWorkspaceState.shareWorkspaceId;
                      if (!id) return;
                      void handleExportWorkspaceConfig(id);
                    }
                  : undefined,
              exportDisabledReason: shareWorkspaceState.exportDisabledReason,
            }
          : null
      }
      activePermission={activePermission}
      activePermissionSourceTitle={activePermissionSourceTitle}
      permissionReplyBusy={permissionReplyBusy}
      respondPermission={respondPermission}
      activeQuestion={activeQuestion}
      questionReplyBusy={questionReplyBusy}
      respondQuestion={respondQuestion}
      safeStringify={safeStringify}
      onRenameSession={
        opencodeClient
          ? async (sessionId, nextTitle) => {
              const trimmed = nextTitle.trim();
              if (!trimmed) return;
              await opencodeClient.session.update({
                sessionID: sessionId,
                title: trimmed,
                directory: selectedWorkspaceRoot || undefined,
              });
              await refreshRouteState();
            }
          : undefined
      }
      onDeleteSession={
        client && selectedWorkspaceId
          ? async (sessionId) => {
              // The sidebar lists sessions from every workspace: delete through
              // the workspace that owns the session, whose engine runs it and
              // whose list shows it.
              const ownerId = workspaceSessionGroups.find((group) =>
                group.sessions.some((session) => session?.id === sessionId),
              )?.workspace.id;
              const ownerWorkspace = workspaces.find((workspace) => workspace.id === ownerId) ?? selectedWorkspace;
              const endpoint = endpointForWorkspace(ownerWorkspace);
              if (!ownerWorkspace || !endpoint) throw new Error(t("session.delete_unavailable"));
              await deleteRouteSession(endpoint, sessionId);
              forgetDeletedSession(sessionId);
              if (selectedSessionId === sessionId) {
                navigateToWorkspaceSession(selectedWorkspaceId);
              }
              void reloadWorkspaceSessions(ownerWorkspace.id);
            }
          : undefined
      }
      onArchiveSession={opencodeClient ? handleArchiveSession : undefined}
      archiveDisabledReason={archiveDisabledReason}
      statusBar={{
        // No per-session loading state here: the account row renders only
        // app-scoped facts. Session loading lives in the pane; an unresolved
        // model surfaces in the composer where the person can act on it.
        reloadBusy: reloadCoordinator.reloadBusy,
        reloadError: reloadCoordinator.reloadError,
        omniRushConnectState: sessionMcpMaintenance,
      }}
      notFoundMessage={gatedRouteNotFoundMessage}
      mainContentTakeover={
        extensionsMainOpen ? (
          <SettingsSurface
            standaloneExtensions
            workspaceId={selectedWorkspaceId || undefined}
          />
        ) : cloudWorkspaceMainContentTakeover
      }
      mainContentTitle={extensionsMainOpen ? t("settings.tab_extensions") : undefined}
      extensionsActive={extensionsMainOpen}
      onAccessibleTargetsChange={setPaletteAccessibleTargets}
    />
    <ConfirmModal
      open={newChatOffer !== null}
      title={newChatOffer ? newChatPrompt(modelTitle(newChatOffer.current), modelTitle(newChatOffer.next)).title : ""}
      message={newChatOffer ? newChatPrompt(modelTitle(newChatOffer.current), modelTitle(newChatOffer.next)).message : ""}
      confirmLabel="Start new chat"
      cancelLabel="Keep this chat"
      onConfirm={() => void confirmNewChat()}
      onCancel={() => setNewChatOffer(null)}
    />
    <CreateWorkspaceModal
      open={createWorkspaceOpen}
      onClose={() => {
        setCreateWorkspaceOpen(false);
        setCreateWorkspaceError(null);
      }}
      onConfirm={handleCreateWorkspace}
      onConfirmRemote={handleCreateRemoteWorkspace}
      onPickFolder={async () => singlePickedDirectory(await pickDirectory({ title: t("onboarding.authorize_folder") }))}
      submitting={createWorkspaceBusy}
      localError={createWorkspaceError}
      localDisabled={!platform.capabilities.nativeFilePicker}
      localDisabledReason={
        platform.capabilities.nativeFilePicker
          ? undefined
          : t("app.local_disabled_reason")
      }
      remoteSubmitting={createWorkspaceRemoteBusy}
      remoteError={createWorkspaceRemoteError}
    />
    <CreateRemoteWorkspaceModal
      open={remoteWorkspaceConnectionEditor.workspace !== null}
      onClose={remoteWorkspaceConnectionEditor.close}
      onConfirm={(input) => void remoteWorkspaceConnectionEditor.save(input)}
      initialValues={remoteWorkspaceConnectionEditor.initialValues}
      submitting={remoteWorkspaceConnectionEditor.busy}
      error={remoteWorkspaceConnectionEditor.error}
      title={t("dashboard.edit_remote_workspace_title")}
      subtitle={t("dashboard.edit_remote_workspace_subtitle")}
      confirmLabel={t("dashboard.edit_remote_workspace_confirm")}
    />
    <RenameWorkspaceModal
      open={renameWorkspaceId !== null}
      title={renameWorkspaceTitle}
      busy={renameWorkspaceBusy}
      canSave={!renameWorkspaceBusy && renameWorkspaceTitle.trim().length > 0}
      onClose={() => {
        if (renameWorkspaceBusy) return;
        setRenameWorkspaceId(null);
        setRenameWorkspaceTitle("");
      }}
      onSave={() => void handleSaveRenameWorkspace()}
      onTitleChange={setRenameWorkspaceTitle}
    />
    <CommandPalette
      open={commandPaletteOpen}
      onClose={() => setCommandPaletteOpen(false)}
      developerMode={developerMode}
      onCreateNewSession={() => {
        if (selectedWorkspaceId) {
          void handleCreateTaskInWorkspace(selectedWorkspaceId);
        }
      }}
      onCreateNewSplitSession={() => {
        if (selectedWorkspaceId) {
          void handleCreateSplitTaskInWorkspace(selectedWorkspaceId);
        }
      }}
      onOpenSession={(workspaceId, sessionId) => navigateToWorkspaceSession(workspaceId, sessionId)}
      currentSession={selectedSessionId ? { workspaceId: selectedWorkspaceId, sessionId: selectedSessionId } : null}
      onOpenSessionInSplit={(workspaceId, sessionId) => {
        const option = paletteSessionOptions.find((candidate) => (
          candidate.workspaceId === workspaceId && candidate.sessionId === sessionId
        ));
        const tab = {
          workspaceId,
          sessionId,
          title: option?.title,
          workspaceTitle: option?.workspaceTitle ?? workspaceId,
        };
        const workbench = useWorkbenchStore.getState();
        workbench.openTab(tab);
        workbench.setSplit(tab);
      }}
      onOpenSettings={(route) => handleOpenSettings(route ?? "/settings/general")}
      onOpenExtensions={(section) => handleOpenExtensions(section)}
      onToggleSidebar={toggleSidebar}
      onOpenAutomations={() => navigate(automationsRoute())}
      onOpenDashboard={() => navigate(dashboardRoute())}
      onCreateWorkspace={handleOpenCreateWorkspace}
      modelOptions={pickerOptions}
      selectedModel={paletteSelectedModel}
      selectedModelBehavior={paletteSelectedModelBehavior}
      onSelectModel={(next, behavior) => {
        applySessionRouteModelSelection(next, selectedSessionId || null, { value: behavior });
      }}
      selectedModelLabel={modelLabel}
      accessibleTargets={paletteAccessibleTargets}
      onOpenAccessibleTarget={(target) => {
        try {
          window.dispatchEvent(new CustomEvent("omnirush-open-accessible-target", { detail: target }));
        } catch {
          // ignore event dispatch failures
        }
      }}
      onHideAccessibleTarget={(target) => {
        try {
          window.dispatchEvent(new CustomEvent("omnirush-hide-accessible-target", { detail: target }));
        } catch {
          // ignore event dispatch failures
        }
      }}
      sessions={paletteSessionOptions}
      sessionGroups={paletteSessionGroups}
      currentSessionForGroupMove={currentSessionForGroupMove}
      currentSessionGroupId={currentSessionGroupId}
      onMoveCurrentSessionToGroup={handleMoveCurrentSessionToGroup}
      extraItems={[...currentSessionActionPaletteItems, ...(sessionFindPaletteItem ? [sessionFindPaletteItem] : []), sessionSearchPaletteItem, ...tasksPaletteItems, ...layoutPaletteItems, ...terminalPaletteItems, ...(checkDesktopRestriction({ restriction: "allowControlSettings" }) ? [] : [developerModePaletteItem]), ...(copySessionIdPaletteItem ? [copySessionIdPaletteItem] : []), diagnosticsCopyPaletteItem, diagnosticsExportPaletteItem, nextSessionTabPaletteItem, prevSessionTabPaletteItem, reloadConfigPaletteItem]}
      listAgents={listAgents}
      selectedAgent={selectedAgent}
      onSelectAgent={setSelectedAgent}
    />
    <SessionSearchDialog
      open={sessionSearchOpen}
      onClose={() => setSessionSearchOpen(false)}
      sessions={paletteSessionOptions}
      fetchMessages={sessionSearchFetcher}
      onOpenSession={(workspaceId, sessionId) => navigateToWorkspaceSession(workspaceId, sessionId)}
    />
    <ModelPickerModal
      open={modelPicker.open}
      options={pickerOptions}
      organizationModelsEmpty={organizationModelsEmpty}
      organizationModelsSettingsUrl={organizationModelsSettingsUrl}

      query={modelPicker.query}
      setQuery={modelPicker.setQuery}
      subtitle={
        resolveModelAvailability(
          (modelPickerSessionId ? getSessionModelSelection(modelPickerSessionId)?.model : null)
            ?? local.prefs.defaultModel
            ?? null,
        ).status === "unavailable"
          ? MODEL_PICKER_UNAVAILABLE_SUBTITLE
          : undefined
      }
      target="default"
      current={
        (modelPickerSessionId ? getSessionModelSelection(modelPickerSessionId)?.model : null)
          ?? local.prefs.defaultModel
          ?? ({ providerID: "", modelID: "" } satisfies ModelRef)
      }
      onSelect={(next: ModelRef) => {
        applySessionRouteModelSelection(next, modelPickerSessionId);
        setModelPickerSessionId(null);
        modelPicker.setOpen(false);
      }}
      disabledProviders={disabledProviderIds}
      onBehaviorChange={() => {}}
      onToggleProvider={async (providerId, enable) => {
        if (!opencodeClient) return;
        try {
          const config = unwrap(await opencodeClient.config.get());
          const current = disabledProvidersFromConfig(config);
          const next = enable
            ? current.filter((id: string) => id !== providerId)
            : [...current, providerId];
          const result = await updateManagedDisabledProviders({
            opencodeClient,
            omnirushClient: selectedWorkspaceEndpoint?.client ?? null,
            workspaceId: selectedWorkspaceEndpoint?.workspaceId ?? null,
            workspaceType: selectedWorkspace?.workspaceType ?? "local",
            disabledProviders: next,
            currentConfig: config,
            markReloadRequired: () => {
              reloadCoordinator.markReloadRequired("config", {
                type: "config",
                name: "runtime-opencode-config.json",
                action: "updated",
              });
            },
          });
          setDisabledProviderIds(result.disabledProviders);
        } catch {}
      }}
      onOpenSettings={() => {
        modelPicker.setOpen(false);
        handleOpenSettings("/settings/general");
      }}
      onClose={() => { modelPicker.setOpen(false); modelPicker.setRecentProviderIds(new Set()); setModelPickerSessionId(null); }}
      omniRushModelsEntitled={omniRushModelsEntitled}
      omniRushModelsSyncing={omniRushModelsSyncing}
      onRefreshOrganizationModels={refreshOrganizationModelAccess}
      restrictToCloud={restrictToCloudProviders}
    />
    </WorkspaceProvider>
  );
}