gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/ticker-detail/quote-monitor/index.test.tsx

@@ -4,12 +4,12 @@ import { testRender } from "../../../../renderers/opentui/test-utils";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../../market-data/coordinator";
 import { createTestDataProvider } from "../../../../test-support/data-provider";
 import type { PricePoint, TickerFinancials } from "../../../../types/financials";
-import type { TickerRecord } from "../../../../types/ticker";
 import { createDefaultConfig, TICKER_RESEARCH_PANE_ID } from "../../../../types/config";
-import { AppContext, createInitialState, PaneInstanceProvider } from "../../../../state/app/context";
+import { createInitialState } from "../../../../state/app/context";
 import { QuoteMonitorPane } from "./index";
-import { PluginRenderProvider, type PluginRuntimeAccess } from "../../../runtime";
+import type { PluginRuntimeAccess } from "../../../runtime";
 import type { PinTickerOptions } from "../../../../types/plugin";
+import { TestPaneProvider, createTestTicker as makeTicker } from "../../../../test-support/pane";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
@@ -68,22 +68,6 @@ function makeRuntime(options: {
   };
 }
 
-function makeTicker(symbol: string, name: string): TickerRecord {
-  return {
-    metadata: {
-      ticker: symbol,
-      exchange: "NASDAQ",
-      currency: "USD",
-      name,
-      portfolios: [],
-      watchlists: [],
-      positions: [],
-      custom: {},
-      tags: [],
-    },
-  };
-}
-
 function makePriceHistory(price: number): PricePoint[] {
   return Array.from({ length: 12 }, (_, index) => ({
     date: new Date(Date.UTC(2026, 0, index + 1)),
@@ -114,6 +98,7 @@ function makeFinancials(
 }
 
 function createQuoteMonitorHarness(options: {
+  width?: number;
   symbols?: string[];
   financials?: Map<string, TickerFinancials>;
   pinCalls?: PinTickerCall[];
@@ -150,16 +135,12 @@ function createQuoteMonitorHarness(options: {
   ]);
 
   return (
-    <AppContext value={{ state, dispatch: () => {} }}>
-      <PaneInstanceProvider paneId="quote-monitor:test">
-        <PluginRenderProvider pluginId="ticker-research" runtime={makeRuntime({
-          pinCalls: options.pinCalls,
-          settingsCalls: options.settingsCalls,
-        })}>
-          <QuoteMonitorPane paneId="quote-monitor:test" paneType="quote-monitor" focused width={72} height={7} />
-        </PluginRenderProvider>
-      </PaneInstanceProvider>
-    </AppContext>
+    <TestPaneProvider state={state} paneId="quote-monitor:test" pluginId="ticker-research" runtime={makeRuntime({
+      pinCalls: options.pinCalls,
+      settingsCalls: options.settingsCalls,
+    })}>
+      <QuoteMonitorPane paneId="quote-monitor:test" paneType="quote-monitor" focused width={options.width ?? 72} height={7} />
+    </TestPaneProvider>
   );
 }
 
@@ -190,6 +171,17 @@ async function flushFrames(count: number) {
 }
 
 describe("QuoteMonitorPane", () => {
+  test.each([80, 120])("uses returned FX instrument type when no ticker metadata exists at %s columns", async (width) => {
+    const symbol = "EURUSD=X";
+    const financials = makeFinancials(symbol, 1.1602274179458618, -0.0010778820541381684, -0.09281642425451501, []);
+    financials.quote!.instrumentType = "CURRENCY";
+    await renderHarness(createQuoteMonitorHarness({ width, symbols: [symbol], financials: new Map([[symbol, financials]]) }), { width, height: 7 });
+    await renderOnce();
+    const frame = testSetup!.captureCharFrame();
+    expect(frame).toContain("$1.160227");
+    expect(frame).toContain("-0.001078");
+  });
+
   test("opens a Ticker Research pane on the second card click", async () => {
     const pinCalls: PinTickerCall[] = [];
     await renderHarness(createQuoteMonitorHarness({ pinCalls }), {

package/src/plugins/builtin/ticker-detail/quote-monitor/retained-status.test.tsx

@@ -0,0 +1,134 @@
+import { afterEach, expect, test } from "bun:test";
+import { act } from "react";
+import { testRender } from "../../../../renderers/opentui/test-utils";
+import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../../market-data/coordinator";
+import { createTestDataProvider } from "../../../../test-support/data-provider";
+import { createTestPluginRuntime } from "../../../../test-support/plugin-runtime";
+import { TestPaneProvider, createTestPaneConfig } from "../../../../test-support/pane";
+import { createInitialState } from "../../../../state/app/context";
+import type { Quote, TickerFinancials } from "../../../../types/financials";
+import { QuoteMonitorPane } from "./index";
+
+let setup: Awaited<ReturnType<typeof testRender>> | undefined;
+let coordinator: MarketDataCoordinator | undefined;
+const symbol = "EURUSD=X";
+const instrument = { symbol, exchange: "" };
+
+async function frame() {
+  for (let i = 0; i < 3; i++) await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    await setup!.renderOnce();
+  });
+  return setup!.captureCharFrame();
+}
+
+afterEach(async () => {
+  if (setup) await act(async () => { setup!.renderer.destroy(); });
+  setup = undefined;
+  coordinator?.destroy();
+  coordinator = undefined;
+  setSharedMarketDataCoordinator(null);
+});
+
+async function render(width: number, getQuote: () => Promise<Quote>, cached?: Quote, height = 7, targetSymbol = symbol) {
+  const provider = createTestDataProvider({ getQuote });
+  coordinator = new MarketDataCoordinator(provider);
+  setSharedMarketDataCoordinator(coordinator);
+  const config = createTestPaneConfig("/tmp/gloom-qm-retained-status", {
+    instanceId: "qm:test", paneId: "quote-monitor", binding: { kind: "none" },
+    settings: { symbols: [targetSymbol], liveStreaming: false },
+  });
+  const state = createInitialState(config);
+  if (cached) state.financials.set(targetSymbol, {
+    quote: cached, annualStatements: [], quarterlyStatements: [], priceHistory: [],
+  } satisfies TickerFinancials);
+  await act(async () => {
+    setup = await testRender(<TestPaneProvider state={state} paneId="qm:test" pluginId="ticker-research"
+      runtime={createTestPluginRuntime({ getMarketData: () => provider })}>
+      <QuoteMonitorPane paneId="qm:test" paneType="quote-monitor" focused width={width} height={height} />
+    </TestPaneProvider>, { width, height });
+  });
+  return frame();
+}
+
+function quote(price = 1.160227): Quote {
+  return { symbol, price, currency: "USD", instrumentType: "CURRENCY", change: -0.001078,
+    changePercent: -0.09, lastUpdated: Date.now() };
+}
+
+test.each([80, 120])("retained provider quote exposes refresh failure and clears it on recovery at %i columns", async (width) => {
+  let fail = false;
+  let price = 1.160227;
+  let calls = 0;
+  const initial = await render(width, async () => {
+    calls++;
+    if (fail) throw new Error("FX feed disconnected");
+    return quote(price);
+  });
+  expect(calls).toBeGreaterThan(0);
+  expect(initial).toContain("$1.160227");
+  expect(initial).not.toContain("disconnected");
+
+  fail = true;
+  await act(async () => { await coordinator!.loadQuotesBatch([instrument], { forceRefresh: true }); });
+  const entry = coordinator!.getQuoteEntry(instrument);
+  expect(entry.error?.message).toBe("FX feed disconnected");
+  expect(entry.lastGoodData?.price).toBe(1.160227);
+  const failed = await frame();
+  expect(failed).toContain("$1.160227");
+  expect(failed).toContain("FX feed disconnected");
+
+  fail = false;
+  price = 1.170227;
+  await act(async () => { await coordinator!.loadQuotesBatch([instrument], { forceRefresh: true }); });
+  const recovered = await frame();
+  expect(recovered).toContain("$1.170227");
+  expect(recovered).not.toContain("disconnected");
+  expect(coordinator!.getQuoteEntry(instrument).error).toBeNull();
+});
+
+test("explicit stale cached quote is identified while its provider refresh is pending", async () => {
+  let complete!: (value: Quote) => void;
+  const pending = new Promise<Quote>((resolve) => { complete = resolve; });
+  const retained = await render(80, () => pending, { ...quote(), stale: true });
+  expect(retained).toContain("$1.160227");
+  expect(retained).toContain("Stale quote");
+  await act(async () => { complete(quote(1.170227)); });
+  const recovered = await frame();
+  expect(recovered).toContain("$1.170227");
+  expect(recovered).not.toContain("Stale quote");
+});
+
+test.each(["NaN", "Infinity", "future"] as const)("retained quote with %s source time stays visibly stale until a valid observation arrives", async kind => {
+  let complete!: (value: Quote) => void;
+  const pending = new Promise<Quote>(resolve => { complete = resolve; });
+  const invalidTime = kind === "NaN" ? NaN : kind === "Infinity" ? Infinity : Date.now() + 86_400_000;
+  const cached = { ...quote(), lastUpdated: invalidTime, receivedAt: Date.now() };
+  const retained = await render(80, () => pending, cached);
+  expect(retained).toContain("$1.160227");
+  expect(retained).toContain("Stale quote");
+  expect(Object.is(cached.lastUpdated, invalidTime)).toBe(true);
+  await act(async () => { complete(quote(1.170227)); });
+  const recovered = await frame();
+  expect(recovered).toContain("$1.170227");
+  expect(recovered).not.toContain("Stale quote");
+});
+
+// Dense boards can allocate only three rows to a narrow card. The failure must
+// remain visible there without pushing the retained quote off the card.
+test.each(["error", "stale"] as const)("compact retained card identifies %s without wrapping a long symbol", async (kind) => {
+  const longSymbol = "LRCX260918C01200000";
+  const optionQuote: Quote = { ...quote(14.23), symbol: longSymbol, instrumentType: "OPTION", change: -0.07 };
+  let finish!: (value: Quote) => void;
+  const pending = new Promise<Quote>((resolve) => { finish = resolve; });
+  const result = await render(30, () => kind === "error" ? Promise.reject(new Error("FX feed disconnected")) : pending,
+    { ...optionQuote, stale: kind === "stale" }, 3, longSymbol);
+  expect(result).toContain(longSymbol);
+  expect(result).toContain("-0.07");
+  expect(result).toContain("$14.23");
+  expect(result).toContain(kind === "stale" ? "STALE" : "ERROR");
+  if (kind === "stale") {
+    await act(async () => { finish({ ...optionQuote, price: 14.5, lastUpdated: Date.now() }); });
+    expect(await frame()).not.toContain("STALE");
+  }
+});

package/src/plugins/builtin/ticker-detail/quote-status.test.tsx

@@ -0,0 +1,116 @@
+import { afterEach, expect, mock, spyOn, test } from "bun:test";
+import { act, useState } from "react";
+import { apiClient } from "../../../api-client";
+import { PaneWrapper } from "../../../components/layout/pane";
+import { PaneFooterProvider, type CombinedPaneFooter } from "../../../components/layout/pane/footer";
+import { setSharedMarketDataCoordinator } from "../../../market-data/coordinator";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import { createInitialState, type AppState } from "../../../state/app/context";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { TestPaneProvider, createTestPaneConfig, createTestTicker } from "../../../test-support/pane";
+import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
+import { TICKER_RESEARCH_PANE_ID } from "../../../types/config";
+import type { Quote, TickerFinancials } from "../../../types/financials";
+import { TickerResearchPane } from "./pane";
+
+const paneId = "research:status";
+const asOf = Date.parse("2026-09-11T08:08:00Z");
+const now = Date.parse("2026-09-12T02:00:00Z");
+let setup: Awaited<ReturnType<typeof testRender>> | undefined;
+let update: (change: (state: AppState) => AppState) => void;
+let footer: CombinedPaneFooter;
+
+afterEach(async () => {
+  if (setup) await act(async () => { setup!.renderer.destroy(); });
+  setup = undefined;
+  mock.restore();
+  setSharedMarketDataCoordinator(null);
+});
+
+const quote = (symbol = "9988", stale = true): Quote => ({
+  symbol, price: 107.5, currency: "HKD", change: 0.6, changePercent: 0.56,
+  listingExchangeName: "HKEX", marketState: "CLOSED", dataSource: "delayed", lastUpdated: asOf, stale,
+});
+const financials = (value: Quote): TickerFinancials => ({
+  quote: value, annualStatements: [{ date: "2026-03-31", currency: "CNY", totalRevenue: 1e12 }],
+  quarterlyStatements: [], priceHistory: [],
+});
+
+async function frame() {
+  for (let i = 0; i < 3; i++) await act(async () => { await setup!.renderOnce(); });
+  return setup!.captureCharFrame();
+}
+
+async function render(plan: "free" | "pro", width: number) {
+  spyOn(Date, "now").mockReturnValue(now);
+  spyOn(apiClient, "getCurrentUser").mockReturnValue({ id: "local-status-test", emailVerified: true, plan } as any);
+  spyOn(apiClient, "recordResearchActivity").mockResolvedValue(undefined as any);
+  setSharedMarketDataCoordinator(null);
+  const config = createTestPaneConfig("/unused/status-test", {
+    instanceId: paneId, paneId: TICKER_RESEARCH_PANE_ID, binding: { kind: "fixed", symbol: "9988" },
+    settings: { liveStreaming: false },
+  });
+  const initial = createInitialState(config);
+  for (const symbol of ["9988", "1211"]) {
+    initial.tickers.set(symbol, createTestTicker(symbol, symbol, { exchange: "HKEX", currency: "HKD" }));
+    initial.financials.set(symbol, financials(quote(symbol, symbol === "9988")));
+  }
+  initial.paneState[paneId] = { activeTabId: "overview" };
+  function Harness() {
+    const [state, setState] = useState(initial);
+    update = setState;
+    return <TestPaneProvider state={state} paneId={paneId} pluginId="ticker-research"
+      runtime={createTestPluginRuntime({ getMarketData: () => createTestDataProvider() })}>
+      <PaneFooterProvider>{(value) => {
+        footer = value;
+        return <PaneWrapper title="Research" focused width={width} height={30} footer={value}>
+          <TickerResearchPane paneId={paneId} paneType={TICKER_RESEARCH_PANE_ID} focused width={width} height={28} />
+        </PaneWrapper>;
+      }}</PaneFooterProvider>
+    </TestPaneProvider>;
+  }
+  setup = await testRender(<Harness />, { width, height: 30 });
+  return frame();
+}
+
+async function replaceQuote(value: Quote) {
+  await act(async () => { update((state) => ({ ...state, financials: new Map(state.financials).set("9988", financials(value)) })); });
+  return frame();
+}
+
+for (const plan of ["free", "pro"] as const) for (const width of [48, 80, 120]) {
+  test(`parent footer exposes stale quote and clears after recovery and ticker change: ${plan}/${width}`, async () => {
+    const stale = await render(plan, width);
+    expect(stale).toContain("HK$107.5");
+    expect(stale).toContain("Stale quote");
+    expect(footer.info.filter((segment) => segment.parts.some((part) => part.text.includes("Stale quote")))).toHaveLength(1);
+    if (plan === "pro" || width >= 80) expect(stale).toContain("2026-09-11 08:08Z");
+    expect(stale.match(/\[u\]pgrade/g)?.length ?? 0).toBe(plan === "free" ? 1 : 0);
+    if (plan === "free") expect(footer.info.find((segment) => segment.id === "ticker-research-access")?.onPress).toBeFunction();
+
+    expect(await replaceQuote(quote("9988", false))).not.toContain("Stale quote");
+    expect(await replaceQuote(quote())).toContain("Stale quote");
+    await act(async () => { update((state) => ({ ...state, config: { ...state.config, layout: { ...state.config.layout,
+      instances: state.config.layout.instances.map((instance) => ({ ...instance, binding: { kind: "fixed", symbol: "1211" } })),
+    } } })); });
+    const switched = await frame();
+    expect(switched).toContain("1211");
+    expect(switched).not.toContain("Stale quote");
+    expect(switched).not.toContain("2026-09-11 08:08Z");
+  });
+}
+
+test("unknown source timestamps do not become fabricated dates and nonquote tabs retain their own status", async () => {
+  await render("pro", 80);
+  for (const lastUpdated of [NaN, Infinity, 0, -1, 9e15]) {
+    const result = await replaceQuote({ ...quote(), lastUpdated });
+    expect(result).toContain("Stale quote");
+    expect(result).not.toContain("Invalid Date");
+    expect(result).not.toContain("1970-");
+    expect(footer.info.find((segment) => segment.id === "ticker-research-stale")?.parts).toHaveLength(1);
+  }
+  await act(async () => { update((state) => ({ ...state, paneState: { ...state.paneState, [paneId]: { activeTabId: "financials" } } })); });
+  const financial = await frame();
+  expect(financial).not.toContain("Stale quote");
+  expect(footer.info.some((segment) => segment.id === "ticker-research-stale")).toBe(false);
+});

package/src/plugins/builtin/ticker-detail/quote-time-integrity.test.ts

@@ -0,0 +1,42 @@
+import { expect, spyOn, test } from "bun:test";
+import { AssetDataRouter } from "../../../sources/provider-router";
+import { createTestDataProvider } from "../../../test-support/data-provider";
+import { createDefaultConfig } from "../../../types/config";
+import type { Quote } from "../../../types/financials";
+import { appendLiveQuotePoint } from "../../../time-series/chart-data";
+import { quoteComparisonHeadless } from "./headless";
+
+for (const routed of [false, true]) test(`QM ${routed ? "routed" : "direct"} exports reject invalid quote times without losing healthy peers and recover the actual observation`, async () => {
+  const now = Date.parse("2026-09-12T03:01:00Z");
+  const clock = spyOn(Date, "now").mockReturnValue(now);
+  const sourceTime = Date.parse("2026-09-11T23:59:00Z");
+  const sourceQuote: Quote = Object.freeze({ symbol: "BAD", price: 59.786, currency: "USD", change: 0.486, changePercent: 0.81956,
+    lastUpdated: sourceTime, listingExchangeName: "NASDAQGM", marketState: "POST", dataSource: "delayed" });
+  let lastUpdated: number | null = NaN;
+  const provider = createTestDataProvider({
+    getQuote: async symbol => ({ ...sourceQuote, symbol, lastUpdated: symbol === "GOOD" ? sourceTime : lastUpdated as number }),
+  });
+  const context = { marketData: routed ? new AssetDataRouter(provider) : provider, config: createDefaultConfig("/tmp/quote-time-export-unused"), signal: new AbortController().signal } as any;
+  const args = { symbols: ["BAD", "GOOD"], argument: ["BAD", "GOOD"], rawArgument: "BAD,GOOD", options: {} };
+  try {
+    for (const invalid of [NaN, Infinity, JSON.parse(JSON.stringify(NaN)), now + 60_000]) {
+      lastUpdated = invalid;
+      const model = await quoteComparisonHeadless.load(args, context);
+      const serialized = JSON.parse(JSON.stringify(model));
+      expect(serialized.rows.map((row: any) => row.symbol)).toEqual(["GOOD"]);
+      expect(serialized.unavailableSymbols).toEqual(["BAD"]);
+      expect(serialized.errors.length).toBe(1);
+      const history = [{ date: new Date(sourceTime - 600_000), close: 59 }];
+      expect(appendLiveQuotePoint(history, { ...sourceQuote, lastUpdated: invalid })).toBe(history);
+    }
+    lastUpdated = sourceTime;
+    const recovered = await quoteComparisonHeadless.load(args, context);
+    expect(recovered.rows.map(row => row.symbol)).toEqual(["BAD", "GOOD"]);
+    expect(recovered.unavailableSymbols).toEqual([]);
+    expect(recovered.rows[0]).toMatchObject({ price: 59.786, updatedAt: sourceTime, change: 0.486, currency: "USD" });
+    const history = [{ date: new Date(sourceTime - 600_000), close: 59 }];
+    const appended = appendLiveQuotePoint(history, sourceQuote);
+    expect(appended.at(-1)).toMatchObject({ date: new Date(sourceTime), close: sourceQuote.price });
+    expect(sourceQuote.lastUpdated).toBe(sourceTime);
+  } finally { clock.mockRestore(); }
+});

package/src/plugins/builtin/ticker-research-plugin.ts

@@ -1,11 +1,15 @@
 import { chartComposerModule } from "./chart-composer";
 import { dividendYieldModule } from "./dividend-yield";
+import { executivesModule } from "./executives";
+import { filingEventsModule } from "./filing-events";
 import { holdersModule } from "./holders";
 import { insiderModule } from "./insider";
+import { jobsModule } from "./jobs";
 import { optionsModule } from "./options";
 import { optionsCalculatorModule } from "./options-calculator";
 import { composeBuiltinPlugin } from "./plugin-module";
 import { researchModule } from "./research";
+import { riskFactorsModule } from "./risk-factors";
 import { secModule } from "./sec";
 import { shortInterestModule } from "./short-interest";
 import { thirteenFModule } from "./thirteenf";
@@ -29,5 +33,9 @@ export const tickerResearchPlugin = composeBuiltinPlugin({
     thirteenFModule,
     secModule,
     insiderModule,
+    jobsModule,
+    executivesModule,
+    riskFactorsModule,
+    filingEventsModule,
   ],
 });

package/src/plugins/builtin/treasury-auctions/cache.test.ts

@@ -1,6 +1,8 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { ConnectionHealthRegistry } from "../../../core/connection-health";
 import type { PluginPersistence } from "../../../types/plugin";
+import { MemoryPluginPersistence } from "../../../test-support/plugin-persistence";
+import { fetchAuctionPages } from "./client";
 import {
   attachTreasuryAuctionsPersistence,
   loadTreasuryAuctions,
@@ -38,7 +40,8 @@ function fakePersistence(seed?: { value: TreasuryAuction[]; stale: boolean; expi
     getResource: (_kind: string, _key: string, options?: { allowExpired?: boolean }) => {
       if (!stored) return null;
       if (stored.expired && !options?.allowExpired) return null;
-      return { value: stored.value, fetchedAt: stored.fetchedAt, stale: stored.stale };
+      return { value: stored.value, fetchedAt: stored.fetchedAt, stale: stored.stale,
+        staleAt: stored.stale ? 0 : Date.now() + 60_000, expiresAt: stored.expired ? 0 : Date.now() + 60_000 };
     },
     setResource: (_kind: string, _key: string, value: TreasuryAuction[]) => {
       writes.push(value);
@@ -54,6 +57,45 @@ afterEach(() => {
 });
 
 describe("loadTreasuryAuctions", () => {
+  test("incomplete pagination cannot overwrite a known board or lose its failure on the next read", async () => {
+    const { persistence, writes } = fakePersistence();
+    attachTreasuryAuctionsPersistence(persistence);
+    const original = await loadTreasuryAuctions(false, async () => [auctionFixture("known")]);
+    const failed = await loadTreasuryAuctions(true, () => fetchAuctionPages(async (page) => page === 1
+      ? { data: [{ security_type: "Note", security_term: "2-Year", auction_date: "2026-09-10" }], meta: { "total-pages": 2 } }
+      : { error: "Invalid page envelope" }));
+    const read = await loadTreasuryAuctions(false, async () => { throw new Error("Fresh cached read must not fetch"); });
+    for (const result of [failed, read]) {
+      expect(result.auctions).toEqual(original.auctions);
+      expect(result.fetchedAt).toBe(original.fetchedAt);
+      expect(result.stale).toBe(true);
+      expect(result.refreshError).toContain("page 2");
+    }
+    expect(writes).toHaveLength(1);
+    const recovered = await loadTreasuryAuctions(true, async () => [auctionFixture("recovered")]);
+    expect(recovered.stale).toBe(false);
+    expect(recovered.refreshError).toBeUndefined();
+    expect((await loadTreasuryAuctions(false)).auctions[0]?.id).toBe("recovered");
+  });
+
+  test("legacy potentially truncated history is replaced while a validated cached board remains usable", async () => {
+    const persistence = new MemoryPluginPersistence();
+    persistence.seedResource("treasury-auctions", "recent:120", [auctionFixture("legacy")], {
+      sourceKey: "treasury-fiscal-data", schemaVersion: 2,
+    });
+    persistence.seedResource("treasury-auctions", "recent:30", [auctionFixture("current")], {
+      sourceKey: "treasury-fiscal-data", schemaVersion: 3,
+    });
+    attachTreasuryAuctionsPersistence(persistence);
+    let calls = 0;
+    const loader = async () => { calls++; return [auctionFixture("complete")]; };
+    const replaced = await loadTreasuryAuctions(false, loader, 120);
+    const current = await loadTreasuryAuctions(false, loader, 30);
+    expect(replaced.auctions[0]?.id).toBe("complete");
+    expect(current.auctions[0]?.id).toBe("current");
+    expect(calls).toBe(1);
+  });
+
   test("serves fresh cache without hitting the network", async () => {
     const { persistence } = fakePersistence({ value: [auctionFixture("cached")], stale: false, expired: false });
     attachTreasuryAuctionsPersistence(persistence);

package/src/plugins/builtin/treasury-auctions/cache.ts

@@ -1,3 +1,4 @@
+import { createPluginCache } from "../../../data/plugin-cache";
 import type { ConnectionHealthRegistry } from "../../../core/connection-health";
 import type { PluginPersistence } from "../../../types/plugin";
 import { AUCTION_HISTORY_DAYS, fetchTreasuryAuctions } from "./client";
@@ -5,13 +6,12 @@ import type { TreasuryAuction } from "./types";
 
 const CACHE_KIND = "treasury-auctions";
 const CACHE_SOURCE = "treasury-fiscal-data";
-/** 2: rows carry a CUSIP, so reopenings no longer share an id with the original. */
-const CACHE_SCHEMA_VERSION = 2;
+/** 3: every reported page was validated before this board was cached. */
+const CACHE_SCHEMA_VERSION = 3;
 export const TREASURY_FISCAL_DATA_CONNECTION_ID = "treasury-fiscal-data";
 /**
- * Auctions settle a few times a week and results never change once published,
- * so an hour of freshness is plenty; the week-long expiry is what keeps an
- * offline start usable.
+ * Refresh the auction board hourly; the week-long expiry keeps an offline
+ * start usable without treating the cached observations as a current fetch.
  */
 const CACHE_POLICY = {
   staleMs: 60 * 60 * 1000,
@@ -23,82 +23,44 @@ export interface TreasuryAuctionsResult {
   fetchedAt: number;
   /** True when the network failed and expired cache was served instead. */
   stale: boolean;
+  refreshError?: string;
 }
 
-let persistence: PluginPersistence | null = null;
+const cache = createPluginCache<TreasuryAuction[]>({
+  kind: CACHE_KIND, source: CACHE_SOURCE, schemaVersion: CACHE_SCHEMA_VERSION, policy: CACHE_POLICY,
+  decode: (auctions) => {
+    if (!Array.isArray(auctions)) throw new Error("Invalid cached auctions");
+    return auctions;
+  },
+});
 let connectionHealth: ConnectionHealthRegistry | null = null;
-const activeFetches = new Map<number, Promise<TreasuryAuctionsResult>>();
 
-function cacheKey(sinceDays: number): string {
-  return `recent:${sinceDays}`;
-}
-
-export function attachTreasuryAuctionsPersistence(
-  next: PluginPersistence,
-  health?: ConnectionHealthRegistry,
-): void {
-  persistence = next;
+export function attachTreasuryAuctionsPersistence(next: PluginPersistence, health?: ConnectionHealthRegistry): void {
+  cache.attach(next);
   connectionHealth = health ?? null;
 }
 
 export function resetTreasuryAuctionsPersistence(): void {
-  persistence = null;
+  cache.reset();
   connectionHealth = null;
-  activeFetches.clear();
-}
-
-function readCache(sinceDays: number, options?: { allowExpired?: boolean }): TreasuryAuctionsResult | null {
-  const record = persistence?.getResource<TreasuryAuction[]>(CACHE_KIND, cacheKey(sinceDays), {
-    sourceKey: CACHE_SOURCE,
-    schemaVersion: CACHE_SCHEMA_VERSION,
-    allowExpired: options?.allowExpired,
-  });
-  if (!record || !Array.isArray(record.value)) return null;
-  return { auctions: record.value, fetchedAt: record.fetchedAt, stale: !!record.stale };
 }
 
-/**
- * Serves fresh cache without a request, shares one in-flight fetch across
- * panes, and falls back to whatever is cached (expired included) when the
- * Treasury endpoint is unreachable.
- */
 export async function loadTreasuryAuctions(
   force = false,
   loader: (sinceDays: number) => Promise<TreasuryAuction[]> = fetchTreasuryAuctions,
   sinceDays: number = AUCTION_HISTORY_DAYS,
 ): Promise<TreasuryAuctionsResult> {
-  const cached = readCache(sinceDays);
-  if (!force && cached && !cached.stale) return cached;
-  const inFlight = activeFetches.get(sinceDays);
-  if (inFlight) return inFlight;
-
-  const fallback = cached ?? readCache(sinceDays, { allowExpired: true });
-  const request = () => loader(sinceDays);
-  const fetchPromise = (connectionHealth?.hasSource(TREASURY_FISCAL_DATA_CONNECTION_ID)
-    ? connectionHealth.track(TREASURY_FISCAL_DATA_CONNECTION_ID, "fetchAuctions", request)
-    : request())
-    .then((auctions) => {
-      // Treasury auctions several times a week, so an empty window is a bad
-      // response, never the truth. It is never cached: persisting [] would
-      // serve the bad response back for an hour.
-      if (auctions.length === 0) {
-        if (fallback) return { ...fallback, stale: true };
-        throw new Error("Treasury Fiscal Data returned no auctions");
-      }
-      persistence?.setResource(CACHE_KIND, cacheKey(sinceDays), auctions, {
-        sourceKey: CACHE_SOURCE,
-        schemaVersion: CACHE_SCHEMA_VERSION,
-        cachePolicy: CACHE_POLICY,
-      });
-      return { auctions, fetchedAt: Date.now(), stale: false };
-    })
-    .catch((error: unknown) => {
-      if (fallback) return { ...fallback, stale: true };
-      throw error;
-    })
-    .finally(() => {
-      if (activeFetches.get(sinceDays) === fetchPromise) activeFetches.delete(sinceDays);
-    });
-  activeFetches.set(sinceDays, fetchPromise);
-  return fetchPromise;
+  const result = await cache.load(`recent:${sinceDays}`, async () => {
+    const request = () => loader(sinceDays);
+    const auctions = await (connectionHealth?.hasSource(TREASURY_FISCAL_DATA_CONNECTION_ID)
+      ? connectionHealth.track(TREASURY_FISCAL_DATA_CONNECTION_ID, "fetchAuctions", request)
+      : request());
+    // An empty response is invalid, so it must never replace the last good board.
+    if (auctions.length === 0) throw new Error("Treasury Fiscal Data returned no auctions");
+    return auctions;
+  }, { force });
+  return {
+    auctions: result.data, fetchedAt: result.fetchedAt, stale: result.stale,
+    ...(result.refreshError ? { refreshError: result.refreshError } : {}),
+  };
 }

package/src/plugins/builtin/treasury-auctions/client.test.ts

@@ -164,18 +164,36 @@ describe("fetchAuctionPages", () => {
 
   test("bounded: absurd page metadata cannot walk forever", async () => {
     let calls = 0;
-    await fetchAuctionPages(async (pageNumber) => {
+    await expect(fetchAuctionPages(async (pageNumber) => {
       calls += 1;
       return page([row("10-Year", `2026-0${pageNumber}-12`)], 9_999);
-    });
-    expect(calls).toBe(5);
+    })).rejects.toThrow("page limit");
+    expect(calls).toBe(1);
   });
 
-  test("treats missing or unusable page metadata as a single page", () => {
-    expect(totalPages({ meta: {} })).toBe(1);
-    expect(totalPages({ meta: { "total-pages": "nope" } })).toBe(1);
-    expect(totalPages({ meta: { "total-pages": 0 } })).toBe(1);
-    expect(totalPages(null)).toBe(1);
+  test("rejects incomplete later pages instead of returning the usable prefix", async () => {
+    await expect(fetchAuctionPages(async () => page([], 2))).rejects.toThrow("page 1");
+    for (const invalid of [null, { message: "Unexpected envelope" }, { data: [] }, { data: [null] }]) {
+      await expect(fetchAuctionPages(async (number) => number === 1
+        ? page([row("10-Year", "2026-08-12")], 2)
+        : invalid)).rejects.toThrow("page 2");
+    }
+  });
+
+  test("does not infer complete pagination from missing or malformed declarations", () => {
+    for (const count of [undefined, null, "", "nope", 0, 1.5, "1.5", -1, true, [1], Infinity]) {
+      expect(() => totalPages({ meta: { "total-pages": count } })).toThrow("invalid page count");
+    }
+    expect(() => totalPages(null)).toThrow("invalid page count");
     expect(totalPages({ meta: { "total-pages": 4 } })).toBe(4);
+    expect(totalPages({ meta: { "total-pages": "1" } })).toBe(1);
+  });
+
+  test("a changing page declaration cannot certify the initially declared prefix", async () => {
+    for (const changed of [1, 3]) {
+      await expect(fetchAuctionPages(async (number) => page(
+        [row("10-Year", `2026-08-0${number}`)], number === 1 ? 2 : changed,
+      ))).rejects.toThrow("page count changed");
+    }
   });
 });