gloomberb 0.6.1 → 0.7.1

package/src/plugins/builtin/ai/screener-pane.tsx

@@ -461,8 +461,6 @@ export function AiScreenerPane({ focused, width, height }: PaneProps) {
   const selectedResult = activeTab?.results.find((result) => result.symbol === cursorSymbol)
     ?? activeTab?.results[0]
     ?? null;
-  const selectedIdx = sortedTickers.findIndex((ticker) => ticker.metadata.ticker === cursorSymbol);
-  const safeSelectedIdx = selectedIdx >= 0 ? selectedIdx : 0;
   const isRunningActiveTab = runState?.tabId === activeTab?.id;
   const forceRunArmed = !!activeTab && forceConfirmTabId === activeTab.id;
 
@@ -753,7 +751,6 @@ export function AiScreenerPane({ focused, width, height }: PaneProps) {
       return;
     }
 
-    const key = event.name;
     if (event.name === "t") {
       addTab();
       return;
@@ -762,11 +759,11 @@ export function AiScreenerPane({ focused, width, height }: PaneProps) {
       removeTab(activeTab.id);
       return;
     }
-    if (event.name === "[" || event.name === "left") {
+    if (event.name === "[") {
       cycleTabs(-1);
       return;
     }
-    if (event.name === "]" || event.name === "right") {
+    if (event.name === "]") {
       cycleTabs(1);
       return;
     }
@@ -920,6 +917,7 @@ export function AiScreenerPane({ focused, width, height }: PaneProps) {
           variant="pill"
           closeMode="active"
           onAdd={editorState ? undefined : addTab}
+          focused={focused && !editorState}
         />
       </Box>
 

package/src/plugins/builtin/analytics/index.tsx

@@ -1,7 +1,6 @@
 import { Box, Text } from "../../../ui";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { TextAttributes } from "../../../ui";
-import { useShortcut } from "../../../react/input";
 import { DataTableView, Tabs, type DataTableColumn } from "../../../components";
 import type { GloomPlugin, PaneProps } from "../../../types/plugin";
 import type { ColumnConfig } from "../../../types/config";
@@ -278,7 +277,6 @@ export function PortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
     () => portfolios.find((portfolio) => portfolio.id === activePortfolioId) ?? null,
     [activePortfolioId, portfolios],
   );
-  const activePortfolioIndex = portfolios.findIndex((portfolio) => portfolio.id === activePortfolioId);
   const portfolioTabs = useMemo(
     () => portfolios.map((portfolio) => ({ label: portfolio.name, value: portfolio.id })),
     [portfolios],
@@ -555,22 +553,6 @@ export function PortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
     setSectorSort((current) => nextSectorSortPreference(current, columnId));
   }, []);
 
-  useShortcut((event) => {
-    if (!focused) return;
-
-    const key = event.name;
-    if ((key === "h" || key === "left") && activePortfolioIndex > 0) {
-      const previousPortfolio = portfolios[activePortfolioIndex - 1];
-      if (previousPortfolio) handlePortfolioSelect(previousPortfolio.id);
-      return;
-    }
-    if ((key === "l" || key === "right") && activePortfolioIndex >= 0 && activePortfolioIndex < portfolios.length - 1) {
-      const nextPortfolio = portfolios[activePortfolioIndex + 1];
-      if (nextPortfolio) handlePortfolioSelect(nextPortfolio.id);
-      return;
-    }
-  });
-
   useEffect(() => {
     if (activePortfolioId !== currentPortfolioId) {
       setCurrentPortfolioId(activePortfolioId);
@@ -592,6 +574,7 @@ export function PortfolioAnalyticsPane({ focused, width, height }: PaneProps) {
                 activeValue={activePortfolioId}
                 onSelect={handlePortfolioSelect}
                 compact
+                focused={focused}
               />
             </Box>
           </Box>

package/src/plugins/builtin/ask-ai.test.tsx

@@ -1,8 +1,8 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { act } from "react";
+import { act, useReducer } from "react";
 import { PaneFooterBar, PaneFooterProvider } from "../../components/layout/pane-footer";
 import { testRender } from "../../renderers/opentui/test-utils";
-import { AppContext, PaneInstanceProvider, createInitialState } from "../../state/app-context";
+import { AppContext, PaneInstanceProvider, appReducer, createInitialState } from "../../state/app-context";
 import { createStatefulTestPluginRuntime } from "../../test-support/plugin-runtime";
 import { createDefaultConfig } from "../../types/config";
 import { Box } from "../../ui";
@@ -258,4 +258,91 @@ describe("AskAiTab", () => {
 
     expect(opened).toEqual(["AAPL"]);
   });
+
+  test("does not persist previous ticker messages while hydrating a newly selected ticker", async () => {
+    setProviders([
+      { id: "claude", name: "Claude", command: "claude", available: true, buildArgs: () => [] },
+    ]);
+
+    const runtime = createStatefulTestPluginRuntime();
+    runtime.setResumeState("ai", "conversation:claude:AAPL", {
+      updatedAt: Date.now(),
+      messages: [
+        { role: "user", content: "AAPL question" },
+        { role: "assistant", content: "AAPL answer", loading: false },
+      ],
+    }, 1);
+    runtime.setResumeState("ai", "conversation:claude:MSFT", {
+      updatedAt: Date.now(),
+      messages: [
+        { role: "user", content: "MSFT question" },
+        { role: "assistant", content: "MSFT answer", loading: false },
+      ],
+    }, 1);
+
+    let selectSymbol: ((symbol: string) => void) | null = null;
+
+    const config = createDefaultConfig("/tmp/gloomberb-ai-navigation");
+    const initialState = createInitialState(config);
+    initialState.focusedPaneId = PANE_ID;
+    initialState.paneState["portfolio-list:main"] = {
+      ...initialState.paneState["portfolio-list:main"],
+      cursorSymbol: "AAPL",
+    };
+    initialState.tickers = new Map([
+      ["AAPL", makeTicker("AAPL", "Apple Inc.")],
+      ["MSFT", makeTicker("MSFT", "Microsoft Corporation")],
+    ]);
+
+    function NavigableAskAiHarness() {
+      const [state, dispatch] = useReducer(appReducer, initialState);
+      selectSymbol = (symbol) => {
+        dispatch({
+          type: "UPDATE_PANE_STATE",
+          paneId: "portfolio-list:main",
+          patch: { cursorSymbol: symbol },
+        });
+      };
+
+      return (
+        <AppContext value={{ state, dispatch }}>
+          <PaneInstanceProvider paneId={PANE_ID}>
+            <PluginRenderProvider pluginId="ai" runtime={runtime}>
+              <PaneFooterProvider>
+                {(footer) => (
+                  <Box flexDirection="column" width={60} height={12}>
+                    <AskAiTab width={60} height={11} focused onCapture={() => {}} />
+                    <PaneFooterBar footer={footer} focused width={60} />
+                  </Box>
+                )}
+              </PaneFooterProvider>
+            </PluginRenderProvider>
+          </PaneInstanceProvider>
+        </AppContext>
+      );
+    }
+
+    await act(async () => {
+      testSetup = await testRender(<NavigableAskAiHarness />, {
+        width: 60,
+        height: 12,
+      });
+    });
+    await flushFrame();
+
+    expect(testSetup.captureCharFrame()).toContain("AAPL answer");
+
+    await act(() => {
+      selectSymbol?.("MSFT");
+    });
+    await flushFrame();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("MSFT answer");
+    expect(frame).not.toContain("AAPL answer");
+    expect((runtime.getResumeState("ai", "conversation:claude:MSFT") as any)?.messages).toEqual([
+      { role: "user", content: "MSFT question" },
+      { role: "assistant", content: "MSFT answer", loading: false },
+    ]);
+  });
 });

package/src/plugins/builtin/broker-manager/index.test.tsx

@@ -65,7 +65,7 @@ function Harness({
   const runtime = createTestPluginRuntime({
     getBrokerAdapter: (brokerType) => brokerType === "ibkr" ? ibkrBroker : null,
     openCommandBar: (query) => calls.push(`command:${query ?? ""}`),
-    showWidget: (paneId) => calls.push(`widget:${paneId}`),
+    showPane: (paneId) => calls.push(`pane:${paneId}`),
     connectBrokerInstance: async (instanceId) => { calls.push(`connect:${instanceId}`); },
     syncBrokerInstance: async (instanceId) => { calls.push(`sync:${instanceId}`); },
     updateBrokerInstance: async (instanceId) => { calls.push(`update:${instanceId}`); },
@@ -163,6 +163,6 @@ describe("BrokersPane", () => {
     await pressKey("s");
     await pressKey("o");
 
-    expect(calls).toEqual(["connect:ibkr-paper", "sync:ibkr-paper", "widget:ibkr-trading"]);
+    expect(calls).toEqual(["connect:ibkr-paper", "sync:ibkr-paper", "pane:ibkr-trading"]);
   });
 });

package/src/plugins/builtin/broker-manager/index.tsx

@@ -2,6 +2,7 @@ import { Box, ScrollBox, Text, TextAttributes } from "../../../ui";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
   Button,
+  ConfirmDialog,
   DataTableStackView,
   NumberField,
   SegmentedControl,
@@ -29,8 +30,7 @@ import type { BrokerAdapter, BrokerConfigField, BrokerProfileAction } from "../.
 import type { BrokerInstanceConfig } from "../../../types/config";
 import type { GloomPlugin, PaneProps } from "../../../types/plugin";
 import type { BrokerAccount } from "../../../types/trading";
-import { DialogFrame } from "../../../components/ui/frame";
-import { useDialog, useDialogKeyboard, type PromptContext } from "../../../ui/dialog";
+import { useDialog, type PromptContext } from "../../../ui/dialog";
 import { formatCurrency } from "../../../utils/format";
 import { usePluginAppActions, usePluginBrokerActions } from "../../plugin-runtime";
 import {
@@ -76,34 +76,6 @@ function isBrokerErrorMessage(message: string | null | undefined): boolean {
   return normalized.includes("failed") || normalized.includes("required");
 }
 
-function ConfirmRemoveBrokerDialog({
-  resolve,
-  row,
-}: PromptContext<boolean> & { row: BrokerProfileRow }) {
-  const confirm = useCallback(() => resolve(true), [resolve]);
-  const cancel = useCallback(() => resolve(false), [resolve]);
-
-  useDialogKeyboard((event) => {
-    event.stopPropagation();
-    if (event.name === "enter" || event.name === "return") confirm();
-    if (event.name === "escape") cancel();
-  });
-
-  return (
-    <DialogFrame title="Disconnect broker?" footer="Enter disconnect · Esc cancel">
-      <Box flexDirection="column" width={58}>
-        <Text fg={colors.text}>{`Remove "${row.label}" and imported broker data?`}</Text>
-        <Text fg={colors.textDim}>Broker-managed portfolios, positions, and contracts will be removed.</Text>
-        <Box height={1} />
-        <Box flexDirection="row" gap={1}>
-          <Button label="Disconnect" variant="danger" onPress={confirm} />
-          <Button label="Back" variant="secondary" onPress={cancel} />
-        </Box>
-      </Box>
-    </DialogFrame>
-  );
-}
-
 function brokerFieldLabel(field: BrokerConfigField, focused: boolean): string {
   return focused ? `> ${field.label}` : `  ${field.label}`;
 }
@@ -202,7 +174,7 @@ export function BrokersPane({ focused, width, height }: PaneProps) {
   const config = useAppSelector((state) => state.config);
   const brokerAccounts = useAppSelector((state) => state.brokerAccounts);
   const dialog = useDialog();
-  const { openCommandBar, showWidget } = usePluginAppActions();
+  const { openCommandBar, showPane } = usePluginAppActions();
   const {
     getBrokerAdapter,
     connectBrokerInstance,
@@ -363,15 +335,26 @@ export function BrokersPane({ focused, width, height }: PaneProps) {
       setMessage(action.disabledReason ?? `${action.label} is unavailable for this profile.`);
       return;
     }
-    if (action.widgetId) showWidget(action.widgetId);
-  }, [primaryProfileAction, showWidget]);
+    if (action.paneId) showPane(action.paneId);
+  }, [primaryProfileAction, showPane]);
 
   const removeSelected = useCallback(async () => {
     if (!selectedRow) return;
     const confirmed = await dialog.prompt<boolean>({
       closeOnClickOutside: true,
       content: (ctx: PromptContext<boolean>) => (
-        <ConfirmRemoveBrokerDialog {...ctx} row={selectedRow} />
+        <ConfirmDialog
+          {...ctx}
+          title="Disconnect broker?"
+          body={[
+            `Remove "${selectedRow.label}" and imported broker data?`,
+            "Broker-managed portfolios, positions, and contracts will be removed.",
+          ]}
+          confirmLabel="Disconnect"
+          cancelLabel="Back"
+          width={58}
+          footer="Enter disconnect · Esc cancel"
+        />
       ),
     }).catch(() => false);
     if (confirmed !== true) return;
@@ -392,7 +375,7 @@ export function BrokersPane({ focused, width, height }: PaneProps) {
   const hasSelectedRow = selectedRow !== null;
   const selectedHasAdapter = !!selectedRow?.adapter;
   const canUseSelectedBroker = selectedHasAdapter && !busy;
-  const canOpenSelectedAction = selectedProfileActions.some((action) => !action.disabled && action.widgetId);
+  const canOpenSelectedAction = selectedProfileActions.some((action) => !action.disabled && action.paneId);
   const canRemoveSelected = hasSelectedRow && !busy;
 
   const footerActionsRef = useRef({
@@ -752,7 +735,7 @@ export const brokerManagerPlugin: GloomPlugin = {
       keywords: ["broker", "brokers", "connection", "accounts", "sync"],
       category: "navigation",
       execute: () => {
-        ctx.showWidget("brokers");
+        ctx.showPane("brokers");
       },
     });
   },

package/src/plugins/builtin/chat-controller.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import type { AppNotificationRequest, PluginPersistence } from "../../types/plugin";
 import type { PersistedResourceValue } from "../../types/persistence";
-import { apiClient, type ChatMessage } from "../../utils/api-client";
+import { apiClient, type ChatChannel, type ChatMessage } from "../../utils/api-client";
 import { ChatController } from "./chat-controller";
 
 const TRANSCRIPT_KIND = "channel-transcript";
@@ -11,6 +11,14 @@ const TRANSCRIPT_SCHEMA_VERSION = 2;
 const originalConnectChannel = apiClient.connectChannel.bind(apiClient);
 const originalGetSession = apiClient.getSession.bind(apiClient);
 const originalGetMessages = apiClient.getMessages.bind(apiClient);
+const originalGetChannels = apiClient.getChannels.bind(apiClient);
+
+const SERVER_CHAT_CHANNELS: ChatChannel[] = [
+  { id: "everyone", name: "everyone", created_at: "2026-03-26T12:10:05.684Z" },
+  { id: "equities", name: "equities", created_at: "2026-05-09T00:00:00.000Z" },
+  { id: "options", name: "options", created_at: "2026-05-09T00:00:00.000Z" },
+  { id: "help", name: "help", created_at: "2026-05-09T00:00:00.000Z" },
+];
 
 async function flushMicrotasks() {
   await Promise.resolve();
@@ -83,12 +91,22 @@ class MemoryPersistence implements PluginPersistence {
   }
 }
 
+class TrackingPersistence extends MemoryPersistence {
+  stateWrites = 0;
+
+  setState(key: string, value: unknown, options?: { schemaVersion?: number }): void {
+    this.stateWrites += 1;
+    super.setState(key, value, options);
+  }
+}
+
 afterEach(() => {
   apiClient.dispose();
   apiClient.setSessionToken(null);
   apiClient.connectChannel = originalConnectChannel;
   apiClient.getSession = originalGetSession;
   apiClient.getMessages = originalGetMessages;
+  apiClient.getChannels = originalGetChannels;
 });
 
 describe("ChatController", () => {
@@ -132,6 +150,27 @@ describe("ChatController", () => {
     expect(snapshot.messages.map((entry) => entry.id)).toEqual(["m1"]);
   });
 
+  test("starts without client-seeded channels and hydrates the server channel list", async () => {
+    const controller = new ChatController();
+    apiClient.getChannels = async () => SERVER_CHAT_CHANNELS;
+
+    expect(controller.getSnapshot().channels).toEqual([]);
+
+    await controller.refreshChannels();
+
+    expect(controller.getSnapshot().channels).toEqual(SERVER_CHAT_CHANNELS);
+  });
+
+  test("rejects unknown shortcut channels after the server list loads", async () => {
+    const controller = new ChatController();
+    apiClient.getChannels = async () => SERVER_CHAT_CHANNELS;
+
+    await expect(controller.resolveRequiredChannelId("help")).resolves.toBe("help");
+    await expect(controller.resolveRequiredChannelId("made-up")).rejects.toThrow(
+      'Unknown chat channel "#made-up".',
+    );
+  });
+
   test("hydrates a cached verified user into the api client for offline use", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -209,6 +248,34 @@ describe("ChatController", () => {
     })).toBeNull();
   });
 
+  test("defers draft persistence and subscriber sync until the user pauses or leaves", () => {
+    const persistence = new TrackingPersistence();
+    const controller = new ChatController();
+    const draftSnapshots: string[] = [];
+
+    controller.attachPersistence(persistence);
+    const unsubscribe = controller.subscribe((snapshot) => {
+      draftSnapshots.push(snapshot.draft);
+    });
+    draftSnapshots.length = 0;
+    persistence.stateWrites = 0;
+
+    controller.setDraft("h");
+    controller.setDraft("he");
+
+    expect(controller.getSnapshot().draft).toBe("he");
+    expect(draftSnapshots).toEqual([]);
+    expect(persistence.stateWrites).toBe(0);
+    expect(persistence.getState("channel:everyone", { schemaVersion: 1 })).toBeNull();
+
+    unsubscribe();
+    controller.dispose();
+
+    expect(persistence.getState<{ draft: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
+      draft: "he",
+    });
+  });
+
   test("pauses verification polling while the app is backgrounded", () => {
     const controller = new ChatController();
 
@@ -254,6 +321,74 @@ describe("ChatController", () => {
     expect((controller as any).wsConnection).toBeNull();
   });
 
+  test("runs a quiet safety refresh while the live connection is active", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const originalSetInterval = globalThis.setInterval;
+    const originalClearInterval = globalThis.clearInterval;
+    const intervalCallbacks: Array<() => void> = [];
+    const intervalHandle = { unref: () => {} };
+    let cleared = false;
+    let getMessagesCalls = 0;
+    const loadingSnapshots: boolean[] = [];
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    (globalThis as any).setInterval = (callback: () => void, timeout: number) => {
+      expect(timeout).toBe(30_000);
+      intervalCallbacks.push(callback);
+      return intervalHandle;
+    };
+    (globalThis as any).clearInterval = (handle: unknown) => {
+      if (handle === intervalHandle) {
+        cleared = true;
+      }
+    };
+
+    try {
+      apiClient.getMessages = async () => {
+        getMessagesCalls += 1;
+        return [];
+      };
+      apiClient.connectChannel = () => ({
+        send: async () => {
+          throw new Error("not implemented");
+        },
+        close: () => {},
+      });
+
+      controller.attachPersistence(persistence);
+      controller.ensureConnection();
+      await flushMicrotasks();
+
+      expect(intervalCallbacks).toHaveLength(1);
+      expect(getMessagesCalls).toBe(1);
+      expect(controller.getSnapshot().loading).toBe(false);
+
+      controller.subscribe((snapshot) => {
+        loadingSnapshots.push(snapshot.loading);
+      });
+      loadingSnapshots.length = 0;
+
+      intervalCallbacks[0]!();
+      await flushMicrotasks();
+
+      expect(getMessagesCalls).toBe(2);
+      expect(loadingSnapshots).toEqual([false]);
+
+      controller.clearSession();
+      expect((controller as any).safetyRefreshTimer).toBeNull();
+      expect(cleared).toBe(true);
+    } finally {
+      controller.dispose();
+      (globalThis as any).setInterval = originalSetInterval;
+      (globalThis as any).clearInterval = originalClearInterval;
+    }
+  });
+
   test("keeps the cached session when session refresh fails transiently", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -307,6 +442,58 @@ describe("ChatController", () => {
     });
   });
 
+  test("keeps per-channel drafts and transcripts isolated", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const everyoneMessage: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "general",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+    const optionsMessage: ChatMessage = {
+      id: "m2",
+      channelId: "options",
+      content: "options note",
+      replyToId: null,
+      createdAt: "2026-03-28T00:01:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("channel:everyone", {
+      draft: "general draft",
+      replyToId: null,
+      lastCursor: "m1",
+      lastViewedMessageId: "m1",
+    }, { schemaVersion: 1 });
+    persistence.setState("channel:options", {
+      draft: "options draft",
+      replyToId: null,
+      lastCursor: "m2",
+      lastViewedMessageId: "m2",
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, "everyone", { messages: [everyoneMessage] }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+    persistence.setResource(TRANSCRIPT_KIND, "options", { messages: [optionsMessage] }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+    controller.setChannelDraft("options", "updated options");
+
+    expect(controller.getSnapshot().messages.map((entry) => entry.content)).toEqual(["general"]);
+    expect(controller.getSnapshot().draft).toBe("general draft");
+    expect(controller.getSnapshot("options").messages.map((entry) => entry.content)).toEqual(["options note"]);
+    expect(controller.getSnapshot("options").draft).toBe("updated options");
+  });
+
   test("stores the latest message id as the incremental cursor", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();