gloomberb 0.12.0 → 0.13.2

package/src/remote/schema.ts

@@ -1,4 +1,12 @@
-import type { RemoteControlSchema, RemoteOperationSchema, RemoteResourceSchema } from "./types";
+import type {
+  RemoteControlSchema,
+  RemoteJsonSchema,
+  RemoteOperationDescriptor,
+  RemoteOperationSchema,
+  RemoteResourceSchema,
+  RemoteSideEffectLevel,
+  RemoteWriteTier,
+} from "./types";
 
 export const REMOTE_RESOURCES: RemoteResourceSchema[] = [
   { uri: "app://snapshot", description: "Current app snapshot including layout, focus, panes, command bar, and plugin/capability catalogs." },
@@ -19,43 +27,262 @@ export const REMOTE_RESOURCES: RemoteResourceSchema[] = [
   { uri: "ui://tree", description: "Live semantic UI node tree populated by shared controls and interactive primitives." },
 ];
 
+const stringSchema = { type: "string" } satisfies RemoteJsonSchema;
+const requiredStringSchema = { type: "string", minLength: 1 } satisfies RemoteJsonSchema;
+const booleanSchema = { type: "boolean" } satisfies RemoteJsonSchema;
+const indexSchema = { type: "integer", minimum: 0 } satisfies RemoteJsonSchema;
+const openObjectSchema = { type: "object", additionalProperties: true } satisfies RemoteJsonSchema;
+const anySchema = {} satisfies RemoteJsonSchema;
+
+function objectSchema(
+  properties: Record<string, RemoteJsonSchema> = {},
+  required: string[] = [],
+): RemoteJsonSchema {
+  return {
+    type: "object",
+    properties,
+    ...(required.length > 0 ? { required } : {}),
+    additionalProperties: false,
+  };
+}
+
+const paneIdInput = objectSchema({ paneId: requiredStringSchema }, ["paneId"]);
+
 export const REMOTE_OPERATIONS: RemoteOperationSchema[] = [
-  op("app.openCommandBar", "Open the command bar with an optional query and optional mode.", "{ query?: string, mode?: 'command' | 'ticker' }", "local-write"),
-  op("app.closeCommandBar", "Close the command bar.", "{}", "local-write"),
-  op("app.setCommandBarQuery", "Set the command bar query.", "{ query: string }", "local-write"),
-  op("app.search", "Open command-bar search without requiring UI prefix syntax.", "{ mode: 'command' | 'ticker', query?: string }", "local-write"),
-  op("app.switchPanel", "Switch the active panel.", "{ panel: 'left' | 'right' }", "local-write"),
-  op("app.notify", "Show an in-app notification.", "{ body: string, type?: string }", "local-write"),
-  op("commandBar.activateResult", "Activate a visible command-bar result by zero-based index, node id, item id, or label.", "{ index?: number, nodeId?: string, itemId?: string, label?: string }", "local-write"),
-  op("pane.show", "Show or focus a pane type.", "{ paneId: string }", "local-write"),
-  op("pane.focus", "Focus a pane instance or pane type.", "{ paneId: string }", "local-write"),
-  op("pane.close", "Close a pane instance or pane type.", "{ paneId: string }", "local-write"),
-  op("pane.createFromTemplate", "Create a pane from a registered template.", "{ templateId: string, options?: object }", "local-write"),
-  op("pane.setState", "Patch pane runtime state.", "{ paneId: string, patch: object }", "local-write"),
-  op("pane.setSetting", "Set one pane setting using the pane's registered setting field when available.", "{ paneId: string, key: string, value: any }", "local-write"),
-  op("ticker.navigate", "Navigate a ticker into the best available ticker research target.", "{ symbol: string, sourcePaneId?: string }", "local-write"),
-  op("ticker.pin", "Open or focus a fixed ticker research pane.", "{ symbol: string, floating?: boolean, forceNewPane?: boolean, paneType?: string }", "local-write"),
-  op("ticker.select", "Select a ticker in a target pane.", "{ symbol: string, paneId?: string }", "local-write"),
-  op("ticker.switchTab", "Switch ticker research tab.", "{ tabId: string, paneId?: string }", "local-write"),
-  op("layout.switch", "Switch active layout by index.", "{ index: number }", "local-write"),
-  op("layout.new", "Create a new blank layout.", "{ name: string }", "local-write"),
-  op("layout.rename", "Rename a layout.", "{ index: number, name: string }", "local-write"),
-  op("layout.duplicate", "Duplicate a layout.", "{ index: number }", "local-write"),
-  op("layout.delete", "Delete a layout.", "{ index: number }", "local-write"),
-  op("layout.undo", "Undo last layout change.", "{}", "local-write"),
-  op("layout.redo", "Redo last layout change.", "{}", "local-write"),
-  op("layout.gridlock", "Tidy all panes into a dense layout.", "{}", "local-write"),
-  op("layout.closeFloating", "Close all floating panes in the active layout.", "{}", "local-write"),
-  op("layout.placePane", "Move a pane to a layout region.", "{ paneId: string, region: 'left' | 'right' | 'top' | 'bottom' | 'floating', relativeTo?: string }", "local-write"),
-  op("layout.focusRegion", "Focus a pane by visual layout region.", "{ region: 'left' | 'right' | 'top' | 'bottom' | 'center' }", "local-write"),
-  op("layout.setGrid", "Dock visible or specified panes into a simple grid.", "{ paneIds?: string[], columns?: number }", "local-write"),
-  op("desktop.popOutPane", "Pop a pane into a detached desktop window.", "{ paneId: string }", "local-write"),
-  op("desktop.dockPane", "Dock a detached desktop pane.", "{ paneId: string }", "local-write"),
-  op("desktop.closeDetachedPane", "Close a detached desktop pane.", "{ paneId: string }", "local-write"),
-  op("desktop.focusDetachedPane", "Focus a detached desktop pane.", "{ paneId: string }", "local-write"),
-  op("capability.invoke", "Invoke a registered plugin capability operation.", "{ capabilityId: string, operationId: string, payload?: object }", "local-write"),
-  op("ui.invoke", "Invoke an action on a live semantic UI node.", "{ nodeId: string, action?: string, input?: any }", "local-write"),
-  op("ui.invokeMatching", "Invoke an action on the first semantic UI node matching role, label, index, or metadata.", "{ role?: string, label?: string, contains?: string, index?: number, action?: string, input?: any, metadata?: object }", "local-write"),
+  op(
+    "app.openCommandBar",
+    "Open the command bar with an optional query and optional mode.",
+    "{ query?: string, mode?: 'command' | 'ticker' | 'default' }",
+    "local-write",
+    objectSchema({
+      query: stringSchema,
+      mode: { type: "string", enum: ["command", "ticker", "default"] },
+    }),
+  ),
+  op("app.closeCommandBar", "Close the command bar.", "{}", "local-write", objectSchema()),
+  op(
+    "app.setCommandBarQuery",
+    "Set the command bar query.",
+    "{ query: string }",
+    "local-write",
+    objectSchema({ query: requiredStringSchema }, ["query"]),
+  ),
+  op(
+    "app.search",
+    "Open command-bar search without requiring UI prefix syntax.",
+    "{ mode?: 'command' | 'ticker' | 'default', query?: string }",
+    "local-write",
+    objectSchema({
+      mode: { type: "string", enum: ["command", "ticker", "default"] },
+      query: stringSchema,
+    }),
+  ),
+  op(
+    "app.switchPanel",
+    "Switch the active panel.",
+    "{ panel: 'left' | 'right' }",
+    "local-write",
+    objectSchema({ panel: { type: "string", enum: ["left", "right"] } }, ["panel"]),
+  ),
+  op(
+    "app.notify",
+    "Show an in-app notification.",
+    "{ body: string, type?: 'info' | 'success' | 'error' }",
+    "local-write",
+    objectSchema({
+      body: requiredStringSchema,
+      type: { type: "string", enum: ["info", "success", "error"] },
+    }, ["body"]),
+  ),
+  op(
+    "commandBar.activateResult",
+    "Activate a visible command-bar result by zero-based index, node id, item id, or label.",
+    "{ index?: number, nodeId?: string, itemId?: string, label?: string }",
+    "local-write",
+    objectSchema({ index: indexSchema, nodeId: stringSchema, itemId: stringSchema, label: stringSchema }),
+  ),
+  op("pane.show", "Show or focus a pane type.", "{ paneId: string }", "local-write", paneIdInput),
+  op("pane.focus", "Focus a pane instance or pane type.", "{ paneId: string }", "local-write", paneIdInput),
+  op("pane.close", "Close a pane instance or pane type.", "{ paneId: string }", "local-write", paneIdInput),
+  op(
+    "pane.createFromTemplate",
+    "Create a pane from a registered template.",
+    "{ templateId: string, options?: object }",
+    "local-write",
+    objectSchema({ templateId: requiredStringSchema, options: openObjectSchema }, ["templateId"]),
+  ),
+  op(
+    "pane.setState",
+    "Patch pane runtime state.",
+    "{ paneId: string, patch: object }",
+    "local-write",
+    objectSchema({ paneId: requiredStringSchema, patch: openObjectSchema }, ["paneId", "patch"]),
+  ),
+  op(
+    "pane.setSetting",
+    "Set one pane setting using the pane's registered setting field when available.",
+    "{ paneId: string, key: string, value: any }",
+    "local-write",
+    objectSchema({ paneId: requiredStringSchema, key: requiredStringSchema, value: anySchema }, ["paneId", "key", "value"]),
+  ),
+  op(
+    "ticker.navigate",
+    "Navigate a ticker into the best available ticker research target.",
+    "{ symbol: string, sourcePaneId?: string }",
+    "local-write",
+    objectSchema({ symbol: requiredStringSchema, sourcePaneId: stringSchema }, ["symbol"]),
+  ),
+  op(
+    "ticker.pin",
+    "Open or focus a fixed ticker research pane.",
+    "{ symbol: string, floating?: boolean, forceNewPane?: boolean, paneType?: string }",
+    "local-write",
+    objectSchema({
+      symbol: requiredStringSchema,
+      floating: booleanSchema,
+      forceNewPane: booleanSchema,
+      paneType: stringSchema,
+    }, ["symbol"]),
+  ),
+  op(
+    "ticker.select",
+    "Select a ticker in a target pane.",
+    "{ symbol: string, paneId?: string }",
+    "local-write",
+    objectSchema({ symbol: requiredStringSchema, paneId: stringSchema }, ["symbol"]),
+  ),
+  op(
+    "ticker.switchTab",
+    "Switch ticker research tab.",
+    "{ tabId: string, paneId?: string }",
+    "local-write",
+    objectSchema({ tabId: requiredStringSchema, paneId: stringSchema }, ["tabId"]),
+  ),
+  op(
+    "layout.switch",
+    "Switch active layout by index.",
+    "{ index: number }",
+    "local-write",
+    objectSchema({ index: indexSchema }, ["index"]),
+  ),
+  op(
+    "layout.new",
+    "Create a new blank layout.",
+    "{ name: string }",
+    "local-write",
+    objectSchema({ name: requiredStringSchema }, ["name"]),
+  ),
+  op(
+    "layout.rename",
+    "Rename a layout.",
+    "{ index: number, name: string }",
+    "local-write",
+    objectSchema({ index: indexSchema, name: requiredStringSchema }, ["index", "name"]),
+  ),
+  op(
+    "layout.duplicate",
+    "Duplicate a layout.",
+    "{ index: number }",
+    "local-write",
+    objectSchema({ index: indexSchema }, ["index"]),
+  ),
+  op(
+    "layout.delete",
+    "Delete a layout.",
+    "{ index: number }",
+    "local-write",
+    objectSchema({ index: indexSchema }, ["index"]),
+    "user-data",
+  ),
+  op("layout.undo", "Undo last layout change.", "{}", "local-write", objectSchema()),
+  op("layout.redo", "Redo last layout change.", "{}", "local-write", objectSchema()),
+  op("layout.gridlock", "Tidy all panes into a dense layout.", "{}", "local-write", objectSchema()),
+  op(
+    "layout.closeFloating",
+    "Close all floating panes in the active layout.",
+    "{}",
+    "local-write",
+    objectSchema(),
+  ),
+  op(
+    "layout.placePane",
+    "Move a pane to a layout region.",
+    "{ paneId: string, region: 'left' | 'right' | 'top' | 'bottom' | 'floating', relativeTo?: string }",
+    "local-write",
+    objectSchema({
+      paneId: requiredStringSchema,
+      region: { type: "string", enum: ["left", "right", "top", "bottom", "floating"] },
+      relativeTo: stringSchema,
+    }, ["paneId", "region"]),
+  ),
+  op(
+    "layout.focusRegion",
+    "Focus a pane by visual layout region.",
+    "{ region: 'left' | 'right' | 'top' | 'bottom' | 'center' }",
+    "local-write",
+    objectSchema({
+      region: { type: "string", enum: ["left", "right", "top", "bottom", "center"] },
+    }, ["region"]),
+  ),
+  op(
+    "layout.setGrid",
+    "Dock visible or specified panes into a simple grid.",
+    "{ paneIds?: string[], columns?: number }",
+    "local-write",
+    objectSchema({
+      paneIds: { type: "array", items: requiredStringSchema },
+      columns: { type: "integer", minimum: 1 },
+    }),
+  ),
+  op("desktop.popOutPane", "Pop a pane into a detached desktop window.", "{ paneId: string }", "local-write", paneIdInput),
+  op("desktop.dockPane", "Dock a detached desktop pane.", "{ paneId: string }", "local-write", paneIdInput),
+  op(
+    "desktop.closeDetachedPane",
+    "Close a detached desktop pane.",
+    "{ paneId: string }",
+    "local-write",
+    paneIdInput,
+  ),
+  op(
+    "desktop.focusDetachedPane",
+    "Focus a detached desktop pane.",
+    "{ paneId: string }",
+    "local-write",
+    paneIdInput,
+  ),
+  op(
+    "capability.invoke",
+    "Invoke a registered plugin capability operation.",
+    "{ capabilityId: string, operationId: string, payload?: object }",
+    "external-side-effect",
+    objectSchema({
+      capabilityId: requiredStringSchema,
+      operationId: requiredStringSchema,
+      payload: openObjectSchema,
+    }, ["capabilityId", "operationId"]),
+  ),
+  op(
+    "ui.invoke",
+    "Invoke an action on a live semantic UI node.",
+    "{ nodeId: string, action?: string, input?: any }",
+    "local-write",
+    objectSchema({ nodeId: requiredStringSchema, action: stringSchema, input: anySchema }, ["nodeId"]),
+  ),
+  op(
+    "ui.invokeMatching",
+    "Invoke an action on the first semantic UI node matching role, label, index, or metadata.",
+    "{ role?: string, label?: string, contains?: string, index?: number, action?: string, input?: any, metadata?: object }",
+    "local-write",
+    objectSchema({
+      role: stringSchema,
+      label: stringSchema,
+      contains: stringSchema,
+      index: indexSchema,
+      action: stringSchema,
+      input: anySchema,
+      metadata: openObjectSchema,
+    }),
+  ),
 ];
 
 export const REMOTE_AGENT_HELP = {
@@ -134,11 +361,67 @@ export function remoteControlSchema(): RemoteControlSchema {
   };
 }
 
+export function writeTierForSideEffectLevel(
+  sideEffectLevel: RemoteSideEffectLevel,
+): RemoteWriteTier {
+  switch (sideEffectLevel) {
+    case "none":
+      return "read";
+    case "local-write":
+      return "ui-write";
+    case "network-write":
+      return "user-data";
+    case "external-side-effect":
+    case "external-trade":
+      return "broker";
+  }
+}
+
+export function remoteOperationDescriptors(): RemoteOperationDescriptor[] {
+  return REMOTE_OPERATIONS.map(({ id, title, description, writeTier, inputSchema }) => ({
+    name: remoteOperationToolName(id),
+    title,
+    description,
+    writeTier,
+    inputSchema,
+  }));
+}
+
+export function remoteOperationToolName(id: string): string {
+  return id
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .toLowerCase();
+}
+
+function operationTitle(id: string): string {
+  const [scope = "", action = ""] = id.split(".");
+  return `${humanizeIdentifier(scope)}: ${humanizeIdentifier(action)}`;
+}
+
+function humanizeIdentifier(value: string): string {
+  if (value === "ui") return "UI";
+  return value
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/^./, (character) => character.toUpperCase());
+}
+
 function op(
   id: string,
   description: string,
   inputShape: string,
-  sideEffectLevel: RemoteOperationSchema["sideEffectLevel"],
+  sideEffectLevel: RemoteSideEffectLevel,
+  inputSchema: RemoteJsonSchema,
+  writeTier = writeTierForSideEffectLevel(sideEffectLevel),
 ): RemoteOperationSchema {
-  return { id, description, inputShape, sideEffectLevel, dryRun: sideEffectLevel !== "none" };
+  return {
+    id,
+    title: operationTitle(id),
+    description,
+    inputShape,
+    inputSchema,
+    sideEffectLevel,
+    writeTier,
+    requiresConfirmation: writeTier === "user-data" || writeTier === "broker",
+    dryRun: sideEffectLevel !== "none",
+  };
 }

package/src/remote/types.ts

@@ -100,19 +100,66 @@ export interface RemoteResourceSchema {
   patchable?: boolean;
 }
 
+export type RemoteSideEffectLevel =
+  | "none"
+  | "local-write"
+  | "network-write"
+  | "external-side-effect"
+  | "external-trade";
+
+export type RemoteWriteTier = "read" | "ui-write" | "user-data" | "broker";
+
+export type RemoteJsonSchemaType =
+  | "object"
+  | "array"
+  | "string"
+  | "number"
+  | "integer"
+  | "boolean"
+  | "null";
+
+/** Serializable subset of JSON Schema used for remote operation inputs. */
+export interface RemoteJsonSchema {
+  type?: RemoteJsonSchemaType | RemoteJsonSchemaType[];
+  description?: string;
+  properties?: Record<string, RemoteJsonSchema>;
+  required?: string[];
+  additionalProperties?: boolean;
+  items?: RemoteJsonSchema;
+  enum?: Array<string | number | boolean | null>;
+  minimum?: number;
+  maximum?: number;
+  minItems?: number;
+  maxItems?: number;
+  minLength?: number;
+  maxLength?: number;
+}
+
 export interface RemoteOperationSchema {
   id: string;
+  title: string;
   description: string;
-  inputShape?: string;
+  inputShape: string;
+  inputSchema: RemoteJsonSchema;
   outputShape?: string;
   returns?: string;
   recommendedNextReads?: string[];
   examples?: unknown[];
-  sideEffectLevel: "none" | "local-write" | "network-write" | "external-side-effect" | "external-trade";
+  sideEffectLevel: RemoteSideEffectLevel;
+  writeTier: RemoteWriteTier;
   requiresConfirmation?: boolean;
   dryRun?: boolean;
 }
 
+/** Stable operation metadata suitable for advertising outside the process. */
+export interface RemoteOperationDescriptor {
+  name: string;
+  title: string;
+  description: string;
+  writeTier: RemoteWriteTier;
+  inputSchema: RemoteJsonSchema;
+}
+
 export interface RemoteControlSchema {
   protocolVersion: number;
   resources: RemoteResourceSchema[];

package/src/renderers/browser/app-services.ts

@@ -1,3 +1,4 @@
+import { recordResearchActivity } from "../../api-client/research-activity";
 import { newsProvider, type NewsCapability } from "../../capabilities";
 import type { AppRuntimeServices, AppServicesFactoryOptions } from "../../core/app-service-ports";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../market-data/coordinator";
@@ -23,6 +24,7 @@ export function createBrowserAppServices({
   );
   const pluginRegistry = new PluginRegistry(dataProvider, tickerRepository, persistence);
   dataProvider.attachRegistry(pluginRegistry);
+  const stopSavedActivity = pluginRegistry.events.on("command-bar:portfolio-membership-persisted", () => recordResearchActivity("ticker_saved"));
   const newsService = new NewsService({
     pollIntervalMs: () => Math.max(1, config.refreshIntervalMinutes) * 60_000,
   });
@@ -51,6 +53,7 @@ export function createBrowserAppServices({
     pluginRegistry,
     ready,
     destroy() {
+      stopSavedActivity();
       setSharedMarketDataCoordinator(null);
       setSharedNewsService(null);
       newsService.stop();

package/src/renderers/browser/config-host.ts

@@ -6,7 +6,8 @@ import {
   normalizeConfigForSave,
   normalizeLoadedConfig,
 } from "../../data/config/store/normalize";
-import { createDefaultConfig, type AppConfig } from "../../types/config";
+import { createDefaultConfig, TICKER_RESEARCH_PANE_ID, type AppConfig } from "../../types/config";
+import { researchEntryFromSearch } from "./research-entry";
 import { BROWSER_STORAGE_KEYS, SafeJsonStorage, type StorageLike } from "./storage";
 
 export const BROWSER_DATA_DIR = "browser://local";
@@ -15,18 +16,33 @@ function browserReady(config: AppConfig): AppConfig {
   return { ...config, onboardingComplete: true, onboardingProgress: undefined };
 }
 
-function createBrowserDefaultConfig(dataDir: string): AppConfig {
-  return browserReady(createDefaultConfig(dataDir));
+function createBrowserDefaultConfig(dataDir: string, search = ""): AppConfig {
+  const config = createDefaultConfig(dataDir);
+  const entry = researchEntryFromSearch(search) ?? { symbol: "NVDA", tab: "overview" };
+  // A first visit starts with one useful research pane. Saved layouts retain
+  // their existing panes and bindings when a visitor returns.
+  config.layouts[0] = {
+    name: "Research",
+    layout: {
+      dockRoot: { kind: "pane", instanceId: "ticker-detail:main" },
+      instances: [{ instanceId: "ticker-detail:main", paneId: TICKER_RESEARCH_PANE_ID,
+        binding: { kind: "fixed", symbol: entry.symbol }, settings: { hideTabs: false } }],
+      floating: [], detached: [],
+    },
+    paneState: { "ticker-detail:main": { activeTabId: entry.tab } },
+  };
+  config.layout = config.layouts[0].layout;
+  return browserReady(config);
 }
 
-export function createBrowserConfigStore(storage: StorageLike): ConfigStoreHost {
+export function createBrowserConfigStore(storage: StorageLike, search = ""): ConfigStoreHost {
   const data = new SafeJsonStorage<unknown>(storage, BROWSER_STORAGE_KEYS.config, null);
   return {
     async getDataDir() { return BROWSER_DATA_DIR; },
     async loadConfig(dataDir) {
       const saved = data.get();
       if (!saved || typeof saved !== "object" || Array.isArray(saved)) {
-        return createBrowserDefaultConfig(dataDir);
+        return createBrowserDefaultConfig(dataDir, search);
       }
       return browserReady(normalizeLoadedConfig(saved as Record<string, unknown>, dataDir).config);
     },
@@ -34,7 +50,7 @@ export function createBrowserConfigStore(storage: StorageLike): ConfigStoreHost
       data.set(normalizeConfigForSave(browserReady({ ...config, dataDir: BROWSER_DATA_DIR })));
     },
     async initDataDir(dataDir) {
-      const config = createBrowserDefaultConfig(dataDir);
+      const config = createBrowserDefaultConfig(dataDir, search);
       data.set(config);
       return config;
     },
@@ -42,7 +58,7 @@ export function createBrowserConfigStore(storage: StorageLike): ConfigStoreHost
       for (const key of Object.values(BROWSER_STORAGE_KEYS)) {
         try { storage.removeItem(key); } catch {}
       }
-      data.set(createBrowserDefaultConfig(dataDir));
+      data.set(createBrowserDefaultConfig(dataDir, search));
     },
     async exportConfig() {
       throw new Error("Config file export is unavailable in the browser.");
@@ -54,5 +70,5 @@ export function createBrowserConfigStore(storage: StorageLike): ConfigStoreHost
 }
 
 export function installBrowserConfigStore(storage: StorageLike = localStorage): void {
-  setConfigStoreHost(createBrowserConfigStore(storage));
+  setConfigStoreHost(createBrowserConfigStore(storage, typeof location !== "undefined" ? location.search : ""));
 }

package/src/renderers/browser/deeplink-bridge.test.ts

@@ -9,6 +9,17 @@ afterEach(() => {
 });
 
 describe("browser social share handoff", () => {
+  test("preserves the incoming ticker while the previous workspace restores", () => {
+    const location = { search: "?ticker=NVDA&tab=earnings-calls" };
+    Object.defineProperty(globalThis, "window", { configurable: true, value: {
+      location, addEventListener() {}, removeEventListener() {},
+    } });
+    const bridge = createBrowserDeepLinkBridge();
+    location.search = "?ticker=AAPL&tab=overview";
+    const seen: string[] = [];
+    bridge.subscribe(({ url }) => seen.push(url));
+    expect(seen).toEqual(["gloomberb://ticker/NVDA?tab=earnings-calls"]);
+  });
   test("maps a valid pane share query to the common deep-link runtime", () => {
     const id = "0123456789abcdef0123456789abcdef";
     Object.defineProperty(globalThis, "window", {

package/src/renderers/browser/deeplink-bridge.ts

@@ -1,18 +1,30 @@
 import { marketplaceLayoutIdFromSearch } from "../../layout-marketplace/api";
 import { paneShareIdFromSearch } from "../../shares/location";
 import type { DesktopDeepLinkBridge } from "../../types/desktop-deeplink";
+import { researchEntryFromSearch } from "./research-entry";
 
 export function createBrowserDeepLinkBridge(): DesktopDeepLinkBridge {
+  // Restoring a saved pane can update the address before App subscribes.
+  // Keep the incoming link intact until it has been delivered once.
+  const initialSearch = window.location.search;
   return {
     subscribe(listener) {
+      let initial = true;
       const emit = () => {
-        const layoutId = marketplaceLayoutIdFromSearch(window.location.search);
+        const search = initial ? initialSearch : window.location.search;
+        initial = false;
+        const layoutId = marketplaceLayoutIdFromSearch(search);
         if (layoutId) {
           listener({ url: `gloomberb://layout/${layoutId}` });
           return;
         }
-        const shareId = paneShareIdFromSearch(window.location.search);
-        if (shareId) listener({ url: `gloomberb://share/${shareId}` });
+        const shareId = paneShareIdFromSearch(search);
+        if (shareId) {
+          listener({ url: `gloomberb://share/${shareId}` });
+          return;
+        }
+        const entry = researchEntryFromSearch(search);
+        if (entry) listener({ url: `gloomberb://ticker/${encodeURIComponent(entry.symbol)}?tab=${entry.tab}` });
       };
       emit();
       window.addEventListener("popstate", emit);

package/src/renderers/browser/main.tsx

@@ -21,6 +21,7 @@ import {
 import { BROWSER_DATA_DIR, installBrowserConfigStore } from "./config-host";
 import { browserRendererHost, browserUiHost } from "./ui-host";
 import { createBrowserDeepLinkBridge } from "./deeplink-bridge";
+import { initializeBrowserResearchActivity, recordResearchActivity } from "../../api-client/research-activity";
 
 // Declared here rather than sniffed: the desktop view and the hosted browser
 // app are both browser contexts but differ in what plugins may do.
@@ -36,8 +37,10 @@ root.render(<div className="gloom-loading">Starting Gloomberb...</div>);
 async function boot(): Promise<void> {
   installBrowserConfigStore();
   installBrowserFetchTransports();
+  initializeBrowserResearchActivity();
   installFocusScopeRelease();
   await restoreBrowserCloudSession();
+  recordResearchActivity("workspace_opened");
   const config = await loadConfig(BROWSER_DATA_DIR);
   applyLanguageFromConfig(config);
   const deepLinkBridge = createBrowserDeepLinkBridge();
@@ -53,7 +56,6 @@ async function boot(): Promise<void> {
                 plugins={getBrowserBuiltinPlugins()}
                 desktopDeepLinkBridge={deepLinkBridge}
                 updatesEnabled={false}
-                requireSignIn
               />
             </WebDialogHostProvider>
           </WebToastHostProvider>

package/src/renderers/browser/research-entry.test.ts

@@ -0,0 +1,8 @@
+import { expect, test } from "bun:test";
+import { researchEntryFromSearch } from "./research-entry";
+
+test("normalizes ticker links while rejecting commands and invalid tab paths", () => {
+  expect(researchEntryFromSearch("?ticker=brk.b&tab=earnings-calls")).toEqual({ symbol: "BRK.B", tab: "earnings-calls" });
+  expect(researchEntryFromSearch("?ticker=NVDA&tab=../../bad")).toEqual({ symbol: "NVDA", tab: "overview" });
+  for (const search of ["", "?ticker=", "?ticker=NVDA%20%3B%20rm", "?ticker=%3Cscript%3E"]) expect(researchEntryFromSearch(search)).toBeNull();
+});

package/src/renderers/browser/research-entry.ts

@@ -0,0 +1,7 @@
+export function researchEntryFromSearch(search: string): { symbol: string; tab: string } | null {
+  const params = new URLSearchParams(search);
+  const symbol = params.get("ticker")?.trim().toUpperCase();
+  if (!symbol || !/^[A-Z0-9.^=:_-]{1,24}$/.test(symbol)) return null;
+  const tab = params.get("tab") ?? "overview";
+  return { symbol, tab: /^[a-z-]{1,40}$/.test(tab) ? tab : "overview" };
+}

package/src/renderers/electrobun/bun/desktop/backend-requests.ts

@@ -1,5 +1,5 @@
 import { createAppServices, type AppServices } from "../../../../core/app-services";
-import { getDesktopBackendPlugins } from "../../../../plugins/catalog-backend";
+import { loadDesktopBackendPlugins } from "../../../../plugins/catalog-backend";
 import type { AppSessionSnapshot } from "../../../../core/state/session-persistence";
 import {
   exportConfig,
@@ -63,7 +63,7 @@ async function importDesktopConfig({
   setCurrentConfig(await importConfig(payload.dataDir, payload.srcPath));
   setServices(createAppServices({
     config: getConfig(),
-    plugins: getDesktopBackendPlugins(),
+    plugins: await loadDesktopBackendPlugins(),
   }));
   syncConfigAccessors();
   registerCoreCapabilities();