gloomberb 0.4.1 → 0.5.0

package/src/plugins/builtin/yield-curve/treasury-data.test.ts

@@ -0,0 +1,212 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import type { PersistedResourceValue } from "../../../types/persistence";
+import type { PluginPersistence } from "../../../types/plugin";
+import {
+  attachYieldCurvePersistence,
+  isInverted,
+  loadYieldCurve,
+  parseYieldPoints,
+  resetYieldCurvePersistence,
+  TREASURY_MATURITIES,
+  YIELD_CURVE_CACHE_POLICY,
+  type YieldPoint,
+} from "./treasury-data";
+
+class MemoryPluginPersistence implements PluginPersistence {
+  private readonly resources = new Map<string, PersistedResourceValue<unknown>>();
+  private readonly state = new Map<string, { schemaVersion: number; value: unknown }>();
+
+  getState<T = unknown>(key: string, options?: { schemaVersion?: number }): T | null {
+    const record = this.state.get(key);
+    if (!record) return null;
+    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) return null;
+    return record.value as T;
+  }
+
+  setState(key: string, value: unknown, options?: { schemaVersion?: number }): void {
+    this.state.set(key, { schemaVersion: options?.schemaVersion ?? 1, value });
+  }
+
+  deleteState(key: string): void {
+    this.state.delete(key);
+  }
+
+  getResource<T = unknown>(
+    kind: string,
+    key: string,
+    options?: { sourceKey?: string; schemaVersion?: number; allowExpired?: boolean },
+  ): PersistedResourceValue<T> | null {
+    const record = this.resources.get(this.resourceKey(kind, key, options?.sourceKey));
+    if (!record) return null;
+    if (options?.schemaVersion != null && record.schemaVersion !== options.schemaVersion) return null;
+    const next = this.withFreshness(record);
+    if (!options?.allowExpired && next.expired) return null;
+    return next as PersistedResourceValue<T>;
+  }
+
+  setResource<T = unknown>(
+    kind: string,
+    key: string,
+    value: T,
+    options: {
+      cachePolicy: { staleMs: number; expireMs: number };
+      sourceKey?: string;
+      schemaVersion?: number;
+      provenance?: unknown;
+    },
+  ): PersistedResourceValue<T> {
+    const now = Date.now();
+    const record: PersistedResourceValue<T> = {
+      value,
+      fetchedAt: now,
+      staleAt: now + options.cachePolicy.staleMs,
+      expiresAt: now + options.cachePolicy.expireMs,
+      sourceKey: options.sourceKey ?? "",
+      schemaVersion: options.schemaVersion ?? 1,
+      provenance: options.provenance,
+      stale: false,
+      expired: false,
+    };
+    this.resources.set(this.resourceKey(kind, key, options.sourceKey), record);
+    return record;
+  }
+
+  deleteResource(kind: string, key: string, options?: { sourceKey?: string }): void {
+    this.resources.delete(this.resourceKey(kind, key, options?.sourceKey));
+  }
+
+  seedResource<T>(
+    kind: string,
+    key: string,
+    value: T,
+    options: { sourceKey?: string; stale?: boolean; expired?: boolean } = {},
+  ): void {
+    const now = Date.now();
+    const record: PersistedResourceValue<T> = {
+      value,
+      fetchedAt: now - 60_000,
+      staleAt: options.stale ? now - 1 : now + YIELD_CURVE_CACHE_POLICY.staleMs,
+      expiresAt: options.expired ? now - 1 : now + YIELD_CURVE_CACHE_POLICY.expireMs,
+      sourceKey: options.sourceKey ?? "",
+      schemaVersion: 1,
+      stale: !!options.stale,
+      expired: !!options.expired,
+    };
+    this.resources.set(this.resourceKey(kind, key, options.sourceKey), record);
+  }
+
+  private resourceKey(kind: string, key: string, sourceKey = ""): string {
+    return `${kind}:${key}:${sourceKey}`;
+  }
+
+  private withFreshness<T>(record: PersistedResourceValue<T>): PersistedResourceValue<T> {
+    const now = Date.now();
+    return {
+      ...record,
+      stale: now >= record.staleAt,
+      expired: now >= record.expiresAt,
+    };
+  }
+}
+
+const SAMPLE_POINTS: YieldPoint[] = [
+  { maturity: "2Y", maturityYears: 2, yield: 4.5 },
+  { maturity: "10Y", maturityYears: 10, yield: 4.3 },
+];
+
+afterEach(() => {
+  resetYieldCurvePersistence();
+});
+
+describe("parseYieldPoints", () => {
+  test("filters out null yields", () => {
+    const points: YieldPoint[] = [
+      { maturity: "2Y", maturityYears: 2, yield: 4.5 },
+      { maturity: "5Y", maturityYears: 5, yield: null },
+      { maturity: "10Y", maturityYears: 10, yield: 4.3 },
+    ];
+    const result = parseYieldPoints(points);
+    expect(result).toHaveLength(2);
+    expect(result[0]!.maturity).toBe("2Y");
+    expect(result[1]!.maturity).toBe("10Y");
+  });
+
+  test("returns empty for all nulls", () => {
+    expect(parseYieldPoints([{ maturity: "2Y", maturityYears: 2, yield: null }])).toEqual([]);
+  });
+});
+
+describe("isInverted", () => {
+  test("detects inverted curve (2Y > 10Y)", () => {
+    const points: YieldPoint[] = [
+      { maturity: "2Y", maturityYears: 2, yield: 5.0 },
+      { maturity: "10Y", maturityYears: 10, yield: 4.3 },
+    ];
+    expect(isInverted(points)).toBe(true);
+  });
+
+  test("normal curve is not inverted", () => {
+    const points: YieldPoint[] = [
+      { maturity: "2Y", maturityYears: 2, yield: 4.0 },
+      { maturity: "10Y", maturityYears: 10, yield: 4.5 },
+    ];
+    expect(isInverted(points)).toBe(false);
+  });
+
+  test("returns false when data is missing", () => {
+    expect(isInverted([])).toBe(false);
+    expect(isInverted([{ maturity: "2Y", maturityYears: 2, yield: 4.0 }])).toBe(false);
+  });
+});
+
+describe("TREASURY_MATURITIES", () => {
+  test("has 10 maturities in ascending order", () => {
+    expect(TREASURY_MATURITIES).toHaveLength(10);
+    for (let i = 1; i < TREASURY_MATURITIES.length; i++) {
+      expect(TREASURY_MATURITIES[i]!.years).toBeGreaterThan(TREASURY_MATURITIES[i - 1]!.years);
+    }
+  });
+});
+
+describe("loadYieldCurve cache", () => {
+  test("uses a fresh plugin resource cache without fetching", async () => {
+    const persistence = new MemoryPluginPersistence();
+    attachYieldCurvePersistence(persistence);
+    persistence.setResource("treasury-yield-curve", "latest", SAMPLE_POINTS, {
+      sourceKey: "fred",
+      cachePolicy: YIELD_CURVE_CACHE_POLICY,
+    });
+    let fetchCalls = 0;
+
+    const points = await loadYieldCurve("key", {
+      fetcher: async () => {
+        fetchCalls += 1;
+        throw new Error("unexpected fetch");
+      },
+    });
+
+    expect(points).toEqual(SAMPLE_POINTS);
+    expect(fetchCalls).toBe(0);
+  });
+
+  test("falls back to stale plugin resource cache when refresh fails", async () => {
+    const persistence = new MemoryPluginPersistence();
+    attachYieldCurvePersistence(persistence);
+    persistence.seedResource("treasury-yield-curve", "latest", SAMPLE_POINTS, {
+      sourceKey: "fred",
+      stale: true,
+    });
+    let fetchCalls = 0;
+
+    const points = await loadYieldCurve("key", {
+      force: true,
+      fetcher: async () => {
+        fetchCalls += 1;
+        throw new Error("offline");
+      },
+    });
+
+    expect(points).toEqual(SAMPLE_POINTS);
+    expect(fetchCalls).toBe(1);
+  });
+});

package/src/plugins/builtin/yield-curve/treasury-data.ts

@@ -0,0 +1,107 @@
+import { fetchFredObservations } from "../econ/fred-client";
+import type { PersistedResourceValue } from "../../../types/persistence";
+import type { PluginPersistence } from "../../../types/plugin";
+
+export interface YieldPoint {
+  maturity: string;      // "1M", "3M", "6M", "1Y", "2Y", "5Y", "7Y", "10Y", "20Y", "30Y"
+  maturityYears: number; // 0.083, 0.25, 0.5, 1, 2, 5, 7, 10, 20, 30
+  yield: number | null;  // percent, e.g., 4.29
+}
+
+export const TREASURY_MATURITIES: Array<{ maturity: string; years: number; seriesId: string }> = [
+  { maturity: "1M",  years: 1/12,  seriesId: "DGS1MO" },
+  { maturity: "3M",  years: 0.25,  seriesId: "DGS3MO" },
+  { maturity: "6M",  years: 0.5,   seriesId: "DGS6MO" },
+  { maturity: "1Y",  years: 1,     seriesId: "DGS1" },
+  { maturity: "2Y",  years: 2,     seriesId: "DGS2" },
+  { maturity: "5Y",  years: 5,     seriesId: "DGS5" },
+  { maturity: "7Y",  years: 7,     seriesId: "DGS7" },
+  { maturity: "10Y", years: 10,    seriesId: "DGS10" },
+  { maturity: "20Y", years: 20,    seriesId: "DGS20" },
+  { maturity: "30Y", years: 30,    seriesId: "DGS30" },
+];
+
+const CACHE_KIND = "treasury-yield-curve";
+const CACHE_KEY = "latest";
+const CACHE_SOURCE = "fred";
+const CACHE_SCHEMA_VERSION = 1;
+
+export const YIELD_CURVE_CACHE_POLICY = {
+  staleMs: 15 * 60 * 1000,
+  expireMs: 7 * 24 * 60 * 60 * 1000,
+} as const;
+
+let yieldCurvePersistence: PluginPersistence | null = null;
+
+export function attachYieldCurvePersistence(persistence: PluginPersistence): void {
+  yieldCurvePersistence = persistence;
+}
+
+export function resetYieldCurvePersistence(): void {
+  yieldCurvePersistence = null;
+}
+
+function readYieldCurveCache(options?: {
+  allowExpired?: boolean;
+}): PersistedResourceValue<YieldPoint[]> | null {
+  return yieldCurvePersistence?.getResource<YieldPoint[]>(CACHE_KIND, CACHE_KEY, {
+    sourceKey: CACHE_SOURCE,
+    schemaVersion: CACHE_SCHEMA_VERSION,
+    allowExpired: options?.allowExpired,
+  }) ?? null;
+}
+
+function writeYieldCurveCache(points: YieldPoint[]): void {
+  yieldCurvePersistence?.setResource(CACHE_KIND, CACHE_KEY, points, {
+    sourceKey: CACHE_SOURCE,
+    schemaVersion: CACHE_SCHEMA_VERSION,
+    cachePolicy: YIELD_CURVE_CACHE_POLICY,
+  });
+}
+
+export async function fetchYieldCurve(apiKey: string): Promise<YieldPoint[]> {
+  const results = await Promise.allSettled(
+    TREASURY_MATURITIES.map(async ({ maturity, years, seriesId }) => {
+      const obs = await fetchFredObservations(apiKey, seriesId, { limit: 1, sortOrder: "desc" });
+      const value = obs[0]?.value ?? null;
+      return { maturity, maturityYears: years, yield: value };
+    }),
+  );
+  return results.map((r, i) => {
+    if (r.status === "fulfilled") return r.value;
+    return { maturity: TREASURY_MATURITIES[i]!.maturity, maturityYears: TREASURY_MATURITIES[i]!.years, yield: null };
+  });
+}
+
+export async function loadYieldCurve(
+  apiKey: string,
+  options?: {
+    force?: boolean;
+    fetcher?: (apiKey: string) => Promise<YieldPoint[]>;
+  },
+): Promise<YieldPoint[]> {
+  const freshCache = readYieldCurveCache();
+  if (!options?.force && freshCache && !freshCache.stale) {
+    return freshCache.value;
+  }
+
+  try {
+    const points = await (options?.fetcher ?? fetchYieldCurve)(apiKey);
+    writeYieldCurveCache(points);
+    return points;
+  } catch (error) {
+    const staleCache = freshCache ?? readYieldCurveCache({ allowExpired: true });
+    if (staleCache) return staleCache.value;
+    throw error;
+  }
+}
+
+export function parseYieldPoints(points: YieldPoint[]): YieldPoint[] {
+  return points.filter((p) => p.yield !== null);
+}
+
+export function isInverted(points: YieldPoint[]): boolean {
+  const y2 = points.find((p) => p.maturity === "2Y")?.yield;
+  const y10 = points.find((p) => p.maturity === "10Y")?.yield;
+  return y2 != null && y10 != null && y2 > y10;
+}

package/src/plugins/catalog.ts

@@ -12,10 +12,21 @@ import { aiPlugin } from "./builtin/ai";
 import { gloomberbCloudPlugin } from "./builtin/chat";
 import { helpPlugin } from "./builtin/help";
 import { comparisonChartPlugin } from "./builtin/comparison-chart";
+import { econCalendarPlugin } from "./builtin/econ";
+import { worldIndicesPlugin } from "./builtin/world-indices";
+import { marketMoversPlugin } from "./builtin/market-movers";
 import { debugPlugin } from "./builtin/debug";
 import { layoutManagerPlugin } from "./builtin/layout-manager";
 import { yahooPlugin } from "./builtin/yahoo";
 import { predictionMarketsPlugin } from "./prediction-markets";
+import { correlationPlugin } from "./builtin/correlation";
+import { analyticsPlugin } from "./builtin/analytics";
+import { insiderPlugin } from "./builtin/insider";
+import { alertsPlugin } from "./builtin/alerts";
+import { fxMatrixPlugin } from "./builtin/fx-matrix";
+import { yieldCurvePlugin } from "./builtin/yield-curve";
+import { sectorsPlugin } from "./builtin/sectors";
+import { earningsPlugin } from "./builtin/earnings";
 
 export interface PluginCatalogEntry {
   plugin: GloomPlugin;
@@ -40,6 +51,17 @@ export const builtinPlugins: GloomPlugin[] = [
   helpPlugin,
   comparisonChartPlugin,
   predictionMarketsPlugin,
+  correlationPlugin,
+  analyticsPlugin,
+  insiderPlugin,
+  econCalendarPlugin,
+  worldIndicesPlugin,
+  marketMoversPlugin,
+  alertsPlugin,
+  fxMatrixPlugin,
+  yieldCurvePlugin,
+  sectorsPlugin,
+  earningsPlugin,
   debugPlugin,
 ];
 

package/src/plugins/gridlock-notification.ts

@@ -0,0 +1,15 @@
+import type { AppNotificationRequest } from "../types/plugin";
+
+export function notifyGridlockComplete(
+  notify: (notification: AppNotificationRequest) => void,
+  onRevert: () => void,
+): void {
+  notify({
+    body: "Retiled all panes",
+    type: "success",
+    action: {
+      label: "Revert",
+      onClick: onRevert,
+    },
+  });
+}

package/src/plugins/ibkr/__snapshots__/trade-tab.test.tsx.snap

@@ -1,11 +1,8 @@
 // Bun Snapshot v1, https://bun.sh/docs/test/snapshots
 
 exports[`renders the compact trade tab layout 1`] = `
-" Trade AMD · Advanced Micro Devices, Inc.                                               
- $199.80  -3.97 · Bid 199.70 · Ask 199.90 · Spd 0.20                                    
-                                                                                        
-  Broker           Account     Net Liq                                                  
-   Paper Gateway    DU123456    —                                                       
+" Trade AMD · Advanced Micro Devices, Inc.        Broker           Account     Net Liq   
+ $199.8  -3.97 · Bid 199.7 · Ask 199.9 · Spd 0.2  Paper Gateway    DU123456    —        
                                                                                         
                                                                                         
   Next Submit order   Ticket Standby   Refresh  r                                       
@@ -31,5 +28,8 @@ exports[`renders the compact trade tab layout 1`] = `
  │  Preview  p  Submit Order  Enter                                                   │ 
  ╰────────────────────────────────────────────────────────────────────────────────────╯ 
                                                                                         
+                                                                                        
+                                                                                        
+                                                                                        
 "
 `;

package/src/plugins/ibkr/index.test.tsx

@@ -111,7 +111,7 @@ function setupIbkrPlugin(config: AppConfig) {
     emit: () => {},
     showWidget: () => {},
     hideWidget: () => {},
-    showToast: (message: string) => { toasts.push(message); },
+    notify: ({ body }: { body: string }) => { toasts.push(body); },
   } satisfies GloomPluginContext;
 
   void ibkrPlugin.setup?.(ctx);

package/src/plugins/ibkr/index.tsx

@@ -20,7 +20,7 @@ let lastSelectedTickerSymbol: string | null = null;
 
 function ensureIbkrTradingProfile(ctx: GloomPluginContext): boolean {
   if (hasIbkrTradingProfiles(ctx.getConfig())) return true;
-  ctx.showToast("Connect a Gateway / TWS IBKR profile first.", { type: "info" });
+  ctx.notify({ body: "Connect a Gateway / TWS IBKR profile first.", type: "info" });
   return false;
 }
 

package/src/plugins/ibkr/trade-tab.tsx

@@ -8,7 +8,8 @@ import { useAppState, usePaneCollection, usePaneInstanceId, usePaneTicker } from
 import { colors, hoverBg } from "../../theme/colors";
 import type { DetailTabProps } from "../../types/plugin";
 import type { BrokerOrderRequest, BrokerOrderType } from "../../types/trading";
-import { formatCurrency, formatNumber } from "../../utils/format";
+import { formatCurrency } from "../../utils/format";
+import { formatMarketPrice, formatMarketQuantity } from "../../utils/market-format";
 import { getBrokerInstance } from "../../utils/broker-instances";
 import { isGatewayConfigured } from "./config";
 import { ChoiceDialog, InputDialog } from "./dialogs";
@@ -401,6 +402,7 @@ export function TradeTab({ focused, width, onCapture }: DetailTabProps) {
           label={label}
           currentValue={currentValue}
           quote={financials?.quote}
+          assetCategory={ticker?.metadata.assetCategory}
         />
       ),
     });
@@ -818,7 +820,7 @@ export function TradeTab({ focused, width, onCapture }: DetailTabProps) {
               )}
             </box>
             <box height={1}>
-              <text fg={colors.textMuted}>{formatQuoteSummary(financials?.quote)}</text>
+              <text fg={colors.textMuted}>{formatQuoteSummary(financials?.quote, { assetCategory: ticker.metadata.assetCategory })}</text>
             </box>
           </box>
 
@@ -946,7 +948,11 @@ export function TradeTab({ focused, width, onCapture }: DetailTabProps) {
               {renderFieldPill({
                 id: "quantity",
                 label: "Qty [q]",
-                value: formatNumber(ticketState.draft.quantity, 0),
+                value: formatMarketQuantity(ticketState.draft.quantity, {
+                  assetCategory: ticker.metadata.assetCategory,
+                  contractSecType: activeContract.secType,
+                  maxWidth: fieldTextWidth,
+                }),
                 widthOverride: orderFieldWidth,
                 onPress: () => {
                   editNumericField("Quantity", ticketState.draft.quantity, (value) => {
@@ -957,7 +963,13 @@ export function TradeTab({ focused, width, onCapture }: DetailTabProps) {
               {showLimit && renderFieldPill({
                 id: "limitPrice",
                 label: "Limit [l]",
-                value: ticketState.draft.limitPrice != null ? ticketState.draft.limitPrice.toFixed(2) : "—",
+                value: ticketState.draft.limitPrice != null
+                  ? formatMarketPrice(ticketState.draft.limitPrice, {
+                    assetCategory: ticker.metadata.assetCategory,
+                    contractSecType: activeContract.secType,
+                    maxWidth: fieldTextWidth,
+                  })
+                  : "—",
                 widthOverride: orderFieldWidth,
                 onPress: () => {
                   editPriceField("Limit Price", ticketState.draft.limitPrice, (value) => {
@@ -968,7 +980,13 @@ export function TradeTab({ focused, width, onCapture }: DetailTabProps) {
               {showStop && renderFieldPill({
                 id: "stopPrice",
                 label: "Stop [x]",
-                value: ticketState.draft.stopPrice != null ? ticketState.draft.stopPrice.toFixed(2) : "—",
+                value: ticketState.draft.stopPrice != null
+                  ? formatMarketPrice(ticketState.draft.stopPrice, {
+                    assetCategory: ticker.metadata.assetCategory,
+                    contractSecType: activeContract.secType,
+                    maxWidth: fieldTextWidth,
+                  })
+                  : "—",
                 widthOverride: orderFieldWidth,
                 onPress: () => {
                   editPriceField("Stop Price", ticketState.draft.stopPrice, (value) => {

package/src/plugins/ibkr/trade-utils.test.ts

@@ -125,7 +125,7 @@ describe("trade-utils", () => {
       bid: 190.2,
       ask: 190.3,
       lastUpdated: Date.now(),
-    })).toContain("Spd 0.10");
+    })).toContain("Spd 0.1");
     expect(formatPreviewSummary(null)).toContain("Preview required before submit");
     expect(formatPreviewSummary({
       initMarginBefore: 12000,

package/src/plugins/ibkr/trade-utils.ts

@@ -5,6 +5,7 @@ import type { TickerRecord } from "../../types/ticker";
 import type { BrokerAccount, BrokerOrderPreview, BrokerOrderType } from "../../types/trading";
 import { colors } from "../../theme/colors";
 import { formatCompact, formatCurrency } from "../../utils/format";
+import { formatMarketPrice, formatMarketPriceWithCurrency, formatSignedMarketPrice, type AssetDisplayContext } from "../../utils/market-format";
 import { getConfiguredIbkrGatewayInstances } from "./instance-selection";
 
 export type TradeTone = "neutral" | "accent" | "positive" | "negative";
@@ -71,13 +72,13 @@ export function formatContractLabel(contract: BrokerContractRef): string {
   return `${base}${suffix}`;
 }
 
-export function formatQuoteSummary(quote?: Quote): string {
+export function formatQuoteSummary(quote?: Quote, formatContext: AssetDisplayContext = {}): string {
   if (!quote) return "No broker quote loaded";
-  const change = `${quote.change >= 0 ? "+" : ""}${quote.change.toFixed(2)}`;
-  const parts = [`${formatCurrency(quote.price, quote.currency)}  ${change}`];
-  if (quote.bid != null) parts.push(`Bid ${quote.bid.toFixed(2)}`);
-  if (quote.ask != null) parts.push(`Ask ${quote.ask.toFixed(2)}`);
-  if (quote.bid != null && quote.ask != null) parts.push(`Spd ${(quote.ask - quote.bid).toFixed(2)}`);
+  const change = formatSignedMarketPrice(quote.change, formatContext);
+  const parts = [`${formatMarketPriceWithCurrency(quote.price, quote.currency, formatContext)}  ${change}`];
+  if (quote.bid != null) parts.push(`Bid ${formatMarketPrice(quote.bid, formatContext)}`);
+  if (quote.ask != null) parts.push(`Ask ${formatMarketPrice(quote.ask, formatContext)}`);
+  if (quote.bid != null && quote.ask != null) parts.push(`Spd ${formatMarketPrice(quote.ask - quote.bid, formatContext)}`);
   return parts.join(" · ");
 }
 

package/src/plugins/ibkr/trading-pane.tsx

@@ -9,6 +9,7 @@ import { colors, priceColor } from "../../theme/colors";
 import type { PaneProps } from "../../types/plugin";
 import type { Quote } from "../../types/financials";
 import { formatCurrency, padTo } from "../../utils/format";
+import { formatMarketPrice, formatMarketQuantity } from "../../utils/market-format";
 import { getBrokerInstance } from "../../utils/broker-instances";
 import { getSharedRegistry } from "../registry";
 import { isGatewayConfigured } from "./config";
@@ -354,12 +355,12 @@ export function TradingPane({ focused, width, height }: PaneProps) {
                 const selected = index === tradeState.selectedOpenOrderIndex;
                 const orderSymbol = order.contract.symbol;
                 const orderQuote = getOrderQuote(orderSymbol);
-                const bidStr = orderQuote?.bid != null ? orderQuote.bid.toFixed(2) : "---";
-                const askStr = orderQuote?.ask != null ? orderQuote.ask.toFixed(2) : "---";
+                const bidStr = orderQuote?.bid != null ? formatMarketPrice(orderQuote.bid, { contractSecType: order.contract.secType, maxWidth: 6 }) : "---";
+                const askStr = orderQuote?.ask != null ? formatMarketPrice(orderQuote.ask, { contractSecType: order.contract.secType, maxWidth: 6 }) : "---";
                 const orderPrice = order.limitPrice != null
-                  ? order.limitPrice.toFixed(2)
+                  ? formatMarketPrice(order.limitPrice, { contractSecType: order.contract.secType, maxWidth: 9 })
                   : order.stopPrice != null
-                    ? order.stopPrice.toFixed(2)
+                    ? formatMarketPrice(order.stopPrice, { contractSecType: order.contract.secType, maxWidth: 9 })
                     : "MKT";
                 return (
                   <box
@@ -379,7 +380,7 @@ export function TradingPane({ focused, width, height }: PaneProps) {
                       {padTo(order.action, 5)}
                       {padTo(order.contract.localSymbol || order.contract.symbol, 14)}
                       {padTo(order.status, 10)}
-                      {padTo(String(order.remaining), 5, "right")}
+                      {padTo(formatMarketQuantity(order.remaining, { contractSecType: order.contract.secType, maxWidth: 5 }), 5, "right")}
                       {" "}
                       {padTo(orderPrice, 9)}
                       {padTo(`B:${bidStr}`, 10)}
@@ -415,9 +416,9 @@ export function TradingPane({ focused, width, height }: PaneProps) {
                   <text fg={priceColor(execution.side.toUpperCase() === "BOT" ? 1 : -1)}>
                     {padTo(execution.side, 5)}
                     {padTo(execution.contract.localSymbol || execution.contract.symbol, 18)}
-                    {padTo(String(execution.shares), 6, "right")}
+                    {padTo(formatMarketQuantity(execution.shares, { contractSecType: execution.contract.secType, maxWidth: 6 }), 6, "right")}
                     {" "}
-                    {execution.price.toFixed(2)}
+                    {formatMarketPrice(execution.price, { contractSecType: execution.contract.secType })}
                   </text>
                 </box>
               ))

package/src/plugins/plugin-runtime.test.tsx

@@ -59,6 +59,8 @@ describe("plugin runtime hooks", () => {
     const listeners = new Map<string, Set<() => void>>();
 
     const runtime: PluginRuntimeAccess = {
+      pinTicker() {},
+      navigateTicker() {},
       subscribeResumeState(pluginId, key, listener) {
         const listenerKey = `${pluginId}:${key}`;
         if (!listeners.has(listenerKey)) listeners.set(listenerKey, new Set());

package/src/plugins/plugin-runtime.tsx

@@ -10,6 +10,8 @@ import {
 import { useAppState, usePaneInstanceId, type PaneRuntimeState } from "../state/app-context";
 
 export interface PluginRuntimeAccess {
+  pinTicker(symbol: string, options?: { floating?: boolean; paneType?: string }): void;
+  navigateTicker(symbol: string): void;
   subscribeResumeState(pluginId: string, key: string, listener: () => void): () => void;
   getResumeState<T = unknown>(pluginId: string, key: string, schemaVersion?: number): T | null;
   setResumeState(pluginId: string, key: string, value: unknown, schemaVersion?: number): void;
@@ -51,6 +53,14 @@ function usePluginRenderContext(): PluginRenderContextValue {
   return context;
 }
 
+export function usePluginTickerActions() {
+  const { runtime } = usePluginRenderContext();
+  return {
+    pinTicker: runtime.pinTicker,
+    navigateTicker: runtime.navigateTicker,
+  };
+}
+
 export function getPluginPaneStateValue<T>(
   paneState: PaneRuntimeState | undefined,
   pluginId: string,

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

@@ -76,6 +76,14 @@ function formatPredictionLoadError(
     return `${venueLabel} is unavailable right now.`;
   }
 
+  if (
+    /socket connection|socket hang up|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|fetch failed|network connection|connection closed/i.test(
+      message,
+    )
+  ) {
+    return `${venueLabel} is unavailable right now.`;
+  }
+
   return `${fallback} ${message}`;
 }
 

package/src/plugins/prediction-markets/detail/shared.tsx

@@ -1,6 +1,5 @@
-import { TextAttributes } from "@opentui/core";
 import { colors } from "../../../theme/colors";
-import { openUrl } from "../../../components/ui/external-link";
+import { ExternalLinkText } from "../../../components/ui/external-link";
 
 export function truncatePredictionText(
   value: string,
@@ -19,10 +18,12 @@ export function SummaryLink({
   maxLength: number;
 }) {
   return (
-    <box height={1} onMouseDown={() => openUrl(url)}>
-      <text fg={colors.textBright} attributes={TextAttributes.UNDERLINE}>
-        {truncatePredictionText(url, maxLength)}
-      </text>
+    <box height={1}>
+      <ExternalLinkText
+        url={url}
+        label={truncatePredictionText(url, maxLength)}
+        color={colors.textBright}
+      />
     </box>
   );
 }