gloomberb 0.15.7 → 0.16.0

package/src/renderers/dom/styles.css

@@ -172,6 +172,34 @@ body.gloom-dragging {
   opacity: 1;
   pointer-events: auto;
 }
+/* Message text can be selected and copied, like any chat. */
+[data-gloom-role="chat-message-body"] {
+  -webkit-user-select: text;
+  user-select: text;
+}
+[data-gloom-role="chat-message-image"]:focus-visible {
+  outline: 2px solid var(--gloom-border-focused, currentColor);
+  outline-offset: 1px;
+}
+/* An upload whose progress the transport cannot report. */
+.gloom-chat-upload-indeterminate {
+  animation: gloom-chat-upload-slide 1.2s ease-in-out infinite;
+}
+@keyframes gloom-chat-upload-slide {
+  from { transform: translateX(-100%); }
+  to { transform: translateX(250%); }
+}
+@media (prefers-reduced-motion: reduce) {
+  .gloom-chat-upload-indeterminate {
+    animation: none;
+    width: 100% !important;
+    opacity: 0.5;
+  }
+}
+/* The image viewer may use the whole window, not a dialog's usual width. */
+.gloom-dialog:has([data-gloom-role="chat-image-lightbox"]) {
+  max-width: calc(100vw - 48px);
+}
 [data-gloom-role="status-bar"] {
   flex: 0 0 var(--cell-h);
   height: var(--cell-h);

package/src/renderers/electrobun/view/backend-rpc.ts

@@ -14,6 +14,7 @@ import {
 } from "../shared/protocol";
 import { decodeRpcResponse, decodeRpcValue, encodeRpcValue } from "../shared/rpc-codec";
 import { subscribeCapability, type CapabilitySubscriptionOptions } from "./capability-subscription";
+import { nameRpcTimeout } from "./rpc-timeout";
 import type { RemoteControlRequest, RemoteControlResponse } from "../../../remote/types";
 
 type BackendMessages = ElectrobunDesktopRpcSchema["webview"]["messages"];
@@ -130,10 +131,10 @@ export async function backendRequest(
   payload: unknown = null,
 ): Promise<unknown> {
   await waitForBridgeReady();
-  const result = await rpc.request["backend.request"]({
+  const result = await nameRpcTimeout(method, payload, () => rpc.request["backend.request"]({
     method,
     payload: encodeRpcValue(payload),
-  });
+  }));
   return decodeRpcResponse(result);
 }
 

package/src/renderers/electrobun/view/cli-pane-shot-entry.tsx

@@ -437,7 +437,7 @@ function ShotPane({ payload, registry }: { payload: DesktopPaneShotPayload; regi
   const width = payload.widthCells;
   const height = payload.heightCells;
   return (
-    <PaneShotFrame paneId={instance.instanceId} title={title} width={width} height={height} preserveStatus={pane.id === "time-sales"}>
+    <PaneShotFrame paneId={instance.instanceId} title={title} width={width} height={height} preserveStatus={["time-sales", "gpu", "hiring", "apps", "catalysts", "litigation", "perps"].includes(pane.id)}>
       {(bodyFrame) => <PaneContent
         component={pane.component}
         paneId={instance.instanceId}

package/src/renderers/electrobun/view/http-fetch.ts

@@ -57,6 +57,8 @@ async function electrobunCloudApiFetch(url: string, init?: RequestInit): Promise
   const path = new URL(url).pathname;
   const timeoutMs = path.startsWith("/market/")
     ? CLOUD_MARKET_HTTP_TIMEOUT_MS
+    : path === "/telemetry/attention"
+      ? 5_000
     : path.endsWith("/feedback") && init?.method === "POST"
       ? FEEDBACK_SUBMIT_BUN_TIMEOUT_MS
       : undefined;

package/src/renderers/electrobun/view/main.tsx

@@ -43,8 +43,9 @@ import { remoteNotesFilesIO, setNotesFilesIO } from "../../../plugins/builtin/no
 import { NOTES_FILES_CAPABILITY_ID } from "../../../capabilities";
 import { loadOfficialPluginIds } from "../../../plugins/builtin/plugin-marketplace/feed";
 import { crashReportsEnabled, installCrashReporter, reportCrash } from "../../../telemetry/crash-reports";
-import { installWindowCrashListeners } from "../../../telemetry/crash-reports-dom";
+import { browserDoNotTrack, installWindowCrashListeners } from "../../../telemetry/crash-reports-dom";
 import { currentTelemetryConfig } from "../../../telemetry/live-config";
+import { attentionCountsEnabled, installAttentionCounter } from "../../../telemetry/attention-counts";
 import { installUsageCounter, usageCountsEnabled } from "../../../telemetry/usage-counts";
 import { installWindowUsageFlush } from "../../../telemetry/usage-counts-dom";
 
@@ -135,6 +136,7 @@ async function boot() {
     getInstallId: () => init.telemetry.installId,
     officialPluginIds: loadOfficialPluginIds,
   });
+  installAttentionCounter(() => !init.telemetry.optedOut && !browserDoNotTrack() && attentionCountsEnabled(currentTelemetryConfig(init.config)));
   installElectrobunCapabilityStreamClient();
   installFocusScopeRelease();
   installElectrobunWindowFullscreenTracking();

package/src/renderers/electrobun/view/rpc-timeout.ts

@@ -0,0 +1,59 @@
+import { getCloudApiBaseUrl } from "../../../api-client/request";
+import type { DesktopBackendRequestMethod } from "../shared/protocol";
+
+/** What Electrobun's request timer rejects with: no method, request id or caller. */
+const ELECTROBUN_REQUEST_TIMEOUT_MESSAGE = "RPC request timed out.";
+
+/**
+ * Runs one `backend.request` and, when Electrobun's request timer gives up on
+ * it, rethrows the timeout with the request named. Every other failure passes
+ * through untouched.
+ *
+ * The library's error is the same for every method, so crash reports could not
+ * tell a stalled update check from a stalled fetch. The name is the method,
+ * plus the capability operation for `capability.invoke`. An HTTP request to
+ * the Gloom API adds its host and first path segment; any other URL can come
+ * from the user's config (a broker gateway, a feed, a plugin endpoint) and is
+ * only called external. Never the payload, rest of the path, query or headers.
+ * Elapsed time is rounded to 10 s because crash reports are deduplicated per
+ * session on the message.
+ */
+export async function nameRpcTimeout<T>(
+  method: DesktopBackendRequestMethod,
+  payload: unknown,
+  request: () => Promise<T>,
+): Promise<T> {
+  const startedAt = performance.now();
+  try {
+    return await request();
+  } catch (error) {
+    if (!(error instanceof Error) || error.message !== ELECTROBUN_REQUEST_TIMEOUT_MESSAGE) throw error;
+    const seconds = Math.round((performance.now() - startedAt) / 10_000) * 10;
+    throw new Error(`RPC request timed out: ${describeRequest(method, payload)} after ~${seconds}s`, { cause: error });
+  }
+}
+
+function describeRequest(method: DesktopBackendRequestMethod, payload: unknown): string {
+  if (!payload || typeof payload !== "object") return method;
+  const { capabilityId, operationId, url } = payload as Record<string, unknown>;
+  if (method === "capability.invoke" && typeof capabilityId === "string" && typeof operationId === "string") {
+    return `${method} ${capabilityId}.${operationId}`;
+  }
+  if (method === "http.fetch" || method === "http.stream.open") {
+    return `${method} ${gloomApiArea(url) ?? "external"}`;
+  }
+  return method;
+}
+
+/** `api.gloom.sh/market` for a Gloom API URL, null for anything else. */
+function gloomApiArea(url: unknown): string | null {
+  if (typeof url !== "string") return null;
+  try {
+    const parsed = new URL(url);
+    if (parsed.origin !== new URL(getCloudApiBaseUrl()).origin) return null;
+    const segment = parsed.pathname.split("/")[1];
+    return segment ? `${parsed.host}/${segment}` : parsed.host;
+  } catch {
+    return null;
+  }
+}

package/src/renderers/opentui/start.tsx

@@ -37,6 +37,7 @@ import {
 } from "../../telemetry/crash-reports-node";
 import { currentTelemetryConfig } from "../../telemetry/live-config";
 import { flushUsageCounts, installUsageCounter, usageCountsEnabled } from "../../telemetry/usage-counts";
+import { attentionCountsEnabled, installAttentionCounter } from "../../telemetry/attention-counts";
 
 // Declared here rather than sniffed: the desktop view and the hosted browser
 // app are both browser contexts but differ in what plugins may do.
@@ -119,8 +120,10 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
       getInstallId: () => readOrCreateInstallId(config.dataDir),
       officialPluginIds: loadOfficialPluginIds,
     });
+    const stopAttention = installAttentionCounter(() => attentionCountsEnabled(currentTelemetryConfig(config), process.env));
     host = await measurePerfAsync("startup.opentui.create-host", () => createOpenTuiHost());
     const renderer = host.renderer;
+    renderer.once("destroy", stopAttention);
     // The renderer already listens for uncaught errors and keeps the process
     // running; these listeners live exactly as long as it does, so nothing
     // changes about when the process exits.

package/src/shares/api.ts

@@ -1,4 +1,3 @@
-import { apiClient } from "../api-client";
 import { ApiRequestError } from "../api-client/errors";
 import { parseSharePayload, type SharePayload } from "./payload";
 
@@ -52,6 +51,9 @@ export async function createShare(payload: SharePayload, fetchImpl?: ShareFetch)
     body = await readJson(response);
   } else {
     try {
+      // Public share pages only read/delete through fetch. Load the signed-in
+      // client when an interactive app creates a share, not on every public view.
+      const { apiClient } = await import("../api-client");
       body = await apiClient.createTerminalShare(validated);
     } catch (error) {
       if (error instanceof ApiRequestError && error.status === 401) throw new Error("Sign in to Gloom Cloud to share.");

package/src/sources/gloomberb-cloud/index.ts

@@ -38,7 +38,7 @@ import type { NewsArticle, NewsQuery } from "../../types/news-source";
 import { normalizeNewsFeed } from "../../news/news-model";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
 import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
-import { normalizePriceHistory } from "../../utils/price-history";
+import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss } from "../provider-errors";
 import { publicListingTarget } from "../listing-target";
 import { canonicalHistoryInterval, HistoryRetentionError, parseHistoryRecoveryCandidate, parseHistoryRetention, type HistoryRetention } from "../history-retention";
@@ -132,6 +132,28 @@ function isStaleCloudResponse(response: CloudMarketResponse<unknown>): boolean {
   return response.stale === true || response.providerMeta?.stale === true;
 }
 
+/**
+ * History with the pre-market and after-hours bars when the chart asks for
+ * them. A backend that cannot serve them answers the regular session, and one
+ * that ignores the request answers it without saying it served them.
+ */
+async function loadCloudHistory(
+  interval: string,
+  load: (session?: "extended") => Promise<CloudMarketResponse<CloudPricePointPayload[]>>,
+  context: MarketDataRequestContext | undefined,
+): Promise<{ response: CloudMarketResponse<CloudPricePointPayload[]>; extendedHours: boolean }> {
+  if (context?.historySession !== "extended" || !/^\d+(min|h)$/i.test(interval)) return { response: await load(), extendedHours: false };
+  try {
+    const response = await load("extended");
+    if (response.status === "success" || response.status === "partial" || response.status === "empty") {
+      return { response, extendedHours: response.session === "extended" };
+    }
+  } catch {
+    // The regular session below.
+  }
+  return { response: await load(), extendedHours: false };
+}
+
 function mapCloudPriceHistory(
   response: CloudMarketResponse<CloudPricePointPayload[]>,
   ticker: string,
@@ -139,11 +161,17 @@ function mapCloudPriceHistory(
   interval: string,
   requestedStart: Date,
   requestedEnd?: Date,
+  extendedHours = false,
 ): PriceHistoryResult {
   const coverageStart = parseHistoryCoverageStart(response.coverage);
   if (response.status === "empty" && coverageStart
     && requestedStart.getTime() < Date.parse(coverageStart)) throw new HistoryCoverageError(coverageStart);
-  if (isStaleCloudResponse(response)) {
+  // The server marks a cached copy it could not refresh in time. Bars that
+  // reach the venue's latest settled session still answer, and the router's
+  // own current-window check applies to them as to any other copy. Older bars,
+  // or a stale answer without bars, are a miss.
+  const stale = isStaleCloudResponse(response);
+  if (stale && response.status !== "success" && response.status !== "partial") {
     throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
   }
   if (response.status === "unsupported" && response.reasonCode === "HISTORY_RETENTION" && requestedEnd) {
@@ -167,6 +195,9 @@ function mapCloudPriceHistory(
       `Cloud chart data is unavailable for ${ticker}`,
     ).map((point) => mapPricePoint(point, divisor, exchange)),
   );
+  if (stale && !reachesLatestSettledSession(points, Date.now(), { exchange, intervalMs: priceHistoryIntervalMs(interval) })) {
+    throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
+  }
   if (
     /^\d+(min|h)$/i.test(interval)
     && hasMalformedIntradayHistory(points)
@@ -193,6 +224,7 @@ function mapCloudPriceHistory(
     resolution,
     ...(session && matchingSource && matchingIdentity ? { session } : {}),
     ...(coverageStart ? { coverageStart } : {}),
+    ...(extendedHours ? { extendedHours: true } : {}),
   };
 }
 
@@ -542,11 +574,11 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const target = cloudInstrumentTarget(ticker, exchange);
     exchange = target.exchange ?? "";
     const request = toHistoryRequest(range);
-    const response = await withCloudFallback(
-      () => apiClient.getCloudHistory(target.symbol, exchange, request),
+    const { response, extendedHours } = await withCloudFallback(
+      () => loadCloudHistory(request.interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, { ...request, ...(session ? { session } : {}) }), _context),
       `Cloud chart data is unavailable for ${ticker}`,
     );
-    return mapCloudPriceHistory(response, target.symbol, exchange, request.interval, subtractTimeRange(new Date(), range));
+    return mapCloudPriceHistory(response, target.symbol, exchange, request.interval, subtractTimeRange(new Date(), range), undefined, extendedHours);
   }
 
   async getPriceHistoryForResolution(
@@ -570,15 +602,16 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const endDate = new Date();
     const startDate = subtractTimeRange(endDate, bufferRange);
     const includeTime = /^\d+(min|h)$/i.test(interval);
-    const response = await withCloudFallback(
-      () => apiClient.getCloudHistory(target.symbol, exchange, {
+    const { response, extendedHours } = await withCloudFallback(
+      () => loadCloudHistory(interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, {
         interval,
         startDate: formatCloudDateTime(startDate, includeTime, exchange),
         endDate: formatCloudDateTime(endDate, includeTime, exchange),
-      }),
+        ...(session ? { session } : {}),
+      }), _context),
       `Cloud chart data is unavailable for ${ticker}`,
     );
-    return mapCloudPriceHistory(response, target.symbol, exchange, interval, startDate, endDate);
+    return mapCloudPriceHistory(response, target.symbol, exchange, interval, startDate, endDate, extendedHours);
   }
 
   async getDetailedPriceHistory(
@@ -601,16 +634,17 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const interval = toCloudInterval(barSize);
     const includeTime = /^\d+(min|h)$/i.test(interval);
     const historyRecovery = cloudHistoryRecovery(_context, ticker, target.symbol, exchange, interval, startDate, endDate);
-    const response = await withCloudFallback(
-      () => apiClient.getCloudHistory(target.symbol, exchange, {
+    const { response, extendedHours } = await withCloudFallback(
+      () => loadCloudHistory(interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, {
         interval,
         startDate: formatCloudDateTime(startDate, includeTime, exchange),
         endDate: formatCloudDateTime(endDate, includeTime, exchange),
         ...(historyRecovery ? { historyRecovery } : {}),
-      }),
+        ...(session ? { session } : {}),
+      }), historyRecovery ? undefined : _context),
       `Cloud detailed chart history is unavailable for ${ticker}`,
     );
-    return mapCloudPriceHistory(response, target.symbol, exchange, interval, startDate, endDate);
+    return mapCloudPriceHistory(response, target.symbol, exchange, interval, startDate, endDate, extendedHours);
   }
 
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, _context?: MarketDataRequestContext): Promise<OptionsChain> {

package/src/sources/history-result.ts

@@ -40,6 +40,7 @@ export function normalizeHistoryResult(
     ...(session ? { session } : {}),
     ...(typeof result.sourceKey === "string" && /^(provider|broker):[^\r\n\0]+$/.test(result.sourceKey) ? { sourceKey: result.sourceKey } : {}),
     ...(isHistoryCoverageDate(result.coverageStart) ? { coverageStart: result.coverageStart } : {}),
+    ...(result.extendedHours === true ? { extendedHours: true } : {}),
   };
 }
 

package/src/sources/history-retention.ts

@@ -1,5 +1,7 @@
+import { formatShortDate } from "../utils/datetime-format";
 import { canonicalExchange, parsePublicTickerKey } from "../utils/exchanges";
 import { isRecord } from "../utils/guards";
+import { zonedDateKey } from "../utils/zoned-date-time";
 import { parseBarInterval } from "../time-series/resolution";
 
 export const HISTORY_RETENTION_MAX_AGE_MS = 5 * 60_000;
@@ -132,6 +134,20 @@ export class HistoryRetentionError extends Error {
   }
 }
 
+/**
+ * Shown while a chart at an explicit interval reaches back past what the
+ * source keeps at it: the first retained day, read in the listing's zone
+ * (UTC when unknown), and the length of the window the source keeps.
+ */
+export function historyRetentionNotice(retention: HistoryRetention, interval: string, timeZone: string | null): string {
+  const zone = timeZone ?? "UTC";
+  const day = zonedDateKey(retention.availableStart, zone);
+  const sameYear = day.slice(0, 4) === zonedDateKey(retention.observedAt, zone).slice(0, 4);
+  const days = Math.round((retention.observedAt - retention.availableStart) / 86_400_000);
+  return `${interval} history starts ${formatShortDate(day, { utc: true, year: sameYear ? false : "numeric" })}; `
+    + `the source keeps the last ${days === 1 ? "day" : `${days} days`}.`;
+}
+
 export function isHistoryRetentionError(value: unknown): value is HistoryRetentionError {
   return value instanceof HistoryRetentionError && parseHistoryRetention(value.retention) !== null;
 }

package/src/sources/provider-router/history.ts

@@ -143,15 +143,17 @@ function makeHistoryRequestIdentity(
     fallbackVariantParts: Array<[string, string | number | undefined | null]>;
   },
 ): Pick<HistoryRequestDescriptor, "identity" | "cacheVariantKeys" | "exactCacheVariantKeys" | "target"> {
+  // Extended-hours bars are another history; they never answer for the regular session.
+  const session: [string, string | undefined] = ["session", input.context?.historySession];
   const identity = makeRouterRequestIdentity(deps, {
     kind: input.kind,
     ticker: input.ticker,
     context: input.context,
-    variantParts: priceHistoryVariantParts(input.variantParts, input.exchange),
+    variantParts: priceHistoryVariantParts([...input.variantParts, session], input.exchange),
   });
   const cacheVariantKeys = [
     identity.variantKey,
-    buildVariantKey(priceHistoryVariantParts(input.fallbackVariantParts, input.exchange)),
+    buildVariantKey(priceHistoryVariantParts([...input.fallbackVariantParts, session], input.exchange)),
   ];
   return {
     target: { symbol: input.ticker, exchange: input.exchange },

package/src/sources/sec-edgar/identity.ts

@@ -0,0 +1,36 @@
+// SEC's fair-access policy asks every client to name itself and a contact in
+// the User-Agent; EDGAR blocks requests that do not.
+
+function sanitizeIdentityPart(value: string, fallback: string): string {
+  const sanitized = value.trim().toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || fallback;
+}
+
+function extractEmail(value: string | undefined): string | null {
+  if (!value) return null;
+  const match = value.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i);
+  return match?.[0] ?? null;
+}
+
+function getEnv(name: string): string | undefined {
+  return typeof process !== "undefined" ? process.env[name] : undefined;
+}
+
+function getRuntimeHostName(): string {
+  const maybeLocation = (globalThis as { location?: { hostname?: string } }).location;
+  if (maybeLocation?.hostname) {
+    return maybeLocation.hostname;
+  }
+  return "localhost";
+}
+
+const runtimeHostName = getRuntimeHostName();
+
+export const DEFAULT_SEC_FROM =
+  getEnv("SEC_FROM_EMAIL")?.trim()
+  || extractEmail(getEnv("SEC_USER_AGENT"))
+  || `${sanitizeIdentityPart(getEnv("USER") ?? "gloomberb", "gloomberb")}@${sanitizeIdentityPart(`${runtimeHostName}.local`, "localhost.localdomain")}`;
+
+export const DEFAULT_SEC_USER_AGENT =
+  getEnv("SEC_USER_AGENT")?.trim()
+  || `Gloomberb/0.1 (${sanitizeIdentityPart(runtimeHostName, "localhost")}; contact=${DEFAULT_SEC_FROM})`;

package/src/sources/sec-edgar.ts

@@ -11,6 +11,7 @@ import {
   isPdfDocument,
 } from "./sec-edgar/content";
 import { parseSecAcceptanceTime } from "./sec-edgar/acceptance-time";
+import { DEFAULT_SEC_FROM, DEFAULT_SEC_USER_AGENT } from "./sec-edgar/identity";
 import { secFourthQuarters, withGuardedFourthQuarters, type SecFourthQuarter } from "./sec-edgar/fourth-quarter";
 
 export { extractFilingContent } from "./sec-edgar/content";
@@ -20,40 +21,6 @@ const SUBMISSIONS_URL = "https://data.sec.gov/submissions";
 const COMPANY_FACTS_URL = "https://data.sec.gov/api/xbrl/companyfacts";
 const FETCH_TIMEOUT_MS = 15_000;
 
-function sanitizeIdentityPart(value: string, fallback: string): string {
-  const sanitized = value.trim().toLowerCase().replace(/[^a-z0-9.-]+/g, "-").replace(/^-+|-+$/g, "");
-  return sanitized || fallback;
-}
-
-function extractEmail(value: string | undefined): string | null {
-  if (!value) return null;
-  const match = value.match(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i);
-  return match?.[0] ?? null;
-}
-
-function getEnv(name: string): string | undefined {
-  return typeof process !== "undefined" ? process.env[name] : undefined;
-}
-
-function getRuntimeHostName(): string {
-  const maybeLocation = (globalThis as { location?: { hostname?: string } }).location;
-  if (maybeLocation?.hostname) {
-    return maybeLocation.hostname;
-  }
-  return "localhost";
-}
-
-const runtimeHostName = getRuntimeHostName();
-
-const DEFAULT_SEC_FROM =
-  getEnv("SEC_FROM_EMAIL")?.trim()
-  || extractEmail(getEnv("SEC_USER_AGENT"))
-  || `${sanitizeIdentityPart(getEnv("USER") ?? "gloomberb", "gloomberb")}@${sanitizeIdentityPart(`${runtimeHostName}.local`, "localhost.localdomain")}`;
-
-const DEFAULT_SEC_USER_AGENT =
-  getEnv("SEC_USER_AGENT")?.trim()
-  || `Gloomberb/0.1 (${sanitizeIdentityPart(runtimeHostName, "localhost")}; contact=${DEFAULT_SEC_FROM})`;
-
 type LookupEntry = {
   cik: string;
   exchange?: string;

package/src/state/app/context/index.tsx

@@ -455,6 +455,7 @@ export function AppProvider({
   );
   const effectiveThemeId = getEffectiveThemeId(state);
   const previousRecentTickers = useRef(state.recentTickers);
+  const previousRecentCommands = useRef(state.config.recentCommands);
   const stateRef = useRef(state);
   const listenersRef = useRef(new Set<() => void>());
   const storeRef = useRef<AppContextStoreValue | null>(null);
@@ -528,6 +529,13 @@ export function AppProvider({
     );
   }, [state.config, state.recentTickers]);
 
+  // A recent pane run changes only config.recentCommands; nothing else saves it.
+  useEffect(() => {
+    if (previousRecentCommands.current === state.config.recentCommands) return;
+    previousRecentCommands.current = state.config.recentCommands;
+    scheduleConfigSave(() => ({ ...stateRef.current.config, recentTickers: stateRef.current.recentTickers }));
+  }, [state.config.recentCommands]);
+
   useEffect(() => {
     if (!desktopBridge) return;
     return desktopBridge.subscribeState((snapshot) => {

package/src/sync/core-contributors.ts

@@ -28,6 +28,7 @@ import {
   normalizeBuiltinPluginStateMap,
 } from "../plugins/ownership";
 import { isRecord } from "../utils/guards";
+import { withoutMissingWatchlists } from "../plugins/builtin/portfolio-list/mutations";
 
 /**
  * What a saved layout mirrors from the live session rather than from the
@@ -365,6 +366,7 @@ function collectCoreConfigPayload(config: AppConfig) {
     chartPreferences: config.chartPreferences,
     valueFlashingEnabled: config.valueFlashingEnabled,
     recentTickers: config.recentTickers,
+    recentCommands: config.recentCommands,
     // Completion is monotonic in synced state. A device only advertises the
     // completed state, while resumable progress and incomplete state stay local.
     onboardingComplete: config.onboardingComplete === true ? true : undefined,
@@ -655,6 +657,7 @@ function mergeConfigPayload(
   assign("chartPreferences");
   assign("valueFlashingEnabled");
   assign("recentTickers");
+  assign("recentCommands");
   // Sync can complete onboarding on another device, but never reopen it.
   // Resumable progress remains local until this installation completes it.
   if (
@@ -920,6 +923,11 @@ export const coreCollectionsSyncContributor: SyncContributor = {
     if (!isRecord(payload)) return;
     hydrateProfileAnalytics(payload);
     const lastSyncedTickers = lastSyncedTickersById(baselinePayload);
+    // The config contributor applies first, so these are the watchlists this
+    // pull left. Tickers here and pulled ones drop the ids of any list that is
+    // gone (removed elsewhere, or deleted by an older build that left its id on
+    // the tickers), so this device never pushes them back.
+    const watchlistIds = new Set(getState().config.watchlists.map((watchlist) => watchlist.id));
     const incomingRecords: TickerRecord[] = [];
     const rawTickers = Array.isArray(payload.tickers) ? payload.tickers : [];
     for (const rawTicker of rawTickers) {
@@ -943,16 +951,26 @@ export const coreCollectionsSyncContributor: SyncContributor = {
         positions: syncedPositions,
         broker_contracts: current?.metadata.broker_contracts ?? [],
       });
-      const record: TickerRecord = { metadata };
+      const record = withoutMissingWatchlists({ metadata }, watchlistIds);
       await tickerRepository.saveTicker(record);
       incomingRecords.push(record);
     }
 
-    if (!isCurrent() || incomingRecords.length === 0) return;
+    if (!isCurrent()) return;
     const nextTickers = new Map(getState().tickers);
     for (const record of incomingRecords) {
       nextTickers.set(record.metadata.ticker, record);
     }
+    let pruned = false;
+    for (const ticker of nextTickers.values()) {
+      const next = withoutMissingWatchlists(ticker, watchlistIds);
+      if (next === ticker) continue;
+      if (!isCurrent()) return;
+      await tickerRepository.saveTicker(next);
+      nextTickers.set(next.metadata.ticker, next);
+      pruned = true;
+    }
+    if (!isCurrent() || (incomingRecords.length === 0 && !pruned)) return;
     dispatch({ type: "SET_TICKERS", tickers: nextTickers });
   },
 };