gloomberb 0.17.3 → 0.17.4

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

@@ -11,6 +11,7 @@ import {
   type ChatChannel,
   type ChatChannelState,
   type ChatMessage,
+  type ChatNotification,
   type ChatReaction,
   type ChatReactionsUpdate,
   type PersistedAuthUser,
@@ -56,10 +57,9 @@ import {
   ensureChatChannelConnection,
   getOpenConnectionChannelIds,
   getSafetyRefreshChannelIds as getChannelIdsForSafetyRefresh,
+  markConnectedChannelsForBackfill,
 } from "./connections";
-import {
-  handleChatNotification as handleChatNotificationEvent,
-} from "./notifications";
+import { ChatNotificationAlerts } from "./notifications";
 import {
   CHAT_MESSAGE_EDIT_WINDOW_LABEL,
   DISCORD_MESSAGE_EDIT_NOTICE,
@@ -116,7 +116,14 @@ export class ChatController {
   );
   private notifyFn: (notification: AppNotificationRequest) => AppNotificationDelivery | void = () => {};
   private openMessageFn: ((channelId: string, messageId: string) => void) | undefined;
-  private notifiedMessageIds = new Set<string>();
+  private readonly alerts = new ChatNotificationAlerts({
+    getAppActive: () => this.appActive,
+    ensureChannelState: (channelId) => this.ensureChannelState(channelId),
+    mergeMessages: (channelId, messages, options) => this.mergeMessages(channelId, messages, options),
+    getChannel: (channelId) => this.channelCatalog.getChannels().find((channel) => channel.id === channelId),
+    getNotify: () => this.notifyFn,
+    getOpenMessage: () => this.openMessageFn,
+  });
 
   private readonly storage = new ChatControllerStorage({
     emit: (channelId) => this.emit(channelId),
@@ -156,6 +163,11 @@ export class ChatController {
     getUser: () => this.session.user,
     refreshSession: () => this.refreshSession(),
     handleNotification: (notification) => this.handleChatNotification(notification),
+    handleChannelState: (state) => {
+      this.applyChannelState(state);
+      this.emit(state.channelId);
+      this.emit();
+    },
     handleReactions: (update) => this.applyReactionsUpdate(update),
     setOnlineCount: (onlineCount) => {
       this.channelCatalog.setOnlineCount(onlineCount);
@@ -163,6 +175,7 @@ export class ChatController {
     emit: () => this.emit(),
     getSafetyRefreshChannelIds: () => getChannelIdsForSafetyRefresh(this.storage.channelStates),
     runSafetyRefresh: (channelId) => this.messageLoading.runMessagesRefresh(channelId, { showLoading: false }),
+    resyncChannels: () => this.resyncConnectedChannels(),
   });
 
   attachPersistence(persistence: PluginPersistence, resume?: PluginResumeState): void {
@@ -170,6 +183,14 @@ export class ChatController {
     this.hydrate();
   }
 
+  /**
+   * A popped-out window has its own chat state but leaves background banners
+   * to the main window, so one message raises one banner per app.
+   */
+  setRaisesBackgroundAlerts(raises: boolean): void {
+    this.alerts.raisesBackgroundAlerts = raises;
+  }
+
   setNotifier(
     notify: (notification: AppNotificationRequest) => AppNotificationDelivery | void,
     openMessage?: (channelId: string, messageId: string) => void,
@@ -466,7 +487,7 @@ export class ChatController {
       },
       closeAllConnections: () => this.closeAllConnections(),
       emit: () => this.emit(),
-      stopRealtime: () => this.realtime.stopAll(),
+      stopRealtime: () => this.stopRealtime(),
     });
   }
 
@@ -502,7 +523,7 @@ export class ChatController {
       persistChannelState: (channelId) => this.storage.persistChannelState(channelId),
       persistSession: () => this.storage.persistSession(this.session.sessionToken, this.session.user),
       shouldClearSession: clearSession,
-      stopRealtime: () => this.realtime.stopAll(),
+      stopRealtime: () => this.stopRealtime(),
     });
   }
 
@@ -514,7 +535,7 @@ export class ChatController {
     });
     disposeChatControllerRuntime({
       channelStates: this.storage.channelStates,
-      clearNotifications: () => this.notifiedMessageIds.clear(),
+      clearNotifications: () => this.alerts.clear(),
       clearView: () => this.view.clear(),
       closeAllConnections: () => this.closeAllConnections(),
       flushDraftSync: (channelId) => this.storage.flushDraftSync(channelId),
@@ -522,7 +543,7 @@ export class ChatController {
         this.notifyFn = () => {};
         this.openMessageFn = undefined;
       },
-      stopRealtime: () => this.realtime.stopAll(),
+      stopRealtime: () => this.stopRealtime(),
     });
   }
 
@@ -778,6 +799,12 @@ export class ChatController {
     closeAllChannelConnections(this.storage.channelStates.values());
   }
 
+  /** Live updates stop, and so do alerts still waiting to go up: nobody signed in reads them. */
+  private stopRealtime(): void {
+    this.realtime.stopAll();
+    this.alerts.clear();
+  }
+
   private applySignedOutSession(): void {
     applySignedOutChatControllerSession({
       channelStates: this.storage.channelStates.values(),
@@ -785,10 +812,21 @@ export class ChatController {
       emit: () => this.emit(),
       persistSession: (sessionToken, user) => this.storage.persistSession(sessionToken, user),
       session: this.session,
-      stopRealtime: () => this.realtime.stopAll(),
+      stopRealtime: () => this.stopRealtime(),
     });
   }
 
+  /** Each channel read live reads its latest page in full, after any read already out. */
+  private resyncConnectedChannels(): void {
+    for (const channelId of markConnectedChannelsForBackfill(this.storage.channelStates)) {
+      const inFlight = this.ensureChannelState(channelId).refreshMessagesPromise ?? Promise.resolve();
+      void inFlight
+        .catch(() => {})
+        .then(() => this.messageLoading.runMessagesRefresh(channelId, { showLoading: false }))
+        .catch(() => {});
+    }
+  }
+
   private ensureOpenChannelConnections(): void {
     const channelIds = getOpenConnectionChannelIds(this.storage.channelStates);
     closeInactiveChannelConnections(this.storage.channelStates, channelIds);
@@ -823,20 +861,10 @@ export class ChatController {
   }
 
   private handleChatNotification(
-    notification: Parameters<typeof handleChatNotificationEvent>[0]["notification"],
+    notification: ChatNotification,
     options: { countUnread?: boolean } = {},
   ): void {
-    handleChatNotificationEvent({
-      notification,
-      options,
-      appActive: this.appActive,
-      ensureChannelState: (channelId) => this.ensureChannelState(channelId),
-      mergeMessages: (channelId, messages, mergeOptions) => this.mergeMessages(channelId, messages, mergeOptions),
-      getChannel: (channelId) => this.channelCatalog.getChannels().find((channel) => channel.id === channelId),
-      notifiedMessageIds: this.notifiedMessageIds,
-      notify: this.notifyFn,
-      openMessage: this.openMessageFn,
-    });
+    this.alerts.handle(notification, options);
   }
 
   private getUnreadMentionCount(channelId: string): number {

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

@@ -11,83 +11,143 @@ import {
   formatReplyToast,
 } from "./utils";
 
-function wasNotificationDelivered(delivery: AppNotificationDelivery | void): boolean {
-  return !!delivery && (delivery.toastVisible || delivery.desktopRequested);
-}
+/**
+ * How long an app in the background holds a chat banner. The reader may be
+ * reading the message at that moment on another device or in a popped-out
+ * window, which tells the server within a second; the banner goes up only if
+ * the server still has the message unseen.
+ */
+const BACKGROUND_ALERT_DELAY_MS = 2_000;
 
-function notifyChatServerMessage({
-  notification,
-  channel,
-  notifiedMessageIds,
-  notify,
-  openMessage,
-}: {
-  notification: ChatNotification;
-  channel: ChatChannel | undefined;
-  notifiedMessageIds: Set<string>;
-  notify: (notification: AppNotificationRequest) => AppNotificationDelivery | void;
-  openMessage?: (channelId: string, messageId: string) => void;
-}): boolean {
-  if (notifiedMessageIds.has(notification.messageId)) return true;
-  const channelTitle = formatChatPaneTitle(channel, notification.channelId);
-  const body = notification.type === "reply"
-    ? formatReplyToast(notification.message)
-    : notification.type === "mention"
-      ? formatMentionToast(notification.message)
-      : formatChannelToast(notification.message, channel?.kind === "direct");
-  const delivered = wasNotificationDelivered(notify({
-    title: channelTitle,
-    body,
-    type: "info",
-    desktop: "when-inactive",
-    ...(openMessage ? {
-      action: {
-        label: "Open",
-        onClick: () => openMessage(notification.channelId, notification.messageId),
-      },
-    } : {}),
-  }));
-  if (delivered) {
-    notifiedMessageIds.add(notification.messageId);
-  }
-  return delivered;
-}
+type Notify = (notification: AppNotificationRequest) => AppNotificationDelivery | void;
 
-export function handleChatNotification({
-  notification,
-  options = {},
-  ensureChannelState,
-  mergeMessages,
-  appActive,
-  getChannel,
-  notifiedMessageIds,
-  notify,
-  openMessage,
-}: {
-  notification: ChatNotification;
-  options?: { countUnread?: boolean };
+interface ChatNotificationAlertsOptions {
+  getAppActive: () => boolean;
   ensureChannelState: (channelId: string) => ChannelRuntimeState;
   mergeMessages: (channelId: string, messages: ChatMessage[], options?: MergeMessagesOptions) => void;
-  appActive: boolean;
   getChannel: (channelId: string) => ChatChannel | undefined;
-  notifiedMessageIds: Set<string>;
-  notify: (notification: AppNotificationRequest) => AppNotificationDelivery | void;
-  openMessage?: (channelId: string, messageId: string) => void;
-}): void {
-  mergeMessages(notification.channelId, [notification.message], { countUnread: options.countUnread });
-  const channel = ensureChannelState(notification.channelId);
-  const activelyViewed = appActive && channel.focusedViewCount > 0;
-  const delivered = activelyViewed || notifyChatServerMessage({
-    notification,
-    channel: getChannel(notification.channelId),
-    notifiedMessageIds,
-    notify,
-    openMessage,
-  });
-  if (activelyViewed) {
-    notifiedMessageIds.add(notification.messageId);
+  getNotify: () => Notify;
+  getOpenMessage: () => ((channelId: string, messageId: string) => void) | undefined;
+}
+
+/** Whether this window holds the message as read: its read marker is at or after it. */
+function isReadHere(channel: ChannelRuntimeState, messageId: string): boolean {
+  const viewedId = channel.lastViewedMessageId;
+  if (!viewedId) return false;
+  if (viewedId === messageId) return true;
+  const viewedIndex = channel.messages.findIndex((message) => message.id === viewedId);
+  if (viewedIndex < 0) return false;
+  const messageIndex = channel.messages.findIndex((message) => message.id === messageId);
+  return messageIndex >= 0 && messageIndex <= viewedIndex;
+}
+
+/**
+ * Tells the server how a notification reached the reader. `seen`: where they
+ * were looking (the open channel, a toast in the foreground), which also
+ * stops the phone push waiting on it. Without it, only a banner on a
+ * computer nobody may be at, which still stops the email and the reminder on
+ * the next reconnect.
+ */
+function acknowledge(notification: ChatNotification, seen: boolean): void {
+  void apiClient.markChatNotificationsDelivered([notification.id], { seen }).catch(() => {});
+}
+
+/**
+ * Decides, once per message, whether a chat notification becomes a toast or
+ * a desktop banner. A message already read here or on another device stays
+ * quiet, whether it arrives live or again on reconnect.
+ */
+export class ChatNotificationAlerts {
+  private readonly notifiedMessageIds = new Set<string>();
+  private readonly waiting = new Map<string, ReturnType<typeof setTimeout>>();
+  private generation = 0;
+  /** False in a popped-out window: the main window raises the background banners. */
+  raisesBackgroundAlerts = true;
+  backgroundDelayMs = BACKGROUND_ALERT_DELAY_MS;
+
+  constructor(private readonly options: ChatNotificationAlertsOptions) {}
+
+  handle(notification: ChatNotification, options: { countUnread?: boolean } = {}): void {
+    this.options.mergeMessages(notification.channelId, [notification.message], { countUnread: options.countUnread });
+    if (this.notifiedMessageIds.has(notification.messageId)) {
+      // Shown here already; this copy came back on a reconnect.
+      acknowledge(notification, false);
+      return;
+    }
+    if (this.waiting.has(notification.id) || this.settledHere(notification)) return;
+
+    if (this.options.getAppActive()) {
+      this.present(notification);
+      return;
+    }
+    if (!this.raisesBackgroundAlerts) return;
+    const generation = this.generation;
+    this.waiting.set(notification.id, setTimeout(() => {
+      this.waiting.delete(notification.id);
+      void this.presentIfUnseen(notification, generation);
+    }, this.backgroundDelayMs));
   }
-  if (delivered) {
-    void apiClient.markChatNotificationsDelivered([notification.id]).catch(() => {});
+
+  /** Drops what is waiting and what was shown, as on sign-out. */
+  clear(): void {
+    this.generation += 1;
+    for (const timer of this.waiting.values()) clearTimeout(timer);
+    this.waiting.clear();
+    this.notifiedMessageIds.clear();
+  }
+
+  /** Read here, or open in front of the reader: nothing to raise, and the server hears it was seen. */
+  private settledHere(notification: ChatNotification): boolean {
+    const channel = this.options.ensureChannelState(notification.channelId);
+    const viewing = this.options.getAppActive() && channel.focusedViewCount > 0;
+    if (!viewing && !isReadHere(channel, notification.messageId)) return false;
+    this.notifiedMessageIds.add(notification.messageId);
+    acknowledge(notification, true);
+    return true;
+  }
+
+  private async presentIfUnseen(notification: ChatNotification, generation: number): Promise<void> {
+    let unseen = true;
+    try {
+      const ids = await apiClient.getUnseenChatNotificationIds([notification.id]);
+      unseen = ids.includes(notification.id);
+    } catch {
+      // A server that cannot say (an older one, a dropped request) gets the banner, as before.
+    }
+    if (generation !== this.generation || this.notifiedMessageIds.has(notification.messageId)) return;
+    if (!unseen) {
+      // Read, or shown in front of the reader, on another device or window.
+      this.notifiedMessageIds.add(notification.messageId);
+      return;
+    }
+    if (this.settledHere(notification)) return;
+    this.present(notification);
+  }
+
+  private present(notification: ChatNotification): void {
+    const channel = this.options.getChannel(notification.channelId);
+    const body = notification.type === "reply"
+      ? formatReplyToast(notification.message)
+      : notification.type === "mention"
+        ? formatMentionToast(notification.message)
+        : formatChannelToast(notification.message, channel?.kind === "direct");
+    const openMessage = this.options.getOpenMessage();
+    const delivery = this.options.getNotify()({
+      title: formatChatPaneTitle(channel, notification.channelId),
+      body,
+      type: "info",
+      desktop: "when-inactive",
+      ...(openMessage ? {
+        action: {
+          label: "Open",
+          onClick: () => openMessage(notification.channelId, notification.messageId),
+        },
+      } : {}),
+    });
+    const toastVisible = !!delivery && delivery.toastVisible;
+    // Nothing reached the reader: it stays pending for the email and the next reconnect.
+    if (!toastVisible && !(delivery && delivery.desktopRequested)) return;
+    this.notifiedMessageIds.add(notification.messageId);
+    acknowledge(notification, toastVisible);
   }
 }

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

@@ -1,4 +1,9 @@
-import { apiClient, type ChatNotification, type ChatReactionsUpdate } from "../../../../api-client";
+import {
+  apiClient,
+  type ChatChannelState,
+  type ChatNotification,
+  type ChatReactionsUpdate,
+} from "../../../../api-client";
 import {
   SAFETY_REFRESH_MS,
   SESSION_RETRY_MS,
@@ -11,20 +16,25 @@ interface ChatControllerRealtimeOptions {
   getUser: () => { emailVerified?: boolean } | null;
   refreshSession: () => Promise<void>;
   handleNotification: (notification: ChatNotification) => void;
+  handleChannelState: (state: ChatChannelState) => void;
   handleReactions: (update: ChatReactionsUpdate) => void;
   setOnlineCount: (onlineCount: number) => void;
   emit: () => void;
   getSafetyRefreshChannelIds: () => string[];
   runSafetyRefresh: (channelId: string) => Promise<void>;
+  /** The socket came back after a drop: the channels read live read their latest page in full. */
+  resyncChannels: () => void;
 }
 
 export class ChatControllerRealtime {
   private verificationPollTimer: ReturnType<typeof setInterval> | null = null;
   private sessionRetryTimer: ReturnType<typeof setTimeout> | null = null;
   private safetyRefreshTimer: ReturnType<typeof setInterval> | null = null;
+  private socketConnectionUnsubscribe: (() => void) | null = null;
   private chatNotificationUnsubscribe: (() => void) | null = null;
   private chatPresenceUnsubscribe: (() => void) | null = null;
   private chatReactionsUnsubscribe: (() => void) | null = null;
+  private channelStateUnsubscribe: (() => void) | null = null;
 
   constructor(private readonly options: ChatControllerRealtimeOptions) {}
 
@@ -72,21 +82,47 @@ export class ChatControllerRealtime {
         this.options.handleReactions(update);
       });
     }
+    if (!this.channelStateUnsubscribe) {
+      // Read or muted on another device or window: the unread count, the
+      // Dock badge and alerts still waiting follow without a refocus.
+      this.channelStateUnsubscribe = apiClient.subscribeChatChannelState((state) => {
+        this.options.handleChannelState(state);
+      });
+    }
     if (!this.chatPresenceUnsubscribe) {
       this.chatPresenceUnsubscribe = apiClient.subscribeChatPresence((onlineCount) => {
         this.options.setOnlineCount(onlineCount);
         this.options.emit();
       });
     }
+    if (!this.socketConnectionUnsubscribe) {
+      // Frames sent while the socket was down are gone, and the catch-up
+      // only reads newer messages, so a reaction, edit or removal made
+      // meanwhile is read with a full page once it is back.
+      let dropped = false;
+      this.socketConnectionUnsubscribe = apiClient.subscribeSocketConnection((event) => {
+        if (event === "closed") {
+          dropped = true;
+          return;
+        }
+        if (!dropped) return;
+        dropped = false;
+        this.options.resyncChannels();
+      });
+    }
   }
 
   stopRealtimeSubscriptions(): void {
+    this.socketConnectionUnsubscribe?.();
+    this.socketConnectionUnsubscribe = null;
     this.chatNotificationUnsubscribe?.();
     this.chatNotificationUnsubscribe = null;
     this.chatPresenceUnsubscribe?.();
     this.chatPresenceUnsubscribe = null;
     this.chatReactionsUnsubscribe?.();
     this.chatReactionsUnsubscribe = null;
+    this.channelStateUnsubscribe?.();
+    this.channelStateUnsubscribe = null;
   }
 
   stopVerificationPolling(): void {

package/src/plugins/builtin/cot/model.ts

@@ -67,11 +67,31 @@ const PRICE_OVERLAYS: Record<string, { exchange: string; priceSymbol: string }>
   "040701": { exchange: "NYB", priceSymbol: "OJ=F" }, "058644": { exchange: "CME", priceSymbol: "LBR=F" },
   "057642": { exchange: "CME", priceSymbol: "LE=F" }, "054642": { exchange: "CME", priceSymbol: "HE=F" },
   "061641": { exchange: "CME", priceSymbol: "GF=F" },
+  // Sector, index and energy roots added on 2026-10-14, each CFTC market matched
+  // by name and open interest against the board and checked for five years of
+  // front-price history the same day.
+  "138749": { exchange: "CME", priceSymbol: "XAE=F" }, "13874H": { exchange: "CME", priceSymbol: "XAB=F" },
+  "13874F": { exchange: "CME", priceSymbol: "XAI=F" }, "138748": { exchange: "CME", priceSymbol: "XAP=F" },
+  "13874E": { exchange: "CME", priceSymbol: "XAV=F" }, "13874C": { exchange: "CME", priceSymbol: "XAF=F" },
+  "13874I": { exchange: "CME", priceSymbol: "XAK=F" }, "13874P": { exchange: "CME", priceSymbol: "XAZ=F" },
+  "13874J": { exchange: "CME", priceSymbol: "XAU=F" }, "240741": { exchange: "CME", priceSymbol: "NKD=F" },
+  "240743": { exchange: "CME", priceSymbol: "NIY=F" }, "13874U": { exchange: "CME", priceSymbol: "MES=F" },
+  "209747": { exchange: "CME", priceSymbol: "MNQ=F" }, "239747": { exchange: "CME", priceSymbol: "M2K=F" },
+  "124608": { exchange: "CBT", priceSymbol: "MYM=F" },
+};
+/**
+ * Board roots the CFTC reports whose front alias has no five years of daily
+ * history to overlay (checked 2026-10-14): positioning without a price line.
+ * The CFTC reports the consumer discretionary sector some weeks only.
+ */
+const UNPRICED_BOARD_MARKETS: Readonly<Record<string, string>> = {
+  EMD: "33874A", RX: "124606", XAY: "138747", HH: "023A55",
 };
 /** The CFTC market a FUT board root reports under, by its price symbol; null for one the CFTC does not report (TTF). */
 function boardMarketCode(contract: FuturesContract): string | null {
   return Object.values(ROOTS).find((row) => row.priceSymbol === contract.symbol)?.code
     ?? Object.entries(PRICE_OVERLAYS).find(([, row]) => row.priceSymbol === contract.symbol)?.[0]
+    ?? UNPRICED_BOARD_MARKETS[contract.code]
     ?? null;
 }
 /**

package/src/plugins/builtin/custom-view/pane.tsx

@@ -10,7 +10,7 @@ import { teamViewsStore } from "../cloud/team/views";
 import { setPaneSettings } from "../../../pane-settings";
 import { customViewInstanceSettings } from "./index";
 import type { DataTableColumn } from "../../../components/ui/data-table/types";
-import { Button, PaneStatusBody, TextPromptDialog, usePaneFooter } from "../../../components";
+import { PaneStatusBody, TextPromptDialog, usePaneFooter } from "../../../components";
 import { useAsyncResource } from "../../../react/async-resource";
 import { useShortcut } from "../../../react/input";
 import { isPlainKey } from "../../../utils/keyboard";
@@ -370,7 +370,7 @@ export function CustomViewPane({ focused, width, height }: PaneProps) {
       <PaneStatusBody
         error={error}
         errorTitle="This view could not load."
-        actions={<Button label="Retry" compact onPress={() => { void reload(); }} />}
+        retry={{ onRetry: reload }}
       />
     );
   }

package/src/plugins/builtin/docs/pane.tsx

@@ -182,7 +182,7 @@ function LessonEntry({ url, width, onOpenLink }: { url: string; width: number; o
       <EmptyState
         title="This lesson is not saved for offline reading."
         hint="It is kept once it has been read with a connection."
-        actions={<Button label="Try Again" onPress={lesson.retry} compact />}
+        retry={{ onRetry: lesson.retry }}
       />
     );
   }

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

@@ -1,6 +1,5 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import {
-  Button,
   DataTableView,
   PaneStatusBody,
   QueryBar,
@@ -286,7 +285,7 @@ export function FuturesPane({ focused, width, height }: PaneProps) {
         height={height}
         error={errorMessage ?? "No quotes returned."}
         subject="Futures quotes"
-        actions={<Button label="Retry" variant="secondary" compact onPress={refresh} />}
+        retry={{ onRetry: refresh }}
       />
     );
   }
@@ -389,7 +388,7 @@ export const futuresModule: PluginModule = {
       paneId: FUTURES_PANE_ID,
       label: "Futures Board",
       description:
-        "Each root's most active futures contract across equity index, rates, energy, metals, agriculture, livestock, and FX with last price, unit, session change, search, and collapsible sectors.",
+        "Each root's most active futures contract across equity index, equity sectors, rates, energy, metals, agriculture, livestock, and FX with last price, unit, session change, search, and collapsible sectors.",
       keywords: [
         "futures",
         "commodities",

package/src/plugins/builtin/futures/model.ts

@@ -40,7 +40,8 @@ export function futuresRowId(row: FuturesTableRow): string {
   return row.type === "header" ? `header-${row.sector}` : row.contract.symbol;
 }
 
-const CONTRACT_MONTH = /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)[ -](\d{4}|\d{2})$/i;
+/** "Nov 26" or "Futures,Nov-2026"; a hyphen takes only a whole year, since "Futures,Nov-20" is 2026 cut short. */
+const CONTRACT_MONTH = /\b(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)(?: (\d{4}|\d{2})|-(\d{4}))$/i;
 
 /**
  * The alias stays the row identity while its quoted contract rolls, so the
@@ -66,7 +67,8 @@ export function quotedContractMonth(
   const match = CONTRACT_MONTH.exec(quote.name?.trim() ?? "");
   if (!match) return null;
   const month = MONTH_NAMES.findIndex((name) => name.toLowerCase() === match[1]!.toLowerCase());
-  const year = match[2]!.length === 2 ? 2000 + Number(match[2]) : Number(match[2]);
+  const written = match[2] ?? match[3]!;
+  const year = written.length === 2 ? 2000 + Number(written) : Number(written);
   return { year, month };
 }
 

package/src/plugins/builtin/futures/series.ts

@@ -9,8 +9,8 @@ import { FUTURES_CONTRACTS, FUTURES_SECTOR_LABELS, type FuturesContract } from "
 const US_CENT_CONTRACTS: ReadonlySet<string> = new Set(["ZC", "ZS", "ZL", "ZW", "KE", "KC", "SB", "CT"]);
 
 /**
- * The unit the board prints, not a blanket dollar price. Index futures are
- * points, rates are points (the board prints decimals, not 32nds), cents
+ * The unit the board prints, not a blanket dollar price. Index and sector
+ * futures are points, rates are points (the board prints decimals, not 32nds), cents
  * contracts are USX, and a declared quote unit wins over USD. Currency
  * futures are dollars per unit of the foreign currency.
  */
@@ -18,7 +18,7 @@ function futuresSeriesUnit(contract: FuturesContract): string {
   if (contract.unit?.startsWith("US cents") || US_CENT_CONTRACTS.has(contract.code)) return "USX";
   if (contract.unit?.startsWith("EUR")) return "EUR";
   if (contract.unit?.startsWith("USD")) return "USD";
-  if (contract.sector === "equity-index" || contract.sector === "rates") return "points";
+  if (contract.sector === "equity-index" || contract.sector === "equity-sectors" || contract.sector === "rates") return "points";
   return "USD";
 }
 

package/src/plugins/builtin/jobs/pane.tsx

@@ -4,7 +4,6 @@ import type { CloudJobsMoverPayload, CloudJobsPosting, CloudJobsSummaryPayload }
 import {
   chartTableChromeRows,
   Badge,
-  Button,
   ChartTableHeader,
   CompositeChart,
   DataTableStackView,
@@ -536,7 +535,7 @@ function CompanyPanel({
     [symbol, companyName],
   );
   const resource = useAsyncResource<JobsCompanyState>(request);
-  const { data, status, error, reload } = resource;
+  const { data, status, error, loading, reload } = resource;
 
   // `r` asks again in every state, including a failed or uncovered company.
   usePaneRefreshKey(reload, { focused });
@@ -555,8 +554,10 @@ function CompanyPanel({
   if ((status === "idle" || status === "loading") && !data) {
     return <PaneStatusBody loading align="center" loadingLabel={`Loading ${symbol} hiring...`} />;
   }
-  if (status === "error" && !data) {
-    return <PaneStatusBody error={error ?? "Could not load hiring data."} errorTitle="Could not load hiring data." actions={<Button label="Try again" onPress={reload} />} />;
+  // A failed look at an uncovered company says so: the old answer left up
+  // would read as the new one.
+  if (status === "error" && (!data || data.kind === "uncovered")) {
+    return <PaneStatusBody error={error ?? "Could not load hiring data."} errorTitle="Could not load hiring data." retry={{ onRetry: reload }} />;
   }
   if (!data) return null;
   if (data.kind === "pending") {
@@ -569,11 +570,13 @@ function CompanyPanel({
     );
   }
   if (data.kind === "uncovered") {
+    // The answer stays on screen while it asks again, so the button says it is asking.
     return (
-      <EmptyState
-        title={`No careers system found for ${symbol}.`}
-        message="Gloomberb reads companies' own careers systems. This one either has none we can read or lists roles only on third-party job boards."
-        actions={<Button label="Look again" onPress={reload} />}
+      <PaneStatusBody
+        empty
+        emptyTitle={`No careers system found for ${symbol}.`}
+        emptyMessage="Gloomberb reads companies' own careers systems. This one either has none we can read or lists roles only on third-party job boards."
+        retry={{ onRetry: reload, pending: loading, label: "Look again", pendingLabel: "Looking again...", unchanged: "Still no careers system." }}
       />
     );
   }
@@ -684,7 +687,7 @@ function HomeView({ width, height, focused, registrationId }: { width: number; h
   }, []);
 
   if (status === "loading" && !data) return <PaneStatusBody loading align="center" loadingLabel="Loading hiring data..." />;
-  if (status === "error" && !data) return <PaneStatusBody error={error ?? "Could not load hiring data."} errorTitle="Could not load hiring data." actions={<Button label="Try again" onPress={reload} />} />;
+  if (status === "error" && !data) return <PaneStatusBody error={error ?? "Could not load hiring data."} errorTitle="Could not load hiring data." retry={{ onRetry: reload }} />;
 
   const tableHeight = Math.max(3, height - (nativePaneChrome ? 1 : 0));
   return (