gloomberb 0.18.0 → 0.18.1

package/src/plugins/builtin/portfolio-list/cli/render.ts

@@ -12,7 +12,7 @@ import {
 import { formatCompact, formatPercentRaw } from "../../../../utils/format";
 import { currencyPriceMinDigits, formatMarketCostWithCurrency, formatMarketPrice, formatMarketPriceWithCurrency, formatMarketQuantity, quoteFormatOptions } from "../../../../market-data/market/format";
 import { resolvePriceBasis } from "../../../../market-data/market/price-basis";
-import { getPortfolioPositionMetrics, resolvePortfolioMarketValue, resolvePortfolioPositionPnl } from "../../../../portfolio/position-metrics";
+import { getPortfolioPositionMetrics, lotCostAtTodaysRate, lotCostFxRate, resolvePortfolioMarketValue, resolvePortfolioPositionPnl } from "../../../../portfolio/position-metrics";
 import {
   getPortfolioValuationDisplay,
   getPortfolioValuationTime,
@@ -282,6 +282,12 @@ interface PortfolioPositionValue {
   row: Record<string, unknown>;
   /** A future's contract size and settlement from its terms; null for any other holding. */
   futures: PortfolioFuturesTerms | null;
+  /**
+   * Only on a lot held in another currency than the portfolio's: the rate its
+   * cost converted at (one unit of its currency in the portfolio's, when
+   * bought), or null when it converted at today's rate.
+   */
+  costFx?: { rate: number; currency: string } | null;
 }
 
 /** What a row's value is priced at: exported after every other field, so existing columns keep their places. */
@@ -309,6 +315,8 @@ export interface PortfolioValuation {
   unknownContractSize: Set<string>;
   /** Futures valued at the close without a confirmed settlement to value them at. */
   unsettled: Set<string>;
+  /** Holdings in another currency whose cost converts at today's rate: no purchase date or cost FX rate was entered. */
+  costAtTodaysRate: Set<string>;
   /** Long and short market value of the priced lots, and their net and gross, in the portfolio's currency. */
   exposure: PortfolioExposure;
 }
@@ -333,6 +341,15 @@ function portfolioExposure(values: Iterable<number | null | undefined>): Portfol
   return { long, short, net: long + short, gross: long - short };
 }
 
+/**
+ * What a book says of holdings in another currency whose cost converts at
+ * today's rate, which leaves the currency's move since purchase out of their
+ * P&L; `named` lists them as the table names its rows.
+ */
+export function costAtTodaysRateNote(named: string): string {
+  return `Cost converted at today's rate for ${named}; give portfolio position set a --date or --cost-fx to use the rate when bought.`;
+}
+
 /**
  * Values every position of a portfolio in the portfolio's currency, as
  * `portfolio show` prints it: cost basis, market value and unrealized P&L
@@ -368,6 +385,7 @@ export async function valuePortfolioPositions({
   const brokerPnlSymbols = new Set<string>();
   const unknownContractSize = new Set<string>();
   const unsettled = new Set<string>();
+  const costAtTodaysRate = new Set<string>();
   const values: PortfolioPositionValue[] = [];
   const holdings: AllocationHolding[] = [];
   const known = (value: number | null | undefined): number | null => value != null && Number.isFinite(value) ? value : null;
@@ -409,11 +427,17 @@ export async function valuePortfolioPositions({
       const valuationQuote = getPortfolioValuationDisplay(metrics, quote, basis, settlement);
       const atSettlement = valuesAtSettlement(metrics, basis);
       const positionCurrency = metrics.positionCurrency;
-      const costBasisBase = positionCurrency ? await toBase(metrics.totalCost, positionCurrency) : Number.NaN;
-
       const positionRate = positionCurrency ? await toBase(1, positionCurrency) : Number.NaN;
+      // The cost converts at the rate the lot was bought at when one was entered, else at today's, as its value does.
       const baseMetrics = getPortfolioPositionMetrics({ ...ticker, metadata: { ...ticker.metadata, positions: [position] } }, id, quoteCurrency,
         { currency, convert: value => value * positionRate }, quote);
+      const boughtRate = positionCurrency ? lotCostFxRate(position, positionCurrency, currency) : null;
+      const costBasisBase = !positionCurrency ? Number.NaN
+        : boughtRate !== null ? baseMetrics.totalCost : await toBase(metrics.totalCost, positionCurrency);
+      // Only a lot entered by hand can be given the rate it was bought at; a broker's lot reads as it always has.
+      const atTodaysRate = position.broker === "manual" && !!positionCurrency && lotCostAtTodaysRate(position, positionCurrency, currency);
+      if (atTodaysRate && metrics.hasCostBasis) costAtTodaysRate.add(ticker.metadata.ticker);
+      const costFx = boughtRate !== null ? { rate: boughtRate, currency } : atTodaysRate ? null : undefined;
       const currentValueBase = resolvePortfolioMarketValue(baseMetrics,
         valuationQuote ? await toBase(valuationQuote.price, quoteCurrency) : null)?.gross ?? null;
       const selectedPnl = resolvePortfolioPositionPnl(baseMetrics,
@@ -436,7 +460,7 @@ export async function valuePortfolioPositions({
         ? { change: await toBase(metrics.totalPriceUnits * change, quoteCurrency),
           previousValue: await toBase(metrics.grossPriceUnits * (valuationQuote.price - change), quoteCurrency) }
         : null;
-      values.push({ ticker, quote, activeQuote, headline, extended, position, metrics, pnl, futures: futuresTerms,
+      values.push({ ticker, quote, activeQuote, headline, extended, position, metrics, pnl, futures: futuresTerms, ...(costFx !== undefined ? { costFx } : {}),
         dayMove: dayMove && Number.isFinite(dayMove.change) && Number.isFinite(dayMove.previousValue) ? dayMove : null,
         valuation: { valuationBasis: basis, valuationPrice: known(valuationQuote?.price),
           valuationAsOf: valuationTimeIso(getPortfolioValuationTime(quote, basis, metrics, settlement)),
@@ -455,7 +479,7 @@ export async function valuePortfolioPositions({
 
   const exposure = portfolioExposure(values.map((entry) => entry.position ? entry.row.marketValue as number | null : null));
   return { basis, positions: values, holdings, totalPnl, unavailablePnl, unavailableCost, unavailableMarketValue, brokerPnlSymbols,
-    unknownContractSize, unsettled, exposure };
+    unknownContractSize, unsettled, costAtTodaysRate, exposure };
 }
 
 /**
@@ -725,6 +749,7 @@ async function showCollectionWithMarketData(
       brokerPnlSymbols,
       unknownContractSize,
       unsettled,
+      costAtTodaysRate,
       exposure,
     } = valuation;
     const { allocation, cash } = await valuePortfolioAllocation({ valuation, portfolio: matchedPortfolio, account, toBase });
@@ -782,6 +807,8 @@ async function showCollectionWithMarketData(
           contractMultiplier: entry.position.multiplier ?? null,
           contractSize: entry.futures.size?.size ?? null,
         } : {}),
+        // Only on a lot held in another currency: the rate its cost converted at when bought, null when at today's.
+        ...(entry.costFx !== undefined ? { costFxRate: entry.costFx?.rate ?? null, costFxCurrency: entry.costFx?.currency ?? null } : {}),
       };
     });
     const totalPnlValue = unavailablePnl.size > 0 ? null : totalPnl;
@@ -884,6 +911,8 @@ async function showCollectionWithMarketData(
         exposure,
         ...(unknownContractSize.size > 0 ? { unknownContractSizeSymbols: [...unknownContractSize] } : {}),
         ...(unsettled.size > 0 ? { unsettledSymbols: [...unsettled] } : {}),
+        // Holdings in another currency with no purchase date or cost FX rate: their cost converts at today's rate.
+        ...(costAtTodaysRate.size > 0 ? { costAtTodaysRateSymbols: [...costAtTodaysRate] } : {}),
         accountingBasis, ...(manualAccounting ? { manualAccounting } : {}),
         ...(matchedPortfolio.importedFrom ? { importedFrom: matchedPortfolio.importedFrom } : {}),
         ...(explain ? { glossary: glossaryExport(explained) } : {}),
@@ -1038,6 +1067,7 @@ async function showCollectionWithMarketData(
     const targetNote = describeTargetSum(allocation.targetSum, allocation.weightBasis);
     if (targetNote) notes.push(cliStyles.muted(targetNote));
     if (brokerPnlSymbols.size > 0) notes.push(cliStyles.muted(`P&L for ${named(brokerPnlSymbols)} is the broker's last snapshot.`));
+    if (costAtTodaysRate.size > 0) notes.push(cliStyles.muted(costAtTodaysRateNote(named(costAtTodaysRate))));
     if (unknownContractSize.size > 0) {
       notes.push(cliStyles.warning(`No contract size for ${named(unknownContractSize)}, so ${unknownContractSize.size === 1 ? "its" : "their"} value, cost and P&L are not shown.`));
     }

package/src/plugins/builtin/portfolio-list/cli/watchlist-command.ts

@@ -125,7 +125,7 @@ async function addToWatchlistCommand(args: string[], file: string | undefined, e
       dryRun,
       add: (ticker) => addTickerToWatchlist(ticker, watchlist.id),
     });
-    printSymbolRows(ctx, rows, { verb: "add", collection: { kind: "watchlist", name: watchlist.name }, repeated: list.repeated, strays: list.strays, retry, dryRun });
+    printSymbolRows(ctx, rows, { verb: "add", collection: { kind: "watchlist", name: watchlist.name }, repeated: list.repeated, notes: list.notes, retry, dryRun });
   });
 }
 
@@ -158,7 +158,7 @@ async function removeFromWatchlistCommand(args: string[], file: string | undefin
       store: context.store,
       remove: (ticker) => removeWatchlistMembership(ticker, watchlist.id),
     });
-    printSymbolRows(ctx, rows, { verb: "remove", collection: { kind: "watchlist", name: watchlist.name }, repeated: list.repeated, strays: list.strays });
+    printSymbolRows(ctx, rows, { verb: "remove", collection: { kind: "watchlist", name: watchlist.name }, repeated: list.repeated, notes: list.notes });
   });
 }
 

package/src/plugins/builtin/portfolio-list/headless.ts

@@ -24,6 +24,7 @@ import {
   valuationTimeText,
   valuePortfolioAllocation,
   valuePortfolioPositions,
+  costAtTodaysRateNote,
   type CollectionMatch,
   type PortfolioValuation,
 } from "./cli/render";
@@ -401,6 +402,7 @@ async function portfolioHoldings(
       : []),
     ...(targetNote ? [targetNote] : []),
     ...(target.portfolio.brokerInstanceId && !resolved.account ? [BROKER_ACCOUNT_MISSING_NOTE] : []),
+    ...(valuation.costAtTodaysRate.size > 0 ? [costAtTodaysRateNote([...valuation.costAtTodaysRate].join(", "))] : []),
   ];
 
   const positionColumns = allocation.weightBasis === "gross"

package/src/plugins/builtin/portfolio-list/pane/index.tsx

@@ -53,6 +53,7 @@ import {
   renderSummarySegments,
 } from "../summary";
 import { usePortfolioAccountState } from "../summary/live-accounts";
+import { useOfflineBrokerFooter } from "../../shared/broker-reconnect";
 import {
   getCollectionEntries,
   getPortfolioPaneSettings,
@@ -190,8 +191,10 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
   const flashSymbols = useQuoteFlashMap(financialsMap, valueFlashingEnabled);
 
   const accountStateInput = useMemo(() => ({ brokerAccounts, config }), [brokerAccounts, config]);
-  const { accountState, accountsError, brokerError } = usePortfolioAccountState(currentPortfolio, accountStateInput);
+  const { accountState, accountsError, offline } = usePortfolioAccountState(currentPortfolio, accountStateInput);
   const brokerPortfolio = isPortfolioTab && !!currentPortfolio?.brokerInstanceId;
+  // The positions stay as last synced while the broker is away, dated, with one key to bring it back.
+  const offlineBrokerFooter = useOfflineBrokerFooter(brokerPortfolio ? offline : null);
   const portfolioTargets = currentPortfolio?.targetWeights;
   const columns = useMemo(
     () => resolveVisibleColumns(paneSettings.columnIds, isPortfolioTab, { targetWeights: hasTargetWeights(currentPortfolio) }),
@@ -548,7 +551,8 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
     accountState: summaryAccountState,
     accountStatusText: accountsError
       ? `Accounts unavailable: ${accountsError}`
-      : brokerPortfolio ? brokerError ?? (accountState ? undefined : "Acct missing") : undefined,
+      : brokerPortfolio && !accountState ? "Acct missing" : undefined,
+    brokerOffline: brokerPortfolio && offline ? { dated: offline.syncedAt != null } : undefined,
     financialsMap,
     isPortfolioTab,
     refreshingSize,
@@ -557,9 +561,9 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
   }), [financialsMap, sortedTickers], [
     accountState,
     accountsError,
-    brokerError,
     brokerPortfolio,
     isPortfolioTab,
+    offline,
     portfolioSummaryTotals,
     refreshingSize,
     summaryAccountState,
@@ -637,11 +641,14 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
 
   usePaneFooter("portfolio-list", () => ({
     info: [
+      ...offlineBrokerFooter.asOf,
       ...summaryFooterInfo,
+      ...offlineBrokerFooter.status,
       ...(fxStatusText && !fxWarning ? [{ id: "fx", parts: [{ text: `FX ${fxStatusText}`, tone: "muted" as const }] }] : []),
       ...(showsPerpetuals && perpetuals.stale ? [{ id: "perpetuals", parts: [{ text: "perpetuals stale", tone: "warning" as const }] }] : []),
     ],
     hints: [
+      ...offlineBrokerFooter.hints,
       ...(removalCollection
         ? [{
             id: "delete",
@@ -676,6 +683,7 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
     fxStatusText,
     fxWarning,
     isPortfolioTab,
+    offlineBrokerFooter,
     perpetuals.stale,
     removalCollection,
     removeSelectedTicker,

package/src/plugins/builtin/portfolio-list/summary/index.tsx

@@ -406,6 +406,7 @@ export function layoutPortfolioSummaryHeader(
 export function buildPortfolioFooterSegments({
   accountState,
   accountStatusText,
+  brokerOffline,
   financialsMap,
   isPortfolioTab,
   refreshingSize,
@@ -414,17 +415,25 @@ export function buildPortfolioFooterSegments({
 }: {
   accountState: PortfolioSummaryAccountState | null;
   accountStatusText?: string;
+  /**
+   * The portfolio's broker is offline. The pane says why, which stands in for
+   * the missing account and the quote time, and when it knows, when the
+   * positions were synced, which also dates the account.
+   */
+  brokerOffline?: { dated: boolean };
   financialsMap: Map<string, TickerFinancials>;
   isPortfolioTab: boolean;
   refreshingSize: number;
   sortedTickers: TickerRecord[];
   totals: PortfolioSummaryTotals;
 }): PaneFooterSegment[] {
+  const source: PaneFooterSegment[] = accountState ? [{ id: "source", parts: [{ text: accountState.sourceLabel, tone: "muted" }] }] : [];
+  if (isPortfolioTab && brokerOffline) return brokerOffline.dated ? [] : source;
   const accountStatus: PaneFooterSegment[] = isPortfolioTab && accountStatusText
     ? [{ id: "account-status", parts: [{ text: accountStatusText, tone: "muted" }] }]
     : [];
   // Cached account numbers stay on screen when a live refresh fails, so the failure sits beside their date.
-  if (accountState) return [{ id: "source", parts: [{ text: accountState.sourceLabel, tone: "muted" }] }, ...accountStatus];
+  if (accountState) return [...source, ...accountStatus];
   if (isPortfolioTab ? !totals.hasPositions && !accountStatusText : totals.watchlistCount === 0) return [];
 
   const lastRefreshTimestamp = getMostRecentQuoteUpdate(

package/src/plugins/builtin/portfolio-list/summary/live-accounts.ts

@@ -6,6 +6,9 @@ import type { Portfolio } from "../../../../types/ticker";
 import type { BrokerAccount } from "../../../../types/trading";
 import { getBrokerInstance } from "../../../../utils/broker-instances";
 import { usePluginBrokerActions } from "../../../runtime";
+import type { OfflineBroker } from "../../shared/broker-reconnect";
+import { tf } from "../../../../i18n";
+import { isSignedInBrokerProfile, signedInBrokerId } from "../../../../brokers/signed-in/profile";
 import { resolvePortfolioAccountState, type ResolvedPortfolioAccountState } from "./index";
 
 const EMPTY_ACCOUNTS = { instanceId: null, accounts: [] as BrokerAccount[], error: null };
@@ -85,11 +88,40 @@ export interface PortfolioAccountStateResult {
   /** Set when the broker refused to list accounts, so "no cash" is not mistaken for a clean empty. */
   accountsError: string | null;
   /**
-   * The broker's last call failed, such as the sync at startup after its
-   * sign-in lapsed. Accounts are listed only while it is connected, so this
-   * is the only word of why the account is missing or stale.
+   * The portfolio's broker while it cannot be reached, such as after its
+   * sign-in lapsed: the positions on screen are its last sync. Accounts are
+   * listed only while it is connected, so this is the only word of why the
+   * account is missing or stale.
    */
-  brokerError: string | null;
+  offline: OfflineBroker | null;
+}
+
+/**
+ * The broker behind a portfolio while Gloom cannot reach it: disconnected,
+ * failing, or without the plugin that connects it. Null while it is connected
+ * or connecting, before it reports a status, for a profile turned off, and for
+ * one that only syncs on demand (IBKR Flex), which is never connected.
+ */
+export function resolveOfflineBroker(
+  portfolio: Portfolio | null,
+  brokerInstance: BrokerInstanceConfig | null | undefined,
+  broker: BrokerAdapter | null | undefined,
+  status: BrokerConnectionStatus | null,
+): OfflineBroker | null {
+  if (!portfolio || !brokerInstance || brokerInstance.enabled === false) return null;
+  const syncedAt = portfolio.lastSyncedAt ?? brokerInstance.lastSyncedAt ?? null;
+  if (!broker) {
+    // A profile signed in through Gloom names its broker, not the adapter it needs.
+    const brokerName = (isSignedInBrokerProfile(brokerInstance) ? signedInBrokerId(brokerInstance) : brokerInstance.brokerType).toUpperCase();
+    return { instance: brokerInstance, brokerName, syncedAt, reason: tf("{broker} unavailable", { broker: brokerName }), reconnectable: false };
+  }
+  if (!status || status.state === "connected" || status.state === "connecting") return null;
+  if (status.mode?.toLowerCase() === "flex") return null;
+  const brokerName = broker.describeInstance?.(brokerInstance).brokerName ?? broker.name;
+  const reason = status.state === "error"
+    ? status.message?.trim() || tf("{broker} unavailable", { broker: brokerName })
+    : tf("{broker} disconnected", { broker: brokerName });
+  return { instance: brokerInstance, brokerName, syncedAt, reason, reconnectable: true };
 }
 
 /**
@@ -117,9 +149,12 @@ export function usePortfolioAccountState(
     () => resolvePortfolioAccountState(portfolio, state, snapshot),
     [portfolio, snapshot, state.brokerAccounts, state.config],
   );
-  const brokerError = live.status?.state === "error" ? live.status.message?.trim() || "Broker unavailable" : null;
+  const offline = useMemo(
+    () => resolveOfflineBroker(portfolio, brokerInstance, broker, live.status),
+    [broker, brokerInstance, live.status, portfolio],
+  );
   return useMemo(
-    () => ({ accountState, accountsError: live.error, brokerError }),
-    [accountState, brokerError, live.error],
+    () => ({ accountState, accountsError: live.error, offline }),
+    [accountState, live.error, offline],
   );
 }

package/src/plugins/builtin/shared/broker-reconnect.ts

@@ -0,0 +1,105 @@
+import { useCallback, useMemo, useRef, useState } from "react";
+import { signedInBrokerForProfile } from "../../../brokers/signed-in/connect";
+import { isSignedInBrokerProfile } from "../../../brokers/signed-in/profile";
+import { requestBrokerSignIn } from "../../../brokers/signed-in/sign-in-dialog";
+import type { PaneFooterSegment, PaneHint } from "../../../components/layout/pane/footer/model";
+import { t, tf } from "../../../i18n";
+import type { BrokerInstanceConfig } from "../../../types/config";
+import { formatShortDate } from "../../../utils/datetime-format";
+import { usePluginAppActions, usePluginBrokerActions } from "../../runtime";
+
+/** A broker profile Gloom cannot reach right now, so what a pane shows of it is from its last sync. */
+export interface OfflineBroker {
+  instance: BrokerInstanceConfig;
+  brokerName: string;
+  /** When the profile last synced its positions, or null when it never has. */
+  syncedAt: number | null;
+  /** Why it is offline, in the broker's words when it gave some. */
+  reason: string;
+  /** False when no plugin connects it, so pressing a key could not help. */
+  reconnectable: boolean;
+}
+
+/** The key onboarding gives "Connect a broker". */
+const RECONNECT_BROKER_KEY = "b";
+
+/** `as of 14:02` today, `as of Oct 17 14:02` before. */
+function formatBrokerSyncedAt(syncedAt: number, now = Date.now()): string {
+  const date = new Date(syncedAt);
+  const time = date.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false });
+  const today = date.toDateString() === new Date(now).toDateString();
+  return today
+    ? tf("as of {time}", { time })
+    : tf("as of {date} {time}", { date: formatShortDate(date, { year: false }), time });
+}
+
+export interface OfflineBrokerFooter {
+  /** `as of …`, when the profile has synced. */
+  asOf: PaneFooterSegment[];
+  /** Why the broker is offline, or that it is reconnecting. */
+  status: PaneFooterSegment[];
+  hints: PaneHint[];
+}
+
+const ONLINE: OfflineBrokerFooter = { asOf: [], status: [], hints: [] };
+
+/**
+ * Footer status and key for a pane showing a broker that is offline: when its
+ * positions were synced, why it is offline, and `[b] reconnect`. Reconnecting
+ * does what Connect does in Brokers (a signed-in broker asks for a new
+ * sign-in, any other connects), then syncs the profile so the positions are
+ * current again. Nothing changes on screen until that sync lands.
+ */
+export function useOfflineBrokerFooter(offline: OfflineBroker | null): OfflineBrokerFooter {
+  const { connectBrokerInstance, syncBrokerInstance } = usePluginBrokerActions();
+  const { notify } = usePluginAppActions();
+  const [reconnecting, setReconnecting] = useState(false);
+  const runningRef = useRef(false);
+  const offlineRef = useRef(offline);
+  offlineRef.current = offline;
+
+  const reconnect = useCallback(async () => {
+    const target = offlineRef.current;
+    if (!target?.reconnectable || runningRef.current) return;
+    runningRef.current = true;
+    setReconnecting(true);
+    try {
+      if (isSignedInBrokerProfile(target.instance)) {
+        if (!await requestBrokerSignIn(signedInBrokerForProfile(target.instance, target.brokerName))) return;
+      } else {
+        await connectBrokerInstance(target.instance.id);
+      }
+      await syncBrokerInstance(target.instance.id);
+    } catch (error) {
+      notify({
+        type: "error",
+        body: error instanceof Error ? error.message : tf("Could not reconnect {broker}.", { broker: target.brokerName }),
+      });
+    } finally {
+      runningRef.current = false;
+      setReconnecting(false);
+    }
+  }, [connectBrokerInstance, notify, syncBrokerInstance]);
+
+  return useMemo(() => {
+    if (!offline) return ONLINE;
+    // Dates the positions, not the quotes, so a shot that dates its quotes keeps it.
+    const asOf: PaneFooterSegment[] = offline.syncedAt != null
+      ? [{ id: "broker-as-of", asOf: false, parts: [{ text: formatBrokerSyncedAt(offline.syncedAt), tone: "muted" }] }]
+      : [];
+    const status: PaneFooterSegment[] = [reconnecting
+      ? { id: "broker-status", parts: [{ text: t("Reconnecting…"), tone: "muted" }] }
+      : { id: "broker-status", parts: [{ text: offline.reason, tone: "warning" }] }];
+    const hints: PaneHint[] = offline.reconnectable
+      ? [{
+          id: "reconnect-broker",
+          key: RECONNECT_BROKER_KEY,
+          label: " reconnect",
+          title: tf("Reconnect {broker}", { broker: offline.brokerName }),
+          onPress: () => { void reconnect(); },
+          disabled: reconnecting,
+        }]
+      : [];
+    return { asOf, status, hints };
+  }, [offline, reconnect, reconnecting]);
+}

package/src/plugins/builtin/shared/pro-feature-wall.tsx

@@ -23,8 +23,11 @@ export type ReadGuard = <T>(read: Promise<T>) => Promise<T>;
  * then upgrade. The session's plan decides before anything loads. Reads go
  * through `guard`, so a refusal from the server (a plan that ended while the
  * app was open, an expired session) shows the same wall, not an error.
+ *
+ * `preview`: the pane opens on every plan, the server serving a preview
+ * without Pro (EXEC), so only a refusal puts up the wall.
  */
-export function useProFeatureWall(copy: ProFeatureWallCopy, size: { width: number; height: number }): {
+export function useProFeatureWall(copy: ProFeatureWallCopy, size: { width: number; height: number }, options: { preview?: boolean } = {}): {
   wall: ReactNode;
   guard: ReadGuard;
 } {
@@ -39,12 +42,14 @@ export function useProFeatureWall(copy: ProFeatureWallCopy, size: { width: numbe
     throw error;
   }), []);
 
+  // A preview pane is walled by the server's answer alone, never by the plan up front.
+  const gated = !options.preview;
   let wall: ReactNode = null;
-  if (!access.signedIn || refused === 401) {
+  if ((gated && !access.signedIn) || refused === 401) {
     wall = <SignInWall placement={`${copy.placement.replace(/-wall$/, "")}-signin`} {...size} symbol={symbol} exchange={exchange} action={copy.action} />;
-  } else if (!access.emailVerified || refused === 403) {
+  } else if ((gated && !access.emailVerified) || refused === 403) {
     wall = <SignInWall placement={`${copy.placement.replace(/-wall$/, "")}-signin`} {...size} symbol={symbol} exchange={exchange} action={copy.action} needsVerification />;
-  } else if (!access.hasProAccess || refused === 402) {
+  } else if ((gated && !access.hasProAccess) || refused === 402) {
     wall = <ProWall placement={copy.placement} title={copy.title} message={copy.message} {...size} symbol={symbol} exchange={exchange} />;
   }
   return { wall, guard };

package/src/plugins/builtin/thirteenf/api.ts

@@ -13,6 +13,7 @@ import { apiClient } from "../../../api-client";
 import { ApiRequestError, isPermanentClientError } from "../../../api-client/errors";
 import { httpFetch } from "../../../utils/http-transport";
 import { asRecord, finiteOrNull } from "../../../utils/guards";
+import { logFailure } from "../../../utils/log-failure";
 
 const FORMS_13F_BASE_URL = "https://forms13f.com/api/v1";
 const FORM_PAGE_LIMIT = 100;
@@ -169,7 +170,9 @@ async function fetchForms13F<T>(
   slot.promise = promise;
   activeRequests.set(key, promise);
   if (cached != null && !options.forceRefresh) {
-    void promise.catch(() => {});
+    void promise.catch((error: unknown) => {
+      if (!options.signal?.aborted) logFailure("thirteenf.api", "Refresh cached filing data failed")(error);
+    });
     return cached.value;
   }
   return promise;

package/src/plugins/builtin/thirteenf/data.ts

@@ -13,6 +13,7 @@ import {
 } from "./api";
 import { isoDateDaysAgo, isoDateToday, isoDateYearsAgo } from "../../../utils/calendar-date";
 import { abortable, withDeadline } from "../../../utils/async-deadline";
+import { logFailure } from "../../../utils/log-failure";
 import {
   buildBrowserRows,
   filingGapFor,
@@ -239,7 +240,10 @@ async function loadBrowserPage(
   }
   const found = await searchThirteenFFunds(trimmed, browserLimit, signal, pageApiOptions);
   const funds = oneFundPerCik(found);
-  const topFunds = await listTopThirteenFFunds(quarter, browserLimit, signal, apiOptions).catch((): ThirteenFTopFund[] => []);
+  const topFunds = await listTopThirteenFFunds(quarter, browserLimit, signal, apiOptions).catch((error: unknown): ThirteenFTopFund[] => {
+    if (!signal?.aborted) logFailure("thirteenf.data", "Load performance ranks for fund search failed")(error);
+    return [];
+  });
   const topByCik = new Map(topFunds.map((fund) => [fund.cik, fund]));
   const matchedTopFunds = funds
     .map((fund) => topByCik.get(fund.cik))

package/src/plugins/builtin/thirteenf/headless.ts

@@ -647,7 +647,9 @@ export function createThirteenFHeadless(
             if (ctx.signal?.aborted) throw error;
             return [];
           });
-          shadowed.catch(() => {});
+          shadowed.catch(() => {
+            // Intentional ignore: only cancellation reaches this guard; the awaited promise still rejects.
+          });
         }
         try {
           holdings = await loadTickerHoldings(ticker, Number(args.options.offset ?? 0), ctx.signal);

package/src/plugins/builtin/thirteenf/pane.tsx

@@ -17,6 +17,7 @@ import {
 } from "../../../ui";
 import { isDetailBackNavigationKey } from "../../../utils/back-navigation";
 import { isPlainKey } from "../../../utils/keyboard";
+import { logFailure } from "../../../utils/log-failure";
 import { isPlainArrowUp, stopSearchFocusNavigation } from "../../../utils/search-focus-navigation";
 import { nextHeaderSort } from "../../../utils/sort-values";
 import { useAssetData, usePluginPaneState, usePluginTickerActions } from "../../runtime";
@@ -118,7 +119,7 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
     let alive = true;
     void Promise.all(browser.pages.map((page) => page.reportsLoaded ?? Promise.resolve())).then(() => {
       if (alive) setReportPaint((value) => value + 1);
-    }, () => {});
+    }, logFailure("thirteenf.pane", "Load filing metadata for fund rows failed"));
     return () => { alive = false; };
   }, [browser.pages]);
   const error = browser.error?.message ?? null;
@@ -193,7 +194,9 @@ function ThirteenFBrowserPane({ focused, width, height, onDetailChange }: PanePr
   // Every request behind a fund detail is cached per path, so warming it
   // while the cursor rests on the row makes Enter read from cache.
   const prefetchDetail = useCallback((row: FundBrowserRow) => {
-    void loadFundDetail(row.cik, row.name).catch(() => {});
+    void loadFundDetail(row.cik, row.name).catch(() => {
+      // Intentional ignore: speculative prefetch is retried and failures are shown when the fund opens.
+    });
   }, []);
 
   const browserStatusInfo = useMemo<PaneFooterSegment[]>(() => [
@@ -376,7 +379,9 @@ export function FundDetailView({
           : Promise.resolve(new Map<string, number | null>())
         ).then((factors) => {
           if (abortRef.current === controller) setSplitFactors(factors);
-        }, () => {});
+        }, () => {
+          // Intentional ignore: split lookups reject only on cancellation; individual failures remain unconfirmed.
+        });
       })
       .catch((loadError) => {
         if (abortRef.current !== controller) return;

package/src/portfolio/cost-fx.ts

@@ -0,0 +1,84 @@
+import type { CloudMarketResponse, CloudPricePointPayload } from "../api-client/types";
+import type { CloudHistoryParams } from "../api-client/paths";
+import { fxLegForCurrency } from "../market-data/coordinator/fx-legs";
+import { heldCurrencyUnit } from "../utils/currency-units";
+
+/** Reads a pair's daily bars; `apiClient` in the app, a fake in tests. */
+export interface CostFxHistoryClient {
+  getCloudHistory(symbol: string, exchange: string, params: CloudHistoryParams): Promise<CloudMarketResponse<CloudPricePointPayload[]>>;
+}
+
+/** The rate a lot's cost was bought at: one unit of its currency in the portfolio's, at a dated daily close. */
+export interface CostFxReading {
+  rate: number;
+  /** The UTC day of the FX close it was read from: the purchase date, or the last trading day before it. */
+  date: string;
+}
+
+/** Why no rate could be read for a purchase date; the command says to give one with --cost-fx instead. */
+export class CostFxError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "CostFxError";
+  }
+}
+
+const DAY_MS = 86_400_000;
+/** How far before the purchase date a close is looked for: a weekend and a holiday fit inside it, a gap in the data does not. */
+const LOOKBACK_DAYS = 7;
+
+const isoDay = (time: number) => new Date(time).toISOString().slice(0, 10);
+
+/**
+ * USD per unit of an ISO currency at its last completed daily close on or
+ * before `date`, looking back a week at most. Today's bar, still trading, is
+ * never read. Null when the pair has no close in that week.
+ */
+async function usdPerUnitOn(code: string, date: string, client: CostFxHistoryClient, now: Date): Promise<CostFxReading | null> {
+  if (code === "USD") return { rate: 1, date };
+  const leg = fxLegForCurrency(code);
+  if (!leg) throw new CostFxError(`No daily FX history is served for ${code}`);
+  const day = Date.parse(`${date}T00:00:00Z`);
+  const response = await client.getCloudHistory(leg.instrument.symbol, leg.instrument.exchange ?? "", {
+    interval: "1day", startDate: isoDay(day - LOOKBACK_DAYS * DAY_MS), endDate: isoDay(day + DAY_MS), outputsize: LOOKBACK_DAYS + 4,
+  });
+  if (response.status !== "success" && response.status !== "partial") return null;
+  const today = isoDay(now.getTime());
+  let best: CostFxReading | null = null;
+  for (const row of Array.isArray(response.data) ? response.data : []) {
+    const at = typeof row?.date === "string" ? Date.parse(row.date) : Number.NaN;
+    if (!Number.isFinite(at) || !Number.isFinite(row.close) || row.close <= 0) continue;
+    const rowDay = isoDay(at);
+    if (rowDay > date || rowDay >= today || Date.parse(`${rowDay}T00:00:00Z`) < day - LOOKBACK_DAYS * DAY_MS) continue;
+    if (!best || rowDay > best.date) best = { rate: leg.invert ? 1 / row.close : row.close, date: rowDay };
+  }
+  return best;
+}
+
+/**
+ * What one unit of `from` (a lot's currency, GBp counting pence and USX cents) cost in
+ * `into` (the portfolio's) at the daily FX closes of `date`, each pair's last
+ * close on or before it, crossed through USD as every converted value is.
+ * Throws `CostFxError` when a pair is not served or has no close in the week
+ * before the date.
+ */
+export async function loadCostFxRate(
+  from: string,
+  into: string,
+  date: string,
+  client: CostFxHistoryClient,
+  now = new Date(),
+): Promise<CostFxReading> {
+  const fromUnit = heldCurrencyUnit(from);
+  const intoUnit = heldCurrencyUnit(into);
+  const [fromUsd, intoUsd] = await Promise.all([
+    usdPerUnitOn(fromUnit.currency, date, client, now),
+    usdPerUnitOn(intoUnit.currency, date, client, now),
+  ]);
+  const missing = [fromUsd ? null : fromUnit.currency, intoUsd ? null : intoUnit.currency].filter(Boolean);
+  if (!fromUsd || !intoUsd) throw new CostFxError(`No ${missing.join(" or ")} FX close in the week up to ${date}`);
+  const rate = (fromUsd.rate / fromUnit.divisor) / (intoUsd.rate / intoUnit.divisor);
+  if (!Number.isFinite(rate) || rate <= 0) throw new CostFxError(`No usable ${fromUnit.currency}/${intoUnit.currency} rate for ${date}`);
+  // A pair that did not trade that day (its holiday) dates the cross by its own last close.
+  return { rate, date: fromUsd.date < intoUsd.date ? fromUsd.date : intoUsd.date };
+}