gloomberb 0.10.4 → 0.11.0

package/src/plugins/prediction-markets/capability.test.ts

@@ -0,0 +1,281 @@
+import { afterEach, expect, test } from "bun:test";
+import { setHttpFetchTransport } from "../../utils/http-transport";
+import {
+  predictionChartSeriesCapability,
+  predictionHistoryPoints,
+  predictionSeriesId,
+} from "./capability";
+import {
+  attachPredictionMarketsPersistence,
+  resetPredictionMarketsPersistence,
+} from "./services/fetch";
+import { MemoryPersistence } from "./test-helpers";
+import type { PredictionMarketSummary } from "./types";
+
+function json(value: unknown) {
+  return new Response(JSON.stringify(value), { status: 200 });
+}
+
+function identity(overrides: Partial<PredictionMarketSummary>): PredictionMarketSummary {
+  return {
+    venue: "polymarket",
+    marketId: "market-1",
+    eventId: "event-1",
+    ...overrides,
+  } as PredictionMarketSummary;
+}
+
+afterEach(() => {
+  setHttpFetchTransport(null);
+  resetPredictionMarketsPersistence();
+});
+
+test("prediction chart history restores persisted dates, drops invalid rows, and sorts observations", () => {
+  const points = predictionHistoryPoints([
+    { date: "2026-02-02T00:00:00Z" as unknown as Date, close: 0.6 },
+    { date: new Date("invalid"), close: 0.9 },
+    { date: "2026-02-01T00:00:00Z" as unknown as Date, close: 0.4, open: 0.3 },
+  ], "polymarket");
+
+  expect(points.map((point) => [point.date.toISOString(), point.value])).toEqual([
+    ["2026-02-01T00:00:00.000Z", 0.4],
+    ["2026-02-02T00:00:00.000Z", 0.6],
+  ]);
+  expect(points[0]).toMatchObject({ open: 0.3, provenance: { providerId: "polymarket", quality: "reported" } });
+});
+
+test("stable prediction IDs retain provider lookup identity", () => {
+  expect(predictionSeriesId(identity({ venue: "kalshi", eventTicker: "EVT-1", marketId: "MKT-1" })))
+    .toBe("kalshi/EVT-1/MKT-1");
+  expect(predictionSeriesId(identity({ venue: "polymarket", eventId: "123", marketId: "456" })))
+    .toBe("polymarket/123/456");
+  expect(predictionSeriesId(identity({ venue: "polymarket", eventId: undefined }))).toBeNull();
+});
+
+test("catalog limit bounds provider search hydration", async () => {
+  const requested: string[] = [];
+  setHttpFetchTransport(async (url) => {
+    requested.push(url);
+    if (url.includes("public-search")) {
+      return json({ events: Array.from({ length: 5 }, (_, index) => ({ id: `event-${index + 1}` })) });
+    }
+    if (url.includes("gamma-api.polymarket.com/events/event-")) {
+      const eventId = url.split("/").at(-1)!;
+      return json({
+        id: eventId,
+        title: `Rates ${eventId}`,
+        markets: [{
+          id: `market-${eventId}`,
+          question: `Rates ${eventId}`,
+          active: true,
+          closed: false,
+          outcomes: ["Yes", "No"],
+          outcomePrices: ["0.5", "0.5"],
+          clobTokenIds: [`yes-${eventId}`, `no-${eventId}`],
+        }],
+      });
+    }
+    if (url.includes("api.elections.kalshi.com/trade-api/v2/events")) {
+      return json({ events: [] });
+    }
+    throw new Error(`Unexpected URL ${url}`);
+  });
+
+  const items = await predictionChartSeriesCapability.provider.search!({ query: "rates", limit: 2 });
+
+  expect(items).toHaveLength(2);
+  expect(requested.filter((url) => url.includes("gamma-api.polymarket.com/events/event-"))).toHaveLength(2);
+  expect(requested.some((url) => url.includes("api.elections.kalshi.com") && url.includes("limit=20"))).toBe(true);
+});
+
+test("polymarket resolution reloads the event and follows a rotated YES token", async () => {
+  const requested: string[] = [];
+  setHttpFetchTransport(async (url) => {
+    requested.push(url);
+    if (url.endsWith("/events/event-1")) {
+      return json({
+        id: "event-1",
+        title: "Current event",
+        markets: [{
+          id: "market-1",
+          question: "Current market title",
+          active: true,
+          closed: false,
+          outcomes: ["Yes", "No"],
+          outcomePrices: ["0.7", "0.3"],
+          clobTokenIds: ["rotated-yes", "rotated-no"],
+        }],
+      });
+    }
+    if (url.includes("prices-history")) return json({ history: [{ t: 1_700_000_000, p: 0.7 }] });
+    throw new Error(`Unexpected URL ${url}`);
+  });
+
+  const resolved = await predictionChartSeriesCapability.provider.resolve({
+    seriesId: "polymarket/event-1/market-1",
+    viewport: { range: "1M", resolution: "auto" },
+  });
+
+  expect(resolved.label).toBe("Current market title");
+  expect(resolved.points[0]?.value).toBe(0.7);
+  expect(requested.some((url) => url.includes("market=rotated-yes"))).toBe(true);
+});
+
+test("polymarket pans request and cache their bounded history windows", async () => {
+  attachPredictionMarketsPersistence(new MemoryPersistence());
+  const historyRequests: string[] = [];
+  setHttpFetchTransport(async (url) => {
+    if (url.endsWith("/events/event-1")) {
+      return json({
+        id: "event-1",
+        title: "Current event",
+        markets: [{
+          id: "market-1",
+          question: "Current market title",
+          active: true,
+          closed: false,
+          outcomes: ["Yes", "No"],
+          outcomePrices: ["0.7", "0.3"],
+          clobTokenIds: ["yes-token", "no-token"],
+        }],
+      });
+    }
+    if (url.includes("prices-history")) {
+      historyRequests.push(url);
+      const start = Number(new URL(url).searchParams.get("startTs"));
+      return json({ history: [{ t: start + 1, p: 0.7 }] });
+    }
+    throw new Error(`Unexpected URL ${url}`);
+  });
+  const viewport = (start: string, end: string) => ({
+    range: "1W" as const,
+    resolution: "auto" as const,
+    dateWindow: { start, end },
+  });
+  const january = viewport("2026-01-01T00:00:00.000Z", "2026-01-08T00:00:00.000Z");
+  const february = viewport("2026-02-01T00:00:00.000Z", "2026-02-08T00:00:00.000Z");
+
+  await predictionChartSeriesCapability.provider.resolve({
+    seriesId: "polymarket/event-1/market-1",
+    viewport: january,
+  });
+  const panned = await predictionChartSeriesCapability.provider.resolve({
+    seriesId: "polymarket/event-1/market-1",
+    viewport: february,
+  });
+  await predictionChartSeriesCapability.provider.resolve({
+    seriesId: "polymarket/event-1/market-1",
+    viewport: january,
+  });
+
+  expect(historyRequests).toHaveLength(2);
+  expect(historyRequests.map((url) => {
+    const params = new URL(url).searchParams;
+    return [params.get("startTs"), params.get("endTs"), params.get("interval")];
+  })).toEqual([
+    [String(Date.parse(january.dateWindow.start) / 1000), String(Date.parse(january.dateWindow.end) / 1000), null],
+    [String(Date.parse(february.dateWindow.start) / 1000), String(Date.parse(february.dateWindow.end) / 1000), null],
+  ]);
+  expect(panned.points[0]?.date.toISOString()).toBe("2026-02-01T00:00:01.000Z");
+});
+
+test("aborting catalog search stops Polymarket event hydration without caching it", async () => {
+  attachPredictionMarketsPersistence(new MemoryPersistence());
+  let searchRequests = 0;
+  let eventRequests = 0;
+  let markHydrationStarted: (() => void) | undefined;
+  const hydrationStarted = new Promise<void>((resolve) => {
+    markHydrationStarted = resolve;
+  });
+  setHttpFetchTransport(async (url, init) => {
+    if (url.includes("public-search")) {
+      searchRequests += 1;
+      return json({ events: [{ id: "event-1" }] });
+    }
+    if (url.endsWith("/events/event-1")) {
+      eventRequests += 1;
+      if (eventRequests === 1) {
+        markHydrationStarted?.();
+        return await new Promise<Response>((_resolve, reject) => {
+          init?.signal?.addEventListener("abort", () => reject(init.signal?.reason), { once: true });
+        });
+      }
+      return json({
+        id: "event-1",
+        title: "Rates",
+        markets: [{
+          id: "market-1",
+          question: "Rates",
+          active: true,
+          closed: false,
+          outcomes: ["Yes", "No"],
+          outcomePrices: ["0.5", "0.5"],
+          clobTokenIds: ["yes", "no"],
+        }],
+      });
+    }
+    if (url.includes("api.elections.kalshi.com")) return json({ events: [] });
+    throw new Error(`Unexpected URL ${url}`);
+  });
+
+  const controller = new AbortController();
+  const pending = predictionChartSeriesCapability.provider.search!({
+    query: "rates",
+    limit: 1,
+    signal: controller.signal,
+  });
+  await hydrationStarted;
+  controller.abort();
+  await expect(pending).rejects.toMatchObject({ name: "AbortError" });
+
+  const retried = await predictionChartSeriesCapability.provider.search!({ query: "rates", limit: 1 });
+  expect(retried).toHaveLength(1);
+  expect(searchRequests).toBe(2);
+  expect(eventRequests).toBe(2);
+});
+
+test("kalshi resolution reloads the event before requesting current market history", async () => {
+  const requested: string[] = [];
+  setHttpFetchTransport(async (url) => {
+    requested.push(url);
+    if (url.endsWith("/events/EVT-1")) {
+      return json({
+        event: { title: "Current event", event_ticker: "EVT-1", series_ticker: "SERIES-NEW" },
+        markets: [{
+          ticker: "MKT-1",
+          event_ticker: "EVT-1",
+          title: "Current Kalshi market",
+          status: "active",
+          market_type: "binary",
+          last_price_dollars: "0.55",
+        }],
+      });
+    }
+    if (url.includes("/candlesticks")) {
+      return json({ candlesticks: [{ end_period_ts: 1_700_000_000, price: { close_dollars: "0.55" } }] });
+    }
+    throw new Error(`Unexpected URL ${url}`);
+  });
+
+  const resolved = await predictionChartSeriesCapability.provider.resolve({
+    seriesId: "kalshi/EVT-1/MKT-1",
+    viewport: {
+      range: "1W",
+      resolution: "auto",
+      dateWindow: { start: "2026-01-01T00:00:00.000Z", end: "2026-01-08T00:00:00.000Z" },
+    },
+  });
+
+  expect(resolved.label).toBe("Current Kalshi market");
+  expect(requested.some((url) => url.includes("/series/SERIES-NEW/markets/MKT-1/candlesticks"))).toBe(true);
+  expect(requested.some((url) => url.includes("start_ts=1767225600") && url.includes("end_ts=1767830400"))).toBe(true);
+});
+
+test("resolution reports an actionable error when a persisted market disappears", async () => {
+  setHttpFetchTransport(async () => json({ id: "event-1", title: "Current event", markets: [] }));
+
+  await expect(predictionChartSeriesCapability.provider.resolve({
+    seriesId: "polymarket/event-1/missing",
+    viewport: { range: "1M", resolution: "auto" },
+  })).rejects.toThrow("no longer resolvable. Remove or replace this chart series");
+});

package/src/plugins/prediction-markets/capability.ts

@@ -0,0 +1,171 @@
+import { chartSeriesProvider, type ChartSeriesCatalogItem, type ChartSeriesResolveRequest } from "../../capabilities";
+import { debugLog } from "../../utils/debug-log";
+import type { ResolvedSeries, TimeSeriesPoint } from "../../time-series/types";
+import {
+  loadKalshiCatalog,
+  loadKalshiHistory,
+  resolveKalshiChartSummary,
+} from "./services/kalshi/adapter";
+import { loadPolymarketCatalog } from "./services/polymarket/adapter";
+import {
+  loadPolymarketHistory,
+  resolvePolymarketChartSummary,
+} from "./services/polymarket/detail";
+import type { PredictionHistoryPoint, PredictionHistoryRange, PredictionMarketSummary, PredictionVenue } from "./types";
+
+export const PREDICTION_CHART_SERIES_CAPABILITY_ID = "prediction-markets.series";
+const predictionSeriesLog = debugLog.createLogger("prediction-markets.series");
+
+interface PredictionSeriesIdentity {
+  venue: PredictionVenue;
+  eventId: string;
+  marketId: string;
+}
+
+export function predictionSeriesId(summary: PredictionMarketSummary): string | null {
+  const eventId = summary.venue === "kalshi" ? summary.eventTicker : summary.eventId;
+  if (!eventId?.trim() || !summary.marketId.trim()) return null;
+  const id = `${summary.venue}/${encodeURIComponent(eventId)}/${encodeURIComponent(summary.marketId)}`;
+  return id.length <= 240 ? id : null;
+}
+
+function parsePredictionSeriesId(seriesId: string): PredictionSeriesIdentity {
+  const parts = seriesId.split("/");
+  if (parts.length !== 3 || (parts[0] !== "kalshi" && parts[0] !== "polymarket")) {
+    throw new Error(`Prediction series ID ${seriesId} is invalid. Remove and add the series again.`);
+  }
+  try {
+    const eventId = decodeURIComponent(parts[1] ?? "");
+    const marketId = decodeURIComponent(parts[2] ?? "");
+    if (!eventId || !marketId) throw new Error("missing identity");
+    return { venue: parts[0], eventId, marketId };
+  } catch {
+    throw new Error(`Prediction series ID ${seriesId} is invalid. Remove and add the series again.`);
+  }
+}
+
+function historyRange(request: ChartSeriesResolveRequest): PredictionHistoryRange {
+  if (request.viewport.dateWindow) {
+    const span = Date.parse(request.viewport.dateWindow.end) - Date.parse(request.viewport.dateWindow.start);
+    if (span <= 24 * 60 * 60_000) return "1D";
+    if (span <= 7 * 24 * 60 * 60_000) return "1W";
+    if (span <= 31 * 24 * 60 * 60_000) return "1M";
+    return "ALL";
+  }
+  switch (request.viewport.range) {
+    case "1D": return "1D";
+    case "1W": return "1W";
+    case "1M": return "1M";
+    default: return "ALL";
+  }
+}
+
+export function predictionHistoryPoints(points: PredictionHistoryPoint[], venue: string): TimeSeriesPoint[] {
+  return points.flatMap((point) => {
+    const date = point.date instanceof Date ? new Date(point.date) : new Date(point.date as unknown as string);
+    if (!Number.isFinite(date.getTime()) || !Number.isFinite(point.close)) return [];
+    return [{
+      date,
+      observedAt: new Date(date),
+      value: point.close,
+      open: point.open,
+      high: point.high,
+      low: point.low,
+      close: point.close,
+      volume: point.volume,
+      provenance: { providerId: venue, quality: "reported" as const },
+    }];
+  }).sort((left, right) => left.date.getTime() - right.date.getTime());
+}
+
+function catalogItem(summary: PredictionMarketSummary): ChartSeriesCatalogItem | null {
+  const seriesId = predictionSeriesId(summary);
+  if (!seriesId) return null;
+  return {
+    seriesId,
+    label: summary.title.slice(0, 160),
+    description: `${summary.venue === "kalshi" ? "Kalshi" : "Polymarket"} · YES probability`,
+    detail: summary.venue === "kalshi" ? "Kalshi" : "Polymarket",
+    style: "area",
+  };
+}
+
+async function catalog(
+  query = "",
+  limit = 8,
+  signal?: AbortSignal,
+): Promise<ChartSeriesCatalogItem[]> {
+  const providers = [
+    { id: "polymarket", load: () => loadPolymarketCatalog(query, "all", { limit, signal }) },
+    { id: "kalshi", load: () => loadKalshiCatalog(query, "all", { limit, signal }) },
+  ] as const;
+  const results = await Promise.allSettled(providers.map((provider) => provider.load()));
+  if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+  const failures = results.flatMap((result, index) => {
+    if (result.status === "fulfilled") return [];
+    const error = result.reason instanceof Error ? result.reason.message : String(result.reason);
+    predictionSeriesLog.warn("Prediction chart catalog provider failed", {
+      provider: providers[index]?.id,
+      error,
+    });
+    return [`${providers[index]?.id}: ${error}`];
+  });
+  if (failures.length === providers.length) {
+    throw new Error(`Prediction chart catalog failed (${failures.join("; ")}).`);
+  }
+  return results
+    .flatMap((result) => result.status === "fulfilled" ? result.value : [])
+    .sort((left, right) => (right.volume24h ?? 0) - (left.volume24h ?? 0))
+    .flatMap((summary) => {
+      const item = catalogItem(summary);
+      return item ? [item] : [];
+    })
+    .slice(0, limit);
+}
+
+async function resolveCurrentSummary(identity: PredictionSeriesIdentity, signal?: AbortSignal) {
+  return identity.venue === "kalshi"
+    ? resolveKalshiChartSummary(identity.eventId, identity.marketId, signal)
+    : resolvePolymarketChartSummary(identity.eventId, identity.marketId, signal);
+}
+
+export const predictionChartSeriesCapability = chartSeriesProvider({
+  id: PREDICTION_CHART_SERIES_CAPABILITY_ID,
+  name: "Prediction Markets",
+  provider: {
+    catalog: (request) => catalog(request.query, request.limit, request.signal),
+    search: (request) => catalog(request.query, request.limit, request.signal),
+    async resolve(request): Promise<ResolvedSeries> {
+      const identity = parsePredictionSeriesId(request.seriesId);
+      const summary = await resolveCurrentSummary(identity, request.signal);
+      const range = historyRange(request);
+      const dateWindow = request.viewport.dateWindow;
+      const historyOptions = {
+        ...(dateWindow ? {
+          start: new Date(dateWindow.start),
+          end: new Date(dateWindow.end),
+        } : {}),
+        signal: request.signal,
+        strict: true,
+      };
+      const history = summary.venue === "kalshi"
+        ? await loadKalshiHistory(summary, range, historyOptions)
+        : await loadPolymarketHistory(summary, range, historyOptions);
+      return {
+        id: request.seriesId,
+        label: summary.title.slice(0, 160),
+        color: "#4dabf7",
+        unit: "probability",
+        unitGroup: "probability",
+        nativeFrequency: "auto",
+        dataShape: "scalar",
+        style: "area",
+        transform: "raw",
+        axis: "left",
+        panelId: "main",
+        interpolation: "none",
+        points: predictionHistoryPoints(history, summary.venue),
+      };
+    },
+  },
+});

package/src/plugins/prediction-markets/chart.tsx

@@ -1,11 +1,10 @@
 import { Box, Text } from "../../ui";
 import { useMemo } from "react";
-import { TextAttributes } from "../../ui";
+import { Tabs } from "../../components";
 import {
   CompositeChart,
   pricePointsToResolvedSeries,
 } from "../../components/chart/composite";
-import type { ChartMouseEvent } from "../../components/chart/core/pointer";
 import { EmptyState } from "../../components/ui/status";
 import { colors } from "../../theme/colors";
 import { formatNumber, formatPercentRaw } from "../../utils/format";
@@ -40,38 +39,27 @@ function toPricePoints(points: PredictionHistoryPoint[]): PricePoint[] {
   });
 }
 
+const RANGE_TABS = RANGES.map((entry) => ({ label: entry, value: entry }));
+
+/** Shared Tabs so the range picker keeps keyboard navigation, not just clicks. */
 function PredictionRangeTabs({
   activeRange,
+  focused,
   onRangeSelect,
 }: {
   activeRange: PredictionHistoryRange;
+  focused: boolean;
   onRangeSelect: (range: PredictionHistoryRange) => void;
 }) {
   return (
-    <Box flexDirection="row" gap={1}>
-      {RANGES.map((entry) => {
-        const active = entry === activeRange;
-        return (
-          <Box
-            key={entry}
-            onMouseDown={(event: ChartMouseEvent) => {
-              event.preventDefault?.();
-              onRangeSelect(entry);
-            }}
-            cursor="pointer"
-            data-gloom-interactive="true"
-            data-gloom-label={`${entry} prediction history`}
-          >
-            <Text
-              fg={active ? colors.textBright : colors.textDim}
-              attributes={active ? TextAttributes.BOLD : 0}
-            >
-              {entry}
-            </Text>
-          </Box>
-        );
-      })}
-    </Box>
+    <Tabs
+      tabs={RANGE_TABS}
+      activeValue={activeRange}
+      onSelect={(value) => onRangeSelect(value as PredictionHistoryRange)}
+      compact
+      variant="bare"
+      focused={focused}
+    />
   );
 }
 
@@ -80,6 +68,7 @@ export function PredictionMarketChart({
   width,
   height,
   loading = false,
+  focused = false,
   range,
   onRangeSelect,
 }: {
@@ -87,6 +76,7 @@ export function PredictionMarketChart({
   width: number;
   height: number;
   loading?: boolean;
+  focused?: boolean;
   range: PredictionHistoryRange;
   onRangeSelect: (range: PredictionHistoryRange) => void;
 }) {
@@ -98,6 +88,7 @@ export function PredictionMarketChart({
         <Box flexDirection="row" height={1}>
           <PredictionRangeTabs
             activeRange={range}
+            focused={focused}
             onRangeSelect={onRangeSelect}
           />
         </Box>
@@ -135,6 +126,7 @@ export function PredictionMarketChart({
       <Box flexDirection="row" height={1}>
         <PredictionRangeTabs
           activeRange={range}
+          focused={focused}
           onRangeSelect={onRangeSelect}
         />
         <Box flexGrow={1} />

package/src/plugins/prediction-markets/columns.ts

@@ -53,8 +53,10 @@ export const PREDICTION_COLUMN_DEFS: PredictionColumnDef[] = [
   },
   {
     id: "open_interest",
+    // One cell wider than the value needs: OI is right aligned and ENDS is left
+    // aligned, so without the slack the two headers read as one "OI ENDS" word.
     label: "OI",
-    width: 10,
+    width: 11,
     align: "right",
     description: "Open interest.",
   },
@@ -125,7 +127,6 @@ export const DEFAULT_PREDICTION_COLUMN_IDS = [
   "vol_24h",
   "open_interest",
   "ends",
-  "status",
 ];
 
 export const PREDICTION_COLUMNS_BY_ID = new Map(

package/src/plugins/prediction-markets/controller/catalog.ts

@@ -11,6 +11,7 @@ import {
   formatPredictionLoadError,
   getPredictionCatalogStatus,
 } from "./status";
+import { useAutoRefresh } from "../../builtin/shared/auto-refresh";
 import { getCachedPredictionResource } from "../services/fetch";
 import { loadKalshiCatalog } from "../services/kalshi/adapter";
 import { loadPolymarketCatalog } from "../services/polymarket/adapter";
@@ -43,6 +44,8 @@ export function usePredictionCatalogData({
     Record<string, string | null>
   >({});
   const [debouncedSearchQuery, setDebouncedSearchQuery] = useState(searchQuery);
+  const [polymarketLoadedAt, setPolymarketLoadedAt] = useState<number | null>(null);
+  const [kalshiLoadedAt, setKalshiLoadedAt] = useState<number | null>(null);
   const activeCatalogRef = useRef<PredictionCatalogCache>({});
 
   const normalizedCatalogQuery = debouncedSearchQuery.trim().toLowerCase();
@@ -198,6 +201,7 @@ export function usePredictionCatalogData({
           ),
         );
       } finally {
+        setPolymarketLoadedAt(Date.now());
         if (showPending) {
           setCatalogPending((current) =>
             updatePredictionPendingCounts(current, cacheKey, -1),
@@ -248,6 +252,7 @@ export function usePredictionCatalogData({
           ),
         );
       } finally {
+        setKalshiLoadedAt(Date.now());
         if (showPending) {
           setCatalogPending((current) =>
             updatePredictionPendingCounts(current, cacheKey, -1),
@@ -269,6 +274,8 @@ export function usePredictionCatalogData({
     return () => clearTimeout(timeoutId);
   }, [searchQuery]);
 
+  // Reloads follow the one refresh cadence the user configured, instead of two
+  // hardcoded intervals nobody can change.
   useEffect(() => {
     if (!includePolymarket) return;
     void loadPolymarket(
@@ -276,14 +283,6 @@ export function usePredictionCatalogData({
       debouncedSearchQuery,
       categoryId,
     );
-    const intervalId = setInterval(() => {
-      void loadPolymarket(
-        polymarketCatalogKey,
-        debouncedSearchQuery,
-        categoryId,
-      );
-    }, 30_000);
-    return () => clearInterval(intervalId);
   }, [
     categoryId,
     debouncedSearchQuery,
@@ -292,13 +291,13 @@ export function usePredictionCatalogData({
     polymarketCatalogKey,
   ]);
 
+  useAutoRefresh(includePolymarket ? polymarketLoadedAt : null, useCallback(() => {
+    void loadPolymarket(polymarketCatalogKey, debouncedSearchQuery, categoryId);
+  }, [categoryId, debouncedSearchQuery, loadPolymarket, polymarketCatalogKey]));
+
   useEffect(() => {
     if (!includeKalshi) return;
     void loadKalshi(kalshiCatalogKey, debouncedSearchQuery, categoryId);
-    const intervalId = setInterval(() => {
-      void loadKalshi(kalshiCatalogKey, debouncedSearchQuery, categoryId);
-    }, 20_000);
-    return () => clearInterval(intervalId);
   }, [
     categoryId,
     debouncedSearchQuery,
@@ -307,6 +306,10 @@ export function usePredictionCatalogData({
     loadKalshi,
   ]);
 
+  useAutoRefresh(includeKalshi ? kalshiLoadedAt : null, useCallback(() => {
+    void loadKalshi(kalshiCatalogKey, debouncedSearchQuery, categoryId);
+  }, [categoryId, debouncedSearchQuery, kalshiCatalogKey, loadKalshi]));
+
   return {
     allMarkets,
     catalogLoadCount,

package/src/plugins/prediction-markets/controller/detail.ts

@@ -167,7 +167,10 @@ export function usePredictionDetailData({
   }, [focused, loadSelectedDetail, selectedSummaryKey, selectedSummaryVenue]);
 
   useEffect(() => {
+    // Same focus gate as the Kalshi polling above: an unfocused pane must not keep
+    // a live socket open.
     if (
+      !focused ||
       selectedSummaryVenue !== "polymarket" ||
       (!selectedYesTokenId && !selectedNoTokenId) ||
       !selectedSummaryKey
@@ -220,6 +223,7 @@ export function usePredictionDetailData({
       },
     );
   }, [
+    focused,
     selectedNoTokenId,
     selectedSummaryKey,
     selectedSummaryVenue,