gloomberb 0.2.0 → 0.3.2

package/src/plugins/builtin/ai/settings.ts

@@ -0,0 +1,79 @@
+import { DEFAULT_COLUMNS, type ColumnConfig } from "../../../types/config";
+import type { PaneSettingsDef } from "../../../types/plugin";
+
+export interface AiScreenerPaneSettings {
+  columnIds: string[];
+}
+
+export const AI_REASON_COLUMN: ColumnConfig = {
+  id: "reason",
+  label: "REASON",
+  width: 34,
+  align: "left",
+};
+
+export const AI_SCREENER_COLUMN_DEFS: ColumnConfig[] = [
+  ...DEFAULT_COLUMNS,
+  { id: "bid", label: "BID", width: 10, align: "right", format: "currency" },
+  { id: "ask", label: "ASK", width: 10, align: "right", format: "currency" },
+  { id: "spread", label: "SPREAD", width: 10, align: "right", format: "currency" },
+  { id: "change", label: "CHG", width: 9, align: "right", format: "currency" },
+  { id: "ext_hours", label: "EXT%", width: 8, align: "right", format: "percent" },
+  { id: "dividend_yield", label: "DIV%", width: 7, align: "right", format: "percent" },
+  AI_REASON_COLUMN,
+];
+
+export const DEFAULT_AI_SCREENER_COLUMN_IDS = [
+  "ticker",
+  "price",
+  "change_pct",
+  "market_cap",
+  "reason",
+];
+
+const AI_SCREENER_COLUMNS_BY_ID = new Map(AI_SCREENER_COLUMN_DEFS.map((column) => [column.id, column]));
+
+export function getAiScreenerPaneSettings(settings: Record<string, unknown> | undefined): AiScreenerPaneSettings {
+  const columnIds = Array.isArray(settings?.columnIds)
+    ? settings.columnIds.filter((value): value is string => typeof value === "string")
+    : DEFAULT_AI_SCREENER_COLUMN_IDS;
+
+  return {
+    columnIds: columnIds.length > 0 ? columnIds : DEFAULT_AI_SCREENER_COLUMN_IDS,
+  };
+}
+
+export function resolveVisibleAiScreenerColumns(columnIds: string[]): ColumnConfig[] {
+  const resolved = columnIds
+    .map((columnId) => AI_SCREENER_COLUMNS_BY_ID.get(columnId))
+    .filter((column): column is ColumnConfig => column != null);
+
+  if (resolved.length > 0) {
+    return resolved;
+  }
+
+  return DEFAULT_AI_SCREENER_COLUMN_IDS
+    .map((columnId) => AI_SCREENER_COLUMNS_BY_ID.get(columnId))
+    .filter((column): column is ColumnConfig => column != null);
+}
+
+export function buildAiScreenerPaneSettingsDef(settings: AiScreenerPaneSettings): PaneSettingsDef {
+  return {
+    title: "AI Screener Settings",
+    fields: [
+      {
+        key: "columnIds",
+        label: "Columns",
+        description: "Choose which columns this screener shows and in what order.",
+        type: "ordered-multi-select",
+        options: AI_SCREENER_COLUMN_DEFS.map((column) => ({
+          value: column.id,
+          label: column.label,
+          description: column.id === "reason"
+            ? "The AI explanation for why the ticker matched the prompt."
+            : "Standard watchlist column.",
+        })),
+      },
+    ],
+  };
+}

package/src/plugins/builtin/ai/ticker-context.ts

@@ -0,0 +1,64 @@
+import { convertCurrency, formatCompact, formatCompactCurrency, formatCurrency, formatPercent } from "../../../utils/format";
+import type { TickerFinancials } from "../../../types/financials";
+import type { TickerRecord } from "../../../types/ticker";
+
+export function buildTickerAiContext(
+  ticker: TickerRecord,
+  financials: TickerFinancials | null,
+  baseCurrency: string,
+  exchangeRates: Map<string, number>,
+): string {
+  const metadata = ticker.metadata;
+  const quote = financials?.quote;
+  const fundamentals = financials?.fundamentals;
+  const profile = financials?.profile;
+  const quoteCurrency = quote?.currency ?? metadata.currency ?? baseCurrency;
+  const toBase = (value: number, fromCurrency: string) =>
+    convertCurrency(value, fromCurrency, baseCurrency, exchangeRates);
+  const sector = metadata.sector ?? profile?.sector;
+  const industry = metadata.industry ?? profile?.industry;
+
+  const lines: string[] = [
+    `Company: ${metadata.name} (${metadata.ticker})`,
+    `Exchange: ${metadata.exchange}`,
+  ];
+
+  if (sector) lines.push(`Sector: ${sector}`);
+  if (industry) lines.push(`Industry: ${industry}`);
+  if (profile?.description) lines.push(`Description: ${profile.description}`);
+
+  if (quote) {
+    lines.push(`Current Price: ${formatCurrency(quote.price, quote.currency)} (${quote.change >= 0 ? "+" : ""}${quote.changePercent.toFixed(2)}%)`);
+    if (quote.marketCap) lines.push(`Market Cap: ${formatCompactCurrency(toBase(quote.marketCap, quoteCurrency), baseCurrency)}`);
+    if (quote.high52w && quote.low52w) lines.push(`52W Range: ${formatCurrency(quote.low52w, quote.currency)} - ${formatCurrency(quote.high52w, quote.currency)}`);
+  }
+
+  if (fundamentals) {
+    if (fundamentals.trailingPE) lines.push(`P/E (TTM): ${fundamentals.trailingPE.toFixed(1)}`);
+    if (fundamentals.forwardPE) lines.push(`Forward P/E: ${fundamentals.forwardPE.toFixed(1)}`);
+    if (fundamentals.pegRatio) lines.push(`PEG: ${fundamentals.pegRatio.toFixed(2)}`);
+    if (fundamentals.revenue) lines.push(`Revenue: ${formatCompact(fundamentals.revenue)}`);
+    if (fundamentals.netIncome) lines.push(`Net Income: ${formatCompact(fundamentals.netIncome)}`);
+    if (fundamentals.eps) lines.push(`EPS: ${formatCurrency(fundamentals.eps)}`);
+    if (fundamentals.operatingMargin != null) lines.push(`Operating Margin: ${formatPercent(fundamentals.operatingMargin)}`);
+    if (fundamentals.profitMargin != null) lines.push(`Profit Margin: ${formatPercent(fundamentals.profitMargin)}`);
+    if (fundamentals.freeCashFlow) lines.push(`Free Cash Flow: ${formatCompact(fundamentals.freeCashFlow)}`);
+    if (fundamentals.dividendYield != null) lines.push(`Dividend Yield: ${formatPercent(fundamentals.dividendYield)}`);
+    if (fundamentals.return1Y != null) lines.push(`1Y Return: ${formatPercent(fundamentals.return1Y)}`);
+  }
+
+  if (financials?.annualStatements && financials.annualStatements.length > 0) {
+    const latest = financials.annualStatements[financials.annualStatements.length - 1]!;
+    lines.push("");
+    lines.push(`Latest Annual Statement (${latest.date}):`);
+    if (latest.totalRevenue) lines.push(`  Revenue: ${formatCompact(latest.totalRevenue)}`);
+    if (latest.netIncome) lines.push(`  Net Income: ${formatCompact(latest.netIncome)}`);
+    if (latest.operatingCashFlow) lines.push(`  Operating CF: ${formatCompact(latest.operatingCashFlow)}`);
+    if (latest.freeCashFlow) lines.push(`  Free Cash Flow: ${formatCompact(latest.freeCashFlow)}`);
+    if (latest.totalAssets) lines.push(`  Total Assets: ${formatCompact(latest.totalAssets)}`);
+    if (latest.totalDebt) lines.push(`  Total Debt: ${formatCompact(latest.totalDebt)}`);
+    if (latest.totalEquity) lines.push(`  Equity: ${formatCompact(latest.totalEquity)}`);
+  }
+
+  return lines.join("\n");
+}

package/src/plugins/builtin/ai/utils.ts

@@ -0,0 +1,71 @@
+export function truncateWithEllipsis(text: string, width: number): string {
+  if (width <= 0) return "";
+  if (text.length <= width) return text;
+  if (width <= 3) return text.slice(0, width);
+  return `${text.slice(0, width - 3)}...`;
+}
+
+export function wrapTextLines(text: string, width: number, maxLines = Number.MAX_SAFE_INTEGER): string[] {
+  if (width <= 0) return [];
+
+  const paragraphs = text
+    .split(/\r?\n/)
+    .map((paragraph) => paragraph.replace(/\s+/g, " ").trim());
+  const lines: string[] = [];
+
+  const pushLine = (line: string) => {
+    if (lines.length >= maxLines) return;
+    lines.push(line);
+  };
+
+  for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex += 1) {
+    const paragraph = paragraphs[paragraphIndex]!;
+    if (!paragraph) {
+      pushLine("");
+      continue;
+    }
+
+    let current = "";
+    for (const rawWord of paragraph.split(" ")) {
+      let word = rawWord;
+      while (word.length > width) {
+        const available = current ? width - current.length - 1 : width;
+        if (available <= 0) {
+          pushLine(current);
+          current = "";
+          continue;
+        }
+        if (word.length <= available) break;
+        const piece = word.slice(0, available);
+        word = word.slice(available);
+        pushLine(current ? `${current} ${piece}` : piece);
+        current = "";
+      }
+
+      if (!current) {
+        current = word;
+        continue;
+      }
+
+      if ((current.length + 1 + word.length) <= width) {
+        current = `${current} ${word}`;
+      } else {
+        pushLine(current);
+        current = word;
+      }
+    }
+
+    if (current) pushLine(current);
+    if (paragraphIndex < (paragraphs.length - 1)) pushLine("");
+    if (lines.length >= maxLines) break;
+  }
+
+  if (lines.length > maxLines) {
+    lines.length = maxLines;
+  }
+  if (lines.length === maxLines && paragraphs.join(" ").length > lines.join(" ").length) {
+    lines[maxLines - 1] = truncateWithEllipsis(lines[maxLines - 1] ?? "", width);
+  }
+
+  return lines;
+}

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

@@ -0,0 +1,258 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "@opentui/react/test-utils";
+import { AppContext, PaneInstanceProvider, createInitialState } from "../../state/app-context";
+import { createDefaultConfig } from "../../types/config";
+import { PluginRenderProvider, type PluginRuntimeAccess } from "../plugin-runtime";
+import { setSharedDataProviderForTests, setSharedRegistryForTests } from "../registry";
+import { AskAiTab, __resetAskAiHistoryForTests, __setAskAiHistoryForTests, __setDetectedProvidersForTests, type AiProvider } from "./ask-ai";
+import type { TickerRecord } from "../../types/ticker";
+
+const PANE_ID = "ticker-detail:main";
+
+let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+function makeRuntime(): PluginRuntimeAccess {
+  const resumeState = new Map<string, unknown>();
+  const listeners = new Map<string, Set<() => void>>();
+
+  return {
+    subscribeResumeState(pluginId, key, listener) {
+      const storeKey = `${pluginId}:${key}`;
+      if (!listeners.has(storeKey)) listeners.set(storeKey, new Set());
+      listeners.get(storeKey)!.add(listener);
+      return () => listeners.get(storeKey)?.delete(listener);
+    },
+    getResumeState(pluginId, key) {
+      return (resumeState.get(`${pluginId}:${key}`) as any) ?? null;
+    },
+    setResumeState(pluginId, key, value) {
+      const storeKey = `${pluginId}:${key}`;
+      resumeState.set(storeKey, value);
+      for (const listener of listeners.get(storeKey) ?? []) listener();
+    },
+    deleteResumeState(pluginId, key) {
+      const storeKey = `${pluginId}:${key}`;
+      resumeState.delete(storeKey);
+      for (const listener of listeners.get(storeKey) ?? []) listener();
+    },
+    getConfigState() {
+      return null;
+    },
+    async setConfigState() {},
+    async deleteConfigState() {},
+    getConfigStateKeys() {
+      return [];
+    },
+  };
+}
+
+function makeTicker(symbol: string, name = symbol): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange: "NASDAQ",
+      currency: "USD",
+      name,
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+function createAskAiHarness(
+  width = 60,
+  height = 12,
+  onCapture: (capturing: boolean) => void = () => {},
+) {
+  const config = createDefaultConfig("/tmp/gloomberb-ai");
+  config.layout.instances = config.layout.instances.map((instance) => (
+    instance.instanceId === PANE_ID
+      ? { ...instance, binding: { kind: "fixed" as const, symbol: "AAPL" } }
+      : instance
+  ));
+
+  const state = createInitialState(config);
+  state.focusedPaneId = PANE_ID;
+  state.tickers = new Map([["AAPL", makeTicker("AAPL", "Apple Inc.")]]);
+  state.financials = new Map([["AAPL", {
+    annualStatements: [],
+    quarterlyStatements: [],
+    priceHistory: [],
+    quote: {
+      symbol: "AAPL",
+      price: 210,
+      currency: "USD",
+      change: 6.3,
+      changePercent: 3,
+      lastUpdated: Date.now(),
+    },
+  }]]);
+
+  return (
+    <AppContext value={{ state, dispatch: () => {} }}>
+      <PaneInstanceProvider paneId={PANE_ID}>
+        <PluginRenderProvider pluginId="ai" runtime={makeRuntime()}>
+          <AskAiTab width={width} height={height} focused onCapture={onCapture} />
+        </PluginRenderProvider>
+      </PaneInstanceProvider>
+    </AppContext>
+  );
+}
+
+async function flushFrame() {
+  await act(async () => {
+    await testSetup!.renderOnce();
+    await testSetup!.renderOnce();
+  });
+}
+
+function setProviders(providers: AiProvider[]) {
+  __setDetectedProvidersForTests(providers);
+}
+
+afterEach(() => {
+  __setDetectedProvidersForTests(null);
+  __resetAskAiHistoryForTests();
+  setSharedRegistryForTests(undefined);
+  setSharedDataProviderForTests(undefined);
+  if (testSetup) {
+    testSetup.renderer.destroy();
+    testSetup = undefined;
+  }
+});
+
+describe("AskAiTab", () => {
+  test("lists Claude, Gemini, and Codex when no AI CLIs are detected", async () => {
+    setProviders([]);
+
+    await act(async () => {
+      testSetup = await testRender(
+        createAskAiHarness(60, 12),
+        { width: 60, height: 12 },
+      );
+    });
+
+    await flushFrame();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("No AI CLI tools detected.");
+    expect(frame).toContain("claude");
+    expect(frame).toContain("gemini");
+    expect(frame).toContain("codex");
+  });
+
+  test("keeps the provider header readable in a narrow pane", async () => {
+    setProviders([
+      { id: "claude", name: "Claude", command: "claude", available: true, buildArgs: () => [] },
+      { id: "gemini", name: "Gemini", command: "gemini", available: true, buildArgs: () => [] },
+    ]);
+
+    await act(async () => {
+      testSetup = await testRender(
+        createAskAiHarness(24, 12),
+        { width: 24, height: 12 },
+      );
+    });
+
+    await flushFrame();
+
+    const headerLine = testSetup.captureCharFrame().split("\n").find((line) => line.includes("Ask AI")) ?? "";
+    expect(headerLine).toContain("Ask AI");
+    expect(headerLine).toContain("Claude (t)");
+    expect(headerLine).not.toContain("t to switch");
+  });
+
+  test("focuses the input when the prompt row is clicked", async () => {
+    setProviders([
+      { id: "claude", name: "Claude", command: "claude", available: true, buildArgs: () => [] },
+    ]);
+
+    await act(async () => {
+      testSetup = await testRender(createAskAiHarness(60, 12), {
+        width: 60,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    const frameBeforeClick = testSetup.captureCharFrame().split("\n");
+    const inputRow = frameBeforeClick.findIndex((line) => line.includes("Enter to start typing"));
+    const inputCol = frameBeforeClick[inputRow]?.indexOf("Enter to start typing") ?? -1;
+
+    expect(inputRow).toBeGreaterThanOrEqual(0);
+    expect(inputCol).toBeGreaterThanOrEqual(0);
+
+    let focusedByClick = false;
+    for (const row of [inputRow, inputRow + 1]) {
+      for (const col of [inputCol + 1, inputCol + 2]) {
+        await act(async () => {
+          await testSetup!.mockMouse.click(col, row);
+          await testSetup!.renderOnce();
+          await testSetup!.renderOnce();
+        });
+        if (testSetup.captureCharFrame().includes("Ask a question...")) {
+          focusedByClick = true;
+          break;
+        }
+      }
+      if (focusedByClick) break;
+    }
+
+    expect(focusedByClick).toBe(true);
+
+    await act(async () => {
+      await testSetup!.mockInput.typeText("DCF");
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    const frameAfterType = testSetup.captureCharFrame();
+    expect(frameAfterType).toContain("> DCF");
+  });
+
+  test("renders assistant ticker badges and opens a floating detail pane on click", async () => {
+    setProviders([
+      { id: "claude", name: "Claude", command: "claude", available: true, buildArgs: () => [] },
+    ]);
+
+    const opened: string[] = [];
+    setSharedRegistryForTests({
+      pinTickerFn(symbol: string) {
+        opened.push(symbol);
+      },
+    } as any);
+
+    __setAskAiHistoryForTests("AAPL", [
+      { role: "assistant", content: "Watch $AAPL here.", loading: false },
+    ]);
+
+    await act(async () => {
+      testSetup = await testRender(createAskAiHarness(60, 12), {
+        width: 60,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    const lines = testSetup.captureCharFrame().split("\n");
+    const row = lines.findIndex((line) => line.includes("AAPL +3%"));
+    const col = lines[row]?.indexOf("AAPL +3%") ?? -1;
+
+    expect(row).toBeGreaterThanOrEqual(0);
+    expect(col).toBeGreaterThanOrEqual(0);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(col + 1, row);
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(opened).toEqual(["AAPL"]);
+  });
+});

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

@@ -0,0 +1,9 @@
+export {
+  AskAiDetailTab as AskAiTab,
+  __resetAskAiHistoryForTests,
+  __setAskAiHistoryForTests,
+  __setDetectedProvidersForTests,
+  type AiProvider,
+} from "./ai/ask-ai-detail-tab";
+
+export { aiPlugin as askAiPlugin } from "./ai/index";

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

@@ -0,0 +1,217 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { PluginPersistence } from "../../types/plugin";
+import type { PersistedResourceValue } from "../../types/persistence";
+import { apiClient, type ChatMessage } from "../../utils/api-client";
+import { ChatController } from "./chat-controller";
+
+const TRANSCRIPT_KIND = "channel-transcript";
+const TRANSCRIPT_KEY = "everyone";
+const TRANSCRIPT_SOURCE = "server";
+const originalGetSession = apiClient.getSession.bind(apiClient);
+
+class MemoryPersistence implements PluginPersistence {
+  private readonly state = new Map<string, { schemaVersion: number; value: unknown }>();
+  private readonly resources = new Map<string, PersistedResourceValue<unknown>>();
+
+  getState<T = unknown>(key: string, options?: { schemaVersion?: number }): T | null {
+    const record = this.state.get(key);
+    if (!record) return null;
+    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) {
+      this.state.delete(key);
+      return null;
+    }
+    return record.value as T;
+  }
+
+  setState(key: string, value: unknown, options?: { schemaVersion?: number }): void {
+    this.state.set(key, { schemaVersion: options?.schemaVersion ?? 1, value });
+  }
+
+  deleteState(key: string): void {
+    this.state.delete(key);
+  }
+
+  getResource<T = unknown>(
+    kind: string,
+    key: string,
+    options?: { sourceKey?: string; schemaVersion?: number; allowExpired?: boolean },
+  ): PersistedResourceValue<T> | null {
+    const record = this.resources.get(`${kind}:${key}:${options?.sourceKey ?? ""}`);
+    if (!record) return null;
+    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) {
+      this.resources.delete(`${kind}:${key}:${options.sourceKey ?? ""}`);
+      return null;
+    }
+    return record as PersistedResourceValue<T>;
+  }
+
+  setResource<T = unknown>(
+    kind: string,
+    key: string,
+    value: T,
+    options: {
+      cachePolicy: { staleMs: number; expireMs: number };
+      sourceKey?: string;
+      schemaVersion?: number;
+      provenance?: unknown;
+    },
+  ): PersistedResourceValue<T> {
+    const now = Date.now();
+    const record: PersistedResourceValue<T> = {
+      value,
+      fetchedAt: now,
+      staleAt: now + options.cachePolicy.staleMs,
+      expiresAt: now + options.cachePolicy.expireMs,
+      sourceKey: options.sourceKey ?? "",
+      schemaVersion: options.schemaVersion ?? 1,
+      provenance: options.provenance,
+    };
+    this.resources.set(`${kind}:${key}:${options.sourceKey ?? ""}`, record);
+    return record;
+  }
+
+  deleteResource(kind: string, key: string, options?: { sourceKey?: string }): void {
+    this.resources.delete(`${kind}:${key}:${options?.sourceKey ?? ""}`);
+  }
+}
+
+afterEach(() => {
+  apiClient.setSessionToken(null);
+  apiClient.getSession = originalGetSession;
+});
+
+describe("ChatController", () => {
+  test("hydrates cached session, draft, and transcript from plugin persistence", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const message: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "hello",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince" },
+    }, { schemaVersion: 1 });
+    persistence.setState("channel:everyone", {
+      draft: "cached draft",
+      replyToId: "m1",
+      lastCursor: "2026-03-28T00:00:00.000Z",
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [message],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: 1,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+
+    const snapshot = controller.getSnapshot();
+    expect(apiClient.getSessionToken()).toBe("token-123");
+    expect(snapshot.user?.username).toBe("vince");
+    expect(snapshot.draft).toBe("cached draft");
+    expect(snapshot.replyToId).toBe("m1");
+    expect(snapshot.messages.map((entry) => entry.id)).toEqual(["m1"]);
+  });
+
+  test("hydrates a cached verified user into the api client for offline use", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.attachPersistence(persistence);
+
+    expect(apiClient.getCurrentUser()).toMatchObject({
+      id: "u1",
+      username: "vince",
+      emailVerified: true,
+    });
+    await expect(apiClient.ensureVerifiedSession()).resolves.toMatchObject({
+      id: "u1",
+      username: "vince",
+      emailVerified: true,
+    });
+  });
+
+  test("reset clears persisted chat state and session token", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince" },
+    }, { schemaVersion: 1 });
+    persistence.setState("channel:everyone", {
+      draft: "cached draft",
+      replyToId: null,
+      lastCursor: null,
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: 1,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+    controller.reset(true);
+
+    expect(apiClient.getSessionToken()).toBeNull();
+    expect(persistence.getState("session", { schemaVersion: 1 })).toBeNull();
+    expect(persistence.getResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, { sourceKey: TRANSCRIPT_SOURCE, schemaVersion: 1 })).toBeNull();
+  });
+
+  test("pauses verification polling while the app is backgrounded", () => {
+    const controller = new ChatController();
+
+    apiClient.setSessionToken("token-123");
+    (controller as any).user = { id: "u1", username: "vince", emailVerified: false };
+
+    controller.setAppActive(false);
+    (controller as any).syncVerificationPolling();
+    expect((controller as any).verificationPollTimer).toBeNull();
+
+    controller.setAppActive(true);
+    expect((controller as any).verificationPollTimer).not.toBeNull();
+
+    controller.reset(true);
+  });
+
+  test("keeps the cached session when session refresh fails transiently", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.attachPersistence(persistence);
+    apiClient.getSession = async () => {
+      throw new Error("network down");
+    };
+
+    await expect(controller.refreshSession()).rejects.toThrow("network down");
+    expect(apiClient.getSessionToken()).toBe("token-123");
+    expect(persistence.getState("session", { schemaVersion: 1 })).toEqual({
+      sessionToken: "token-123",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    });
+    expect(controller.getSnapshot().user).toEqual({
+      id: "u1",
+      username: "vince",
+      emailVerified: true,
+    });
+  });
+});