gloomberb 0.16.3 → 0.16.4

package/src/api-client/research-activity.ts

@@ -3,6 +3,7 @@ import { getCurrentPluginTarget } from "../plugins/current-target";
 import type { DesktopDeepLinkBridge } from "../types/desktop-deeplink";
 import { exposeExperiment, storedExperimentAssignments } from "./web-experiments";
 import { createWallExperimentSession, type WallExperiment, type WallExperimentContext, type WallTeaserVariant } from "./wall-experiments";
+import { createUpgradeExperimentSession, UPGRADE_PERSONALIZED, type UpgradeExperimentContext, type UpgradePersonalizedVariant } from "./upgrade-experiment";
 import { hasProAccess } from "./plan-rules";
 import { withDeadline } from "../utils/async-deadline";
 
@@ -38,6 +39,7 @@ let anonymousId: string | undefined;
 let attribution: Record<string, string> = {};
 const wallExperiment = createWallExperimentSession();
 const signinWallExperiment = createWallExperimentSession("wall_teaser_signin");
+const upgradeExperiment = createUpgradeExperimentSession();
 const WALL_VIEWS_SESSION_KEY = "gloomberb.wall-teaser.views";
 
 const ATTRIBUTION_STORAGE_KEY = "gloomberb.web.attribution";
@@ -524,6 +526,35 @@ export function exposeWallTeaser(experiment: WallExperiment = "wall_teaser"): Pr
   });
 }
 
+function upgradeExperimentContext(): UpgradeExperimentContext {
+  const { accountId, pro, optedOut, automated, session } = wallExperimentContext();
+  return { accountId, pro, optedOut, automated, session };
+}
+
+/** The `upgrade_personalized` arm this session already has, without asking; see upgrade-experiment.ts. */
+export function knownUpgradePersonalized(): UpgradePersonalizedVariant | null | undefined {
+  return upgradeExperiment.known(upgradeExperimentContext());
+}
+
+/**
+ * Asks for the `upgrade_personalized` arm when an upgrade surface is shown to
+ * a free account that has tickers to name, once per account and session. The
+ * request says where it showed and nothing about the holdings.
+ */
+export function exposeUpgradePersonalized(placement: string): Promise<UpgradePersonalizedVariant | null> {
+  const context = upgradeExperimentContext();
+  const surface = getCurrentPluginTarget();
+  return upgradeExperiment.expose(context, () => {
+    const controller = new AbortController();
+    return withDeadline(apiClient.recordExperimentExposure({
+      eventId: crypto.randomUUID(),
+      surface,
+      experiment: UPGRADE_PERSONALIZED,
+      ...(ACTIVITY_ID.test(placement) ? { placement } : {}),
+    }, controller.signal), 3_000, "Upgrade experiment request timed out", (error) => controller.abort(error));
+  });
+}
+
 /** Records the visible wall once per placement, including visitors outside the experiment. */
 export function recordWallViewed(placement: string, teaserKind?: "summary" | "sample" | "none"): void {
   recordResearchActivity("wall_viewed", undefined, undefined, { placement, teaser_kind: teaserKind });

package/src/api-client/socket.ts

@@ -33,7 +33,9 @@ const QUOTE_SUBSCRIPTION_FLUSH_MS = 25;
 const MARKET_BATCH_FEATURE = "market.batch";
 /** Chat frames carry `attachments`; without it the server writes images into the text. */
 export const CHAT_ATTACHMENTS_FEATURE = "chat.attachments";
-const CLIENT_SOCKET_FEATURES = [MARKET_BATCH_FEATURE, CHAT_ATTACHMENTS_FEATURE] as const;
+/** The app can run terminal tools relayed from a remote assistant; it still announces itself first. */
+export const TERMINAL_RELAY_FEATURE = "terminal.relay";
+const CLIENT_SOCKET_FEATURES = [MARKET_BATCH_FEATURE, CHAT_ATTACHMENTS_FEATURE, TERMINAL_RELAY_FEATURE] as const;
 const cloudApiLog = debugLog.createLogger("cloud-api");
 
 type ChannelListener = (message: ChatMessage) => void;
@@ -131,6 +133,7 @@ export class CloudApiSocket {
   /** What the last "ready" frame offered; kept across reconnects so a blip does not hide features. */
   private offeredFeatures: ReadonlySet<string> = new Set();
   private readonly offeredFeatureListeners = new Set<() => void>();
+  private readonly connectionListeners = new Set<(event: "ready" | "closed") => void>();
   private readonly tapeListeners = new Map<string, { symbol: string; exchange: string; listeners: Set<(event: TapeFeedEvent) => void> }>();
   private readonly scannerListeners = new Map<
     ScannerKind,
@@ -164,6 +167,7 @@ export class CloudApiSocket {
     const ws = this.ws;
     this.ws = null;
     if (ws) {
+      this.emitConnection("closed");
       cloudApiLog.info("teardown websocket");
       this.health.reportSocketState(
         GLOOM_CLOUD_SOCKET_CONNECTION_ID,
@@ -260,6 +264,29 @@ export class CloudApiSocket {
     };
   }
 
+  /** "ready" after each server hello (features negotiated), "closed" when that connection ends. */
+  subscribeConnection(listener: (event: "ready" | "closed") => void): () => void {
+    this.connectionListeners.add(listener);
+    return () => {
+      this.connectionListeners.delete(listener);
+    };
+  }
+
+  /** Sends one frame on the open connection; false when there is none. */
+  sendFrame(payload: Record<string, unknown>): boolean {
+    if (this.ws?.readyState !== WebSocket.OPEN) return false;
+    try {
+      this.ws.send(JSON.stringify(payload));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private emitConnection(event: "ready" | "closed"): void {
+    for (const listener of this.connectionListeners) listener(event);
+  }
+
   subscribeTeamNotifications(listener: TeamNotificationListener): () => void {
     this.teamNotificationListeners.add(listener);
     this.syncAuthState();
@@ -470,6 +497,7 @@ export class CloudApiSocket {
     });
     this.channelListeners.clear();
     this.offeredFeatureListeners.clear();
+    this.connectionListeners.clear();
     this.chatNotificationListeners.clear();
     this.chatPresenceListeners.clear();
     this.teamNotificationListeners.clear();
@@ -500,13 +528,15 @@ export class CloudApiSocket {
     if (parsed?.type === "ready") {
       recordServerClockSample(parsed.serverTime);
       this.negotiateSocketFeatures(parsed.features);
-      if (!parsed.user) return;
-      cloudApiLog.info("websocket ready", {
-        emailVerified: parsed.user.emailVerified === true,
-      });
-      this.delegate.updateCurrentUserFromSocket(
-        parsed.user as Partial<AuthUser>,
-      );
+      if (parsed.user) {
+        cloudApiLog.info("websocket ready", {
+          emailVerified: parsed.user.emailVerified === true,
+        });
+        this.delegate.updateCurrentUserFromSocket(
+          parsed.user as Partial<AuthUser>,
+        );
+      }
+      this.emitConnection("ready");
       return;
     }
 
@@ -769,6 +799,7 @@ export class CloudApiSocket {
         tokenSource: usingWebSocketToken ? "websocket" : "session",
       });
       if (!activeSocket) return;
+      this.emitConnection("closed");
       this.health.reportSocketState(
         GLOOM_CLOUD_SOCKET_CONNECTION_ID,
         "closed",

package/src/api-client/types.ts

@@ -10,10 +10,20 @@ import type {
 } from "../types/financials";
 import type { SyncSettings, SyncSnapshot } from "../sync/types";
 
+/**
+ * What stands behind a chat account. `discord` is a person on the Gloom
+ * Discord who has not linked a Gloom account: a ghost with no profile, no DMs.
+ * A server that predates the field leaves it out, which reads as a human.
+ */
+export type ChatAccountType = "human" | "managed_llm" | "discord";
+
+/** Where a message was written. A message without one came from the app. */
+export type ChatMessageOrigin = "app" | "discord";
+
 export interface ChatUserSummary {
   id: string;
   /** A person, a managed assistant (Gloombot), or a Discord user bridged into public channels. */
-  accountType?: "human" | "managed_llm" | "discord";
+  accountType?: ChatAccountType;
   username: string | null;
   displayName: string;
   bio?: string | null;
@@ -47,6 +57,7 @@ export interface ChatMessage {
   createdAt: string;
   editedAt?: string | null;
   user: ChatUserSummary;
+  origin?: ChatMessageOrigin;
   replyTo?: {
     content: string;
     user: { id?: string; username: string };
@@ -67,6 +78,15 @@ export interface ChatMessage {
   clientMessageId?: string;
 }
 
+/** Whether this account is tied to a person on the Gloom Discord, and whether its public messages go there. */
+export interface ChatDiscordLink {
+  linked: boolean;
+  discordUsername?: string;
+  mirror: boolean;
+  /** False when the server has linking switched off. A server that predates the field is available. */
+  available: boolean;
+}
+
 export interface ChatChannel {
   id: string;
   name: string;
@@ -225,6 +245,22 @@ export interface CloudPricing {
   yearly: CloudPricingTier;
 }
 
+/**
+ * What an MCP key reaches beyond market data: `data` is market and filing
+ * tools only, `read` adds notes, teams and collections, `write` lets the agent
+ * save notes and change collection items.
+ */
+export type McpKeyScope = "data" | "read" | "write";
+
+/**
+ * A key just created with `POST /account/mcp/keys`. `token` is the secret,
+ * which the server never returns again: show it once, never store it.
+ */
+export interface CreatedMcpKey {
+  token: string;
+  apiKey: { id: string; name: string; scope: McpKeyScope };
+}
+
 /** The account's private calendar feed link (`/account/calendar-feed`). */
 export interface CalendarFeed {
   url: string;
@@ -382,6 +418,17 @@ export interface CloudEconEventPayload {
   impact: CloudEconImpact;
 }
 
+/** CPI, payrolls and FOMC statement days as published, as GET /cloud/econ/release-days serves them. */
+export interface CloudMacroReleaseDaysPayload {
+  /** When the publishers' pages were read, ISO. */
+  checkedAt: string;
+  /** The last New York day the lists are complete for. */
+  coveredThrough: string;
+  sources: string[];
+  /** New York dates, oldest first. */
+  releases: Record<"cpi" | "jobs" | "fomc", string[]>;
+}
+
 export interface CloudFredObservationPayload {
   date: string;
   value: number | null;
@@ -408,6 +455,11 @@ export interface CloudFredSeriesPayload {
   coverage?: { observations: "available"; info: "available" | "unavailable" };
 }
 
+/** The FRED series Gloom Cloud serves, from `GET /cloud/econ/series`; any other id is refused. */
+export interface CloudFredSeriesCatalogPayload {
+  series: Array<{ id: string; title?: string | null; group?: string | null }>;
+}
+
 /**
  * One month of Robert Shiller's dataset. FRED carries no long-run S&P earnings,
  * so this is what every earnings-based valuation ratio is built from.
@@ -1319,6 +1371,8 @@ export interface CloudMarketResponse<T> {
   status: CloudMarketStatus;
   data: T | null;
   reasonCode?: string;
+  /** Untrusted, human-readable reason the answer is empty. Cleaned before it is shown. */
+  message?: string;
   asOf?: string;
   staleAt?: string;
   stale?: boolean;
@@ -1362,6 +1416,8 @@ export interface CloudMarketBatchItem<T> {
   status: CloudMarketStatus;
   data: T | null;
   reasonCode?: string;
+  /** Untrusted, human-readable reason this item is empty. Cleaned before it is shown. */
+  message?: string;
   stale?: boolean;
 }
 

package/src/api-client/upgrade-experiment.ts

@@ -0,0 +1,90 @@
+import type { ExperimentAnswer, StorageLike } from "./web-experiments";
+
+/**
+ * `upgrade_personalized`: the upgrade sheet and onboarding's Pro step name
+ * the account's own holdings, or the tickers it watches, instead of the
+ * generic line. The registry, the arm and the stop
+ * switch live with the API (gloomberb-platform `shared/experiments.ts`); the
+ * unit is the signed-in free account, so the same person gets the same arm in
+ * the terminal, the desktop app, the web terminal and on gloom.sh/cloud.
+ *
+ * The tickers never leave the device: the exposure carries the experiment and
+ * where it was shown, nothing about the holdings.
+ */
+export const UPGRADE_PERSONALIZED = "upgrade_personalized";
+
+export type UpgradePersonalizedVariant = "control" | "personalized";
+
+export interface UpgradeExperimentContext {
+  accountId?: string;
+  pro: boolean;
+  optedOut: boolean;
+  automated: boolean;
+  /** Keeps this session's answer across reloads where there is one (web, desktop). */
+  session?: StorageLike;
+}
+
+const SESSION_PREFIX = "gloomberb.upgrade-personalized.exposed:";
+
+function unit(context: UpgradeExperimentContext): string | undefined {
+  if (!context.accountId || context.pro || context.optedOut || context.automated) return undefined;
+  return `account:${context.accountId}`;
+}
+
+function isVariant(value: unknown): value is UpgradePersonalizedVariant {
+  return value === "control" || value === "personalized";
+}
+
+function read(storage: StorageLike | undefined, key: string): string | null {
+  try { return storage?.getItem(key) ?? null; } catch { return null; }
+}
+
+function write(storage: StorageLike | undefined, key: string, value: string): void {
+  try { storage?.setItem(key, value); } catch { /* Storage is optional in private browsing. */ }
+}
+
+/**
+ * One exposure per account and session. An accepted arm, or the API's "not in
+ * the experiment", is kept for the session; a failed request (offline, an API
+ * that does not know the experiment yet, a timeout) is not an exposure and is
+ * asked again by the next surface.
+ */
+export function createUpgradeExperimentSession() {
+  const answers = new Map<string, UpgradePersonalizedVariant | null>();
+  const pending = new Map<string, Promise<UpgradePersonalizedVariant | null>>();
+
+  function known(context: UpgradeExperimentContext): UpgradePersonalizedVariant | null | undefined {
+    const identity = unit(context);
+    if (!identity) return null;
+    if (answers.has(identity)) return answers.get(identity);
+    const saved = read(context.session, `${SESSION_PREFIX}${identity}`);
+    if (saved === "excluded") return null;
+    return isVariant(saved) ? saved : undefined;
+  }
+
+  return {
+    /** The arm already answered in this session, null outside it, undefined when not asked yet. */
+    known,
+    expose(
+      context: UpgradeExperimentContext,
+      ask: () => Promise<ExperimentAnswer>,
+    ): Promise<UpgradePersonalizedVariant | null> {
+      const identity = unit(context);
+      if (!identity) return Promise.resolve(null);
+      const previous = known(context);
+      if (previous !== undefined) return Promise.resolve(previous);
+      const inFlight = pending.get(identity);
+      if (inFlight) return inFlight;
+      const request = (async () => {
+        let answer: ExperimentAnswer;
+        try { answer = await ask(); } catch { return null; }
+        const variant = answer.accepted && isVariant(answer.variant) ? answer.variant : null;
+        answers.set(identity, variant);
+        write(context.session, `${SESSION_PREFIX}${identity}`, variant ?? "excluded");
+        return variant;
+      })().finally(() => pending.delete(identity));
+      pending.set(identity, request);
+      return request;
+    },
+  };
+}

package/src/app/global-shortcuts.ts

@@ -14,6 +14,7 @@ import { requestFunctionHelp, useFunctionHelpHost } from "../plugins/builtin/hel
 import { buildRegistryHelpIndex, helpFunctionForPane } from "../plugins/builtin/help/function-index";
 import { recordFunctionOpen } from "../telemetry/usage-counts";
 import { isMoveDownShortcut, isMoveUpShortcut } from "../components/command-bar/keyboard-handlers";
+import { pressStarPromptKey } from "./star-prompt/runtime";
 import {
   copyActiveSelection,
   isCopyShortcut,
@@ -154,10 +155,19 @@ export function useAppGlobalShortcuts({
     }
 
     // Toasts float above everything, so their keys work over a dialog too.
+    // The status bar's star line answers the same keys once no toast does,
+    // but only over the workspace itself.
     if (action === "notification-action" || action === "notification-dismiss") {
-      const handled = action === "notification-action"
+      const toastHandled = action === "notification-action"
         ? toastHost.activateNewest?.() === true
         : toastHost.dismissNewest?.() === true;
+      const handled = toastHandled || (
+        !dialogOpen
+        && !state.commandBarOpen
+        && !state.inputCaptured
+        && !isDetachedWindow
+        && pressStarPromptKey(action === "notification-action" ? "open" : "dismiss")
+      );
       if (handled) {
         event.preventDefault();
         event.stopPropagation();

package/src/app/keybindings/actions.ts

@@ -22,6 +22,7 @@ export type CoreKeybindingActionId =
   | "close-floating-panes"
   | "pane-settings"
   | "pane-fullscreen"
+  | "pane-new-layout"
   | "pane-float"
   | "pane-pop-out"
   | "pane-screenshot"
@@ -52,6 +53,7 @@ export const PANE_ACTION_IDS = new Set<CoreKeybindingActionId>([
   "close-floating-panes",
   "pane-settings",
   "pane-fullscreen",
+  "pane-new-layout",
   "pane-float",
   "pane-pop-out",
   "pane-screenshot",
@@ -186,6 +188,14 @@ export const KEYBINDING_ACTIONS: readonly KeybindingActionDef[] = [
     description: "Fill the window with the focused pane, or restore it.",
     defaults: ["CmdOrCtrl+Shift+F"],
   },
+  {
+    id: "pane-new-layout",
+    category: "Pane Management",
+    description: "Move the focused pane to a new layout of its own, or back to the layout it came from.",
+    // N for new, and no app chord had it. Browsers keep Ctrl/Cmd+Shift+N for a
+    // private window, so on the web the pane menu and command bar carry it.
+    defaults: ["CmdOrCtrl+Shift+N"],
+  },
   {
     id: "pane-float",
     category: "Pane Management",

package/src/app/pane-runtime/index.tsx

@@ -10,6 +10,7 @@ import {
   isPaneInLayout,
 } from "../../layout/pane-manager";
 import type { PluginRegistry } from "../../plugins/registry";
+import { PluginOffError, notifyPluginOff } from "../../plugins/plugin-off";
 import type { LoadedExternalPlugin } from "../../plugins/loader";
 import {
   getFocusedCollectionId,
@@ -215,6 +216,12 @@ export function useAppPaneRuntime({
     const target = resolvePaneShowTarget(state.config.layout, paneId);
     const paneDef = pluginRegistry.panes.get(target.paneType);
     if (!paneDef) return;
+    // Its pane would be added, or focused, hidden.
+    const owner = pluginRegistry.getDisabledPaneOwner(target.paneType, stateRef.current.config.disabledPlugins);
+    if (owner) {
+      notifyPluginOff(pluginRegistry, new PluginOffError(owner, paneDef.name), () => pluginRegistry.showPane(paneId));
+      return;
+    }
 
     if (target.paneType === TICKER_RESEARCH_PANE_ID) {
       showTickerResearchPane();
@@ -241,6 +248,7 @@ export function useAppPaneRuntime({
     pluginRegistry,
     showTickerResearchPane,
     state.config.layout,
+    stateRef,
   ]);
 
   const { createPaneFromTemplate } = useAppPaneTemplateRuntime({

package/src/app/pane-runtime/pane-template-runtime.ts

@@ -4,6 +4,7 @@ import { createPaneTemplateOrThrow } from "../../components/command-bar/workflow
 import { openFormModal } from "../../components/form-modal";
 import type { AppTickerRepositoryPort } from "../../core/app-service-ports";
 import type { PluginRegistry } from "../../plugins/registry";
+import { PluginOffError, notifyPluginOff } from "../../plugins/plugin-off";
 import type { AppAction, AppState } from "../../state/app/context";
 import type { PaneBinding, PaneInstanceConfig } from "../../types/config";
 import type { DataProvider } from "../../types/data-provider";
@@ -70,6 +71,10 @@ export function useAppPaneTemplateRuntime({
         placePaneInstance,
       });
     } catch (error) {
+      if (error instanceof PluginOffError) {
+        notifyPluginOff(pluginRegistry, error, () => { void createPaneFromTemplate(templateId, options); });
+        return;
+      }
       notify(
         error instanceof Error ? error.message : `Could not create ${getPaneTemplateDisplayLabel(template).toLowerCase()}.`,
         { type: "info" },

package/src/app/pane-runtime/plugin-bindings.ts

@@ -8,6 +8,13 @@ import { openFormModal } from "../../components/form-modal";
 import { t } from "../../i18n";
 import { openBrokerAddFlow } from "../../plugins/builtin/broker-manager/add-request";
 import { getPanelFocusTarget } from "../../core/state/app/layout";
+import { getVisiblePaneCycleOrder } from "../../components/layout/pane/cycle-order";
+import {
+  collectDisabledPaneIds,
+  resolveShellVisibleLayout,
+  restoreShellHiddenPanes,
+} from "../../components/layout/shell/visible-layout";
+import { applyPluginToggles } from "../../plugins/ownership";
 import { setLayoutManagerDispatch } from "../../plugins/builtin/layout-manager";
 import { setMarketplaceHost } from "../../plugins/builtin/plugin-marketplace/store";
 import type { InstalledPlugin } from "../../plugins/builtin/plugin-marketplace/model";
@@ -25,6 +32,7 @@ import {
   removePane,
 } from "../../layout/pane-manager";
 import type { PluginRegistry } from "../../plugins/registry";
+import { PluginOffError, notifyPluginOff } from "../../plugins/plugin-off";
 import { reportCrash } from "../../telemetry/crash-reports";
 import { recordFunctionOpen, usageFunctionForPane } from "../../telemetry/usage-counts";
 import { captureAttentionAction } from "../../telemetry/attention-counts";
@@ -33,15 +41,16 @@ import {
   resolveTickerNavigationReplacementPane,
   shouldFocusTickerNavigationTarget,
 } from "../../layout/ticker-navigation";
-import type {
-  AppAction,
-  AppState,
+import {
+  resolveTickerForPane,
+  type AppAction,
+  type AppState,
 } from "../../state/app/context";
 import type {
   LayoutConfig,
   PaneInstanceConfig,
 } from "../../types/config";
-import { TICKER_RESEARCH_PANE_ID } from "../../types/config";
+import { findPaneInstance, TICKER_RESEARCH_PANE_ID } from "../../types/config";
 import type { DataProvider } from "../../types/data-provider";
 import type {
   PaneDef,
@@ -129,7 +138,33 @@ export function bindAppPanePluginRegistry({
   switchTickerResearchTab,
   tickerRepository,
 }: BindAppPanePluginRegistryOptions): void {
+  // Switching plugins never edits the layout: the shell hides a switched-off
+  // plugin's panes where they are and shows them again when it comes back.
+  // Only focus moves, off a pane that just went hidden.
+  const setPluginsEnabled = (changes: Readonly<Record<string, boolean>>) => {
+    const current = stateRef.current;
+    // Setting a state, not flipping it, so a second "Turn on" from an older
+    // toast cannot switch the plugin back off.
+    const disabledPlugins = applyPluginToggles(current.config.disabledPlugins ?? [], changes);
+    if (!disabledPlugins) return;
+    const focused = current.focusedPaneId ? findPaneInstance(current.config.layout, current.focusedPaneId) : undefined;
+    const focusHidden = !!focused && collectDisabledPaneIds(pluginRegistry, disabledPlugins).has(focused.paneId);
+    dispatch(focusHidden
+      ? {
+        type: "SET_DISABLED_PLUGINS",
+        disabledPlugins,
+        focusedPaneId: getVisiblePaneCycleOrder(current.config.layout, pluginRegistry, disabledPlugins)[0] ?? null,
+      }
+      : { type: "SET_DISABLED_PLUGINS", disabledPlugins });
+    const nextConfig = { ...current.config, disabledPlugins };
+    persistConfig(nextConfig);
+    pluginRegistry.events.emit("config:changed", { config: nextConfig });
+  };
+  const setPluginEnabled = (pluginId: string, enabled: boolean) => setPluginsEnabled({ [pluginId]: enabled });
+
   pluginRegistry.bindHost({
+    setPluginEnabled,
+    setPluginsEnabled,
     selectTicker: (symbol, paneId) => selectTickerInPane(symbol, paneId),
     switchPanel: (panel) => {
       if (isDetachedWindow) return;
@@ -196,10 +231,9 @@ export function bindAppPanePluginRegistry({
       const sharedPane = materialized.layout.instances[0];
       if (!sharedPane) throw new Error("This shared pane is invalid.");
       const paneDef = pluginRegistry.panes.get(sharedPane.paneId);
-      const ownerId = pluginRegistry.getPanePluginId(sharedPane.paneId);
-      if (!paneDef || (ownerId && stateRef.current.config.disabledPlugins.includes(ownerId))) {
-        throw new Error("This shared pane is unavailable in this version of Gloomberb.");
-      }
+      if (!paneDef) throw new Error("This shared pane is unavailable in this version of Gloomberb.");
+      const owner = pluginRegistry.getDisabledPaneOwner(sharedPane.paneId, stateRef.current.config.disabledPlugins);
+      if (owner) throw new PluginOffError(owner, "this shared pane");
       const instance = buildPaneInstance(sharedPane.paneId, sharedPane);
       if (!instance) throw new Error("This shared pane could not be created.");
       dispatch({
@@ -242,6 +276,15 @@ export function bindAppPanePluginRegistry({
         showPane(paneId);
         return;
       }
+      // In the layout but hidden with its plugin, as the research pane that
+      // follows a list is while Ticker Research is off.
+      const paneType = findPaneInstance(stateRef.current.config.layout, instanceId)?.paneId;
+      const owner = paneType ? pluginRegistry.getDisabledPaneOwner(paneType, stateRef.current.config.disabledPlugins) : null;
+      if (owner) {
+        const what = resolveTickerForPane(stateRef.current, instanceId) ?? pluginRegistry.panes.get(paneType!)?.name ?? paneType!;
+        notifyPluginOff(pluginRegistry, new PluginOffError(owner, what), () => pluginRegistry.focusPane(paneId, layout));
+        return;
+      }
 
       focusVisiblePane(instanceId, layout);
     },
@@ -254,6 +297,12 @@ export function bindAppPanePluginRegistry({
     },
     navigateTicker: (rawSymbol, options) => {
       if (isDetachedWindow) return;
+      // Navigation lands in a research pane, which stays hidden while its plugin is off.
+      const researchOwner = pluginRegistry.getDisabledPaneOwner(TICKER_RESEARCH_PANE_ID, stateRef.current.config.disabledPlugins);
+      if (researchOwner) {
+        notifyPluginOff(pluginRegistry, new PluginOffError(researchOwner, rawSymbol), () => pluginRegistry.navigateTicker(rawSymbol, options));
+        return;
+      }
       const recordAttention = captureAttentionAction();
       recordFunctionOpen(usageFunctionForPane(pluginRegistry, TICKER_RESEARCH_PANE_ID));
       const sourcePaneId = options?.sourcePaneId ?? stateRef.current.focusedPaneId;
@@ -334,12 +383,15 @@ export function bindAppPanePluginRegistry({
     },
   });
 
+  // Layout commands (Tidy, Swap, Float, Close) act on what is on screen, as
+  // the shell's own menus do, and leave a switched-off plugin's panes alone.
+  const disabledPaneIds = () => collectDisabledPaneIds(pluginRegistry, stateRef.current.config.disabledPlugins);
   setLayoutManagerDispatch(dispatch, () => ({
-    layout: state.config.layout,
+    layout: resolveShellVisibleLayout(state.config.layout, disabledPaneIds(), pluginRegistry.panes),
     termWidth: pluginRegistry.getTermSize().width,
     termHeight: pluginRegistry.getTermSize().height,
     focusedPaneId: state.focusedPaneId,
-  }));
+  }), (edited) => restoreShellHiddenPanes(stateRef.current.config.layout, edited, disabledPaneIds(), pluginRegistry.panes));
 
   setExternalPlugins(externalPlugins);
 
@@ -457,7 +509,7 @@ export function bindAppPanePluginRegistry({
         });
       const commands = [...pluginRegistry.commands.entries()]
         .filter(([id]) => pluginRegistry.getCommandPluginId(id) === pluginId && !id.endsWith(":setup"))
-        .map(([id, command]) => ({ id, label: command.label }));
+        .map(([id, command]) => ({ id, label: command.label, ...(command.shortcut ? { shortcut: command.shortcut } : {}) }));
       const capabilities = pluginRegistry.capabilities.manifests()
         .filter((manifest) => pluginRegistry.getCapabilityPluginId(manifest.id) === pluginId).length;
       const broker = [...pluginRegistry.brokers.keys()].some((type) => pluginRegistry.getBrokerPluginId(type) === pluginId);
@@ -466,19 +518,7 @@ export function bindAppPanePluginRegistry({
     notify: (notification) => {
       pluginRegistry.notify(notification);
     },
-    setPluginEnabled: (pluginId, enabled) => {
-      const current = stateRef.current.config;
-      if (!enabled) {
-        for (const paneId of pluginRegistry.getPluginPaneIds(pluginId)) pluginRegistry.hidePane(paneId);
-      }
-      dispatch({ type: "TOGGLE_PLUGIN", pluginId });
-      const disabled = current.disabledPlugins ?? [];
-      persistConfig({
-        ...current,
-        disabledPlugins: enabled
-          ? disabled.filter((entry) => entry !== pluginId)
-          : [...disabled, pluginId],
-      });
-    },
+    setPluginEnabled,
+    setPluginsEnabled,
   });
 }

package/src/app/pane-runtime/ticker-inspector-runtime.ts

@@ -5,6 +5,7 @@ import {
   findDockLeaf,
 } from "../../layout/pane-manager";
 import type { PluginRegistry } from "../../plugins/registry";
+import { PluginOffError, notifyPluginOff } from "../../plugins/plugin-off";
 import {
   findTickerResearchFollower,
   listVisibleTickerSourcePanes,
@@ -110,6 +111,15 @@ export function useAppTickerInspectorRuntime({
   }, [pluginRegistry, resolveInspectorPane, state.config.layout]);
 
   const switchTickerResearchTab = useCallback((tabId: string, preferredPaneId?: string | null) => {
+    // The tab lives in a research pane, which stays hidden while its plugin is
+    // off, and the tab itself is hidden while its own plugin is.
+    const owner = pluginRegistry.getDisabledPaneOwner(TICKER_RESEARCH_PANE_ID, state.config.disabledPlugins)
+      ?? pluginRegistry.getDisabledTickerResearchTabOwner(tabId, state.config.disabledPlugins);
+    if (owner) {
+      const tabName = pluginRegistry.tickerResearchTabs.get(tabId)?.name ?? "this tab";
+      notifyPluginOff(pluginRegistry, new PluginOffError(owner, tabName), () => pluginRegistry.switchTab(tabId, preferredPaneId ?? undefined));
+      return;
+    }
     const targetPaneId = (() => {
       const target = preferredPaneId ? resolvePaneInstance(state.config.layout, preferredPaneId) : null;
       if (target?.paneId === TICKER_RESEARCH_PANE_ID) return target.instanceId;
@@ -131,7 +141,9 @@ export function useAppTickerInspectorRuntime({
     dispatch,
     ensureInspectorPane,
     persistLayout,
+    pluginRegistry,
     resolveTickerSourcePaneId,
+    state.config.disabledPlugins,
     state.config.layout,
     state.focusedPaneId,
   ]);