gloomberb 0.9.2 → 0.9.4

package/src/plugins/builtin/comparison-chart/index.test.tsx

@@ -6,6 +6,7 @@ import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../
 import { PaneFooterBar, PaneFooterProvider } from "../../../components/layout/pane/footer";
 import {
   AppContext,
+  type AppAction,
   createInitialState,
   PaneInstanceProvider,
 } from "../../../state/app/context";
@@ -13,7 +14,7 @@ import { Box } from "../../../ui";
 import { cloneLayout, createDefaultConfig } from "../../../types/config";
 import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
 import type { DataProvider } from "../../../types/data-provider";
-import type { TickerFinancials } from "../../../types/financials";
+import type { PricePoint, TickerFinancials } from "../../../types/financials";
 import type { PluginRegistry } from "../../registry";
 import { PluginRenderProvider, type PluginRuntimeAccess } from "../../runtime";
 import { setSharedMarketDataForTests, setSharedRegistryForTests } from "../../registry";
@@ -30,6 +31,12 @@ let root: ReturnType<typeof createRoot> | undefined;
 let sharedCoordinator: MarketDataCoordinator | null = null;
 const actEnvironment = globalThis as typeof globalThis & { IS_REACT_ACT_ENVIRONMENT?: boolean };
 
+interface ComparisonHarnessOptions {
+  dispatch?: (action: AppAction) => void;
+  focused?: boolean;
+  focusedPaneId?: string | null;
+}
+
 function makeTicker(symbol: string, currency: string): TickerRecord {
   return {
     metadata: {
@@ -90,6 +97,13 @@ function makeDatedFinancials(symbol: string, currency: string, closes: Array<[st
   };
 }
 
+function makeDatedPriceHistory(closes: Array<[string, number]>): PricePoint[] {
+  return closes.map(([date, close]) => ({
+    date: new Date(`${date}T00:00:00Z`),
+    close,
+  }));
+}
+
 function createProvider(historyBySymbol: Record<string, number[]>, currencyBySymbol: Record<string, string>): DataProvider {
   return {
     id: "test-provider",
@@ -139,6 +153,30 @@ function createDatedProvider(financialsBySymbol: Record<string, TickerFinancials
   return provider;
 }
 
+function createRangeAwareDatedProvider({
+  fullHistoryBySymbol,
+  shortHistoryBySymbol,
+}: {
+  fullHistoryBySymbol: Record<string, Array<[string, number]>>;
+  shortHistoryBySymbol: Record<string, Array<[string, number]>>;
+}): DataProvider {
+  const financialsBySymbol = Object.fromEntries(
+    Object.entries(shortHistoryBySymbol).map(([symbol, history]) => [
+      symbol,
+      makeDatedFinancials(symbol, "USD", history),
+    ]),
+  );
+  const provider = createDatedProvider(financialsBySymbol);
+  const resolveHistory = (symbol: string, range: string) => makeDatedPriceHistory(
+    range === "5Y"
+      ? fullHistoryBySymbol[symbol] ?? shortHistoryBySymbol[symbol] ?? []
+      : shortHistoryBySymbol[symbol] ?? [],
+  );
+  provider.getPriceHistory = async (symbol, _exchange, range) => resolveHistory(symbol, range);
+  provider.getPriceHistoryForResolution = async (symbol, _exchange, range) => resolveHistory(symbol, range);
+  return provider;
+}
+
 function createRegistrySpy(spy: { selected: string[]; focused: string[] }): PluginRegistry {
   return {
     selectTicker: (symbol: string) => { spy.selected.push(symbol); },
@@ -171,7 +209,13 @@ function createComparisonHarness(
   tickers: TickerRecord[],
   financials: Array<[string, TickerFinancials]>,
   runtime: PluginRuntimeAccess,
+  options: ComparisonHarnessOptions = {},
 ) {
+  const {
+    dispatch = () => {},
+    focused = true,
+    focusedPaneId = focused ? TEST_PANE_ID : null,
+  } = options;
   const config = createDefaultConfig("/tmp/gloomberb-compare");
   const layout = {
     dockRoot: { kind: "pane" as const, instanceId: TEST_PANE_ID },
@@ -189,7 +233,7 @@ function createComparisonHarness(
     layouts: [{ name: "Default", layout: cloneLayout(layout) }],
   };
   const state = createInitialState(nextConfig);
-  state.focusedPaneId = TEST_PANE_ID;
+  state.focusedPaneId = focusedPaneId;
   state.tickers = new Map(tickers.map((ticker) => [ticker.metadata.ticker, ticker]));
   state.financials = new Map(financials);
 
@@ -202,7 +246,7 @@ function createComparisonHarness(
   }) => ReactElement;
 
   return (
-    <AppContext value={{ state, dispatch: () => {} }}>
+    <AppContext value={{ state, dispatch }}>
       <PaneInstanceProvider paneId={TEST_PANE_ID}>
         <PluginRenderProvider pluginId="comparison-chart" runtime={runtime}>
           <PaneFooterProvider>
@@ -211,11 +255,11 @@ function createComparisonHarness(
                 <ComparisonPane
                   paneId={TEST_PANE_ID}
                   paneType="comparison-chart"
-                  focused
+                  focused={focused}
                   width={120}
                   height={19}
                 />
-                <PaneFooterBar footer={footer} focused width={120} />
+                <PaneFooterBar footer={footer} focused={focused} width={120} />
               </Box>
             )}
           </PaneFooterProvider>
@@ -241,13 +285,14 @@ async function mountComparisonHarness(
   tickers: TickerRecord[],
   financials: Array<[string, TickerFinancials]>,
   spy: { selected: string[]; focused: string[]; settings?: string[] } = { selected: [], focused: [] },
+  options: ComparisonHarnessOptions = {},
 ) {
   actEnvironment.IS_REACT_ACT_ENVIRONMENT = true;
   testSetup = await createTestRenderer({ width: 120, height: 20 });
   root = createRoot(testSetup.renderer);
   await act(async () => {
     root!.render(
-      createComparisonHarness(settings, tickers, financials, createRuntimeSpy(spy)),
+      createComparisonHarness(settings, tickers, financials, createRuntimeSpy(spy), options),
     );
     await Promise.resolve();
     await new Promise((resolve) => setTimeout(resolve, 0));
@@ -399,6 +444,85 @@ describe("comparisonChartPlugin", () => {
     expect(frame).toMatch(/MSFT\s+0\.00%/);
   });
 
+  test("focuses the pane when an unfocused comparison plot is clicked", async () => {
+    const dispatched: AppAction[] = [];
+    const provider = createProvider({
+      AAPL: [100, 102, 104],
+      MSFT: [200, 202, 204],
+    }, {
+      AAPL: "USD",
+      MSFT: "USD",
+    });
+    setSharedMarketDataForTests(provider);
+    sharedCoordinator = new MarketDataCoordinator(provider);
+    setSharedMarketDataCoordinator(sharedCoordinator);
+    setSharedRegistryForTests(createRegistrySpy({ selected: [], focused: [] }));
+
+    await mountComparisonHarness({
+      axisMode: "percent",
+      symbols: ["AAPL", "MSFT"],
+      symbolsText: "AAPL, MSFT",
+    }, [
+      makeTicker("AAPL", "USD"),
+      makeTicker("MSFT", "USD"),
+    ], [
+      ["AAPL", makeFinancials("AAPL", "USD", [100, 102, 104])],
+      ["MSFT", makeFinancials("MSFT", "USD", [200, 202, 204])],
+    ], { selected: [], focused: [] }, {
+      dispatch: (action) => { dispatched.push(action); },
+      focused: false,
+      focusedPaneId: "ticker-detail:main",
+    });
+
+    await flushFrames();
+    await act(async () => {
+      await testSetup!.mockMouse.click(20, 8);
+      await testSetup!.renderOnce();
+    });
+
+    expect(dispatched).toContainEqual({ type: "FOCUS_PANE", paneId: TEST_PANE_ID });
+  });
+
+  test("keeps fixed return horizons independent from the selected chart range", async () => {
+    const shortHistory = {
+      AAPL: [["2025-01-02", 180], ["2026-01-02", 200]],
+      MSFT: [["2025-01-02", 300], ["2026-01-02", 330]],
+    } satisfies Record<string, Array<[string, number]>>;
+    const fullHistory = {
+      AAPL: [["2021-01-02", 100], ["2023-01-02", 150], ["2025-01-02", 180], ["2026-01-02", 200]],
+      MSFT: [["2021-01-02", 220], ["2023-01-02", 270], ["2025-01-02", 300], ["2026-01-02", 330]],
+    } satisfies Record<string, Array<[string, number]>>;
+    const provider = createRangeAwareDatedProvider({
+      fullHistoryBySymbol: fullHistory,
+      shortHistoryBySymbol: shortHistory,
+    });
+    setSharedMarketDataForTests(provider);
+    sharedCoordinator = new MarketDataCoordinator(provider);
+    setSharedMarketDataCoordinator(sharedCoordinator);
+    setSharedRegistryForTests(createRegistrySpy({ selected: [], focused: [] }));
+
+    await mountComparisonHarness({
+      axisMode: "percent",
+      rangePreset: "1Y",
+      chartResolution: "1d",
+      symbols: ["AAPL", "MSFT"],
+      symbolsText: "AAPL, MSFT",
+    }, [
+      makeTicker("AAPL", "USD"),
+      makeTicker("MSFT", "USD"),
+    ], [
+      ["AAPL", makeDatedFinancials("AAPL", "USD", shortHistory.AAPL)],
+      ["MSFT", makeDatedFinancials("MSFT", "USD", shortHistory.MSFT)],
+    ]);
+
+    await flushFrames(8);
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("5Y");
+    expect(frame).toMatch(/> AAPL\s+\+11\.11%[^\n]*\+100\.00%/);
+    expect(frame).toMatch(/MSFT\s+\+10\.00%[^\n]*\+50\.00%/);
+  });
+
   test("sorts comparison summary rows by one-year return", async () => {
     const rows = {
       SLOW: makeDatedFinancials("SLOW", "USD", [["2025-01-02", 100], ["2026-01-02", 105]]),

package/src/plugins/builtin/kelly-sizer/constants.ts

@@ -0,0 +1,3 @@
+export const KELLY_PANE_ID = "kelly-sizer";
+export const COMMON_ASSUMPTIONS_STATE_KEY = "commonAssumptions:v1";
+export const DEFAULT_FLOATING_SIZE = { width: 88, height: 30 };

package/src/plugins/builtin/kelly-sizer/fields.ts

@@ -0,0 +1,214 @@
+import {
+  type KellyCommonAssumptions,
+  type KellySizerDraft,
+  type KellySizerModeDrafts,
+  type KellySizingMode,
+  type ScenarioKellyAssumptions,
+} from "./model";
+
+export interface InlineField {
+  id: string;
+  label: string;
+  value?: number;
+  valueText?: string;
+  percent?: boolean;
+  suffix?: string;
+  allowNegative?: boolean;
+  onValue?: (value: number) => void;
+  onClear?: () => void;
+  onPress?: () => void;
+  tone?: "neutral" | "positive" | "negative";
+}
+
+export function buildModeFields({
+  mode,
+  draft,
+  updateDraft,
+}: {
+  mode: KellySizingMode;
+  draft: KellySizerDraft;
+  updateDraft: (patch: Partial<KellySizerDraft>) => void;
+}): InlineField[] {
+  if (mode === "scenario") {
+    const scenario = draft as ScenarioKellyAssumptions;
+    const updateOutcome = (index: number, patch: Partial<ScenarioKellyAssumptions["outcomes"][number]>) => {
+      updateDraft({
+        outcomes: scenario.outcomes.map((outcome, outcomeIndex) => (
+          outcomeIndex === index ? { ...outcome, ...patch } : outcome
+        )),
+      } as Partial<KellySizerDraft>);
+    };
+    return scenario.outcomes.flatMap((outcome, index): InlineField[] => [
+      {
+        id: `${outcome.id}:p`,
+        label: `${outcome.label} p`,
+        value: outcome.probability,
+        percent: true,
+        onValue: (value) => updateOutcome(index, { probability: value }),
+      },
+      {
+        id: `${outcome.id}:ret`,
+        label: `${outcome.label} ret`,
+        value: outcome.returnPct,
+        percent: true,
+        allowNegative: true,
+        tone: outcome.returnPct >= 0 ? "positive" : "negative",
+        onValue: (value) => updateOutcome(index, { returnPct: value }),
+      },
+    ]);
+  }
+
+  if (mode === "risk-budget") {
+    const risk = draft as KellySizerModeDrafts["risk-budget"];
+    return [
+      {
+        id: "riskBudget",
+        label: "Risk budget",
+        value: risk.riskBudgetFraction,
+        percent: true,
+        onValue: (value) => updateDraft({ riskBudgetFraction: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "downside",
+        label: "Downside",
+        value: risk.downsideReturn,
+        percent: true,
+        allowNegative: true,
+        tone: "negative",
+        onValue: (value) => updateDraft({ downsideReturn: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "winProbability",
+        label: "Win p",
+        value: risk.winProbability,
+        percent: true,
+        onValue: (value) => updateDraft({ winProbability: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "upside",
+        label: "Upside",
+        value: risk.upsideReturn,
+        percent: true,
+        tone: "positive",
+        onValue: (value) => updateDraft({ upsideReturn: value } as Partial<KellySizerDraft>),
+      },
+    ];
+  }
+
+  if (mode === "prediction-market") {
+    const market = draft as KellySizerModeDrafts["prediction-market"];
+    return [
+      {
+        id: "side",
+        label: "Side",
+        valueText: market.side.toUpperCase(),
+        tone: "positive",
+        onPress: () => updateDraft({ side: market.side === "yes" ? "no" : "yes" } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "estimatedProbability",
+        label: "Est p",
+        value: market.estimatedProbability,
+        percent: true,
+        onValue: (value) => updateDraft({ estimatedProbability: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "marketPrice",
+        label: "Price",
+        value: market.marketPrice,
+        percent: true,
+        onValue: (value) => updateDraft({ marketPrice: value } as Partial<KellySizerDraft>),
+      },
+    ];
+  }
+
+  if (mode === "asymmetric") {
+    const asymmetric = draft as KellySizerModeDrafts["asymmetric"];
+    return [
+      {
+        id: "winProbability",
+        label: "Win p",
+        value: asymmetric.winProbability,
+        percent: true,
+        onValue: (value) => updateDraft({ winProbability: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "targetReturn",
+        label: "Target",
+        value: asymmetric.targetReturn,
+        percent: true,
+        tone: "positive",
+        onValue: (value) => updateDraft({ targetReturn: value } as Partial<KellySizerDraft>),
+      },
+      {
+        id: "maxLossReturn",
+        label: "Max loss",
+        value: asymmetric.maxLossReturn,
+        percent: true,
+        allowNegative: true,
+        tone: "negative",
+        onValue: (value) => updateDraft({ maxLossReturn: value } as Partial<KellySizerDraft>),
+      },
+    ];
+  }
+
+  const binary = draft as KellySizerModeDrafts["binary"];
+  return [
+    {
+      id: "winProbability",
+      label: "Win p",
+      value: binary.winProbability,
+      percent: true,
+      onValue: (value) => updateDraft({ winProbability: value } as Partial<KellySizerDraft>),
+    },
+    {
+      id: "upside",
+      label: "Upside",
+      value: binary.upsideReturn,
+      percent: true,
+      tone: "positive",
+      onValue: (value) => updateDraft({ upsideReturn: value } as Partial<KellySizerDraft>),
+    },
+    {
+      id: "downside",
+      label: "Downside",
+      value: binary.downsideReturn,
+      percent: true,
+      allowNegative: true,
+      tone: "negative",
+      onValue: (value) => updateDraft({ downsideReturn: value } as Partial<KellySizerDraft>),
+    },
+  ];
+}
+
+export function buildCommonFields({
+  common,
+  updateCommon,
+}: {
+  common: KellyCommonAssumptions;
+  updateCommon: (patch: Partial<KellyCommonAssumptions>) => void;
+}): InlineField[] {
+  return [
+    {
+      id: "common:kellyFraction",
+      label: "Kelly",
+      value: common.kellyFraction,
+      percent: true,
+      onValue: (value) => updateCommon({ kellyFraction: value }),
+    },
+    {
+      id: "common:maxLoss",
+      label: "Loss cap",
+      value: common.maxLossFraction,
+      percent: true,
+      onValue: (value) => updateCommon({ maxLossFraction: value }),
+    },
+    {
+      id: "common:maxName",
+      label: "Name cap",
+      value: common.maxNameFraction,
+      percent: true,
+      onValue: (value) => updateCommon({ maxNameFraction: value }),
+    },
+  ];
+}

package/src/plugins/builtin/kelly-sizer/index.test.tsx

@@ -0,0 +1,197 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import { setSharedMarketDataCoordinator } from "../../../market-data/coordinator";
+import type { TickerRecord } from "../../../types/ticker";
+import { KellySizerHarness, createFinancials, createSizerConfig, createTicker } from "./test-support";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+async function renderPane(props?: Parameters<typeof KellySizerHarness>[0]) {
+  await act(async () => {
+    testSetup = await testRender(<KellySizerHarness {...props} />, { width: 100, height: 30 });
+    await Promise.resolve();
+    await testSetup.renderOnce();
+  });
+}
+
+async function flushFrame() {
+  await act(async () => {
+    await testSetup!.renderOnce();
+  });
+}
+
+beforeEach(() => {
+  setSharedMarketDataCoordinator(null);
+});
+
+afterEach(async () => {
+  if (testSetup) {
+    await act(async () => {
+      testSetup!.renderer.destroy();
+    });
+    testSetup = undefined;
+  }
+  setSharedMarketDataCoordinator(null);
+});
+
+describe("KellySizerPane", () => {
+  test("renders binary sizing context, result, and curve", async () => {
+    await renderPane();
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("AAPL · Main Portfolio");
+    expect(frame).toContain("Bankroll");
+    expect(frame).toContain("100000");
+    expect(frame).toContain("Win p");
+    expect(frame).toContain("Full Kelly");
+    expect(frame).toContain("Clipped");
+    expect(frame).toContain("Target val");
+    expect(frame).toContain("Current %");
+    expect(frame).toContain("Kelly Curve");
+    expect(frame).toContain("4.0% -> 8.0%");
+    expect(frame).toContain("growth");
+    expect(frame).toContain("loss cap");
+    expect(frame).toContain("cap max loss, max name");
+    expect(frame).toContain("full");
+    expect(frame).toContain("159%");
+    expect(frame).toContain("636%");
+    expect(frame).not.toContain("Mode");
+    expect(frame).not.toContain("Sensitivity");
+  });
+
+  test("prefills shared caps from plugin config", async () => {
+    const config = {
+      ...createSizerConfig(),
+      pluginConfig: {
+        "kelly-sizer": {
+          "commonAssumptions:v1": {
+            kellyFraction: 0.5,
+            maxLossFraction: 0.02,
+            maxNameFraction: 0.1,
+          },
+        },
+      },
+    };
+
+    await renderPane({ config, paneState: { mode: "scenario" } });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("Scenario");
+    expect(frame).toMatch(/Kelly\s+50\.0\s+%/);
+    expect(frame).toMatch(/Loss cap\s+2\.00\s+%/);
+    expect(frame).toMatch(/Name cap\s+10\.0\s+%/);
+  });
+
+  test("keeps shared caps scoped to pane state after seeding", async () => {
+    const config = {
+      ...createSizerConfig(),
+      pluginConfig: {
+        "kelly-sizer": {
+          "commonAssumptions:v1": {
+            kellyFraction: 0.5,
+            maxLossFraction: 0.02,
+            maxNameFraction: 0.1,
+          },
+        },
+      },
+    };
+
+    await renderPane({
+      config,
+      paneState: {
+        mode: "scenario",
+        "commonAssumptions:v1": {
+          kellyFraction: 0.3,
+          maxLossFraction: 0.015,
+          maxNameFraction: 0.07,
+        },
+      },
+    });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("Scenario");
+    expect(frame).toMatch(/Kelly\s+30\.0\s+%/);
+    expect(frame).toMatch(/Loss cap\s+1\.50\s+%/);
+    expect(frame).toMatch(/Name cap\s+7\.00\s+%/);
+    expect(frame).not.toMatch(/Kelly\s+50\.0\s+%/);
+  });
+
+  test("converts foreign quote current value to base currency", async () => {
+    const ticker = createTicker({
+      symbol: "SIVE",
+      currency: "SEK",
+      positions: [{
+        portfolio: "main",
+        shares: 100,
+        avgCost: 50,
+        currency: "SEK",
+        broker: "ibkr",
+        brokerInstanceId: "ibkr-flex",
+        brokerAccountId: "DU12345",
+        marketValue: 10_000,
+        unrealizedPnl: 5_000,
+      }],
+    });
+    const financials = createFinancials({ symbol: "SIVE", price: 100, currency: "SEK" });
+
+    await renderPane({
+      config: createSizerConfig("SIVE"),
+      ticker,
+      financials,
+      exchangeRates: new Map([["USD", 1], ["SEK", 0.1]]),
+    });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("SIVE · Main Portfolio");
+    expect(frame).toMatch(/Current\s+1000\s+USD/);
+    expect(frame).not.toMatch(/Current\s+10000\s+USD/);
+  });
+
+  test("toggles sensitivity with s", async () => {
+    await renderPane();
+    await flushFrame();
+
+    await act(async () => {
+      (testSetup!.renderer.keyInput as any).emit("keypress", {
+        name: "s",
+        sequence: "s",
+        ctrl: false,
+        meta: false,
+        shift: false,
+      });
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("Sensitivity");
+    expect(frame).toContain("Win p");
+    expect(frame).toContain("Upside");
+    expect(frame).not.toContain("Kelly Curve");
+  });
+
+  test("focuses ticker search with t", async () => {
+    await renderPane();
+    await flushFrame();
+
+    await act(async () => {
+      (testSetup!.renderer.keyInput as any).emit("keypress", {
+        name: "t",
+        sequence: "t",
+        ctrl: false,
+        meta: false,
+        shift: false,
+      });
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("/ AAPL");
+  });
+});

package/src/plugins/builtin/kelly-sizer/index.tsx

@@ -0,0 +1,47 @@
+import type { GloomPlugin, PaneTemplateContext, PaneTemplateCreateOptions } from "../../../types/plugin";
+import { DEFAULT_FLOATING_SIZE, KELLY_PANE_ID } from "./constants";
+import { KellySizerPane } from "./pane";
+
+function resolveTemplateSymbol(context: PaneTemplateContext, options?: PaneTemplateCreateOptions): string | null {
+  return options?.symbol
+    ?? options?.ticker?.metadata.ticker
+    ?? options?.arg?.trim().toUpperCase()
+    ?? context.activeTicker
+    ?? null;
+}
+
+export const kellySizerPlugin: GloomPlugin = {
+  id: KELLY_PANE_ID,
+  name: "Position Sizer",
+  version: "1.0.0",
+  description: "Size positions from Kelly, risk budget, and asymmetric payoff assumptions.",
+  toggleable: true,
+  panes: [
+    {
+      id: KELLY_PANE_ID,
+      name: "Position Sizer",
+      icon: "K",
+      component: KellySizerPane,
+      defaultPosition: "right",
+      defaultMode: "floating",
+      defaultFloatingSize: DEFAULT_FLOATING_SIZE,
+    },
+  ],
+  paneTemplates: [
+    {
+      id: "kelly-sizer-pane",
+      paneId: KELLY_PANE_ID,
+      label: "Position Sizer",
+      description: "Open Kelly-based position sizing for a ticker.",
+      keywords: ["kelly", "position", "sizing", "risk", "bet", "portfolio"],
+      shortcut: { prefix: "KELLY", argPlaceholder: "ticker", argKind: "ticker", argOptional: true },
+      canCreate: (context, options) => !!resolveTemplateSymbol(context, options),
+      createInstance: (context, options) => {
+        const symbol = resolveTemplateSymbol(context, options);
+        return symbol ? { params: { symbol }, placement: "floating" } : null;
+      },
+    },
+  ],
+};
+
+export default kellySizerPlugin;