gloomberb 0.5.0 → 0.6.0

package/src/plugins/builtin/broker-manager/model.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import type { BrokerAdapter } from "../../../types/broker";
+import { createDefaultConfig, type BrokerInstanceConfig } from "../../../types/config";
+import { ibkrBroker } from "../../ibkr/broker-adapter";
+import { buildBrokerProfileRows, formatBrokerUpdatedAt } from "./model";
+
+function createInstance(patch: Partial<BrokerInstanceConfig> = {}): BrokerInstanceConfig {
+  return {
+    id: "demo-live",
+    brokerType: "demo",
+    label: "Demo Live",
+    connectionMode: "gateway",
+    config: { connectionMode: "gateway" },
+    enabled: true,
+    ...patch,
+  };
+}
+
+function createAdapter(state: "connected" | "error" = "connected"): BrokerAdapter {
+  return {
+    id: "demo",
+    name: "Demo Broker",
+    configSchema: [],
+    validate: async () => true,
+    importPositions: async () => [],
+    getStatus: () => ({ state, updatedAt: 1_000_000, message: state === "error" ? "No route" : "Ready" }),
+  };
+}
+
+describe("broker manager rows", () => {
+  test("derives live status and account summary", () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-broker-manager"),
+      brokerInstances: [createInstance()],
+    };
+    const rows = buildBrokerProfileRows(
+      config,
+      new Map([["demo", createAdapter()]]),
+      {
+        "demo-live": [
+          { accountId: "DU1", name: "DU1", currency: "USD", netLiquidation: 100 },
+          { accountId: "DU2", name: "DU2", currency: "USD", netLiquidation: 50 },
+        ],
+      },
+    );
+
+    expect(rows[0]).toMatchObject({
+      id: "demo-live",
+      brokerName: "Demo Broker",
+      state: "connected",
+      stateLabel: "Connected",
+      accountSummary: "$150.00",
+    });
+  });
+
+  test("handles disabled and unavailable profiles before adapter status", () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-broker-manager"),
+      brokerInstances: [
+        createInstance({ id: "disabled", enabled: false }),
+        createInstance({ id: "missing", brokerType: "missing" }),
+      ],
+    };
+    const rows = buildBrokerProfileRows(config, new Map([["demo", createAdapter("error")]]), {});
+
+    expect(rows.map((row) => row.state)).toEqual(["disabled", "unavailable"]);
+  });
+
+  test("labels Flex profiles as sync-only", () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-broker-manager"),
+      brokerInstances: [createInstance({ id: "flex", connectionMode: "flex", config: { connectionMode: "flex" } })],
+    };
+    const rows = buildBrokerProfileRows(config, new Map([["demo", createAdapter()]]), {});
+
+    expect(rows[0]?.mode).toBe("Flex");
+    expect(rows[0]?.stateLabel).toBe("Sync only");
+  });
+
+  test("keeps real IBKR Flex profiles out of gateway status", () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-broker-manager"),
+      brokerInstances: [{
+        id: "ibkr-flex",
+        brokerType: "ibkr",
+        label: "IBKR Flex",
+        connectionMode: "flex",
+        config: {
+          connectionMode: "flex",
+          flex: { token: "token", queryId: "123", endpoint: "" },
+          gateway: { host: "127.0.0.1" },
+        },
+        enabled: true,
+      }],
+    };
+    const rows = buildBrokerProfileRows(config, new Map([["ibkr", ibkrBroker]]), {});
+
+    expect(rows[0]?.mode).toBe("Flex");
+    expect(rows[0]?.stateLabel).toBe("Sync only");
+  });
+
+  test("formats relative status timestamps", () => {
+    expect(formatBrokerUpdatedAt(undefined, 10_000)).toBe("never");
+    expect(formatBrokerUpdatedAt(9_000, 10_000)).toBe("just now");
+    expect(formatBrokerUpdatedAt(10_000 - 5 * 60_000, 10_000)).toBe("5m ago");
+  });
+});

package/src/plugins/builtin/broker-manager/model.ts

@@ -0,0 +1,142 @@
+import type { BrokerAdapter, BrokerConnectionStatus } from "../../../types/broker";
+import type { AppConfig, BrokerInstanceConfig } from "../../../types/config";
+import type { BrokerAccount } from "../../../types/trading";
+import { formatCurrency } from "../../../utils/format";
+
+export type BrokerDisplayState =
+  | "disabled"
+  | "unavailable"
+  | "configured"
+  | BrokerConnectionStatus["state"];
+
+export interface BrokerProfileRow {
+  id: string;
+  label: string;
+  brokerType: string;
+  brokerName: string;
+  mode: string;
+  state: BrokerDisplayState;
+  stateLabel: string;
+  message: string;
+  updatedAt: number;
+  accountCount: number;
+  accountSummary: string;
+  accountIds: string[];
+  instance: BrokerInstanceConfig;
+  adapter: BrokerAdapter | null;
+}
+
+function titleCase(value: string): string {
+  return value
+    .split(/[\s_-]+/g)
+    .filter(Boolean)
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join(" ");
+}
+
+export function formatBrokerMode(value: unknown): string {
+  const text = typeof value === "string" ? value.trim() : "";
+  return text ? titleCase(text) : "Configured";
+}
+
+export function formatBrokerUpdatedAt(updatedAt: number | undefined, now = Date.now()): string {
+  if (!updatedAt) return "never";
+  const ageMs = Math.max(0, now - updatedAt);
+  if (ageMs < 60_000) return "just now";
+  if (ageMs < 60 * 60_000) return `${Math.floor(ageMs / 60_000)}m ago`;
+  if (ageMs < 24 * 60 * 60_000) return `${Math.floor(ageMs / (60 * 60_000))}h ago`;
+  return `${Math.floor(ageMs / (24 * 60 * 60_000))}d ago`;
+}
+
+export function summarizeBrokerAccounts(accounts: BrokerAccount[]): string {
+  if (accounts.length === 0) return "0 acct";
+  const currencies = new Set(accounts.map((account) => account.currency || "USD"));
+  const canSum = currencies.size === 1 && accounts.every((account) => typeof account.netLiquidation === "number");
+  if (!canSum) return `${accounts.length} acct${accounts.length === 1 ? "" : "s"}`;
+  const currency = currencies.values().next().value ?? "USD";
+  const total = accounts.reduce((sum, account) => sum + (account.netLiquidation ?? 0), 0);
+  return formatCurrency(total, currency);
+}
+
+function resolveMode(
+  adapter: BrokerAdapter | null,
+  instance: BrokerInstanceConfig,
+  status: BrokerConnectionStatus | null,
+): string {
+  const values = adapter?.toConfigValues?.(instance) ?? instance.config;
+  return formatBrokerMode(
+    status?.mode
+      ?? values.connectionMode
+      ?? instance.connectionMode
+      ?? instance.config.connectionMode,
+  );
+}
+
+function resolveState(
+  instance: BrokerInstanceConfig,
+  adapter: BrokerAdapter | null,
+  mode: string,
+  status: BrokerConnectionStatus | null,
+): { state: BrokerDisplayState; label: string; message: string; updatedAt: number } {
+  if (instance.enabled === false) {
+    return { state: "disabled", label: "Disabled", message: "Profile is disabled", updatedAt: 0 };
+  }
+  if (!adapter) {
+    return { state: "unavailable", label: "Unavailable", message: "Broker plugin is not available", updatedAt: 0 };
+  }
+  if (mode.toLowerCase() === "flex") {
+    return {
+      state: "configured",
+      label: "Sync only",
+      message: "Flex profiles sync on demand",
+      updatedAt: status?.updatedAt ?? 0,
+    };
+  }
+  if (!status) {
+    return { state: "configured", label: "Configured", message: "Ready to test or sync", updatedAt: 0 };
+  }
+
+  const labels: Record<BrokerConnectionStatus["state"], string> = {
+    disconnected: "Disconnected",
+    connecting: "Connecting",
+    connected: "Connected",
+    error: "Error",
+  };
+  return {
+    state: status.state,
+    label: labels[status.state],
+    message: status.message || "",
+    updatedAt: status.updatedAt,
+  };
+}
+
+export function buildBrokerProfileRows(
+  config: AppConfig,
+  adapters: ReadonlyMap<string, BrokerAdapter | null>,
+  brokerAccounts: Record<string, BrokerAccount[]>,
+): BrokerProfileRow[] {
+  return config.brokerInstances.map((instance) => {
+    const adapter = adapters.get(instance.brokerType) ?? null;
+    const status = adapter?.getStatus?.(instance) ?? null;
+    const mode = resolveMode(adapter, instance, status);
+    const state = resolveState(instance, adapter, mode, status);
+    const accounts = brokerAccounts[instance.id] ?? [];
+
+    return {
+      id: instance.id,
+      label: instance.label,
+      brokerType: instance.brokerType,
+      brokerName: adapter?.name ?? instance.brokerType.toUpperCase(),
+      mode,
+      state: state.state,
+      stateLabel: state.label,
+      message: state.message,
+      updatedAt: state.updatedAt,
+      accountCount: accounts.length,
+      accountSummary: summarizeBrokerAccounts(accounts),
+      accountIds: accounts.map((account) => account.accountId),
+      instance,
+      adapter,
+    };
+  });
+}

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

@@ -155,6 +155,27 @@ describe("ChatController", () => {
     });
   });
 
+  test("does not restore persisted websocket tokens", () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+
+    persistence.setState("session", {
+      sessionToken: "token-123",
+      websocketToken: "stale-ws-token",
+      user: { id: "u1", username: "vince", emailVerified: true },
+    }, { schemaVersion: 1 });
+
+    controller.attachPersistence(persistence);
+
+    expect(apiClient.getSessionToken()).toBe("token-123");
+    expect(apiClient.getWebSocketToken()).toBeNull();
+    expect(apiClient.getCurrentUser()).toMatchObject({
+      id: "u1",
+      username: "vince",
+      emailVerified: true,
+    });
+  });
+
   test("reset clears persisted chat state and session token", () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -340,6 +361,60 @@ describe("ChatController", () => {
     });
   });
 
+  test("backfills from cached transcript when persisted cursor is ahead of the cache", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const cached: ChatMessage = {
+      id: "m1",
+      channelId: "everyone",
+      content: "cached",
+      replyToId: null,
+      createdAt: "2026-03-28T00:00:00.000Z",
+      user: { id: "u1", username: "vince", displayName: "Vince" },
+    };
+    const fresh: ChatMessage = {
+      id: "m2",
+      channelId: "everyone",
+      content: "fresh",
+      replyToId: null,
+      createdAt: "2026-03-28T00:01:00.000Z",
+      user: { id: "u2", username: "bob", displayName: "Bob" },
+    };
+
+    persistence.setState("channel:everyone", {
+      draft: "",
+      replyToId: null,
+      lastCursor: "m99",
+      lastViewedMessageId: "m1",
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: [cached],
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+
+    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
+    apiClient.getMessages = async (channelId, opts) => {
+      calls.push({ channelId, opts });
+      return opts?.after === "m1" ? [fresh] : [];
+    };
+
+    await controller.refreshMessages();
+
+    expect(calls).toEqual([{
+      channelId: "everyone",
+      opts: { limit: 50, after: "m1" },
+    }]);
+    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2"]);
+    expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
+      lastCursor: "m2",
+    });
+  });
+
   test("shows a pending message immediately and replaces it when the send succeeds", async () => {
     const persistence = new MemoryPersistence();
     const controller = new ChatController();
@@ -655,4 +730,79 @@ describe("ChatController", () => {
       lastCursor: "m2",
     });
   });
+
+  test("loads older messages before the oldest cached message without moving the latest cursor", async () => {
+    const persistence = new MemoryPersistence();
+    const controller = new ChatController();
+    const cached: ChatMessage[] = [
+      {
+        id: "m3",
+        channelId: "everyone",
+        content: "cached older",
+        replyToId: null,
+        createdAt: "2026-03-28T00:03:00.000Z",
+        user: { id: "u3", username: "cara", displayName: "Cara" },
+      },
+      {
+        id: "m4",
+        channelId: "everyone",
+        content: "cached newer",
+        replyToId: null,
+        createdAt: "2026-03-28T00:04:00.000Z",
+        user: { id: "u4", username: "drew", displayName: "Drew" },
+      },
+    ];
+    const older: ChatMessage[] = [
+      {
+        id: "m1",
+        channelId: "everyone",
+        content: "oldest",
+        replyToId: null,
+        createdAt: "2026-03-28T00:01:00.000Z",
+        user: { id: "u1", username: "alice", displayName: "Alice" },
+      },
+      {
+        id: "m2",
+        channelId: "everyone",
+        content: "older",
+        replyToId: null,
+        createdAt: "2026-03-28T00:02:00.000Z",
+        user: { id: "u2", username: "bob", displayName: "Bob" },
+      },
+    ];
+
+    persistence.setState("channel:everyone", {
+      draft: "",
+      replyToId: null,
+      lastCursor: "m4",
+      lastViewedMessageId: "m4",
+    }, { schemaVersion: 1 });
+    persistence.setResource(TRANSCRIPT_KIND, TRANSCRIPT_KEY, {
+      messages: cached,
+    }, {
+      sourceKey: TRANSCRIPT_SOURCE,
+      schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
+      cachePolicy: { staleMs: 1_000, expireMs: 2_000 },
+    });
+
+    controller.attachPersistence(persistence);
+
+    const calls: Array<{ channelId: string; opts?: { after?: string; before?: string; limit?: number } }> = [];
+    apiClient.getMessages = async (channelId, opts) => {
+      calls.push({ channelId, opts });
+      return opts?.before === "m3" ? older : [];
+    };
+
+    await controller.loadOlderMessages();
+
+    expect(calls).toEqual([{
+      channelId: "everyone",
+      opts: { limit: 50, before: "m3" },
+    }]);
+    expect(controller.getSnapshot().messages.map((entry) => entry.id)).toEqual(["m1", "m2", "m3", "m4"]);
+    expect(controller.getSnapshot().hasOlderMessages).toBe(false);
+    expect(persistence.getState<{ lastCursor: string }>("channel:everyone", { schemaVersion: 1 })).toMatchObject({
+      lastCursor: "m4",
+    });
+  });
 });

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

@@ -7,6 +7,7 @@ const SESSION_STATE_KEY = "session";
 const CHANNEL_STATE_KEY = "channel:everyone";
 const TRANSCRIPT_KIND = "channel-transcript";
 const TRANSCRIPT_SOURCE = "server";
+const MESSAGE_PAGE_SIZE = 50;
 const MAX_CACHED_MESSAGES = 50;
 const SESSION_SCHEMA_VERSION = 1;
 const CHANNEL_SCHEMA_VERSION = 1;
@@ -40,6 +41,8 @@ interface PersistedTranscript {
 
 export interface ChatControllerSnapshot {
   loading: boolean;
+  loadingOlderMessages: boolean;
+  hasOlderMessages: boolean;
   hasSavedSession: boolean;
   user: { id: string; username: string; emailVerified: boolean } | null;
   messages: ChatMessage[];
@@ -80,6 +83,21 @@ function isLegacyTimestampCursor(cursor: string | null): boolean {
   return !!cursor && ISO_TIMESTAMP_CURSOR.test(cursor);
 }
 
+function getLatestMessageId(messages: ChatMessage[]): string | null {
+  return messages[messages.length - 1]?.id ?? null;
+}
+
+function resolveHydratedCursor(messages: ChatMessage[], persistedCursor: string | null): string | null {
+  const transcriptCursor = getLatestMessageId(messages);
+  if (!transcriptCursor) return null;
+  if (!persistedCursor || isLegacyTimestampCursor(persistedCursor)) {
+    return persistedCursor ?? transcriptCursor;
+  }
+  // Desktop web can persist channel state without persisting the matching transcript cache.
+  // Backfill from the transcript we actually loaded when those two cursors diverge.
+  return persistedCursor === transcriptCursor ? persistedCursor : transcriptCursor;
+}
+
 function compareMessages(a: ChatMessage, b: ChatMessage): number {
   // Preserve server/insertion order inside same-timestamp batches so the bottom-most
   // rendered message stays the one selected first from the composer.
@@ -93,7 +111,10 @@ export class ChatController {
   private hydrated = false;
   private sessionChecked = false;
   private messagesLoading = false;
+  private olderMessagesLoading = false;
   private refreshMessagesPromise: Promise<void> | null = null;
+  private loadOlderMessagesPromise: Promise<void> | null = null;
+  private reachedOldestMessage = false;
   private user: { id: string; username: string; emailVerified: boolean } | null = null;
   private messages: ChatMessage[] = [];
   private pendingMessages: ChatMessage[] = [];
@@ -129,7 +150,9 @@ export class ChatController {
       schemaVersion: SESSION_SCHEMA_VERSION,
     });
     apiClient.setSessionToken(session?.sessionToken ?? null);
-    apiClient.setWebSocketToken(session?.websocketToken ?? null);
+    // WebSocket tokens are short-lived connection credentials. Reusing a persisted
+    // one can trap reconnects on an expired token even while the session cookie is valid.
+    apiClient.setWebSocketToken(null);
     apiClient.restoreCachedUser(session?.user ?? null);
     this.user = session?.user
       ? {
@@ -156,11 +179,9 @@ export class ChatController {
       allowExpired: true,
     });
     this.messages = transcript?.value.messages ?? [];
-    this.lastCursor = this.messages.length > 0
-      ? persistedCursor ?? this.messages[this.messages.length - 1]?.id ?? null
-      : null;
+    this.lastCursor = resolveHydratedCursor(this.messages, persistedCursor);
     this.lastViewedMessageId = this.user?.id && apiClient.getSessionToken()
-      ? persistedViewedMessageId ?? this.messages[this.messages.length - 1]?.id ?? null
+      ? persistedViewedMessageId ?? getLatestMessageId(this.messages)
       : null;
     this.syncVerificationPolling();
   }
@@ -176,6 +197,8 @@ export class ChatController {
   getSnapshot(): ChatControllerSnapshot {
     return {
       loading: !this.sessionChecked || this.messagesLoading,
+      loadingOlderMessages: this.olderMessagesLoading,
+      hasOlderMessages: this.messages.length > 0 && !this.reachedOldestMessage,
       hasSavedSession: !!apiClient.getSessionToken(),
       user: this.user,
       messages: this.getVisibleMessages(),
@@ -261,6 +284,28 @@ export class ChatController {
     return request;
   }
 
+  async loadOlderMessages(): Promise<void> {
+    if (this.loadOlderMessagesPromise) return this.loadOlderMessagesPromise;
+    const before = this.messages[0]?.id ?? null;
+    if (!before || this.reachedOldestMessage) return;
+
+    this.olderMessagesLoading = true;
+    this.emit();
+
+    const request = this.fetchOlderMessages(before)
+      .catch(() => {
+        this.persistChannelState();
+      })
+      .finally(() => {
+        this.olderMessagesLoading = false;
+        this.loadOlderMessagesPromise = null;
+        this.emit();
+      });
+
+    this.loadOlderMessagesPromise = request;
+    return request;
+  }
+
   setDraft(draft: string): void {
     if (draft === this.draft) return;
     this.draft = draft;
@@ -317,6 +362,7 @@ export class ChatController {
     this.replyToId = null;
     this.lastCursor = null;
     this.lastViewedMessageId = null;
+    this.reachedOldestMessage = false;
     this.openViewCount = 0;
     if (clearSession) {
       this.user = null;
@@ -340,7 +386,9 @@ export class ChatController {
     this.wsConnection = null;
     this.wsConnected = false;
     this.messagesLoading = false;
+    this.olderMessagesLoading = false;
     this.refreshMessagesPromise = null;
+    this.loadOlderMessagesPromise = null;
     this.openViewCount = 0;
     this.notifyFn = () => {};
     this.listeners.clear();
@@ -427,18 +475,25 @@ export class ChatController {
 
   private async fetchMessages(): Promise<void> {
     const legacyTimestampCursor = isLegacyTimestampCursor(this.lastCursor);
+    const hasIncrementalCursor = !!this.lastCursor;
 
     try {
       const messages = await apiClient.getMessages("everyone", {
-        limit: MAX_CACHED_MESSAGES,
+        limit: MESSAGE_PAGE_SIZE,
         after: this.lastCursor ?? undefined,
       });
+      if (!hasIncrementalCursor && messages.length < MESSAGE_PAGE_SIZE) {
+        this.reachedOldestMessage = true;
+      }
       if (messages.length > 0) {
         this.mergeMessages(messages);
         return;
       }
       if (legacyTimestampCursor) {
-        const fullRefresh = await apiClient.getMessages("everyone", { limit: MAX_CACHED_MESSAGES });
+        const fullRefresh = await apiClient.getMessages("everyone", { limit: MESSAGE_PAGE_SIZE });
+        if (fullRefresh.length < MESSAGE_PAGE_SIZE) {
+          this.reachedOldestMessage = true;
+        }
         if (fullRefresh.length > 0) {
           this.mergeMessages(fullRefresh);
           return;
@@ -448,7 +503,10 @@ export class ChatController {
       this.persistChannelState();
       return;
     } catch {
-      const messages = await apiClient.getMessages("everyone", { limit: MAX_CACHED_MESSAGES });
+      const messages = await apiClient.getMessages("everyone", { limit: MESSAGE_PAGE_SIZE });
+      if (messages.length < MESSAGE_PAGE_SIZE) {
+        this.reachedOldestMessage = true;
+      }
       if (messages.length > 0) {
         this.mergeMessages(messages);
         return;
@@ -457,7 +515,22 @@ export class ChatController {
     }
   }
 
-  private mergeMessages(messages: ChatMessage[]): void {
+  private async fetchOlderMessages(before: string): Promise<void> {
+    const messages = await apiClient.getMessages("everyone", {
+      limit: MESSAGE_PAGE_SIZE,
+      before,
+    });
+    if (messages.length < MESSAGE_PAGE_SIZE) {
+      this.reachedOldestMessage = true;
+    }
+    if (messages.length === 0) {
+      this.persistChannelState();
+      return;
+    }
+    this.mergeMessages(messages, { notifyMentions: false });
+  }
+
+  private mergeMessages(messages: ChatMessage[], options?: { notifyMentions?: boolean }): void {
     this.reconcilePendingMessages(messages);
     const merged = new Map<string, ChatMessage>();
     const incoming = new Map<string, ChatMessage>();
@@ -469,13 +542,14 @@ export class ChatController {
       merged.set(message.id, message);
     }
     this.messages = [...merged.values()]
-      .sort(compareMessages)
-      .slice(-MAX_CACHED_MESSAGES);
+      .sort(compareMessages);
     this.lastCursor = this.messages[this.messages.length - 1]?.id ?? this.lastCursor;
     if (this.openViewCount > 0) {
       this.markViewedThroughLatestMessage(false);
     }
-    this.trackUnreadMentions([...incoming.values()]);
+    if (options?.notifyMentions !== false) {
+      this.trackUnreadMentions([...incoming.values()]);
+    }
     this.persistTranscript();
     this.emit();
   }
@@ -483,7 +557,6 @@ export class ChatController {
   private persistSession(): void {
     const value = {
       sessionToken: apiClient.getSessionToken(),
-      websocketToken: apiClient.getWebSocketToken(),
       user: this.user,
     } satisfies PersistedSessionState;
     this.resume?.setState(SESSION_STATE_KEY, value, {
@@ -517,7 +590,7 @@ export class ChatController {
     }
 
     this.persistence?.setResource(TRANSCRIPT_KIND, "everyone", {
-      messages: this.messages,
+      messages: this.messages.slice(-MAX_CACHED_MESSAGES),
     } satisfies PersistedTranscript, {
       sourceKey: TRANSCRIPT_SOURCE,
       schemaVersion: TRANSCRIPT_SCHEMA_VERSION,
@@ -590,8 +663,7 @@ export class ChatController {
 
   private getVisibleMessages(): ChatMessage[] {
     return [...this.messages, ...this.pendingMessages]
-      .sort(compareMessages)
-      .slice(-MAX_CACHED_MESSAGES);
+      .sort(compareMessages);
   }
 
   private createPendingMessage(content: string, replyToId?: string): ChatMessage {