gloomberb 0.17.3 → 0.17.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gloomberb",
-  "version": "0.17.3",
+  "version": "0.17.5",
   "packageManager": "bun@1.3.11",
   "description": "Market research and portfolio tracker for the terminal",
   "module": "src/public/index.ts",
@@ -86,6 +86,7 @@
     "check:pane-screenshot": "bun run scripts/pane-chrome/screenshot.ts",
     "check:pane-rest": "bun run scripts/pane-chrome/rest-diff.ts",
     "check:pane-layout": "bun run scripts/pane-chrome/layout-sweep.ts",
+    "audit:ui": "bun run scripts/pane-chrome/ui-audit.ts",
     "benchmark:pane-drag:compare": "bun run scripts/pane-chrome/frame-budget.ts",
     "test:global-upgrade": "bun run scripts/smoke-global-upgrade.ts",
     "release": "./scripts/release.sh"

package/patches/electrobun@1.18.1.patch

@@ -53,6 +53,86 @@ index c26c2c977ee1fc25a8dc144b85bac8626a45f572..8920a2905380228c23cba66c20d9bfd1
  			frame: {
  				width: this.frame.width,
  				height: this.frame.height,
+diff --git a/dist/api/bun/core/Updater.ts b/dist/api/bun/core/Updater.ts
+index 39daf6d341780af8e30c2c50327162863f5977ec..bf4a4b615f84904759d4bcd57be0d899c9464a5f 100644
+--- a/dist/api/bun/core/Updater.ts
++++ b/dist/api/bun/core/Updater.ts
+@@ -132,6 +132,19 @@ let updateInfo: {
+ 	error: string;
+ };
+ 
++// Where updates are fetched from when it is not the channel and baseUrl that
++// version.json names. Only the download URLs read it: the app data folder and
++// the "dev" check keep the installed build's own channel.
++let updateSource: { channel: string; baseUrl: string } | null = null;
++
++function updateSourceChannel(): string {
++	return updateSource?.channel ?? localInfo.channel;
++}
++
++function updateSourceBaseUrl(): string {
++	return updateSource?.baseUrl ?? localInfo.baseUrl;
++}
++
+ function cleanupExtractionFolder(
+ 	extractionFolder: string,
+ 	keepTarHash: string,
+@@ -176,6 +189,12 @@ const Updater = {
+ 		onStatusChangeCallback = callback;
+ 	},
+ 
++	// Checks and downloads from `source` (a channel prefix and the URL its
++	// files sit under) until it is set again; null goes back to version.json.
++	setUpdateSource: (source: { channel: string; baseUrl: string } | null) => {
++		updateSource = source;
++	},
++
+ 	// todo: allow switching channels, by default will check the current channel
+ 	checkForUpdate: async () => {
+ 		emitStatus("checking", "Checking for updates...");
+@@ -196,11 +215,11 @@ const Updater = {
+ 
+ 		const cacheBuster = Math.random().toString(36).substring(7);
+ 		const platformPrefix = getPlatformPrefix(
+-			localInfo.channel,
++			updateSourceChannel(),
+ 			currentOS,
+ 			currentArch,
+ 		);
+-		const updateInfoUrl = `${localInfo.baseUrl.replace(/\/+$/, "")}/${platformPrefix}-update.json?${cacheBuster}`;
++		const updateInfoUrl = `${updateSourceBaseUrl().replace(/\/+$/, "")}/${platformPrefix}-update.json?${cacheBuster}`;
+ 
+ 		try {
+ 			const updateInfoResponse = await fetch(updateInfoUrl);
+@@ -329,11 +348,11 @@ const Updater = {
+ 
+ 				// check if there's a patch file for it
+ 				const platformPrefix = getPlatformPrefix(
+-					localInfo.channel,
++					updateSourceChannel(),
+ 					currentOS,
+ 					currentArch,
+ 				);
+-				const patchUrl = `${localInfo.baseUrl.replace(/\/+$/, "")}/${platformPrefix}-${currentHash}.patch`;
++				const patchUrl = `${updateSourceBaseUrl().replace(/\/+$/, "")}/${platformPrefix}-${currentHash}.patch`;
+ 				emitStatus(
+ 					"fetching-patch",
+ 					`Checking for patch: ${currentHash.slice(0, 8)}`,
+@@ -612,12 +631,12 @@ const Updater = {
+ 
+ 				const cacheBuster = Math.random().toString(36).substring(7);
+ 				const platformPrefix = getPlatformPrefix(
+-					localInfo.channel,
++					updateSourceChannel(),
+ 					currentOS,
+ 					currentArch,
+ 				);
+ 				const tarballName = getTarballFileName(appFileName, currentOS);
+-				const urlToLatestTarball = `${localInfo.baseUrl.replace(/\/+$/, "")}/${platformPrefix}-${tarballName}`;
++				const urlToLatestTarball = `${updateSourceBaseUrl().replace(/\/+$/, "")}/${platformPrefix}-${tarballName}`;
+ 				const prevVersionCompressedTarballPath = join(
+ 					appDataFolder,
+ 					"self-extraction",
 diff --git a/dist/api/bun/proc/native.ts b/dist/api/bun/proc/native.ts
 index f0f6c2532ba2eb467ec1d452a25c835b6db72661..ae77cf58d32392ad4cc8e2103ac7ed27baae8bea 100644
 --- a/dist/api/bun/proc/native.ts

package/src/api-client/chat.ts

@@ -154,16 +154,40 @@ export class CloudChatApi {
     );
   }
 
+  /**
+   * `seen`: the app showed them where the reader was looking (the open
+   * channel, a toast in the foreground), which also cancels the phone push
+   * waiting on them. A server that predates it ignores the field.
+   */
   async markNotificationsDelivered(
     notificationIds: string[],
+    options: { seen?: boolean } = {},
   ): Promise<{ delivered: number }> {
     return this.request<{ delivered: number }>(
       "/chat/notifications/delivered",
+      {
+        method: "POST",
+        body: JSON.stringify({ notificationIds, ...(options.seen ? { seen: true } : {}) }),
+      },
+    );
+  }
+
+  /**
+   * The notifications among these the reader has neither read nor been shown
+   * in front of them, on any device. Throws on a server without the route
+   * (404); the caller raises the alert then, as before.
+   */
+  async getUnseenNotificationIds(notificationIds: string[]): Promise<string[]> {
+    const answer = await this.request<{ notificationIds?: unknown }>(
+      "/chat/notifications/unseen",
       {
         method: "POST",
         body: JSON.stringify({ notificationIds }),
       },
     );
+    return Array.isArray(answer?.notificationIds)
+      ? answer.notificationIds.filter((id): id is string => typeof id === "string")
+      : notificationIds;
   }
 
   async openDirectChannel(target: {
@@ -327,6 +351,10 @@ export class CloudChatApi {
     return this.options.socket.subscribeChatNotifications(listener);
   }
 
+  subscribeChannelState(listener: (state: ChatChannelState) => void): () => void {
+    return this.options.socket.subscribeChatChannelState(listener);
+  }
+
   subscribePresence(listener: ChatPresenceListener): () => void {
     return this.options.socket.subscribeChatPresence(listener);
   }

package/src/api-client/data.ts

@@ -953,8 +953,11 @@ export class CloudDataApi {
   async getCloudSec13F(
     path: string,
     params: Record<string, string | number | undefined> = {},
+    options?: { signal?: AbortSignal },
   ): Promise<unknown> {
-    return this.request<unknown>(cloudSec13FPath(path, params));
+    return this.request<unknown>(cloudSec13FPath(path, params), {
+      signal: options?.signal,
+    });
   }
 
   /**

package/src/api-client/errors.ts

@@ -75,12 +75,22 @@ export function parseApiErrorMessage(body: string): string {
       (value): value is string =>
         typeof value === "string" && value.trim().length > 0,
     );
-    return parts.join(" ") || body;
+    return parts.join(" ") || validationErrorText(parsed) || body;
   } catch {
     return htmlErrorTitle(body) ?? body;
   }
 }
 
+/**
+ * A request the API's schema refused comes back as the values it was sent
+ * (`{"type":"validation","on":"query","found":{...}}`), which is no message to
+ * show; it is said in words instead.
+ */
+function validationErrorText(parsed: Record<string, unknown>): string | null {
+  if (parsed.type !== "validation") return null;
+  return parsed.on === "query" ? "Gloom Cloud did not accept an option or filter value." : "Gloom Cloud did not accept the request.";
+}
+
 /** A JSON error body as an object, or undefined for any other body. */
 export function parseApiErrorDetails(body: string): Readonly<Record<string, unknown>> | undefined {
   try {

package/src/api-client/index.ts

@@ -60,7 +60,8 @@ export type {
 /** Server-side caps for `/assist/command`; enforced here so a 422 is never sent. */
 const ASSIST_QUERY_MAX_LENGTH = 200;
 const ASSIST_COMMAND_LIMIT = 150;
-const ASSIST_ARG_OPTION_LIMIT = 64;
+/** The futures curve's root list is the longest a command sends: 76 since GLO-783. */
+export const ASSIST_ARG_OPTION_LIMIT = 128;
 const ASSIST_ARG_OPTION_VALUE_MAX_LENGTH = 40;
 const ASSIST_ARG_OPTION_LABEL_MAX_LENGTH = 60;
 const ASSIST_REQUEST_TIMEOUT_MS = 6_000;
@@ -646,6 +647,7 @@ class GloomApiClient {
   getChatState = this.chat.getState.bind(this.chat);
   updateChatChannelState = this.chat.updateChannelState.bind(this.chat);
   markChatNotificationsDelivered = this.chat.markNotificationsDelivered.bind(this.chat);
+  getUnseenChatNotificationIds = this.chat.getUnseenNotificationIds.bind(this.chat);
   openDirectChannel = this.chat.openDirectChannel.bind(this.chat);
   openGroupChannel = this.chat.openGroupChannel.bind(this.chat);
   getMessages = this.chat.getMessages.bind(this.chat);
@@ -658,6 +660,7 @@ class GloomApiClient {
   subscribeChatReactions = this.chat.subscribeReactions.bind(this.chat);
   connectChannel = this.chat.connectChannel.bind(this.chat);
   subscribeChatNotifications = this.chat.subscribeNotifications.bind(this.chat);
+  subscribeChatChannelState = this.chat.subscribeChannelState.bind(this.chat);
   subscribeChatPresence = this.chat.subscribePresence.bind(this.chat);
   getChatDiscordLink = this.chat.getDiscordLink.bind(this.chat);
   unlinkChatDiscord = this.chat.unlinkDiscord.bind(this.chat);

package/src/api-client/normalizers.ts

@@ -2,6 +2,7 @@ import type {
   ChatAccountType,
   ChatAttachment,
   ChatChannel,
+  ChatChannelState,
   ChatDiscordLink,
   ChatMessage,
   ChatMessageOrigin,
@@ -191,6 +192,26 @@ export function normalizeChatNotification(
   };
 }
 
+/** A `chat.channel_state` frame, or null when it is not one. */
+export function normalizeChatChannelStateFrame(data: unknown): ChatChannelState | null {
+  if (!data || typeof data !== "object") return null;
+  const state = data as Partial<ChatChannelState>;
+  if (
+    typeof state.channelId !== "string"
+    || typeof state.notificationsEnabled !== "boolean"
+    || typeof state.unreadCount !== "number"
+    || (state.lastReadMessageId !== null && typeof state.lastReadMessageId !== "string")
+  ) {
+    return null;
+  }
+  return {
+    channelId: state.channelId,
+    notificationsEnabled: state.notificationsEnabled,
+    lastReadMessageId: state.lastReadMessageId,
+    unreadCount: state.unreadCount,
+  };
+}
+
 export function normalizeChatChannel(
   channel: ChatChannel,
   fallbackKind: ChatChannel["kind"] = "public",

package/src/api-client/research-activity.ts

@@ -28,7 +28,10 @@ export type ResearchActivity =
   | "onboarding_signed_in"
   | "onboarding_pro_viewed"
   | "onboarding_completed"
-  | "onboarding_skipped";
+  | "onboarding_skipped"
+  // The first action of a web visitor counted in the first-screen experiment,
+  // in that first session. Keep in sync with the server's list.
+  | "first_screen_engaged";
 export type ResearchFeature =
   | "overview"
   | "chart"
@@ -451,7 +454,10 @@ function webExperimentAttribution(): { experiments?: string } {
  * visitors on term.gloom.sh with an analytics id (no Do Not Track or Global
  * Privacy Control) and not driven by automation are asked. See web-experiments.ts.
  */
-export function exposeWebExperiment(experiment: string): Promise<string | null> {
+export function exposeWebExperiment(
+  experiment: string,
+  { placement, signal }: { placement?: string; signal?: AbortSignal } = {},
+): Promise<string | null> {
   if (!researchTelemetryAllowed()) return Promise.resolve(null);
   if (getCurrentPluginTarget() !== "web") return Promise.resolve(null);
   try {
@@ -468,7 +474,8 @@ export function exposeWebExperiment(experiment: string): Promise<string | null>
         attribution: attributionPayload(),
         experiment: key,
         variant,
-      }),
+        ...(placement && ACTIVITY_ID.test(placement) ? { placement } : {}),
+      }, signal),
     });
   } catch {
     return Promise.resolve(null);

package/src/api-client/socket.ts

@@ -1,6 +1,7 @@
 import type { TapeFeedEvent } from "./tape";
 import type {
   AuthUser,
+  ChatChannelState,
   ChatMessage,
   ChatNotification,
   ChatReactionsUpdate,
@@ -11,6 +12,7 @@ import type {
   TeamNotification,
 } from "./types";
 import {
+  normalizeChatChannelStateFrame,
   normalizeChatMessage,
   normalizeChatNotification,
   normalizeChatReactions,
@@ -42,6 +44,7 @@ const cloudApiLog = debugLog.createLogger("cloud-api");
 
 type ChannelListener = (message: ChatMessage) => void;
 type ChatNotificationListener = (notification: ChatNotification) => void;
+type ChatChannelStateListener = (state: ChatChannelState) => void;
 type ChatPresenceListener = (onlineCount: number) => void;
 type ChatReactionsListener = (update: ChatReactionsUpdate) => void;
 type TeamNotificationListener = (notification: TeamNotification) => void;
@@ -108,6 +111,8 @@ export class CloudApiSocket {
   private readonly channelListeners = new Map<string, Set<ChannelListener>>();
   private readonly chatNotificationListeners =
     new Set<ChatNotificationListener>();
+  private readonly chatChannelStateListeners =
+    new Set<ChatChannelStateListener>();
   private readonly chatPresenceListeners = new Set<ChatPresenceListener>();
   private readonly chatReactionsListeners = new Set<ChatReactionsListener>();
   private readonly teamNotificationListeners =
@@ -249,6 +254,17 @@ export class CloudApiSocket {
     };
   }
 
+  /**
+   * The reader's read state or mute changed on another device or window. Like
+   * notifications, it never opens the socket by itself.
+   */
+  subscribeChatChannelState(listener: ChatChannelStateListener): () => void {
+    this.chatChannelStateListeners.add(listener);
+    return () => {
+      this.chatChannelStateListeners.delete(listener);
+    };
+  }
+
   /** A message's reactions changed in a channel this socket reads. */
   subscribeChatReactions(listener: ChatReactionsListener): () => void {
     this.chatReactionsListeners.add(listener);
@@ -511,6 +527,7 @@ export class CloudApiSocket {
     this.offeredFeatureListeners.clear();
     this.connectionListeners.clear();
     this.chatNotificationListeners.clear();
+    this.chatChannelStateListeners.clear();
     this.chatPresenceListeners.clear();
     this.chatReactionsListeners.clear();
     this.teamNotificationListeners.clear();
@@ -614,6 +631,16 @@ export class CloudApiSocket {
       return;
     }
 
+    if (parsed?.type === "chat.channel_state") {
+      const state = normalizeChatChannelStateFrame(parsed.data);
+      if (state) {
+        for (const listener of this.chatChannelStateListeners) {
+          listener(state);
+        }
+      }
+      return;
+    }
+
     if (parsed?.type === "team.notification" && parsed.data) {
       const notification = normalizeTeamNotification(
         parsed.data as TeamNotification,

package/src/app/pane-runtime/ticker-open-runtime.ts

@@ -21,6 +21,7 @@ import type { DataProvider } from "../../types/data-provider";
 import type { PinTickerOptions } from "../../types/plugin";
 import {
   resolveTickerOpenTarget,
+  tickerOpenFailureMessage,
   type TickerOpenTarget,
 } from "../../tickers/open-target";
 import { AmbiguousTickerError, findExactTickerSearchMatch } from "../../tickers/search";
@@ -73,7 +74,7 @@ export function useAppTickerOpenRuntime({
         tickerRepository,
       });
       if (!target && canPresentFeedback()) {
-        pluginRegistry.notify({ body: `Could not open ${rawSymbol}.`, type: "error" });
+        pluginRegistry.notify({ body: tickerOpenFailureMessage(rawSymbol), type: "error" });
       }
       return target;
     } catch (err) {

package/src/app/runtime/startup.ts

@@ -107,6 +107,10 @@ export function useAppStartupRuntime({
     appLog.info("app activity propagated", { active: appActive });
   }, [appActive]);
 
+  useEffect(() => {
+    chatController.setRaisesBackgroundAlerts(!isDetachedWindow);
+  }, [isDetachedWindow]);
+
   // Runs for the life of the app: a freeze is only reportable if something
   // was watching the clock while it happened.
   useEffect(() => startMainThreadStallMonitor(), []);

package/src/app/runtime/update.ts

@@ -7,13 +7,17 @@ import {
   canRestartToApply,
   canSelfUpdate,
   checkForUpdateDetailed,
+  discardStagedUpdate,
   performUpdate,
   type ReleaseInfo,
   type UpdateCheckResult,
   type UpdateProgress,
 } from "../../updater";
+import { resolveUpdateChannel, stagedUpdateFitsChannel } from "../../updater/channel";
+import type { UpdateChannel } from "../../types/config";
 import { VERSION } from "../../version";
 import { debugLog } from "../../utils/debug-log";
+import { isPrereleaseVersion } from "../../utils/semver";
 import { reportCrash } from "../../telemetry/crash-reports";
 import { runAutomated } from "../../telemetry/usage-counts";
 
@@ -41,6 +45,7 @@ export function useAppUpdateRuntime({
   pluginRegistry,
   stateRef,
   updateAvailable,
+  updateChannel = "stable",
   updateCheckInProgress,
   updateProgress,
 }: {
@@ -50,6 +55,8 @@ export function useAppUpdateRuntime({
   pluginRegistry: PluginRegistry;
   stateRef: { current: AppState };
   updateAvailable: ReleaseInfo | null;
+  /** The channel in effect (`resolveUpdateChannel`); a change checks again at once. */
+  updateChannel?: UpdateChannel;
   updateCheckInProgress: boolean;
   updateProgress: unknown;
 }): {
@@ -97,7 +104,8 @@ export function useAppUpdateRuntime({
     // failed check like any other: the hourly one must not end as an
     // unhandled rejection, and a manual one must clear its progress state.
     // The timeout is still reported, as it was when it went unhandled.
-    const result = await checkForUpdateDetailed(VERSION).catch((error: unknown): UpdateCheckResult => {
+    const channel = resolveUpdateChannel(stateRef.current.config);
+    const result = await checkForUpdateDetailed(VERSION, channel).catch((error: unknown): UpdateCheckResult => {
       const message = error instanceof Error ? error.message : "";
       if (message.startsWith("RPC request timed out")) {
         reportCrash(error, { kind: "unhandled-rejection" });
@@ -123,7 +131,7 @@ export function useAppUpdateRuntime({
 
     if (result.kind === "current") {
       dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
-      dispatch({ type: "SET_UPDATE_NOTICE", notice: `Already on v${VERSION}` });
+      dispatch({ type: "SET_UPDATE_NOTICE", notice: result.notice ?? `Already on v${VERSION}` });
       return;
     }
 
@@ -147,6 +155,44 @@ export function useAppUpdateRuntime({
     return () => { clearInterval(interval); };
   }, [enabled, isDetachedWindow, runUpdateCheck]);
 
+  // A channel switch checks again at once and says what it found: nightly
+  // starts on today's build, stable says when this nightly build stays. An
+  // update already downloading or waiting for a restart is left to the effect
+  // below, which takes it back once it is ready if the channel rules it out.
+  const checkedChannelRef = useRef(updateChannel);
+  useEffect(() => {
+    if (!enabled || isDetachedWindow || checkedChannelRef.current === updateChannel) return;
+    checkedChannelRef.current = updateChannel;
+    if (updateInFlight(stateRef.current.updateProgress)) return;
+    // What the other channel offered, or how its download failed, is not this one's answer.
+    if (stateRef.current.updateProgress) dispatch({ type: "SET_UPDATE_PROGRESS", progress: null });
+    dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
+    void runUpdateCheck(true);
+  }, [dispatch, enabled, isDetachedWindow, runUpdateCheck, stateRef, updateChannel]);
+
+  // A downloaded update the channel does not allow (a nightly build waiting
+  // for a restart after the switch back to stable, or one that finished
+  // downloading after it) is taken back rather than installed by the restart,
+  // and stable checks again.
+  const discardingRef = useRef(false);
+  useEffect(() => {
+    if (!enabled || isDetachedWindow || discardingRef.current) return;
+    const { updateProgress: progress, updateAvailable: staged } = stateRef.current;
+    if (progress?.phase !== "ready" || stagedUpdateFitsChannel(staged, updateChannel)) return;
+    discardingRef.current = true;
+    void discardStagedUpdate().then((error) => {
+      discardingRef.current = false;
+      if (error) {
+        updateLog.warn("could not take back the staged update", { error, version: staged?.version });
+        dispatch({ type: "SET_UPDATE_NOTICE", notice: `Could not take back v${staged?.version ?? "?"}: ${error}` });
+        return;
+      }
+      dispatch({ type: "SET_UPDATE_PROGRESS", progress: null });
+      dispatch({ type: "SET_UPDATE_AVAILABLE", release: null });
+      void runUpdateCheck(true);
+    });
+  }, [dispatch, enabled, isDetachedWindow, runUpdateCheck, stateRef, updateAvailable, updateChannel, updateProgress]);
+
   // First launch on a new version: show that release's notes, then remember the version.
   useEffect(() => {
     if (!enabled || isDetachedWindow) return;
@@ -156,7 +202,8 @@ export function useAppUpdateRuntime({
     const nextConfig = { ...config, lastLaunchedVersion: VERSION };
     dispatch({ type: "SET_CONFIG", config: nextConfig });
     void saveConfigImmediately(nextConfig).catch(() => {});
-    if (!isUpgrade) return;
+    // Nightly builds come daily and the changelog lists stable releases only.
+    if (!isUpgrade || isPrereleaseVersion(VERSION)) return;
     // Opened by the app, not the user: usage counts leave it out.
     void runAutomated(() => pluginRegistry.createPaneFromTemplateAsync("changelog-pane", {
       values: { version: VERSION },

package/src/app.tsx

@@ -50,6 +50,7 @@ import { bindPluginRegistryRuntimeAccess } from "./app/runtime/plugin-bindings";
 import { useAppStartupRuntime } from "./app/runtime/startup";
 import { useTickerRefreshRuntime } from "./app/runtime/ticker-refresh";
 import { useAppUpdateRuntime } from "./app/runtime/update";
+import { resolveUpdateChannel } from "./updater/channel";
 import { createCoreSyncContributors } from "./sync/core-contributors";
 import { useCloudSyncRuntime } from "./sync/react";
 import { RemoteControlHost, type RemoteControlAdapter } from "./remote/app-host";
@@ -278,6 +279,7 @@ function AppInner({
     pluginRegistry,
     stateRef,
     updateAvailable: state.updateAvailable,
+    updateChannel: resolveUpdateChannel(state.config),
     updateCheckInProgress: state.updateCheckInProgress,
     updateProgress: state.updateProgress,
   });

package/src/ask-gloom/pane-context.ts

@@ -41,7 +41,7 @@ function scalarArgs(source: ArgSource, privateFields: PaneSharePrivateFields | u
  * that opens this pane (a chart opened with `GP` stays `GP`), else the first
  * template that opens it.
  */
-function functionCode(registry: Pick<PluginRegistry, "paneTemplates">, paneType: string, title: string): string | null {
+export function functionCode(registry: Pick<PluginRegistry, "paneTemplates">, paneType: string, title: string): string | null {
   const prefixes = [...registry.paneTemplates.values()]
     .filter((template) => template.paneId === paneType && template.shortcut?.prefix)
     .map((template) => template.shortcut!.prefix.toUpperCase());
@@ -50,6 +50,16 @@ function functionCode(registry: Pick<PluginRegistry, "paneTemplates">, paneType:
   return prefixes[0] ?? null;
 }
 
+/**
+ * A pane named by its function and what it shows, such as `DES AAPL`: its
+ * title, led by its function code unless the title already starts with it.
+ */
+export function paneFunctionLabel(pane: { title: string; code: string | null; paneType: string }): string {
+  const title = pane.title.trim() || pane.paneType;
+  if (!pane.code) return title;
+  return title.split(/\s+/)[0]?.toUpperCase() === pane.code ? title : `${pane.code} ${title}`;
+}
+
 export interface PaneAttachmentSource {
   registry: Pick<PluginRegistry, "paneTemplates" | "brokers" | "getPanePluginId" | "getBrokerPluginId">;
   pane: Pick<ResolvedPane, "instance" | "def">;

package/src/cli/commands/overview.ts

@@ -428,7 +428,7 @@ async function runFred(rawArgs: string[], ctx: Parameters<CliCommandDef["execute
     }),
   }, {
     dateKey: "date",
-    empty: fredEmptyMessage(startDate, latest),
+    empty: fredEmptyMessage(startDate, latest == null ? null : exportRow(latest)),
     ...(notes.length ? { footnote: notes.join("\n"), exportNotes: notes } : {}),
     exportIdentity: { symbolOrSeries: seriesId, currencyOrUnit: unit, interval },
     textColumns: [
@@ -486,7 +486,7 @@ async function runYieldCurve(rawArgs: string[], ctx: Parameters<CliCommandDef["e
         key: "changeBasisPoints",
         header: "1D bp",
         align: "right",
-        format: (value) => typeof value === "number" ? formatBasisPoints(value / 100) : "-",
+        format: (value) => typeof value === "number" ? formatBasisPoints(value / 100, 1) : "-",
       },
       { key: "date", header: "Date" },
       { key: "seriesId", header: "Series" },

package/src/cli/commands/system.ts

@@ -4,6 +4,7 @@ import { saveConfig } from "../../data/config/store";
 import { builtinPluginGroupMembers } from "../../plugins/ownership";
 import type { AppConfig, TelemetryConfig } from "../../types/config";
 import { canonicalTimeZone } from "../../utils/utc-time";
+import { NIGHTLY_CHANNEL_SUMMARY, parseUpdateChannel, withUpdateChannel } from "../../updater/channel";
 import type { CliCommandDef } from "../../types/plugin";
 import { resolveCliDataDir, withCliServices, withConfigData } from "../context";
 import { CLI_COMMAND_GROUPS } from "../help";
@@ -33,6 +34,8 @@ const STAR_PROMPT_CONFIG_KEY = "starPrompt.enabled";
 const TIMEZONE_CONFIG_KEY = "timezone";
 /** What `config set timezone` takes to go back to UTC alone. */
 const NO_TIMEZONE = "none";
+/** Stable releases, or nightly builds as well. */
+const UPDATE_CHANNEL_CONFIG_KEY = "updates.channel";
 const EDITABLE_CONFIG_KEYS = [
   "baseCurrency",
   "refreshIntervalMinutes",
@@ -41,6 +44,7 @@ const EDITABLE_CONFIG_KEYS = [
   ...Object.keys(TELEMETRY_CONFIG_KEYS),
   STAR_PROMPT_CONFIG_KEY,
   TIMEZONE_CONFIG_KEY,
+  UPDATE_CHANNEL_CONFIG_KEY,
 ];
 
 function isTelemetryConfigKey(key: string): key is TelemetryConfigKey {
@@ -219,6 +223,7 @@ export function createSystemCliCommands(): CliCommandDef[] {
         "config set telemetry.usage false",
         "config set starPrompt.enabled false",
         "config set timezone <Region/City>|none",
+        "config set updates.channel stable|nightly",
         "config get keybindings",
         "config set keybindings.actions.<action> <keys>|null|default",
         "config set keybindings.commands.<keys> <command>|null",
@@ -236,6 +241,11 @@ export function createSystemCliCommands(): CliCommandDef[] {
         lines: [
           `theme takes one of these ids, or its name as config themes lists it: ${getThemeIds().join(", ")}.`,
         ],
+      }, {
+        title: "Release channel",
+        lines: [
+          `The app updates itself from stable releases. With updates.channel nightly (Release Channel in the command bar) it also installs the nightly build: ${NIGHTLY_CHANNEL_SUMMARY}. Back on stable, a nightly build stays until a newer stable release is out. GLOOMBERB_UPDATE_CHANNEL overrides the setting for one run; npm and Bun installs always follow stable.`,
+        ],
       }],
       examples: [
         "config",
@@ -287,6 +297,7 @@ export function createSystemCliCommands(): CliCommandDef[] {
           "telemetry.attention": context.config.telemetry?.attention === true,
           [STAR_PROMPT_CONFIG_KEY]: context.config.starPrompt?.enabled !== false,
           [TIMEZONE_CONFIG_KEY]: context.config.timezone ?? null,
+          [UPDATE_CHANNEL_CONFIG_KEY]: context.config.updates?.channel ?? "stable",
         };
 
         if (action === "list") {
@@ -347,11 +358,16 @@ export function createSystemCliCommands(): CliCommandDef[] {
           if ((isTelemetryConfigKey(key) || key === STAR_PROMPT_CONFIG_KEY) && value !== "true" && value !== "false") {
             ctx.fail(`Usage: gloomberb config set ${key} true|false`);
           }
+          if (key === UPDATE_CHANNEL_CONFIG_KEY && !parseUpdateChannel(value)) {
+            ctx.fail(`Usage: gloomberb config set ${key} stable|nightly`);
+          }
           // A display name may come unquoted: config set theme White Phosphor.
           const parsedValue = key === "theme"
             ? requireThemeId(args.slice(2).join(" "))
             : key === TIMEZONE_CONFIG_KEY
               ? parseTimezoneSetting(value)
+              : key === UPDATE_CHANNEL_CONFIG_KEY
+              ? parseUpdateChannel(value)
               : key === "refreshIntervalMinutes"
               ? Number(value)
               : isBooleanConfigKey(key)
@@ -363,7 +379,9 @@ export function createSystemCliCommands(): CliCommandDef[] {
               ? { ...context.config, starPrompt: { ...context.config.starPrompt, enabled: parsedValue as boolean } }
               : key === TIMEZONE_CONFIG_KEY
                 ? withTimezone(context.config, parsedValue as string | null)
-                : { ...context.config, [key]: parsedValue };
+                : key === UPDATE_CHANNEL_CONFIG_KEY
+                  ? withUpdateChannel(context.config, parsedValue as "stable" | "nightly")
+                  : { ...context.config, [key]: parsedValue };
           if (!ctx.cliOptions.dryRun) await saveConfig(nextConfig);
           ctx.printResult({
             data: {