gloomberb 0.7.0 → 0.7.2

package/src/market-data/coordinator.ts

@@ -1,4 +1,4 @@
-import type { DataProvider, SecFilingItem } from "../types/data-provider";
+import type { CachedFinancialsTarget, DataProvider, QuoteSubscriptionTarget, SecFilingItem } from "../types/data-provider";
 import type { NewsArticle } from "../news/types";
 import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { ChartRequest, InstrumentRef, NewsRequest, OptionsRequest, SecFilingsRequest } from "./request-types";
@@ -39,6 +39,7 @@ const SEC_FILINGS_CACHE_TTL_MS = 10 * 60_000;
 const SEC_CONTENT_CACHE_TTL_MS = 24 * 60 * 60_000;
 const ARTICLE_SUMMARY_CACHE_TTL_MS = 24 * 60 * 60_000;
 const FX_CACHE_TTL_MS = 30 * 60_000;
+const QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS = 250;
 
 function createBaselineChartRequest(instrument: InstrumentRef): ChartRequest {
   return {
@@ -223,6 +224,13 @@ export class MarketDataCoordinator {
   private readonly keyVersions = new Map<string, number>();
   private readonly inFlight = new Map<string, Promise<unknown>>();
   private readonly chartRequests = new Map<string, ChartRequest>();
+  private readonly quoteSubscriptions = new Map<string, {
+    target: QuoteSubscriptionTarget;
+    refCount: number;
+    unsubscribe: (() => void) | null;
+    removeTimer: ReturnType<typeof setTimeout> | null;
+  }>();
+  private pendingQuoteSubscriptionKeys = new Set<string>();
 
   private readonly quoteStore = new QueryStore<Quote>((key) => this.bump(key));
   private readonly snapshotStore = new QueryStore<TickerFinancials>((key) => this.bump(key));
@@ -427,6 +435,63 @@ export class MarketDataCoordinator {
     return promise;
   }
 
+  private cachedFinancialsTargetFromInstrument(instrument: InstrumentRef): CachedFinancialsTarget {
+    return {
+      symbol: instrument.symbol,
+      exchange: instrument.exchange,
+      brokerId: instrument.brokerId,
+      brokerInstanceId: instrument.brokerInstanceId,
+      instrument: instrument.instrument ?? null,
+    };
+  }
+
+  private quoteTargetFromInstrument(instrument: InstrumentRef): QuoteSubscriptionTarget {
+    return {
+      symbol: instrument.symbol,
+      exchange: instrument.exchange ?? "",
+      context: toMarketDataContext(instrument),
+    };
+  }
+
+  private storeSnapshotData(
+    instrument: InstrumentRef,
+    data: TickerFinancials,
+    source: string,
+    attempts: ProviderAttempt[],
+  ): QueryEntry<TickerFinancials> {
+    const normalized = normalizeTickerFinancialsPriceHistory(data);
+    const snapshotKey = buildSnapshotKey(instrument);
+    const entry = this.snapshotStore.update(snapshotKey, (current) =>
+      readyEntry(current, normalized, source, attempts, { keepLastGoodOnEmpty: true })
+    );
+    if (normalized.quote) {
+      this.quoteStore.set(buildQuoteKey(instrument), readyEntry(this.getQuoteEntry(instrument), normalized.quote, normalized.quote.providerId ?? source, attempts));
+    }
+    this.profileStore.set(buildProfileKey(instrument), readyEntry(this.profileStore.get(buildProfileKey(instrument)), normalized.profile ?? null, source, attempts, { keepLastGoodOnEmpty: true }));
+    this.fundamentalsStore.set(buildFundamentalsKey(instrument), readyEntry(this.fundamentalsStore.get(buildFundamentalsKey(instrument)), normalized.fundamentals ?? null, source, attempts, { keepLastGoodOnEmpty: true }));
+    this.statementsStore.set(
+      buildStatementsKey(instrument),
+      readyEntry(
+        this.statementsStore.get(buildStatementsKey(instrument)),
+        {
+          annualStatements: normalized.annualStatements ?? [],
+          quarterlyStatements: normalized.quarterlyStatements ?? [],
+        },
+        source,
+        attempts,
+        { keepLastGoodOnEmpty: true },
+      ),
+    );
+    if ((normalized.priceHistory ?? []).length > 0) {
+      const chartRequest = createBaselineChartRequest(instrument);
+      this.chartStore.set(
+        buildChartKey(chartRequest),
+        readyEntry(this.getChartEntry(chartRequest), normalized.priceHistory, source, attempts, { keepLastGoodOnEmpty: true }),
+      );
+    }
+    return entry;
+  }
+
   private findChartSeedEntry(
     key: string,
     request: ChartRequest,
@@ -485,42 +550,17 @@ export class MarketDataCoordinator {
       const startedAt = Date.now();
       traceMarketData("snapshot:start", { key, symbol: instrument.symbol, exchange: instrument.exchange ?? "" });
       try {
-        const data = normalizeTickerFinancialsPriceHistory(await this.dataProvider.getTickerFinancials(
+        const data = await this.dataProvider.getTickerFinancials(
           instrument.symbol,
           instrument.exchange ?? "",
           {
             ...toMarketDataContext(instrument),
             cacheMode: options.forceRefresh ? "refresh" : "default",
           },
-        ));
+        );
         const source = data.quote?.providerId ?? this.dataProvider.id;
         const attempts = [createAttempt(source, startedAt, data ? "success" : "empty")];
-        const entry = this.snapshotStore.update(key, (current) => readyEntry(current, data, source, attempts, { keepLastGoodOnEmpty: true }));
-        if (data.quote) {
-          this.quoteStore.set(buildQuoteKey(instrument), readyEntry(this.getQuoteEntry(instrument), data.quote, data.quote.providerId ?? source, attempts));
-        }
-        this.profileStore.set(buildProfileKey(instrument), readyEntry(this.profileStore.get(buildProfileKey(instrument)), data.profile ?? null, source, attempts, { keepLastGoodOnEmpty: true }));
-        this.fundamentalsStore.set(buildFundamentalsKey(instrument), readyEntry(this.fundamentalsStore.get(buildFundamentalsKey(instrument)), data.fundamentals ?? null, source, attempts, { keepLastGoodOnEmpty: true }));
-        this.statementsStore.set(
-          buildStatementsKey(instrument),
-          readyEntry(
-            this.statementsStore.get(buildStatementsKey(instrument)),
-            {
-              annualStatements: data.annualStatements ?? [],
-              quarterlyStatements: data.quarterlyStatements ?? [],
-            },
-            source,
-            attempts,
-            { keepLastGoodOnEmpty: true },
-          ),
-        );
-        if ((data.priceHistory ?? []).length > 0) {
-          const chartRequest = createBaselineChartRequest(instrument);
-          this.chartStore.set(
-            buildChartKey(chartRequest),
-            readyEntry(this.getChartEntry(chartRequest), data.priceHistory, source, attempts, { keepLastGoodOnEmpty: true }),
-          );
-        }
+        const entry = this.storeSnapshotData(instrument, data, source, attempts);
         traceMarketData("snapshot:ready", {
           key,
           symbol: instrument.symbol,
@@ -538,6 +578,49 @@ export class MarketDataCoordinator {
     });
   }
 
+  async loadSnapshotsBatch(
+    instruments: InstrumentRef[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<QueryEntry<TickerFinancials>[]> {
+    const uniqueInstruments = [...new Map(instruments.map((instrument) => [buildSnapshotKey(instrument), instrument] as const)).values()];
+    const results = new Map<string, QueryEntry<TickerFinancials>>();
+    const misses: InstrumentRef[] = [];
+
+    for (const instrument of uniqueInstruments) {
+      const key = buildSnapshotKey(instrument);
+      const current = this.snapshotStore.get(key);
+      if (!options.forceRefresh && hasFreshEntryData(current, SNAPSHOT_CACHE_TTL_MS)) {
+        results.set(key, current);
+      } else {
+        misses.push(instrument);
+      }
+    }
+
+    if (misses.length > 0 && this.dataProvider.getTickerFinancialsBatch) {
+      const batchResults = await this.dataProvider.getTickerFinancialsBatch(
+        misses.map((instrument) => this.cachedFinancialsTargetFromInstrument(instrument)),
+        { forceRefresh: options.forceRefresh },
+      );
+      batchResults.forEach((item, index) => {
+        const instrument = misses[index];
+        if (!instrument) return;
+        const key = buildSnapshotKey(instrument);
+        if (!item.financials) return;
+        const source = item.financials.quote?.providerId ?? this.dataProvider.id;
+        const attempts = [createAttempt(source, Date.now(), "success")];
+        results.set(key, this.storeSnapshotData(instrument, item.financials, source, attempts));
+      });
+    }
+
+    await Promise.all(misses.map(async (instrument) => {
+      const key = buildSnapshotKey(instrument);
+      if (results.has(key)) return;
+      results.set(key, await this.loadSnapshot(instrument, options));
+    }));
+
+    return instruments.map((instrument) => results.get(buildSnapshotKey(instrument)) ?? this.getSnapshotEntry(instrument));
+  }
+
   async loadQuote(
     instrument: InstrumentRef,
     options: { forceRefresh?: boolean } = {},
@@ -567,6 +650,48 @@ export class MarketDataCoordinator {
     });
   }
 
+  async loadQuotesBatch(
+    instruments: InstrumentRef[],
+    options: { forceRefresh?: boolean } = {},
+  ): Promise<QueryEntry<Quote>[]> {
+    const uniqueInstruments = [...new Map(instruments.map((instrument) => [buildQuoteKey(instrument), instrument] as const)).values()];
+    const results = new Map<string, QueryEntry<Quote>>();
+    const misses: InstrumentRef[] = [];
+
+    for (const instrument of uniqueInstruments) {
+      const key = buildQuoteKey(instrument);
+      const current = this.quoteStore.get(key);
+      if (!options.forceRefresh && hasFreshEntryData(current, SNAPSHOT_CACHE_TTL_MS)) {
+        results.set(key, current);
+      } else {
+        misses.push(instrument);
+      }
+    }
+
+    if (misses.length > 0 && this.dataProvider.getQuotesBatch) {
+      const batchResults = await this.dataProvider.getQuotesBatch(
+        misses.map((instrument) => this.quoteTargetFromInstrument(instrument)),
+        { forceRefresh: options.forceRefresh },
+      );
+      batchResults.forEach((item, index) => {
+        const instrument = misses[index];
+        if (!instrument || !item.quote) return;
+        const key = buildQuoteKey(instrument);
+        const source = item.quote.providerId ?? this.dataProvider.id;
+        const attempts = [createAttempt(source, Date.now(), "success")];
+        results.set(key, this.quoteStore.update(key, (current) => readyQuoteEntry(current, item.quote!, source, attempts)));
+      });
+    }
+
+    await Promise.all(misses.map(async (instrument) => {
+      const key = buildQuoteKey(instrument);
+      if (results.has(key)) return;
+      results.set(key, await this.loadQuote(instrument, options));
+    }));
+
+    return instruments.map((instrument) => results.get(buildQuoteKey(instrument)) ?? this.getQuoteEntry(instrument));
+  }
+
   async loadChart(
     request: ChartRequest,
     options: { forceRefresh?: boolean } = {},
@@ -798,26 +923,71 @@ export class MarketDataCoordinator {
       return () => {};
     }
 
-    const normalizedTargets = targets.map(({ instrument }) => ({
-      symbol: instrument.symbol,
-      exchange: instrument.exchange ?? "",
-      context: toMarketDataContext(instrument),
-    }));
-
-    return this.dataProvider.subscribeQuotes(normalizedTargets, (target, quote) => {
-      const instrument: InstrumentRef = {
-        symbol: target.symbol,
-        exchange: target.exchange ?? "",
-        brokerId: target.context?.brokerId,
-        brokerInstanceId: target.context?.brokerInstanceId,
-        instrument: target.context?.instrument ?? null,
-      };
+    const subscribedKeys = new Set<string>();
+    for (const { instrument } of targets) {
       const key = buildQuoteKey(instrument);
-      const current = this.quoteStore.get(key);
-      if (areStreamQuotesEquivalent(current.data ?? current.lastGoodData, quote)) return;
-      const attempts = [createAttempt(quote.providerId ?? this.dataProvider.id, Date.now(), "success")];
-      this.quoteStore.set(key, readyQuoteEntry(current, quote, quote.providerId ?? this.dataProvider.id, attempts));
-    });
+      subscribedKeys.add(key);
+      const existing = this.quoteSubscriptions.get(key);
+      if (existing) {
+        existing.refCount += 1;
+        if (existing.removeTimer) {
+          clearTimeout(existing.removeTimer);
+          existing.removeTimer = null;
+        }
+        continue;
+      }
+      this.quoteSubscriptions.set(key, {
+        target: this.quoteTargetFromInstrument(instrument),
+        refCount: 1,
+        unsubscribe: null,
+        removeTimer: null,
+      });
+      this.pendingQuoteSubscriptionKeys.add(key);
+    }
+    this.flushQuoteSubscriptions();
+
+    return () => {
+      for (const key of subscribedKeys) {
+        const existing = this.quoteSubscriptions.get(key);
+        if (!existing) continue;
+        existing.refCount = Math.max(0, existing.refCount - 1);
+        if (existing.refCount > 0 || existing.removeTimer) continue;
+        existing.removeTimer = setTimeout(() => {
+          const current = this.quoteSubscriptions.get(key);
+          if (!current || current.refCount > 0) return;
+          current.unsubscribe?.();
+          this.quoteSubscriptions.delete(key);
+          this.pendingQuoteSubscriptionKeys.delete(key);
+        }, QUOTE_SUBSCRIPTION_REMOVE_GRACE_MS);
+      }
+    };
+  }
+
+  private flushQuoteSubscriptions(): void {
+    const keys = this.pendingQuoteSubscriptionKeys;
+    this.pendingQuoteSubscriptionKeys = new Set();
+    for (const key of keys) {
+      const entry = this.quoteSubscriptions.get(key);
+      if (!entry || entry.refCount === 0 || entry.unsubscribe) continue;
+      entry.unsubscribe = this.dataProvider.subscribeQuotes?.([entry.target], (target, quote) => {
+        const instrument: InstrumentRef = {
+          symbol: target.symbol,
+          exchange: target.exchange ?? "",
+          brokerId: target.context?.brokerId,
+          brokerInstanceId: target.context?.brokerInstanceId,
+          instrument: target.context?.instrument ?? null,
+        };
+        this.applyStreamQuote(instrument, quote);
+      }) ?? null;
+    }
+  }
+
+  private applyStreamQuote(instrument: InstrumentRef, quote: Quote): void {
+    const key = buildQuoteKey(instrument);
+    const current = this.quoteStore.get(key);
+    if (areStreamQuotesEquivalent(current.data ?? current.lastGoodData, quote)) return;
+    const attempts = [createAttempt(quote.providerId ?? this.dataProvider.id, Date.now(), "success")];
+    this.quoteStore.set(key, readyQuoteEntry(current, quote, quote.providerId ?? this.dataProvider.id, attempts));
   }
 }
 

package/src/news/aggregator.test.ts

@@ -6,7 +6,7 @@ import type { MarketNewsItem } from "../types/news-source";
 function makeItem(overrides: Partial<MarketNewsItem> & { url: string }): MarketNewsItem {
   return {
     ...overrides,
-    id: overrides.url,
+    id: overrides.id ?? overrides.url,
     title: "Test headline",
     url: overrides.url,
     source: "Test",
@@ -51,6 +51,17 @@ function makeCachedSource(id: string, cachedItems: MarketNewsItem[], fetchItems:
   });
 }
 
+function makeStorySource(id: string, items: MarketNewsItem[], story: MarketNewsItem): NewsCapability {
+  return newsProvider({
+    id,
+    name: id,
+    provider: {
+      fetchNews: mock(async () => items),
+      fetchNewsStory: mock(async (storyId: string) => storyId === story.id ? story : null),
+    },
+  });
+}
+
 describe("NewsService", () => {
   let agg: NewsService;
 
@@ -264,4 +275,41 @@ describe("NewsService", () => {
     expect(state.articles[0]!.url).toBe(fallbackItem.url);
     expect(state.sourceIds).toEqual(["fallback"]);
   });
+
+  it("loads story detail and merges source items into existing query state", async () => {
+    const listArticle = makeItem({
+      id: "story-1",
+      url: "https://detail.example.com/story",
+      items: [],
+    });
+    const detailArticle = makeItem({
+      ...listArticle,
+      items: [{
+        id: "item-2",
+        sourceKey: "wire-b",
+        sourceName: "Wire B",
+        title: "Follow-up",
+        url: "https://detail.example.com/follow-up",
+        publishedAt: new Date("2026-04-01T10:05:00.000Z"),
+      }, {
+        id: "item-1",
+        sourceKey: "wire-a",
+        sourceName: "Wire A",
+        title: "Original",
+        url: "https://detail.example.com/original",
+        publishedAt: new Date("2026-04-01T10:00:00.000Z"),
+      }],
+    });
+
+    agg.register(makeStorySource("cloud", [listArticle], detailArticle));
+
+    const initial = await agg.load({ feed: "top", limit: 10 });
+    expect(initial.articles[0]?.items).toEqual([]);
+
+    const detail = await agg.loadStory("story-1");
+    const state = agg.getQueryState({ feed: "top", limit: 10 });
+
+    expect(detail?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
+    expect(state.articles[0]?.items?.map((item) => item.id)).toEqual(["item-2", "item-1"]);
+  });
 });

package/src/news/aggregator.ts

@@ -120,6 +120,16 @@ function dedupeArticles(items: NewsArticle[]): NewsArticle[] {
   return sortByPublishedAt([...byKey.values()]).slice(0, MAX_ARTICLES);
 }
 
+function mergeNewsArticle(base: NewsArticle, detail: NewsArticle): NewsArticle {
+  const detailItems = detail.items ?? [];
+  const baseItems = base.items ?? [];
+  return {
+    ...base,
+    ...detail,
+    items: detailItems.length > 0 ? detailItems : baseItems,
+  };
+}
+
 function filterArticlesForQuery(items: NewsArticle[], query: NewsQuery): NewsArticle[] {
   let filtered = items;
   if (query.since) {
@@ -264,6 +274,24 @@ export class NewsService {
     return this.refreshQuery(normalizeQuery(query), true);
   }
 
+  async loadStory(storyId: string): Promise<NewsArticle | null> {
+    const sources = this.enabledSources({ feed: "latest" })
+      .filter((source) => !!source.provider.fetchNewsStory);
+
+    for (const source of sources) {
+      try {
+        const article = await source.provider.fetchNewsStory?.(storyId);
+        if (!article) continue;
+        this.mergeStoryDetail(article);
+        return article;
+      } catch {
+        // Continue to lower-priority sources.
+      }
+    }
+
+    return null;
+  }
+
   async poll(query: NewsQuery = DEFAULT_GLOBAL_QUERY): Promise<void> {
     await this.refreshQuery(normalizeQuery(query), false);
   }
@@ -413,6 +441,26 @@ export class NewsService {
     this.articles = dedupeArticles([...this.queryStates.values()].flatMap((state) => state.articles));
   }
 
+  private mergeStoryDetail(article: NewsArticle): void {
+    let changed = false;
+    for (const [key, state] of this.queryStates) {
+      let stateChanged = false;
+      const nextArticles = state.articles.map((existing) => {
+        if (existing.id !== article.id) return existing;
+        stateChanged = true;
+        changed = true;
+        return mergeNewsArticle(existing, article);
+      });
+      if (stateChanged) {
+        this.queryStates.set(key, { ...state, articles: nextArticles });
+      }
+    }
+
+    if (!changed) return;
+    this.rebuildArticlePool();
+    this.notify();
+  }
+
   getTopStories(count = 20): NewsArticle[] {
     return [...this.articles]
       .sort((a, b) => b.importance - a.importance)

package/src/news/hooks.ts

@@ -1,6 +1,6 @@
-import { useEffect, useSyncExternalStore } from "react";
+import { useCallback, useEffect, useSyncExternalStore } from "react";
 import { buildNewsQueryKey, type NewsService } from "./aggregator";
-import type { NewsQuery, NewsQueryState } from "./types";
+import type { NewsArticle, NewsQuery, NewsQueryState } from "./types";
 
 let sharedService: NewsService | null = null;
 
@@ -37,3 +37,7 @@ export function useNewsArticles(query: NewsQuery | null | undefined): NewsQueryS
 
   return query && sharedService ? sharedService.getQueryState(query) : idleState();
 }
+
+export function useLoadNewsStory(): (storyId: string) => Promise<NewsArticle | null> {
+  return useCallback(async (storyId: string) => sharedService?.loadStory(storyId) ?? null, []);
+}

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

@@ -759,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;
     }
@@ -917,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/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();
@@ -98,6 +106,7 @@ afterEach(() => {
   apiClient.connectChannel = originalConnectChannel;
   apiClient.getSession = originalGetSession;
   apiClient.getMessages = originalGetMessages;
+  apiClient.getChannels = originalGetChannels;
 });
 
 describe("ChatController", () => {
@@ -141,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();
@@ -412,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();