gloomberb 0.13.2 → 0.14.0

package/src/cli/entry.test.ts

@@ -0,0 +1,55 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("packaged UI launches restore once before loading the TUI catalog; headless commands do not restore", async () => {
+  const root = join(import.meta.dir, "../..");
+  const directory = await mkdtemp(join(tmpdir(), "gloom-cli-entry-"));
+  const preload = join(directory, "preload.ts");
+  const modulePath = (path: string) => JSON.stringify(join(root, "src", path));
+  try {
+    // Isolate module mocks from the rest of the suite, while exercising the shipped bin entry.
+    await Bun.write(preload, `
+      import { mock } from "bun:test";
+      const calls = [];
+      let restored = false;
+      mock.module(${modulePath("cli/restore-plugins.ts")}, () => ({ restoreExtractedPlugins: async () => {
+        calls.push("restore"); restored = true;
+      }}));
+      mock.module(${modulePath("plugins/loader.ts")}, () => ({ loadExternalPlugins: async (target = "cli") => {
+        calls.push("catalog:" + target);
+        return restored ? [{ plugin: { id: "tv" }, path: "tv" }] : [];
+      }}));
+      mock.module(${modulePath("cli/index.ts")}, () => ({ dispatchCli: async (args) => {
+        calls.push("dispatch:" + args[0]);
+        return args[0] === "handoff" ? { kind: "launch-ui", request: { source: "handoff" } } : { kind: "handled" };
+      }}));
+      mock.module(${modulePath("renderers/opentui/start.tsx")}, () => ({ startOpenTuiApp: async (options) => {
+        calls.push({ launch: options.externalPlugins.map((entry) => entry.plugin.id), args: options.cliArgs, request: options.cliLaunchRequest });
+      }}));
+      process.on("beforeExit", () => console.log(JSON.stringify(calls)));
+    `);
+    for (const args of [[], ["ui"], ["launch-ui", "TV"], ["handoff"], ["help"]]) {
+      const child = Bun.spawn([process.execPath, "--preload", preload, join(root, "bin/gloomberb"), ...args], {
+        cwd: root, stdout: "pipe", stderr: "pipe",
+      });
+      const [stdout, stderr, status] = await Promise.all([
+        new Response(child.stdout).text(), new Response(child.stderr).text(), child.exited,
+      ]);
+      expect({ status, stderr }).toEqual({ status: 0, stderr: "" });
+      const calls = JSON.parse(stdout.trim());
+      if (args[0] === "help") {
+        expect(calls).toEqual(["catalog:cli", "dispatch:help"]);
+      } else {
+        expect(calls).toEqual([
+          ...(args[0] === "handoff" ? ["catalog:cli", "dispatch:handoff"] : []),
+          "restore", "catalog:tui",
+          { launch: ["tv"], args: args[0] === "launch-ui" ? ["TV"] : [], request: args[0] === "handoff" ? { source: "handoff" } : null },
+        ]);
+      }
+    }
+  } finally {
+    await rm(directory, { recursive: true, force: true });
+  }
+});

package/src/cli/entry.ts

@@ -1,22 +1,26 @@
 import { dispatchCli } from "./index";
 import { fail, inferCliErrorOptions, printCliError } from "./errors";
 import { loadExternalPlugins } from "../plugins/loader";
+import { restoreExtractedPlugins } from "./restore-plugins";
 import type { CliLaunchRequest } from "../types/plugin";
 import {
   OPEN_TUI_NATIVE_SMOKE_COMMAND,
   OPEN_TUI_RUNTIME_SMOKE_COMMAND,
+  PLUGIN_HOST_SMOKE_COMMAND,
   smokeOpenTuiNative,
   smokeOpenTuiRuntime,
+  smokePluginHost,
 } from "./native-smoke";
 
 async function launchOpenTuiApp(options: {
-  externalPlugins: Awaited<ReturnType<typeof loadExternalPlugins>>;
   cliLaunchRequest?: CliLaunchRequest | null;
   cliArgs?: string[];
 }): Promise<void> {
   const { startOpenTuiApp } = await import("../renderers/opentui/start");
+  await restoreExtractedPlugins();
+  const externalPlugins = await loadExternalPlugins("tui");
   await startOpenTuiApp({
-    externalPlugins: options.externalPlugins,
+    externalPlugins,
     cliArgs: options.cliArgs ?? [],
     skipCliDispatch: true,
     cliLaunchRequest: options.cliLaunchRequest ?? null,
@@ -36,23 +40,26 @@ export async function runCliEntrypoint(rawArgs = process.argv.slice(2)): Promise
     process.exit(0);
   }
 
-  const externalPlugins = await loadExternalPlugins();
+  if (command === PLUGIN_HOST_SMOKE_COMMAND) {
+    await smokePluginHost();
+    process.exit(0);
+  }
 
   if (!command) {
-    await launchOpenTuiApp({ externalPlugins });
+    await launchOpenTuiApp({});
     return;
   }
 
   if (command === "launch-ui" || command === "ui") {
-    await launchOpenTuiApp({ externalPlugins, cliArgs: rawArgs.slice(1) });
+    await launchOpenTuiApp({ cliArgs: rawArgs.slice(1) });
     return;
   }
 
+  const externalPlugins = await loadExternalPlugins();
   const dispatchResult = await dispatchCli(rawArgs, { externalPlugins });
   if (dispatchResult.kind === "handled") return;
   if (dispatchResult.kind === "launch-ui") {
     await launchOpenTuiApp({
-      externalPlugins,
       cliLaunchRequest: dispatchResult.request,
       cliArgs: [],
     });

package/src/cli/helpers.ts

@@ -1,3 +1,4 @@
+import type { PriceBasis } from "../types/instrument";
 import {
   formatCompact,
   formatCurrency,
@@ -14,7 +15,7 @@ export function formatSignedCurrency(value: number, currency: string): string {
   return value > 0 ? `+${formatCurrency(value, currency)}` : formatCurrency(value, currency);
 }
 
-export function formatSignedPercentRaw(value: number): string {
+export function formatSignedPercentRaw(value: number | undefined): string {
   return formatPercentRaw(value);
 }
 
@@ -45,13 +46,14 @@ export function formatBidAsk(
   askSize: number | undefined,
   currency: string,
   assetCategory?: string,
+  priceBasis?: PriceBasis,
 ): string {
   if (bid == null && ask == null) return "—";
   const bidText = bid != null
-    ? `${formatMarketPriceWithCurrency(bid, currency, { assetCategory })}${bidSize != null ? ` x ${formatNumber(bidSize, 0)}` : ""}`
+    ? `${formatMarketPriceWithCurrency(bid, currency, { assetCategory, priceBasis })}${bidSize != null ? ` x ${formatNumber(bidSize, 0)}` : ""}`
     : "—";
   const askText = ask != null
-    ? `${formatMarketPriceWithCurrency(ask, currency, { assetCategory })}${askSize != null ? ` x ${formatNumber(askSize, 0)}` : ""}`
+    ? `${formatMarketPriceWithCurrency(ask, currency, { assetCategory, priceBasis })}${askSize != null ? ` x ${formatNumber(askSize, 0)}` : ""}`
     : "—";
   return `${bidText} / ${askText}`;
 }

package/src/cli/index.ts

@@ -21,7 +21,6 @@ import { overviewCliCommands } from "./commands/overview";
 import { remoteCliCommand } from "./commands/remote";
 import { createSystemCliCommands } from "./commands/system";
 import {
-  aiCliCommand,
   brokerCliCommand,
   ibkrCliCommand,
   rssCliCommand,
@@ -29,7 +28,9 @@ import {
 import {
   installPlugin,
   listPlugins,
+  parseGitHubRef,
   removePlugin,
+  resolveRegistryPin,
   updatePlugins,
 } from "./commands/plugins";
 import { runPaneCatalog, runPaneFunction, runPaneScreenshot } from "./pane-functions";
@@ -149,7 +150,10 @@ function createCoreCliCommands(
         if (!ref) {
           fail("Usage: gloomberb install <github-user/repo>");
         }
-        await installPlugin(ref);
+        // A listed plugin lands on the commit the registry reviewed, the same
+        // as an install from the marketplace pane. Unlisted ones follow HEAD.
+        const pin = await resolveRegistryPin(parseGitHubRef(ref).repo);
+        await installPlugin(ref, pin ? { pin } : {});
       },
     },
     {
@@ -195,7 +199,6 @@ function createCoreCliCommands(
     ...createSystemCliCommands(allCommands),
     brokerCliCommand,
     ibkrCliCommand,
-    aiCliCommand,
     rssCliCommand,
   ];
   return commands;

package/src/cli/native-smoke.ts

@@ -1,5 +1,6 @@
 export const OPEN_TUI_NATIVE_SMOKE_COMMAND = "__gloomberb-smoke-opentui-native";
 export const OPEN_TUI_RUNTIME_SMOKE_COMMAND = "__gloomberb-smoke-opentui-runtime";
+export const PLUGIN_HOST_SMOKE_COMMAND = "__gloomberb-smoke-plugin-host";
 
 export async function smokeOpenTuiNative(): Promise<void> {
   await import("../renderers/opentui/native-smoke");
@@ -8,3 +9,18 @@ export async function smokeOpenTuiNative(): Promise<void> {
 export async function smokeOpenTuiRuntime(): Promise<void> {
   await import("../renderers/opentui/start");
 }
+
+/**
+ * Loads a throwaway external plugin the way the terminal loads a real one.
+ *
+ * A packaged host has no Gloomberb package on disk, so a plugin's
+ * `gloomberb/*` and `react` imports only resolve if the host answers them
+ * itself. This is what an upgrade relies on: the panes that moved out of the
+ * repository come back as plugins, and a binary that cannot load one has
+ * lost them. Run against the built binary so a regression fails the build,
+ * not the user's first launch.
+ */
+export async function smokePluginHost(): Promise<void> {
+  const { smokePluginHostLoad } = await import("../plugins/host-smoke");
+  await smokePluginHostLoad();
+}

package/src/cli/pane-functions/capabilities.ts

@@ -1,4 +1,3 @@
-import { CHART_RESOLUTIONS } from "../../time-series/range";
 import type {
   HeadlessPaneArgumentDef,
   HeadlessPaneDefinition,
@@ -31,380 +30,6 @@ export interface PaneFunctionCapability {
   options: PaneFunctionOptionDef[];
 }
 
-const PERIOD_OPTION: PaneFunctionOptionDef = {
-  key: "period",
-  description: "Financial reporting period.",
-  type: "enum",
-  aliases: ["financialPeriod"],
-  values: [
-    { value: "annual", aliases: ["a", "ann", "year", "yearly", "fy"] },
-    { value: "quarterly", aliases: ["q", "qtr", "quarter"] },
-  ],
-  defaultValue: "annual",
-};
-
-const GRAPH_PERIOD_OPTION: PaneFunctionOptionDef = {
-  ...PERIOD_OPTION,
-};
-
-const GRAPH_PERIOD_COUNT_OPTION: PaneFunctionOptionDef = {
-  key: "periods",
-  description: "Keep only the latest N annual or quarterly observations per ticker.",
-  type: "integer",
-  aliases: ["years", "limit"],
-  minimum: 1,
-  maximum: 40,
-};
-
-const RANGE_VALUES: PaneFunctionOptionValue[] = [
-  { value: "1D", aliases: ["day", "daily"] },
-  { value: "1W", aliases: ["week", "weekly"] },
-  { value: "1M", aliases: ["month", "monthly"] },
-  { value: "3M" },
-  { value: "6M" },
-  { value: "1Y", aliases: ["year"] },
-  { value: "5Y", aliases: ["five-years", "five years"] },
-  { value: "ALL", aliases: ["max", "maximum"] },
-];
-
-const FUNDAMENTAL_METRIC_VALUES: PaneFunctionOptionValue[] = [
-  { value: "totalRevenue", aliases: ["revenue", "sales"] },
-  { value: "grossProfit", aliases: ["gross profit"] },
-  { value: "grossMargin", aliases: ["gross margin"] },
-  { value: "operatingIncome", aliases: ["operating income", "ebit"] },
-  { value: "operatingMargin", aliases: ["operating margin"] },
-  { value: "netIncome", aliases: ["net income", "profit", "earnings"] },
-  { value: "netMargin", aliases: ["net margin", "profit margin"] },
-  { value: "operatingCashFlow", aliases: ["operating cash flow", "cash flow", "ocf"] },
-  { value: "freeCashFlow", aliases: ["free cash flow", "fcf"] },
-  { value: "freeCashFlowMargin", aliases: ["free cash flow margin", "fcf margin"] },
-  { value: "totalAssets", aliases: ["assets", "total assets"] },
-  { value: "totalDebt", aliases: ["debt", "total debt"] },
-  { value: "totalEquity", aliases: ["equity", "book value"] },
-  { value: "eps", aliases: ["earnings per share"] },
-];
-
-const VALUATION_METRIC_VALUES: PaneFunctionOptionValue[] = [
-  { value: "trailingPE", aliases: ["pe", "p/e", "trailing pe"] },
-  { value: "forwardPE", aliases: ["forward pe", "forward p/e"] },
-  { value: "pegRatio", aliases: ["peg", "peg ratio"] },
-  { value: "priceSales", aliases: ["price sales", "price to sales", "p/s"] },
-  { value: "evSales", aliases: ["ev sales", "ev/sales"] },
-  { value: "evEbitda", aliases: ["ev ebitda", "ev/ebitda"] },
-  { value: "priceFcf", aliases: ["price fcf", "price to free cash flow", "p/fcf"] },
-];
-
-const CAPABILITIES: Record<string, PaneFunctionCapability> = {
-  "chart-composer-pane": {
-    id: "chart-composer",
-    botSafe: true,
-    tickerCardinality: "none",
-    aliases: ["custom chart", "mixed series chart", "chart composer", "economic chart"],
-    intents: ["chart arbitrary market fundamental valuation and economic series together"],
-    outputKind: "chart-series",
-    reportReadiness: "ready",
-    screenshotReadiness: "ready",
-    dataRequirements: ["data required by each authored chart series"],
-    limitations: ["FRED observations do not include historical vintage availability dates."],
-    options: [
-      {
-        key: "rangePreset",
-        description: "Chart history window.",
-        type: "enum",
-        aliases: ["range"],
-        values: RANGE_VALUES,
-      },
-      {
-        key: "chartResolution",
-        description: "Market-price sampling resolution.",
-        type: "enum",
-        aliases: ["resolution"],
-        values: CHART_RESOLUTIONS.map((value) => ({ value })),
-      },
-    ],
-  },
-  "financial-analysis-pane": {
-    id: "financial-statements",
-    botSafe: true,
-    tickerCardinality: "one",
-    aliases: ["financials", "financial statement", "income statement", "balance sheet", "cash flow statement"],
-    intents: ["inspect company financial statements", "review income balance sheet or cash flow"],
-    outputKind: "financial-statement",
-    reportReadiness: "ready",
-    screenshotReadiness: "ready",
-    dataRequirements: ["ticker financial statements"],
-    limitations: ["One company per invocation; use GF for cross-company metric comparisons."],
-    options: [
-      PERIOD_OPTION,
-      {
-        key: "statement",
-        description: "Statement to display.",
-        type: "enum",
-        aliases: ["tab", "financialStatement"],
-        values: [
-          { value: "income", aliases: ["income statement", "is"] },
-          { value: "balance", aliases: ["balance sheet", "bs"] },
-          { value: "cashflow", aliases: ["cash flow", "cash flow statement", "cf", "cashflows"] },
-        ],
-        defaultValue: "income",
-      },
-    ],
-  },
-  "fundamental-graph-pane": {
-    id: "fundamental-series",
-    botSafe: true,
-    tickerCardinality: "one-or-more",
-    aliases: [
-      "fundamental comparison",
-      "financial metric comparison",
-      "cash flow comparison",
-      "revenue comparison",
-      "earnings comparison",
-      "operating cash flow",
-      "free cash flow",
-      "fcf",
-      "ocf",
-    ],
-    intents: ["compare company fundamentals over time", "compare cash flow revenue earnings margins assets debt or equity"],
-    outputKind: "fundamental-series",
-    reportReadiness: "ready",
-    screenshotReadiness: "ready",
-    dataRequirements: ["ticker annual or quarterly financial statements"],
-    limitations: ["One metric per invocation; run twice when both operating and free cash flow are requested."],
-    options: [
-      {
-        key: "metric",
-        description: "Fundamental metric to compare.",
-        type: "enum",
-        values: FUNDAMENTAL_METRIC_VALUES,
-        defaultValue: "totalRevenue",
-      },
-      GRAPH_PERIOD_OPTION,
-      GRAPH_PERIOD_COUNT_OPTION,
-    ],
-  },
-  "valuation-graph-pane": {
-    id: "valuation-series",
-    botSafe: true,
-    tickerCardinality: "one-or-more",
-    aliases: ["valuation comparison", "multiple comparison", "pe comparison", "price to sales comparison", "ev ebitda"],
-    intents: ["compare company valuation multiples over time"],
-    outputKind: "valuation-series",
-    reportReadiness: "ready",
-    screenshotReadiness: "ready",
-    dataRequirements: ["ticker financial statements", "price history"],
-    limitations: ["Historical multiples require usable prices and statement share counts."],
-    options: [
-      {
-        key: "metric",
-        description: "Valuation metric to compare.",
-        type: "enum",
-        values: VALUATION_METRIC_VALUES,
-        defaultValue: "priceSales",
-      },
-      GRAPH_PERIOD_OPTION,
-      GRAPH_PERIOD_COUNT_OPTION,
-    ],
-  },
-  "comparison-chart-pane": {
-    id: "price-comparison",
-    botSafe: true,
-    tickerCardinality: "two-or-more",
-    aliases: ["stock comparison", "price performance comparison", "returns comparison", "compare stock prices"],
-    intents: ["compare market price performance for multiple securities"],
-    outputKind: "price-performance",
-    reportReadiness: "ready",
-    screenshotReadiness: "ready",
-    dataRequirements: ["price history"],
-    limitations: ["Compares market prices or percentage returns, never company financial statements."],
-    options: [
-      {
-        key: "rangePreset",
-        description: "Price-history window.",
-        type: "enum",
-        aliases: ["range"],
-        values: RANGE_VALUES,
-        defaultValue: "1Y",
-      },
-      {
-        key: "axisMode",
-        description: "Display raw price or normalized percentage performance.",
-        type: "enum",
-        values: [
-          { value: "percent", aliases: ["return", "returns", "performance"] },
-          { value: "price", aliases: ["prices"] },
-        ],
-        defaultValue: "percent",
-      },
-      {
-        key: "chartResolution",
-        description: "Price sampling resolution.",
-        type: "enum",
-        aliases: ["resolution"],
-        values: CHART_RESOLUTIONS.filter((value) => value !== "auto").map((value) => ({ value })),
-        defaultValue: "1d",
-      },
-    ],
-  },
-  "correlation-pane": {
-    id: "return-correlation",
-    botSafe: true,
-    tickerCardinality: "two-or-more",
-    aliases: ["correlation", "return correlation", "correlation matrix", "pearson correlation"],
-    intents: ["compare correlations between security returns"],
-    outputKind: "correlation-matrix",
-    reportReadiness: "ready",
-    screenshotReadiness: "partial",
-    dataRequirements: ["date-aligned price history"],
-    limitations: ["Correlation is computed from daily returns with at least five shared observations."],
-    options: [{
-      key: "rangePreset",
-      description: "Correlation history window.",
-      type: "enum",
-      aliases: ["range"],
-      values: RANGE_VALUES.filter(({ value }) => !["1D", "1W", "ALL"].includes(value)),
-      defaultValue: "1Y",
-      settingKey: "rangePreset",
-    }],
-  },
-  "relationship-graph-pane": {
-    id: "security-relationship",
-    botSafe: true,
-    tickerCardinality: "one-or-two",
-    aliases: ["relationship", "ratio", "beta", "regression", "rolling correlation"],
-    intents: ["analyze ratio correlation and regression between two securities"],
-    outputKind: "relationship-analysis",
-    reportReadiness: "ready",
-    screenshotReadiness: "partial",
-    dataRequirements: ["date-aligned price history"],
-    limitations: ["A single ticker is compared with SPY."],
-    options: [
-      {
-        key: "range",
-        description: "Relationship history window.",
-        type: "enum",
-        aliases: ["rangePreset"],
-        values: RANGE_VALUES.filter(({ value }) => !["1D", "1W"].includes(value)),
-        defaultValue: "1Y",
-        pluginState: { pluginId: "market-overview" },
-      },
-      {
-        key: "correlationWindow",
-        description: "Rolling-correlation window in observations.",
-        type: "integer",
-        aliases: ["window"],
-        defaultValue: 120,
-        minimum: 5,
-        maximum: 1000,
-        pluginState: { pluginId: "market-overview" },
-      },
-    ],
-  },
-  "relative-valuation-pane": {
-    id: "relative-valuation",
-    botSafe: true,
-    tickerCardinality: "one-or-more",
-    aliases: ["relative valuation", "peer valuation", "valuation comps", "compare multiples"],
-    intents: ["compare current valuation and operating metrics across peers"],
-    outputKind: "relative-valuation",
-    reportReadiness: "ready",
-    screenshotReadiness: "partial",
-    dataRequirements: ["ticker quote and fundamentals"],
-    limitations: ["Uses current provider fundamentals rather than a historical series."],
-    options: [],
-  },
-  "quote-monitor-pane": {
-    id: "quote-comparison",
-    botSafe: true,
-    tickerCardinality: "one-or-more",
-    aliases: ["quotes", "stock prices", "market snapshot", "price comparison"],
-    intents: ["compare current quotes for one or more securities"],
-    outputKind: "quote-comparison",
-    reportReadiness: "ready",
-    screenshotReadiness: "ready",
-    dataRequirements: ["current quotes"],
-    limitations: [],
-    options: [],
-  },
-  "historical-prices-pane": {
-    id: "historical-prices",
-    botSafe: true,
-    tickerCardinality: "one",
-    aliases: ["historical prices", "price history", "ohlcv", "daily prices"],
-    intents: ["inspect historical open high low close and volume"],
-    outputKind: "price-history",
-    reportReadiness: "ready",
-    screenshotReadiness: "partial",
-    dataRequirements: ["price history"],
-    limitations: [],
-    options: [{
-      key: "range",
-      description: "Price-history window.",
-      type: "enum",
-      aliases: ["rangePreset"],
-      values: RANGE_VALUES,
-      defaultValue: "ALL",
-      pluginState: { pluginId: "ticker-research" },
-    }],
-  },
-  "graph-price-pane": {
-    id: "price-chart",
-    botSafe: true,
-    tickerCardinality: "one",
-    aliases: ["price chart", "stock chart", "historical chart"],
-    intents: ["chart a security price over time"],
-    outputKind: "price-history",
-    reportReadiness: "ready",
-    screenshotReadiness: "ready",
-    dataRequirements: ["price history"],
-    limitations: [],
-    options: [{
-      key: "rangePreset",
-      settingKey: "chartRangePreset",
-      description: "Chart history window.",
-      type: "enum",
-      aliases: ["range"],
-      values: RANGE_VALUES,
-      defaultValue: "5Y",
-    }],
-  },
-  "graph-intraday-price-pane": {
-    id: "intraday-price-chart",
-    botSafe: true,
-    tickerCardinality: "one",
-    aliases: ["intraday chart", "intraday price", "one day chart"],
-    intents: ["chart intraday security prices"],
-    outputKind: "price-history",
-    reportReadiness: "ready",
-    screenshotReadiness: "ready",
-    dataRequirements: ["intraday price history"],
-    limitations: ["Intraday availability and historical retention depend on the selected market-data provider."],
-    options: [
-      {
-        key: "rangePreset",
-        description: "Session window. 1D selects the latest session and 1W selects the latest five sessions.",
-        type: "enum",
-        aliases: ["range"],
-        values: RANGE_VALUES.filter(({ value }) => value === "1D" || value === "1W"),
-        defaultValue: "1D",
-      },
-      {
-        key: "chartResolution",
-        description: "Intraday sampling interval. Auto uses 1m for 1D and 5m for 1W.",
-        type: "enum",
-        aliases: ["resolution"],
-        values: ["auto", "5m", "15m", "1h"].map((value) => ({ value })),
-        defaultValue: "auto",
-      },
-      {
-        key: "session",
-        description: "Specific exchange-local session in YYYY-MM-DD form. Overrides the session window.",
-        type: "string",
-      },
-    ],
-  },
-};
-
 const NON_DATA_PANE_IDS = new Set([
   "account-management",
   "brokers",
@@ -461,7 +86,9 @@ function headlessTickerCardinality(argument: HeadlessPaneArgumentDef): PaneFunct
       return "one";
     case "tickers":
     case "symbol-list":
-      return (argument.minimum ?? 1) >= 2 ? "two-or-more" : "one-or-more";
+      return argument.maximum === 2 && (argument.minimum ?? 1) === 1
+        ? "one-or-two"
+        : (argument.minimum ?? 1) >= 2 ? "two-or-more" : "one-or-more";
     case "none":
     case "free-text":
       return "none";
@@ -484,20 +111,19 @@ export function getPaneFunctionCapability(
   pane: PaneDef,
 ): PaneFunctionCapability {
   const fallback = fallbackCapability(template, pane);
-  const existing = template ? CAPABILITIES[template.id] ?? fallback : fallback;
   const headless = getHeadlessPaneDefinition(template, pane);
-  if (!headless) return existing;
-
-  const hasExistingCapability = existing !== fallback;
+  if (!headless) return fallback;
   return {
-    ...(hasExistingCapability ? existing : fallback),
-    id: hasExistingCapability ? existing.id : template?.id ?? pane.id,
+    ...fallback,
+    aliases: template?.keywords ?? [],
+    intents: template ? [template.description] : [],
+    limitations: [],
+    ...headless.discovery,
     botSafe: true,
     tickerCardinality: headlessTickerCardinality(headless.argument),
     outputKind: headless.shape,
     reportReadiness: "ready",
     options: [...headless.options],
-    ...(hasExistingCapability ? {} : { limitations: [] }),
   };
 }
 

package/src/cli/pane-functions/catalog.ts

@@ -72,11 +72,12 @@ export function buildPaneFunctionLookup(registry: PaneFunctionCatalog): Map<stri
     registerResolverToken(lookup, pane.name, pane);
   }
 
-  const financialTemplate = registry.paneTemplates.get("financial-analysis-pane");
-  if (financialTemplate) {
-    lookup.set(normalizeLookupToken("financials"), financialTemplate);
-    lookup.set(normalizeLookupToken("financial-statements"), financialTemplate);
-    lookup.set(normalizeLookupToken("financial-statement"), financialTemplate);
+  for (const template of registry.paneTemplates.values()) {
+    const pane = registry.panes.get(template.paneId);
+    if (!pane) continue;
+    const discovery = getHeadlessPaneDefinition(template, pane)?.discovery;
+    registerResolverToken(lookup, discovery?.id, template);
+    for (const alias of discovery?.aliases ?? []) registerResolverToken(lookup, alias, template);
   }
 
   return lookup;

package/src/cli/pane-functions/cloud-session.test.ts

@@ -52,3 +52,26 @@ describe("pane function Cloud session", () => {
     }
   });
 });
+
+describe("cloud session token from the environment", () => {
+  test("prefers GLOOMBERB_SESSION_TOKEN over persisted state so containers can authenticate", () => {
+    const context = {
+      persistence: {
+        pluginState: {
+          get: () => ({ value: { sessionToken: "persisted-token" } }),
+        },
+      },
+    } as unknown as Parameters<typeof resolvePersistedCloudSessionToken>[0];
+
+    const previous = process.env.GLOOMBERB_SESSION_TOKEN;
+    try {
+      process.env.GLOOMBERB_SESSION_TOKEN = "env-token";
+      expect(resolvePersistedCloudSessionToken(context)).toBe("env-token");
+      delete process.env.GLOOMBERB_SESSION_TOKEN;
+      expect(resolvePersistedCloudSessionToken(context)).toBe("persisted-token");
+    } finally {
+      if (previous === undefined) delete process.env.GLOOMBERB_SESSION_TOKEN;
+      else process.env.GLOOMBERB_SESSION_TOKEN = previous;
+    }
+  });
+});