gloomberb 0.18.4 → 0.19.0

package/src/renderers/electrobun/view/view-ids.ts

@@ -0,0 +1,85 @@
+import { ANONYMOUS_ID_STORAGE_KEY, ATTRIBUTION_STORAGE_KEY } from "../../../api-client/research-activity";
+import { SYNC_CLIENT_ID_STORAGE_KEY } from "../../../sync/controller";
+import { logFailure } from "../../../utils/log-failure";
+import type { DesktopViewIds } from "../shared/protocol";
+
+/**
+ * What the desktop view keeps only in its WebView storage: the id Cloud sync
+ * knows this device by, and the visitor id and first touch a gloom.sh link
+ * handed over. macOS and Windows keep that storage under the app's bundle
+ * identifier, so a build under another identifier would start without them.
+ * The Bun process keeps a copy in the data folder (bun/desktop/view-ids.ts),
+ * and a view whose storage lacks one takes it back from there.
+ */
+const VIEW_ID_KEYS = [SYNC_CLIENT_ID_STORAGE_KEY, ANONYMOUS_ID_STORAGE_KEY, ATTRIBUTION_STORAGE_KEY] as const;
+
+interface ViewIdStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+/** The view's WebView storage, or null where it is refused. */
+export function viewIdStorage(): ViewIdStorage | null {
+  try {
+    return globalThis.localStorage ?? null;
+  } catch {
+    // Intentional ignore: without storage there is nothing to restore or keep.
+    return null;
+  }
+}
+
+function readViewIds(storage: ViewIdStorage): DesktopViewIds {
+  const ids: DesktopViewIds = {};
+  for (const key of VIEW_ID_KEYS) {
+    const value = storage.getItem(key);
+    if (value) ids[key] = value;
+  }
+  return ids;
+}
+
+function sameIds(left: DesktopViewIds, right: DesktopViewIds): boolean {
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => left[key] === right[key]);
+}
+
+/** Puts the ids kept on disk into `storage` where it has none. One it has is never replaced. */
+export function restoreViewIds(storage: ViewIdStorage, kept: DesktopViewIds | undefined): void {
+  try {
+    for (const key of VIEW_ID_KEYS) {
+      const value = kept?.[key];
+      if (value && !storage.getItem(key)) storage.setItem(key, value);
+    }
+  } catch (error) {
+    logFailure("desktop-view-ids", "Could not restore the view's ids")(error);
+  }
+}
+
+/**
+ * A function that sends the ids in `storage` to be kept on disk when they
+ * differ from the copy there (`kept`, from `init`). It reads three keys, so it
+ * can run whenever one of them may have been written. A save that fails is
+ * tried again at the next call.
+ */
+export function createViewIdMirror(
+  storage: ViewIdStorage,
+  kept: DesktopViewIds | undefined,
+  save: (ids: DesktopViewIds) => Promise<unknown>,
+): () => void {
+  let onDisk: DesktopViewIds = { ...kept };
+  return () => {
+    let ids: DesktopViewIds;
+    try {
+      ids = readViewIds(storage);
+    } catch (error) {
+      logFailure("desktop-view-ids", "Could not read the view's ids")(error);
+      return;
+    }
+    if (sameIds(ids, onDisk)) return;
+    const previous = onDisk;
+    onDisk = ids;
+    save(ids).catch((error: unknown) => {
+      if (onDisk === ids) onDisk = previous;
+      logFailure("desktop-view-ids", "Could not send the view's ids to be kept")(error);
+    });
+  };
+}

package/src/renderers/opentui/start.tsx

@@ -38,6 +38,9 @@ import {
 } from "../../telemetry/crash-reports-node";
 import { currentTelemetryConfig } from "../../telemetry/live-config";
 import { installUpdateFailureReporter } from "../../telemetry/update-failures";
+import { installStallReporter, recordStall } from "../../telemetry/stall-reports";
+import { createNodeStallReporterHost } from "../../telemetry/stall-reports-node";
+import { setStallSink } from "../../utils/main-thread-stall";
 import { createNodeUpdateFailureHost } from "../../telemetry/update-failures-node";
 import { terminalInstallKind } from "../../updater";
 import { flushUsageCounts, installUsageCounter, usageCountsEnabled } from "../../telemetry/usage-counts";
@@ -124,6 +127,8 @@ export async function startOpenTuiApp({ externalPlugins, cliLaunchRequest }: Sta
       installKind: terminalInstallKind(),
       getDataDir: () => config.dataDir,
     }));
+    installStallReporter(createNodeStallReporterHost({ getDataDir: () => config.dataDir }));
+    setStallSink((event) => recordStall("terminal", event));
     installUsageCounter({
       surface: "terminal",
       os: describeNodeOs(),

package/src/renderers/opentui/toast-host.tsx

@@ -4,9 +4,13 @@ import { useSyncExternalStore } from "react";
 import { colors } from "../../theme/colors";
 import { createToastStore, type ToastHost, type ToastTone } from "../../ui/toast";
 import { useActionShortcut } from "../../ui";
+import { displayWidth } from "../../utils/format";
 
 const toastStore = createToastStore();
 
+/** The cells beside a toast's text on its first line: border and padding each side, the icon, the close mark and the gaps after and before them. */
+const TOAST_CHROME_CELLS = 8;
+
 function toneColor(tone: ToastTone): string {
   if (tone === "success") return colors.positive;
   if (tone === "error") return colors.negative;
@@ -44,56 +48,80 @@ function ToastViewport({ position = "bottom-right" }: { position?: string }) {
       flexDirection="column"
       gap={1}
     >
-      {shownToasts.map((toast) => (
-        <box
-          key={toast.id}
-          width="100%"
-          border
-          borderStyle="single"
-          borderColor={toneColor(toast.tone)}
-          backgroundColor={colors.panel}
-          paddingX={1}
-          flexDirection="row"
-          gap={1}
-        >
-          <text fg={toneColor(toast.tone)}>{toneIcon(toast.tone)}</text>
-          <text fg={colors.text} flexGrow={1} flexShrink={1} flexBasis={0} wrapMode="word">{toast.body}</text>
-          {toast.options?.action && (
-            <text
-              fg={colors.textBright}
-              attributes={1}
-              onMouseDown={(event) => {
-                event.stopPropagation();
-                toast.options?.action?.onClick();
-              }}
-            >
-              {toast.id === newestActionId && actionShortcut
-                ? `[${toast.options.action.label} ${actionShortcut}]`
-                : `[${toast.options.action.label}]`}
-            </text>
-          )}
-          {toast.options?.secondaryAction && (
+      {shownToasts.map((toast) => {
+        const actionLabel = toast.options?.action
+          ? toast.id === newestActionId && actionShortcut
+            ? `[${toast.options.action.label} ${actionShortcut}]`
+            : `[${toast.options.action.label}]`
+          : null;
+        const secondaryLabel = toast.options?.secondaryAction ? `[${toast.options.secondaryAction.label}]` : null;
+        const actionCells = [actionLabel, secondaryLabel].reduce((cells, label) => cells + (label ? displayWidth(label) + 1 : 0), 0);
+        // Actions sit beside text that fits on one line with them. Beside longer text they would
+        // squeeze it into a narrow column, or out of sight, so they go under it and it wraps at full width.
+        const inline = actionCells === 0 || displayWidth(toast.body) + actionCells + TOAST_CHROME_CELLS <= maxWidth;
+        const actions = (
+          <>
+            {toast.options?.action && (
+              <text
+                fg={colors.textBright}
+                attributes={1}
+                onMouseDown={(event) => {
+                  event.stopPropagation();
+                  toast.options?.action?.onClick();
+                }}
+              >
+                {actionLabel}
+              </text>
+            )}
+            {toast.options?.secondaryAction && (
+              <text
+                fg={colors.textMuted}
+                onMouseDown={(event) => {
+                  event.stopPropagation();
+                  toast.options?.secondaryAction?.onClick();
+                }}
+              >
+                {secondaryLabel}
+              </text>
+            )}
+          </>
+        );
+        return (
+          <box
+            key={toast.id}
+            width="100%"
+            border
+            borderStyle="single"
+            borderColor={toneColor(toast.tone)}
+            backgroundColor={colors.panel}
+            paddingX={1}
+            flexDirection="row"
+            gap={1}
+          >
+            <text fg={toneColor(toast.tone)}>{toneIcon(toast.tone)}</text>
+            {inline ? (
+              <>
+                <text fg={colors.text} flexGrow={1} flexShrink={1} flexBasis={0} wrapMode="word">{toast.body}</text>
+                {actions}
+              </>
+            ) : (
+              <box flexGrow={1} flexShrink={1} flexBasis={0} flexDirection="column">
+                <text fg={colors.text} wrapMode="word">{toast.body}</text>
+                <box flexDirection="row" gap={1}>{actions}</box>
+              </box>
+            )}
             <text
               fg={colors.textMuted}
               onMouseDown={(event) => {
                 event.stopPropagation();
-                toast.options?.secondaryAction?.onClick();
+                toastStore.dismiss(toast.id);
               }}
             >
-              {`[${toast.options.secondaryAction.label}]`}
+              ×
             </text>
-          )}
-          <text
-            fg={colors.textMuted}
-            onMouseDown={(event) => {
-              event.stopPropagation();
-              toastStore.dismiss(toast.id);
-            }}
-          >
-            ×
-          </text>
-        </box>
-      ))}
+          </box>
+        );
+      })}
     </box>
   );
 }

package/src/series/registry.ts

@@ -63,6 +63,7 @@ export function seriesCatalogEntry(series: RegisteredSeries): SeriesCatalogEntry
     ...(definition.description ? { description: definition.description } : {}),
     ...(definition.publisher ? { publisher: definition.publisher } : {}),
     ...(definition.url ? { url: definition.url } : {}),
+    ...(definition.limitation ? { limitation: definition.limitation } : {}),
     ...(definition.input ? { input: definition.input } : {}),
     ...(definition.placement ? { placement: definition.placement } : {}),
     ...(definition.lines?.length ? {

package/src/series/types.ts

@@ -133,6 +133,11 @@ interface SeriesDefinitionBase {
   publisher?: string;
   /** The publisher's page for the series. */
   url?: string;
+  /**
+   * A limit on the data the publisher sets, such as a cap on how far back its
+   * history goes. One sentence: the catalog lists it beside the series.
+   */
+  limitation?: string;
   /** Ask for a ticker, an option or a crypto pair before charting. */
   input?: SeriesInput;
   /**
@@ -203,6 +208,7 @@ export interface SeriesCatalogEntry {
   description?: string;
   publisher?: string;
   url?: string;
+  limitation?: string;
   input?: SeriesInput;
   placement?: SeriesPlacement;
   /** The lines of a series that draws several, each with the expression that charts it alone. */

package/src/series/validate.ts

@@ -136,6 +136,7 @@ export function validateSeriesDefinition(definition: SeriesDefinition, context:
   checkLabel(id, "group", definition.group, 32, context);
   checkLabel(id, "description", definition.description, 300, context);
   checkLabel(id, "publisher", definition.publisher, 60, context);
+  checkLabel(id, "limitation", definition.limitation, 160, context);
   if (definition.tags !== undefined) {
     if (!Array.isArray(definition.tags) || definition.tags.length > 16) fail(id, "tags must be a list of at most 16 words.");
     for (const tag of definition.tags) checkLabel(id, "tag", tag, 40, context, false);

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

@@ -964,6 +964,7 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
           return {
             articles: cloudNewsReadArticles(read, query.ticker),
             nextCursor: read.nextCursor ?? null,
+            access: read.access ?? null,
           };
         },
         async fetchNews(query: NewsQuery): Promise<NewsArticle[]> {

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

@@ -1,7 +1,8 @@
 import { normalizeNewsFeed } from "../../news/news-model";
 import { readableNewsSource } from "../../news/source-label";
 import { collectNewsDisplayTickers } from "../../news/ticker-symbols";
-import type { NewsArticle, NewsQuery, NewsStoryItem } from "../../types/news-source";
+import type { NewsAccess, NewsArticle, NewsQuery, NewsStoryItem } from "../../types/news-source";
+import { CLOUD_NEWS_DELAY_HOURS } from "../../api-client/plan-rules";
 import type {
   apiClient,
   CloudNewsListResponse,
@@ -134,10 +135,44 @@ export function cloudNewsParams(query: NewsQuery): CloudNewsParams {
   };
 }
 
-/** A page of Gloom Cloud stories, with the text searched for when a coin pair's feed had none filed under it. */
-export type CloudNewsRead = CloudNewsListResponse & { searchedFor?: string };
+/**
+ * A page of Gloom Cloud stories, with the text searched for when a coin pair's
+ * feed had none filed under it, and which news the service answered with.
+ */
+export type CloudNewsRead = Omit<CloudNewsListResponse, "access"> & { searchedFor?: string; access?: NewsAccess | null };
+
+/**
+ * How recently the service must have seen a story for the answer to be the
+ * live wire. It holds a story back from an account without real-time news
+ * until it last saw it {@link CLOUD_NEWS_DELAY_HOURS} hours ago; the hour
+ * less leaves room for this clock and the service's to disagree.
+ */
+const LIVE_STORY_WINDOW_MS = (CLOUD_NEWS_DELAY_HOURS - 1) * 60 * 60 * 1000;
+
+/**
+ * Which news a Gloom Cloud answer is, from the answer: what the service says
+ * when it says it; held back when the request carried no session, since the
+ * service holds news back for anyone it cannot name; live when it holds a
+ * story seen too recently to have been held back. Otherwise null: a quiet
+ * feed read live looks the same as a held-back one.
+ */
+export function cloudNewsAccess(
+  response: Pick<CloudNewsListResponse, "items" | "access">,
+  sentSession: boolean,
+  now = Date.now(),
+): NewsAccess | null {
+  if (response.access === "realtime" || response.access === "delayed") return response.access;
+  if (!sentSession) return "delayed";
+  const live = response.items.some((item) => {
+    const seenAt = Date.parse(item.lastSeenAt);
+    return Number.isFinite(seenAt) && now - seenAt < LIVE_STORY_WINDOW_MS;
+  });
+  return live ? "realtime" : null;
+}
 
-type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "searchCloudNews">;
+/** A client that cannot say whether a session goes with its requests (a test double) is taken to send one. */
+type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "searchCloudNews">
+  & Partial<Pick<typeof apiClient, "hasSessionCredential">>;
 
 /**
  * A news query's first page from Gloom Cloud. Stories are filed under company
@@ -147,13 +182,18 @@ type CloudNewsClient = Pick<typeof apiClient, "getCloudNews" | "searchCloudNews"
  * no name to search keeps the empty answer.
  */
 export async function readCloudNews(client: CloudNewsClient, query: NewsQuery): Promise<CloudNewsRead> {
+  // Asked in the tick the request goes out in, which is when its headers take the session.
+  const sentSession = client.hasSessionCredential?.() ?? true;
   const response = await client.getCloudNews(cloudNewsParams(query));
-  if (response.items.length > 0 || query.cursor || normalizeNewsFeed(query) !== "ticker") return response;
+  const read: CloudNewsRead = { ...response, access: cloudNewsAccess(response, sentSession) };
+  if (response.items.length > 0 || query.cursor || normalizeNewsFeed(query) !== "ticker") return read;
   const text = coinSearchName(query.ticker, query.exchange, query.listingName);
-  if (!text) return response;
+  if (!text) return read;
   const found = await client.searchCloudNews(text, query.limit)
     .catch(logFailure("sources.gloomberb-cloud.news", "Search a coin's stories failed", null));
-  return found && found.items.length > 0 ? { items: found.items, nextCursor: null, searchedFor: text } : response;
+  return found && found.items.length > 0
+    ? { items: found.items, nextCursor: null, searchedFor: text, access: cloudNewsAccess(found, sentSession) }
+    : read;
 }
 
 /** A read's stories as articles, each marked with the text a coin's fallback searched for. */

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

@@ -349,6 +349,8 @@ export function mapOptionsChain(
     asOf: chain.asOf,
     // Left absent when the server does not send it, so the date is then established against OPX.
     ...(chain.openInterestAsOf !== undefined ? { openInterestAsOf: chain.openInterestAsOf } : {}),
+    ...(Number.isFinite(chain.rate) ? { rate: chain.rate } : {}),
+    ...(chain.venue ? { venue: chain.venue } : {}),
   };
 }
 

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

@@ -26,6 +26,7 @@ import {
   type CachedFinancialsSelection,
 } from "./financials";
 import type { ProviderRouterCoreDeps } from "./route-types";
+import { isNetworkFailure } from "../../utils/network-failure";
 
 export interface ProviderRouterBatchDeps extends ProviderRouterCoreDeps {
   readCachedMergedFinancialsSelection(
@@ -89,6 +90,7 @@ export class ProviderRouterBatchRoutes {
     const batchProvider = this.deps.providersInPriorityOrder().find((provider) => provider.getQuotesBatch);
     const providerMisses = misses.filter(({ target }) => !this.deps.hasBrokerContext(target.context));
     const providerIndexes = new Map<string, Array<{ index: number; target: QuoteSubscriptionTarget }>>();
+    let batchFailure: unknown = null;
     if (batchProvider && providerMisses.length > 0) {
       for (const entry of providerMisses) {
         const key = this.quoteBatchKey(entry.target);
@@ -97,7 +99,10 @@ export class ProviderRouterBatchRoutes {
         providerIndexes.set(key, bucket);
       }
       const uniqueTargets = [...providerIndexes.values()].map((bucket) => bucket[0]!.target);
-      const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, providerOptions).catch(logFailure("sources.provider-router.batches", "Loading batch quotes failed", []));
+      const batchResults = await batchProvider.getQuotesBatch!(uniqueTargets, providerOptions).catch((error: unknown) => {
+        batchFailure = error;
+        return logFailure("sources.provider-router.batches", "Loading batch quotes failed", [] as QuoteBatchResult[])(error);
+      });
       for (const item of batchResults) {
         if (!isProviderQuoteUsableForCurrentSession(item.quote, item.target.exchange, item.target.symbol, { recentAnswer: true })) continue;
         const key = this.quoteBatchKey(item.target);
@@ -111,12 +116,15 @@ export class ProviderRouterBatchRoutes {
       }
     }
 
+    // The batch never reached the data service: a copy saved a moment ago is still a saved copy, not the
+    // service's answer, so each is asked for as a refresh, which fails at once and says it answers from that copy.
+    const unreached = isNetworkFailure(batchFailure) ? new Set(providerMisses.map(({ index }) => index)) : null;
     await Promise.all(misses.map(async ({ index, target }) => {
       if (results[index]) return;
       try {
         const quote = await this.deps.getQuote(target.symbol, target.exchange, {
           ...target.context,
-          cacheMode: forceRefresh ? "refresh" : "default",
+          cacheMode: forceRefresh || unreached?.has(index) ? "refresh" : "default",
         });
         results[index] = { target, quote };
       } catch (error) {

package/src/sources/provider-router/financial-routes.ts

@@ -16,7 +16,7 @@ import {
   sortCachedRecords,
 } from "./cache";
 import { noProviderError, type ProviderMissNote } from "../provider-errors";
-import { servedFromSavedCopy } from "../../data/saved-copies";
+import { quoteServedFromSavedCopy, servedFromSavedCopy } from "../../data/saved-copies";
 import { withBrokerTimeout } from "./brokers";
 import {
   hasMeaningfulProfile,
@@ -240,7 +240,7 @@ export class ProviderRouterFinancialRoutes {
     }
     if (cached) {
       // The refresh failed rather than finding nothing newer: the saved copy answers, and says so.
-      return misses.failure !== undefined ? servedFromSavedCopy(cached.value, cached.fetchedAt) : cached.value;
+      return misses.failure !== undefined ? quoteServedFromSavedCopy(cached.value, cached.fetchedAt) : cached.value;
     }
     // No source has a current quote: the last price one answered with, flagged
     // stale and dated by its own time, rather than none.
@@ -379,5 +379,5 @@ export class ProviderRouterFinancialRoutes {
 /** Financials as served from their saved copy, with their quote when it is the saved one. */
 function savedFinancials(value: TickerFinancials, savedAt: number, savedQuote: boolean): TickerFinancials {
   const served = servedFromSavedCopy(value, savedAt);
-  return savedQuote && served.quote ? { ...served, quote: servedFromSavedCopy(served.quote, savedAt) } : served;
+  return savedQuote && served.quote ? { ...served, quote: quoteServedFromSavedCopy(served.quote, savedAt) } : served;
 }

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

@@ -3,7 +3,7 @@ import type { AnalystResearchData, CompanyProfile, CorporateActionsData, Financi
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
 import { coalesceFinancialPeriodAliases, mergeFinancialStatementRows } from "../../utils/financial-statements";
 import { normalizePriceHistory, normalizeTickerFinancialsPriceHistory } from "../../utils/price-history";
-import { redactUnavailableFundamentals, RETRACTABLE_VALUATION_FIELDS } from "../../utils/fundamentals";
+import { redactUnavailableFundamentals, RETRACTABLE_VALUATION_FIELDS, RETRACTED_FUNDAMENTALS_FIELDS } from "../../utils/fundamentals";
 import { hasValidQuoteObservationTime, isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "../../market-data/quotes/freshness";
 import { mergeQuoteMetadata, quoteMetadataFromQuote, quoteMetadataMatchesTarget } from "../../market-data/quotes/metadata";
 import { canonicalExchange, parsePublicTickerKey } from "../../utils/exchanges";
@@ -458,12 +458,21 @@ function mergeFundamentals(primary: Fundamentals | undefined, fallback: Fundamen
   const merged = mergeDefinedObject(primary, fallback);
   if (merged) {
     const unavailable = new Set(fallback?.unavailableFields ?? []);
-    for (const field of RETRACTABLE_VALUATION_FIELDS) {
+    for (const field of RETRACTED_FUNDAMENTALS_FIELDS) {
       if (primary?.unavailableFields?.includes(field)) unavailable.add(field);
       else if (typeof primary?.[field] === "number" && Number.isFinite(primary[field])) unavailable.delete(field);
     }
     if (unavailable.size) merged.unavailableFields = [...unavailable];
     else delete merged.unavailableFields;
+    // A retracted cap is none, whatever an older observation held; its reason goes with the retraction that stands.
+    if (unavailable.has("marketCap")) {
+      delete merged.marketCap;
+      merged.marketCapUnavailable = primary?.unavailableFields?.includes("marketCap")
+        ? primary.marketCapUnavailable : fallback?.marketCapUnavailable;
+      if (!merged.marketCapUnavailable) delete merged.marketCapUnavailable;
+    } else {
+      delete merged.marketCapUnavailable;
+    }
   }
   const dividend = primary?.dividendYield != null ? primary : fallback;
   if (merged && dividend) {
@@ -557,7 +566,10 @@ export function mergeRefreshedFinancials(cached: TickerFinancials, fresh: Ticker
   const merged = mergeFinancials(cached, fresh)!;
   const statistics = redactUnavailableFundamentals(fresh?.fundamentals);
   if (!statistics) return merged;
-  const update: Fundamentals = { unavailableFields: statistics.unavailableFields };
+  const update: Fundamentals = {
+    unavailableFields: statistics.unavailableFields,
+    ...statistics.marketCapUnavailable ? { marketCapUnavailable: statistics.marketCapUnavailable } : {},
+  };
   const currencyConflict = cached.fundamentals?.financialCurrency && statistics.financialCurrency
     && cached.fundamentals.financialCurrency !== statistics.financialCurrency;
   for (const field of RETRACTABLE_VALUATION_FIELDS) {

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

@@ -59,6 +59,12 @@ interface HistoryRequestDescriptor {
   interval?: string;
   method: "getPriceHistory" | "getPriceHistoryForResolution" | "getDetailedPriceHistory";
   context?: MarketDataRequestContext;
+  /**
+   * False to fetch from the providers alone: a broker's saved copy still
+   * answers, but a broker is not asked, so reads made for every quote never
+   * spend its request pacing.
+   */
+  askBrokers?: boolean;
   cachePolicyKey: PriceHistoryCachePolicyKey;
   missingProviderError?: string;
   /** `fetchedAt` is when the cached copy was fetched. */
@@ -68,6 +74,11 @@ interface HistoryRequestDescriptor {
   fetchProvider(provider: DataProvider): Promise<PriceHistoryResult | null>;
 }
 
+/** The brokers a request may ask: none for one made for the providers alone. */
+function askedBrokers(request: HistoryRequestDescriptor, candidates: BrokerCandidate[]): BrokerCandidate[] {
+  return request.askBrokers === false ? [] : candidates;
+}
+
 interface HistoryAttempts {
   outcomes: Map<string, HistorySourceOutcome>;
   candidates: Map<string, HistoryRecoveryCandidate>;
@@ -363,8 +374,14 @@ export class ProviderRouterHistoryRoutes {
     }
   }
 
-  async getPriceHistory(ticker: string, exchange: string, range: TimeRange, context?: MarketDataRequestContext): Promise<PricePoint[]> {
-    return (await this.getPriceHistoryWithMetadata(ticker, exchange, range, context)).points;
+  async getPriceHistory(
+    ticker: string,
+    exchange: string,
+    range: TimeRange,
+    context?: MarketDataRequestContext,
+    options: Pick<HistoryRequestDescriptor, "askBrokers"> = {},
+  ): Promise<PricePoint[]> {
+    return (await this.getPriceHistoryWithMetadata(ticker, exchange, range, context, options)).points;
   }
 
   async getPriceHistoryWithMetadata(
@@ -372,6 +389,7 @@ export class ProviderRouterHistoryRoutes {
     exchange: string,
     range: TimeRange,
     context?: MarketDataRequestContext,
+    { askBrokers }: Pick<HistoryRequestDescriptor, "askBrokers"> = {},
   ): Promise<PriceHistoryResult> {
     if (context?.historyRecovery) throw new Error("History recovery requires an exact detailed request");
     const identity = makeHistoryRequestIdentity(this.deps, {
@@ -390,6 +408,7 @@ export class ProviderRouterHistoryRoutes {
       requestedStart: subtractTimeRange(new Date(), range).getTime(),
       method: "getPriceHistory",
       context,
+      askBrokers,
       cachePolicyKey: intraday ? "priceHistoryIntraday" : "priceHistoryDaily",
       missingProviderError: `No history provider available for ${ticker}`,
       isCachedValueStale: (value, fetchedAt) => intraday && resultIsStale(value, ticker, exchange, fetchedAt),
@@ -688,7 +707,9 @@ export class ProviderRouterHistoryRoutes {
     if (usableCached && !forceRefresh && !awaitRefresh) {
       const exactHit = request.exactCacheVariantKeys.includes(cached.variantKey);
       if (refreshDue) {
-        scheduleRouterRevalidation(this.historyRefreshInFlight, request.identity.revalidationKey, () => this.refreshHistory(request));
+        // A refresh from the providers alone never stands in for one that asks the brokers too.
+        const refreshKey = request.askBrokers === false ? `${request.identity.revalidationKey}|providers` : request.identity.revalidationKey;
+        scheduleRouterRevalidation(this.historyRefreshInFlight, refreshKey, () => this.refreshHistory(request));
       }
       // Only a copy a re-check could not replace reaches here short of the latest session.
       const answered = cachedHistoryStale ? { ...cachedValue, savedCopyBehind: true as const } : cachedValue;
@@ -702,7 +723,7 @@ export class ProviderRouterHistoryRoutes {
       if (value.points.length && !hasUsablePriceHistory(value.points)) supersededCacheSources.add(sourceKey);
     };
     const attempts: HistoryAttempts = { outcomes: new Map(), candidates: new Map(), pending: new Set(), misses: {} };
-    const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, brokerCandidates, onUnavailable, attempts));
+    const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, askedBrokers(request, brokerCandidates), onUnavailable, attempts));
     for (const sourceKey of [...attempts.pending]) recordHistoryOutcome(attempts, sourceKey, "timeout");
     if (brokerResult && hasUsablePriceHistory(brokerResult.value.points)) return withReportedGaps(brokerResult.value);
     if (brokerResult) reportedGaps.push(brokerResult.value);
@@ -715,7 +736,7 @@ export class ProviderRouterHistoryRoutes {
     });
     if (providerResult && hasUsablePriceHistory(providerResult.value.points)) return withReportedGaps(providerResult.value);
     if (providerResult) reportedGaps.push(providerResult.value);
-    if (regularSessionBrokers.length) {
+    if (askedBrokers(request, regularSessionBrokers).length) {
       const regularResult = await withBrokerTimeout(this.fetchBrokerHistory(request, regularSessionBrokers, onUnavailable, attempts));
       for (const sourceKey of [...attempts.pending]) recordHistoryOutcome(attempts, sourceKey, "timeout");
       if (regularResult && hasUsablePriceHistory(regularResult.value.points)) return withReportedGaps(regularResult.value);
@@ -785,11 +806,11 @@ export class ProviderRouterHistoryRoutes {
     try {
       const recovery = this.validateRecovery(request);
       const { first, last } = brokersForSession(recovery ? [] : this.deps.getBrokerCandidatesForContext(request.context, false), request.context);
-      const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, first));
+      const brokerResult = await withBrokerTimeout(this.fetchBrokerHistory(request, askedBrokers(request, first)));
       if (brokerResult && hasUsablePriceHistory(brokerResult.value.points)) return;
       const providerResult = await this.fetchProviderHistory(request);
       if (providerResult && hasUsablePriceHistory(providerResult.value.points)) return;
-      if (last.length) await withBrokerTimeout(this.fetchBrokerHistory(request, last));
+      if (askedBrokers(request, last).length) await withBrokerTimeout(this.fetchBrokerHistory(request, last));
     } catch (error) {
       logFailure("sources.provider-router.history", "Refreshing background price history failed")(error);
     }