@gloom-sh/terminal 0.18.5 → 0.19.1

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

@@ -1,4 +1,5 @@
 import { logFailure } from "../../utils/log-failure";
+import { readCompanyFrom } from "../../types/company-from";
 import { exchangeRateMetadata } from "../../utils/exchange-rate-snapshot";
 import type { ExchangeRateSnapshot } from "../../types/exchange-rate";
 import type { TimeRange } from "../../time-series/range";
@@ -42,7 +43,7 @@ import {
 import type { NewsArticle, NewsQuery } from "../../types/news-source";
 import { normalizeNewsFeed } from "../../news/news-model";
 import { resolveCurrencyUnit } from "../../utils/currency-units";
-import { isRoundTheClockCoin } from "../../utils/crypto-pair";
+import { exchangeLineCoinListing, isRoundTheClockCoin, withExchangeLinesAsCoinListings } from "../../utils/crypto-pair";
 import { canonicalExchange, canonicalTickerKey, parsePublicTickerKey } from "../../utils/exchanges";
 import { normalizePriceHistory, priceHistoryIntervalMs, reachesLatestSettledSession } from "../../utils/price-history";
 import { createProviderMiss, ProviderBusyError, providerMissReason, StaleHistoryError } from "../provider-errors";
@@ -315,14 +316,35 @@ function cloudResponseTargetKey(key: string, requested: Set<string>): string | u
 
 /**
  * The listing as Gloom Cloud knows it. A Hong Kong code goes out with its four
- * digits: Cloud has no 700 or 5 on HKEX, only 0700 and 0005.
+ * digits: Cloud has no 700 or 5 on HKEX, only 0700 and 0005. A crypto
+ * exchange's line of a coin pair (BTC/GBP on COINBASE PRO), which no source
+ * quotes, goes out as the crypto venue's listing of the pair, BTC-GBP on CCC.
  */
 function cloudInstrumentTarget(symbol: string, exchange?: string) {
   rejectPredictionMarket(symbol, exchange);
   const target = publicListingTarget(symbol, exchange);
+  const coin = exchangeLineCoinListing(target.symbol, target.exchange);
+  if (coin) return { symbol: coin.symbol, exchange: coin.exchange };
   return target.exchange ? { ...target, symbol: hongKongListingCode(target.symbol, target.exchange) } : target;
 }
 
+/**
+ * Whether a quote names a listing other than the one asked for: asked for BHP
+ * on Cboe Australia, Gloom Cloud has answered with BHP on NYSE, in dollars. A
+ * price for another instrument is worse than none. A quote that names no
+ * listing is judged by its symbol alone, as the router judges it.
+ */
+function pricesOtherListing(quote: Quote, target: ReturnType<typeof cloudInstrumentTarget>): boolean {
+  const metadata = quoteMetadataFromQuote(quote);
+  const named = !!(metadata.listingExchangeName || parsePublicTickerKey(quote.symbol).exchange);
+  return !quoteMetadataMatchesTarget(metadata, named ? target.symbol : parsePublicTickerKey(target.symbol).symbol, named ? target.exchange : undefined);
+}
+
+function otherListingMiss(ticker: string, quote: Quote) {
+  const venue = quote.listingExchangeName || quote.exchangeName || parsePublicTickerKey(quote.symbol).exchange;
+  return createProviderMiss(`Cloud quoted ${quote.symbol}${venue ? ` on ${venue}` : ""} for ${ticker}`);
+}
+
 function cloudHistoryRecovery(
   context: MarketDataRequestContext | undefined,
   ticker: string, symbol: string, exchange: string, interval: string, start: Date, end: Date,
@@ -520,10 +542,12 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     return withCloudFallback(
       async () => {
         const response = await apiClient.getCloudQuote(target.symbol, target.exchange);
-        const quote = retainRequestedQuoteSymbol(mapQuote(
+        const answered = mapQuote(
           unwrapRequiredCloudResponse(response, `Cloud quotes are unavailable for ${ticker}`),
           response.providerMeta,
-        ), ticker);
+        );
+        if (pricesOtherListing(answered, target)) throw otherListingMiss(ticker, answered);
+        const quote = retainRequestedQuoteSymbol(answered, ticker);
         // A stale answer is the last price the service has. It stays flagged, so
         // no freshness check passes it and only a request with no current quote
         // from any source falls back to it.
@@ -585,7 +609,11 @@ export class GloomberbCloudProvider implements AssetDataProvider {
           return { target, quote: null, error: createProviderMiss(`Cloud quotes are stale for ${target.symbol}`) };
         }
         if ((item.status === "success" || item.status === "partial") && item.data) {
-          const quote = retainRequestedQuoteSymbol(mapQuote(item.data), target.symbol);
+          const answered = mapQuote(item.data);
+          if (pricesOtherListing(answered, cloudInstrumentTarget(target.symbol, target.exchange))) {
+            return { target, quote: null, error: otherListingMiss(target.symbol, answered) };
+          }
+          const quote = retainRequestedQuoteSymbol(answered, target.symbol);
           return { target, quote: item.stale === true ? { ...quote, stale: true } : quote };
         }
         return {
@@ -617,8 +645,9 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     // Perpetual markets are listings too, asked for beside the others. They are optional: a failed lookup leaves the
     // other results, and a keystroke waits for them only briefly once the listings are in, unless the query names one.
     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(
-      () => apiClient.searchInstruments(query, context?.limit ?? 10),
+      async () => withExchangeLinesAsCoinListings(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.
@@ -637,9 +666,12 @@ export class GloomberbCloudProvider implements AssetDataProvider {
     const name = venue ? context?.listingName?.trim() || await this.listingName(ticker, venue) || undefined : undefined;
     const filings = await withCloudFallback(async () => {
       const response = await apiClient.getCloudSecFilings({ ticker, exchange, name, limit: count, offset: 0 });
-      return response.filings.map(mapCloudSecFiling);
+      // A foreign line's filings read from its company's home line say whose, each of them.
+      const companyFrom = readCompanyFrom(response.companyFrom);
+      return response.filings.map((filing) => companyFrom ? { ...mapCloudSecFiling(filing), companyFrom } : mapCloudSecFiling(filing));
     }, `Cloud SEC filings are unavailable for ${ticker}`);
-    if (!venue || filings.length === 0) return filings;
+    // The service matched a line read from its company's home line to the company itself.
+    if (!venue || filings.length === 0 || filings[0]!.companyFrom) return filings;
     const symbol = parsePublicTickerKey(ticker).symbol;
     // Without the listing's company the filings cannot be told apart from another company's.
     if (!name) throw createProviderMiss(`SEC filings for ${symbol} could not be matched to its ${venue} listing`);
@@ -732,6 +764,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));
     // 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.
@@ -964,6 +997,8 @@ export function createGloomberbCloudCapabilities(provider = createGloomberbCloud
           return {
             articles: cloudNewsReadArticles(read, query.ticker),
             nextCursor: read.nextCursor ?? null,
+            access: read.access ?? null,
+            companyFrom: readCompanyFrom(read.companyFrom),
           };
         },
         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/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/index.ts

@@ -53,6 +53,7 @@ import { ProviderRouterSearchRoutes } from "./search";
 import { collectCapabilityRouteSources, normalizeRouteSource } from "./sources";
 import type { ProviderRouterCoreDeps } from "./route-types";
 import { withProviderConnectionHealth } from "./connection-health";
+import { withFiledTrailingEps } from "../../time-series/filed-trailing-eps";
 import {
   contextFromCachedTarget,
   getBrokerCandidates,
@@ -213,7 +214,7 @@ export class AssetDataRouter implements DataProvider {
     for (const target of valid) {
       const key = target.symbol.toUpperCase();
       const financials = cached.get(key);
-      if (financials) cached.set(key, this.knownFinancials(financials, listingOf(target, contextFromCachedTarget(target))));
+      if (financials) cached.set(key, withFiledTrailingEps(this.knownFinancials(financials, listingOf(target, contextFromCachedTarget(target)))));
     }
     return cached;
   }
@@ -263,8 +264,9 @@ export class AssetDataRouter implements DataProvider {
     const dated = await this.datedAnswers(quoted, options.datesChangeBasis);
     let next = 0;
     const results = answered.map((result) => {
-      if (!result.financials?.quote) return result;
-      const financials = this.withDatedQuote(result.financials, dated[next++]!, listingOfResult(result));
+      if (!result.financials) return result;
+      const quoted = result.financials.quote ? this.withDatedQuote(result.financials, dated[next++]!, listingOfResult(result)) : result.financials;
+      const financials = withFiledTrailingEps(quoted);
       return financials === result.financials ? result : { ...result, financials };
     });
     const restored = new Map(results.map((result) => {
@@ -279,10 +281,11 @@ export class AssetDataRouter implements DataProvider {
     const { context, datesChangeBasis } = splitDating(requestContext);
     exchange = this.resolvePublicExchange(ticker, exchange, context);
     const financials = await this.financialRoutes.getTickerFinancials(ticker, exchange, context);
-    if (!financials.quote) return financials;
+    if (!financials.quote) return withFiledTrailingEps(financials);
     const listing = listingOf({ symbol: ticker, exchange }, context);
     const [quote] = await this.datedAnswers([{ quote: financials.quote, listing }], datesChangeBasis);
-    return this.withDatedQuote(financials, quote!, listing);
+    // One trailing EPS and P/E for every view of the listing: the filed quarters', as PEB and GE read them.
+    return withFiledTrailingEps(this.withDatedQuote(financials, quote!, listing));
   }
 
   async getQuote(ticker: string, exchange?: string, requestContext?: MarketDataRequestContext): Promise<Quote> {

package/src/state/ticker-cleanup.ts

@@ -0,0 +1,50 @@
+import type { AppTickerRepositoryPort } from "../core/app-service-ports";
+import { hasPendingTickerWrites, settleTickerWrites, tickerWriteRevision } from "../data/ticker-writes";
+import type { TickerRecord } from "../types/ticker";
+
+/**
+ * Persist cleanup before publishing it, retrying against edits acknowledged in between.
+ * Return the cleaned map so callers can recheck it after their config save.
+ */
+export async function persistTickerCleanup({
+  tickerRepository,
+  getTickers,
+  transform,
+  publish,
+  isCurrent = () => true,
+}: {
+  tickerRepository: AppTickerRepositoryPort;
+  getTickers: () => ReadonlyMap<string, TickerRecord>;
+  transform: (ticker: TickerRecord) => TickerRecord | null;
+  publish: (symbol: string, ticker: TickerRecord | null) => void;
+  isCurrent?: () => boolean;
+}): Promise<ReadonlyMap<string, TickerRecord> | null> {
+  for (;;) {
+    do {
+      await settleTickerWrites(tickerRepository);
+    } while (hasPendingTickerWrites(tickerRepository));
+    if (!isCurrent()) return null;
+    const before = getTickers();
+    let wrote = false;
+    for (const symbol of before.keys()) {
+      do {
+        await settleTickerWrites(tickerRepository);
+      } while (hasPendingTickerWrites(tickerRepository));
+      if (!isCurrent()) return null;
+      const source = getTickers().get(symbol);
+      if (!source) continue;
+      const next = transform(source);
+      if (next === source) continue;
+      wrote = true;
+      const save = next ? tickerRepository.saveTicker(next) : tickerRepository.deleteTicker(symbol);
+      const revision = tickerWriteRevision(tickerRepository, symbol);
+      await save;
+      if (!isCurrent()) return null;
+      // An edit can start its save before publishing state, especially over RPC.
+      if (tickerWriteRevision(tickerRepository, symbol) !== revision || getTickers().get(symbol) !== source) continue;
+      publish(symbol, next);
+    }
+    // Include rows created or recreated while earlier rows were being saved.
+    if (!wrote && getTickers() === before) return before;
+  }
+}

package/src/sync/controller.ts

@@ -41,7 +41,8 @@ interface SyncRuntime {
   isLocalMarketData?: LocalMarketDataLookup;
 }
 
-const CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
+/** Kept in the view's storage; the desktop app also keeps a copy on disk (electrobun/view/view-ids.ts). */
+export const SYNC_CLIENT_ID_STORAGE_KEY = "gloomberb.sync.clientId";
 const PUSH_DEBOUNCE_MS = 2500;
 /** How soon after a change contributors date it, so an edit made just before quitting still is. */
 const OBSERVE_DEBOUNCE_MS = 250;
@@ -60,10 +61,10 @@ function nowIso(): string {
 
 function resolveClientId(): string {
   const storage = globalThis.localStorage;
-  const existing = storage?.getItem(CLIENT_ID_STORAGE_KEY);
+  const existing = storage?.getItem(SYNC_CLIENT_ID_STORAGE_KEY);
   if (existing) return existing;
   const id = `client_${crypto.randomUUID()}`;
-  storage?.setItem(CLIENT_ID_STORAGE_KEY, id);
+  storage?.setItem(SYNC_CLIENT_ID_STORAGE_KEY, id);
   return id;
 }
 

package/src/sync/core-contributors.ts

@@ -1,4 +1,6 @@
 import { saveConfigImmediately, scheduleConfigSave } from "../state/config-save-scheduler";
+import { persistTickerCleanup } from "../state/ticker-cleanup";
+import { hasPendingTickerWrites } from "../data/ticker-writes";
 import { normalizeStoredBaseCurrency } from "../utils/base-currency";
 import { debugLog } from "../utils/debug-log";
 import { fnv1aHex, stableStringify } from "../utils/hash";
@@ -1184,6 +1186,23 @@ function holdingIn(positions: readonly TickerPosition[], links: readonly unknown
   };
 }
 
+/** Without a shared baseline, keep both devices' manual lots, matching identical copies one for one. */
+function mergeUntrackedManualPositions(local: TickerPosition[], pulled: TickerPosition[]): TickerPosition[] {
+  const unmatched = new Map<string, number>();
+  for (const position of local) {
+    const key = JSON.stringify(sanitizePosition(position));
+    unmatched.set(key, (unmatched.get(key) ?? 0) + 1);
+  }
+  const merged = [...local];
+  for (const position of pulled) {
+    const key = JSON.stringify(sanitizePosition(position));
+    const count = unmatched.get(key) ?? 0;
+    if (count > 0) unmatched.set(key, count - 1);
+    else merged.push(position);
+  }
+  return merged;
+}
+
 interface PulledTickersMerge {
   lastSyncedTickers: Map<string, Record<string, unknown>> | null;
   /** This device's live broker portfolios, each with the side holding its latest broker sync. */
@@ -1274,8 +1293,25 @@ function mergePulledTicker(
         holdingIn(baselinePositions, baselineLinks, portfolioId),
       );
     const [sidePositions, sideLinks] = takePulled ? [pulledPositions, pulledLinks] : [localPositions, localLinks];
-    positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId));
-    if (sideLinks.includes(portfolioId)) portfolios.push(portfolioId);
+    if (brokerSide && !merge.localOnly?.portfolioIds.has(portfolioId)) {
+      // A broker's timestamp governs imported holdings, never hand-entered
+      // lots. Those use the same edit comparison as a manual portfolio.
+      const manualIn = (entries: readonly TickerPosition[]) => entries.filter((position) => (
+        position.portfolio === portfolioId && position.broker === "manual"
+      ));
+      const localManual = manualIn(localPositions);
+      const manualEdited = comparable && !sameAsStored(
+        localManual.map(sanitizePosition), manualIn(baselinePositions).map(sanitizePosition),
+      );
+      const pulledManual = manualIn(pulledPositions);
+      const manual = !comparable ? mergeUntrackedManualPositions(localManual, pulledManual)
+        : manualEdited ? localManual : pulledManual;
+      positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId && position.broker !== "manual"), ...manual);
+      if (sideLinks.includes(portfolioId) || manual.length > 0) portfolios.push(portfolioId);
+    } else {
+      positions.push(...sidePositions.filter((position) => position.portfolio === portfolioId));
+      if (sideLinks.includes(portfolioId)) portfolios.push(portfolioId);
+    }
   }
 
   const record: TickerRecord = {
@@ -1297,8 +1333,9 @@ function mergePulledTicker(
 function withoutUnpulledHoldings(ticker: TickerRecord, merge: PulledTickersMerge): TickerRecord | null {
   const sold = (portfolioId: string) => merge.brokerPortfolios.get(portfolioId) === "pulled";
   const { metadata } = ticker;
-  const positions = metadata.positions.filter((position) => !sold(position.portfolio));
-  const portfolios = metadata.portfolios.filter((portfolioId) => !sold(portfolioId));
+  const positions = metadata.positions.filter((position) => position.broker === "manual" || !sold(position.portfolio));
+  const held = new Set(positions.map((position) => position.portfolio));
+  const portfolios = metadata.portfolios.filter((portfolioId) => held.has(portfolioId) || !sold(portfolioId));
   const kept = positions.length === metadata.positions.length && portfolios.length === metadata.portfolios.length
     ? ticker
     : { ...ticker, metadata: { ...metadata, positions, portfolios } };
@@ -1322,12 +1359,57 @@ export const coreConfigSyncContributor: SyncContributor = {
   },
   apply: async (payload, { snapshot, baselinePayload, baselineState, state, getState, isCurrent, dispatch, tickerRepository, memo }) => {
     const pushedAt = snapshot?.contributors[CORE_CONFIG_CONTRIBUTOR_ID]?.updatedAt;
-    const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config, baselinePayload, {
+    const merge = (config: AppConfig) => mergeConfigPayload(config, payload, baselineState.config, baselinePayload, {
       memo: memo?.get(),
       pushedAt,
-    }, localOnlyScope(state.config));
+    }, localOnlyScope(config));
+    let nextConfig = merge(state.config);
     if (!nextConfig) return;
-    const configChanged = !valuesEqual(nextConfig, state.config);
+    const removed = removedBrokerHoldings(state.config, nextConfig);
+    if (removed) {
+      // Keep the profile until row and config writes succeed, so a failed
+      // cleanup remains visible to the next attempt.
+      const cleanTickers = () => persistTickerCleanup({
+        tickerRepository,
+        getTickers: () => getState().tickers,
+        transform: (ticker) => withoutRemovedBrokerHoldings(ticker, removed),
+        publish: (symbol, ticker) => {
+          const tickers = new Map(getState().tickers);
+          if (ticker) tickers.set(symbol, ticker);
+          else tickers.delete(symbol);
+          dispatch({ type: "SET_TICKERS", tickers });
+        },
+        isCurrent,
+      });
+      let savedRemoval = false;
+      for (;;) {
+        const cleaned = await cleanTickers().catch(async (error: unknown) => {
+          // Restore the profile if a late row fails after config was saved,
+          // so retry can also recover after restarting the app.
+          if (savedRemoval) await saveConfigImmediately(getState().config);
+          throw error;
+        });
+        if (!cleaned || !isCurrent()) return;
+        if (hasPendingTickerWrites(tickerRepository) || getState().tickers !== cleaned) continue;
+        const source = getState().config;
+        const merged = merge(source);
+        if (!merged) return;
+        // Preserve unrelated edits while retaining the removal already applied
+        // to rows, including pulls from builds that merged whole profile lists.
+        nextConfig = {
+          ...merged,
+          brokerInstances: merged.brokerInstances.filter((instance) => !removed.instanceIds.has(instance.id)),
+          portfolios: merged.portfolios.filter((portfolio) => !removed.portfolioIds.has(portfolio.id)),
+        };
+        await saveConfigImmediately(nextConfig);
+        savedRemoval = true;
+        if (!isCurrent()) return;
+        if (getState().config !== source || getState().tickers !== cleaned
+          || hasPendingTickerWrites(tickerRepository)) continue;
+        break;
+      }
+    }
+    const configChanged = !valuesEqual(nextConfig, getState().config);
     if (configChanged) {
       // Adopting another device's workspace rearranges the screen under the
       // user, so it is worth a line in the log when a report says "my panes
@@ -1339,32 +1421,9 @@ export const coreConfigSyncContributor: SyncContributor = {
         });
       }
       dispatch({ type: "SET_CONFIG", config: nextConfig });
-      scheduleConfigSave(nextConfig);
+      if (!removed) scheduleConfigSave(nextConfig);
     }
     if (memo && isRecord(payload)) rememberCloudLayout(payload, pushedAt, getState().config, memo, nextConfig.layouts !== state.config.layouts);
-    if (!configChanged) return;
-
-    // A profile removed on another device takes its positions with it here
-    // too; kept, this device would push them back and recreate the tickers
-    // that removal deleted.
-    const removed = removedBrokerHoldings(state.config, nextConfig);
-    if (!removed) return;
-    const nextTickers = new Map(getState().tickers);
-    let changed = false;
-    for (const ticker of getState().tickers.values()) {
-      if (!isCurrent()) return;
-      const next = withoutRemovedBrokerHoldings(ticker, removed);
-      if (next === ticker) continue;
-      changed = true;
-      if (next) {
-        await tickerRepository.saveTicker(next);
-        nextTickers.set(next.metadata.ticker, next);
-      } else {
-        await tickerRepository.deleteTicker(ticker.metadata.ticker);
-        nextTickers.delete(ticker.metadata.ticker);
-      }
-    }
-    if (changed && isCurrent()) dispatch({ type: "SET_TICKERS", tickers: nextTickers });
   },
 };
 

package/src/telemetry/stall-reports-dom.ts

@@ -0,0 +1,38 @@
+import type { StallEvent } from "../utils/main-thread-stall";
+
+/**
+ * Only the freezes a user sat through. The system slows the timers of a
+ * window behind others or out of view, sometimes to one a second, and the
+ * stall monitor cannot tell that from a freeze: a timer back a second late
+ * reads the same either way. A window that has been in front, with focus,
+ * since before the stall began ran at full speed, so its late timers are
+ * freezes. Anything else is dropped, including a real freeze the user
+ * clicked into the window during: missing one beats reporting a false one.
+ */
+export function forwardAttendedStalls(
+  forward: (event: StallEvent) => void,
+  target: Window = window,
+  now: () => number = () => performance.now(),
+): { sink: (event: StallEvent) => void; dispose: () => void } {
+  const doc = target.document;
+  const attended = () => doc.visibilityState === "visible" && doc.hasFocus();
+  // Since when the window has been attended; never while it is not.
+  let attendedSince = attended() ? now() : Number.POSITIVE_INFINITY;
+  const update = () => {
+    if (!attended()) attendedSince = Number.POSITIVE_INFINITY;
+    else if (attendedSince === Number.POSITIVE_INFINITY) attendedSince = now();
+  };
+  target.addEventListener("focus", update);
+  target.addEventListener("blur", update);
+  doc.addEventListener("visibilitychange", update);
+  return {
+    sink: (event) => {
+      if (attended() && attendedSince <= now() - event.blockedMs) forward(event);
+    },
+    dispose: () => {
+      target.removeEventListener("focus", update);
+      target.removeEventListener("blur", update);
+      doc.removeEventListener("visibilitychange", update);
+    },
+  };
+}

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

@@ -0,0 +1,75 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { StallReportState, StallReporterHost } from "./stall-reports";
+
+/** Next to config.json: one line per stall, newest last. */
+const STALL_LOG_FILE = "stall-log.txt";
+/** Next to config.json: when each kind of stall was last reported, and the counts since. */
+const STATE_FILE = "stall-reports.json";
+/** Past this the log keeps its newer half. */
+const LOG_MAX_BYTES = 256 * 1024;
+
+function readCounts(value: unknown): StallReportState["pending"] {
+  const pending: StallReportState["pending"] = {};
+  if (!value || typeof value !== "object") return pending;
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    const { count, longestMs } = (entry ?? {}) as Record<string, unknown>;
+    if (typeof count === "number" && Number.isFinite(count) && typeof longestMs === "number" && Number.isFinite(longestMs)) {
+      pending[key] = { count, longestMs };
+    }
+  }
+  return pending;
+}
+
+/** The saved state, keeping only entries of the right shape. */
+function parseStallReportState(text: string): StallReportState {
+  const parsed: unknown = JSON.parse(text);
+  const record = parsed && typeof parsed === "object" ? parsed as Record<string, unknown> : {};
+  const sent: Record<string, number> = {};
+  if (record.sent && typeof record.sent === "object") {
+    for (const [key, at] of Object.entries(record.sent as Record<string, unknown>)) {
+      if (typeof at === "number" && Number.isFinite(at)) sent[key] = at;
+    }
+  }
+  return { sent, pending: readCounts(record.pending) };
+}
+
+function trimLog(path: string): void {
+  if (statSync(path).size <= LOG_MAX_BYTES) return;
+  const text = readFileSync(path, "utf-8");
+  const keep = text.slice(text.length - LOG_MAX_BYTES / 2);
+  writeFileSync(path, keep.slice(keep.indexOf("\n") + 1), "utf-8");
+}
+
+/** The stall reporter for a Bun process (the terminal app, the desktop app's main process). */
+export function createNodeStallReporterHost(options: {
+  /** The profile's data folder, or null before the config is loaded. */
+  getDataDir(): string | null;
+}): StallReporterHost {
+  const pathFor = (file: string) => {
+    const dir = options.getDataDir();
+    return dir ? join(dir, file) : null;
+  };
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    appendLog: (line) => {
+      const path = pathFor(STALL_LOG_FILE);
+      if (!path) return;
+      mkdirSync(join(path, ".."), { recursive: true });
+      appendFileSync(path, `${line}\n`, "utf-8");
+      trimLog(path);
+    },
+    load: () => {
+      const path = pathFor(STATE_FILE);
+      if (!path || !existsSync(path)) return { sent: {}, pending: {} };
+      return parseStallReportState(readFileSync(path, "utf-8"));
+    },
+    save: (state) => {
+      const path = pathFor(STATE_FILE);
+      if (!path) return;
+      mkdirSync(join(path, ".."), { recursive: true });
+      writeFileSync(path, JSON.stringify(state), "utf-8");
+    },
+  };
+}