gloomberb 0.9.7 → 0.9.8

package/src/market-data/hooks.tsx

@@ -2,7 +2,7 @@ import { useCallback, useEffect, useMemo, useRef, useSyncExternalStore } from "r
 import type { SecFilingDocument, SecFilingItem } from "../types/data-provider";
 import type { OptionsChain, PricePoint, Quote, TickerFinancials } from "../types/financials";
 import type { TickerRecord } from "../types/ticker";
-import type { ChartRequest, InstrumentRef, OptionsRequest, SecFilingsRequest } from "./request-types";
+import type { ChartRequest, InstrumentRef, OptionsRequest, SecFilingsRequest, TickerInstrumentOptions } from "./request-types";
 import { instrumentFromTicker } from "./request-types";
 import { useAppActive } from "../state/app/activity";
 import {
@@ -74,17 +74,17 @@ function stableCurrencyList(currencies: Array<string | null | undefined>): strin
   )].sort((left, right) => left.localeCompare(right));
 }
 
-function buildTickerFinancialsMapKey(tickers: TickerRecord[]): string {
+function buildTickerFinancialsMapKey(tickers: TickerRecord[], options: TickerInstrumentOptions = {}): string {
   return tickers.map((ticker) => {
-    const instrument = ticker.metadata.broker_contracts?.[0];
+    const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, options);
     return [
       ticker.metadata.ticker,
       ticker.metadata.exchange ?? "",
       instrument?.brokerId ?? "",
       instrument?.brokerInstanceId ?? "",
-      instrument?.conId ?? "",
-      instrument?.localSymbol ?? "",
-      instrument?.symbol ?? "",
+      instrument?.instrument?.conId ?? "",
+      instrument?.instrument?.localSymbol ?? "",
+      instrument?.instrument?.symbol ?? "",
     ].join("|");
   }).join("::");
 }
@@ -122,10 +122,10 @@ export function useTickerFinancials(symbol: string | null | undefined, ticker: T
   return financials;
 }
 
-function buildTickerFinancialsKeys(tickers: TickerRecord[]): string[] {
+function buildTickerFinancialsKeys(tickers: TickerRecord[], options: TickerInstrumentOptions = {}): string[] {
   const keys: string[] = [];
   for (const ticker of tickers) {
-    const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
+    const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, options);
     if (!instrument) continue;
     keys.push(
       buildSnapshotKey(instrument),
@@ -136,17 +136,21 @@ function buildTickerFinancialsKeys(tickers: TickerRecord[]): string[] {
   return keys;
 }
 
-export function useTickerFinancialsMap(tickers: TickerRecord[]): Map<string, TickerFinancials> {
+export function useTickerFinancialsMap(
+  tickers: TickerRecord[],
+  options: TickerInstrumentOptions = {},
+): Map<string, TickerFinancials> {
   const coordinator = getSharedMarketDataCoordinator();
-  const tickerKey = buildTickerFinancialsMapKey(tickers);
-  const subscriptionKeys = useMemo(() => buildTickerFinancialsKeys(tickers), [tickerKey]);
+  const optionsKey = options.portfolioId ?? "";
+  const tickerKey = buildTickerFinancialsMapKey(tickers, options);
+  const subscriptionKeys = useMemo(() => buildTickerFinancialsKeys(tickers, options), [optionsKey, tickerKey]);
   const keysVersion = useCoordinatorKeysVersion(subscriptionKeys);
 
   return useMemo(() => {
     if (!coordinator) return new Map<string, TickerFinancials>();
     const result = new Map<string, TickerFinancials>();
     for (const ticker of tickers) {
-      const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker);
+      const instrument = instrumentFromTicker(ticker, ticker.metadata.ticker, options);
       if (!instrument) continue;
       const financials = coordinator.getTickerFinancialsSync(instrument);
       if (financials) {
@@ -154,7 +158,7 @@ export function useTickerFinancialsMap(tickers: TickerRecord[]): Map<string, Tic
       }
     }
     return result;
-  }, [coordinator, keysVersion, tickerKey, subscriptionKeys]);
+  }, [coordinator, keysVersion, optionsKey, tickerKey, subscriptionKeys]);
 }
 
 export function useQuoteEntry(symbol: string | null | undefined, ticker: TickerRecord | null | undefined): QueryEntry<Quote> | null {

package/src/market-data/market/freshness.ts

@@ -5,7 +5,33 @@ const US_EXTENDED_HOURS_EXCHANGES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "
 const ALWAYS_OPEN_EXCHANGES = new Set(["CCC"]);
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
 const OVERNIGHT_CLOSE_MAX_AGE_MS = 20 * 60 * 60 * 1000;
+const REGULAR_OPEN_MINUTES: Record<string, number> = {
+  NASDAQ: 9 * 60 + 30,
+  NYSE: 9 * 60 + 30,
+  ARCA: 9 * 60 + 30,
+  AMEX: 9 * 60 + 30,
+  BATS: 9 * 60 + 30,
+  TSX: 9 * 60 + 30,
+  TSXV: 9 * 60 + 30,
+  CSE: 9 * 60 + 30,
+  FWB2: 8 * 60,
+  XETRA: 8 * 60,
+  LSE: 8 * 60,
+  EPA: 9 * 60,
+  AMS: 9 * 60,
+  BRU: 9 * 60,
+  LIS: 8 * 60,
+  BIT: 9 * 60,
+  SFB: 9 * 60,
+  HEL: 10 * 60,
+  CPH: 9 * 60,
+  JPX: 9 * 60,
+  HKEX: 9 * 60 + 30,
+  TWSE: 9 * 60,
+  NSE: 9 * 60 + 15,
+};
 const exchangeLocalDateFormatters = new Map<string, Intl.DateTimeFormat>();
+const exchangeLocalTimeFormatters = new Map<string, Intl.DateTimeFormat>();
 const usSessionFormatter = new Intl.DateTimeFormat("en-US", {
   timeZone: "America/New_York",
   weekday: "short",
@@ -34,6 +60,20 @@ function getExchangeLocalDateFormatter(timeZone: string): Intl.DateTimeFormat {
   return formatter;
 }
 
+function getExchangeLocalTimeFormatter(timeZone: string): Intl.DateTimeFormat {
+  let formatter = exchangeLocalTimeFormatters.get(timeZone);
+  if (!formatter) {
+    formatter = new Intl.DateTimeFormat("en-US", {
+      timeZone,
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23",
+    });
+    exchangeLocalTimeFormatters.set(timeZone, formatter);
+  }
+  return formatter;
+}
+
 function exchangeLocalDate(exchange: string, timestampMs: number): string | null {
   const timeZone = EXCHANGE_TIME_ZONES[canonicalExchange(exchange)];
   if (!timeZone) return null;
@@ -46,6 +86,23 @@ function exchangeLocalDate(exchange: string, timestampMs: number): string | null
   return `${year}-${month}-${day}`;
 }
 
+function exchangeLocalMinuteOfDay(exchange: string, timestampMs: number): number | null {
+  const timeZone = EXCHANGE_TIME_ZONES[canonicalExchange(exchange)];
+  if (!timeZone) return null;
+
+  const parts = getExchangeLocalTimeFormatter(timeZone).formatToParts(new Date(timestampMs));
+  const hour = Number(parts.find((part) => part.type === "hour")?.value);
+  const minute = Number(parts.find((part) => part.type === "minute")?.value);
+  return Number.isFinite(hour) && Number.isFinite(minute) ? hour * 60 + minute : null;
+}
+
+function isBeforeKnownRegularOpen(exchange: string, timestampMs: number): boolean {
+  const canonical = canonicalExchange(exchange);
+  const openMinute = REGULAR_OPEN_MINUTES[canonical];
+  const localMinute = exchangeLocalMinuteOfDay(canonical, timestampMs);
+  return openMinute != null && localMinute != null && localMinute < openMinute;
+}
+
 function isoLocalDateToUtcDay(date: string): number | null {
   const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
   if (!match) return null;
@@ -122,7 +179,7 @@ function isTimestampStaleForExchangeSessionUnsafe(
   if (!timestampDate || !currentDate || timestampDate === currentDate) return false;
 
   if (ALWAYS_OPEN_EXCHANGES.has(canonical)) return true;
-  if (marketState === "REGULAR") return true;
+  if (marketState === "REGULAR" && !isBeforeKnownRegularOpen(canonical, now)) return true;
 
   if (isUsExtendedHoursExchange(canonical)) {
     const session = usSessionState(now);

package/src/market-data/quotes/freshness.test.ts

@@ -132,7 +132,55 @@ describe("quote freshness", () => {
     ).toBe(false);
   });
 
-  test("treats prior-date regular-session quotes as stale immediately", () => {
+  test("allows prior-day regular-session quotes before the local exchange reopens", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "NEO.TO",
+          currency: "CAD",
+          lastUpdated: Date.parse("2026-07-06T20:00:00Z"),
+          listingExchangeName: "TOR",
+          exchangeName: "TOR",
+          marketState: "REGULAR",
+        }),
+        Date.parse("2026-07-07T12:10:00Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("allows non-US premarket labels without active-session prices", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "NEO.TO",
+          currency: "CAD",
+          lastUpdated: Date.parse("2026-07-07T12:10:00Z"),
+          listingExchangeName: "TOR",
+          exchangeName: "TOR",
+          marketState: "PRE",
+        }),
+        Date.parse("2026-07-07T12:10:30Z"),
+      ),
+    ).toBe(false);
+  });
+
+  test("rejects US premarket labels without active-session prices", () => {
+    expect(
+      isQuoteStaleForCurrentSession(
+        quote({
+          symbol: "ALAB",
+          currency: "USD",
+          lastUpdated: Date.parse("2026-07-07T12:10:00Z"),
+          listingExchangeName: "NASDAQ",
+          exchangeName: "NASDAQ",
+          marketState: "PRE",
+        }),
+        Date.parse("2026-07-07T12:10:30Z"),
+      ),
+    ).toBe(true);
+  });
+
+  test("treats prior-date regular-session quotes as stale after the local exchange reopens", () => {
     expect(
       isQuoteStaleForCurrentSession(
         quote({

package/src/market-data/quotes/freshness.ts

@@ -1,7 +1,15 @@
 import type { Quote } from "../../types/financials";
+import { canonicalExchange } from "../../utils/exchanges";
 import { isTimestampStaleForExchangeSession } from "../market/freshness";
 
+const EXTENDED_HOURS_EXCHANGES = new Set(["NASDAQ", "NYSE", "AMEX", "ARCA", "BATS"]);
+
+function isExtendedHoursExchange(quote: Quote): boolean {
+  return EXTENDED_HOURS_EXCHANGES.has(canonicalExchange(quote.listingExchangeName || quote.exchangeName));
+}
+
 function isQuoteMissingActiveSessionPrice(quote: Quote): boolean {
+  if (!isExtendedHoursExchange(quote)) return false;
   if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice == null) {
     return true;
   }

package/src/market-data/quotes/resolution.test.ts

@@ -68,6 +68,191 @@ describe("quote-resolution", () => {
     expect(quote?.provenance?.session?.providerId).toBe("yahoo");
   });
 
+  test("uses provider previous close with the live broker price for daily change", () => {
+    const now = Date.parse("2026-07-06T14:05:00Z");
+    const contributions: QuoteContributionMap = {
+      ibkr: {
+        symbol: "VICR",
+        providerId: "ibkr",
+        dataSource: "live",
+        price: 299.8,
+        currency: "USD",
+        change: -80.3,
+        changePercent: -21.12,
+        previousClose: 380.1,
+        lastUpdated: Date.parse("2026-07-06T14:04:58Z"),
+        receivedAt: Date.parse("2026-07-06T14:04:59Z"),
+        listingExchangeName: "NASDAQ",
+        routingExchangeName: "SMART",
+        sessionConfidence: "unknown",
+      },
+      yahoo: {
+        symbol: "VICR",
+        providerId: "yahoo",
+        dataSource: "delayed",
+        price: 299.74,
+        currency: "USD",
+        change: 16.79,
+        changePercent: 5.93,
+        previousClose: 282.95,
+        lastUpdated: Date.parse("2026-07-06T14:04:00Z"),
+        listingExchangeName: "NMS",
+        marketState: "REGULAR",
+        sessionConfidence: "derived",
+      },
+    };
+
+    const quote = resolveCanonicalQuote(contributions, now).quote;
+
+    expect(quote?.providerId).toBe("ibkr");
+    expect(quote?.price).toBe(299.8);
+    expect(quote?.previousClose).toBe(282.95);
+    expect(quote?.change).toBeCloseTo(16.85, 10);
+    expect(quote?.changePercent).toBeCloseTo((16.85 / 282.95) * 100, 10);
+    expect(quote?.provenance?.price?.providerId).toBe("ibkr");
+    expect(quote?.provenance?.fields?.previousClose?.providerId).toBe("yahoo");
+  });
+
+  test("prefers fresher/provider-ranked non-live price candidates", () => {
+    const now = Date.parse("2026-07-07T11:25:00Z");
+    const cases: Array<{
+      contributions: QuoteContributionMap;
+      expectedPrice: number;
+      expectedProvider: string;
+      expectedChangePercent?: number;
+      expectedRoute?: string;
+    }> = [
+      {
+        contributions: {
+          ibkr: {
+            symbol: "LPK",
+            providerId: "ibkr",
+            dataSource: "delayed",
+            price: 17.75,
+            currency: "EUR",
+            change: -1.85,
+            changePercent: -9.44,
+            previousClose: 19.6,
+            lastUpdated: Date.parse("2026-07-07T11:02:00Z"),
+            receivedAt: Date.parse("2026-07-07T11:02:01Z"),
+            listingExchangeName: "IBIS",
+            routingExchangeName: "SMART",
+            sessionConfidence: "unknown",
+          },
+          yahoo: {
+            symbol: "LPK.DE",
+            providerId: "yahoo",
+            dataSource: "delayed",
+            price: 17.85,
+            currency: "EUR",
+            change: -1.75,
+            changePercent: -8.93,
+            previousClose: 19.6,
+            lastUpdated: Date.parse("2026-07-07T11:24:00Z"),
+            listingExchangeName: "GER",
+            marketState: "REGULAR",
+            sessionConfidence: "derived",
+          },
+        },
+        expectedProvider: "yahoo",
+        expectedPrice: 17.85,
+        expectedChangePercent: ((17.85 - 19.6) / 19.6) * 100,
+        expectedRoute: "SMART",
+      },
+      {
+        contributions: {
+          "gloomberb-cloud": {
+            symbol: "3HNX",
+            providerId: "gloomberb-cloud",
+            dataSource: "delayed",
+            price: 5.81,
+            currency: "GBP",
+            change: -1.58,
+            changePercent: -21.42,
+            previousClose: 7.39,
+            lastUpdated: Date.parse("2026-07-07T11:18:00Z"),
+            listingExchangeName: "LSE",
+            marketState: "REGULAR",
+            sessionConfidence: "derived",
+          },
+          yahoo: {
+            symbol: "3HNX.L",
+            providerId: "yahoo",
+            dataSource: "delayed",
+            price: 5.9775,
+            currency: "GBP",
+            change: -1.4125,
+            changePercent: -19.09,
+            previousClose: 7.39,
+            lastUpdated: Date.parse("2026-07-07T11:24:00Z"),
+            listingExchangeName: "LSE",
+            marketState: "REGULAR",
+            sessionConfidence: "derived",
+          },
+        },
+        expectedProvider: "yahoo",
+        expectedPrice: 5.9775,
+      },
+    ];
+
+    for (const scenario of cases) {
+      const quote = resolveCanonicalQuote(scenario.contributions, now).quote;
+      expect(quote?.providerId).toBe(scenario.expectedProvider);
+      expect(quote?.price).toBe(scenario.expectedPrice);
+      expect(quote?.provenance?.price?.providerId).toBe(scenario.expectedProvider);
+      if (scenario.expectedChangePercent != null) {
+        expect(quote?.changePercent).toBeCloseTo(scenario.expectedChangePercent, 10);
+      }
+      if (scenario.expectedRoute) {
+        expect(quote?.routingExchangeName).toBe(scenario.expectedRoute);
+      }
+    }
+  });
+
+  test("prefers yahoo day reference fields over stale cloud previous close data", () => {
+    const now = Date.parse("2026-07-06T15:45:00Z");
+    const contributions: QuoteContributionMap = {
+      "gloomberb-cloud": {
+        symbol: "VICR",
+        providerId: "gloomberb-cloud",
+        dataSource: "delayed",
+        price: 299.8,
+        currency: "USD",
+        change: -80.27,
+        changePercent: -21.12,
+        previousClose: 380.07,
+        lastUpdated: Date.parse("2026-07-06T15:44:00Z"),
+        listingExchangeName: "NASDAQ",
+        marketState: "REGULAR",
+        sessionConfidence: "derived",
+      },
+      yahoo: {
+        symbol: "VICR",
+        providerId: "yahoo",
+        dataSource: "delayed",
+        price: 297.9,
+        currency: "USD",
+        change: 14.95,
+        changePercent: 5.28,
+        previousClose: 282.95,
+        lastUpdated: Date.parse("2026-07-06T15:41:00Z"),
+        listingExchangeName: "NMS",
+        marketState: "REGULAR",
+        sessionConfidence: "derived",
+      },
+    };
+
+    const quote = resolveCanonicalQuote(contributions, now).quote;
+
+    expect(quote?.providerId).toBe("gloomberb-cloud");
+    expect(quote?.price).toBe(299.8);
+    expect(quote?.previousClose).toBe(282.95);
+    expect(quote?.change).toBeCloseTo(16.85, 10);
+    expect(quote?.changePercent).toBeCloseTo((16.85 / 282.95) * 100, 10);
+    expect(quote?.provenance?.price?.providerId).toBe("gloomberb-cloud");
+    expect(quote?.provenance?.fields?.previousClose?.providerId).toBe("yahoo");
+  });
+
   test("prefers cloud session data over yahoo when confidence is tied", () => {
     const now = Date.parse("2026-04-08T11:00:00Z");
     const contributions: QuoteContributionMap = {

package/src/market-data/quotes/resolution.ts

@@ -31,9 +31,6 @@ const PRICE_FIELD_KEYS = [
   "symbol",
   "price",
   "currency",
-  "change",
-  "changePercent",
-  "previousClose",
   "bid",
   "ask",
   "bidSize",
@@ -88,12 +85,39 @@ function providerKindRank(providerId?: string): number {
   }
 }
 
+function dailyReferenceRank(providerId?: string): number {
+  switch (providerId) {
+    case "yahoo":
+      return 0;
+    case "gloomberb-cloud":
+      return 1;
+    case "ibkr":
+      return 2;
+    default:
+      return 3;
+  }
+}
+
 function priceRank(quote: QuoteContribution): number {
   if (quote.providerId === "ibkr" && quote.dataSource === "live") return 0;
-  if (quote.providerId === "ibkr") return 1;
-  if (quote.providerId === "gloomberb-cloud") return 2;
-  if (quote.providerId === "yahoo") return 3;
-  return 4;
+  return 1;
+}
+
+function priceProviderTieRank(providerId?: string): number {
+  switch (providerId) {
+    case "gloomberb-cloud":
+      return 0;
+    case "yahoo":
+      return 1;
+    case "ibkr":
+      return 2;
+    default:
+      return 3;
+  }
+}
+
+function quoteUpdateTime(quote: QuoteContribution): number {
+  return quote.lastUpdated ?? quote.receivedAt ?? 0;
 }
 
 function sessionConfidenceRank(confidence?: SessionConfidence): number {
@@ -144,6 +168,61 @@ function pickField(
   return undefined;
 }
 
+function finitePositiveNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+
+function buildDailyReferenceCandidates(
+  candidates: QuoteContribution[],
+  priceProvider: QuoteContribution | undefined,
+): QuoteContribution[] {
+  return [...candidates]
+    .filter((quote) => finitePositiveNumber(quote.previousClose))
+    .sort((left, right) => {
+      if (priceProvider) {
+        const leftMismatch = hasLikelyQuoteUnitMismatch(priceProvider, left) ? 1 : 0;
+        const rightMismatch = hasLikelyQuoteUnitMismatch(priceProvider, right) ? 1 : 0;
+        if (leftMismatch !== rightMismatch) return leftMismatch - rightMismatch;
+      }
+      const providerDelta = dailyReferenceRank(left.providerId) - dailyReferenceRank(right.providerId);
+      if (providerDelta !== 0) return providerDelta;
+      return (right.lastUpdated ?? 0) - (left.lastUpdated ?? 0);
+    });
+}
+
+function assignDailyChangeFields(
+  target: Partial<Quote>,
+  provenance: QuoteProvenance,
+  priceProvider: QuoteContribution | undefined,
+  candidates: QuoteContribution[],
+): void {
+  const referenceProvider = buildDailyReferenceCandidates(candidates, priceProvider)[0];
+  if (!referenceProvider) {
+    pickField(target, provenance, "previousClose", candidates);
+    pickField(target, provenance, "change", candidates);
+    pickField(target, provenance, "changePercent", candidates);
+    return;
+  }
+
+  assignField(target, provenance, "previousClose", referenceProvider);
+  const price = target.price;
+  const previousClose = target.previousClose;
+  if (!finitePositiveNumber(price) || !finitePositiveNumber(previousClose)) {
+    pickField(target, provenance, "change", candidates);
+    pickField(target, provenance, "changePercent", candidates);
+    return;
+  }
+
+  target.change = price - previousClose;
+  target.changePercent = (target.change / previousClose) * 100;
+  provenance.fields ??= {};
+  const referenceProvenance = toProvenance(referenceProvider);
+  if (referenceProvenance) {
+    provenance.fields.change = referenceProvenance;
+    provenance.fields.changePercent = referenceProvenance;
+  }
+}
+
 function buildAcceptedPriceCandidates(contributions: QuoteContribution[]): {
   accepted: QuoteContribution[];
   rejectedProviders: string[];
@@ -153,7 +232,13 @@ function buildAcceptedPriceCandidates(contributions: QuoteContribution[]): {
     .sort((left, right) => {
       const rankDelta = priceRank(left) - priceRank(right);
       if (rankDelta !== 0) return rankDelta;
-      return (right.lastUpdated ?? 0) - (left.lastUpdated ?? 0);
+      if (priceRank(left) > 0) {
+        const updateDelta = quoteUpdateTime(right) - quoteUpdateTime(left);
+        if (updateDelta !== 0) return updateDelta;
+      }
+      const providerDelta = priceProviderTieRank(left.providerId) - priceProviderTieRank(right.providerId);
+      if (providerDelta !== 0) return providerDelta;
+      return quoteUpdateTime(right) - quoteUpdateTime(left);
     });
 
   const accepted: QuoteContribution[] = [];
@@ -290,6 +375,7 @@ export function resolveCanonicalQuote(
     if (field === "price") continue;
     pickField(resolved, provenance, field, acceptedPriceCandidates);
   }
+  assignDailyChangeFields(resolved, provenance, priceProvider, acceptedPriceCandidates);
   provenance.price = toProvenance(priceProvider);
 
   const sessionProvider = sessionCandidates[0];

package/src/market-data/request-types.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import type { TickerRecord } from "../types/ticker";
-import { quoteSubscriptionTargetFromTicker } from "./request-types";
+import { instrumentFromTicker, quoteSubscriptionTargetFromTicker } from "./request-types";
 
 function makeTicker(overrides: Partial<TickerRecord["metadata"]> = {}): TickerRecord {
   return {
@@ -21,6 +21,66 @@ function makeTicker(overrides: Partial<TickerRecord["metadata"]> = {}): TickerRe
 }
 
 describe("quoteSubscriptionTargetFromTicker", () => {
+  test("selects the broker contract that belongs to the active portfolio", () => {
+    const ticker = makeTicker({
+      ticker: "VICR",
+      name: "Vicor",
+      portfolios: [
+        "broker:ibkr-live:DU111",
+        "broker:ibkr-coldstart:DU222",
+      ],
+      positions: [
+        {
+          portfolio: "broker:ibkr-live:DU111",
+          shares: 170,
+          avgCost: 198,
+          currency: "USD",
+          broker: "ibkr",
+          brokerInstanceId: "ibkr-live",
+          brokerContractId: 275759,
+        },
+        {
+          portfolio: "broker:ibkr-coldstart:DU222",
+          shares: 350,
+          avgCost: 290,
+          currency: "USD",
+          broker: "ibkr",
+          brokerInstanceId: "ibkr-coldstart",
+          brokerContractId: 275759,
+        },
+      ],
+      broker_contracts: [
+        {
+          brokerId: "ibkr",
+          brokerInstanceId: "ibkr-live",
+          conId: 275759,
+          symbol: "VICR",
+          localSymbol: "VICR",
+          exchange: "NASDAQ",
+          currency: "USD",
+          secType: "STK",
+        },
+        {
+          brokerId: "ibkr",
+          brokerInstanceId: "ibkr-coldstart",
+          conId: 275759,
+          symbol: "VICR",
+          localSymbol: "VICR",
+          exchange: "NASDAQ",
+          currency: "USD",
+          secType: "STK",
+        },
+      ],
+    });
+
+    expect(instrumentFromTicker(ticker, "VICR", { portfolioId: "broker:ibkr-coldstart:DU222" })).toMatchObject({
+      symbol: "VICR",
+      brokerId: "ibkr",
+      brokerInstanceId: "ibkr-coldstart",
+      instrument: ticker.metadata.broker_contracts?.[1],
+    });
+  });
+
   test("preserves broker contract context for streaming targets", () => {
     const ticker = makeTicker({
       broker_contracts: [{