gloomberb 0.13.3 → 0.14.0

package/src/plugins/builtin/portfolio-list/position-cost-integrity.test.ts

@@ -0,0 +1,101 @@
+import { expect, test } from "bun:test";
+import { hydrateTickerMetadata } from "../../../tickers/metadata";
+import { createDefaultConfig } from "../../../types/config";
+import type { TickerPosition, TickerRecord } from "../../../types/ticker";
+import type { TickerFinancials } from "../../../types/financials";
+import { buildPositionRows } from "../ticker-detail/overview/model";
+import { buildSetPortfolioPositionWorkflow } from "./command-bar";
+import { setManualPortfolioPosition } from "./mutations";
+import { getPortfolioPositionMetrics, resolvePortfolioPositionPnl, resolveBrokerFallbackMarketValue } from "./position-metrics";
+import { calculatePortfolioSummaryTotals, getColumnValue, getSortValue } from "./metrics";
+import { buildPortfolioSummarySegments } from "./summary";
+
+const now = Date.now();
+const financials: TickerFinancials = {
+  quote: { symbol: "AAPL", price: 120, currency: "USD", change: 0, changePercent: 0, previousClose: 120, lastUpdated: now },
+  annualStatements: [], quarterlyStatements: [], priceHistory: [],
+};
+const context = { activeTab: "main", baseCurrency: "USD", exchangeRates: new Map([["USD", 1]]), now };
+const lot = (overrides: Partial<TickerPosition> = {}): TickerPosition => ({ portfolio: "main", broker: "manual", shares: 10, currency: "USD", ...overrides });
+const ticker = (...positions: TickerPosition[]): TickerRecord => ({ metadata: {
+  ticker: "AAPL", name: "Apple", exchange: "NASDAQ", currency: "USD", assetCategory: "STK",
+  positions, portfolios: ["main"], watchlists: [], custom: {}, tags: [],
+} });
+const totals = (record: TickerRecord, source = financials) => calculatePortfolioSummaryTotals(
+  [record], new Map([["AAPL", source]]), "USD", context.exchangeRates, true, "main",
+);
+const column = (id: string) => ({ id, label: id, width: 12, align: "right" as const });
+
+test("missing cost is unavailable across hydration, cells, sorting, summary and overview; zero remains explicit", () => {
+  for (const raw of [{}, { avgCost: null, avg_cost: 100 }, { avgCost: Number.NaN }, { avgCost: Infinity }]) {
+    const original = ticker(lot(raw as Partial<TickerPosition>));
+    const record = { metadata: hydrateTickerMetadata(JSON.parse(JSON.stringify(original.metadata))) };
+    expect(record.metadata.positions[0]!.avgCost).toBeUndefined();
+    expect(totals(record).unrealizedPnl).toBeNaN();
+    expect(totals(record).unrealizedPnlPct).toBeNaN();
+    for (const id of ["avg_cost", "cost_basis", "pnl", "pnl_pct"]) {
+      expect(getColumnValue(column(id), record, financials, context).text).toBe("—");
+      expect(getSortValue(column(id), record, financials, context)).toBeNull();
+    }
+    const row = buildPositionRows({ ticker: record, quote: financials.quote, quoteCurrency: "USD", baseCurrency: "USD", toBase: value => value })[0]!;
+    expect(row).toMatchObject({ pnlValue: null, pnlBasis: "unavailable", avg: "—", cost: "—", ret: "—" });
+  }
+  for (const raw of [{ avgCost: 0 }, { avg_cost: 0 }]) {
+    const record = { metadata: hydrateTickerMetadata({ ...ticker().metadata, positions: [{ ...lot(), ...raw }] }) };
+    expect(record.metadata.positions[0]!.avgCost).toBe(0);
+    expect(totals(record)).toMatchObject({ totalCostBasis: 0, unrealizedPnl: 1200, unrealizedPnlPct: Number.NaN });
+    expect(getSortValue(column("cost_basis"), record, financials, context)).toBe(0);
+    expect(getColumnValue(column("cost_basis"), record, financials, context).text).toBe("0");
+    expect(getColumnValue(column("pnl_pct"), record, financials, context).text).toBe("—");
+  }
+});
+
+test("a current mark cannot refresh broker profit without cost, and manual correction restores current calculations", () => {
+  const record = ticker(lot({ unrealizedPnl: 200, marketValue: 1150, markPrice: 115 }));
+  expect(totals(record)).toMatchObject({ totalMktValue: 1200, totalCostBasis: Number.NaN, unrealizedPnl: 200, unrealizedPnlPct: Number.NaN,
+    unrealizedPnlBasis: "broker-snapshot", unavailableCostSymbols: ["AAPL"], brokerPnlSymbols: ["AAPL"] });
+  expect(getColumnValue(column("pnl"), record, financials, context)).toMatchObject({ text: "+200", pnlBasis: "broker-snapshot" });
+  expect(getSortValue(column("pnl"), record, financials, context)).toBe(200);
+  const summary = buildPortfolioSummarySegments({ totals: totals(record), accountState: null, widthBudget: 240 });
+  expect(summary.flatMap(segment => segment.parts.map(part => part.text)).join(" ")).toContain("Broker P&L");
+  const config = createDefaultConfig("/unused-cost-recovery");
+  expect(buildSetPortfolioPositionWorkflow(config, { activeCollectionId: "main", activeTicker: record })?.values.avgCost).toBe("");
+  const restored = setManualPortfolioPosition(record, "main", { shares: 10, avgCost: 105, currency: "USD" }).ticker;
+  expect(restored.metadata.positions[0]).toMatchObject({ avgCost: 105 });
+  expect(restored.metadata.positions[0]!.unrealizedPnl).toBeUndefined();
+  expect(totals(restored)).toMatchObject({ totalCostBasis: 1050, unrealizedPnl: 150, unrealizedPnlBasis: "quote-and-cost" });
+  expect(totals(restored).unavailableCostSymbols).toBeUndefined();
+});
+
+test("mixed lots select each independently, preserve offsetting exposure, and withhold an incomplete sum", () => {
+  const record = ticker(lot({ avgCost: 100 }), lot({ shares: -10, unrealizedPnl: 50 }));
+  expect(totals(record)).toMatchObject({ netMktValue: 0, totalMktValue: 2400, unrealizedPnl: 250,
+    unrealizedPnlBasis: "mixed", totalCostBasis: Number.NaN, unrealizedPnlPct: Number.NaN });
+  expect(getColumnValue(column("pnl"), record, financials, context)).toMatchObject({ text: "+250", pnlBasis: "mixed" });
+  expect(getSortValue(column("pnl"), record, financials, context)).toBe(250);
+  record.metadata.positions.push(lot({ shares: 1 }));
+  expect(totals(record).unrealizedPnl).toBeNaN();
+  expect(getSortValue(column("pnl"), record, financials, context)).toBeNull();
+});
+
+test("lot currencies convert before selection, including a quote in a third currency", () => {
+  const record = ticker(lot({ avgCost: 100, currency: "EUR" }), lot({ shares: -10, currency: "GBP", unrealizedPnl: 40 }));
+  const source = { ...financials, quote: { ...financials.quote!, price: 13000, currency: "JPY" } };
+  const rates = new Map([["EUR", 1.1], ["GBP", 1.25], ["JPY", 0.01]]);
+  const result = calculatePortfolioSummaryTotals([record], new Map([["AAPL", source]]), "USD", rates, true, "main");
+  expect(result).toMatchObject({ unrealizedPnl: 250, unrealizedPnlBasis: "mixed", totalCostBasis: Number.NaN });
+  rates.delete("GBP");
+  expect(calculatePortfolioSummaryTotals([record], new Map([["AAPL", source]]), "USD", rates, true, "main").unrealizedPnl).toBeNaN();
+});
+
+test("profit alone never manufactures cost or a complete market value, and overflow stays unavailable", () => {
+  const metrics = getPortfolioPositionMetrics(ticker(lot({ unrealizedPnl: 200 })), "main", "USD");
+  expect(metrics.hasBrokerMktValue).toBe(false);
+  expect(resolveBrokerFallbackMarketValue(metrics)).toBeNull();
+  expect(resolvePortfolioPositionPnl(metrics)).toEqual({ value: 200, basis: "broker-snapshot" });
+  const absentQuote = { ...financials, quote: undefined };
+  expect(totals(ticker(lot({ unrealizedPnl: 200 })), absentQuote)).toMatchObject({ totalMktValue: Number.NaN, unrealizedPnl: 200, unavailableSymbols: ["AAPL"] });
+  const overflow = getPortfolioPositionMetrics(ticker(lot({ shares: Number.MAX_VALUE, markPrice: 2 })), "main", "USD");
+  expect(overflow.hasBrokerMktValue).toBe(false);
+  expect(resolvePortfolioPositionPnl(overflow, 2)).toEqual({ value: null, basis: "unavailable" });
+});

package/src/plugins/builtin/portfolio-list/position-metrics.ts

@@ -1,65 +1,57 @@
 import type { TickerRecord } from "../../../types/ticker";
+import type { Quote } from "../../../types/financials";
+import type { PriceBasis } from "../../../types/instrument";
+import { resolvePriceBasis } from "../../../market-data/market/price-basis";
+import { getActiveQuoteDisplay, type ActiveQuoteDisplay } from "../../../market-data/market/status";
+import { resolveCurrencyUnit } from "../../../utils/currency-units";
 
 export interface PortfolioPositionMetrics {
   positionCurrency: string;
+  positionCount: number;
+  hasShorts: boolean;
   totalShares: number;
   totalCost: number;
+  /** Every nonzero lot has a finite source cost, independently of FX conversion. */
+  hasCostBasis: boolean;
+  /** Common source convention for displaying raw cost/mark; null is unknown or mixed. */
+  priceBasis: PriceBasis | null;
+  /** Signed cost basis, for net market value minus cost P&L. */
+  signedCost: number;
   totalCostUnits: number;
   totalPriceUnits: number;
+  grossPriceUnits: number;
   multiplierHint: number;
   brokerMktValue: number;
+  brokerNetMktValue: number;
   hasBrokerMktValue: boolean;
   brokerPnl: number;
   hasBrokerPnl: boolean;
   brokerMarkPrice: number | undefined;
-}
-
-function getPositionCurrency(
-  positions: TickerRecord["metadata"]["positions"],
-  fallbackCurrency: string,
-): string {
-  return positions.find((position) => position.currency)?.currency || fallbackCurrency;
+  pnlLots: { signedCost: number; priceUnits: number; direction: 1 | -1; brokerMarketValue: number | null; brokerPnl: number | null }[];
 }
 
 function normalizePositionMultiplier(multiplier: number | undefined): number {
-  return typeof multiplier === "number" && Number.isFinite(multiplier) && multiplier > 0
-    ? multiplier
-    : 1;
+  return typeof multiplier === "number" && Number.isFinite(multiplier) && multiplier > 0 ? multiplier : 1;
 }
 
-export function signedPositionDirection(position: {
-  shares: number;
-  side?: "long" | "short";
-}): 1 | -1 {
+export function signedPositionDirection(position: { shares: number; side?: "long" | "short" }): 1 | -1 {
   if (position.side === "short") return -1;
   if (position.side === "long") return 1;
   return position.shares < 0 ? -1 : 1;
 }
 
-/** Quote-path unrealized P&L. Shorts profit when market value falls below cost. */
-export function signedQuoteUnrealizedPnl(
-  absMarketValue: number,
-  cost: number,
-  totalPriceUnits: number,
-): number {
-  return (totalPriceUnits < 0 ? -1 : 1) * (absMarketValue - cost);
-}
-
-function resolvePositionCostMultiplier(
-  position: TickerRecord["metadata"]["positions"][number],
-): number {
+export function resolvePositionCostMultiplier(position: TickerRecord["metadata"]["positions"][number]): number {
   const priceMultiplier = normalizePositionMultiplier(position.multiplier);
   if (priceMultiplier === 1) return 1;
-
-  if (position.marketValue == null || position.unrealizedPnl == null) {
-    return priceMultiplier;
-  }
+  if (position.marketValue == null || position.unrealizedPnl == null
+    || typeof position.avgCost !== "number" || !Number.isFinite(position.avgCost)) return priceMultiplier;
 
   const costWithoutMultiplier = Math.abs(position.shares) * position.avgCost;
   const costWithMultiplier = costWithoutMultiplier * priceMultiplier;
-  const withoutMultiplierError = Math.abs((position.marketValue - costWithoutMultiplier) - position.unrealizedPnl);
-  const withMultiplierError = Math.abs((position.marketValue - costWithMultiplier) - position.unrealizedPnl);
-
+  const direction = signedPositionDirection(position);
+  const marketValue = Math.abs(position.marketValue);
+  const withoutMultiplierError = Math.abs(direction * (marketValue - costWithoutMultiplier) - position.unrealizedPnl);
+  const withMultiplierError = Math.abs(direction * (marketValue - costWithMultiplier) - position.unrealizedPnl);
   // Some broker derivative feeds report avgCost already scaled to the contract.
   return withoutMultiplierError < withMultiplierError ? 1 : priceMultiplier;
 }
@@ -68,75 +60,159 @@ export function getPortfolioPositionMetrics(
   ticker: TickerRecord,
   activeTab: string | undefined,
   fallbackCurrency: string,
+  valuation?: { currency: string; convert: (value: number, currency: string) => number },
+  /** Independent candidate quote: its convention must not come from stored cost/mark. */
+  quote?: Quote | null,
 ): PortfolioPositionMetrics {
-  const tabPositions = activeTab
-    ? ticker.metadata.positions.filter((position) => position.portfolio === activeTab)
-    : ticker.metadata.positions;
-  const positionCurrency = getPositionCurrency(tabPositions, fallbackCurrency);
-  let totalShares = 0;
-  let totalCost = 0;
-  let totalCostUnits = 0;
-  let totalPriceUnits = 0;
-  let multiplierHint = 1;
-  let brokerMktValue = 0;
-  let hasBrokerMktValue = false;
-  let brokerPnl = 0;
-  let hasBrokerPnl = false;
-  for (const position of tabPositions) {
+  const positions = ticker.metadata.positions.filter((position) =>
+    (!activeTab || position.portfolio === activeTab) && position.shares !== 0,
+  );
+  const currencyFor = (position: typeof positions[number]) =>
+    position.priceBasis === "percent-of-par" || ticker.metadata.assetCategory?.trim().toUpperCase() === "BOND"
+      ? position.currency?.trim() || ticker.metadata.currency?.trim() || ""
+      : position.currency || fallbackCurrency;
+  const currencies = new Set(positions.map(currencyFor));
+  const bases = new Set(positions.map(position => resolvePriceBasis(position.priceBasis, ticker.metadata.assetCategory)));
+  const priceBasis = bases.size === 0 ? resolvePriceBasis(undefined, ticker.metadata.assetCategory) : bases.size === 1 ? [...bases][0]! : null;
+  const positionCurrency = valuation?.currency ?? (currencies.size > 1 ? "Mixed" : [...currencies][0] ?? fallbackCurrency);
+  const convert = (value: number, position: typeof positions[number]) => {
+    const currency = currencyFor(position);
+    if (!currency) return Number.NaN;
+    return valuation ? valuation.convert(value, currency) : currencies.size > 1 ? Number.NaN : value;
+  };
+  const metrics: PortfolioPositionMetrics = {
+    positionCurrency, positionCount: positions.length, hasShorts: false,
+    totalShares: 0, totalCost: 0, hasCostBasis: positions.length > 0, priceBasis, signedCost: 0, totalCostUnits: 0,
+    totalPriceUnits: 0, grossPriceUnits: 0, multiplierHint: 1,
+    brokerMktValue: 0, brokerNetMktValue: 0, hasBrokerMktValue: positions.length > 0,
+    brokerPnl: 0, hasBrokerPnl: positions.length > 0,
+    brokerMarkPrice: positions.length === 1 && priceBasis ? positions[0]?.markPrice : undefined,
+    pnlLots: [],
+  };
+  for (const position of positions) {
     const direction = signedPositionDirection(position);
     const magnitude = Math.abs(position.shares);
-    const priceMultiplier = normalizePositionMultiplier(position.multiplier);
-    const costMultiplier = resolvePositionCostMultiplier(position);
-    multiplierHint = Math.max(multiplierHint, priceMultiplier, costMultiplier);
-
-    totalShares += magnitude * direction;
-    totalCost += magnitude * position.avgCost * costMultiplier;
-    totalCostUnits += magnitude * costMultiplier;
-    totalPriceUnits += magnitude * priceMultiplier * direction;
+    const basis = resolvePriceBasis(position.priceBasis, ticker.metadata.assetCategory);
+    const contractMultiplier = normalizePositionMultiplier(position.multiplier);
+    // Nominal face already includes the amount held. Keep the supplied contract
+    // multiplier as metadata; it must not scale percent-of-par money again.
+    const priceMultiplier = basis === "percent-of-par" ? .01 : basis === "per-unit" ? contractMultiplier : Number.NaN;
+    const costMultiplier = basis === "percent-of-par" ? .01 : basis === "per-unit" ? resolvePositionCostMultiplier(position) : Number.NaN;
+    const quoteBasis = quote ? resolvePriceBasis(quote.priceBasis,
+      basis === "percent-of-par" || ticker.metadata.assetCategory?.toUpperCase() === "BOND" ? "BOND" : quote.instrumentType) : basis;
+    const nominalCurrency = resolveCurrencyUnit(currencyFor(position));
+    const quoteCurrency = resolveCurrencyUnit(quote?.currency || "");
+    const compatiblePar = !quote || quoteBasis !== "percent-of-par"
+      || basis === "percent-of-par" && !!nominalCurrency.currency
+        && nominalCurrency.currency === quoteCurrency.currency && nominalCurrency.divisor === quoteCurrency.divisor;
+    const quoteMultiplier = basis === null || quoteBasis === null || !compatiblePar ? Number.NaN
+      : quoteBasis === "percent-of-par" ? .01 : basis === "percent-of-par" ? 1 : contractMultiplier;
+    const hasCost = basis !== null && !!currencyFor(position) && typeof position.avgCost === "number" && Number.isFinite(position.avgCost);
+    const cost = hasCost ? magnitude * position.avgCost! * costMultiplier : Number.NaN;
+    metrics.hasCostBasis &&= hasCost;
+    metrics.hasShorts ||= direction < 0;
+    metrics.multiplierHint = Math.max(metrics.multiplierHint, contractMultiplier);
+    metrics.totalShares += magnitude * direction;
+    metrics.totalCost += convert(cost, position);
+    metrics.signedCost += direction * convert(cost, position);
+    metrics.totalCostUnits += magnitude * costMultiplier;
+    metrics.totalPriceUnits += magnitude * quoteMultiplier * direction;
+    metrics.grossPriceUnits += magnitude * quoteMultiplier;
 
-    if (position.marketValue != null) {
-      brokerMktValue += position.marketValue;
-      hasBrokerMktValue = true;
-    }
-    if (position.unrealizedPnl != null) {
-      brokerPnl += position.unrealizedPnl;
-      hasBrokerPnl = true;
+    // Normalize each lot before summing: broker values may be signed, and a
+    // complete snapshot for one account cannot stand in for another missing lot.
+    const marketValue = Number.isFinite(position.marketValue) ? Math.abs(position.marketValue!)
+      : Number.isFinite(position.markPrice) && Number.isFinite(priceMultiplier) ? magnitude * priceMultiplier * position.markPrice!
+      : Number.isFinite(position.unrealizedPnl) && Number.isFinite(cost) ? cost + direction * position.unrealizedPnl!
+      : null;
+    const pnl = Number.isFinite(position.unrealizedPnl) ? position.unrealizedPnl!
+      : marketValue != null && Number.isFinite(cost) ? direction * (marketValue - cost) : null;
+    if (marketValue == null || !Number.isFinite(marketValue)) metrics.hasBrokerMktValue = false;
+    else {
+      metrics.brokerMktValue += convert(marketValue, position);
+      metrics.brokerNetMktValue += direction * convert(marketValue, position);
     }
+    if (pnl == null || !Number.isFinite(pnl)) metrics.hasBrokerPnl = false;
+    else metrics.brokerPnl += convert(pnl, position);
+    metrics.pnlLots.push({
+      signedCost: direction * convert(cost, position),
+      priceUnits: magnitude * quoteMultiplier * direction,
+      direction,
+      brokerMarketValue: marketValue != null && Number.isFinite(marketValue) ? convert(marketValue, position) : null,
+      brokerPnl: pnl != null && Number.isFinite(pnl) ? convert(pnl, position) : null,
+    });
   }
+  return metrics;
+}
 
-  return {
-    positionCurrency,
-    totalShares,
-    totalCost,
-    totalCostUnits,
-    totalPriceUnits,
-    multiplierHint,
-    brokerMktValue,
-    hasBrokerMktValue,
-    brokerPnl,
-    hasBrokerPnl,
-    brokerMarkPrice: tabPositions.length === 1 ? tabPositions[0]?.markPrice : undefined,
-  };
+/** Only a compatible, finite quote may replace independently usable broker totals. */
+export function getPortfolioQuoteDisplay(metrics: PortfolioPositionMetrics, quote: Quote | null | undefined): ActiveQuoteDisplay | null {
+  const active = getActiveQuoteDisplay(quote);
+  return active && Number.isFinite(active.price)
+    && (metrics.positionCount === 0 || metrics.pnlLots.some(lot => Number.isFinite(lot.priceUnits))) ? active : null;
 }
 
-export function resolveBrokerFallbackMarketValue(metrics: PortfolioPositionMetrics): number | null {
-  if (metrics.hasBrokerMktValue) return metrics.brokerMktValue;
-  if (metrics.brokerMarkPrice != null && metrics.totalPriceUnits !== 0) {
-    return Math.abs(metrics.totalPriceUnits) * metrics.brokerMarkPrice;
-  }
-  if (metrics.hasBrokerPnl) {
-    return metrics.totalCost + metrics.brokerPnl;
+/** Select compatible current prices or independent snapshot totals per lot. */
+export function resolvePortfolioMarketValue(metrics: PortfolioPositionMetrics, currentUnitPrice?: number | null): { gross: number; net: number } | null {
+  if (metrics.positionCount === 0) return null;
+  let gross = 0;
+  let net = 0;
+  for (const lot of metrics.pnlLots) {
+    const current = currentUnitPrice != null && Number.isFinite(currentUnitPrice)
+      ? Math.abs(lot.priceUnits) * currentUnitPrice : Number.NaN;
+    const value = Number.isFinite(current) ? current : lot.brokerMarketValue;
+    if (value === null || !Number.isFinite(value)) return null;
+    gross += value;
+    net += lot.direction * value;
   }
-  return null;
+  return Number.isFinite(gross) && Number.isFinite(net) ? { gross, net } : null;
+}
+
+export function resolveBrokerFallbackMarketValue(metrics: PortfolioPositionMetrics): number | null {
+  return metrics.hasBrokerMktValue && Number.isFinite(metrics.brokerMktValue) ? metrics.brokerMktValue : null;
+}
+
+export function resolveBrokerFallbackPnl(metrics: PortfolioPositionMetrics, _brokerMarketValue?: number | null): number | null {
+  return metrics.hasBrokerPnl && Number.isFinite(metrics.brokerPnl) ? metrics.brokerPnl : null;
 }
 
-export function resolveBrokerFallbackPnl(
+export interface PortfolioPositionPnl {
+  value: number | null;
+  basis: "quote-and-cost" | "broker-snapshot" | "mixed" | "unavailable";
+}
+
+export function portfolioPnlLabel(bases: Iterable<PortfolioPositionPnl["basis"]>): string {
+  const sources = new Set(bases);
+  if (sources.has("mixed") || (sources.has("broker-snapshot") && sources.has("quote-and-cost"))) return "Mixed P&L";
+  return sources.has("broker-snapshot") ? "Broker P&L" : "P&L";
+}
+
+/** A current quote cannot establish missing acquisition cost or refresh a broker P&L snapshot. */
+export function resolvePortfolioPositionPnl(
   metrics: PortfolioPositionMetrics,
-  brokerMarketValue: number | null,
-): number | null {
-  if (metrics.hasBrokerPnl) return metrics.brokerPnl;
-  if (brokerMarketValue != null && metrics.totalCost !== 0) {
-    return brokerMarketValue - metrics.totalCost;
+  currentUnitPrice?: number | null,
+): PortfolioPositionPnl {
+  if (metrics.pnlLots.length === 0) return { value: null, basis: "unavailable" };
+  let total = 0;
+  const bases = new Set<"quote-and-cost" | "broker-snapshot">();
+  for (const lot of metrics.pnlLots) {
+    const currentPnl = typeof currentUnitPrice === "number" && Number.isFinite(currentUnitPrice)
+      ? currentUnitPrice * lot.priceUnits - lot.signedCost : Number.NaN;
+    if (Number.isFinite(currentPnl)) {
+      total += currentPnl;
+      bases.add("quote-and-cost");
+    } else if (lot.brokerPnl !== null && Number.isFinite(lot.brokerPnl)) {
+      total += lot.brokerPnl;
+      bases.add("broker-snapshot");
+    } else return { value: null, basis: "unavailable" };
   }
-  return null;
+  return Number.isFinite(total)
+    ? { value: total, basis: bases.size > 1 ? "mixed" : [...bases][0]! }
+    : { value: null, basis: "unavailable" };
+}
+
+export function portfolioPnlPercent(value: number | null, costBasis: number): number | null {
+  const percent = value !== null && Number.isFinite(value) && Number.isFinite(costBasis) && costBasis !== 0
+    ? value / costBasis * 100 : Number.NaN;
+  return Number.isFinite(percent) ? percent : null;
 }

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

@@ -201,6 +201,24 @@ export function buildPortfolioSummarySegments({
   const accountMetrics = resolvePortfolioAccountMetrics(totals, accountState?.account, convertAccountValue);
   const totalMarketValue = resolvePortfolioMarketValue(totals, accountState?.account, convertAccountValue);
 
+  if (totals.unavailableConversions?.length || (accountState && !Number.isFinite(convertAccountValue(1)))) {
+    candidates.push(createSummarySegment("fx-unavailable", [
+      { text: "FX unavailable", tone: "muted", color: colors.warning },
+    ]));
+  }
+
+  if (totals.unavailableSymbols?.length) {
+    candidates.push(createSummarySegment("prices-unavailable", [
+      { text: "Prices unavailable", tone: "muted", color: colors.warning },
+    ]));
+  }
+
+  if (totals.unavailableCostSymbols?.length) {
+    candidates.push(createSummarySegment("cost-unavailable", [
+      { text: "Cost unavailable", tone: "muted", color: colors.warning },
+    ]));
+  }
+
   if (accountState?.account.netLiquidation != null) {
     candidates.push(createSummarySegment("netliq", [
       { text: "Net Liq", tone: "label" },
@@ -209,10 +227,17 @@ export function buildPortfolioSummarySegments({
   }
 
   candidates.push(createSummarySegment("val", [
-    { text: "Val", tone: "label" },
+    { text: totals.hasShorts ? "Gross" : "Val", tone: "label" },
     { text: formatCompact(totalMarketValue), tone: "value", bold: true },
   ]));
 
+  if (totals.hasShorts && totals.netMktValue != null) {
+    candidates.push(createSummarySegment("net-value", [
+      { text: "Net", tone: "label" },
+      { text: formatCompact(totals.netMktValue), tone: "value", bold: true },
+    ]));
+  }
+
   if (accountState?.account.totalCashValue != null) {
     candidates.push(createSummarySegment("cash", [
       { text: "Cash", tone: "label" },
@@ -226,7 +251,10 @@ export function buildPortfolioSummarySegments({
     { text: `(${formatPercentRaw(accountMetrics.dailyPnlPct)})`, tone: "muted", color: priceColor(accountMetrics.dailyPnlPct) },
   ]));
   candidates.push(createSummarySegment("pnl", [
-    { text: "P&L", tone: "label" },
+    { text: !Number.isFinite(accountState?.account.unrealizedPnl)
+      && totals.unrealizedPnlBasis === "broker-snapshot" ? "Broker P&L"
+      : !Number.isFinite(accountState?.account.unrealizedPnl)
+        && totals.unrealizedPnlBasis === "mixed" ? "Mixed P&L" : "P&L", tone: "label" },
     { text: formatSignedCompact(accountMetrics.unrealizedPnl), tone: "value", color: priceColor(accountMetrics.unrealizedPnl), bold: true },
     { text: `(${formatPercentRaw(accountMetrics.unrealizedPnlPct)})`, tone: "muted", color: priceColor(accountMetrics.unrealizedPnlPct) },
   ]));
@@ -352,7 +380,7 @@ export function buildPortfolioFooterSegments({
   if (!totals.hasPositions && !accountState && !accountStatusText) return [];
   const convertAccountValue = (value: number) => convertCurrency(
     value,
-    accountState?.account.currency || baseCurrency,
+    accountState?.account.currency ?? "",
     baseCurrency,
     exchangeRates,
   );

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

@@ -4,13 +4,21 @@ import { convertCurrency } from "../../../../utils/format";
 import { getActiveQuoteDisplay } from "../../../../market-data/market/status";
 import {
   getPortfolioPositionMetrics,
-  resolveBrokerFallbackMarketValue,
-  resolveBrokerFallbackPnl,
-  signedQuoteUnrealizedPnl,
+  getPortfolioQuoteDisplay,
+  resolvePortfolioMarketValue,
+  resolvePortfolioPositionPnl,
+  portfolioPnlPercent,
+  type PortfolioPositionPnl,
 } from "../position-metrics";
 
 export interface PortfolioSummaryTotals {
   totalMktValue: number;
+  netMktValue?: number;
+  hasShorts?: boolean;
+  unavailableSymbols?: string[];
+  unavailableCostSymbols?: string[];
+  brokerPnlSymbols?: string[];
+  unrealizedPnlBasis?: PortfolioPositionPnl["basis"];
   dailyPnl: number;
   dailyPnlPct: number;
   totalCostBasis: number;
@@ -19,6 +27,8 @@ export interface PortfolioSummaryTotals {
   unrealizedPnlPct: number;
   avgWatchlistChange: number;
   watchlistCount: number;
+  /** Currency pairs preventing the full portfolio from being valued. */
+  unavailableConversions?: string[];
 }
 
 export function calculatePortfolioSummaryTotals(
@@ -30,6 +40,12 @@ export function calculatePortfolioSummaryTotals(
   collectionId: string | null,
 ): PortfolioSummaryTotals {
   let totalMktValue = 0;
+  let netMktValue = 0;
+  let hasShorts = false;
+  const unavailableSymbols = new Set<string>();
+  const unavailableCostSymbols = new Set<string>();
+  const brokerPnlSymbols = new Set<string>();
+  const pnlBases = new Set<PortfolioPositionPnl["basis"]>();
   let totalPrevValue = 0;
   let totalCostBasis = 0;
   let signedDailyPnl = 0;
@@ -37,57 +53,80 @@ export function calculatePortfolioSummaryTotals(
   let hasPositions = false;
   let watchlistChangeSum = 0;
   let watchlistCount = 0;
+  const unavailableConversions = new Set<string>();
+  const toBase = (value: number, currency: string) => {
+    const converted = convertCurrency(value, currency, baseCurrency, exchangeRates);
+    if (Number.isFinite(value) && !Number.isFinite(converted)) unavailableConversions.add(`${currency}/${baseCurrency}`);
+    return converted;
+  };
 
   for (const ticker of tickers) {
     const financials = financialsMap.get(ticker.metadata.ticker);
     const quote = financials?.quote;
-    const activeQuote = getActiveQuoteDisplay(quote);
+    const displayedQuote = getActiveQuoteDisplay(quote);
+    let activeQuote = displayedQuote && Number.isFinite(displayedQuote.price) ? displayedQuote : null;
     const quoteCurrency = quote?.currency || ticker.metadata.currency || "USD";
 
     if (!isPortfolio) {
-      if (quote?.changePercent != null) {
-        watchlistChangeSum += quote.changePercent;
+      if (activeQuote?.changePercent != null) {
+        watchlistChangeSum += activeQuote.changePercent;
         watchlistCount++;
       }
       continue;
     }
 
-    const positionMetrics = getPortfolioPositionMetrics(ticker, collectionId ?? undefined, quoteCurrency);
-    const { positionCurrency, totalPriceUnits, totalCost } = positionMetrics;
-    const brokerFallbackMktValue = resolveBrokerFallbackMarketValue(positionMetrics);
-    const toBaseQuote = (value: number) => convertCurrency(value, quoteCurrency, baseCurrency, exchangeRates);
-    const toBasePosition = (value: number) => convertCurrency(value, positionCurrency, baseCurrency, exchangeRates);
+    const positionMetrics = getPortfolioPositionMetrics(ticker, collectionId ?? undefined, quoteCurrency, {
+      currency: baseCurrency, convert: toBase,
+    }, quote);
+    activeQuote = getPortfolioQuoteDisplay(positionMetrics, quote);
+    const { totalPriceUnits, grossPriceUnits, totalCost } = positionMetrics;
+    if (positionMetrics.positionCount === 0) continue;
+    hasPositions = true;
+    hasShorts ||= positionMetrics.hasShorts;
+    totalCostBasis += totalCost;
+    if (!positionMetrics.hasCostBasis) unavailableCostSymbols.add(ticker.metadata.ticker);
+
+    const toBaseQuote = (value: number) => toBase(value, quoteCurrency);
+    const positionPnl = resolvePortfolioPositionPnl(positionMetrics,
+      activeQuote ? toBaseQuote(activeQuote.price) : null);
+    signedUnrealizedPnl += positionPnl.value ?? Number.NaN;
+    pnlBases.add(positionPnl.basis);
+    if (positionPnl.basis === "broker-snapshot" || positionPnl.basis === "mixed") brokerPnlSymbols.add(ticker.metadata.ticker);
 
-    if (quote && activeQuote && totalPriceUnits !== 0) {
-      hasPositions = true;
-      const marketValue = Math.abs(totalPriceUnits) * activeQuote.price;
-      const previousClose = quote.previousClose || (activeQuote.price - activeQuote.change);
-      const previousValue = Math.abs(totalPriceUnits) * previousClose;
-      const convertedMarket = toBaseQuote(marketValue);
-      const convertedCost = toBasePosition(totalCost);
-      totalMktValue += convertedMarket;
-      totalPrevValue += toBaseQuote(previousValue);
-      totalCostBasis += convertedCost;
-      signedDailyPnl += toBaseQuote(totalPriceUnits * (activeQuote.price - previousClose));
-      signedUnrealizedPnl += signedQuoteUnrealizedPnl(convertedMarket, convertedCost, totalPriceUnits);
-    } else if (brokerFallbackMktValue != null) {
-      hasPositions = true;
-      totalMktValue += toBasePosition(brokerFallbackMktValue);
-      totalCostBasis += toBasePosition(totalCost);
-      totalPrevValue += toBasePosition(brokerFallbackMktValue);
-      const brokerPnl = resolveBrokerFallbackPnl(positionMetrics, brokerFallbackMktValue);
-      if (brokerPnl != null) signedUnrealizedPnl += toBasePosition(brokerPnl);
+    const marketValue = resolvePortfolioMarketValue(positionMetrics, activeQuote ? toBaseQuote(activeQuote.price) : null);
+    if (marketValue) {
+      totalMktValue += marketValue.gross;
+      netMktValue += marketValue.net;
+      if (activeQuote && Number.isFinite(grossPriceUnits)) {
+        const previousClose = activeQuote.change != null ? activeQuote.price - activeQuote.change : Number.NaN;
+        totalPrevValue += toBaseQuote(grossPriceUnits * previousClose);
+        signedDailyPnl += toBaseQuote(totalPriceUnits * (activeQuote.price - previousClose));
+      } else {
+        // A broker mark is not evidence of an unchanged day.
+        signedDailyPnl = Number.NaN;
+        totalPrevValue = Number.NaN;
+      }
+    } else {
+      unavailableSymbols.add(ticker.metadata.ticker);
+      totalMktValue = netMktValue = totalPrevValue = signedDailyPnl = Number.NaN;
     }
   }
 
   const dailyPnl = signedDailyPnl;
   const dailyPnlPct = totalPrevValue !== 0 ? (dailyPnl / totalPrevValue) * 100 : 0;
   const unrealizedPnl = signedUnrealizedPnl;
-  const unrealizedPnlPct = totalCostBasis !== 0 ? (unrealizedPnl / totalCostBasis) * 100 : 0;
+  const unrealizedPnlPct = portfolioPnlPercent(unrealizedPnl, totalCostBasis) ?? Number.NaN;
   const avgWatchlistChange = watchlistCount > 0 ? watchlistChangeSum / watchlistCount : 0;
 
   return {
     totalMktValue,
+    netMktValue,
+    hasShorts,
+    ...(unavailableSymbols.size ? { unavailableSymbols: [...unavailableSymbols].sort() } : {}),
+    ...(unavailableCostSymbols.size ? { unavailableCostSymbols: [...unavailableCostSymbols].sort() } : {}),
+    ...(brokerPnlSymbols.size ? { brokerPnlSymbols: [...brokerPnlSymbols].sort() } : {}),
+    unrealizedPnlBasis: !Number.isFinite(unrealizedPnl) || pnlBases.size === 0 ? "unavailable"
+      : pnlBases.size > 1 ? "mixed" : [...pnlBases][0],
     dailyPnl,
     dailyPnlPct,
     totalCostBasis,
@@ -96,5 +135,6 @@ export function calculatePortfolioSummaryTotals(
     unrealizedPnlPct,
     avgWatchlistChange,
     watchlistCount,
+    ...(unavailableConversions.size > 0 ? { unavailableConversions: [...unavailableConversions].sort() } : {}),
   };
 }