gloomberb 0.13.2 → 0.14.0

package/src/market-data/quotes/price-basis.test.ts

@@ -0,0 +1,44 @@
+import { expect, test } from "bun:test";
+import type { Quote } from "../../types/financials";
+import { resolveCanonicalQuote } from "./resolution";
+import { mergeQuoteContribution, normalizeQuoteContribution } from "./contributions";
+const now=Date.parse("2026-09-10T18:00:00Z");
+const quote=(changes:Partial<Quote>={}):Quote=>({symbol:"CONTROLLED",price:87,currency:"USD",change:1,changePercent:100/86,
+  previousClose:86,instrumentType:"BOND",priceBasis:"percent-of-par",lastUpdated:now,marketState:"REGULAR",sessionConfidence:"explicit",...changes});
+
+test("selected price owns its unit; incompatible contributors cannot supply daily, session or range prices",()=>{
+  const ibkr={...quote(),providerId:"ibkr",dataSource:"live" as const};
+  const yahoo={...quote({price:.87,previousClose:.86,priceBasis:"per-unit",marketState:"POST",postMarketPrice:.89,high52w:1,low52w:.8,bid:.85}),providerId:"yahoo"};
+  const selected=resolveCanonicalQuote({ibkr,yahoo},now).quote!;
+  expect(selected).toMatchObject({price:87,priceBasis:"percent-of-par",previousClose:86,change:1});
+  for(const key of ["bid","postMarketPrice","high52w","low52w"] as const)expect(selected[key]).toBeUndefined();
+  const unknown=resolveCanonicalQuote({ibkr:{...ibkr,priceBasis:undefined},yahoo:{...yahoo,priceBasis:"percent-of-par"}},now).quote!;
+  expect(unknown.priceBasis).toBeUndefined();
+  expect(unknown.postMarketPrice).toBeUndefined();
+});
+
+test("new untagged responses clear prior basis and cannot inherit old unit-priced session fields or extrema",()=>{
+  const old=normalizeQuoteContribution(quote({providerId:"ibkr",marketState:"POST",postMarketPrice:88,postMarketChange:2,high:89,low:85}))!;
+  const next=mergeQuoteContribution(old,quote({providerId:"ibkr",priceBasis:undefined,price:.87,marketState:undefined,high:undefined,low:undefined,previousClose:undefined}));
+  expect(next.priceBasis).toBeUndefined();
+  expect(next.postMarketPrice).not.toBe(88);
+  expect(next.high).toBeUndefined(); expect(next.low).toBeUndefined();
+  expect(resolveCanonicalQuote({ibkr:next},now).quote!.priceBasis).toBeUndefined();
+  const restored=mergeQuoteContribution(next,quote({providerId:"ibkr",price:90,postMarketPrice:90,marketState:"POST"}));
+  expect(restored).toMatchObject({priceBasis:"percent-of-par",price:90,postMarketPrice:90});
+});
+
+test("unknown bond observations cannot borrow old or cross-provider units, anchors or descriptive share classification",()=>{
+  const ibkr={...quote({priceBasis:undefined,previousClose:undefined,change:0}),providerId:"ibkr",dataSource:"live" as const};
+  const yahoo={...quote({priceBasis:undefined,previousClose:80,bid:85,high52w:100,marketState:"POST",postMarketPrice:89}),providerId:"yahoo"};
+  const selected=resolveCanonicalQuote({ibkr,yahoo},now).quote!;
+  expect(selected).toMatchObject({price:87,change:0,instrumentType:"BOND"});
+  for(const key of ["priceBasis","previousClose","bid","postMarketPrice","high52w"] as const)expect(selected[key]).toBeUndefined();
+  const enriched=resolveCanonicalQuote({ibkr,yahoo:{...yahoo,instrumentType:"STK"}},now).quote!;
+  expect(enriched.instrumentType).toBe("BOND");expect(enriched.priceBasis).toBeUndefined();
+  const old=normalizeQuoteContribution({...ibkr,previousClose:80,bid:85,open:84,high:90,low:80,high52w:100,lastTradePrice:86,lastTradeTime:now-1000,marketState:"REGULAR",exchangeName:"NYSE"})!;
+  const next=mergeQuoteContribution(old,{...ibkr,lastUpdated:now+1000,marketState:"REGULAR",exchangeName:"NYSE"});
+  for(const key of ["previousClose","bid","open","high","low","high52w","lastTradePrice","lastTradeTime"] as const)expect(next[key]).toBeUndefined();
+  const self=resolveCanonicalQuote({ibkr:{...ibkr,previousClose:86,bid:85}},now).quote!;
+  expect(self).toMatchObject({previousClose:86,bid:85});
+});

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

@@ -5,8 +5,23 @@ import {
   resolveTickerFinancialsQuoteState,
   upsertQuoteContributionMap,
 } from "./resolution";
+import { mergeQuoteContribution, normalizeQuoteContribution } from "./contributions";
 
 describe("quote-resolution", () => {
+  test("keeps actual trade price and timestamp paired with the selected price provider", () => {
+    const now = Date.parse("2026-09-10T18:00:00Z");
+    const contributions: QuoteContributionMap = {
+      ibkr: { symbol: "PLTR", providerId: "ibkr", dataSource: "live", price: 166, mark: 166, lastTradePrice: 165.9,
+        currency: "USD", change: 1, changePercent: 1, lastUpdated: now, lastTradeTime: now - 2000 },
+      yahoo: { symbol: "PLTR", providerId: "yahoo", dataSource: "delayed", price: 165, lastTradePrice: 164.9,
+        currency: "USD", change: 0, changePercent: 0, lastUpdated: now - 900000, lastTradeTime: now - 900000 },
+    };
+    expect(resolveCanonicalQuote(contributions, now).quote).toMatchObject({ price: 166, lastTradePrice: 165.9, lastTradeTime: now - 2000 });
+    delete contributions.ibkr!.lastTradeTime;
+    expect(resolveCanonicalQuote(contributions, now).quote?.lastTradeTime).toBeUndefined();
+    delete contributions.ibkr!.lastTradePrice;
+    expect(resolveCanonicalQuote(contributions, now).quote?.lastTradePrice).toBeUndefined();
+  });
   test("resolves price, session, listing venue, and route from separate providers", () => {
     const now = Date.parse("2026-04-08T11:00:00Z");
     const contributions: QuoteContributionMap = {
@@ -66,6 +81,36 @@ describe("quote-resolution", () => {
     expect(quote?.routingExchangeName).toBe("SMART");
     expect(quote?.provenance?.price?.providerId).toBe("ibkr");
     expect(quote?.provenance?.session?.providerId).toBe("yahoo");
+
+    const streamed = upsertQuoteContributionMap({ yahoo: contributions.yahoo! }, contributions.ibkr!, { now });
+    expect(streamed.ibkr?.price).toBe(100);
+    expect(resolveCanonicalQuote(streamed, now).quote).toMatchObject({ price: 100, marketState: "PRE", preMarketPrice: 101 });
+  });
+
+  test("admits incomplete price contributions only from the current extended session", () => {
+    for (const [nowIso, marketState] of [["2026-09-14T11:00:00Z", "PRE"], ["2026-09-14T22:00:00Z", "POST"]] as const) {
+      const now = Date.parse(nowIso);
+      const yahoo = { symbol: "AMD", providerId: "yahoo", price: 99, currency: "USD", change: 0, changePercent: 0,
+        lastUpdated: now - 60_000, listingExchangeName: "NASDAQ", marketState,
+        ...(marketState === "PRE" ? { preMarketPrice: 101 } : { postMarketPrice: 102 }) };
+      const ibkr = { ...yahoo, providerId: "ibkr", dataSource: "live" as const, price: 100,
+        marketState: undefined, preMarketPrice: undefined, postMarketPrice: undefined };
+      const good = resolveCanonicalQuote({ yahoo, ibkr }, now).quote;
+      expect(good).toMatchObject({ price: 100, marketState });
+      for (const overrides of [
+        { stale: true }, { lastUpdated: now - 86_400_000 }, { lastUpdated: NaN }, { lastUpdated: Infinity },
+        { lastUpdated: 0 }, { lastUpdated: now + 60_000 },
+        { lastUpdated: Date.parse(marketState === "PRE" ? "2026-09-14T07:59:00Z" : "2026-09-14T11:00:00Z") },
+        { marketState: marketState === "PRE" ? "POST" as const : "PRE" as const, preMarketPrice: 101, postMarketPrice: 102 },
+      ]) {
+        const rejected = { ...ibkr, ...overrides };
+        expect(resolveCanonicalQuote({ yahoo, ibkr: rejected }, now).quote?.price).toBe(99);
+        expect(upsertQuoteContributionMap({ yahoo }, rejected, { now }).ibkr).toBeUndefined();
+      }
+      // Price-only contributions remain useful as retained data; they cannot
+      // establish a complete current-session quote without session metadata.
+      expect(resolveCanonicalQuote({ ibkr }, now).quote?.marketState).toBeUndefined();
+    }
   });
 
   test("uses provider previous close with the live broker price for daily change", () => {
@@ -361,6 +406,49 @@ describe("quote-resolution", () => {
     expect(quote?.preMarketChangePercent).toBeUndefined();
   });
 
+  test("explicit session state does not turn a delayed or unclassified regular close into extended-hours trades", () => {
+    for (const marketState of ["PRE", "POST"] as const) {
+      for (const dataSource of ["delayed", undefined] as const) {
+        const contribution = normalizeQuoteContribution({
+          symbol: "ASML", providerId: "gloomberb-cloud", listingExchangeName: "AMS",
+          price: 1472.8, currency: "EUR", previousClose: 1497.6,
+          change: -24.8, changePercent: -1.65598,
+          lastUpdated: Date.parse("2026-09-10T15:29:00Z"),
+          marketState, sessionConfidence: "explicit", dataSource,
+        })!;
+        const canonical = resolveCanonicalQuote({ "gloomberb-cloud": contribution }, contribution.lastUpdated).quote;
+        for (const quote of [contribution, canonical]) {
+          expect(quote?.price).toBe(1472.8);
+          expect(quote?.marketState).toBe(marketState);
+          expect(quote?.preMarketPrice).toBeUndefined();
+          expect(quote?.preMarketChange).toBeUndefined();
+          expect(quote?.preMarketChangePercent).toBeUndefined();
+          expect(quote?.postMarketPrice).toBeUndefined();
+          expect(quote?.postMarketChange).toBeUndefined();
+          expect(quote?.postMarketChangePercent).toBeUndefined();
+        }
+      }
+    }
+  });
+
+  test("preserves reported delayed after-hours fields without filling missing changes from the daily move", () => {
+    const base = {
+      symbol: "ASML", providerId: "gloomberb-cloud", listingExchangeName: "AMS",
+      price: 1472.8, currency: "EUR", previousClose: 1497.6,
+      change: -24.8, changePercent: -1.65598, lastUpdated: Date.parse("2026-09-10T16:00:00Z"),
+      marketState: "POST" as const, sessionConfidence: "explicit" as const, dataSource: "delayed" as const,
+      postMarketPrice: 1475,
+    };
+    const priceOnly = normalizeQuoteContribution(base)!;
+    expect(priceOnly.postMarketPrice).toBe(1475);
+    expect(priceOnly.postMarketChange).toBeUndefined();
+    expect(priceOnly.postMarketChangePercent).toBeUndefined();
+    const reported = normalizeQuoteContribution({ ...base, postMarketChange: 2.2, postMarketChangePercent: 0.1494 })!;
+    expect(resolveCanonicalQuote({ "gloomberb-cloud": reported }, reported.lastUpdated).quote).toMatchObject({
+      postMarketPrice: 1475, postMarketChange: 2.2, postMarketChangePercent: 0.1494,
+    });
+  });
+
   test("ignores stale cloud price contributions when a fresh yahoo quote exists", () => {
     const now = Date.parse("2026-04-08T10:30:00Z");
     const contributions: QuoteContributionMap = {
@@ -460,3 +548,52 @@ describe("quote-resolution", () => {
     expect(financials?.quote?.provenance?.price?.providerId).toBe("ibkr");
   });
 });
+
+
+test("live after-hours prices never inherit the daily loss as their session return", () => {
+  const base = { symbol: "NVDA", providerId: "gloomberb-cloud", dataSource: "live" as const,
+    marketState: "POST" as const, price: 218.47, currency: "USD", previousClose: 223.67,
+    change: -5.2, changePercent: -2.324853578933245,
+    exchangeName: "NASDAQ", lastUpdated: Date.parse("2026-09-10T20:30:00Z") };
+  const noClose = normalizeQuoteContribution(base)!;
+  expect(noClose.postMarketPrice).toBe(218.47);
+  expect(noClose.postMarketChange).toBeUndefined();
+  expect(noClose.postMarketChangePercent).toBeUndefined();
+  const reported = normalizeQuoteContribution({ ...base, regularClose: 218.36, regularCloseSessionDate: "2026-09-10",
+    postMarketPrice: 218.47, postMarketChange: 0.11, postMarketChangePercent: 0.0503755266532 })!;
+  const canonical = resolveCanonicalQuote({ cloud: reported }, base.lastUpdated).quote!;
+  expect(canonical.change).toBeCloseTo(-5.2, 8);
+  expect(canonical.postMarketChange).toBe(0.11);
+  expect(canonical.regularClose).toBe(218.36);
+  for (const change of [{}, { currency: "EUR" }, { symbol: "ASML", exchangeName: "AMS" },
+    { lastUpdated: base.lastUpdated + 86400000 }]) {
+    const next = mergeQuoteContribution(reported, { ...base, ...change, marketState: undefined, price: 219 });
+    expect(next.postMarketPrice).toBe(219);
+    expect(next.postMarketChange).toBeUndefined();
+    expect(next.postMarketChangePercent).toBeUndefined();
+    expect(next.regularClose).toBeUndefined();
+    expect(next.regularCloseSessionDate).toBeUndefined();
+  }
+});
+
+test("a different price provider cannot inherit a closing-price anchor", () => {
+  const now = Date.parse("2026-09-10T20:30:00Z");
+  const result = resolveCanonicalQuote({
+    cloud: { symbol: "NVDA", providerId: "gloomberb-cloud", dataSource: "delayed", price: 218.47, currency: "USD",
+      change: -5.2, changePercent: -2.32, lastUpdated: now - 900000, regularClose: 218.36, regularCloseSessionDate: "2026-09-10" },
+    ibkr: { symbol: "NVDA", providerId: "ibkr", dataSource: "live", price: 219, currency: "USD",
+      change: -4.67, changePercent: -2.08, lastUpdated: now },
+  }, now).quote!;
+  expect(result.price).toBe(219);
+  expect(result.regularClose).toBeUndefined();
+  expect(result.regularCloseSessionDate).toBeUndefined();
+});
+
+test("canonical quote preserves unavailable day changes while retaining zero and a legitimate prior-close derivation", () => {
+  const base = { symbol: "SCANNER", price: 12, currency: "USD", lastUpdated: Date.now(), marketState: "CLOSED" };
+  const missing = resolveCanonicalQuote({ quote: base }).quote!;
+  expect(missing.change).toBeNaN();
+  expect(missing.changePercent).toBeNaN();
+  expect(resolveCanonicalQuote({ quote: { ...base, change: 0, changePercent: 0 } }).quote).toMatchObject({ change: 0, changePercent: 0 });
+  expect(resolveCanonicalQuote({ quote: { ...base, previousClose: 10 } }).quote).toMatchObject({ change: 2, changePercent: 20 });
+});

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

@@ -8,9 +8,12 @@ import type {
   SessionConfidence,
   TickerFinancials,
 } from "../../types/financials";
+import { mergeQuoteMetadata, quoteMetadataFromQuote } from "./metadata";
+import { resolvePriceBasis } from "../market/price-basis";
 import { hasLikelyQuoteUnitMismatch } from "../../utils/currency-units";
 import { debugLog } from "../../utils/debug-log";
-import { hasFreshQuoteForCurrentSession, isQuoteStaleForCurrentSession } from "./freshness";
+import { hasValidQuoteObservationTime, isExtendedHoursExchange, isQuoteStaleForCurrentSession } from "./freshness";
+import { activeUsExtendedHoursSession, isTimestampStaleForExchangeSession } from "../market/freshness";
 import {
   finalizeSessionFields,
   getQuoteContributionKey,
@@ -31,6 +34,7 @@ const PRICE_FIELD_KEYS = [
   "symbol",
   "price",
   "currency",
+  "changeSessionDate",
   "bid",
   "ask",
   "bidSize",
@@ -68,6 +72,7 @@ const DESCRIPTIVE_FIELD_KEYS = [
   "marketCap",
   "volume",
   "name",
+  "instrumentType",
 ] as const;
 
 function isBrokerProvider(providerId?: string): boolean {
@@ -267,11 +272,22 @@ function buildAcceptedPriceCandidates(contributions: QuoteContribution[]): {
   return { accepted, rejectedProviders };
 }
 
+export function isQuoteContributionStaleForCurrentSession(contribution: Quote, now = Date.now()): boolean {
+  if (contribution.marketState != null) return isQuoteStaleForCurrentSession(contribution, now);
+  // A price-only source can be combined with independent session metadata.
+  // Its observation must still belong to the current active session.
+  const timestamp = contribution.lastUpdated;
+  if (contribution.stale === true || !hasValidQuoteObservationTime(contribution, now)) return true;
+  const activeSession = isExtendedHoursExchange(contribution) ? activeUsExtendedHoursSession(now) : null;
+  if (activeSession && activeUsExtendedHoursSession(timestamp) !== activeSession) return true;
+  return isTimestampStaleForExchangeSession(timestamp, contribution.listingExchangeName || contribution.exchangeName, now);
+}
+
 function filterFreshQuoteCandidates(
   contributions: QuoteContribution[],
   now: number,
 ): { accepted: QuoteContribution[]; rejectedProviders: string[] } {
-  if (!hasFreshQuoteForCurrentSession(contributions, now)) {
+  if (!contributions.some((contribution) => !isQuoteContributionStaleForCurrentSession(contribution, now))) {
     return { accepted: contributions, rejectedProviders: [] };
   }
 
@@ -279,7 +295,7 @@ function filterFreshQuoteCandidates(
   const rejectedProviders = new Set<string>();
 
   for (const contribution of contributions) {
-    if (isQuoteStaleForCurrentSession(contribution, now)) {
+    if (isQuoteContributionStaleForCurrentSession(contribution, now)) {
       rejectedProviders.add(contribution.providerId);
       quoteResolutionLog.warn("Rejected stale quote contribution for the current session", {
         providerId: contribution.providerId,
@@ -373,11 +389,22 @@ export function resolveCanonicalQuote(
   };
 
   const priceProvider = pickField(resolved, provenance, "price", acceptedPriceCandidates);
+  // The selected response owns the price convention; metadata enrichment must
+  // not declare units for another provider's price or supply incompatible anchors.
+  assignField(resolved, provenance, "priceBasis", priceProvider);
+  const selectedBasis = resolvePriceBasis(priceProvider?.priceBasis, priceProvider?.instrumentType);
+  const compatiblePrice = (candidate: QuoteContribution) => candidate === priceProvider
+    || selectedBasis !== null && resolvePriceBasis(candidate.priceBasis, candidate.instrumentType) === selectedBasis;
+  const compatiblePriceCandidates = acceptedPriceCandidates.filter(compatiblePrice);
   for (const field of PRICE_FIELD_KEYS) {
     if (field === "price") continue;
-    pickField(resolved, provenance, field, acceptedPriceCandidates);
+    pickField(resolved, provenance, field, compatiblePriceCandidates);
   }
-  assignDailyChangeFields(resolved, provenance, priceProvider, acceptedPriceCandidates);
+  if (priceProvider && typeof priceProvider.lastTradePrice === "number" && Number.isFinite(priceProvider.lastTradePrice)) {
+    assignField(resolved, provenance, "lastTradePrice", priceProvider);
+    if (finitePositiveNumber(priceProvider.lastTradeTime)) assignField(resolved, provenance, "lastTradeTime", priceProvider);
+  }
+  assignDailyChangeFields(resolved, provenance, priceProvider, compatiblePriceCandidates);
   provenance.price = toProvenance(priceProvider);
 
   const sessionProvider = sessionCandidates[0];
@@ -388,12 +415,12 @@ export function resolveCanonicalQuote(
     provenance.session = toProvenance(sessionProvider);
   }
 
-  const preSessionCandidates = sessionCandidates.filter((quote) => matchesPreMarketState(quote.marketState));
+  const preSessionCandidates = sessionCandidates.filter((quote) => compatiblePrice(quote) && matchesPreMarketState(quote.marketState));
   for (const field of PRE_SESSION_FIELD_KEYS) {
     pickField(resolved, provenance, field, preSessionCandidates);
   }
 
-  const postSessionCandidates = sessionCandidates.filter((quote) => matchesPostMarketState(quote.marketState));
+  const postSessionCandidates = sessionCandidates.filter((quote) => compatiblePrice(quote) && matchesPostMarketState(quote.marketState));
   for (const field of POST_SESSION_FIELD_KEYS) {
     pickField(resolved, provenance, field, postSessionCandidates);
   }
@@ -423,24 +450,34 @@ export function resolveCanonicalQuote(
 
   let descriptiveProvider: QuoteContribution | undefined;
   for (const field of DESCRIPTIVE_FIELD_KEYS) {
-    const provider = pickField(resolved, provenance, field, descriptiveCandidates);
+    const provider = pickField(resolved, provenance, field, field === "high52w" || field === "low52w" ? descriptiveCandidates.filter(compatiblePrice) : descriptiveCandidates);
     descriptiveProvider ??= provider;
   }
   provenance.descriptive = toProvenance(descriptiveProvider);
+  // Descriptive enrichment cannot turn an unknown-unit bond observation into
+  // an ordinary share price by replacing its source-reported security type.
+  if (priceProvider?.instrumentType?.trim().toUpperCase() === "BOND") {
+    assignField(resolved, provenance, "instrumentType", priceProvider);
+  }
 
   const canonical = finalizeSessionFields({
     symbol: String(resolved.symbol ?? priceProvider?.symbol ?? contributions[0]!.symbol ?? ""),
     providerId: priceProvider?.providerId ?? contributions[0]!.providerId,
     price: Number(resolved.price ?? priceProvider?.price ?? 0),
+    priceBasis: priceProvider?.priceBasis,
     currency: String(resolved.currency ?? priceProvider?.currency ?? contributions[0]!.currency ?? ""),
-    change: Number(resolved.change ?? priceProvider?.change ?? 0),
-    changePercent: Number(resolved.changePercent ?? priceProvider?.changePercent ?? 0),
+    change: resolved.change ?? Number.NaN,
+    changePercent: resolved.changePercent ?? Number.NaN,
     previousClose: resolved.previousClose as Quote["previousClose"],
+    regularClose: priceProvider?.regularClose,
+    regularCloseSessionDate: priceProvider?.regularClose != null ? priceProvider.regularCloseSessionDate : undefined,
+    changeSessionDate: resolved.changeSessionDate as Quote["changeSessionDate"],
     high52w: resolved.high52w as Quote["high52w"],
     low52w: resolved.low52w as Quote["low52w"],
     marketCap: resolved.marketCap as Quote["marketCap"],
     volume: resolved.volume as Quote["volume"],
     name: resolved.name as Quote["name"],
+    instrumentType: resolved.instrumentType as Quote["instrumentType"],
     lastUpdated: Number(resolved.lastUpdated ?? priceProvider?.lastUpdated ?? sessionProvider?.lastUpdated ?? now),
     receivedAt: resolved.receivedAt as Quote["receivedAt"],
     delivery: resolved.delivery as Quote["delivery"],
@@ -467,6 +504,8 @@ export function resolveCanonicalQuote(
     high: resolved.high as Quote["high"],
     low: resolved.low as Quote["low"],
     mark: resolved.mark as Quote["mark"],
+    lastTradePrice: resolved.lastTradePrice as Quote["lastTradePrice"],
+    lastTradeTime: resolved.lastTradeTime as Quote["lastTradeTime"],
     dataSource: (resolved.dataSource as QuoteDataSource | undefined) ?? priceProvider?.dataSource,
     provenance,
   }, {
@@ -487,7 +526,7 @@ export function upsertQuoteContributionMap(
   const normalized = normalizeQuoteContribution(quote);
   if (!normalized) return current ?? {};
   const now = options.now ?? Date.now();
-  if (isQuoteStaleForCurrentSession(normalized, now) && hasFreshQuoteForCurrentSession(quoteContributionValues(current), now)) {
+  if (isQuoteContributionStaleForCurrentSession(normalized, now) && quoteContributionValues(current).some((contribution) => !isQuoteContributionStaleForCurrentSession(contribution, now))) {
     quoteResolutionLog.warn("Rejected incoming stale quote contribution for the current session", {
       incomingProviderId: normalized.providerId,
       incomingPrice: normalized.price,
@@ -550,9 +589,16 @@ export function resolveTickerFinancialsQuoteState(
   }
 
   const { quote } = resolveCanonicalQuote(quoteContributions);
+  const metadataQuote = quote ?? incomingQuote ?? baseFinancials.quote;
   return {
     ...baseFinancials,
     quote,
+    // Listing identity remains useful when the price is stale or unavailable.
+    // Keep its source timestamp/stale flag rather than presenting it as a quote.
+    quoteMetadata: mergeQuoteMetadata(
+      metadataQuote ? quoteMetadataFromQuote(metadataQuote) : undefined,
+      baseFinancials.quoteMetadata,
+    ),
     quoteContributions,
   };
 }

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

@@ -3,6 +3,7 @@ import type { ManualChartResolution } from "../time-series/resolution";
 import type { QuoteSubscriptionTarget } from "../types/data-provider";
 import type { BrokerContractRef } from "../types/instrument";
 import type { TickerRecord } from "../types/ticker";
+import { brokerContractIdentityKey, scopedBrokerContractIdentityKey } from "../utils/instrument-identity";
 
 export interface InstrumentRef {
   symbol: string;
@@ -41,28 +42,40 @@ export interface SecFilingsRequest {
 function brokerContractForTicker(
   ticker: TickerRecord | null | undefined,
   options: TickerInstrumentOptions = {},
-): BrokerContractRef | null {
+): BrokerContractRef | null | undefined {
   const contracts = ticker?.metadata.broker_contracts ?? [];
-  if (contracts.length === 0) return null;
-
   const portfolioId = options.portfolioId;
   if (portfolioId) {
-    const positions = ticker?.metadata.positions.filter((position) => position.portfolio === portfolioId) ?? [];
+    const positions = ticker?.metadata.positions.filter((position) => position.portfolio === portfolioId && position.shares !== 0) ?? [];
+    const selected = new Map<string, BrokerContractRef>();
+    let hasPublicPosition = false;
     for (const position of positions) {
-      const matchingContract = contracts.find((contract) => (
+      const hasExplicitId = position.brokerContractId != null;
+      const hasExplicitIdentity = position.brokerContractIdentity != null;
+      const hasLegacyScope = position.broker !== "manual" && !!position.broker && !!position.brokerInstanceId;
+      if (!hasExplicitId && !hasExplicitIdentity && !hasLegacyScope) {
+        hasPublicPosition = true;
+        continue;
+      }
+      const matches = contracts.filter((contract) => (
         (position.brokerContractId == null || contract.conId === position.brokerContractId)
+        && (hasExplicitId || !hasExplicitIdentity || brokerContractIdentityKey(contract) === position.brokerContractIdentity)
         && (!position.brokerInstanceId || contract.brokerInstanceId === position.brokerInstanceId)
         && (!position.broker || contract.brokerId === position.broker)
       ));
-      if (matchingContract) return matchingContract;
-    }
-    for (const position of positions) {
-      const matchingContract = contracts.find((contract) => (
-        (!position.brokerInstanceId || contract.brokerInstanceId === position.brokerInstanceId)
-        && (!position.broker || contract.brokerId === position.broker)
-      ));
-      if (matchingContract) return matchingContract;
+      if (matches.length === 0) {
+        if (hasExplicitId || hasExplicitIdentity) return undefined;
+        hasPublicPosition = true;
+        continue;
+      }
+      for (const contract of matches) {
+        const key = scopedBrokerContractIdentityKey(contract);
+        selected.set(key, contract);
+      }
     }
+    // One ticker quote must identify every selected lot. Never choose by array order.
+    if (selected.size > 1 || (selected.size > 0 && hasPublicPosition)) return undefined;
+    return selected.values().next().value ?? null;
   }
 
   return contracts[0] ?? null;
@@ -76,6 +89,7 @@ export function instrumentFromTicker(
   const symbol = ticker?.metadata.ticker ?? fallbackSymbol ?? null;
   if (!symbol) return null;
   const instrument = brokerContractForTicker(ticker, options);
+  if (instrument === undefined) return null;
   return {
     symbol,
     exchange: ticker?.metadata.exchange ?? "",

package/src/market-data/result-types.ts

@@ -27,6 +27,9 @@ export interface QueryEntry<T> {
   lastGoodData: T | null;
   source: string | null;
   fetchedAt: number | null;
+  /** Accepted source response order in this runtime, preserved through cache projections. */
+  responseSequence?: number;
+  asOf?: number;
   staleAt: number | null;
   error: { reasonCode: string; message: string } | null;
   attempts: ProviderAttempt[];

package/src/market-data/selectors.ts

@@ -5,19 +5,10 @@ import type { QueryEntry } from "./result-types";
 import { hasLikelyQuoteUnitMismatch } from "../utils/currency-units";
 import { normalizePriceHistory } from "../utils/price-history";
 import { resolveTickerFinancialsQuoteState } from "./quotes/resolution";
+import { instrumentIdentityKey } from "../utils/instrument-identity";
 
 export function buildInstrumentKey(instrument: InstrumentRef): string {
-  const contractKey = instrument.instrument?.conId
-    ?? instrument.instrument?.localSymbol
-    ?? instrument.instrument?.symbol
-    ?? "";
-  return [
-    instrument.symbol.trim().toUpperCase(),
-    (instrument.exchange ?? "").trim().toUpperCase(),
-    instrument.brokerId ?? "",
-    instrument.brokerInstanceId ?? "",
-    contractKey,
-  ].join("|");
+  return instrumentIdentityKey(instrument);
 }
 
 export function toMarketDataContext(instrument: InstrumentRef): MarketDataRequestContext {
@@ -36,18 +27,6 @@ export function buildSnapshotKey(instrument: InstrumentRef): string {
   return `snapshot:${buildInstrumentKey(instrument)}`;
 }
 
-export function buildProfileKey(instrument: InstrumentRef): string {
-  return `profile:${buildInstrumentKey(instrument)}`;
-}
-
-export function buildFundamentalsKey(instrument: InstrumentRef): string {
-  return `fundamentals:${buildInstrumentKey(instrument)}`;
-}
-
-export function buildStatementsKey(instrument: InstrumentRef): string {
-  return `statements:${buildInstrumentKey(instrument)}`;
-}
-
 export function buildChartKey(request: ChartRequest): string {
   return [
     "chart",

package/src/market-data/snapshot-contract.test.ts

@@ -0,0 +1,110 @@
+import { expect, test } from "bun:test";
+import { createSnapshotDataProvider } from "./snapshot-provider";
+import { createTestDataProvider } from "../test-support/data-provider";
+import { loadChartPaneModel, chartHeadless } from "../plugins/builtin/chart-composer/headless";
+import { buildPriceChartPreset } from "../plugins/builtin/chart-composer/presets";
+import { createDefaultConfig } from "../types/config";
+import { quoteMetadataFromQuote } from "./quotes/metadata";
+import { buildDesktopShotPayload, createDesktopShotBridge } from "../cli/pane-functions/screenshot";
+import { decodeRpcValue, encodeRpcValue } from "../renderers/electrobun/view/rpc-codec";
+import type { InstrumentRef } from "./request-types";
+import type { Quote } from "../types/financials";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const target = (expiry: string): InstrumentRef => ({ symbol: "ACME", exchange: "CBOE", brokerId: "fixture", brokerInstanceId: "desk", instrument: {
+  brokerId: "fixture", brokerInstanceId: "desk", symbol: "ACME", secType: "FUT", currency: "USD", exchange: "CBOE", lastTradeDateOrContractMonth: expiry, multiplier: "100",
+} });
+const targets = [target("20261218"), target("20270319")];
+const quote = (price: number): Quote => ({ symbol: "ACME", price, currency: "USD", instrumentType: "FUTURE", listingExchangeName: "CBOE", change: 0, changePercent: 0, lastUpdated: Date.now() });
+const price = (context: any) => context?.instrument?.lastTradeDateOrContractMonth === "20261218" ? 10 : 20;
+const history = (value: number) => [0, 1].map(i => ({ date: new Date(`2026-09-11T14:3${i}:00Z`), close: value }));
+const revive = (value: unknown) => JSON.parse(JSON.stringify(value), (key, entry) => key === "date" ? new Date(entry) : entry);
+
+test("two contract chart observations survive JSON snapshot and actual screenshot payload reconstruction", async () => {
+  const spec = buildPriceChartPreset("ACME:CBOE");
+  spec.studies = [];
+  spec.viewport.dateWindow = { start: "2026-09-11", end: "2026-09-12" };
+  spec.series = targets.map((instrument, i) => ({ ...spec.series[0]!, id: `future-${i}`, source: { kind: "security", instrument, fieldId: "market.close" } }));
+  const provider = createTestDataProvider({
+    getTickerFinancials: async (_s, _e, context) => ({ quote: quote(price(context)), annualStatements: [], quarterlyStatements: [], priceHistory: [] }),
+    getQuoteMetadata: async (_s, _e, context) => quoteMetadataFromQuote(quote(price(context))),
+    getQuote: async (_s, _e, context) => quote(price(context)),
+    getPriceHistory: async (_s, _e, _r, context) => history(price(context)),
+    getPriceHistoryForResolution: async (_s, _e, _r, _resolution, context) => history(price(context)),
+    getDetailedPriceHistory: async (_s, _e, _start, _end, _resolution, context) => history(price(context)),
+  });
+  const config = createDefaultConfig(":memory:");
+  const context = { marketData: provider, config, apiClient: {} as any, signal: new AbortController().signal };
+  const first = await loadChartPaneModel(spec, context);
+  expect(first.series.map(s => s.points.at(-1)?.value)).toEqual([10, 20]);
+  expect(first.snapshot.financials).toEqual([]); expect(first.snapshot.instrumentFinancials).toHaveLength(2);
+  let fallbackCalls = 0;
+  const fail = async () => { fallbackCalls++; throw new Error("Unexpected fallback"); };
+  const fallback = createTestDataProvider({ getQuote: fail, getQuoteMetadata: fail, getTickerFinancials: fail, getPriceHistory: fail, getPriceHistoryForResolution: fail, getDetailedPriceHistory: fail });
+  const snapshot = createSnapshotDataProvider(revive(first.snapshot), fallback);
+  const second = await loadChartPaneModel(spec, { ...context, marketData: snapshot });
+  expect(second.series.map(s => s.points)).toEqual(first.series.map(s => s.points)); expect(fallbackCalls).toBe(0);
+  const definition = chartHeadless("graph-price-pane");
+  const resolved: any = { pane: { id: "chart-composer" }, token: "GP", headless: definition, options: {}, capability: { options: [] }, instance: { instanceId: "chart", paneId: "chart-composer", settings: { chartSpec: spec } } };
+  const payload = await buildDesktopShotPayload(resolved, { config, dataProvider: provider, store: { loadTicker: async () => null } } as any, "ACME", {}, 800, 600, null, 1, null);
+  expect(payload.instrumentFinancials).toHaveLength(2); expect(payload.financials).toEqual([]);
+  const decoded = decodeRpcValue<typeof payload>(JSON.parse(JSON.stringify(encodeRpcValue(payload))));
+  expect(decoded.instrumentFinancials?.[0]?.financials.priceHistory[0]?.date).toBeInstanceOf(Date);
+  expect(decoded.instrumentFinancials?.map(entry => entry.instrument)).toEqual(targets);
+  const captured = createSnapshotDataProvider(decoded, fallback);
+  const reconstructed = await loadChartPaneModel(spec, { ...context, marketData: captured });
+  expect(reconstructed.series.map(s => s.points)).toEqual(first.series.map(s => s.points)); expect(fallbackCalls).toBe(0);
+  const bridgeRequests: unknown[] = [];
+  const dispatcher = createDesktopShotBridge({ dataProvider: createTestDataProvider({
+    getQuote: async (_symbol, _exchange, context) => { bridgeRequests.push(context); return quote(30); },
+    getPriceHistory: async (_symbol, _exchange, _range, context) => { bridgeRequests.push(context); return history(30); },
+  }) });
+  const missingProvider = createSnapshotDataProvider(decoded, createTestDataProvider({
+    getQuote: (symbol, exchange, context) => dispatcher.marketData("getQuote", JSON.parse(JSON.stringify([symbol, exchange, context]))) as Promise<Quote>,
+    getPriceHistory: (symbol, exchange, range, context) => dispatcher.marketData("getPriceHistory", JSON.parse(JSON.stringify([symbol, exchange, range, context]))) as Promise<ReturnType<typeof history>>,
+  }));
+  const missing = target("20270618");
+  expect((await missingProvider.getQuote("ACME", "CBOE", missing)).price).toBe(30);
+  expect((await missingProvider.getPriceHistory("ACME", "CBOE", "1Y", missing)).at(-1)?.close).toBe(30);
+  expect(bridgeRequests).toEqual([missing, missing]);
+  if (process.env.SEARCH_REPLAY_OUTPUT) {
+    await mkdir(process.env.SEARCH_REPLAY_OUTPUT, { recursive: true });
+    await writeFile(join(process.env.SEARCH_REPLAY_OUTPUT, "chart-capture.json"), JSON.stringify({
+      first, reconstructed, encodedDesktopPayload: encodeRpcValue(payload), bridgeRequests, fallbackCalls,
+    }, null, 2));
+  }
+});
+
+test("intraday capture and context-aware quote/history batches preserve identities and legacy public snapshots", async () => {
+  const spec = buildPriceChartPreset("ACME:CBOE"); spec.viewport = { range: "1D", resolution: "1m" };
+  spec.studies = [];
+  spec.series = targets.map((instrument, i) => ({ ...spec.series[0]!, id: `future-${i}`, source: { kind: "security", instrument, fieldId: "market.close" } }));
+  const seen: any[] = [];
+  const provider = createTestDataProvider({
+    getPriceHistoryForResolution: async (_s, _e, _r, _resolution, context) => { seen.push(context); return history(price(context)); },
+    getQuoteMetadata: async (_s, _e, context) => quoteMetadataFromQuote(quote(price(context))),
+  });
+  const context = { marketData: provider, config: createDefaultConfig(":memory:"), apiClient: {} as any, signal: new AbortController().signal, settings: { chartSpec: spec } };
+  const model = await chartHeadless("graph-intraday-price-pane").load({ argument: "ACME", rawArgument: "ACME", symbols: ["ACME"], options: {} }, context);
+  expect(model.series.map(s => s.points.at(-1)?.value)).toEqual([10, 20]);
+  expect(seen.map(c => c?.instrument?.lastTradeDateOrContractMonth).sort()).toEqual(["20261218", "20270319"]);
+  expect(model.snapshot.intradayHistories.map(h => h.target?.instrument?.lastTradeDateOrContractMonth)).toEqual(["20261218", "20270319"]);
+  const publicData = { quote: quote(999), annualStatements: [], quarterlyStatements: [], priceHistory: history(999) };
+  const ownData = (n: number) => ({ ...publicData, quote: quote(n), priceHistory: history(n) });
+  const requests: any[] = [];
+  const snapshot = createSnapshotDataProvider({ financials: [["ACME:CBOE", publicData]], instrumentFinancials: targets.map((instrument, i) => ({ instrument, financials: ownData((i + 1) * 10) })) },
+    createTestDataProvider({ getQuote: async (_s, _e, context) => { requests.push(context); return quote(30); } }));
+  const batch = await snapshot.getQuotesBatch!(targets.map(({ symbol, exchange, ...context }) => ({ symbol, exchange, context })));
+  expect(batch.map(r => r.quote?.price)).toEqual([10, 20]);
+  expect((await snapshot.getTickerFinancialsBatch!(targets)).map(r => r.financials?.quote?.price)).toEqual([10, 20]);
+  expect((await snapshot.getCachedFinancialsForTargets!(targets))?.size).toBe(0);
+  expect((await snapshot.getCachedFinancialsForTargets!([targets[0]!]))?.get("ACME")?.quote?.price).toBe(10);
+  expect((await snapshot.getQuote("ACME", "CBOE")).price).toBe(999);
+  const missing = target("20270618");
+  expect((await snapshot.getQuote("ACME", "CBOE", missing)).price).toBe(30); expect(requests[0]?.instrument?.lastTradeDateOrContractMonth).toBe("20270618");
+  for (const [i, instrument] of targets.entries()) expect((await snapshot.getPriceHistory("ACME", "CBOE", "1Y", instrument)).at(-1)?.close).toBe((i + 1) * 10);
+  const restored = createSnapshotDataProvider(revive(model.snapshot), provider);
+  const replay = await chartHeadless("graph-intraday-price-pane").load({ argument: "ACME", rawArgument: "ACME", symbols: ["ACME"], options: {} }, { ...context, marketData: restored });
+  expect(replay.series.map(s => s.points)).toEqual(model.series.map(s => s.points));
+});