gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/sectors/client.test.ts

@@ -0,0 +1,211 @@
+import { describe, expect, test } from "bun:test";
+import type { DataProvider } from "../../../types/data-provider";
+import type { PricePoint, Quote } from "../../../types/financials";
+import { loadSectorRows } from "./client";
+import { projectSectorRows } from "./headless";
+
+const sectors = [
+  { name: "Technology", etf: "XLK" },
+  { name: "Financials", etf: "XLF" },
+];
+const quote = (symbol: string): Quote => ({
+  symbol, price: 105, change: 5, changePercent: 5, currency: "USD", lastUpdated: Date.parse("2026-09-10T18:00:00Z"), changeSessionDate: "2026-09-10",
+});
+const history = [
+  { date: "2025-09-10", close: 80 },
+  { date: "2026-08-10", close: 90 },
+  { date: "2026-09-10", close: 100 },
+] as PricePoint[];
+
+describe("sector quote recovery", () => {
+  test("retries missing batch items without refetching successful quotes", async () => {
+    const retried: string[] = [];
+    const provider = {
+      getQuotesBatch: async () => [{ target: { symbol: "XLK", exchange: "" }, quote: quote("XLK") }],
+      getQuote: async (symbol: string) => { retried.push(symbol); return quote(symbol); },
+      getPriceHistory: async () => history,
+    } as unknown as DataProvider;
+    const rows = await loadSectorRows(sectors, provider);
+    expect(retried).toEqual(["XLF"]);
+    expect(rows.map(({ row }) => [row?.price, row?.changePercent, row?.quoteUnavailable]))
+      .toEqual([[105, 5, false], [105, 5, false]]);
+  });
+
+  test("keeps historical returns while leaving unavailable current quotes blank", async () => {
+    const provider = {
+      getQuotesBatch: async () => { throw new Error("batch unavailable"); },
+      getQuote: async () => { throw new Error("quote unavailable"); },
+      getPriceHistory: async () => history,
+    } as unknown as DataProvider;
+    const [result] = await loadSectorRows(sectors.slice(0, 1), provider);
+    expect(result?.row).toMatchObject({ price: null, changePercent: null, quoteUnavailable: true });
+    expect(result?.row?.return1Y).toBeCloseTo(25);
+    expect(result?.row?.return1M).toBeCloseTo(11.111111);
+  });
+});
+
+
+test("uses one session for live returns and rejects short or outdated histories", async () => {
+  const provider = {
+    getQuotesBatch: async () => [{ target: { symbol: "XLK" }, quote: quote("XLK") }],
+    getQuote: async () => null,
+    getPriceHistory: async (symbol: string) => symbol === "XLK"
+      ? [{ date: new Date("2026-08-10"), close: 90 }, { date: new Date("2026-09-09"), close: 100 }]
+      : [{ date: new Date("2025-09-10"), close: 80 }, { date: new Date("2026-08-10"), close: 90 }, { date: new Date("2026-09-09"), close: 100 }],
+  } as unknown as DataProvider;
+  const rows = await loadSectorRows(sectors, provider);
+  expect(rows[0]?.row?.return1M).toBeCloseTo(16.6666667);
+  expect(rows[0]?.row).toMatchObject({ return1Y: null, returnAsOfDate: "2026-09-10", return1MStartDate: "2026-08-10" });
+  expect(rows[1]?.row).toMatchObject({ return1M: null, return1Y: null, quoteUnavailable: true });
+});
+
+test("requests a boundary buffer when the prior-year date falls on a holiday", async () => {
+  let requestedStart: string | null = null;
+  const sessionQuote = { ...quote("XLK"), changeSessionDate: "2026-10-12", lastUpdated: Date.parse("2026-10-12T18:00:00Z") };
+  const provider = {
+    getQuote: async () => sessionQuote,
+    getPriceHistory: async () => [{ date: new Date("2025-10-13"), close: 101 }, { date: new Date("2026-10-12"), close: 104 }],
+    getDetailedPriceHistory: async (_symbol: string, _exchange: string, start: Date) => {
+      requestedStart = start.toISOString().slice(0, 10);
+      return [{ date: new Date("2025-10-10"), close: 100 }];
+    },
+  } as unknown as DataProvider;
+  const [result] = await loadSectorRows(sectors.slice(0, 1), provider);
+  expect(requestedStart).toBe("2025-10-05");
+  expect(result?.row?.return1Y).toBeCloseTo(5);
+  expect(result?.row?.return1YStartDate).toBe("2025-10-10");
+});
+
+
+test("one missing baseline bar cannot change a fund's comparison window", async () => {
+  const provider = {
+    getQuote: async (symbol: string) => quote(symbol),
+    getPriceHistory: async (symbol: string) => [
+      { date: new Date("2025-09-10"), close: 80 },
+      { date: new Date("2026-08-07"), close: 85 },
+      ...(symbol === "XLK" ? [{ date: new Date("2026-08-10"), close: 90 }] : []),
+      { date: new Date("2026-09-10"), close: 100 },
+    ],
+  } as unknown as DataProvider;
+  const outcomes = await loadSectorRows(sectors, provider);
+  expect(outcomes[0]?.row?.return1M).toBeCloseTo(16.6666667);
+  expect(outcomes[1]?.row?.return1M).toBeNull();
+  expect(outcomes.map(({ row }) => row?.return1Y)).toEqual([31.25, 31.25]);
+});
+
+test("a prior-session quote cannot lead the current sector ranking", async () => {
+  const provider = {
+    getQuote: async (symbol: string) => symbol === "XLK" ? quote(symbol) : {
+      ...quote(symbol), price: 117, changePercent: 17, changeSessionDate: "2026-09-09",
+    },
+    getPriceHistory: async () => history,
+  } as unknown as DataProvider;
+  const rows = projectSectorRows(sectors, await loadSectorRows(sectors, provider));
+  expect(rows.map((row) => row.etf)).toEqual(["XLK", "XLF"]);
+  expect(rows[1]).toMatchObject({ price: null, changePercent: null, lastReportedPrice: 117,
+    quoteSessionDate: "2026-09-09", quoteUnavailable: true, returnAsOfDate: "2026-09-10" });
+  expect(rows[1]?.quoteIssue).toContain("shared session is 2026-09-10");
+  expect(rows[1]?.return1M).toBeCloseTo(11.111111);
+  expect(rows[1]?.return1Y).toBe(25);
+});
+
+test.each([
+  { stale: true },
+  { changeSessionDate: "2026-02-30" },
+  { changeSessionDate: undefined, lastUpdated: NaN },
+])("withholds unverifiable session prices even when all quotes share the defect: %j", async (override) => {
+  const provider = {
+    getQuote: async (symbol: string) => ({ ...quote(symbol), ...override }),
+    getPriceHistory: async () => history,
+  } as unknown as DataProvider;
+  const rows = await loadSectorRows(sectors, provider);
+  for (const { row } of rows) {
+    expect(row).toMatchObject({ price: null, changePercent: null, quoteUnavailable: true, return1Y: 25 });
+    expect(row?.quoteIssue).toBeTruthy();
+  }
+});
+
+test("missing session change stays unavailable while a reported zero is valid", async () => {
+  const provider = {
+    getQuote: async (symbol: string) => ({ ...quote(symbol), changePercent: symbol === "XLK" ? NaN : 0 }),
+    getPriceHistory: async () => history,
+  } as unknown as DataProvider;
+  const rows = projectSectorRows(sectors, await loadSectorRows(sectors, provider));
+  expect(rows.map((row) => row.etf)).toEqual(["XLF", "XLK"]);
+  expect(rows[0]).toMatchObject({ changePercent: 0, quoteIssue: null });
+  expect(rows[1]).toMatchObject({ price: 105, changePercent: null, quoteIssue: "1D change unavailable" });
+});
+
+test("a corrected boundary response replaces the cached contradiction without mutating it", async () => {
+  const bad = { ...history[0]!, open: 80, high: 79, low: 78 };
+  const original = { ...bad };
+  let corrected = false;
+  const provider = {
+    getQuote: async (symbol: string) => quote(symbol),
+    getPriceHistory: async () => [bad, ...history.slice(1)],
+    getDetailedPriceHistory: async () => [{ ...bad, ...(corrected ? { high: 81 } : {}) }],
+  } as unknown as DataProvider;
+  const [first] = await loadSectorRows(sectors.slice(0, 1), provider);
+  expect(first?.row?.return1Y).toBeNull();
+  expect(first?.row?.return1M).toBeCloseTo(16.6666667);
+  const diagnostic = first?.row?.returnIntegrity?.["1Y"];
+  expect(diagnostic?.sourcePoints[0]).toMatchObject({ close: 80, high: 79, low: 78 });
+  corrected = true;
+  const [next] = await loadSectorRows(sectors.slice(0, 1), provider);
+  expect(next?.row?.return1Y).toBe(31.25);
+  expect(next?.row?.returnIntegrity).toEqual({});
+  expect(bad).toEqual(original);
+  expect(diagnostic?.sourcePoints[0]?.high).toBe(79);
+});
+
+test.each(["missing end", "invalid baseline"] as const)("a peer's %s cannot move the shared calendar boundaries", async (failure) => {
+  const definitions = [{ name: "Semiconductors", etf: "SMH" }, { name: "Gold Miners", etf: "GDX" }];
+  const provider = {
+    getQuote: async (symbol: string) => symbol === "SMH" && failure === "missing end" ? null : quote(symbol),
+    getPriceHistory: async (symbol: string) => symbol === "SMH" ? [
+      { date: new Date("2025-09-10"), close: failure === "invalid baseline" ? NaN : 80 },
+      { date: new Date("2026-08-10"), close: failure === "invalid baseline" ? 0 : 90 },
+      { date: new Date("2026-09-09"), close: 100 },
+    ] : [
+      { date: new Date("2025-09-09"), close: 80 },
+      { date: new Date("2026-08-07"), close: 90 },
+      { date: new Date("2026-09-10"), close: 100 },
+    ],
+  } as unknown as DataProvider;
+  const outcomes = await loadSectorRows(definitions, provider);
+  expect(outcomes[0]?.row).toMatchObject({ return1M: null, return1Y: null });
+  expect(outcomes[1]?.row).toMatchObject({ price: 105, changePercent: 5, return1M: null, return1Y: null,
+    return1MStartDate: null, return1YStartDate: null, returnAsOfDate: "2026-09-10" });
+});
+
+test("an extended peer baseline counts even when its ending observation remains unavailable", async () => {
+  const provider = {
+    getQuote: async (symbol: string) => symbol === "XLK" ? null : quote(symbol),
+    getPriceHistory: async (symbol: string) => symbol === "XLK" ? [
+      { date: new Date("2026-08-10"), close: 90 },
+      { date: new Date("2026-09-09"), close: 100 },
+    ] : [
+      { date: new Date("2025-09-09"), close: 80 },
+      ...history.slice(1),
+    ],
+    getDetailedPriceHistory: async () => [{ date: new Date("2025-09-10"), close: 80 }],
+  } as unknown as DataProvider;
+  const rows = await loadSectorRows(sectors, provider);
+  expect(rows[0]?.row).toMatchObject({ return1M: null, return1Y: null });
+  expect(rows[1]?.row?.return1M).toBeCloseTo(16.6666667);
+  expect(rows[1]?.row?.return1Y).toBeNull();
+});
+
+test("shared holiday baselines remain valid and a separate history failure cannot erase them", async () => {
+  const provider = {
+    getQuote: async (symbol: string) => ({ ...quote(symbol), changeSessionDate: "2026-10-12" }),
+    getPriceHistory: async (symbol: string) => {
+      if (symbol === "XLK") throw new Error("history unavailable");
+      return [{ date: new Date("2025-10-10"), close: 100 }, { date: new Date("2026-09-11"), close: 100 }];
+    },
+  } as unknown as DataProvider;
+  const rows = await loadSectorRows(sectors, provider);
+  expect(rows[0]?.row).toMatchObject({ price: 105, return1M: null, return1Y: null });
+  expect(rows[1]?.row?.return1Y).toBeCloseTo(5);
+  expect(rows[1]?.row).toMatchObject({ return1MStartDate: "2026-09-11", return1YStartDate: "2025-10-10" });
+});

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

@@ -3,9 +3,9 @@ import type { PricePoint, Quote } from "../../../types/financials";
 import type { SectorDef } from "./sector-data";
 import {
   computeTrailingReturn,
-  latestHistoryClose,
-  ONE_MONTH_DAYS,
-  ONE_YEAR_DAYS,
+  latestHistoryDate,
+  sectorReturnTargetDate,
+  sectorReturnStartDate,
   type SectorRow,
 } from "./sector-model";
 
@@ -24,31 +24,102 @@ export async function loadSectorRows(
       sectors.map((sector) => ({ symbol: sector.etf, exchange: "" })),
     ).catch(() => []);
     for (const result of results) quotes.set(result.target.symbol, result.quote ?? null);
-  } else {
-    await Promise.all(sectors.map(async (sector) => {
-      try {
-        quotes.set(sector.etf, await provider.getQuote(sector.etf, ""));
-      } catch {
-        quotes.set(sector.etf, null);
-      }
-    }));
   }
+  // A partial batch must not silently replace a live quote with yesterday's
+  // history close. Retry only the missing instruments through the normal route.
+  await Promise.all(sectors.filter((sector) => !quotes.get(sector.etf)).map(async (sector) => {
+    try {
+      quotes.set(sector.etf, await provider.getQuote(sector.etf, ""));
+    } catch {
+      quotes.set(sector.etf, null);
+    }
+  }));
 
-  return Promise.all(sectors.map(async (sector) => {
-    const history: PricePoint[] = await provider.getPriceHistory(sector.etf, "", "1Y")
-      .catch(() => []);
+  const histories = new Map(await Promise.all(sectors.map(async (sector) => [
+    sector.etf,
+    await provider.getPriceHistory(sector.etf, "", "1Y").catch(() => []),
+  ] as const)));
+  const quoteDates = new Map([...quotes].map(([symbol, quote]) => [symbol, quote ? quoteSessionDate(quote) : null]));
+  const asOfDate = [...quoteDates.values(), ...[...histories.values()].map(latestHistoryDate)]
+    .filter((date): date is string => date != null).sort().at(-1) ?? null;
+
+  const outcomes = await Promise.all(sectors.map(async (sector) => {
+    let history: PricePoint[] = histories.get(sector.etf) ?? [];
     const quote = quotes.get(sector.etf) ?? null;
     if (!quote && history.length === 0) return { etf: sector.etf, row: null };
-    const price = quote?.price ?? latestHistoryClose(history);
+    const lastReportedPrice = quote && Number.isFinite(quote.price) && quote.price > 0 ? quote.price : null;
+    const sessionDate = quoteDates.get(sector.etf) ?? null;
+    const priceIssue = !quote || lastReportedPrice == null ? "quote unavailable"
+      : !sessionDate ? "quote session unknown"
+      : quote.stale ? `stale quote from ${sessionDate}`
+      : sessionDate !== asOfDate ? `quote from ${sessionDate}; shared session is ${asOfDate}`
+      : null;
+    const price = priceIssue ? null : lastReportedPrice;
+    const changePercent = price != null && Number.isFinite(quote?.changePercent) ? quote!.changePercent : null;
+    const quoteIssue = priceIssue ?? (changePercent == null ? "1D change unavailable" : null);
+    // A strict trailing request may begin after the prior year's weekend or
+    // holiday. Ask for a small boundary buffer when the provider supports it.
+    if (asOfDate && computeTrailingReturn(history, "1Y", price, asOfDate)?.value == null
+      && provider.getDetailedPriceHistory) {
+      const start = new Date(`${sectorReturnTargetDate(asOfDate, "1Y")}T00:00:00Z`);
+      start.setUTCDate(start.getUTCDate() - 7);
+      const end = new Date(`${asOfDate}T00:00:00Z`);
+      end.setUTCDate(end.getUTCDate() + 1);
+      const extended = await provider.getDetailedPriceHistory(sector.etf, "", start, end, "1d").catch(() => []);
+      if (extended.length > 0) {
+        history = [...history, ...extended];
+        histories.set(sector.etf, history);
+      }
+    }
+    const month = computeTrailingReturn(history, "1M", price, asOfDate);
+    const year = computeTrailingReturn(history, "1Y", price, asOfDate);
     return {
       etf: sector.etf,
       row: {
         price,
-        changePercent: quote?.changePercent ?? null,
-        return1M: computeTrailingReturn(history, ONE_MONTH_DAYS, price),
-        return1Y: computeTrailingReturn(history, ONE_YEAR_DAYS, price),
+        quoteUnavailable: price == null,
+        quoteSessionDate: sessionDate,
+        quoteIssue,
+        lastReportedPrice,
+        changePercent,
+        return1M: month?.value ?? null,
+        return1Y: year?.value ?? null,
+        returnAsOfDate: asOfDate,
+        return1MStartDate: month?.startDate ?? null,
+        return1YStartDate: year?.startDate ?? null,
+        returnIntegrity: {
+          ...(month?.integrity ? { "1M": month.integrity } : {}),
+          ...(year?.integrity ? { "1Y": year.integrity } : {}),
+        },
         currency: quote?.currency ?? "USD",
       },
     };
   }));
+  // These ETFs share a market calendar. A missing observation for one fund
+  // must not silently give it an earlier baseline than its peers. Use every
+  // reported baseline, independently of whether that fund has an ending price.
+  const sharedStartDate = (range: "1M" | "1Y") => [...histories.values()]
+    .map((history) => sectorReturnStartDate(history, range, asOfDate))
+    .filter((date): date is string => !!date).sort().at(-1);
+  const monthStartDate = sharedStartDate("1M");
+  const yearStartDate = sharedStartDate("1Y");
+  for (const { row } of outcomes) {
+    if (!row) continue;
+    if (row.return1MStartDate !== monthStartDate) { row.return1M = null; row.return1MStartDate = null; }
+    if (row.return1YStartDate !== yearStartDate) { row.return1Y = null; row.return1YStartDate = null; }
+  }
+  return outcomes;
+}
+
+function quoteSessionDate(quote: Quote): string | null {
+  const declared = quote.changeSessionDate;
+  if (typeof declared === "string" && /^\d{4}-\d{2}-\d{2}$/.test(declared)
+    && Number.isFinite(Date.parse(declared)) && new Date(declared).toISOString().slice(0, 10) === declared) return declared;
+  if (declared != null) return null;
+  if (!Number.isFinite(quote.lastUpdated) || quote.lastUpdated <= 0) return null;
+  // Every instrument in these collections is a US-listed ETF. quote.price is
+  // the regular-session price; prefer its declared session when supplied.
+  return new Intl.DateTimeFormat("en-CA", {
+    timeZone: "America/New_York", year: "numeric", month: "2-digit", day: "2-digit",
+  }).format(new Date(quote.lastUpdated));
 }

package/src/plugins/builtin/sectors/headless.test.ts

@@ -1,12 +1,25 @@
 import { describe, expect, test } from "bun:test";
 import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
 import { createSectorsHeadless } from "./headless";
+import { pricePointIntegrity } from "../../../utils/price-history-integrity";
 
 function args(collection: string): HeadlessPaneLoadArgs {
   return { rawArgument: "", argument: null, symbols: [], options: { collection } };
 }
 
 describe("sectors headless model", () => {
+  test("reports incomplete quotes even when historical returns remain available", async () => {
+    const headless = createSectorsHeadless({
+      load: async (_args, definitions) => definitions.map((definition) => ({
+        etf: definition.etf,
+        row: { price: null, changePercent: null, return1Y: 10, quoteUnavailable: true },
+      })),
+    });
+    const result = await headless.load(args("sectors"), {} as HeadlessPaneContext);
+    expect(result.unavailableSymbols).toContain("XLK");
+    expect(result.rows.find((row) => row.etf === "XLK")?.return1Y).toBe(10);
+  });
+
   test("changes the loaded ETF universe with the collection option", async () => {
     const requested: string[][] = [];
     const headless = createSectorsHeadless({
@@ -26,3 +39,49 @@ describe("sectors headless model", () => {
     expect(requested[0]).not.toEqual(requested[1]);
   });
 });
+
+
+test("an available quote does not make an unavailable annual window complete", async () => {
+  const headless = createSectorsHeadless({
+    load: async (_args, definitions) => definitions.map((definition) => ({
+      etf: definition.etf,
+      row: { price: 100, changePercent: 1, return1M: 2, return1Y: null, quoteUnavailable: false, returnAsOfDate: "2026-09-10" },
+    })),
+  });
+  const result = await headless.load(args("sectors"), {} as HeadlessPaneContext);
+  expect(result.unavailableSymbols).toContain("XLK");
+  expect(result.errors?.some((error) => error.startsWith("XLK:"))).toBe(true);
+  expect(result.rows.find((row) => row.etf === "XLK")).toMatchObject({ price: 100, return1M: 2, return1Y: null });
+});
+
+test("exports stale quote dates and rejected endpoints with the matching reason", async () => {
+  const integrity = pricePointIntegrity({ date: new Date("2025-09-10"), open: 80, high: 79, low: 78, close: 80 })!;
+  const headless = createSectorsHeadless({
+    load: async (_args, definitions) => definitions.map((definition) => ({ etf: definition.etf, row: {
+      price: null, lastReportedPrice: 117, quoteSessionDate: "2026-09-09", quoteIssue: "stale quote from 2026-09-09",
+      quoteUnavailable: true, changePercent: null, return1M: 2, return1Y: null, returnIntegrity: { "1Y": integrity },
+    } })),
+  });
+  const result = await headless.load(args("sectors"), {} as HeadlessPaneContext);
+  expect(result.unavailableSymbols).toContain("XLK");
+  expect(result.errors).toContain("XLK: stale quote from 2026-09-09.");
+  expect(result.errors).toContain("XLK: 1Y: inconsistent OHLC at return endpoint.");
+  expect(result.errors?.some((error) => error.includes("history does not cover"))).toBe(false);
+  expect(result.rows.find((row) => row.etf === "XLK")).toMatchObject({ lastReportedPrice: 117,
+    quoteSessionDate: "2026-09-09", returnIntegrity: { "1Y": integrity } });
+});
+
+test("actual industry loader exports missing windows when the peer establishing their calendar loses its endpoint", async () => {
+  const provider = {
+    getQuote: async (symbol: string) => symbol === "GDX" ? { symbol, price: 150, currency: "USD", changePercent: 0,
+      changeSessionDate: "2026-09-10", lastUpdated: Date.parse("2026-09-10T18:00:00Z") } : null,
+    getPriceHistory: async (symbol: string) => symbol === "SMH"
+      ? [{ date: new Date("2025-09-10"), close: 100 }, { date: new Date("2026-08-10"), close: 100 }, { date: new Date("2026-09-09"), close: 110 }]
+      : symbol === "GDX" ? [{ date: new Date("2025-09-09"), close: 100 }, { date: new Date("2026-08-07"), close: 100 }, { date: new Date("2026-09-10"), close: 150 }] : [],
+  };
+  const result = await createSectorsHeadless().load(args("industries"), { marketData: provider } as unknown as HeadlessPaneContext);
+  expect(result.rows.find((row) => row.etf === "GDX")).toMatchObject({ price: 150, changePercent: 0, return1M: null, return1Y: null });
+  expect(result.unavailableSymbols).toContain("GDX");
+  expect(result.errors).toContain("GDX: 1M: history does not cover the shared window.");
+  expect(result.errors).toContain("GDX: 1Y: history does not cover the shared window.");
+});

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

@@ -6,7 +6,7 @@ import type {
 import { formatCurrency, formatPercentRaw } from "../../../utils/format";
 import { loadSectorRows, type SectorRowOutcome } from "./client";
 import { getSectorCollection, type SectorCollectionId, type SectorDef } from "./sector-data";
-import { DEFAULT_SORT_PREFERENCE, sortRows, type SectorRow } from "./sector-model";
+import { DEFAULT_SORT_PREFERENCE, sectorRowIssues, sortRows, type SectorRow } from "./sector-model";
 
 const COLUMNS = [
   { key: "name", header: "Sector" },
@@ -30,6 +30,14 @@ export function projectSectorRows(
     return1Y: byEtf.get(definition.etf)?.return1Y ?? null,
     currency: byEtf.get(definition.etf)?.currency ?? "USD",
     loading: false,
+    quoteUnavailable: !byEtf.get(definition.etf) || byEtf.get(definition.etf)?.quoteUnavailable === true,
+    quoteSessionDate: byEtf.get(definition.etf)?.quoteSessionDate ?? null,
+    quoteIssue: byEtf.get(definition.etf)?.quoteIssue ?? null,
+    lastReportedPrice: byEtf.get(definition.etf)?.lastReportedPrice ?? null,
+    returnIntegrity: byEtf.get(definition.etf)?.returnIntegrity ?? {},
+    returnAsOfDate: byEtf.get(definition.etf)?.returnAsOfDate ?? null,
+    return1MStartDate: byEtf.get(definition.etf)?.return1MStartDate ?? null,
+    return1YStartDate: byEtf.get(definition.etf)?.return1YStartDate ?? null,
   })), DEFAULT_SORT_PREFERENCE);
 }
 
@@ -65,12 +73,23 @@ export function createSectorsHeadless(
       const definitions = getSectorCollection(collectionId).items;
       const outcomes = await dependencies.load(args, definitions, ctx.marketData);
       const rows = projectSectorRows(definitions, outcomes);
+      const unavailableQuotes = rows.filter((row) => row.quoteUnavailable).map((row) => row.etf);
+      const unavailableReturns = rows.filter((row) => row.return1M == null || row.return1Y == null).map((row) => row.etf);
+      const unavailableDailyChanges = rows.filter((row) => row.changePercent == null).map((row) => row.etf);
+      const unavailableSymbols = [...new Set([...unavailableQuotes, ...unavailableReturns, ...unavailableDailyChanges])];
       return {
+        unavailableSymbols: unavailableSymbols.length > 0 ? unavailableSymbols : undefined,
+        errors: rows.flatMap((row) => sectorRowIssues(row).map((issue) => `${row.etf}: ${issue}.`)),
         rows: rows.map((row) => ({ ...row })),
         metadata: {
           collection: collectionId,
           available: outcomes.filter((outcome) => outcome.row).length,
           requested: definitions.length,
+          unavailableQuotes,
+          unavailableReturns,
+          unavailableDailyChanges,
+          returnDefinition: "ETF price returns in listing currency; cash distributions are not reinvested. Shared ending session and calendar-month/year boundaries; prior close used for holidays.",
+          returnWindows: rows.map((row) => ({ symbol: row.etf, asOfDate: row.returnAsOfDate, monthStartDate: row.return1MStartDate, yearStartDate: row.return1YStartDate })),
         },
       };
     },

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

@@ -24,6 +24,7 @@ import {
   buildSectorColumns,
   nextSortPreference,
   normalizeRowsForCollection,
+  sectorRowIssues,
   sortRows,
   updateRowsForCollection,
   type SectorColumn,
@@ -58,11 +59,11 @@ function SectorPerformancePane({ focused, width, height }: PaneProps) {
     [activeCollection.id, savedIndustryEtfs, savedSectorEtfs],
   );
   const [rowsByCollection, setRowsByCollection] = useDebouncedPluginPaneState<SectorRowsByCollection>(
-    "rowsByCollection:v1",
+    "rowsByCollection:v4",
     INITIAL_ROWS_BY_COLLECTION,
   );
   const [lastRefreshByCollection, setLastRefreshByCollection] = useDebouncedPluginPaneState<SectorRefreshByCollection>(
-    "lastRefreshByCollection:v1",
+    "lastRefreshByCollection:v2",
     INITIAL_REFRESH_BY_COLLECTION,
   );
   const [selectedEtf, setSelectedEtf] = usePluginPaneState<string | null>("selectedEtf", null);
@@ -108,7 +109,7 @@ function SectorPerformancePane({ focused, width, height }: PaneProps) {
       if (fetchGenRef.current !== gen) return;
       const loadedByEtf = new Map(outcomes.map((outcome) => [outcome.etf, outcome.row]));
       setRowsByCollection((prev) => updateRowsForCollection(prev, collectionId, sectorDefs, (rows) => (
-        rows.map((row) => ({ ...row, ...(loadedByEtf.get(row.etf) ?? {}), loading: false }))
+        rows.map((row) => ({ ...row, ...(loadedByEtf.get(row.etf) ?? { price: null, changePercent: null, return1M: null, return1Y: null, returnAsOfDate: null, return1MStartDate: null, return1YStartDate: null, quoteUnavailable: true, quoteSessionDate: null, quoteIssue: "quote unavailable", lastReportedPrice: null, returnIntegrity: {} }), loading: false }))
       )));
 
       const loadedCount = outcomes.filter((outcome) => outcome.row).length;
@@ -205,17 +206,29 @@ function SectorPerformancePane({ focused, width, height }: PaneProps) {
   }, []);
 
   const updatedAgo = useUpdatedAgo(lastRefreshMs);
+  const returnAsOfDate = rows.map((row) => row.returnAsOfDate).filter((date): date is string => !!date).sort().at(-1);
+  const incompleteRows = rows.filter((row) => !row.loading && sectorRowIssues(row).length > 0).length;
+  const selectedRow = rows.find((row) => row.etf === selectedEtf);
+  const selectedIssues = selectedRow && !selectedRow.loading ? sectorRowIssues(selectedRow) : [];
+  const selectedIssue = selectedIssues.length > 0 ? `${selectedEtf}: ${selectedIssues.join(" · ")}` : null;
 
   usePaneFooter("sectors", () => {
     const info: PaneFooterSegment[] = [];
     if (loading) info.push({ id: "loading", parts: [{ text: "loading", tone: "muted" }] });
     if (loadError) info.push({ id: "error", parts: [{ text: loadError, tone: "warning" }] });
-    if (updatedAgo) info.push({ id: "updated", parts: [{ text: `updated ${updatedAgo}`, tone: "muted" }] });
-    return { info };
-  }, [loadError, loading, updatedAgo]);
+    if (selectedIssue) info.push({ id: "selected-issue", parts: [{ text: selectedIssue, tone: "warning" }] });
+    if (incompleteRows) info.push({ id: "incomplete", parts: [{ text: `${incompleteRows} ETFs have unavailable values`, tone: "warning" }] });
+    if (returnAsOfDate) info.push({ id: "return-as-of", parts: [{ text: `returns as of ${returnAsOfDate}`, tone: "muted" }] });
+    if (updatedAgo) info.push({ id: "updated", parts: [{ text: `checked ${updatedAgo}`, tone: "muted" }] });
+    // Keep the leading current failure readable when the pane is narrow; separate
+    // flex children would each shrink it to a few characters beside routine status.
+    return { info: info.length > 0 ? [{ id: "status", parts: info.flatMap((segment, index) => [
+      ...(index > 0 ? [{ text: "·", tone: "muted" as const }] : []), ...segment.parts,
+    ]) }] : [] };
+  }, [loadError, loading, selectedIssue, incompleteRows, returnAsOfDate, updatedAgo]);
 
   const rootBefore = (
-    <Box height={1} paddingX={1}>
+    <Box height={1} flexShrink={0} paddingX={1} flexDirection="column">
       <Tabs
         tabs={tabs}
         activeValue={activeCollection.id}
@@ -297,27 +310,13 @@ export const sectorsModule: PluginModule = {
     },
   ],
 
-  setup(ctx) {
-    ctx.registerCommand({
-      id: "sectors-sp",
-      label: "Sector Performance",
-      description: "S&P 500 sector and industry performance sorted by daily change.",
-      keywords: ["sector", "sectors", "sp", "performance"],
-      category: "data",
-      shortcut: "SP",
-      execute: () => {
-        ctx.createPaneFromTemplate("sectors-pane");
-      },
-    });
-  },
-
   paneTemplates: [
     {
       id: "sectors-pane",
       paneId: "sectors",
       label: "Sector Performance",
       description: "S&P 500 sector and industry performance sorted by daily change.",
-      keywords: ["sector", "sectors", "industry", "semis", "defense", "food", "leisure", "etf", "xlk", "xlv", "xlf", "performance", "spdr"],
+      keywords: ["sector", "sectors", "industry", "semis", "defense", "food", "leisure", "etf", "xlk", "xlv", "xlf", "performance", "spdr", "sp"],
       shortcut: { prefix: "BI" },
       headless: sectorsHeadless,
     },

package/src/plugins/builtin/sectors/pane-cache.test.tsx

@@ -0,0 +1,78 @@
+import { afterAll, afterEach, expect, test } from "bun:test";
+import { act, useReducer } from "react";
+import { mkdirSync, writeFileSync } from "node:fs";
+
+const source = process.env.SECTOR_CACHE_SOURCE ?? new URL("../../../../", import.meta.url).pathname.replace(/\/$/, "");
+const out = process.env.SECTOR_CACHE_OUT;
+if (out) mkdirSync(out, { recursive: true });
+const originalFetch = globalThis.fetch;
+const originalWebSocket = globalThis.WebSocket;
+let externalAttempts = 0;
+globalThis.fetch = (async (input: any, init: any) => {
+  const url = String(input instanceof Request ? input.url : input);
+  if (url.startsWith("data:")) return originalFetch(input, init);
+  externalAttempts++;
+  throw new Error("External request prohibited in sector cache regression");
+}) as typeof fetch;
+globalThis.WebSocket = class { constructor() { externalAttempts++; throw new Error("External socket prohibited"); } } as any;
+
+const { sectorsModule } = await import(`${source}/src/plugins/builtin/sectors/index.tsx`);
+const { testRender, takeSavedTextFile } = await import(`${source}/src/renderers/opentui/test-utils.tsx`);
+const { createInitialState, appReducer } = await import(`${source}/src/state/app/context/index.tsx`);
+const { TestPaneProvider, createTestPaneConfig } = await import(`${source}/src/test-support/pane.tsx`);
+const { createTestPluginRuntime } = await import(`${source}/src/test-support/plugin-runtime.ts`);
+const { exportPaneTable } = await import(`${source}/src/state/pane-table-export-registry.ts`);
+const Pane = sectorsModule.panes[0].component;
+let setup: Awaited<ReturnType<typeof testRender>> | undefined;
+const cases: unknown[] = [];
+
+afterEach(async () => {
+  if (setup) await act(async () => setup!.renderer.destroy());
+  setup = undefined;
+});
+afterAll(() => {
+  if (out) writeFileSync(`${out}/observations.json`, JSON.stringify({ source, externalAttempts, cases }, null, 2));
+  globalThis.fetch = originalFetch;
+  globalThis.WebSocket = originalWebSocket;
+  if (externalAttempts) throw new Error("Unexpected external attempt");
+});
+
+for (const version of ["v3", "v4"]) test(`opening without a provider handles the ${version} computed-row cache`, async () => {
+  const config = createTestPaneConfig("/tmp/sector-cache-controlled", {
+    instanceId: "sector-cache", paneId: "sectors", settings: { industryEtfs: ["GDX"] },
+  });
+  config.refreshIntervalMinutes = 0;
+  const state = createInitialState(config);
+  state.focusedPaneId = "sector-cache";
+  state.paneState["sector-cache"] = { pluginState: { "market-overview": {
+    activeCollectionId: "industries", selectedEtf: "GDX",
+    [`rowsByCollection:${version}`]: { sectors: [], industries: [{
+      name: "Gold Miners", etf: "GDX", price: version === "v3" ? 150 : 110, currency: "USD", changePercent: 0,
+      return1M: version === "v3" ? 50 : 10, return1Y: version === "v3" ? 50 : 10,
+      returnAsOfDate: "2026-09-10", return1MStartDate: version === "v3" ? "2026-08-07" : "2026-08-10",
+      return1YStartDate: version === "v3" ? "2025-09-09" : "2025-09-10", loading: false,
+    }] },
+  } } };
+  const runtime = createTestPluginRuntime(); // No provider is connected during reopening.
+  function Harness() {
+    const [current, dispatch] = useReducer(appReducer, state);
+    return <TestPaneProvider state={current} dispatch={dispatch} paneId="sector-cache" pluginId="market-overview" runtime={runtime}>
+      <Pane focused width={82} height={10} />
+    </TestPaneProvider>;
+  }
+  await act(async () => { setup = await testRender(<Harness />, { width: 82, height: 10 }); });
+  for (let index = 0; index < 4; index++) await act(async () => { await setup!.renderOnce(); });
+  const frame = setup!.captureCharFrame();
+  await exportPaneTable("sector-cache", `${version}.csv`);
+  const csv = takeSavedTextFile()!.text;
+  if (out) {
+    writeFileSync(`${out}/${version}.txt`, frame);
+    writeFileSync(`${out}/${version}.csv`, csv);
+  }
+  cases.push({ version, frame, csv });
+  expect(frame).toContain("GDX");
+  expect(csv).not.toContain("+50.00%");
+  expect(frame).not.toContain("+50.00%");
+  expect(csv.includes("+10.00%")).toBe(version === "v4");
+  expect(frame.includes("+10.00%")).toBe(version === "v4");
+});