gloomberb 0.16.4 → 0.16.5

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

@@ -13,6 +13,7 @@ import {
   extendedQuoteFields,
   extendedSessionsOf,
   findCollection,
+  listingLabel,
   loadCollectionQuotes,
   valuePortfolioAllocation,
   valuePortfolioPositions,
@@ -27,9 +28,10 @@ import {
   formatAllocationWeight,
   formatTradeUnits,
 } from "./allocation";
-import { currencyMinorDigits, formatMarketPrice, formatMarketQuantity } from "../../../market-data/market/format";
+import { currencyPriceMinDigits, formatMarketPrice, formatMarketQuantity } from "../../../market-data/market/format";
 import { resolvePortfolioTotalsCurrency } from "./summary/totals";
 import { quoteFreshnessFields } from "../shared/report-freshness";
+import { importedFromText } from "./imported-from";
 
 const DEFAULT_ROW_LIMIT = 50;
 const MAX_ROW_LIMIT = 200;
@@ -54,7 +56,7 @@ const tradeUnits = (value: unknown, row: HeadlessPaneRow) => (
 /** Money per unit at the currency's minor digits: $230.00, not 230. */
 const unitMoney = (currencyKey: string) => (value: unknown, row: HeadlessPaneRow) => (
   typeof value === "number"
-    ? formatMarketPrice(value, { assetCategory: textOf(row.assetCategory), minimumFractionDigits: Math.min(2, currencyMinorDigits(textOf(row[currencyKey]))) })
+    ? formatMarketPrice(value, { assetCategory: textOf(row.assetCategory), minimumFractionDigits: currencyPriceMinDigits(textOf(row[currencyKey])) })
     : formatNumber(undefined)
 );
 
@@ -113,6 +115,25 @@ const WATCHLIST_COLUMNS: HeadlessPaneColumn[] = [
   { key: "changePercent", header: "Chg", align: "right", format: percent },
 ];
 
+/**
+ * `columns` with the text report's Ticker column naming each listing as
+ * `portfolio show` does (SAN:EPA, SAN:NYSE), not by the key it is stored under,
+ * which leaves two listings of one symbol looking alike. `textFormat` is text
+ * only: JSON and CSV keep the stored key in `symbol`, and the rows stay keyed
+ * by it.
+ */
+function withListingLabels(columns: HeadlessPaneColumn[], tickers: readonly TickerRecord[]): HeadlessPaneColumn[] {
+  const labels = new Map(tickers.map((ticker) => [ticker.metadata.ticker, listingLabel(ticker)]));
+  return columns.map((column) => column.key !== "symbol" ? column : {
+    ...column,
+    textFormat: (value, row) => {
+      // The cash line is not a listing, even when a ticker is called CASH; its row carries no exchange.
+      if (typeof value !== "string" || !("exchange" in row)) return textOf(value) ?? formatNumber(undefined);
+      return labels.get(value) ?? value;
+    },
+  });
+}
+
 function finite(value: unknown): number | null {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
@@ -234,7 +255,9 @@ async function portfolioHoldings(
   const broker = !!(target.portfolio.brokerId || target.portfolio.brokerInstanceId);
   const showTargets = allocation.targetSum != null;
   const targetNote = describeTargetSum(allocation.targetSum);
+  const imported = importedFromText(target.portfolio);
   const notices = [
+    ...(imported ? [imported] : []),
     ...(rows.length > limit
       ? [`${rows.length - limit} more position${rows.length - limit === 1 ? "" : "s"} not shown; totals include every position.`]
       : []),
@@ -244,7 +267,10 @@ async function portfolioHoldings(
 
   return {
     freshness: { source: broker ? "Your broker account and Gloom Cloud" : "Local portfolio and Gloom Cloud" },
-    columns: withExtendedColumns(showTargets ? [...POSITION_COLUMNS, ...TARGET_COLUMNS] : POSITION_COLUMNS, extendedSessions),
+    columns: withListingLabels(
+      withExtendedColumns(showTargets ? [...POSITION_COLUMNS, ...TARGET_COLUMNS] : POSITION_COLUMNS, extendedSessions),
+      tickers,
+    ),
     rows: shown,
     complete: unavailable.length === 0,
     ...(unavailable.length
@@ -252,6 +278,7 @@ async function portfolioHoldings(
       : {}),
     metadata: {
       collection: { kind: "portfolio", id: target.id, name: target.name, broker },
+      ...(target.portfolio.importedFrom ? { importedFrom: target.portfolio.importedFrom } : {}),
       currency,
       positions: rows.length,
       totals: {
@@ -299,7 +326,10 @@ async function watchlistHoldings(
   const shown = rows.slice(0, limit);
   return {
     freshness: { source: "Local watchlist and Gloom Cloud" },
-    columns: withExtendedColumns(WATCHLIST_COLUMNS, extendedSessionsOf(shown.map((row) => row.extendedSession))),
+    columns: withListingLabels(
+      withExtendedColumns(WATCHLIST_COLUMNS, extendedSessionsOf(shown.map((row) => row.extendedSession))),
+      tickers,
+    ),
     rows: shown,
     metadata: {
       collection: { kind: "watchlist", id: target.id, name: target.name },

package/src/plugins/builtin/portfolio-list/imported-from.ts

@@ -0,0 +1,8 @@
+import type { Portfolio } from "../../../types/ticker";
+
+/** One line naming the filing an imported portfolio comes from, as `portfolio show`, `fn PF` and the import print it. */
+export function importedFromText(portfolio: Pick<Portfolio, "importedFrom">): string | null {
+  const source = portfolio.importedFrom;
+  if (!source) return null;
+  return `Weights from ${source.name}'s 13F for ${source.period}, filed ${source.filed}; not your holdings.`;
+}

package/src/plugins/builtin/portfolio-list/live-valuation.ts

@@ -1,5 +1,6 @@
 import type { AnalystResearchData, Fundamentals, Quote } from "../../../types/financials";
 import { hasLikelyQuoteUnitMismatch } from "../../../utils/currency-units";
+import { priceEarningsEps } from "../../../utils/fundamentals";
 import { selectMarketCapitalization, type MarketCapitalization } from "../../../utils/market-capitalization";
 import { priceEarningsOnEarnings, type PriceEarnings } from "../../../utils/price-earnings";
 
@@ -54,9 +55,12 @@ function repriceMultiple(
   return price / perShare;
 }
 
-/** Trailing P/E over the current price; not meaningful when the trailing EPS is zero or a loss. */
+/**
+ * Trailing P/E over the current price; not meaningful when the trailing EPS is zero or a loss. An EPS in another
+ * currency than the price is repriced at the rate the served P/E converted it at.
+ */
 export function liveTrailingPE(quote: Quote | null | undefined, fundamentals: Fundamentals | undefined): PriceEarnings | undefined {
-  return priceEarningsOnEarnings(repriceMultiple(fundamentals?.trailingPE, fundamentals?.eps, quote, fundamentals), fundamentals?.eps);
+  return priceEarningsOnEarnings(repriceMultiple(fundamentals?.trailingPE, priceEarningsEps(fundamentals), quote, fundamentals), fundamentals?.eps);
 }
 
 /** Forward P/E over the current price; not meaningful when the forward EPS behind it is zero or a loss. */

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

@@ -88,7 +88,7 @@ import { useThrottledTickerOrder } from "../use-throttled-ticker-order";
 import { useThrottledMemo } from "../use-throttled-memo";
 import { useColumnClock } from "../use-column-clock";
 import { liveMarketCapitalization } from "../live-valuation";
-import { hasUnknownOptionMultiplier } from "../position-metrics";
+import { hasUnknownOptionMultiplier } from "../../../../portfolio/position-metrics";
 import {
   allocationTotal,
   buildPortfolioAllocation,
@@ -126,6 +126,8 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
 
   const [streamWindow, setStreamWindow] = useState({ start: 0, end: 24 });
   const [quickAddFocused, setQuickAddFocused] = useState(false);
+  // Bumped by the empty table's "+ ticker" button to open the add row.
+  const [quickAddRequest, setQuickAddRequest] = useState(0);
 
   const {
     cursorSymbol,
@@ -612,6 +614,7 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
     return null;
   }, [activeCollectionId, config, currentPortfolio]);
   const showQuickAdd = !!(activeCollectionId && activeCollectionEntry && quickAddCollectionKind);
+  const requestQuickAdd = useCallback(() => setQuickAddRequest((count) => count + 1), []);
   const quickAddHeight = showQuickAdd ? 1 : 0;
   const selectedFinancials = cursorSymbol ? financialsMap.get(cursorSymbol) : undefined;
   const selectedCap = liveMarketCapitalization(selectedFinancials?.quote, selectedFinancials?.fundamentals);
@@ -636,6 +639,7 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
       width={width}
       onAdded={handleTickerAdded}
       onFocusChange={setQuickAddFocused}
+      focusRequest={quickAddRequest}
     />
   ) : null;
 
@@ -674,6 +678,7 @@ export function PortfolioListPane({ focused, width, height }: PaneProps) {
           visibleRangeBuffer={3}
           resetScrollKey={activeCollectionId}
           onRowActivate={handleRowActivate}
+          onAddTicker={showQuickAdd ? requestQuickAdd : undefined}
           rootHeight={contentHeight}
         />
       ) : (

package/src/plugins/builtin/portfolio-list/quick-add/index.tsx

@@ -30,6 +30,8 @@ import {
 } from "./resolution";
 
 const QUICK_ADD_DEBOUNCE_MS = 300;
+/** The pane key that opens the add row, as its footer hint shows it. */
+export const QUICK_ADD_KEY = "a";
 
 export type { QuickAddCollectionKind } from "./resolution";
 
@@ -101,6 +103,7 @@ export function QuickAddTickerInput({
   width,
   onAdded,
   onFocusChange,
+  focusRequest = 0,
 }: {
   collectionId: string;
   collectionKind: QuickAddCollectionKind;
@@ -109,6 +112,12 @@ export function QuickAddTickerInput({
   width: number;
   onAdded: (symbol: string) => void;
   onFocusChange?: (focused: boolean) => void;
+  /**
+   * Bumped by a control outside the row, such as the empty table's
+   * "+ ticker" button, to open it. A click there focuses the pane in the same
+   * press, so the row opens once the pane is focused.
+   */
+  focusRequest?: number;
 }) {
   const dispatch = useAppDispatch();
   const { notify } = usePluginAppActions();
@@ -132,6 +141,13 @@ export function QuickAddTickerInput({
     setInputFocused(false);
   }, []);
 
+  const handledFocusRequestRef = useRef(focusRequest);
+  useEffect(() => {
+    if (focusRequest === handledFocusRequestRef.current || !focused) return;
+    handledFocusRequestRef.current = focusRequest;
+    focusInput();
+  }, [focusInput, focusRequest, focused]);
+
   const resetInput = useCallback(() => {
     setInputValue("");
     setValidation(IDLE_VALIDATION);
@@ -350,7 +366,7 @@ export function QuickAddTickerInput({
 
   // The row shows only its placeholder, so the footer says which key reaches it.
   usePaneFooter("portfolio-list:quick-add", () => ({
-    hints: inputFocused ? [] : [{ id: "add", key: "a", label: "dd", onPress: focusInput }],
+    hints: inputFocused ? [] : [{ id: "add", key: QUICK_ADD_KEY, label: "dd", onPress: focusInput }],
   }), [focusInput, inputFocused]);
 
   return (

package/src/plugins/builtin/portfolio-list/summary/totals.ts

@@ -14,7 +14,7 @@ import {
   resolvePortfolioPositionPnl,
   portfolioPnlPercent,
   type PortfolioPositionPnl,
-} from "../position-metrics";
+} from "../../../../portfolio/position-metrics";
 
 /** A position lot valued from a current quote, in the totals currency. */
 interface PricedPortfolioLot {

package/src/plugins/builtin/portfolio-list/table.tsx

@@ -1,4 +1,5 @@
 import { useCallback, useMemo, useRef } from "react";
+import { QUICK_ADD_KEY } from "./quick-add";
 import {
   TickerListTableView,
   type DataTableKeyEvent,
@@ -15,7 +16,7 @@ import type { TickerRecord } from "../../../types/ticker";
 import { objectVersion } from "../../../utils/object-version";
 import { columnContextVersion } from "./cell-version";
 import { getColumnValue, type ColumnContext } from "./metrics";
-import { portfolioPnlLabel } from "./position-metrics";
+import { portfolioPnlLabel } from "../../../portfolio/position-metrics";
 import { PORTFOLIO_ROW_MENU_KEYS } from "./row-actions";
 
 export type { QuoteFlashDirection };
@@ -98,6 +99,7 @@ export function PortfolioTickerTable({
   visibleRangeBuffer,
   resetScrollKey,
   onRowActivate,
+  onAddTicker,
   rootHeight,
 }: {
   columns: ColumnConfig[];
@@ -117,6 +119,8 @@ export function PortfolioTickerTable({
   visibleRangeBuffer?: number;
   resetScrollKey?: unknown;
   onRowActivate?: (ticker: TickerRecord) => void;
+  /** Opens the add row; the empty table offers it as a button. */
+  onAddTicker?: () => void;
   rootHeight?: number;
 }) {
   const cellCacheRef = useRef(createRowValueCache<string, ReturnType<typeof getColumnValue>>(5000));
@@ -175,6 +179,8 @@ export function PortfolioTickerTable({
       resetScrollKey={resetScrollKey}
       onRowActivate={onRowActivate}
       rowMenuAccelerators={PORTFOLIO_ROW_MENU_KEYS}
+      onAddTicker={onAddTicker}
+      addTickerShortcut={onAddTicker ? QUICK_ADD_KEY : undefined}
       rootHeight={rootHeight}
     />
   );

package/src/plugins/builtin/power/client.ts

@@ -2,6 +2,8 @@ import { apiClient } from "../../../api-client";
 import type { PowerBoard, PowerDetail, PowerFilter, PowerHistory, PowerProject } from "../../../api-client/power";
 import { createPluginCache } from "../../../data/plugin-cache";
 import { loadCloudResource, unavailableOnServer } from "../shared/cloud-resource";
+import { powerTickerScopes, type PowerTab, type PowerTickerScope } from "./model";
+import { powerQuery } from "./query";
 
 const cacheOptions = { source: "gloom-cloud", schemaVersion: 1, policy: { staleMs: 60 * 60_000, expireMs: 30 * 86_400_000 } };
 export const powerBoardCache = createPluginCache<PowerBoard>({ ...cacheOptions, kind: "power-board" });
@@ -88,6 +90,20 @@ export async function fetchAllPowerHistory(filter: PowerFilter, client: Pick<Pow
   }
   return { ...first, points, hasMore: false, nextOffset: null };
 }
+/**
+ * How many records name a ticker on each other tab, for a tab that has none:
+ * one single-row page per scope, read for its total, which a free preview
+ * reports in full. A scope that fails to answer has no total rather than
+ * failing the tab it explains.
+ */
+export async function fetchPowerTickerScopes(symbol: string, tab: PowerTab, context: string,
+  client: Pick<PowerApi, "getCloudPowerBoard"> = apiClient, signal?: AbortSignal): Promise<PowerTickerScope[]> {
+  return Promise.all(powerTickerScopes(tab, context).map((scope) => {
+    const count = () => fetchPowerBoard({ ...powerQuery({ tab: scope.tab, context: scope.context }, symbol), limit: 1 }, client, signal).then((board) => board.total);
+    // One retry: a count is cheap, and the first of several at once is the one most often refused.
+    return count().catch(() => count()).then((total) => ({ ...scope, total }), () => ({ ...scope, total: null }));
+  }));
+}
 const key = (query: unknown, scope: string) => `${scope}:${JSON.stringify(query)}`;
 export const loadPowerBoard = (filter: PowerFilter, scope: string, force = false, signal?: AbortSignal) =>
   loadCloudResource(powerBoardCache, key(filter, scope), () => fetchPowerBoard(filter, apiClient, signal), { force, validate: validatePowerBoard });

package/src/plugins/builtin/power/evidence.ts

@@ -2,7 +2,7 @@ import type { PowerBoard, PowerHistory } from "../../../api-client/power";
 import type { PaneScreenshotEvidenceHook } from "../../../cli/pane-functions/screenshot-evidence";
 import { useRemoteUiNode } from "../../../remote/semantic-tree";
 import { isRecord } from "../../../utils/guards";
-import { fetchPowerBoard, fetchAllPowerHistory, validatePowerBoard, validatePowerHistory } from "./client";
+import { fetchPowerBoard, fetchAllPowerHistory, fetchPowerTickerScopes, validatePowerBoard, validatePowerHistory } from "./client";
 import { otherRows, powerTab, projectRows } from "./model";
 import { powerQuery } from "./query";
 interface PowerEvidence {
@@ -29,7 +29,11 @@ export const powerScreenshotEvidence: PaneScreenshotEvidenceHook<PowerEvidence>
     const filter = powerQuery({ ...settings, ...resolved.options, tab }, symbol);
     const board = await fetchPowerBoard({ ...filter, limit: 100 });
     const history = tab === "history" ? await fetchAllPowerHistory(filter) : undefined;
-    return { settings: { powerSnapshot: { board, ...(history ? { history } : {}) } }, financials: [] };
+    // A ticker with nothing on this tab: the counts that say where its records are, captured with the rest.
+    const empty = !!symbol && tab !== "coverage" && !(tab === "history" ? history?.points.length : tab === "outcomes" ? board.rates.length
+      : tab === "utilities" ? board.exposure.length : board.projects.length);
+    const tickerScopes = empty && symbol ? await fetchPowerTickerScopes(symbol, tab, String(settings.context ?? resolved.options.context ?? "capacity")) : undefined;
+    return { settings: { powerSnapshot: { board, ...(history ? { history } : {}), ...(tickerScopes ? { tickerScopes } : {}) } }, financials: [] };
   },
   read(value) {
     if (!isRecord(value) || value.kind !== "power" || value.version !== 1 || value.complete !== true || !isRecord(value.board)

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

@@ -1,11 +1,50 @@
-import type { HeadlessPaneDefinition } from "../../../types/plugin";
-import { fetchPowerBoard, fetchAllPowerHistory } from "./client";
+import type { DataTableColumn } from "../../../components";
+import type { HeadlessPaneColumn, HeadlessPaneDefinition, HeadlessPaneRow } from "../../../types/plugin";
+import { withoutQuietColumns } from "../shared/research-cells";
+import { fetchPowerBoard, fetchAllPowerHistory, fetchPowerTickerScopes } from "./client";
 import { powerQuery } from "./query";
-import { POWER_TABS, powerTab } from "./model";
+import {
+  COVERAGE_COLUMNS, EXPOSURE_COLUMNS, GENERATION_COLUMNS, HISTORY_COLUMNS, POWER_TABS, PROJECT_COLUMNS, RATE_COLUMNS, UTILITY_COLUMNS,
+  historyRows, powerCoverageNote, powerLoadedSources, powerNumber, powerPercent, powerRegion, powerScopeOptions, powerTab, powerTickerEmpty, projectRows, tickerLabel, titleCase, UNMAPPED, type PowerTab,
+} from "./model";
+
+/** Bars the pane draws beside the numbers they are made of; the report has the numbers. */
+const GRAPHIC_COLUMNS = new Set(["outcome", "pipeline"]);
+/** Columns that only repeat a default on every row, as the pane leaves them out. */
+const QUIET_COLUMNS: Record<string, readonly string[]> = { scope: ["Project"], unknownCapacity: ["0"], unknown: ["0"], fuel: ["Load"], role: ["Direct"], kind: ["Queue"] };
+const text = (value: unknown) => value == null || value === "" ? "-" : String(value);
+const coded = (value: unknown) => typeof value === "string" && value ? titleCase(value) : "-";
+
+/**
+ * The pane's columns for a tab, printed as the pane prints them: MW and MWh
+ * to a tenth with thousands separators, rates as percentages, register codes
+ * by name, and each record's listed company or "unmapped". Raw metrics and
+ * evidence stay in the exported rows, out of the table.
+ */
+function reportColumns(tab: PowerTab, context: unknown): HeadlessPaneColumn[] {
+  const columns: DataTableColumn[] = tab === "capacity" && context === "generation" ? GENERATION_COLUMNS : tab === "capacity" && context === "utility" ? UTILITY_COLUMNS
+    : ["queue", "loads", "capacity"].includes(tab) ? PROJECT_COLUMNS : tab === "history" ? HISTORY_COLUMNS : tab === "outcomes" ? RATE_COLUMNS : tab === "utilities" ? EXPOSURE_COLUMNS : COVERAGE_COLUMNS;
+  // The coverage list names its register by its own id; everything else by the record's source.
+  const region = (value: unknown, row: HeadlessPaneRow) => typeof value !== "string" ? "-"
+    : tab === "utilities" ? value : powerRegion(value, String((tab === "coverage" ? row.id : row.sourceId) ?? ""));
+  const format = (column: DataTableColumn): HeadlessPaneColumn["format"] => {
+    if (column.id === "region") return region;
+    if (["fuel", "status", "kind", "role"].includes(column.id)) return coded;
+    if (column.id === "ticker") return (value) => typeof value === "string" && value ? value : UNMAPPED;
+    if (column.id === "developer") return (value, row) => text(value ?? row.utility);
+    if (column.id === "observedAt") return (value) => typeof value === "string" ? value.slice(0, 16).replace("T", " ") : "-";
+    if (/Rate$/.test(column.id)) return (value) => typeof value === "number" ? powerPercent(value) : "-";
+    if (column.align === "right") return (value) => typeof value === "number" ? `${column.id === "changeMw" && value > 0 ? "+" : ""}${powerNumber(value)}` : "-";
+    return text;
+  };
+  // The pane groups outcomes under region headings; the report names the region on each row.
+  return [...(tab === "outcomes" ? [{ id: "region", label: "Region", width: 16, align: "left" as const }] : []), ...columns].filter((column) => !GRAPHIC_COLUMNS.has(column.id))
+    .map((column) => ({ key: column.id, header: column.label, align: column.align === "right" ? "right" as const : "left" as const, format: format(column) }));
+}
 
 export const powerHeadless: HeadlessPaneDefinition<"bundle"> = {
   shape: "bundle",
-  freshness: { source: "Grid operator queues and utility filings", status: "not-a-feed", basis: "published records" },
+  freshness: { source: "Grid operator queues and utility filings", status: "not-a-feed", basis: "published records", dataset: true },
   argument: { kind: "free-text", optional: true, placeholder: "ticker", description: "Optional listed developer or utility ticker, with exchange suffix where needed." },
   options: [
     { key: "tab", type: "enum", settingKey: "tab", defaultValue: "queue", values: POWER_TABS.map(({ value }) => ({ value })), description: "Queue, history, outcomes, large loads, utility exposure, capacity or coverage." },
@@ -36,10 +75,35 @@ export const powerHeadless: HeadlessPaneDefinition<"bundle"> = {
       projects.push(...page.projects); offset = page.nextOffset; hasMore = page.hasMore;
     }
     const history = tab === "history" ? await fetchAllPowerHistory(filter, ctx.apiClient) : null;
-    const rows = tab === "history" ? history!.points : tab === "outcomes" ? board.rates : tab === "utilities" ? board.exposure : tab === "coverage" ? board.coverage : projects;
+    // Exported rows keep every field the server sent; the pane's derived cells (the ticker map, location, scope) ride beside them.
+    const cells = projectRows(projects);
+    const rows: HeadlessPaneRow[] = tab === "history" ? historyRows(history!.points).map((point) => ({ ...point, date: point.basis === "published" ? point.period : point.observedAt.slice(0, 16).replace("T", " ") }))
+      : tab === "outcomes" ? board.rates.map((rate) => ({ ...rate }))
+        : tab === "utilities" ? board.exposure.map((exposure) => ({ ...exposure, ticker: tickerLabel(exposure) }))
+          : tab === "coverage" ? board.coverage.map((coverage) => ({ ...coverage }))
+            : projects.map((project, index) => {
+              const { ticker, location, scope, generationMwh, summerPeakDemandMw, winterPeakDemandMw, salesMwh, revenueUsd } = cells[index]!.cells;
+              return { ...project, ticker, location, scope, generationMwh, summerPeakDemandMw, winterPeakDemandMw, salesMwh, revenueUsd };
+            });
     const locked = history?.locked ?? (tab === "outcomes" ? board.locked.rates : tab === "utilities" ? board.locked.exposure : tab === "coverage" ? 0 : board.locked.projects);
-    return { complete: locked === 0, sections: [{ title: POWER_TABS.find((t) => t.value === tab)!.label, rows: rows.map((r) => ({ ...r })) }],
+    const columns = reportColumns(tab, args.options.context);
+    const shown = withoutQuietColumns(columns.map((column) => ({ id: column.key, label: column.header, width: 0, align: "left" as const })), rows,
+      (row, id) => columns.find((column) => column.key === id)!.format!(row[id], row), QUIET_COLUMNS).map((column) => column.id);
+    // A ticker with nothing on this tab says where its records are instead; a narrower filter is the filters' doing.
+    const narrowed = ["country", "region", "fuel", "status", "search", "sourceId", "from", "to", "loadClass", "historical"].some((key) => !!args.options[key]);
+    const empty = !rows.length && symbol && !narrowed && tab !== "coverage" ? await fetchPowerTickerScopes(symbol, tab, String(args.options.context ?? "capacity"), ctx.apiClient)
+      .then((scopes) => {
+        const message = powerTickerEmpty(symbol, tab, String(args.options.context ?? "capacity"), scopes);
+        const where = message.found.map((scope) => `${powerNumber(scope.total)} ${scope.label} (${powerScopeOptions(scope)})`).join(", ");
+        const loaded = powerLoadedSources(tab, board.coverage);
+        return [message.title, where ? `${symbol} has ${where}.` : message.hint?.replace(/\.$/, " (--search <name>)."),
+          loaded ? `Sources loaded now: ${loaded}.` : null].filter(Boolean).join(" ");
+      }) : "No reported records match these filters.";
+    // Missing or unsupported sources are coverage, not failures: one plain line, details in --tab coverage.
+    const coverageNote = tab === "capacity" ? null : powerCoverageNote(board.coverage);
+    return { complete: locked === 0, sections: [{ title: POWER_TABS.find((t) => t.value === tab)!.label, columns: columns.filter((column) => shown.includes(column.key)), rows, empty }],
       metadata: { generatedAt: board.generatedAt, access: board.access, locked, total: board.total, units: "MW unless specified", filters: filter, aggregates: board.aggregates, coverage: board.coverage },
-      errors: [...(locked ? ["Additional records and history need Gloom Pro."] : []), ...board.coverage.filter((c) => c.status !== "current").map((c) => `${c.region}: ${c.status}${c.reason ? `: ${c.reason}` : ""}`)] };
+      ...(coverageNote ? { notes: [coverageNote] } : {}),
+      ...(locked ? { errors: ["Additional records and history need Gloom Pro."] } : {}) };
   },
 };

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

@@ -10,7 +10,10 @@ export const powerModule: PluginModule = {
     description: "Pro: interconnection queues, historical MW and outcomes, datacenter loads, utility exposure and generation capacity, with primary evidence.",
     keywords: ["power", "electricity", "interconnection", "grid", "datacenter", "utility", "renewables", "storage", "capacity"],
     shortcut: { prefix: "POWER", argKind: "text", argPlaceholder: "ticker", argOptional: true }, headless: powerHeadless,
-    createInstance: (_context, options) => ({ placement: "floating", params: { symbol: options?.symbol ?? options?.arg?.trim().toUpperCase() ?? "" } }) }],
+    createInstance: (_context, options) => {
+      const symbol = options?.symbol ?? options?.arg?.trim().toUpperCase() ?? "";
+      return { placement: "floating", params: { symbol }, ...(symbol ? { title: `POWER ${symbol}` } : {}) };
+    } }],
   setup(ctx) { for (const cache of [powerBoardCache, powerHistoryCache, powerDetailCache]) cache.attach(ctx.persistence); },
   dispose() { for (const cache of [powerBoardCache, powerHistoryCache, powerDetailCache]) cache.reset(); },
 };

package/src/plugins/builtin/power/model.ts

@@ -8,10 +8,81 @@ export const powerTab = (value: unknown): PowerTab => POWER_TABS.find((tab) => t
 const REGISTERS: Record<string, string> = { "neso-tec": "GB transmission", "neso-embedded": "GB embedded", "neso-interconnector": "GB interconnectors" };
 const REGIONS: Record<string, string> = { LBNL: "US project queues", "LBNL-ANNUAL": "US annual queues", EIA860: "US generation capacity", EIA861: "US utilities", EIA923: "US generation output" };
 export const powerRegion = (value: string, sourceId?: string) => REGISTERS[sourceId ?? ""] ?? REGIONS[value] ?? value;
+/** A source with stored records, even when its latest refresh failed. */
+const loadedSource = (c: PowerCoverage) => (c.status === "current" || c.status === "stale") && c.records > 0;
+const names = (rows: readonly PowerCoverage[]) => [...new Set(rows.map((c) => c.region === "EirGrid" ? "Ireland" : c.region))].join(", ");
+/**
+ * Which US grid operators' queues loaded, in plain words. Source errors and
+ * unsupported registers stay in the Coverage tab and on the server; a missing
+ * queue is a gap in coverage, never zero.
+ */
+export function powerCoverageNote(coverage: readonly PowerCoverage[]): string | null {
+  const queues = coverage.filter((c) => c.country === "US" && c.role === "direct" && c.kind === "queue");
+  const missing = queues.filter((c) => !loadedSource(c));
+  if (!missing.length) return null;
+  const loaded = queues.filter(loadedSource);
+  return `US queues: ${loaded.length ? `${names(loaded)} loaded; ` : ""}${names(missing)} not available`;
+}
+/**
+ * The registers carrying records right now, named, for a ticker that has none
+ * in them: grid operator and TSO registers, or the EIA filings behind the
+ * Capacity tab. Null when nothing is loaded.
+ */
+export function powerLoadedSources(tab: PowerTab, coverage: readonly PowerCoverage[]): string | null {
+  const loaded = coverage.filter((c) => loadedSource(c) && (tab === "capacity" ? c.role === "context" : c.role === "direct"));
+  if (!loaded.length) return null;
+  return tab === "capacity" ? "US EIA generation and utility filings" : names([...loaded.filter((c) => c.country === "US"), ...loaded.filter((c) => c.country !== "US")]);
+}
 export const titleCase = (value: string) => value.replace(/(^|[ _-])\w/g, (match) => match.toUpperCase());
 export const powerNumber = (n: number | null | undefined) => n == null ? "--" : n.toLocaleString("en-US", { maximumFractionDigits: 1 });
 export const powerPercent = (n: number | null) => n == null ? "--" : `${(n * 100).toFixed(1)}%`;
-const tickerLabel = (row: { entities: PowerProject["entities"] }) => [...new Set(row.entities.flatMap((e) => e.tickers.map((t) => t.ticker)))].join(", ") || "--";
+/** The listed companies a record names, or null when its register names none: the ticker map. */
+export const tickerLabel = (row: { entities: PowerProject["entities"] }) => [...new Set(row.entities.flatMap((e) => e.tickers.map((t) => t.ticker)))].join(", ") || null;
+/** What the ticker column says for a record no listed company is mapped to. */
+export const UNMAPPED = "unmapped";
+
+/** Where else a ticker's records can sit: each tab, and the capacity tab's contexts, with what they list. */
+const POWER_TICKER_SCOPES = [
+  { tab: "queue", context: "capacity", label: "interconnection queue records", view: "Queue" },
+  { tab: "loads", context: "capacity", label: "large-load requests", view: "Loads" },
+  { tab: "capacity", context: "capacity", label: "generation capacity records", view: "Capacity" },
+  { tab: "capacity", context: "generation", label: "monthly generation records", view: "Generation" },
+  { tab: "capacity", context: "utility", label: "utility sales records", view: "Utility sales" },
+] as const satisfies readonly { tab: PowerTab; context: string; label: string; view: string }[];
+/** `total` is null for a scope that did not answer, which is no evidence either way. */
+export type PowerTickerScope = (typeof POWER_TICKER_SCOPES)[number] & { total: number | null };
+const sameScope = (scope: { tab: string; context: string }, tab: PowerTab, context: string) =>
+  scope.tab === tab && (tab !== "capacity" || scope.context === context)
+  // Utilities are the large loads summed by utility: a ticker with no loads has no exposure either.
+  || tab === "utilities" && scope.tab === "loads";
+/** The scopes to count a ticker's records in when the open tab has none of them. */
+export const powerTickerScopes = (tab: PowerTab, context: string) => POWER_TICKER_SCOPES.filter((scope) => !sameScope(scope, tab, context));
+
+/** What the open tab lists, for the sentence that says none of it maps to a ticker. */
+function powerTabRecords(tab: PowerTab, context: string): string {
+  if (tab === "capacity") return POWER_TICKER_SCOPES.find((scope) => scope.tab === "capacity" && scope.context === context)?.label ?? "capacity records";
+  return { queue: "interconnection queue records", history: "queue history records", outcomes: "queue outcomes", loads: "large-load requests",
+    utilities: "large-load requests or utility exposure", coverage: "records" }[tab];
+}
+
+/**
+ * Why a ticker's tab is empty, and where its records are instead: the title
+ * says what does not map to it, the hint where it has records, or, once every
+ * other tab has answered with none, that a name search is what is left.
+ */
+export function powerTickerEmpty(symbol: string, tab: PowerTab, context: string, scopes: readonly PowerTickerScope[]) {
+  const found = scopes.filter((scope): scope is PowerTickerScope & { total: number } => (scope.total ?? 0) > 0);
+  const answered = scopes.length > 0 && scopes.every((scope) => scope.total != null);
+  return {
+    title: `No ${powerTabRecords(tab, context)} map to ${symbol}.`,
+    found,
+    hint: found.length ? `${symbol} has ${found.map((scope) => `${powerNumber(scope.total)} ${scope.label}`).join(", ")}.`
+      : answered ? `No power records map to ${symbol}; search by the company's or a subsidiary's name instead.` : null,
+  };
+}
+/** The options that open a scope from the command line. */
+export const powerScopeOptions = (scope: { tab: string; context: string }) =>
+  scope.tab === "capacity" && scope.context !== "capacity" ? `--tab capacity --context ${scope.context}` : `--tab ${scope.tab}`;
 const historyKey = (p: PowerHistoryPoint) => JSON.stringify([p.sourceId, p.country, p.region, p.kind, p.fuel, p.status, p.historical, p.basis]);
 /** Annual benchmarks use their stated period. Current queues use when we observed them, never a proposed completion date. */
 export function historyDate(p: PowerHistoryPoint): Date {