gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/plugin-marketplace/store.ts

@@ -1,3 +1,4 @@
+import type { LoadedExternalPlugin } from "../../loader";
 import type { InstalledPlugin } from "./model";
 
 /**
@@ -13,6 +14,28 @@ import type { InstalledPlugin } from "./model";
 export interface MarketplaceHost {
   listInstalled(): InstalledPlugin[];
   setPluginEnabled(pluginId: string, enabled: boolean): void;
+  /**
+   * Registers a plugin that was loaded after startup, so its panes and
+   * commands exist in this session. Replaces a previous registration of the
+   * same id (an update). Rejects with the setup error when the plugin cannot
+   * be registered, in which case the entry is kept with that error attached.
+   */
+  activate(entry: LoadedExternalPlugin): Promise<void>;
+  /**
+   * Hides the plugin's panes and unregisters it, ahead of removing its files.
+   * The folder identifies an install that never produced an id.
+   */
+  deactivate(pluginId: string, directory?: string): Promise<void>;
+  /** What a registered plugin actually added, for "open what it added" and the detail view. */
+  contributions(pluginId: string): PluginContributions;
+}
+
+export interface PluginContributions {
+  panes: Array<{ id: string; name: string }>;
+  templates: Array<{ id: string; label: string; prefix?: string }>;
+  commands: Array<{ id: string; label: string }>;
+  capabilities: number;
+  broker: boolean;
 }
 
 let host: MarketplaceHost | null = null;
@@ -25,6 +48,15 @@ export function getMarketplaceHost(): MarketplaceHost | null {
   return host;
 }
 
+export interface PluginPin {
+  ref?: string;
+  commit?: string;
+}
+
+export type PluginOperationResult =
+  | { ok: true; directory: string }
+  | { ok: false; error: string };
+
 /**
  * Installing a plugin means running git and bun, which only the Bun-hosted
  * renderers can do — and the desktop view has to ask its Bun process over RPC.
@@ -33,14 +65,32 @@ export function getMarketplaceHost(): MarketplaceHost | null {
  * startup. A renderer that leaves it unset (the browser) gets the install
  * command shown instead of a button.
  */
-export type PluginInstaller = (ref: string) => Promise<{ ok: boolean; error?: string }>;
+export interface PluginManager {
+  install(repo: string, pin?: PluginPin): Promise<PluginOperationResult>;
+  update(directory: string, pin?: PluginPin): Promise<PluginOperationResult>;
+  remove(directory: string): Promise<PluginOperationResult>;
+  /**
+   * Loads the plugin in `directory` into this renderer, fresh, so it can be
+   * activated without a restart. Null when the directory has no plugin entry.
+   */
+  load(directory: string): Promise<LoadedExternalPlugin | null>;
+  /**
+   * Registers the plugin wherever its capabilities and brokers execute when
+   * that is not this renderer. The desktop view renders panes, but forwards
+   * data calls to its Bun process, which keeps its own registry; without this
+   * an installed plugin would draw its pane and fail on the first request.
+   * The terminal is one process and leaves it out.
+   */
+  activate?(directory: string): Promise<{ ok: true } | { ok: false; error: string }>;
+  deactivate?(pluginId: string): Promise<void>;
+}
 
-let installer: PluginInstaller | null = null;
+let manager: PluginManager | null = null;
 
-export function setPluginInstaller(next: PluginInstaller | null): void {
-  installer = next;
+export function setPluginManager(next: PluginManager | null): void {
+  manager = next;
 }
 
-export function getPluginInstaller(): PluginInstaller | null {
-  return installer;
+export function getPluginManager(): PluginManager | null {
+  return manager;
 }

package/src/plugins/builtin/plugin-module.ts

@@ -6,13 +6,16 @@ import type {
 
 type PluginMetadataKey =
   | "id"
+  | "stateId"
   | "name"
   | "version"
   | "description"
   | "toggleable"
   | "order"
   | "targets"
-  | "homepage";
+  | "homepage"
+  | "configSchema"
+  | "isConfigured";
 type PluginMetadata = Pick<GloomPlugin, PluginMetadataKey>;
 
 export type PluginModule = Omit<GloomPlugin, PluginMetadataKey>;
@@ -26,6 +29,7 @@ const HANDLED_MODULE_KEYS = [
   "broker",
   "capabilities",
   "slots",
+  "hosts",
 ] as const satisfies readonly (keyof PluginModule)[];
 
 type MissingModuleKey = Exclude<keyof PluginModule, typeof HANDLED_MODULE_KEYS[number]>;
@@ -55,11 +59,7 @@ function composeSlots(modules: readonly PluginModule[]): GloomPlugin["slots"] {
     slots[slotName] = (props) => createElement(
       Fragment,
       null,
-      ...renderers.map((render, index) => createElement(
-        Fragment,
-        { key: index },
-        render(props),
-      )),
+      ...renderers.map((render, index) => createElement(render, { ...(props as object), key: index })),
     );
   }
 
@@ -80,6 +80,8 @@ export function composeBuiltinPlugin(options: CompositePluginOptions): GloomPlug
   const capabilities = modules.flatMap((module) => module.capabilities ?? []);
   const brokers = modules.flatMap((module) => module.broker ? [module.broker] : []);
   const slots = composeSlots(modules);
+  // The plugin reaches every host any of its modules reaches.
+  const hosts = [...new Set(modules.flatMap((module) => module.hosts ?? []))];
   let startedModules: PluginModule[] = [];
 
   return {
@@ -89,6 +91,7 @@ export function composeBuiltinPlugin(options: CompositePluginOptions): GloomPlug
     ...(paneTemplates.length > 0 ? { paneTemplates } : {}),
     ...(capabilities.length > 0 ? { capabilities } : {}),
     ...(slots ? { slots } : {}),
+    ...(hosts.length > 0 ? { hosts } : {}),
 
     async setup(ctx: GloomPluginContext) {
       startedModules = [];

package/src/plugins/builtin/portfolio-list/account-metrics.test.ts

@@ -19,6 +19,26 @@ function createTotals(overrides: Partial<PortfolioSummaryTotals> = {}): Portfoli
 }
 
 describe("resolvePortfolioAccountMetrics", () => {
+  test("a zero daily-P&L denominator is unavailable rather than a zero return", () => {
+    for (const dailyPnl of [0, 100]) {
+      const account: BrokerAccount = { accountId: "test", name: "Test", dailyPnl, netLiquidation: dailyPnl };
+      const metrics = resolvePortfolioAccountMetrics(createTotals(), account);
+      expect(metrics.dailyPnl).toBe(dailyPnl);
+      expect(metrics.dailyPnlPct).toBeNaN();
+      expect(resolvePortfolioAccountMetrics(createTotals(), { ...account, netLiquidation: dailyPnl + 1000 }).dailyPnlPct).toBe(dailyPnl / 10);
+    }
+  });
+
+  test("broker account profit cannot supply a missing or zero acquisition-cost denominator", () => {
+    const account: BrokerAccount = { accountId: "test", name: "Test", unrealizedPnl: 200 };
+    for (const cost of [Number.NaN, 0]) {
+      const result = resolvePortfolioAccountMetrics(createTotals({ totalCostBasis: cost, unrealizedPnlPct: 0 }), account);
+      expect(result.unrealizedPnl).toBe(200);
+      expect(result.unrealizedPnlPct).toBeNaN();
+    }
+    expect(resolvePortfolioAccountMetrics(createTotals({ totalCostBasis: 1000 }), account).unrealizedPnlPct).toBe(20);
+  });
+
   test("prefers broker account P&L while preserving position fallback percentages", () => {
     const account: BrokerAccount = {
       accountId: "DU12345",

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

@@ -1,5 +1,6 @@
 import type { BrokerAccount } from "../../../types/trading";
 import type { PortfolioSummaryTotals } from "./metrics";
+import { portfolioPnlPercent } from "./position-metrics";
 
 export interface PortfolioAccountMetrics {
   dailyPnl: number;
@@ -14,7 +15,7 @@ function finiteNumber(value: unknown): value is number {
 }
 
 function percentChange(value: number, previousValue: number): number {
-  return previousValue !== 0 ? (value / previousValue) * 100 : 0;
+  return previousValue !== 0 ? (value / previousValue) * 100 : Number.NaN;
 }
 
 export function resolveBrokerPortfolioMarketValue(
@@ -51,9 +52,7 @@ export function resolvePortfolioAccountMetrics(
 
   const brokerUnrealizedPnl = finiteNumber(account?.unrealizedPnl) ? convertAccountValue(account.unrealizedPnl) : null;
   const unrealizedPnl = brokerUnrealizedPnl ?? totals.unrealizedPnl;
-  const unrealizedPnlPct = totals.totalCostBasis !== 0
-    ? percentChange(unrealizedPnl, totals.totalCostBasis)
-    : totals.unrealizedPnlPct;
+  const unrealizedPnlPct = portfolioPnlPercent(unrealizedPnl, totals.totalCostBasis) ?? Number.NaN;
 
   return {
     dailyPnl,

package/src/plugins/builtin/portfolio-list/bond-price-basis.test.ts

@@ -0,0 +1,120 @@
+import { expect, test } from "bun:test";
+import type { Quote, TickerFinancials } from "../../../types/financials";
+import type { TickerPosition, TickerRecord } from "../../../types/ticker";
+import { getPortfolioPositionMetrics, resolvePortfolioPositionPnl, resolveBrokerFallbackMarketValue } from "./position-metrics";
+import { calculatePortfolioSummaryTotals, getColumnValue, getSortValue } from "./metrics";
+import { buildPositionRows } from "../ticker-detail/overview/model";
+import { getPortfolioPositionValue } from "../kelly-sizer/portfolio";
+
+const position = (overrides: Partial<TickerPosition> = {}): TickerPosition => ({ portfolio: "main", broker: "controlled", shares: 1000,
+  currency: "USD", avgCost: 87.742, markPrice: 86.359375, multiplier: 1, priceBasis: "percent-of-par", ...overrides });
+const record = (positions = [position()], assetCategory = "BOND"): TickerRecord => ({ metadata: {
+  ticker: "CONTROLLED", name: "Controlled", exchange: "", currency: "USD", assetCategory,
+  positions, portfolios: ["main"], watchlists: [], tags: [], custom: {},
+} });
+const quote = (overrides: Partial<Quote> = {}): Quote => ({ symbol: "CONTROLLED", price: 87, change: 1, changePercent: 100/86,
+  currency: "USD", instrumentType: "BOND", priceBasis: "percent-of-par", lastUpdated: 1700000000000, ...overrides });
+const financials = (q?: Quote): TickerFinancials => ({ quote: q, annualStatements: [], quarterlyStatements: [], priceHistory: [] });
+const ctx = { activeTab: "main", baseCurrency: "USD", exchangeRates: new Map([["USD",1],["EUR",1.2]]), now: 1700000000000 };
+const col = (id: string) => ({ id, label: id, width: 18, align: "right" as const });
+const totals = (r: TickerRecord, q?: Quote) => calculatePortfolioSummaryTotals([r], new Map([["CONTROLLED",financials(q)]]), "USD", ctx.exchangeRates, true, "main");
+
+test("nominal bond cost and mark apply /100 once, independently of contract multiplier and optional totals", () => {
+  for (const multiplier of [undefined, 1, 100]) {
+    for (const supplied of [{}, { marketValue: 863.59 }, { unrealizedPnl: -13.83 }, { marketValue: 863.59, unrealizedPnl: -13.83 }]) {
+      const r = record([position({ multiplier, ...supplied })]); const m = getPortfolioPositionMetrics(r,"main","USD");
+      expect(m.totalCost).toBeCloseTo(877.42,8);
+      expect(resolveBrokerFallbackMarketValue(m)).toBeCloseTo(supplied.marketValue ?? 863.59375,8);
+      expect(resolvePortfolioPositionPnl(m).value).toBeCloseTo(supplied.unrealizedPnl ?? (supplied.marketValue ?? 863.59375)-877.42,8);
+      expect(r.metadata.positions[0]!.multiplier).toBe(multiplier);
+    }
+  }
+  const r = record([position({ marketValue:863.59, unrealizedPnl:-13.83 })]);
+  expect(totals(r).unrealizedPnlPct).toBeCloseTo(-1.5762120763,8);
+  expect(getColumnValue(col("avg_cost"),r,financials(),ctx).text).toBe("87.74% par");
+  expect(getSortValue(col("cost_basis"),r,financials(),ctx)).toBeCloseTo(877.42,8);
+  expect(getSortValue(col("mkt_value"),r,financials(),ctx)).toBe(863.59);
+  expect(buildPositionRows({ticker:r,quote:undefined,quoteCurrency:"USD",baseCurrency:"USD",toBase:v=>v})[0])
+    .toMatchObject({qty:"1k USD face",avg:"87.7% par",mark:"86.4% par",cost:"$877.42",value:"$863.59",ret:"-1.58%"});
+});
+
+test("bond quote basis belongs to its own observation, and all monetary consumers select compatible snapshots", () => {
+  const r = record([position({marketValue:863.59,unrealizedPnl:-13.83})]);
+  for (const [q,value,pnl] of [
+    [quote(),870,-7.42], [quote({priceBasis:"per-unit",price:.87,change:.01}),870,-7.42],
+    [quote({priceBasis:undefined}),863.59,-13.83], [quote({price:NaN}),863.59,-13.83],
+    [quote({currency:"EUR"}),863.59,-13.83], [quote({price:0,change:0}),0,-877.42],
+  ] as const) {
+    expect(totals(r,q).totalMktValue).toBeCloseTo(value,8);
+    expect(totals(r,q).unrealizedPnl).toBeCloseTo(pnl,8);
+    expect(getSortValue(col("mkt_value"),r,financials(q),ctx)).toBeCloseTo(value,8);
+    expect(getSortValue(col("pnl"),r,financials(q),ctx)).toBeCloseTo(pnl,8);
+    expect(getPortfolioPositionValue({ticker:r,financials:financials(q),portfolioId:"main",baseCurrency:"USD",exchangeRates:ctx.exchangeRates})).toBeCloseTo(value,8);
+    expect(buildPositionRows({ticker:r,quote:q,quoteCurrency:q.currency,baseCurrency:"USD",toBase:(v,c)=>c==="EUR"?v*1.2:v})[0]!.pnlValue).toBeCloseTo(pnl,8);
+  }
+  expect(totals(r,quote()).dailyPnl).toBe(10);
+  expect(totals(r,quote({priceBasis:undefined})).dailyPnl).toBeNaN();
+  expect(getSortValue(col("mark_delta"),r,financials(quote({priceBasis:"per-unit",price:.87})),ctx)).toBeNull();
+});
+
+test("unknown legacy bond units preserve raw totals and quantity but cannot derive money or percentages", () => {
+  const r=record([position({priceBasis:undefined,marketValue:863.59,unrealizedPnl:-13.83})]);
+  expect(totals(r,quote())).toMatchObject({totalMktValue:863.59,totalCostBasis:Number.NaN,unrealizedPnl:-13.83,unrealizedPnlPct:Number.NaN,unavailableCostSymbols:["CONTROLLED"]});
+  for(const id of ["avg_cost","cost_basis","pnl_pct","price"]) {
+    expect(getColumnValue(col(id),r,financials(),ctx).text).toBe("—");
+    expect(getSortValue(col(id),r,financials(),ctx)).toBeNull();
+  }
+  expect(r.metadata.positions[0]).toMatchObject({shares:1000,avgCost:87.742,markPrice:86.359375});
+  const noTotals=record([position({priceBasis:undefined})]);
+  expect(totals(noTotals).totalMktValue).toBeNaN(); expect(totals(noTotals).unrealizedPnl).toBeNaN();
+});
+
+test("signed nominal currency totals convert after pricing; absent cost, zero and mixed lots remain distinct", () => {
+  const short=record([position({currency:"EUR",side:"short",marketValue:-863.59,unrealizedPnl:13.83})]);
+  expect(totals(short).totalCostBasis).toBeCloseTo(877.42*1.2,8);
+  expect(totals(short).netMktValue).toBeCloseTo(-863.59*1.2,8);
+  expect(totals(short).unrealizedPnl).toBeCloseTo(13.83*1.2,8);
+  expect(totals(record([position({avgCost:undefined,unrealizedPnl:-13.83})])).unrealizedPnl).toBe(-13.83);
+  expect(totals(record([position({avgCost:0})]))).toMatchObject({totalCostBasis:0,unrealizedPnlPct:Number.NaN});
+  const mixed=record([position(),position({priceBasis:"per-unit",avgCost:.87742,markPrice:.86359375})]);
+  expect(totals(mixed).totalCostBasis).toBeCloseTo(1754.84,8);
+  expect(getSortValue(col("avg_cost"),mixed,financials(),ctx)).toBeNull();
+  const offset=record([position(),position({side:"short"})]);
+  expect(totals(offset,quote())).toMatchObject({totalMktValue:1740,netMktValue:0,unrealizedPnl:0});
+});
+
+test("explicit per-unit bonds and other asset contracts retain monetary unit prices and derivative cost policy", () => {
+  for(const asset of ["STK","ETF","OPT","FUT"]) {
+    const r=record([position({priceBasis:undefined})],asset);
+    expect(totals(r).totalCostBasis).toBe(87742); expect(totals(r).totalMktValue).toBe(86359.375);
+  }
+  expect(totals(record([position({priceBasis:"per-unit",avgCost:.87742,markPrice:.86359375})])).totalCostBasis).toBeCloseTo(877.42,8);
+  const option=record([position({priceBasis:undefined,shares:2,multiplier:100,avgCost:400,markPrice:5,marketValue:1000,unrealizedPnl:200})],"OPT");
+  expect(totals(option)).toMatchObject({totalCostBasis:800,totalMktValue:1000,unrealizedPnl:200});
+});
+
+test("mixed known and legacy bond lots retain per-lot quote and source valuations without net-exposure division",()=>{
+  const r=record([position({marketValue:863.59,unrealizedPnl:-13.83}),position({shares:500,priceBasis:undefined,marketValue:550,unrealizedPnl:50})]);
+  const result=totals(r,quote());
+  expect(result.totalMktValue).toBeCloseTo(1420,8);
+  expect(result.unrealizedPnl).toBeCloseTo(42.58,8);
+  expect(result.unrealizedPnlBasis).toBe("mixed");
+  expect(result.totalCostBasis).toBeNaN(); expect(result.dailyPnl).toBeNaN();
+  expect(getSortValue(col("mkt_value"),r,financials(quote()),ctx)).toBeCloseTo(1420,8);
+});
+
+test("a percentage quote cannot define nominal quantity for a per-unit holding",()=>{
+  for(const asset of ["STK","BOND"]) {
+    const r=record([position({priceBasis:"per-unit",shares:100,avgCost:2,markPrice:2.5,marketValue:250,unrealizedPnl:50})],asset);
+    expect(totals(r,quote({price:98}))).toMatchObject({totalMktValue:250,unrealizedPnl:50,unrealizedPnlBasis:"broker-snapshot"});
+  }
+});
+
+test("nominal bond currency cannot be supplied by an independent quote",()=>{
+  const r=record([position({currency:"",marketValue:863.59,unrealizedPnl:-13.83})]);r.metadata.currency="";
+  const m=getPortfolioPositionMetrics(r,"main","USD",undefined,quote());
+  expect(m.positionCurrency).toBe("");expect(m.totalCost).toBeNaN();
+  expect(resolveBrokerFallbackMarketValue(m)).toBeNull();
+  expect(totals(r,quote()).totalMktValue).toBeNaN();
+  expect(r.metadata.positions[0]).toMatchObject({marketValue:863.59,unrealizedPnl:-13.83,currency:""});
+});

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

@@ -126,9 +126,9 @@ async function setPositionCommand(
   await withMarketData(ctx, async ({ config, store, dataProvider }) => {
     try {
       const portfolio = requireManualPortfolio(config, portfolioName);
-      const ticker = await resolveTickerForCli(symbol, store, dataProvider);
       const shares = parseFiniteNumber(sharesValue, "Shares");
       const avgCost = parseFiniteNumber(avgCostValue, "Average cost");
+      const ticker = await resolveTickerForCli(symbol, store, dataProvider);
       const currency = resolveManualPositionCurrency(rawCurrency, ticker, portfolio, config.baseCurrency);
       const result = setManualPortfolioPosition(ticker, portfolio.id, {
         shares,

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

@@ -0,0 +1,261 @@
+import { expect, spyOn, test } from "bun:test";
+import { serializeCliResult, type CliResult } from "../../../../cli/result";
+import { DEFAULT_CLI_OPTIONS } from "../../../../cli/options";
+import { createDefaultConfig } from "../../../../types/config";
+import type { CliCommandContext } from "../../../../types/plugin";
+import type { TickerRecord } from "../../../../types/ticker";
+import { createTestDataProvider } from "../../../../test-support/data-provider";
+import { buildTickerReport, ticker as runTickerCommand } from "../../../../cli/commands/ticker";
+import { buildPositionRows } from "../../ticker-detail/overview/model";
+import { calculatePortfolioSummaryTotals, getSortValue } from "../metrics";
+import { showCollection } from "./render";
+import { portfolioCliCommand } from "./portfolio-command";
+
+const ticker: TickerRecord = { metadata: {
+  ticker: "AAPL", name: "Apple", exchange: "NASDAQ", currency: "USD", portfolios: ["main"], watchlists: [], custom: {}, tags: [],
+  positions: [{ portfolio: "main", shares: -10, avgCost: 100, currency: "USD", broker: "manual" }],
+} };
+const quote = { symbol: "AAPL", price: 90, currency: "USD", change: -5, changePercent: -5.26, previousClose: 95, lastUpdated: Date.now() };
+
+test("CLI rejects blank acquisition cost before resolving or writing a ticker, and accepts explicit zero", async () => {
+  const config = createDefaultConfig("/unused-cost-parser");
+  let reads = 0;
+  const saved: TickerRecord[] = [];
+  const ctx = {
+    initMarketData: async () => ({ config, persistence: { close() {} },
+      store: { loadTicker: async () => { reads++; return ticker; }, saveTicker: async (record: TickerRecord) => { saved.push(record); } },
+      dataProvider: createTestDataProvider(),
+    }),
+    fail: (message: string) => { throw new Error(message); },
+  } as unknown as CliCommandContext;
+  for (const cost of ["", "  ", "NaN"]) {
+    await expect(portfolioCliCommand.execute(["position", "set", "main", "AAPL", "10", cost], ctx)).rejects.toThrow("Average cost must be a valid number");
+    expect(saved).toEqual([]);
+    expect(reads).toBe(0);
+  }
+  const logger = spyOn(console, "log").mockImplementation(() => {});
+  try { await portfolioCliCommand.execute(["position", "set", "main", "AAPL", "10", "0"], ctx); }
+  finally { logger.mockRestore(); }
+  expect(saved[0]?.metadata.positions[0]?.avgCost).toBe(0);
+});
+
+test("ticker and collection CLI reconcile short P&L and withhold totals for a missing holding", async () => {
+  const config = createDefaultConfig("/unused-test-data");
+  const report = await buildTickerReport({ symbol: "AAPL", tickerFile: ticker, financials: { quote, annualStatements: [], quarterlyStatements: [], priceHistory: [] }, config, toBase: async value => value });
+  expect(report).toMatch(/P&L[^\n]*\+\$100/);
+  expect(report).toMatch(/Position[^\n]*-10 shares/);
+  expect(report).toMatch(/Cost Basis[^\n]*-\$1,000/);
+  expect(report).toMatch(/Market Value[^\n]*-\$900/);
+
+  const missing: TickerRecord = { metadata: { ...ticker.metadata, ticker: "MISSING" } };
+  const output: string[] = [];
+  const logger = spyOn(console, "log").mockImplementation((...args) => { output.push(args.join(" ")); });
+  try {
+    await showCollection("main", {
+      initMarketData: async () => ({ config, persistence: { close() {} }, store: { loadAllTickers: async () => [ticker, missing] },
+        dataProvider: createTestDataProvider({ getQuote: async symbol => { if (symbol === "MISSING") throw new Error("No quote"); return quote; } }),
+      }),
+      fail: (message: string) => { throw new Error(message); },
+    } as unknown as CliCommandContext);
+  } finally { logger.mockRestore(); }
+  const result = output.join("\n");
+  expect(result).toMatch(/Total P&L[^\n]*—/);
+  expect(result).toContain("P&L unavailable for MISSING");
+  expect(result).toContain("+$100");
+});
+
+test("ticker, portfolio and overview select the same current or broker P&L across extended and unusable quotes", async () => {
+  const config = createDefaultConfig("/unused-pnl-selection");
+  for (const avgCost of [100, undefined]) {
+    const record = { metadata: { ...ticker.metadata, positions: [{ portfolio: "main", broker: "demo", shares: 10,
+      avgCost, currency: "EUR", marketValue: 1150, unrealizedPnl: 75, markPrice: 115 }] } };
+    for (const currentQuote of [
+      { ...quote, price: 120, currency: "USD", marketState: "POST", postMarketPrice: 130 },
+      { ...quote, price: Number.NaN, currency: "USD" },
+    ]) {
+      const financials = { quote: currentQuote, annualStatements: [], quarterlyStatements: [], priceHistory: [] };
+      const toBase = (value: number, currency: string) => currency === "EUR" ? value * 1.2 : value;
+      const expected = avgCost === 100 && Number.isFinite(currentQuote.price) ? 100 : 90;
+      const expectedBasis = expected === 100 ? "quote-and-cost" : "broker-snapshot";
+      const report = await buildTickerReport({ symbol: "AAPL", tickerFile: record, financials, config, toBase: async (value, currency) => toBase(value, currency) });
+      expect(report).toMatch(/Broker Mark[^\n]*115/);
+      expect(report).toMatch(new RegExp(`${expectedBasis === "broker-snapshot" ? "Broker P&L" : "P&L"}[^\\n]*\\+\\$${expected}`));
+      const overview = buildPositionRows({ ticker: record, quote: currentQuote, quoteCurrency: "USD", baseCurrency: "USD", toBase })[0]!;
+      expect(overview).toMatchObject({ pnlValue: expected, pnlBasis: expectedBasis });
+      const context = { activeTab: "main", baseCurrency: "USD", exchangeRates: new Map([["EUR", 1.2]]), now: Date.now() };
+      expect(getSortValue({ id: "pnl", label: "P&L", width: 10, align: "right" }, record, financials, context)).toBe(expected);
+      expect(calculatePortfolioSummaryTotals([record], new Map([["AAPL", financials]]), "USD", context.exchangeRates, true, "main")).toMatchObject({
+        unrealizedPnl: expected, unrealizedPnlBasis: expectedBasis,
+      });
+    }
+  }
+});
+
+test("actual ticker command preserves stored positions and structured research when the returned quote is absent", async () => {
+  const config = createDefaultConfig("/unused-no-quote-report");
+  const record = { metadata: { ...ticker.metadata, positions: [{ portfolio: "main", broker: "demo", shares: 10,
+    currency: "USD", marketValue: 1200, unrealizedPnl: 150, markPrice: 120 }] } };
+  const financials = { annualStatements: [], quarterlyStatements: [], priceHistory: [], fundamentals: { eps: 5 } };
+  let closes = 0;
+  const dependencies = {
+    initMarketData: async () => ({ config, dataDir: "/unused-no-quote-report", persistence: { close() { closes++; } },
+      store: { loadTicker: async () => record }, dataProvider: { ...createTestDataProvider({ getTickerFinancials: async () => financials }), getNews: async () => [] },
+    }) as any,
+    fail: (message: string): never => { throw new Error(message); },
+  };
+  const output: string[] = [];
+  const logger = spyOn(console, "log").mockImplementation((...args) => { output.push(args.join(" ")); });
+  try { await runTickerCommand("AAPL", dependencies); }
+  finally { logger.mockRestore(); }
+  expect(output.join("\n")).toContain("Quote unavailable.");
+  expect(output.join("\n")).toMatch(/Position[^\n]*10 shares @ —/);
+  expect(output.join("\n")).toMatch(/Cost Basis[^\n]*—/);
+  expect(output.join("\n")).toMatch(/Market Value[^\n]*\$1,200/);
+  expect(output.join("\n")).toMatch(/Broker P&L[^\n]*\+\$150/);
+  let result: CliResult | undefined;
+  await runTickerCommand("AAPL", { ...dependencies, printResult: value => { result = value; } });
+  const json = JSON.parse(serializeCliResult(result!, { ...DEFAULT_CLI_OPTIONS, format: "json" }));
+  expect(json.data.quote).toBeNull();
+  expect(json.data.fundamentals).toEqual({ eps: 5 });
+  expect(json.data.ticker.positions[0].avgCost).toBeUndefined();
+  expect(json.data.ticker.positions[0].unrealizedPnl).toBe(150);
+  expect(closes).toBe(2);
+});
+
+test("no-quote ticker command does not assign display currency to untyped broker values", async () => {
+  const config = createDefaultConfig("/unused-no-source-currency");
+  const record: TickerRecord = { metadata: { ...ticker.metadata, currency: "", positions: [{ portfolio: "main", broker: "demo", shares: 10,
+    marketValue: 1200, unrealizedPnl: 150, markPrice: 120 }] } };
+  const financials = { annualStatements: [], quarterlyStatements: [], priceHistory: [] };
+  let conversions = 0;
+  const dependencies = {
+    initMarketData: async () => ({ config, dataDir: "/unused-no-source-currency", persistence: { close() {} },
+      store: { loadTicker: async () => record }, dataProvider: { ...createTestDataProvider({
+        getTickerFinancials: async () => financials,
+        getExchangeRate: async (currency) => { conversions++; return currency === "EUR" ? 1.2 : 1; },
+      }), getNews: async () => [] },
+    }) as any,
+    fail: (message: string): never => { throw new Error(message); },
+  };
+  const output: string[] = [];
+  const logger = spyOn(console, "log").mockImplementation((...args) => { output.push(args.join(" ")); });
+  try { await runTickerCommand("AAPL", dependencies); }
+  finally { logger.mockRestore(); }
+  expect(output.join("\n")).toContain("Currency unavailable.");
+  expect(output.join("\n")).toMatch(/Position[^\n]*10 shares @ —/);
+  for (const label of ["Market Value", "P&L", "Broker Mark"]) expect(output.join("\n")).toMatch(new RegExp(`${label}[^\\n]*—`));
+  expect(conversions).toBe(0);
+  let result: CliResult | undefined;
+  await runTickerCommand("AAPL", { ...dependencies, printResult: value => { result = value; } });
+  const rawPosition = JSON.parse(serializeCliResult(result!, { ...DEFAULT_CLI_OPTIONS, format: "json" })).data.ticker.positions[0];
+  expect(rawPosition).toMatchObject({ shares: 10, marketValue: 1200, unrealizedPnl: 150, markPrice: 120 });
+  expect(rawPosition.currency).toBeUndefined();
+  for (const sourceCurrency of ["position", "metadata"] as const) {
+    const declared: TickerRecord = { metadata: { ...record.metadata, currency: sourceCurrency === "metadata" ? "EUR" : "",
+      positions: [{ ...record.metadata.positions[0]!, currency: sourceCurrency === "position" ? "EUR" : undefined }] } };
+    const report = await buildTickerReport({ symbol: "AAPL", tickerFile: declared, financials, config,
+      toBase: async (value, currency) => currency === "EUR" ? value * 1.2 : Number.NaN });
+    expect(report).toMatch(/Market Value[^\n]*\$1,440/);
+    expect(report).toMatch(/Broker P&L[^\n]*\+\$180/);
+    expect(report).toMatch(/Broker Mark[^\n]*€120/);
+    expect(report).not.toContain("Currency unavailable");
+  }
+});
+
+test("portfolio JSON and CSV exports preserve signed positions, currencies and unknown totals", async () => {
+  const config = createDefaultConfig("/unused-test-data");
+  const missing: TickerRecord = { metadata: { ...ticker.metadata, ticker: "MISSING" } };
+  let result: CliResult | undefined;
+  const output: string[] = [];
+  const logger = spyOn(console, "log").mockImplementation((...args) => { output.push(args.join(" ")); });
+  try {
+    await showCollection("main", {
+      cliOptions: { ...DEFAULT_CLI_OPTIONS, format: "json" },
+      printResult: (value: CliResult) => { result = value; },
+      initMarketData: async () => ({ config, persistence: { close() {} }, store: { loadAllTickers: async () => [ticker, missing] },
+        dataProvider: createTestDataProvider({ getQuote: async symbol => { if (symbol === "MISSING") throw new Error("No quote"); return quote; } }),
+      }),
+      fail: (message: string) => { throw new Error(message); },
+    } as unknown as CliCommandContext);
+  } finally { logger.mockRestore(); }
+  expect(output).toEqual([]);
+  const json = JSON.parse(serializeCliResult(result!, { ...DEFAULT_CLI_OPTIONS, format: "json" }));
+  expect(json.data[0]).toMatchObject({ symbol: "AAPL", shares: -10, costBasis: -1000, marketValue: -900, unrealizedPnl: 100, positionCurrency: "USD", baseCurrency: "USD" });
+  expect(json.data[1]).toMatchObject({ symbol: "MISSING", marketValue: null, unrealizedPnl: null });
+  expect(json.metadata).toMatchObject({ totalUnrealizedPnl: null, complete: false, unavailableSymbols: ["MISSING"],
+    accountingBasis: expect.any(String), manualAccounting: expect.any(String) });
+  const csv = serializeCliResult(result!, { ...DEFAULT_CLI_OPTIONS, format: "csv" });
+  expect(csv).toContain("unrealizedPnl,baseCurrency");
+  expect(csv).toContain("-1000,-900,100,USD");
+});
+
+test("portfolio exports retain missing cost and broker P&L basis without borrowing the live quote timestamp", async () => {
+  const config = createDefaultConfig("/unused-test-data");
+  const unknown: TickerRecord = { metadata: { ...ticker.metadata, positions: [
+    { portfolio: "main", broker: "demo", shares: 10, currency: "USD", unrealizedPnl: 200 },
+  ] } };
+  let result: CliResult | undefined;
+  const live = { ...quote, price: 120 };
+  const exportRecord = async (record: TickerRecord, hasQuote: boolean) => {
+    await showCollection("main", {
+      cliOptions: { ...DEFAULT_CLI_OPTIONS, format: "json" },
+      printResult: (value: CliResult) => { result = value; },
+      initMarketData: async () => ({ config, persistence: { close() {} }, store: { loadAllTickers: async () => [record] },
+        dataProvider: createTestDataProvider({ getQuote: async () => { if (!hasQuote) throw new Error("No quote"); return live; } }),
+      }),
+      fail: (message: string) => { throw new Error(message); },
+    } as unknown as CliCommandContext);
+    return JSON.parse(serializeCliResult(result!, { ...DEFAULT_CLI_OPTIONS, format: "json" }));
+  };
+  const exported = await exportRecord(unknown, true);
+  expect(exported.data[0]).toMatchObject({ avgCost: null, costBasis: null, marketValue: 1200, unrealizedPnl: 200,
+    pnlBasis: "broker-snapshot", brokerUnrealizedPnl: 200, brokerPnlAsOf: null, quoteAsOf: live.lastUpdated });
+  expect(exported.metadata).toMatchObject({ complete: false, totalUnrealizedPnl: 200, unavailableCostSymbols: ["AAPL"], brokerPnlSymbols: ["AAPL"] });
+  const csv = serializeCliResult(result!, { ...DEFAULT_CLI_OPTIONS, format: "csv" });
+  expect(csv).toContain("pnlBasis,brokerUnrealizedPnl");
+  expect(csv).toContain("broker-snapshot,200,USD,");
+  const noMark = await exportRecord(unknown, false);
+  expect(noMark.data[0]).toMatchObject({ marketValue: null, unrealizedPnl: 200, pnlBasis: "broker-snapshot" });
+  expect(noMark.metadata.complete).toBe(false);
+  const report = await buildTickerReport({ symbol: "AAPL", tickerFile: unknown, financials: { quote: live, annualStatements: [], quarterlyStatements: [], priceHistory: [] }, config, toBase: async value => value });
+  expect(report).toMatch(/Cost Basis[^\n]*—/);
+  expect(report).toMatch(/Broker P&L[^\n]*\+\$200/);
+  const restored = { metadata: { ...unknown.metadata, positions: [{ ...unknown.metadata.positions[0]!, avgCost: 100 }] } };
+  expect((await exportRecord(restored, true)).data[0]).toMatchObject({ costBasis: 1000, unrealizedPnl: 200, pnlBasis: "quote-and-cost" });
+  expect((await exportRecord(restored, true)).metadata.complete).toBe(true);
+});
+
+test("portfolio CLI quote context follows the selected contract and unresolved identity retains only its own broker mark", async () => {
+  const config = createDefaultConfig("/unused-portfolio-identity");
+  config.portfolios = [{ id: "a", name: "A", currency: "USD" }, { id: "b", name: "B", currency: "USD" }];
+  const record: TickerRecord = { metadata: { ...ticker.metadata, ticker: "ACME", portfolios: ["a", "b"], positions: [
+    { portfolio: "a", shares: 10, avgCost: 80, markPrice: 100, currency: "USD", broker: "ibkr", brokerInstanceId: "feed-a", brokerContractId: 101 },
+    { portfolio: "b", shares: 10, avgCost: 160, markPrice: 200, currency: "USD", broker: "ibkr", brokerInstanceId: "feed-b", brokerContractId: 202 },
+  ], broker_contracts: [
+    { brokerId: "ibkr", brokerInstanceId: "feed-a", conId: 101, symbol: "ACME", currency: "USD", secType: "STK" },
+    { brokerId: "ibkr", brokerInstanceId: "feed-b", conId: 202, symbol: "ACME", currency: "USD", secType: "STK" },
+  ] } };
+  const calls: unknown[] = [];
+  const provider = createTestDataProvider({ getQuote: async (_symbol, _exchange, context) => {
+    calls.push(context);
+    return { ...quote, symbol: "ACME", price: context?.instrument?.conId === 202 ? 200 : 100 };
+  } });
+  let result: { data: any[]; metadata: any };
+  const ctx = { cliOptions: { ...DEFAULT_CLI_OPTIONS, format: "json" }, printResult: (value: typeof result) => { result = value; },
+    initMarketData: async () => ({ config, persistence: { close() {} }, store: { loadAllTickers: async () => [record] }, dataProvider: provider }),
+  } as unknown as CliCommandContext;
+  for (const id of ["a", "b"]) {
+    await showCollection(id, ctx);
+    expect(calls.at(-1)).toMatchObject({ brokerId: "ibkr", brokerInstanceId: `feed-${id}`, instrument: { conId: id === "a" ? 101 : 202 } });
+    expect(result!.data[0]).toMatchObject({ quotePrice: id === "a" ? 100 : 200, marketValue: id === "a" ? 1000 : 2000, unrealizedPnl: id === "a" ? 200 : 400 });
+  }
+  record.metadata.broker_contracts!.pop();
+  await showCollection("b", ctx);
+  expect(calls).toHaveLength(2);
+  expect(result!.data[0]).toMatchObject({ quotePrice: null, marketValue: 2000, unrealizedPnl: 400, pnlBasis: "broker-snapshot" });
+  expect(result!.metadata.complete).toBe(true);
+  const output: string[] = [], logger = spyOn(console, "log").mockImplementation((...args) => { output.push(args.join(" ")); });
+  try { await showCollection("b", { ...ctx, cliOptions: DEFAULT_CLI_OPTIONS }); } finally { logger.mockRestore(); }
+  expect(output.join("\n")).toContain("+$400");
+  expect(calls).toHaveLength(2);
+});