gloomberb 0.18.4 → 0.19.0

package/src/plugins/builtin/analytics/risk-fx.ts

@@ -38,10 +38,18 @@ export interface RiskConversion {
 export const FX_UNAVAILABLE = "Foreign holdings: daily FX closes unavailable";
 export const FX_NO_PAIR = "Foreign holdings: no daily FX pair for this currency";
 export const FX_STALE = "Foreign holdings: daily FX history is stale";
-export const FX_GAP = "Foreign holdings: daily FX history has gaps on the holding's dates";
+export const FX_GAP = "Foreign holdings: daily FX history has gaps longer than three days on the holding's dates";
 export const FX_DISAGREES = "Foreign holdings: daily FX closes disagree with the current rate";
 export const LOCAL_GAP = "Foreign holdings: local daily history has a gap longer than a market holiday";
 
+/**
+ * Most FX trading days in a row (weekdays) a pair may go without a daily
+ * close and still be bridged with the last close before them: Good Friday and
+ * Easter Monday, 25 December, 1 January, which the daily source skips while
+ * US sessions continue. A longer run is missing data and rejects the series.
+ */
+const MAX_BRIDGED_FX_DAYS = 3;
+
 /**
  * Longest run of calendar days a listing may go without a close while US
  * sessions continue (Golden Week, Lunar New Year, national holidays). A longer
@@ -70,6 +78,42 @@ export function accountFxReason(currency: string, problem: string): string {
   return `${pair} ${tail ?? "daily FX closes unavailable"}`;
 }
 
+/**
+ * The FX close a date converts at: the pair's own close that day, or the last
+ * close before it across at most MAX_BRIDGED_FX_DAYS weekdays without one
+ * (`bridged`). Null when the gap is longer, or no close comes before it.
+ */
+export function bridgedFxClose(rateOn: (date: string) => number | undefined, date: string): { rate: number; bridged: boolean } | null {
+  let missing = 0;
+  for (let time = Date.parse(`${date}T00:00:00Z`), step = 0; step <= 7 + MAX_BRIDGED_FX_DAYS; step++, time -= DAY_MS) {
+    const day = new Date(time).toISOString().slice(0, 10);
+    const rate = rateOn(day);
+    if (rate != null && rate > 0) return { rate, bridged: day !== date };
+    const weekday = new Date(time).getUTCDay();
+    if (weekday !== 0 && weekday !== 6 && ++missing > MAX_BRIDGED_FX_DAYS) return null;
+  }
+  return null;
+}
+
+/**
+ * "GBP/USD has no daily close on 2025-04-18 and 2025-04-21; the returns across
+ * them use the close before": what a conversion bridged (bridgedFxClose), said
+ * once per pair. Null when it bridged nothing.
+ */
+export function fxBridgeNote(pair: string, dates: Iterable<string>): string | null {
+  const days = [...new Set(dates)].sort();
+  if (!days.length) return null;
+  const shown = days.length > 4 ? [...days.slice(0, 3), `${days.length - 3} more days`] : days;
+  const list = shown.length === 1 ? shown[0]! : `${shown.slice(0, -1).join(", ")} and ${shown.at(-1)!}`;
+  return `${pair} has no daily close on ${list}; the returns across ${days.length === 1 ? "it use the close before it" : "them use the close before each"}.`;
+}
+
+/** Account returns, and the dates whose FX close was the last one before them (bridgedFxClose). */
+export interface AccountReturns {
+  returns: DatedReturn[];
+  bridged: string[];
+}
+
 /**
  * Restates daily USD returns in the account currency at the FX closes of each
  * return's own start and end dates: the holding's USD value is divided by the
@@ -77,23 +121,29 @@ export function accountFxReason(currency: string, problem: string): string {
  * (1 + r) * fx(start) / fx(end) - 1. A listing already converted from its own
  * currency to USD therefore converts at the cross of the two closes of the
  * same date. Returns before the first FX close or after the last are dropped,
- * so the series starts and ends with the FX history; a return inside it with an
- * endpoint that has no FX close rejects the whole series instead of bridging it.
+ * so the series starts and ends with the FX history. An endpoint without an FX
+ * close converts at the last close before it across a gap of up to
+ * MAX_BRIDGED_FX_DAYS FX trading days (Good Friday and Easter Monday), and
+ * says so in `bridged`; a longer gap rejects the whole series.
  */
 export function convertReturnsToAccount(
   returns: readonly DatedReturn[],
   fx: Pick<AccountFx, "currency" | "closes" | "first" | "asOf">,
-): DatedReturn[] {
+): AccountReturns {
   if (!fx.first || !fx.asOf) throw new Error(accountFxReason(fx.currency, FX_UNAVAILABLE));
   const converted: DatedReturn[] = [];
+  const bridged = new Set<string>();
+  const rateOn = (date: string) => fx.closes[date];
   for (const point of returns) {
     if (point.startDateKey < fx.first || point.dateKey > fx.asOf) continue;
-    const start = fx.closes[point.startDateKey],
-      end = fx.closes[point.dateKey];
-    if (!(start! > 0) || !(end! > 0)) throw new Error(accountFxReason(fx.currency, FX_GAP));
-    converted.push({ ...point, value: (1 + point.value) * (start! / end!) - 1 });
+    const start = bridgedFxClose(rateOn, point.startDateKey),
+      end = bridgedFxClose(rateOn, point.dateKey);
+    if (!start || !end) throw new Error(accountFxReason(fx.currency, FX_GAP));
+    if (start.bridged) bridged.add(point.startDateKey);
+    if (end.bridged) bridged.add(point.dateKey);
+    converted.push({ ...point, value: (1 + point.value) * (start.rate / end.rate) - 1 });
   }
-  return converted;
+  return { returns: converted, bridged: [...bridged].sort() };
 }
 
 /** The pair that restates a listing currency in USD, or null when there is none. */
@@ -127,7 +177,9 @@ export function validateFxHistory(
  * On a US session the listing did not trade (its own holiday), the holding is
  * worth its last local close at that day's FX close: its USD value moves with
  * the currency alone, as it would in the account. A US session with no FX
- * close, or a local silence longer than any market holiday, rejects the whole
+ * close converts at the last close before it across a gap of up to
+ * MAX_BRIDGED_FX_DAYS FX trading days, listed in `bridged`; a longer FX gap,
+ * or a local silence longer than any market holiday, rejects the whole
  * series instead of bridging it. The series ends at the earlier of the last
  * local close and the last FX close, so no close is carried past the data.
  */
@@ -135,7 +187,7 @@ export function convertClosesToUsd(
   local: readonly { date: string; close: number }[],
   fx: FxCloses,
   divisor: number,
-): PricePoint[] {
+): { points: PricePoint[]; bridged: string[] } {
   const points = [...local]
     .map((point) => ({ date: point.date.slice(0, 10), close: point.close }))
     .sort((left, right) => left.date.localeCompare(right.date));
@@ -143,6 +195,8 @@ export function convertClosesToUsd(
   const start = points[0]!.date > fx.first ? points[0]!.date : fx.first;
   const end = points.at(-1)!.date < fx.asOf ? points.at(-1)!.date : fx.asOf;
   const converted: PricePoint[] = [];
+  const bridged: string[] = [];
+  const rateOn = (date: string) => fx.closes.get(date);
   let cursor = 0;
   for (let time = Date.parse(`${start}T00:00:00Z`); time <= Date.parse(`${end}T00:00:00Z`); time += DAY_MS) {
     const date = new Date(time).toISOString().slice(0, 10);
@@ -153,11 +207,12 @@ export function convertClosesToUsd(
     const last = points[cursor]!;
     if (last.date > date) continue;
     if (time - Date.parse(`${last.date}T00:00:00Z`) > MAX_LOCAL_CLOSED_DAYS * DAY_MS) throw new Error(LOCAL_GAP);
-    const rate = fx.closes.get(date);
-    if (rate == null) throw new Error(FX_GAP);
-    const close = (last.close * rate) / divisor;
+    const fxClose = bridgedFxClose(rateOn, date);
+    if (!fxClose) throw new Error(FX_GAP);
+    if (fxClose.bridged) bridged.push(date);
+    const close = (last.close * fxClose.rate) / divisor;
     converted.push({ date: new Date(time), open: close, high: close, low: close, close });
   }
   if (converted.length < 2) throw new Error("Daily history unavailable");
-  return converted;
+  return { points: converted, bridged };
 }

package/src/plugins/builtin/analytics/risk-headless.ts

@@ -3,6 +3,7 @@ import type { HeadlessPaneDefinition } from "../../../types/plugin";
 import { fetchPortfolioRiskMarket, RISK_HISTORY_LIMIT } from "./risk-client";
 import { parsePortfolioRiskEvidence } from "./risk-evidence";
 import { describeCollections } from "../../../portfolio/collection-name";
+import { shellWord } from "../../../utils/shell-word";
 import { formatShocks, parseAssetShifts, parseFxShifts, riskCashLines } from "./risk-book";
 import {
   BASKET_VIEWS,
@@ -48,6 +49,22 @@ function reportPortfolioName(metadata: Record<string, unknown> | undefined): str
   return typeof name === "string" ? name : undefined;
 }
 
+/**
+ * What a portfolio with nothing to estimate says, as one line: the commands
+ * that fill it. Risk is read from lots, so a symbol listed without shares
+ * (`portfolio add`) is no holding yet; `portfolio position set` gives it
+ * shares, and adds the symbol too when it is not listed.
+ */
+function emptyPortfolioHint(name: string, listed: readonly string[]): string {
+  const portfolio = shellWord(name);
+  if (listed.length > 0) {
+    return `${name} lists ${listed.slice(0, 3).join(", ")}${listed.length > 3 ? ` and ${listed.length - 3} more` : ""} but holds no shares: `
+      + `gloom portfolio position set ${portfolio} ${shellWord(listed[0]!)} 10 150.`;
+  }
+  return `No holdings in ${name}. Add symbols with gloom portfolio add ${portfolio} AAPL,MSFT, `
+    + `then their shares with gloom portfolio position set ${portfolio} AAPL 10 150.`;
+}
+
 /** Rows of one view in the compact result; the pane and reports keep every row. */
 const COMPACT_ROW_LIMIT = 100;
 /** The correlation view is every pair of holdings; the compact result keeps the strongest. */
@@ -260,6 +277,16 @@ export const portfolioRiskHeadless: HeadlessPaneDefinition<"bundle"> = {
       throw new Error(
         "Imported evidence belongs to a different portfolio or currency",
       );
+    // A portfolio with no holdings and no cash has nothing to estimate: say how to fill it, not a table of dashes.
+    if (tickers.length === 0 && cash.length === 0 && !evidence) {
+      const listed = local.tickers.filter((ticker) => ticker.metadata.portfolios.includes(id)).map((ticker) => ticker.metadata.ticker);
+      return {
+        sections: [],
+        complete: false,
+        empty: emptyPortfolioHint(local.portfolio.name, listed),
+        metadata: { portfolio: { id, name: local.portfolio.name, currency: local.portfolio.currency } },
+      };
+    }
     const requestedView = isRiskView(args.options.view) ? args.options.view : null;
     const view: string = requestedView ?? "risk";
     const localOnly =

package/src/plugins/builtin/analytics/risk-model.ts

@@ -48,7 +48,16 @@ import {
   type RiskHoldingRequest,
   type RiskMarketSnapshot,
 } from "./risk-client";
-import { accountFxPair, accountFxReason, convertReturnsToAccount, FX_UNAVAILABLE, type AccountFx } from "./risk-fx";
+import {
+  accountFxPair,
+  accountFxReason,
+  bridgedFxClose,
+  convertReturnsToAccount,
+  FX_UNAVAILABLE,
+  fxBridgeNote,
+  riskConversion,
+  type AccountFx,
+} from "./risk-fx";
 
 interface PortfolioRiskHolding {
   id: string;
@@ -77,6 +86,8 @@ interface PortfolioRiskHolding {
   historyAsOf: string | null;
   /** Daily returns in the account currency. */
   returns: DatedReturn[];
+  /** Dates its returns converted at the FX close before them, by pair ("GBP/USD"), its daily closes having none (bridgedFxClose). */
+  fxBridged: ReadonlyMap<string, readonly string[]>;
   error: string | null;
   /** Why the holding is outside the basket; null when it qualifies. */
   leftOut: string | null;
@@ -386,15 +397,43 @@ function cashReason(line: RiskCashLine, accountCurrency: string): string {
     ? "Cash is outside the equity basket"
     : `Cash is outside the equity basket; its ${accountCurrency} value moves with ${own}`;
 }
+/** One note per pair whose missing daily closes the basket's returns were converted across (fxBridgeNote). */
+function fxBridgeNotes(members: readonly Pick<PortfolioRiskHolding, "fxBridged">[]): string[] {
+  const byPair = new Map<string, Set<string>>();
+  for (const member of members)
+    for (const [pair, dates] of member.fxBridged) {
+      const set = byPair.get(pair) ?? new Set<string>();
+      for (const date of dates) set.add(date);
+      byPair.set(pair, set);
+    }
+  return [...byPair].flatMap(([pair, dates]) => fxBridgeNote(pair, dates) ?? []);
+}
 /** USD returns in the account currency, or none with the reason its daily closes cannot convert them. */
-function accountReturns(returns: readonly DatedReturn[], account: AccountFx): { returns: DatedReturn[]; error: string | null } {
-  if (account.error) return { returns: [], error: account.error };
+function accountReturns(
+  returns: readonly DatedReturn[],
+  account: AccountFx,
+): { returns: DatedReturn[]; bridged: string[]; error: string | null } {
+  if (account.error) return { returns: [], bridged: [], error: account.error };
   try {
-    return { returns: convertReturnsToAccount(returns, account), error: null };
+    return { ...convertReturnsToAccount(returns, account), error: null };
   } catch (error) {
-    return { returns: [], error: error instanceof Error ? error.message : accountFxReason(account.currency, FX_UNAVAILABLE) };
+    return { returns: [], bridged: [], error: error instanceof Error ? error.message : accountFxReason(account.currency, FX_UNAVAILABLE) };
   }
 }
+/** The dates a holding's returns converted at the FX close before them, by pair: its listing's into USD, then USD into the account's. */
+function holdingFxBridges(
+  listingCurrency: string | null,
+  listingBridged: readonly string[] | undefined,
+  account: AccountFx | null | undefined,
+  accountBridged: readonly string[] | undefined,
+): Map<string, readonly string[]> {
+  const bridges = new Map<string, readonly string[]>();
+  const listingPair = listingCurrency && listingBridged?.length ? accountFxPair(riskConversion(listingCurrency)?.currency ?? listingCurrency) : null;
+  if (listingPair) bridges.set(listingPair, listingBridged!);
+  const accountPair = account?.pair;
+  if (accountPair && accountBridged?.length) bridges.set(accountPair, [...(bridges.get(accountPair) ?? []), ...accountBridged]);
+  return bridges;
+}
 /**
  * "returns in TRY at daily USD/TRY closes": the currency the basket views of a
  * non-USD account are in and how they got there; null for a USD account, or
@@ -474,6 +513,8 @@ export function riskCoverageNotices(coverage: RiskCoverage | undefined): string[
       `${row.symbol} (${row.share == null ? "value unknown" : `${shareText(row.share)} of the book`}) is excluded from the risk estimate: ${lowerFirst(row.reason.replace(/\.$/, ""))}.`,
   );
 }
+/** What an empty portfolio's pane says after "No holdings in this portfolio.": where holdings come from. */
+export const NO_HOLDINGS_HINT = "Add holdings from the Portfolio pane (PF), or connect a broker in BR to sync them.";
 /** Why the basket views show no estimate, when too little of the holdings qualifies. */
 export function riskCoverageShortfall(
   coverage: RiskCoverage | undefined,
@@ -690,6 +731,7 @@ export function buildPortfolioRisk(
       // Converted returns end with the account currency's last daily close.
       historyAsOf: (inAccount ? inAccount.returns.at(-1)?.dateKey : null) ?? history?.asOf ?? null,
       returns,
+      fxBridged: holdingFxBridges(convertedFrom, history?.converted?.fxBridged, account, inAccount?.bridged),
       error,
       leftOut,
     };
@@ -774,6 +816,8 @@ export function buildPortfolioRisk(
           "Converted holdings are matched to the US close of the same date; where their market closes at another time, correlations and betas to US holdings read lower than they are.",
         ]
       : []),
+    // A pair's daily closes skip Good Friday, Easter Monday, 25 Dec and 1 Jan; returns across them use the close before.
+    ...fxBridgeNotes(members),
   ];
   const warnings = [
     ...market.warnings,
@@ -796,12 +840,14 @@ export function buildPortfolioRisk(
     return (instrument && byId.get(riskInstrumentId(instrument))?.returns) || [];
   };
   // SPY's USD returns are the market factor and the equity stress; the risk
-  // rows compare the basket with SPY in the basket's own currency. A session
-  // without an account close is a gap in that benchmark, never bridged, so it
-  // cannot blank the holdings the closes do cover.
+  // rows compare the basket with SPY in the basket's own currency, bridged
+  // across missing account closes as the holdings are (bridgedFxClose). A
+  // session past a longer gap is a gap in that benchmark, so it cannot blank
+  // the holdings the closes do cover.
   const spy = proxy(RISK_BENCHMARK);
+  const accountClose = (date: string) => account ? bridgedFxClose((day) => account.closes[day], date) : null;
   const benchmark = account
-    ? accountReturns(spy.filter((point) => account.closes[point.startDateKey] && account.closes[point.dateKey]), account).returns
+    ? accountReturns(spy.filter((point) => accountClose(point.startDateKey) && accountClose(point.dateKey)), account).returns
     : spy;
   // Since the filing only for a portfolio that has one; any other keeps the trailing window and says why.
   const filed = window.since === "filed" ? portfolio.importedFrom?.filed ?? null : null;

package/src/plugins/builtin/analytics/risk-pane.tsx

@@ -30,6 +30,7 @@ import {
   useAsyncResource,
   useAutoRefresh,
   usePaneSettingValue,
+  usePluginAppActions,
   usePluginPaneState,
   useShortcut,
 } from "../../../public/react";
@@ -54,6 +55,7 @@ import {
   HOLDINGS_SHARE_UNIT,
   HOLDINGS_SUMMARY_ROW_IDS,
   isShockRow,
+  NO_HOLDINGS_HINT,
   portfolioRiskRequests,
   portfolioRiskTickers,
   riskCoverageLine,
@@ -234,6 +236,7 @@ function RiskDetail({
 export function PortfolioRiskPane({ focused, width, height }: PaneProps) {
   const instance = usePaneInstance(),
     renderer = useRendererHost();
+  const { showPane } = usePluginAppActions();
   const portfolios = useAppSelector((state) => state.config.portfolios),
     tickers = useAppSelector((state) => state.tickers),
     brokerAccounts = useAppSelector((state) => state.brokerAccounts);
@@ -403,14 +406,16 @@ export function PortfolioRiskPane({ focused, width, height }: PaneProps) {
   const model = derived.model;
   const marketLoading = resource.loading && !resource.data;
   // A basket view with nothing to estimate says why in the body, not with a table of dashes.
-  const basketBody = useMemo<{ loading?: boolean; error?: string; title?: string; message?: string } | null>(() => {
+  const basketBody = useMemo<{ loading?: boolean; error?: string; title?: string; message?: string; noHoldings?: boolean } | null>(() => {
     if (!model || !BASKET_VIEWS.has(view)) return null;
     if (!frozen && !resource.data)
       return marketLoading ? { loading: true } : resource.error ? { error: resource.error } : null;
     if (view === "holdings") return null;
     const shortfall = riskCoverageShortfall(model.coverage);
     // The currency and price shocks reprice the book without the basket, so they stay; the footer says why the basket scenarios do not.
-    return shortfall && view === "stress" && model.rows.stress.some(isShockRow) ? null : shortfall;
+    if (shortfall && view === "stress" && model.rows.stress.some(isShockRow)) return null;
+    // A portfolio with no holdings says where they come from, as the other panes' empty states do.
+    return shortfall && !model.coverage?.holdings ? { ...shortfall, message: NO_HOLDINGS_HINT, noHoldings: true } : shortfall;
   }, [frozen, marketLoading, model, resource.data, resource.error, view]);
   // Stress with too little covered for the basket scenarios, its shocks shown alone.
   const stressShortfall = useMemo(
@@ -816,6 +821,7 @@ export function PortfolioRiskPane({ focused, width, height }: PaneProps) {
               loadingLabel="Loading portfolio risk"
               emptyTitle={basketBody.title}
               emptyMessage={basketBody.message || undefined}
+              actions={basketBody.noHoldings ? <Button label="Open Portfolio" compact onPress={() => showPane("portfolio-list")} /> : undefined}
             />
           ) : evidenceMissing ? (
             <PaneStatusBody

package/src/plugins/builtin/attention/index.tsx

@@ -5,11 +5,12 @@ import { attentionHeadless } from "./headless";
 import { TrendingPane } from "./trending";
 import { AttentionPane } from "./pane";
 import { ATTENTION_SERIES } from "./series";
+import { ATTENTION_LISTED } from "./listing";
 export const attentionModule: PluginModule = {
   panes: [{ id: "attention", name: "Research Attention", icon: "A", component: AttentionPane, defaultPosition: "right", defaultMode: "floating",
     defaultFloatingSize: { width: 126, height: 32 }, tableExport: true, headless: attentionHeadless },
     { id: "attention-trending", reportFreshness: { status: "not-a-feed", basis: "hourly publication" }, name: "Gloom Trending", icon: "A", component: TrendingPane, defaultPosition: "right", defaultMode: "floating", defaultFloatingSize: { width: 58, height: 12 } }],
-  paneTemplates: [{ id: "attention-pane", paneId: "attention", label: "Research Attention",
+  paneTemplates: [{ id: "attention-pane", paneId: "attention", label: "Research Attention", listed: ATTENTION_LISTED,
     description: "Pro research attention: rankings, abnormal activity, sectors, countries and privacy-qualified hourly history.",
     keywords: ["attention", "trending", "research", "activity"], shortcut: { prefix: "ATTN", argKind: "text", argPlaceholder: "TICKER", argOptional: true },
     headless: attentionHeadless, createInstance: (_ctx, options) => ({ placement: "floating", settings: { window: attentionWindow(options?.values?.window), symbol: (options?.arg ?? options?.symbol)?.trim().toUpperCase() ?? "" } }) },

package/src/plugins/builtin/attention/listing.ts

@@ -0,0 +1,14 @@
+/**
+ * Whether ATTN is listed: in command-bar search, Help, `gloom catalog` and
+ * search, the plugin directory and chat suggestions, and its two screener
+ * fields (ATTN HRS, ATTN Z) in the EQS field and metric pickers.
+ *
+ * Research attention publishes an hour only once enough opted-in users
+ * researched in it, and it has published nothing for weeks, so ATTN stays
+ * unlisted until it does. Typing ATTN still opens it, a screen that already
+ * uses its fields keeps them, and the Attention Counts setting and its
+ * collection are unchanged. Set it to true the day ATTN publishes again,
+ * with the server's own switch, and refresh the docs snapshot
+ * (`bun run docs:snapshot`) once the site lists ATTN.
+ */
+export const ATTENTION_LISTED = false;

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

@@ -3,7 +3,7 @@ import type { InstrumentRef } from "../../../market-data/request-types";
 import { DATE_OPTION_EXAMPLES, isoDateOption } from "../../../utils/calendar-date";
 import { resolveHeadlessInstrument } from "../shared/headless-market-data";
 import { createBacktestDependencies, loadBacktestHistory } from "./client";
-import { BACKTEST_PRESETS, DEFAULT_PRESET, lookbackYears, resolveRules } from "./presets";
+import { BACKTEST_PRESETS, CUSTOM_PRESET_ID, DEFAULT_PRESET, lookbackYears, presetRulesConflict, resolveRules } from "./presets";
 import { BACKTEST_FRESHNESS, backtestPriceUnit, backtestReport } from "./report";
 import { parseRule, RULE_SYNTAX } from "./rules";
 import { runHistoryBacktest } from "./window";
@@ -37,8 +37,10 @@ export const backtestHeadless: HeadlessPaneDefinition<"bundle"> = {
     ],
   },
   options: [
-    { key: "preset", type: "enum", defaultValue: DEFAULT_PRESET.id, description: "Strategy preset, or custom to use --entry and --exit",
-      values: [...BACKTEST_PRESETS.map(({ id }) => ({ value: id })), { value: "custom" }] },
+    // No default: a run given --entry or --exit and no preset tests those rules, and one given both is refused.
+    { key: "preset", type: "enum",
+      description: `Strategy preset, ${DEFAULT_PRESET.id} when neither it nor a rule is given; --entry and --exit alone (or with custom) test your own rules`,
+      values: [...BACKTEST_PRESETS.map(({ id }) => ({ value: id })), { value: CUSTOM_PRESET_ID }] },
     { key: "entry", type: "string", defaultValue: "", description: `Custom entry rule, for example 'close > sma(200)' or 'weekday == 3'. ${RULE_SYNTAX}` },
     { key: "exit", type: "string", defaultValue: "", description: "Custom exit rule, for example 'close < sma(200)' or 'weekday == 4'. Same operands and comparisons as --entry" },
     { key: "lookback", type: "enum", defaultValue: "10", values: [{ value: "5" }, { value: "10" }, { value: "max" }], description: "Evaluation years after indicator warmup" },
@@ -55,8 +57,11 @@ export const backtestHeadless: HeadlessPaneDefinition<"bundle"> = {
       pluginState: { pluginId: "ticker-research", key: "backtest:view" } },
   ],
   async load(args, ctx) {
-    const preset = String(args.options.preset ?? DEFAULT_PRESET.id);
-    const rules = resolveRules(preset, String(args.options.entry ?? ""), String(args.options.exit ?? ""));
+    const preset = args.options.preset == null ? null : String(args.options.preset);
+    const typedEntry = String(args.options.entry ?? ""), typedExit = String(args.options.exit ?? "");
+    const conflict = presetRulesConflict(preset, typedEntry, typedExit);
+    if (conflict) throw new Error(conflict);
+    const rules = resolveRules(preset, typedEntry, typedExit);
     const entry = parseRule(rules.entry), exit = parseRule(rules.exit);
     const instrument = await resolveHeadlessInstrument(ctx, args.symbols[0]!);
     const [history, unit] = await Promise.all([

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

@@ -30,7 +30,7 @@ import { loadBacktestHistory } from "./client";
 import type { BacktestTrade } from "./engine";
 import { backtestEquityCsv } from "./export";
 import { formatStat, PRICE_RETURN_NOTE, SUMMARY_ROWS, type SummaryRow } from "./format";
-import { BACKTEST_PRESETS, DEFAULT_PRESET, lookbackYears, resolveRules } from "./presets";
+import { BACKTEST_PRESETS, DEFAULT_PRESET, lookbackYears, resolveRules, strategyPreset } from "./presets";
 import { backtestPriceUnit, backtestReport } from "./report";
 import { parseRule } from "./rules";
 import { continuationNote, runHistoryBacktest, type HistoryBacktestResult } from "./window";
@@ -82,9 +82,14 @@ export function BacktestPane({ width, height, focused }: PaneProps) {
   const paneId = usePaneInstanceId();
   const { openPaneSettings } = usePluginAppActions();
   const { symbol, ticker, financials, error: identityError } = usePaneTicker();
-  const [preset, setPreset] = usePaneSettingValue("preset", DEFAULT_PRESET.id);
-  const [entryText] = usePaneSettingValue("entry", DEFAULT_PRESET.entry);
-  const [exitText] = usePaneSettingValue("exit", DEFAULT_PRESET.exit);
+  // Rules typed in settings, or by `shot BT --entry ... --exit ...`, with no strategy chosen are tested as custom rules.
+  const [chosenPreset, setPreset] = usePaneSettingValue<string | null>("preset", null);
+  const [typedEntry] = usePaneSettingValue<string | null>("entry", null);
+  const [typedExit] = usePaneSettingValue<string | null>("exit", null);
+  const preset = strategyPreset(chosenPreset, typedEntry ?? "", typedExit ?? "");
+  // Custom starts from the default preset's rules until one is typed.
+  const entryText = typedEntry ?? DEFAULT_PRESET.entry;
+  const exitText = typedExit ?? DEFAULT_PRESET.exit;
   const [lookback, setLookback] = usePaneSettingValue("lookback", "10");
   const [costText] = usePaneSettingValue<string | number>("cost", "5");
   // Set by `shot BT --end` and `--include-partial`; the pane has no control for them.

package/src/plugins/builtin/backtest/presets.ts

@@ -26,9 +26,35 @@ export const LOOKBACK_OPTIONS = [
   { value: "max", label: "All history" },
 ];
 
-/** A preset's rules, or the typed ones for "custom". */
-export function resolveRules(preset: string, entry: string, exit: string): { entry: string; exit: string; label: string } {
-  const match = BACKTEST_PRESETS.find((candidate) => candidate.id === preset);
+export const CUSTOM_PRESET_ID = "custom";
+
+const typedRule = (entry: string, exit: string) => entry.trim() !== "" || exit.trim() !== "";
+
+/**
+ * The strategy a run tests: the preset chosen; with none chosen, the typed
+ * rules when there are any (`fn BT --entry ... --exit ...` means custom),
+ * else the default preset.
+ */
+export function strategyPreset(preset: string | null | undefined, entry: string, exit: string): string {
+  if (preset) return preset;
+  return typedRule(entry, exit) ? CUSTOM_PRESET_ID : DEFAULT_PRESET.id;
+}
+
+/** A preset's rules, or the typed ones for "custom" and for rules typed with no preset chosen. */
+export function resolveRules(preset: string | null | undefined, entry: string, exit: string): { entry: string; exit: string; label: string } {
+  const id = strategyPreset(preset, entry, exit);
+  const match = BACKTEST_PRESETS.find((candidate) => candidate.id === id);
   return match ? { entry: match.entry, exit: match.exit, label: match.label } : { entry, exit, label: "Custom rules" };
 }
+
+/**
+ * Why rules typed beside a preset cannot both be tested (`--preset
+ * golden-cross --entry ...`), naming both; null when they agree.
+ */
+export function presetRulesConflict(preset: string | null | undefined, entry: string, exit: string): string | null {
+  if (!preset || preset === CUSTOM_PRESET_ID || !typedRule(entry, exit)) return null;
+  const typed = [entry.trim() ? "--entry" : null, exit.trim() ? "--exit" : null].filter(Boolean).join(" and ");
+  return `${typed} ${entry.trim() && exit.trim() ? "are custom rules" : "is a custom rule"}, but --preset ${preset} tests its own. `
+    + `Leave out --preset to test the typed rules, or give --preset ${CUSTOM_PRESET_ID}.`;
+}
 export const lookbackYears = (value: unknown) => value === "max" ? null : value === "5" ? 5 : 10;

package/src/plugins/builtin/broker-manager/index.tsx

@@ -11,7 +11,7 @@ import {
   resetSignedInBrokerCatalog,
   subscribeSignedInBrokers,
 } from "../../../brokers/signed-in/catalog";
-import { DataTableStackView, EmptyState } from "../../../components";
+import { Button, DataTableStackView, EmptyState } from "../../../components";
 import { t } from "../../../i18n";
 import { useAppLanguage } from "../../../i18n/react";
 import {
@@ -50,6 +50,7 @@ export function BrokersPane({ focused, width, height }: PaneProps) {
   const config = usePaneAppConfig();
   const paneId = usePaneInstanceId();
   const brokerAccounts = useAppSelector((state) => state.brokerAccounts);
+  const brokerSyncErrors = useAppSelector((state) => state.brokerSyncErrors);
   const { getBrokerAdapter, getBrokerLogo } = usePluginBrokerActions();
   const desktop = useUiCapabilities().nativePaneChrome === true;
   // The profile is remembered by id so a reload lands on the same row.
@@ -82,8 +83,8 @@ export function BrokersPane({ focused, width, height }: PaneProps) {
   const signedInBrokers = useSyncExternalStore(subscribeSignedInBrokers, getSignedInBrokers, getSignedInBrokers);
   const { ends: signInEnds, reload: reloadSignInEnds } = useSignInEnds(config.brokerInstances);
   const rows = useMemo(
-    () => buildBrokerProfileRows(config, adapters, brokerAccounts, signInEnds, getBrokerLogo),
-    [adapters, brokerAccounts, config, getBrokerLogo, language, signInEnds, signedInBrokers, statusVersion],
+    () => buildBrokerProfileRows(config, adapters, brokerAccounts, signInEnds, getBrokerLogo, brokerSyncErrors),
+    [adapters, brokerAccounts, brokerSyncErrors, config, getBrokerLogo, language, signInEnds, signedInBrokers, statusVersion],
   );
   const selectedIndex = Math.max(0, rows.findIndex((row) => row.id === selectedId));
   const selectedRow = rows[selectedIndex] ?? null;
@@ -339,10 +340,14 @@ export function BrokersPane({ focused, width, height }: PaneProps) {
           sortDirection="asc"
           getItemKey={(row) => row.id}
           renderCell={renderCell}
-          // The footer's a adds one.
+          // The same add the footer's a and the command bar start; as the state's first
+          // action it also answers Enter.
           emptyContent={(
             <Box width="100%" paddingX={1} paddingY={1}>
-              <EmptyState title={t("No broker profiles.")} />
+              <EmptyState
+                title={t("No broker profiles.")}
+                actions={<Button label="Add Broker Account" onPress={startAdd} />}
+              />
             </Box>
           )}
           emptyStateTitle={t("No broker profiles.")}

package/src/plugins/builtin/broker-manager/model.ts

@@ -125,6 +125,7 @@ export function buildBrokerProfileRows(
   brokerAccounts: Record<string, BrokerAccount[]>,
   signInEnds: SignInEnds = new Map(),
   pluginLogo: BrokerPluginLogo = () => null,
+  syncErrors: Readonly<Record<string, string>> = {},
 ): BrokerProfileRow[] {
   return config.brokerInstances.map((instance) => {
     const adapter = adapters.get(instance.brokerType) ?? null;
@@ -132,7 +133,11 @@ export function buildBrokerProfileRows(
     // An adapter that fronts several brokers names the broker and how it connects.
     const described = adapter?.describeInstance?.(instance) ?? null;
     const mode = described?.method ?? resolveMode(adapter, instance, status);
-    const state = resolveState(instance, adapter, mode, status);
+    const connection = resolveState(instance, adapter, mode, status);
+    const syncError = syncErrors[instance.id];
+    const state = syncError && !["disabled", "unavailable", "sign-in"].includes(connection.state)
+      ? { ...connection, state: "error" as const, label: t("Sync failed"), message: t(syncError) }
+      : connection;
     const accounts = brokerAccounts[instance.id] ?? [];
     const portfolioLastSyncedAt = Math.max(
       0,