gloomberb 0.7.2 → 0.7.3

package/src/state/app-context.test.ts

@@ -329,6 +329,64 @@ describe("pane state updates", () => {
 
     expect(next).toBe(initial);
   });
+
+  test("keeps pane runtime state scoped to each saved layout", () => {
+    let state = createInitialState(createDefaultConfig("/tmp/gloomberb-test"));
+    const originalLayoutIndex = state.config.activeLayoutIndex;
+
+    state = appReducer(state, {
+      type: "UPDATE_PANE_STATE",
+      paneId: "ticker-detail:main",
+      patch: { activeTabId: "chart" },
+    });
+    state = appReducer(state, { type: "DUPLICATE_LAYOUT", index: originalLayoutIndex });
+    const duplicateLayoutIndex = state.config.activeLayoutIndex;
+
+    state = appReducer(state, {
+      type: "UPDATE_PANE_STATE",
+      paneId: "ticker-detail:main",
+      patch: { activeTabId: "financials" },
+    });
+
+    expect(state.config.layouts[duplicateLayoutIndex]?.paneState?.["ticker-detail:main"]?.activeTabId).toBe("financials");
+
+    state = appReducer(state, { type: "SWITCH_LAYOUT", index: originalLayoutIndex });
+    expect(state.paneState["ticker-detail:main"]?.activeTabId).toBe("chart");
+    expect(state.config.layouts[originalLayoutIndex]?.paneState?.["ticker-detail:main"]?.activeTabId).toBe("chart");
+
+    state = appReducer(state, { type: "SWITCH_LAYOUT", index: duplicateLayoutIndex });
+    expect(state.paneState["ticker-detail:main"]?.activeTabId).toBe("financials");
+  });
+
+  test("hydrates saved layout pane state before legacy session pane state", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    config.layouts[config.activeLayoutIndex] = {
+      ...config.layouts[config.activeLayoutIndex]!,
+      paneState: {
+        "ticker-detail:main": { activeTabId: "chart" },
+      },
+      focusedPaneId: "ticker-detail:main",
+      activePanel: "right",
+    };
+    const sessionSnapshot: AppSessionSnapshot = {
+      paneState: {
+        "ticker-detail:main": { activeTabId: "overview" },
+      },
+      focusedPaneId: "portfolio-list:main",
+      activePanel: "left",
+      statusBarVisible: true,
+      openPaneIds: ["portfolio-list:main", "ticker-detail:main"],
+      hydrationTargets: [],
+      exchangeCurrencies: ["USD"],
+      savedAt: Date.now(),
+    };
+
+    const state = createInitialState(config, sessionSnapshot);
+
+    expect(state.paneState["ticker-detail:main"]?.activeTabId).toBe("chart");
+    expect(state.focusedPaneId).toBe("ticker-detail:main");
+    expect(state.activePanel).toBe("right");
+  });
 });
 
 describe("quote merging", () => {
@@ -487,6 +545,61 @@ describe("quote merging", () => {
 });
 
 describe("layout focus fallback", () => {
+  test("switching to an old layout without focused metadata uses that layout's top floating pane", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const targetLayout = {
+      ...cloneLayout(config.layout),
+      dockRoot: null,
+      floating: [
+        { instanceId: "chat:main", x: 4, y: 2, width: 36, height: 10, zIndex: 70 },
+        { instanceId: "ticker-detail:main", x: 12, y: 4, width: 36, height: 10, zIndex: 95 },
+      ],
+    };
+    config.layouts = [
+      { name: "Current", layout: cloneLayout(config.layout), paneState: {} },
+      { name: "Floating", layout: cloneLayout(targetLayout), paneState: {} },
+    ];
+    config.activeLayoutIndex = 0;
+
+    let state = createInitialState(config);
+    state = appReducer(state, { type: "FOCUS_PANE", paneId: "chat:main" });
+    state = appReducer(state, { type: "SWITCH_LAYOUT", index: 1 });
+
+    const chatEntry = state.config.layout.floating.find((entry) => entry.instanceId === "chat:main");
+    const tickerEntry = state.config.layout.floating.find((entry) => entry.instanceId === "ticker-detail:main");
+    expect(state.focusedPaneId).toBe("ticker-detail:main");
+    expect((tickerEntry?.zIndex ?? 0) > (chatEntry?.zIndex ?? 0)).toBe(true);
+  });
+
+  test("switching layouts raises the saved focused floating pane above stale z-order", () => {
+    const config = createDefaultConfig("/tmp/gloomberb-test");
+    const targetLayout = {
+      ...cloneLayout(config.layout),
+      dockRoot: null,
+      floating: [
+        { instanceId: "chat:main", x: 4, y: 2, width: 36, height: 10, zIndex: 70 },
+        { instanceId: "ticker-detail:main", x: 12, y: 4, width: 36, height: 10, zIndex: 95 },
+      ],
+    };
+    config.layouts = [
+      { name: "Current", layout: cloneLayout(config.layout), paneState: {} },
+      {
+        name: "Floating",
+        layout: cloneLayout(targetLayout),
+        paneState: {},
+        focusedPaneId: "chat:main",
+      },
+    ];
+    config.activeLayoutIndex = 0;
+
+    const state = appReducer(createInitialState(config), { type: "SWITCH_LAYOUT", index: 1 });
+
+    const chatEntry = state.config.layout.floating.find((entry) => entry.instanceId === "chat:main");
+    const tickerEntry = state.config.layout.floating.find((entry) => entry.instanceId === "ticker-detail:main");
+    expect(state.focusedPaneId).toBe("chat:main");
+    expect((chatEntry?.zIndex ?? 0) > (tickerEntry?.zIndex ?? 0)).toBe(true);
+  });
+
   test("starts with the top floating pane focused when no session pane is active", () => {
     const config = createDefaultConfig("/tmp/gloomberb-test");
     const layout = {

package/src/state/app-context.tsx

@@ -37,6 +37,7 @@ import {
   type PaneRuntimeState,
   resolveCollectionForPane,
   resolveTickerForPane,
+  syncConfigActiveLayoutState,
 } from "../core/state/app-state";
 import type { AppAction, AppState } from "../core/state/app-state";
 import { scheduleConfigSave } from "./config-save-scheduler";
@@ -50,6 +51,7 @@ export {
   getPaneState,
   resolveCollectionForPane,
   resolveFinancialsForPane,
+  syncConfigActiveLayoutState,
   resolveTickerFileForPane,
   resolveTickerForPane,
 } from "../core/state/app-state";
@@ -283,10 +285,12 @@ export function usePaneSettingValue<T>(
       ? (nextValue as (previousValue: T) => T)(currentValue)
       : nextValue;
     const layout = setPaneSetting(currentState.config.layout, scopedPaneId, key, resolved);
-    const layouts = currentState.config.layouts.map((savedLayout, index) => (
-      index === currentState.config.activeLayoutIndex ? { ...savedLayout, layout } : savedLayout
-    ));
-    const nextConfig = { ...currentState.config, layout, layouts };
+    const nextConfig = syncConfigActiveLayoutState(
+      { ...currentState.config, layout },
+      currentState.paneState,
+      currentState.focusedPaneId,
+      currentState.activePanel,
+    );
     dispatch({ type: "SET_CONFIG", config: nextConfig });
     scheduleConfigSave(nextConfig);
   }, [dispatch, fallback, key, scopedPaneId, stateRef]);

package/src/theme/colors.ts

@@ -73,21 +73,20 @@ export function syncTheme(id: string): void {
 
 export { blendHex } from "./color-utils";
 
-const COMPARISON_SERIES_COLORS = [
-  "#5bc0eb",
-  "#f6ae2d",
-  "#f26419",
-  "#6f2dbd",
-  "#00a896",
-  "#ef476f",
-  "#118ab2",
-  "#8ac926",
-  "#ff7f51",
-  "#4361ee",
-] as const;
-
 export function getComparisonSeriesColor(index: number): string {
-  return COMPARISON_SERIES_COLORS[((index % COMPARISON_SERIES_COLORS.length) + COMPARISON_SERIES_COLORS.length) % COMPARISON_SERIES_COLORS.length]!;
+  const seriesColors = [
+    colors.borderFocused,
+    colors.warning,
+    colors.positive,
+    colors.negative,
+    colors.textBright,
+    colors.neutral,
+    blendHex(colors.borderFocused, colors.positive, 0.45),
+    blendHex(colors.warning, colors.negative, 0.35),
+    blendHex(colors.textBright, colors.positive, 0.35),
+    blendHex(colors.borderFocused, colors.negative, 0.35),
+  ];
+  return seriesColors[((index % seriesColors.length) + seriesColors.length) % seriesColors.length]!;
 }
 
 /** Returns a hover background color derived from bg and selected */

package/src/types/config.ts

@@ -1,8 +1,8 @@
 import type { Portfolio, Watchlist } from "./ticker";
 
-export const CURRENT_CONFIG_VERSION = 15;
+export const CURRENT_CONFIG_VERSION = 16;
 
-export type DefaultChartRenderMode = "area" | "line" | "candles" | "ohlc";
+export type DefaultChartRenderMode = "area" | "line" | "candles" | "ohlc" | "hlc";
 export type ChartRendererPreference = "auto" | "kitty" | "braille";
 
 export interface ChartPreferences {
@@ -108,8 +108,12 @@ export interface LayoutConfig {
 }
 
 export interface SavedLayout {
+  id?: string;
   name: string;
   layout: LayoutConfig;
+  paneState?: Record<string, Record<string, unknown>>;
+  focusedPaneId?: string | null;
+  activePanel?: "left" | "right";
 }
 
 export interface AppConfig {
@@ -154,6 +158,7 @@ export const DEFAULT_COLUMNS: ColumnConfig[] = [
 
 export const DEFAULT_PORTFOLIO_COLUMN_IDS = [
   ...DEFAULT_COLUMNS.map((column) => column.id),
+  "sparkline",
   "shares",
   "avg_cost",
   "cost_basis",
@@ -585,8 +590,8 @@ export function createDefaultConfig(dataDir: string): AppConfig {
     watchlists: [{ id: "watchlist", name: "Watchlist" }],
     layout,
     layouts: [
-      { name: "Home", layout: cloneLayout(layout) },
-      { name: "Monitor", layout: cloneLayout(DEFAULT_MONITOR_LAYOUT) },
+      { name: "Home", layout: cloneLayout(layout), paneState: {} },
+      { name: "Monitor", layout: cloneLayout(DEFAULT_MONITOR_LAYOUT), paneState: {} },
     ],
     activeLayoutIndex: 0,
     brokerInstances: [],

package/src/types/plugin.ts

@@ -110,6 +110,7 @@ export type PaneSettingField =
 
 export interface PaneSettingsDef {
   title?: string;
+  values?: Record<string, unknown>;
   fields: PaneSettingField[];
 }
 
@@ -406,6 +407,12 @@ export interface BrokerInstanceUpdateOptions {
   replaceConfig?: boolean;
 }
 
+export interface PinTickerOptions {
+  floating?: boolean;
+  paneType?: string;
+  forceNewPane?: boolean;
+}
+
 export interface GloomPluginContext {
   registerPane(pane: PaneDef): void;
   registerPaneTemplate(template: PaneTemplateDef): void;
@@ -448,7 +455,7 @@ export interface GloomPluginContext {
   createPaneFromTemplate(templateId: string, options?: PaneTemplateCreateOptions): void;
   hidePane(paneId: string): void;
   focusPane(paneId: string): void;
-  pinTicker(symbol: string, options?: { floating?: boolean; paneType?: string }): void;
+  pinTicker(symbol: string, options?: PinTickerOptions): void;
   navigateTicker(symbol: string, options?: { sourcePaneId?: string | null }): void;
   openPaneSettings(paneId?: string): void;
 

package/src/ui/context-menu.tsx

@@ -127,7 +127,7 @@ function selectedTextMenuItems(text: string, registry: PluginRegistry | null, co
       contextMenuDivider("selected-text:ticker-divider"),
       {
         id: "selected-text:open-ticker",
-        label: "Open as Ticker",
+        label: "Open Ticker Detail",
         onSelect: () => registry?.navigateTicker(symbol),
       },
       {
@@ -224,13 +224,13 @@ export function tickerContextMenuItems({
   const items: ContextMenuItem[] = [
     {
       id: "ticker:open",
-      label: `Open ${symbol}`,
+      label: `Open ${symbol} Detail`,
       onSelect: () => (openTicker ? openTicker(symbol) : registry?.navigateTicker(symbol)),
     },
     {
       id: "ticker:pin-floating",
-      label: `Pin ${symbol} in Floating Detail`,
-      onSelect: () => registry?.pinTicker(symbol, { floating: true, paneType: "ticker-detail" }),
+      label: `Open ${symbol} in New Floating Detail`,
+      onSelect: () => registry?.pinTicker(symbol, { floating: true, paneType: "ticker-detail", forceNewPane: true }),
     },
     {
       id: "ticker:copy-symbol",

package/src/utils/api-client.test.ts

@@ -282,6 +282,134 @@ describe("apiClient chat timestamps", () => {
     expect(seenCreatedAts).toEqual(["2026-04-08T07:28:27.625Z"]);
     channel.close();
   });
+
+  test("fetches chat state and normalizes pending notification timestamps", async () => {
+    let requestedUrl = "";
+    globalThis.fetch = mockFetch(async (input: Request | string | URL) => {
+      requestedUrl = String(input);
+      return createResponse({
+        channels: [{ id: "everyone", name: "everyone", created_at: "2026-04-08T07:00:00.000Z" }],
+        onlineCount: 2,
+        channelStates: [{
+          channelId: "everyone",
+          notificationsEnabled: true,
+          lastReadMessageId: "m1",
+          unreadCount: 1,
+        }],
+        notifications: [{
+          id: "n1",
+          type: "reply",
+          channelId: "everyone",
+          messageId: "m2",
+          createdAt: "2026-04-08 07:30:00.000",
+          message: {
+            id: "m2",
+            channelId: "everyone",
+            content: "reply",
+            replyToId: "m1",
+            createdAt: "2026-04-08 07:29:00.000",
+            user: { id: "u2", username: "bob", displayName: "Bob" },
+            replyTo: { content: "parent", user: { id: "u1", username: "vince" } },
+          },
+        }],
+      });
+    });
+
+    const state = await apiClient.getChatState();
+
+    expect(new URL(requestedUrl).pathname).toBe("/chat/state");
+    expect(state.onlineCount).toBe(2);
+    expect(state.notifications[0]?.createdAt).toBe("2026-04-08T07:30:00.000Z");
+    expect(state.notifications[0]?.message.createdAt).toBe("2026-04-08T07:29:00.000Z");
+  });
+
+  test("updates chat channel state and marks notifications delivered", async () => {
+    const requests: Array<{ path: string; method: string; body: unknown }> = [];
+    const responses = [
+      createResponse({
+        channelId: "everyone",
+        notificationsEnabled: true,
+        lastReadMessageId: "m2",
+        unreadCount: 0,
+      }),
+      createResponse({ delivered: 2 }),
+      createResponse({ onlineCount: 4 }),
+    ];
+    globalThis.fetch = mockFetch(async (input: Request | string | URL, init?: RequestInit) => {
+      requests.push({
+        path: new URL(String(input)).pathname,
+        method: init?.method ?? "GET",
+        body: init?.body ? JSON.parse(String(init.body)) : null,
+      });
+      return responses.shift() as Response;
+    });
+
+    await apiClient.updateChatChannelState("everyone", {
+      notificationsEnabled: true,
+      readThroughMessageId: "m2",
+    });
+    await apiClient.markChatNotificationsDelivered(["n1", "n2"]);
+    const presence = await apiClient.getChatPresence();
+
+    expect(requests).toEqual([
+      {
+        path: "/chat/channels/everyone/state",
+        method: "PATCH",
+        body: { notificationsEnabled: true, readThroughMessageId: "m2" },
+      },
+      {
+        path: "/chat/notifications/delivered",
+        method: "POST",
+        body: { notificationIds: ["n1", "n2"] },
+      },
+      {
+        path: "/chat/presence",
+        method: "GET",
+        body: null,
+      },
+    ]);
+    expect(presence).toEqual({ onlineCount: 4 });
+  });
+
+  test("emits websocket chat presence and notification events", async () => {
+    const seenPresence: number[] = [];
+    const seenNotifications: string[] = [];
+    const unsubscribePresence = apiClient.subscribeChatPresence((onlineCount) => {
+      seenPresence.push(onlineCount);
+    });
+    const unsubscribeNotifications = apiClient.subscribeChatNotifications((notification) => {
+      seenNotifications.push(`${notification.id}:${notification.message.createdAt}`);
+    });
+
+    await (apiClient as any).handleSocketMessage(JSON.stringify({
+      type: "chat.presence",
+      onlineCount: 5,
+    }));
+    await (apiClient as any).handleSocketMessage(JSON.stringify({
+      type: "chat.notification",
+      data: {
+        id: "n1",
+        type: "reply",
+        channelId: "everyone",
+        messageId: "m2",
+        createdAt: "2026-04-08 07:30:00.000",
+        message: {
+          id: "m2",
+          channelId: "everyone",
+          content: "reply",
+          replyToId: "m1",
+          createdAt: "2026-04-08 07:29:00.000",
+          user: { id: "u2", username: "bob", displayName: "Bob" },
+          replyTo: { content: "parent", user: { id: "u1", username: "vince" } },
+        },
+      },
+    }));
+
+    expect(seenPresence).toEqual([5]);
+    expect(seenNotifications).toEqual(["n1:2026-04-08T07:29:00.000Z"]);
+    unsubscribePresence();
+    unsubscribeNotifications();
+  });
 });
 
 describe("apiClient cloud news", () => {

package/src/utils/api-client.ts

@@ -48,7 +48,7 @@ export interface ChatMessage {
   replyToId: string | null;
   createdAt: string;
   user: { id: string; username: string; displayName: string };
-  replyTo?: { content: string; user: { username: string } } | null;
+  replyTo?: { content: string; user: { id?: string; username: string } } | null;
   clientStatus?: "sending" | "failed";
   clientError?: string | null;
 }
@@ -59,6 +59,29 @@ export interface ChatChannel {
   created_at: string;
 }
 
+export interface ChatChannelState {
+  channelId: string;
+  notificationsEnabled: boolean;
+  lastReadMessageId: string | null;
+  unreadCount: number;
+}
+
+export interface ChatNotification {
+  id: string;
+  type: "reply" | "mention" | "channel";
+  channelId: string;
+  messageId: string;
+  createdAt: string;
+  message: ChatMessage;
+}
+
+export interface ChatStateResponse {
+  channels: ChatChannel[];
+  onlineCount: number;
+  channelStates: ChatChannelState[];
+  notifications: ChatNotification[];
+}
+
 export interface AuthUser {
   id: string;
   name: string;
@@ -352,6 +375,21 @@ function normalizeChatMessages(messages: ChatMessage[]): ChatMessage[] {
   return messages.map((message) => normalizeChatMessage(message));
 }
 
+function normalizeChatNotification(notification: ChatNotification): ChatNotification {
+  return {
+    ...notification,
+    createdAt: normalizeTimestamp(notification.createdAt),
+    message: normalizeChatMessage(notification.message),
+  };
+}
+
+function normalizeChatState(response: ChatStateResponse): ChatStateResponse {
+  return {
+    ...response,
+    notifications: response.notifications.map(normalizeChatNotification),
+  };
+}
+
 function normalizeTweet(tweet: CloudTweetPayload): CloudTweetPayload {
   return {
     ...tweet,
@@ -370,6 +408,8 @@ function normalizeTweetSearchResponse(response: CloudTweetSearchResponse): Cloud
 }
 
 type ChannelListener = (message: ChatMessage) => void;
+type ChatNotificationListener = (notification: ChatNotification) => void;
+type ChatPresenceListener = (onlineCount: number) => void;
 type QuoteListener = (target: QuoteStreamTarget, quote: CloudQuotePayload) => void;
 type SessionCookieName = (typeof SESSION_COOKIE_NAMES)[number];
 
@@ -408,6 +448,8 @@ class GloomApiClient {
   private reconnectDelayMs = 1000;
 
   private readonly channelListeners = new Map<string, Set<ChannelListener>>();
+  private readonly chatNotificationListeners = new Set<ChatNotificationListener>();
+  private readonly chatPresenceListeners = new Set<ChatPresenceListener>();
   private readonly quoteListeners = new Map<string, Set<QuoteListener>>();
   private readonly quoteTargets = new Map<string, QuoteStreamTarget>();
   private readonly pendingQuoteSubscribes = new Map<string, QuoteStreamTarget>();
@@ -650,7 +692,12 @@ class GloomApiClient {
     if (this.ws?.readyState !== WebSocket.OPEN) return;
     if (payload && typeof payload === "object" && "type" in (payload as Record<string, unknown>)) {
       const type = (payload as Record<string, unknown>).type;
-      if (type === "market.subscribe" || type === "market.unsubscribe" || type === "chat.subscribe") {
+      if (
+        type === "market.subscribe"
+        || type === "market.unsubscribe"
+        || type === "chat.subscribe"
+        || type === "chat.unsubscribe"
+      ) {
         cloudApiLog.info("send websocket message", payload);
       }
     }
@@ -773,6 +820,21 @@ class GloomApiClient {
       return;
     }
 
+    if (parsed?.type === "chat.notification" && parsed.data) {
+      const notification = normalizeChatNotification(parsed.data as ChatNotification);
+      for (const listener of this.chatNotificationListeners) {
+        listener(notification);
+      }
+      return;
+    }
+
+    if (parsed?.type === "chat.presence" && typeof parsed.onlineCount === "number") {
+      for (const listener of this.chatPresenceListeners) {
+        listener(parsed.onlineCount);
+      }
+      return;
+    }
+
     if (parsed?.type === "market.quote" && parsed.quote && typeof parsed.symbol === "string") {
       const key = marketKey(parsed.symbol, parsed.exchange);
       const target = this.quoteTargets.get(key) ?? {
@@ -853,6 +915,32 @@ class GloomApiClient {
     return this.request<ChatChannel[]>("/chat/channels");
   }
 
+  async getChatPresence(): Promise<{ onlineCount: number }> {
+    return this.request<{ onlineCount: number }>("/chat/presence");
+  }
+
+  async getChatState(): Promise<ChatStateResponse> {
+    const state = await this.request<ChatStateResponse>("/chat/state");
+    return normalizeChatState(state);
+  }
+
+  async updateChatChannelState(
+    channelId: string,
+    body: { notificationsEnabled?: boolean; readThroughMessageId?: string },
+  ): Promise<ChatChannelState> {
+    return this.request<ChatChannelState>(`/chat/channels/${channelId}/state`, {
+      method: "PATCH",
+      body: JSON.stringify(body),
+    });
+  }
+
+  async markChatNotificationsDelivered(notificationIds: string[]): Promise<{ delivered: number }> {
+    return this.request<{ delivered: number }>("/chat/notifications/delivered", {
+      method: "POST",
+      body: JSON.stringify({ notificationIds }),
+    });
+  }
+
   async getMessages(
     channelId: string,
     opts?: { after?: string; before?: string; limit?: number },
@@ -866,10 +954,10 @@ class GloomApiClient {
     return normalizeChatMessages(messages);
   }
 
-  async sendMessage(channelId: string, content: string, replyToId?: string): Promise<ChatMessage> {
+  async sendMessage(channelId: string, content: string, replyToId?: string, clientMessageId?: string): Promise<ChatMessage> {
     const message = await this.request<ChatMessage>(`/chat/channels/${channelId}/messages`, {
       method: "POST",
-      body: JSON.stringify({ content, replyToId }),
+      body: JSON.stringify({ content, replyToId, clientMessageId }),
     });
     return normalizeChatMessage(message);
   }
@@ -878,7 +966,7 @@ class GloomApiClient {
     channelId: string,
     onMessage: (msg: ChatMessage) => void,
     onError?: (err: string) => void,
-  ): { send: (content: string, replyToId?: string) => Promise<ChatMessage>; close: () => void } {
+  ): { send: (content: string, replyToId?: string, clientMessageId?: string) => Promise<ChatMessage>; close: () => void } {
     if (!channelId) {
       return {
         send: async () => {
@@ -898,9 +986,9 @@ class GloomApiClient {
     }
 
     return {
-      send: async (content: string, replyToId?: string) => {
+      send: async (content: string, replyToId?: string, clientMessageId?: string) => {
         try {
-          const message = await this.sendMessage(channelId, content, replyToId);
+          const message = await this.sendMessage(channelId, content, replyToId, clientMessageId);
           onMessage(message);
           return message;
         } catch (error) {
@@ -914,6 +1002,7 @@ class GloomApiClient {
         current.delete(onMessage);
         if (current.size === 0) {
           this.channelListeners.delete(channelId);
+          this.sendSocketMessage({ type: "chat.unsubscribe", channelId });
         }
         if (!this.shouldKeepSocketOpen()) {
           this.teardownSocket();
@@ -922,6 +1011,20 @@ class GloomApiClient {
     };
   }
 
+  subscribeChatNotifications(listener: ChatNotificationListener): () => void {
+    this.chatNotificationListeners.add(listener);
+    return () => {
+      this.chatNotificationListeners.delete(listener);
+    };
+  }
+
+  subscribeChatPresence(listener: ChatPresenceListener): () => void {
+    this.chatPresenceListeners.add(listener);
+    return () => {
+      this.chatPresenceListeners.delete(listener);
+    };
+  }
+
   subscribeQuotes(
     targets: QuoteStreamTarget[],
     onQuote: (target: QuoteStreamTarget, quote: CloudQuotePayload) => void,
@@ -997,6 +1100,8 @@ class GloomApiClient {
       channelTargets: this.channelListeners.size,
     });
     this.channelListeners.clear();
+    this.chatNotificationListeners.clear();
+    this.chatPresenceListeners.clear();
     this.quoteListeners.clear();
     this.quoteTargets.clear();
     this.pendingQuoteSubscribes.clear();

package/src/utils/fuzzy-search.ts

@@ -5,7 +5,18 @@ export function fuzzyMatch(query: string, target: string): { match: boolean; sco
   const t = target.toLowerCase();
 
   if (q.length === 0) return { match: true, score: 0 };
-  if (t.startsWith(q)) return { match: true, score: 1000 - q.length }; // exact prefix match
+  if (t === q) return { match: true, score: 2500 - q.length };
+
+  const tokens = t.split(/\s+/).filter(Boolean);
+  const exactTokenIndex = tokens.findIndex((token) => token === q);
+  if (exactTokenIndex >= 0) return { match: true, score: 2200 - q.length - exactTokenIndex };
+
+  const prefixTokenIndex = tokens.findIndex((token) => token.startsWith(q));
+  if (prefixTokenIndex >= 0) {
+    const token = tokens[prefixTokenIndex]!;
+    return { match: true, score: 1000 - q.length - prefixTokenIndex - (token.length - q.length) };
+  }
+
   if (t.includes(q)) return { match: true, score: 500 - q.length }; // substring match
 
   let qi = 0;