@gloom-sh/terminal 0.19.1 → 0.19.3

package/src/sources/gloomberb-cloud/fred-series.ts

@@ -1,4 +1,4 @@
-import { createPluginCache } from "../../data/plugin-cache";
+import { createPluginCache, savedCopyForTransientFailure } from "../../data/plugin-cache";
 import { getPublishedUsEquityCalendarDay } from "../../market-data/published-us-sessions";
 import { zonedDateKey } from "../../utils/zoned-date-time";
 import type {
@@ -198,7 +198,9 @@ export async function loadCachedFredSeries(
   const cached = stored ? withFredSourceFreshness(stored) : null;
   if (!options?.force && !pending && cached && !cached.stale) return { ...cached, source: "cache" };
   const result = await cache.load(cacheKey(request), loader, pending ? { ...options, force: true } : options);
-  // An early re-read is opportunistic: a failure keeps the still-fresh copy as it was.
+  // An early re-read is opportunistic: a failure keeps the still-fresh copy as it was, as not asking would have.
   if (pending && result.source === "stale-fallback" && cached && !cached.stale && !options?.force) return { ...cached, source: "cache" };
-  return withFredSourceFreshness(result);
+  // A refusal (a series no longer served, a signed-out session) or a reply that fails validation is thrown,
+  // whatever copy is saved: a saved copy answers only for a failure asking again may get past.
+  return withFredSourceFreshness(savedCopyForTransientFailure(result));
 }

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

@@ -18,6 +18,7 @@ import type {
   EarningsEvent,
   SecFilingDocument,
   SecFilingItem,
+  BatchedReadMethod,
   MarketDataRequestContext,
   QuoteBatchOptions,
   QuoteBatchResult,
@@ -48,7 +49,7 @@ import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss, ProviderBusyError, providerMissReason, StaleHistoryError } from "../provider-errors";
 import { parseListingDelisting } from "../../market-data/quotes/delisting";
-import { isRetryableApiError } from "../../api-client/errors";
+import { isRetryableApiError, markAskedTwice, sourceDidNotAnswer, wasAskedTwice } from "../../api-client/errors";
 import { assertSecRegistrantMatches } from "../sec-registrant";
 import { nonUsSecListingVenue } from "../../utils/sec";
 import { publicListingTarget } from "../listing-target";
@@ -66,6 +67,7 @@ import {
   GLOOMBERB_CLOUD_PROVIDER_ID,
   formatCloudDateTime,
   formatCloudHistoryEnd,
+  isCloudSourceFailure,
   isEmptyCloudStatus,
   mapBatchError,
   NOT_FOUND_REASON,
@@ -86,6 +88,7 @@ import {
   boardSearchesFrom,
 } from "./perpetuals";
 import { predictionMarketListing } from "../../tickers/prediction-listing";
+import { cleanListingName } from "../../tickers/company-name";
 import { settleWithin } from "../../utils/async-deadline";
 import { cloudSearchBatch, cloudTickerChangesBatch } from "./batched-lookups";
 
@@ -127,6 +130,7 @@ function mapCloudSecFiling(item: {
   primaryDocumentUrl?: string;
   fileNumber?: string;
   fundSeries?: boolean;
+  pressReleaseUrl?: string;
 }): SecFilingItem {
   return {
     accessionNumber: item.accessionNumber,
@@ -144,9 +148,20 @@ function mapCloudSecFiling(item: {
     // Absent from an older server: no file number is not the same as an empty one.
     ...(typeof item.fileNumber === "string" ? { fileNumber: item.fileNumber } : {}),
     ...(typeof item.fundSeries === "boolean" ? { fundSeries: item.fundSeries } : {}),
+    ...(typeof item.pressReleaseUrl === "string" && /^https:\/\/www\.sec\.gov\//.test(item.pressReleaseUrl)
+      ? { pressReleaseUrl: item.pressReleaseUrl } : {}),
   };
 }
 
+/** Search rows with a venue's fixed-width name cleaned of the stray code after its spaces ("Americold Realty Trust Inc.   R"). */
+function withCleanNames<T extends { name: string }>(rows: T[]): T[] {
+  return rows.map((row) => {
+    if (typeof row.name !== "string") return row;
+    const name = cleanListingName(row.name);
+    return name === row.name ? row : { ...row, name };
+  });
+}
+
 function isCloudProviderMiss(error: unknown): boolean {
   const message = error instanceof Error ? error.message : String(error);
   return CLOUD_PROVIDER_MISS_PATTERNS.some((pattern) => pattern.test(message));
@@ -420,6 +435,8 @@ function unwrapRequiredCloudResponse<T>(response: CloudMarketResponse<T>, messag
   if (isEmptyCloudStatus(response.status)) {
     throw createProviderMiss(response.reasonCode ?? message, response.message, { notFound: response.reasonCode === NOT_FOUND_REASON });
   }
+  // The service's own source failed on a listing read asked twice (`readListing`): not an answer that the listing has nothing.
+  if (isCloudSourceFailure(response.status) && wasAskedTwice(response)) throw markAskedTwice(sourceDidNotAnswer(response.reasonCode ?? message));
   throw new Error(response.reasonCode ?? message);
 }
 
@@ -647,7 +664,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const pending = searchPerpetualMarkets(query).catch(logFailure("sources.gloomberb-cloud.index", "Searching perpetual markets failed", [] as InstrumentSearchResult[]));
     // A crypto exchange's line of a coin pair, which no source quotes, is offered as the crypto venue's listing.
     const listings = await withCloudFallback(
-      async () => withExchangeLinesAsCoinListings(await apiClient.searchInstruments(query, context?.limit ?? 10)),
+      async () => withExchangeLinesAsCoinListings(withCleanNames(await apiClient.searchInstruments(query, context?.limit ?? 10))),
       "Cloud search is unavailable",
     ).catch((error: unknown) => {
       // Rate limited or overloaded: the search was not run, which is not a search that found nothing.
@@ -764,7 +781,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
   async searchBatch(queries: string[], options: { limit?: number; signal?: AbortSignal } = {}): Promise<Map<string, InstrumentSearchResult[]> | null> {
     const answers = await cloudSearchBatch(queries, options);
     if (!answers) return null;
-    for (const [query, rows] of answers) answers.set(query, withExchangeLinesAsCoinListings(rows));
+    for (const [query, rows] of answers) answers.set(query, withExchangeLinesAsCoinListings(withCleanNames(rows)));
     // Perpetual markets lead each answer, as `search` gives them, so a symbol in a list resolves as it does alone:
     // one read of the board answers every query's search of it. A query that found no listing is searched again
     // on its own, which finds them then; a board that does not answer leaves them out, as a search does.
@@ -818,7 +835,8 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     exchange = target.exchange ?? "";
     const request = toHistoryRequest(range);
     const { response, extendedHours } = await withCloudFallback(
-      () => loadCloudHistory(request.interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, { ...request, ...(session ? { session } : {}) }), _context),
+      () => loadCloudHistory(request.interval, (session) => apiClient.getCloudHistory(target.symbol, exchange, { ...request, ...(session ? { session } : {}) },
+        { batch: _context?.batch }), _context),
       `Cloud chart data is unavailable for ${ticker}`,
     );
     return mapCloudPriceHistory(response, target.symbol, exchange, request.interval, subtractTimeRange(new Date(), range), undefined, extendedHours);
@@ -905,11 +923,16 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return mapCloudPriceHistory(response, target.symbol, exchange, interval, startDate, endDate, extendedHours);
   }
 
+  /** Trailing history and dated expiries asked with others (`batch`) go out as batch requests while the service reads them so. */
+  batchesReads(method: BatchedReadMethod): boolean {
+    return apiClient.batchesReads(method === "getPriceHistory" ? "history" : "options");
+  }
+
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, _context?: MarketDataRequestContext): Promise<OptionsChain> {
     rejectPerpetual(ticker, exchange, "options chains");
     const target = cloudInstrumentTarget(ticker, exchange);
     return withCloudFallback(async () => {
-      const response = await apiClient.getCloudOptionsChain(target.symbol, target.exchange, expirationDate);
+      const response = await apiClient.getCloudOptionsChain(target.symbol, target.exchange, expirationDate, { batch: _context?.batch });
       const chain = unwrapRequiredCloudResponse(
         response,
         `Cloud options chains are unavailable for ${ticker}`,

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

@@ -28,13 +28,34 @@ function uniqueStrings(values: string[]): string[] {
   return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
 }
 
+type CloudNewsTickerLink = CloudNewsPayload["tickerLinks"][number];
+
+const statesMarketCap = (link: CloudNewsTickerLink) => typeof link.marketCap === "number" && link.marketCap > 0;
+
+/**
+ * One link a company: a symbol a story tags on several venues (ASML on
+ * Euronext Amsterdam and on NASDAQ) keeps its home listing, the line Gloom
+ * Cloud states the company's market cap on, else the venue tagged first. The
+ * tag stays where the company was first tagged.
+ */
+function homeListingLinks(links: readonly CloudNewsTickerLink[]): CloudNewsTickerLink[] {
+  const companies = new Map<string, CloudNewsTickerLink>();
+  links.forEach((link, index) => {
+    const symbol = link.symbol?.trim().toUpperCase() || `#${index}`;
+    const kept = companies.get(symbol);
+    if (!kept || (!statesMarketCap(kept) && statesMarketCap(link))) companies.set(symbol, link);
+  });
+  return [...companies.values()];
+}
+
 function mapCloudNewsTickers(
   item: CloudNewsPayload,
   fallbackTicker?: string,
 ): string[] {
-  const tickers = collectNewsDisplayTickers(
-    item.tickerLinks.flatMap((link) => [link.symbol, link.canonicalTicker]),
-  );
+  // Each company's listing: its canonical key, or its symbol on its venue.
+  const tickers = collectNewsDisplayTickers(homeListingLinks(item.tickerLinks).map((link) => (
+    link.canonicalTicker || (link.symbol && link.exchange ? `${link.symbol}:${link.exchange}` : link.symbol)
+  )));
   const fallbackTickers = collectNewsDisplayTickers([fallbackTicker]);
   if (tickers.length === 0) tickers.push(...fallbackTickers);
   return tickers;

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

@@ -86,8 +86,8 @@ export function mapQuote(
   const changePercent = !impossibleClose && typeof quote.changePercent === "number" && Number.isFinite(quote.changePercent)
     ? quote.changePercent
     : Number.NaN;
-  // A generic future (VX1, TY1) reads in points or 32nds, and an index future's
-  // continuous symbol or contract (ES=F, SXOZ26.CME) in points, not dollars.
+  // Generics, continuous symbols and listed contracts share their root's
+  // price basis: index futures in points and Treasury futures in 32nds.
   const futuresBasis = isNonFutureType(quote.instrumentType) ? null
     : futuresListingPriceBasis(quote.symbol, quote.listingExchangeName ?? quote.exchangeName);
   const priceObservation = quote.priceBasis === "nav" ? "nav" : undefined;
@@ -234,6 +234,11 @@ function venueVolume(value: unknown): { venueVolume: { venue: string; volume: nu
     : null;
 }
 
+/** What a served bar's volume counts, when it is a short plain phrase (`aggregate`, `3 spot venues`). */
+function volumeBasis(value: unknown): { volumeBasis: string } | null {
+  return typeof value === "string" && /^[a-z0-9][a-z0-9 ]{0,31}$/i.test(value.trim()) ? { volumeBasis: value.trim() } : null;
+}
+
 /**
  * One served bar. `coin`: the bars are a coin's, which trades every hour of every day. Its intraday volume is the
  * value traded in the bar on major spot venues, and a bar no venue reported has none rather than 0, so a 0 (from an
@@ -254,12 +259,17 @@ export function mapPricePoint(
     close: normalizePriceValueByDivisor(point.close, divisor) ?? point.close,
     volume: coin && point.volume === 0 ? undefined : point.volume,
     ...(venueVolume(point.venueVolume) ?? {}),
+    ...(volumeBasis(point.volumeBasis) ?? {}),
     ...(point.partial === true ? { partial: true } : {}),
     ...(point.filled === true ? { filled: true } : {}),
     ...(point.unsettled === true ? { unsettled: true } : {}),
+    ...(typeof point.contract === "string" && FUTURES_CONTRACT_CODE.test(point.contract) ? { contract: point.contract } : {}),
   };
 }
 
+/** A listed contract as a continuous future's bar names it: root, month letter and year (NGZ26, ZQF27). */
+const FUTURES_CONTRACT_CODE = /^[A-Z0-9]{1,4}[FGHJKMNQUVXZ]\d{2}$/;
+
 /** Per-share bases the statistics block serves beside its multiples. */
 const CLOUD_PER_SHARE_BASES = ["forwardEps", "dividendRate"] as const;
 
@@ -363,6 +373,11 @@ export function isEmptyCloudStatus(
   return status === "empty" || status === "unsupported";
 }
 
+/** The service answered that its own source failed: `retryable_error`, or `fatal_error`, its catch-all for an upstream error. */
+export function isCloudSourceFailure(status: CloudMarketResponse<unknown>["status"]): boolean {
+  return status === "retryable_error" || status === "fatal_error";
+}
+
 export function mapBatchError<T>(
   item: CloudMarketBatchItem<T>,
   fallbackMessage: string,

package/src/sources/provider-errors.ts

@@ -1,4 +1,5 @@
 import { DataServiceUnreachableError, isNetworkFailure } from "../utils/network-failure";
+import { wasAskedTwice } from "../api-client/errors";
 
 // Registered, so a miss raised by another copy of this module (a plugin that
 // resolved `gloomberb/market-data` from the source tree) is still recognized.
@@ -129,6 +130,16 @@ export function isNoProviderMessage(message: string): boolean {
   return /\bprovider available for\b/i.test(message) || notATickerSymbol(message) !== null;
 }
 
+/**
+ * What a read says when Gloom's data service answered that its source failed,
+ * having been asked twice (`readListing`): the listing is not said to have no
+ * data, since asked again in a moment it may. "for SYMBOL" closes the first
+ * sentence, so a table's note can name several symbols in front of it.
+ */
+export function serviceDidNotAnswerMessage(symbol?: string): string {
+  return `Gloom's data service did not answer${symbol ? ` for ${symbol}` : ""}. Try again in a moment.`;
+}
+
 /** The router's generic answer that no provider served a request, holding the failure behind it when a provider failed rather than missed. */
 class NoProviderError extends Error {
   constructor(message: string, readonly failure: unknown) {
@@ -139,9 +150,11 @@ class NoProviderError extends Error {
 /**
  * The router's final error when no provider answered. A reason a provider gave
  * replaces the generic wording, and so does the service's answer that no
- * listing exists for `symbol` ("Not a ticker"), and a request that never
- * reached the data service, which says that rather than that no source has the
- * symbol; a timeout or any other failure keeps the generic message.
+ * listing exists for `symbol` ("Not a ticker"), a request that never reached
+ * the data service, and a listing read the data service failed to answer twice
+ * (`wasAskedTwice`, `serviceDidNotAnswerMessage`), each of which says that
+ * rather than that no source has the symbol; any other failure, a 5xx on a read
+ * that is not asked again among them, keeps the generic message.
  */
 export function noProviderError(message: string, note: ProviderMissNote | undefined, symbol?: string): Error {
   if (note?.reason) return createProviderMiss(note.reason, note.reason);
@@ -149,9 +162,19 @@ export function noProviderError(message: string, note: ProviderMissNote | undefi
   if (isNetworkFailure(note?.failure)) {
     return note!.failure instanceof DataServiceUnreachableError ? note!.failure : new DataServiceUnreachableError(note!.failure);
   }
+  if (wasAskedTwice(note?.failure)) return new NoProviderError(serviceDidNotAnswerMessage(symbol), note!.failure);
   return new NoProviderError(message, note?.failure);
 }
 
+/**
+ * The router's answer that no source served a read because one failed (a
+ * timeout, a rate limit, a refused session), not because none has it: asked
+ * again shortly it may answer.
+ */
+export function isSourceFailure(error: unknown): boolean {
+  return error instanceof NoProviderError && error.failure !== undefined;
+}
+
 /**
  * Whether a failed read means no source has what was asked for: a source's
  * miss, or the router's answer that none served it when none failed another

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

@@ -781,6 +781,11 @@ export class ProviderRouterHistoryRoutes {
       throw noProviderError(coin ? `No source could load history for ${request.target.symbol} just now` : request.missingProviderError,
         attempts.misses, request.target.symbol);
     }
+    // A window of dates no source could answer, because one failed rather than had nothing, is that failure:
+    // an empty answer would read as no bars in the window (`history --from` printing "0 bars").
+    if (!providerResult && attempts.misses.failure !== undefined && !reportedGaps.some((value) => value.points.length > 0)) {
+      throw noProviderError(`No source could load history for ${request.target.symbol} just now`, attempts.misses, request.target.symbol);
+    }
     return withReportedGaps(providerResult?.value ?? { points: [], resolution: historyResolutionForInterval(request.interval) });
   }
 

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

@@ -9,6 +9,7 @@ import { createDefaultConfig } from "../../types/config";
 import type {
   CachedAssetArgs,
   CachedAssetMethod,
+  BatchedReadMethod,
   CachedFinancialsTarget,
   DataProvider,
   MarketDataRequestContext,
@@ -631,6 +632,18 @@ export class AssetDataRouter implements DataProvider {
     return this.providersInPriorityOrder()[0]?.name ?? null;
   }
 
+  /**
+   * Whether reads of `method` asked together go out as batch requests: only
+   * when every source the router could ask for them does, each broker that
+   * reads them and each provider. A caller asking many at once then never
+   * sends them one by one to a source that takes them one by one.
+   */
+  batchesReads(method: BatchedReadMethod): boolean {
+    if (this.getBrokerCandidatesForContext(undefined, false).some(({ broker }) => typeof broker[method] === "function")) return false;
+    const providers = this.providersInPriorityOrder().filter((provider) => typeof provider[method] === "function");
+    return providers.length > 0 && providers.every((provider) => provider.batchesReads?.(method) === true);
+  }
+
   private providersInPriorityOrder(): DataProvider[] {
     const providers = [...this.sortedProviders()];
     const fallbackProvider = this.fallbackSource?.market ?? null;

package/src/sync/core-contributors.ts

@@ -39,6 +39,7 @@ import { getBrokerInstance } from "../utils/broker-instances";
 import { withoutMissingWatchlists } from "../portfolio/mutations";
 import { mergeSuffixedListings, moveTargetWeights } from "../portfolio/suffixed-listings";
 import { positionContractMultiplier } from "../portfolio/position-metrics";
+import { reportTelemetryConfig } from "../telemetry/live-config";
 import {
   clearLeftoverBrokerHoldings,
   knownBrokerHoldings,
@@ -421,9 +422,36 @@ function collectCoreConfigPayload(config: AppConfig) {
     // 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,
+    // Only whether Attention Counts is off: see mergedAttentionTelemetry.
+    attentionOff: config.telemetry?.attention === false,
   });
 }
 
+/**
+ * Attention Counts off belongs to the signed-in account, not to one device:
+ * an off made on another device turns it off here, and an explicit on made
+ * there afterwards turns it back on. The default never overrides either. An
+ * edit made here since the last sync wins, like any setting. No synced copy,
+ * or one from before `attentionOff` existed, reads as not off: a device's
+ * first sync takes an off already on the account, and keeps its own off
+ * instead of taking an on.
+ */
+function mergedAttentionTelemetry(
+  config: AppConfig,
+  baselineConfig: AppConfig,
+  payload: Record<string, unknown>,
+  lastSynced: Record<string, unknown> | null,
+): AppConfig["telemetry"] {
+  // A copy pushed by an older build says nothing either way.
+  if (typeof payload.attentionOff !== "boolean") return config.telemetry;
+  const localOff = config.telemetry?.attention === false;
+  if (payload.attentionOff === localOff) return config.telemetry;
+  const editedHere = localOff !== (baselineConfig.telemetry?.attention === false)
+    || localOff !== (lastSynced?.attentionOff === true);
+  if (editedHere) return config.telemetry;
+  return { ...config.telemetry, attention: !payload.attentionOff };
+}
+
 function positionValueBase(
   ticker: TickerRecord,
   position: TickerPosition,
@@ -957,6 +985,8 @@ function mergeConfigPayload(
   assign("valueFlashingEnabled");
   assign("recentTickers");
   assign("recentCommands");
+  const telemetry = mergedAttentionTelemetry(config, baselineConfig, payload, lastSynced);
+  if (telemetry !== config.telemetry) next.telemetry = telemetry;
   // Sync can complete onboarding on another device, but never reopen it.
   // Resumable progress remains local until this installation completes it.
   if (
@@ -1420,6 +1450,8 @@ export const coreConfigSyncContributor: SyncContributor = {
           activeLayoutIndex: nextConfig.activeLayoutIndex,
         });
       }
+      // An Attention Counts off from another device drops unsent counts before React commits.
+      if (nextConfig.telemetry !== getState().config.telemetry) reportTelemetryConfig(nextConfig.telemetry);
       dispatch({ type: "SET_CONFIG", config: nextConfig });
       if (!removed) scheduleConfigSave(nextConfig);
     }

package/src/telemetry/attention-counts.ts

@@ -2,9 +2,11 @@ import { logFailure } from "../utils/log-failure";
 import { apiClient } from "../api-client";
 import type { AttentionAction, AttentionCountsPayload } from "../api-client/telemetry";
 import { CHART_COMPOSER_PANE_ID, TICKER_RESEARCH_PANE_ID, type TelemetryConfig } from "../types/config";
+import { attentionNoticeShown } from "./attention-setting";
 import { telemetryOptedOut } from "./crash-reports";
-import { subscribeTelemetryConfig } from "./live-config";
+import { currentTelemetryConfig, subscribeTelemetryConfig } from "./live-config";
 import { automationActive } from "./usage-counts";
+import { cloudSyncController } from "../sync/controller";
 
 const FLUSH_MS = 60_000;
 const MAX_AGE_MS = 120_000;
@@ -13,12 +15,19 @@ const MAX_EVENTS = 100;
 const SYMBOL = /^[A-Z0-9^][A-Z0-9.^_:/=-]{0,63}$/;
 const ACTIONS = new Set<AttentionAction>(["des", "chart", "quote", "option_chain", "watchlist_add"]);
 
-/** Ticker-level counting always requires its own explicit consent. */
+/**
+ * Whether `account`'s ticker opens count. On by default: an explicit `true`
+ * counts, `false` never does, and while the setting is untouched the account
+ * counts only once this installation has drawn the notice for it.
+ */
 export function attentionCountsEnabled(
   config: { telemetry?: TelemetryConfig } | null | undefined,
+  account: string | null,
   env: Record<string, string | undefined> = {},
 ): boolean {
-  return config?.telemetry?.attention === true && !telemetryOptedOut(env);
+  const telemetry = config?.telemetry;
+  if (telemetryOptedOut(env) || telemetry?.attention === false) return false;
+  return telemetry?.attention === true || attentionNoticeShown(telemetry, account);
 }
 
 interface AttentionHost {
@@ -136,26 +145,75 @@ export class AttentionCounter {
 }
 
 let counter: AttentionCounter | null = null;
+let collectionAllowed: (() => boolean) | null = null;
+
+interface AttentionCounterOptions {
+  /** False under a privacy signal (`DO_NOT_TRACK`, browser Do Not Track or GPC): nothing counts and no notice shows. */
+  allowed(): boolean;
+  /** The config the surface launched with; the app's live switches replace it once reported. */
+  launchConfig(): { telemetry?: TelemetryConfig } | null | undefined;
+  /**
+   * Whether this surface has the signed-in account's synced settings, so an
+   * Attention Counts off made on another device has arrived before anything
+   * counts. Defaults to this session's cloud sync having pulled them; without
+   * cloud sync nothing counts. A popped-out desktop window gets them from the
+   * main window instead.
+   */
+  accountSettingsPulled?(): boolean;
+}
+
+function cloudSettingsPulled(): boolean {
+  return cloudSyncController.getStatus().lastPullAt !== null;
+}
 
 /** Installed only by interactive terminal, desktop and web entry points. */
-export function installAttentionCounter(isEnabled: () => boolean): () => void {
+export function installAttentionCounter({
+  allowed,
+  launchConfig,
+  accountSettingsPulled = cloudSettingsPulled,
+}: AttentionCounterOptions): () => void {
   counter?.dispose();
   const next = new AttentionCounter({
-    isEnabled,
+    isEnabled: () => allowed()
+      && accountSettingsPulled()
+      && attentionCountsEnabled(currentTelemetryConfig(launchConfig()), apiClient.getCurrentUser()?.id ?? null),
     verifiedSession: () => apiClient.getVerifiedSessionIdentity(),
     send: (payload, signal) => apiClient.reportAttentionCounts(payload, signal),
   });
   counter = next;
+  collectionAllowed = allowed;
   const config = subscribeTelemetryConfig(() => next.refresh());
   const auth = apiClient.subscribeCurrentUser(() => next.refresh());
   return () => {
     next.dispose();
     config();
     auth();
-    if (counter === next) counter = null;
+    if (counter === next) {
+      counter = null;
+      collectionAllowed = null;
+    }
   };
 }
 
+/**
+ * Whether this surface counts at all: an interactive entry point installed
+ * the collector and no privacy signal is set. The notice shows only here, so
+ * CLI commands, `shot`, tests and opted-out environments never draw it.
+ */
+export function attentionCollectionAvailable(): boolean {
+  try {
+    return counter !== null && collectionAllowed?.() === true;
+  } catch {
+    // Intentional ignore: an unreadable privacy signal counts as set.
+    return false;
+  }
+}
+
+/** Sends what the installed counter holds now instead of after its delay. */
+export async function __flushAttentionCountsForTests(): Promise<void> {
+  await counter?.flush();
+}
+
 export function captureAttentionAction(): (symbol: string, action: AttentionAction) => void {
   return counter?.capture() ?? (() => {});
 }

package/src/telemetry/attention-setting.ts

@@ -0,0 +1,33 @@
+import type { TelemetryConfig } from "../types/config";
+
+/**
+ * The Attention Counts setting, apart from the collector. It is on by
+ * default: `telemetry.attention: false` turns it off and `true` is an
+ * explicit on. While it is unset, an account counts only after this
+ * installation has drawn the one-time notice for it; an explicit choice
+ * either way never needs the notice. While signed in, an off is the
+ * account's: cloud sync carries it to the account's other devices
+ * (`mergedAttentionTelemetry` in sync/core-contributors.ts).
+ */
+
+/** What switching off says, from the notice or the command bar: counting stops, published totals stay. */
+export const ATTENTION_OFF_MESSAGE = "Attention Counts is off. Totals already published can't be withdrawn.";
+
+/** How many accounts an installation remembers showing the notice to. */
+export const ATTENTION_NOTICE_ACCOUNTS = 20;
+
+export function attentionNoticeShown(telemetry: TelemetryConfig | undefined, account: string | null): boolean {
+  return account !== null && (telemetry?.attentionNoticeShownTo?.includes(account) ?? false);
+}
+
+/** Whether `account` is waiting for the notice: the setting is untouched and this installation never showed it. */
+export function attentionNoticeDue(telemetry: TelemetryConfig | undefined, account: string | null): boolean {
+  return account !== null && telemetry?.attention === undefined && !attentionNoticeShown(telemetry, account);
+}
+
+/** Records that the notice was drawn for `account`. The same object when it already was. */
+export function withAttentionNoticeShown(telemetry: TelemetryConfig | undefined, account: string): TelemetryConfig | undefined {
+  if (attentionNoticeShown(telemetry, account)) return telemetry;
+  const accounts = [...(telemetry?.attentionNoticeShownTo ?? []), account].slice(-ATTENTION_NOTICE_ACCOUNTS);
+  return { ...telemetry, attentionNoticeShownTo: accounts };
+}

package/src/telemetry/crash-reports-node.ts

@@ -2,6 +2,7 @@ import { logFailure } from "../utils/log-failure";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { homedir, release } from "os";
 import { join } from "path";
+import { writePrivateFileSync } from "../utils/private-files";
 import type { CrashReportSurface } from "../api-client";
 import type { TelemetryConfig } from "../types/config";
 import {
@@ -109,7 +110,8 @@ export function createNodeCrashReporterHost(options: NodeCrashReporterHostOption
       const dir = dataDir();
       if (!dir) return;
       const reports = [...readSpool(dir), report].slice(-MAX_SPOOLED_REPORTS);
-      writeFileSync(spoolPath(dir), JSON.stringify(reports), "utf-8");
+      // Readable by the user alone: a report's stack names the user's files.
+      writePrivateFileSync(spoolPath(dir), JSON.stringify(reports));
     },
     clearSpool: () => {
       const dir = dataDir();

package/src/telemetry/stall-clocks.ts

@@ -0,0 +1,93 @@
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import type { StallClockReading } from "../utils/main-thread-stall";
+
+/** macOS `clock_gettime_nsec_np` clocks: awake time (stops in sleep), and this thread's CPU time. */
+const DARWIN_CLOCK_UPTIME_RAW = 8;
+const DARWIN_CLOCK_THREAD_CPUTIME_ID = 16;
+/** Linux `clock_gettime` clocks: awake time (stops in suspend), and this thread's CPU time. */
+const LINUX_CLOCK_MONOTONIC = 1;
+const LINUX_CLOCK_THREAD_CPUTIME_ID = 3;
+/** Windows counts both in 100 ns units. */
+const WINDOWS_TICKS_PER_MS = 10_000;
+
+type PlatformClocks = () => Pick<StallClockReading, "awakeMs" | "threadCpuMs">;
+
+function processCpuMs(): number | null {
+  if (typeof process.cpuUsage !== "function") return null;
+  const usage = process.cpuUsage();
+  return (usage.user + usage.system) / 1_000;
+}
+
+/**
+ * Windows: QueryUnbiasedInterruptTime leaves out sleep and hibernation (the
+ * clock timers read keeps counting through them), and GetThreadTimes gives
+ * the calling thread's kernel and user time.
+ */
+function windowsClocks(): PlatformClocks {
+  const kernel32 = dlopen("kernel32.dll", {
+    QueryUnbiasedInterruptTime: { args: [FFIType.ptr], returns: FFIType.bool },
+    // A handle as a 64-bit integer: the pseudo-handle is -2, which a pointer as a JS number would not keep exactly.
+    GetCurrentThread: { args: [], returns: FFIType.u64 },
+    GetThreadTimes: { args: [FFIType.u64, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr], returns: FFIType.bool },
+  });
+  // A pseudo-handle: whichever thread passes it means itself.
+  const thread = kernel32.symbols.GetCurrentThread();
+  const awake = new BigUint64Array(1);
+  // Creation, exit, kernel and user time.
+  const times = new BigUint64Array(4);
+  return () => ({
+    awakeMs: kernel32.symbols.QueryUnbiasedInterruptTime(ptr(awake)) ? Number(awake[0]!) / WINDOWS_TICKS_PER_MS : null,
+    threadCpuMs: thread && kernel32.symbols.GetThreadTimes(thread, ptr(times), ptr(times, 8), ptr(times, 16), ptr(times, 24))
+      ? Number(times[2]! + times[3]!) / WINDOWS_TICKS_PER_MS
+      : null,
+  });
+}
+
+function darwinClocks(): PlatformClocks {
+  const libc = dlopen("/usr/lib/libSystem.B.dylib", {
+    clock_gettime_nsec_np: { args: [FFIType.u32], returns: FFIType.u64 },
+  });
+  const read = (clock: number): number | null => {
+    const nanoseconds = Number(libc.symbols.clock_gettime_nsec_np(clock));
+    return nanoseconds > 0 ? nanoseconds / 1e6 : null;
+  };
+  return () => ({ awakeMs: read(DARWIN_CLOCK_UPTIME_RAW), threadCpuMs: read(DARWIN_CLOCK_THREAD_CPUTIME_ID) });
+}
+
+function linuxClocks(): PlatformClocks {
+  const libc = dlopen("libc.so.6", {
+    clock_gettime: { args: [FFIType.i32, FFIType.ptr], returns: FFIType.i32 },
+  });
+  // struct timespec: seconds, nanoseconds.
+  const time = new BigInt64Array(2);
+  const read = (clock: number): number | null => (
+    libc.symbols.clock_gettime(clock, ptr(time)) === 0 ? Number(time[0]!) * 1_000 + Number(time[1]!) / 1e6 : null
+  );
+  return () => ({ awakeMs: read(LINUX_CLOCK_MONOTONIC), threadCpuMs: read(LINUX_CLOCK_THREAD_CPUTIME_ID) });
+}
+
+function platformClocks(): PlatformClocks | null {
+  try {
+    if (process.platform === "win32") return windowsClocks();
+    if (process.platform === "darwin") return darwinClocks();
+    if (process.platform === "linux") return linuxClocks();
+  } catch {
+    // Intentional ignore: without the platform's clocks a stall still counts, only its cause stays unknown.
+  }
+  return null;
+}
+
+/**
+ * The clocks the stall monitor reads on each check, for the thread that
+ * calls this: the thread's CPU time is the caller's own. A platform whose
+ * clocks cannot be loaded gives the process's CPU time alone.
+ */
+export function createStallClocks(): () => StallClockReading {
+  const platform = platformClocks();
+  return () => ({
+    awakeMs: null,
+    threadCpuMs: null,
+    ...platform?.(),
+    processCpuMs: processCpuMs(),
+  });
+}