gloomberb 0.10.4 → 0.11.0

package/src/plugins/builtin/credit-conditions/client.test.ts

@@ -0,0 +1,80 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import {
+  attachFredSeriesPersistence,
+  resetFredSeriesPersistence,
+} from "../../../data/fred-series";
+import { MemoryPluginPersistence } from "../../../test-support/plugin-persistence";
+import { loadCreditConditions } from "./client";
+import { CREDIT_SERIES, type CreditSeriesId } from "./model";
+
+function payload(seriesId: CreditSeriesId, count = 3) {
+  return {
+    observations: Array.from({ length: count }, (_, index) => ({
+      date: `2026-07-${String(index + 1).padStart(2, "0")}`,
+      value: 0.8 + index / 100,
+    })),
+    info: {
+      id: seriesId,
+      title: `${seriesId} Option-Adjusted Spread`,
+      units: "Percent",
+      frequency: "Daily, Close",
+      seasonalAdjustment: "Not Seasonally Adjusted",
+      source: "FRED",
+      notes: "",
+    },
+  };
+}
+
+beforeEach(resetFredSeriesPersistence);
+afterEach(resetFredSeriesPersistence);
+
+describe("loadCreditConditions", () => {
+  test("returns available rows and reports partial failures", async () => {
+    const result = await loadCreditConditions(false, async (seriesId) => {
+      if (seriesId !== CREDIT_SERIES[0].seriesId) throw new Error("unavailable");
+      return payload(seriesId);
+    });
+
+    expect(result.rows.map((row) => row.seriesId)).toEqual([CREDIT_SERIES[0].seriesId]);
+    expect(result.errors).toHaveLength(CREDIT_SERIES.length - 1);
+  });
+
+  test("throws when every credit series fails", async () => {
+    await expect(loadCreditConditions(false, async () => {
+      throw new Error("offline");
+    })).rejects.toThrow("offline");
+  });
+
+  test("reuses bounded persisted history across midnight", async () => {
+    const persistence = new MemoryPluginPersistence();
+    attachFredSeriesPersistence(persistence);
+    const originalNow = Date.now;
+    let calls = 0;
+
+    try {
+      Date.now = () => Date.UTC(2026, 7, 18, 23, 58);
+      await loadCreditConditions(false, async (seriesId) => {
+        calls += 1;
+        return payload(seriesId, 60);
+      });
+      expect(persistence.getResource<{ observations: unknown[] }>(
+        "fred-series",
+        `${CREDIT_SERIES[0].seriesId}:limit=45:sort=desc`,
+        { sourceKey: "gloomberb-cloud", schemaVersion: 1 },
+      )?.value.observations).toHaveLength(45);
+
+      resetFredSeriesPersistence();
+      attachFredSeriesPersistence(persistence);
+      Date.now = () => Date.UTC(2026, 7, 19, 0, 2);
+      const cached = await loadCreditConditions(false, async () => {
+        calls += 1;
+        throw new Error("cache miss");
+      });
+
+      expect(calls).toBe(CREDIT_SERIES.length);
+      expect(cached.rows).toHaveLength(CREDIT_SERIES.length);
+    } finally {
+      Date.now = originalNow;
+    }
+  });
+});

package/src/plugins/builtin/credit-conditions/client.ts

@@ -0,0 +1,105 @@
+import { apiClient, type CloudFredSeriesPayload } from "../../../api-client";
+import {
+  getCachedFredSeries,
+  loadCachedFredSeries,
+  type FredSeriesRequest,
+} from "../../../data/fred-series";
+import {
+  CREDIT_SERIES,
+  normalizeCreditSeries,
+  type CreditConditionRow,
+  type CreditSeriesId,
+} from "./model";
+
+export interface CreditConditionsLoadResult {
+  rows: CreditConditionRow[];
+  stale: boolean;
+  errors: string[];
+}
+
+const HISTORY_LIMIT = 45;
+
+type CreditSeriesLoader = (
+  seriesId: CreditSeriesId,
+  options: { limit: number; sortOrder: "desc" },
+) => Promise<CloudFredSeriesPayload>;
+
+function requestFor(seriesId: CreditSeriesId): FredSeriesRequest {
+  return { seriesId, limit: HISTORY_LIMIT, sortOrder: "desc" };
+}
+
+function trimHistory(data: CloudFredSeriesPayload): CloudFredSeriesPayload {
+  return { ...data, observations: data.observations.slice(0, HISTORY_LIMIT) };
+}
+
+export function getCachedCreditConditions(): CreditConditionsLoadResult | null {
+  const rows: CreditConditionRow[] = [];
+  const errors: string[] = [];
+  for (const definition of CREDIT_SERIES) {
+    const cached = getCachedFredSeries(requestFor(definition.seriesId), { allowExpired: true });
+    if (!cached) continue;
+    try {
+      rows.push(normalizeCreditSeries(definition, cached.data, cached.stale));
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return rows.length === 0 ? null : {
+    rows,
+    stale: rows.some((row) => row.stale),
+    errors,
+  };
+}
+
+async function loadSeries(
+  definition: typeof CREDIT_SERIES[number],
+  force: boolean,
+  loader: CreditSeriesLoader,
+) {
+  const request = requestFor(definition.seriesId);
+  const result = await loadCachedFredSeries(
+    request,
+    async () => trimHistory(await loader(definition.seriesId, {
+      limit: HISTORY_LIMIT,
+      sortOrder: "desc",
+    })),
+    { force },
+  );
+  return {
+    row: normalizeCreditSeries(definition, result.data, result.stale),
+    refreshError: result.refreshError,
+  };
+}
+
+export async function loadCreditConditions(
+  force = false,
+  loader: CreditSeriesLoader = (seriesId, options) => apiClient.getCloudFredSeries(seriesId, options),
+): Promise<CreditConditionsLoadResult> {
+  const settled = await Promise.allSettled(
+    CREDIT_SERIES.map((definition) => loadSeries(definition, force, loader)),
+  );
+  const rows: CreditConditionRow[] = [];
+  const errors: string[] = [];
+  settled.forEach((result, index) => {
+    if (result.status === "rejected") {
+      const seriesId = CREDIT_SERIES[index]!.seriesId;
+      errors.push(`${seriesId}: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+      return;
+    }
+    rows.push(result.value.row);
+    if (result.value.refreshError) errors.push(`${result.value.row.seriesId}: ${result.value.refreshError}`);
+  });
+  if (rows.length === 0) throw new Error(summarizeSeriesErrors(errors));
+  return { rows, stale: rows.some((row) => row.stale), errors };
+}
+
+/**
+ * Every series failing is one outage, not six. Joining all of them produced a
+ * message several times wider than the pane, which then got cut mid-word.
+ */
+function summarizeSeriesErrors(errors: readonly string[]): string {
+  if (errors.length === 0) return "Credit spread data unavailable";
+  const reasons = new Set(errors.map((entry) => entry.replace(/^[A-Z0-9]+:\s*/, "")));
+  const reason = reasons.size === 1 ? [...reasons][0]! : `${errors.length} series failed`;
+  return errors.length > 1 ? `${reason} (${errors.length} series)` : reason;
+}

package/src/plugins/builtin/credit-conditions/index.test.tsx

@@ -0,0 +1,111 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { act } from "react";
+import { PaneFooterProvider } from "../../../components/layout/pane/footer";
+import {
+  attachFredSeriesPersistence,
+  resetFredSeriesPersistence,
+  type FredSeriesCacheEntry,
+} from "../../../data/fred-series";
+import { testRender } from "../../../renderers/opentui/test-utils";
+import { MemoryPluginPersistence } from "../../../test-support/plugin-persistence";
+import {
+  AppContext,
+  createInitialState,
+  PaneInstanceProvider,
+} from "../../../state/app/context";
+import { createDefaultConfig } from "../../../types/config";
+import { CREDIT_SERIES, type CreditConditionRow } from "./model";
+import { CreditConditionsPane, moveCreditSelection } from "./index";
+
+let setup: Awaited<ReturnType<typeof testRender>> | undefined;
+
+function entry(seriesId: string, index: number): FredSeriesCacheEntry {
+  return {
+    fetchedAt: Date.now(),
+    stale: false,
+    data: {
+      observations: [
+        { date: "2026-08-17", value: 0.8 + index / 10 },
+        { date: "2026-08-18", value: 0.81 + index / 10 },
+      ],
+      info: {
+        id: seriesId,
+        title: `${seriesId} Option-Adjusted Spread`,
+        units: "Percent",
+        frequency: "Daily, Close",
+        seasonalAdjustment: "Not Seasonally Adjusted",
+        source: "FRED",
+        notes: "",
+      },
+    },
+  };
+}
+
+async function settle() {
+  await act(async () => {
+    for (let index = 0; index < 8; index += 1) {
+      await Promise.resolve();
+      await setup!.renderOnce();
+    }
+  });
+  for (let index = 0; index < 3; index += 1) {
+    await act(async () => {
+      await Promise.resolve();
+      await setup!.renderOnce();
+    });
+  }
+}
+
+beforeEach(() => {
+  resetFredSeriesPersistence();
+  const persistence = new MemoryPluginPersistence();
+  for (const [index, { seriesId }] of CREDIT_SERIES.entries()) {
+    persistence.seedResource(
+      "fred-series",
+      `${seriesId}:limit=45:sort=desc`,
+      entry(seriesId, index).data,
+      { sourceKey: "gloomberb-cloud", schemaVersion: 1 },
+    );
+  }
+  attachFredSeriesPersistence(persistence);
+});
+
+afterEach(async () => {
+  if (setup) {
+    await act(async () => setup?.renderer.destroy());
+    setup = undefined;
+  }
+  resetFredSeriesPersistence();
+});
+
+describe("CreditConditionsPane", () => {
+  test("selects credit rows with keyboard and mouse", async () => {
+    const keyboardRows = CREDIT_SERIES.map((definition) => ({ ...definition }) as CreditConditionRow);
+    expect(moveCreditSelection(keyboardRows, CREDIT_SERIES[5].seriesId, -1)).toBe(CREDIT_SERIES[4].seriesId);
+
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-credit-test"));
+    setup = await testRender(
+      <AppContext value={{ state, dispatch: () => {} }}>
+        <PaneInstanceProvider paneId="credit:test">
+          <PaneFooterProvider>
+            {() => <CreditConditionsPane paneId="credit:test" paneType="credit-conditions" focused width={72} height={18} />}
+          </PaneFooterProvider>
+        </PaneInstanceProvider>
+      </AppContext>,
+      { width: 72, height: 18 },
+    );
+    await settle();
+
+    expect(setup.captureCharFrame()).toContain(`${CREDIT_SERIES[0].seriesId} Option-Adjusted Spread`);
+
+    let mouseSelected = false;
+    for (let row = 3; row < 9 && !mouseSelected; row += 1) {
+      await act(async () => {
+        await setup!.mockMouse.click(2, row);
+        await setup!.renderOnce();
+      });
+      mouseSelected = !setup.captureCharFrame().includes(`${CREDIT_SERIES[0].seriesId} Option-Adjusted Spread`);
+    }
+    expect(mouseSelected).toBe(true);
+  });
+});

package/src/plugins/builtin/credit-conditions/index.tsx

@@ -0,0 +1,227 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, TextAttributes } from "../../../ui";
+import { useShortcut } from "../../../react/input";
+import {
+  Button,
+  DataTableView,
+  EmptyState,
+  Spinner,
+  usePaneFooter,
+  type DataTableCell,
+  type DataTableColumn,
+  type PaneFooterSegment,
+} from "../../../components";
+import { useAutoRefresh } from "../shared/auto-refresh";
+import type { PaneProps } from "../../../types/plugin";
+import { colors } from "../../../theme/colors";
+import type { PluginModule } from "../plugin-module";
+import { getCachedCreditConditions, loadCreditConditions } from "./client";
+import {
+  CREDIT_SERIES,
+  type CreditConditionRow,
+  type CreditSeriesId,
+} from "./model";
+
+type SortId = "label" | "oas" | "change";
+interface Column extends DataTableColumn { id: SortId }
+
+const COLUMNS: readonly Column[] = [
+  { id: "label", label: "INDEX", width: 12, align: "left" },
+  { id: "oas", label: "OAS", width: 10, align: "right" },
+  { id: "change", label: "1D", width: 9, align: "right" },
+];
+
+function formatBp(value: number | null, signed = false): string {
+  if (value == null) return "--";
+  const sign = signed && value > 0 ? "+" : "";
+  return `${sign}${value.toFixed(1)}bp`;
+}
+
+function sortRows(rows: CreditConditionRow[], id: SortId, descending: boolean): CreditConditionRow[] {
+  return [...rows].sort((left, right) => {
+    let comparison = 0;
+    if (id === "label") comparison = left.label.localeCompare(right.label);
+    else if (id === "oas") comparison = left.oasBp - right.oasBp;
+    else comparison = (left.dailyChangeBp ?? -Infinity) - (right.dailyChangeBp ?? -Infinity);
+    return descending ? -comparison : comparison;
+  });
+}
+
+export function moveCreditSelection(
+  rows: CreditConditionRow[],
+  selectedId: CreditSeriesId | null,
+  offset: -1 | 1,
+): CreditSeriesId | null {
+  if (rows.length === 0) return null;
+  const current = Math.max(0, rows.findIndex((row) => row.seriesId === selectedId));
+  return rows[Math.max(0, Math.min(current + offset, rows.length - 1))]!.seriesId;
+}
+
+function renderCell(
+  row: CreditConditionRow,
+  column: Column,
+  _index: number,
+  state: { selected: boolean },
+): DataTableCell {
+  const selected = state.selected ? colors.selectedText : undefined;
+  if (column.id === "label") return { text: row.label, color: selected ?? colors.text, attributes: TextAttributes.BOLD };
+  if (column.id === "oas") return { text: formatBp(row.oasBp), color: selected ?? colors.textBright };
+  return {
+    text: formatBp(row.dailyChangeBp, true),
+    color: selected ?? (row.dailyChangeBp == null
+      ? colors.textDim
+      : row.dailyChangeBp > 0
+        ? colors.negative
+        : row.dailyChangeBp < 0
+          ? colors.positive
+          : colors.textDim),
+  };
+}
+
+export function CreditConditionsPane({ paneId, focused, width, height }: PaneProps) {
+  const [initial] = useState(getCachedCreditConditions);
+  const [rows, setRows] = useState(initial?.rows ?? []);
+  const [selectedId, setSelectedId] = useState<CreditSeriesId | null>(initial?.rows[0]?.seriesId ?? null);
+  const [sort, setSort] = useState<{ id: SortId; descending: boolean }>({ id: "label", descending: false });
+  const [loading, setLoading] = useState(!initial);
+  const [stale, setStale] = useState(initial?.stale ?? false);
+  const [error, setError] = useState<string | null>(initial?.errors[0] ?? null);
+  const [lastUpdated, setLastUpdated] = useState<number | null>(null);
+  const generation = useRef(0);
+
+  const load = useCallback(async (force = false) => {
+    const current = ++generation.current;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await loadCreditConditions(force);
+      if (generation.current !== current) return;
+      setRows(result.rows);
+      setSelectedId((id) => id && result.rows.some((row) => row.seriesId === id) ? id : result.rows[0]?.seriesId ?? null);
+      setStale(result.stale);
+      if (!result.stale) setLastUpdated(Date.now());
+      setError(result.errors[0] ?? null);
+    } catch (loadError) {
+      if (generation.current !== current) return;
+      setError(loadError instanceof Error ? loadError.message : String(loadError));
+    } finally {
+      if (generation.current === current) setLoading(false);
+    }
+  }, []);
+  useEffect(() => { void load(false); }, [load]);
+  const reload = useCallback(() => { void load(true); }, [load]);
+  const refresh = useCallback(() => { void load(false); }, [load]);
+  // The shared FRED cache decides whether a tick actually hits the network, so
+  // the pane can follow the global cadence without refetching daily data.
+  useAutoRefresh(lastUpdated, refresh);
+
+  const sorted = useMemo(() => sortRows(rows, sort.id, sort.descending), [rows, sort]);
+  const selectedRow = rows.find((row) => row.seriesId === selectedId) ?? rows[0] ?? null;
+  const columns = useMemo<Column[]>(() => {
+    const labelWidth = Math.max(12, width - 23);
+    return COLUMNS.map((column) => column.id === "label" ? { ...column, width: labelWidth } : { ...column });
+  }, [width]);
+  const renderRowCell = useCallback((
+    row: CreditConditionRow,
+    column: Column,
+    index: number,
+    state: { selected: boolean },
+  ): DataTableCell => ({
+    ...renderCell(row, column, index, state),
+    onMouseDown: () => setSelectedId(row.seriesId),
+  }), []);
+  useShortcut((event) => {
+    if (!focused) return;
+    if (event.name === "r") {
+      if (loading) return;
+      reload();
+    } else if (["up", "k", "down", "j"].includes(event.name ?? "")) {
+      const offset = event.name === "up" || event.name === "k" ? -1 : 1;
+      setSelectedId(moveCreditSelection(sorted, selectedId, offset));
+    } else {
+      return;
+    }
+    event.preventDefault?.();
+    event.stopPropagation?.();
+  });
+  const partial = rows.length > 0 && rows.length < CREDIT_SERIES.length;
+  const asOf = rows.reduce<string | null>((latest, row) => !latest || row.date > latest ? row.date : latest, null);
+  const footerInfo = useMemo<PaneFooterSegment[]>(() => [
+    ...(asOf ? [{ id: "as-of", parts: [{ text: `as of ${asOf}`, tone: "muted" as const }] }] : []),
+    ...(rows.length > 0 ? [{ id: "delayed", parts: [{ text: "delayed", tone: "muted" as const }] }] : []),
+    ...(partial ? [{ id: "partial", parts: [{ text: `PARTIAL ${rows.length}/${CREDIT_SERIES.length}`, tone: "warning" as const, bold: true }] }] : []),
+    ...(stale ? [{ id: "stale", parts: [{ text: "STALE", tone: "warning" as const }] }] : []),
+    ...(loading ? [{ id: "loading", parts: [{ text: "loading", tone: "muted" as const }] }] : []),
+    ...(error ? [{ id: "error", parts: [{ text: error, tone: "warning" as const }] }] : []),
+  ], [asOf, error, loading, partial, rows.length, stale]);
+  usePaneFooter(paneId, () => ({ info: footerInfo }), [footerInfo, paneId]);
+
+  if (rows.length === 0 && loading) {
+    return (
+      <Box width={width} height={height} justifyContent="center" alignItems="center">
+        <Spinner label="Loading credit spreads..." />
+      </Box>
+    );
+  }
+  if (rows.length === 0) {
+    return (
+      <Box width={width} height={height} padding={1} flexDirection="column" gap={1}>
+        <EmptyState title="Credit spreads unavailable." message={error ?? undefined} />
+      </Box>
+    );
+  }
+
+  const metadata = (
+    <Box height={2} flexDirection="column" paddingX={1}>
+      <Text fg={colors.textMuted}>FRED · option-adjusted spread · daily close</Text>
+      <Text fg={colors.textDim}>{selectedRow?.title ?? ""}</Text>
+    </Box>
+  );
+
+  return (
+    <DataTableView<CreditConditionRow, Column>
+      focused={focused}
+      rootWidth={width}
+      rootHeight={height}
+      rootBefore={metadata}
+      selection={{
+        kind: "id",
+        selectedId,
+        getId: (row) => row.seriesId,
+        onChange: (id) => setSelectedId(id as CreditSeriesId),
+      }}
+      onCursorChange={(row) => setSelectedId(row.seriesId)}
+      columns={columns}
+      items={sorted}
+      sortColumnId={sort.id}
+      sortDirection={sort.descending ? "desc" : "asc"}
+      onHeaderClick={(id) => setSort((current) => ({
+        id: id as SortId,
+        descending: current.id === id ? !current.descending : id !== "label",
+      }))}
+      getItemKey={(row) => row.seriesId}
+      renderCell={renderRowCell}
+      emptyStateTitle={loading ? "Loading credit spreads..." : error ?? "No credit spread data."}
+    />
+  );
+}
+
+export const creditConditionsModule: PluginModule = {
+  panes: [{
+    id: "credit-conditions",
+    name: "Credit Spreads",
+    icon: "C",
+    component: CreditConditionsPane,
+    defaultPosition: "right",
+    defaultMode: "floating",
+    defaultFloatingSize: { width: 72, height: 18 },
+  }],
+  paneTemplates: [{
+    id: "credit-conditions-pane",
+    paneId: "credit-conditions",
+    label: "Credit Spreads",
+    description: "ICE BofA US corporate option-adjusted spreads from FRED.",
+    keywords: ["credit", "spread", "oas", "corporate", "high yield", "investment grade", "macro"],
+    shortcut: { prefix: "CRD" },
+  }],
+};

package/src/plugins/builtin/credit-conditions/model.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { CREDIT_SERIES, normalizeCreditSeries } from "./model";
+
+function payload(overrides: Record<string, unknown> = {}) {
+  return {
+    observations: [
+      { date: "2026-08-17", value: 0.81 },
+      { date: "2026-08-14", value: 0.8 },
+      { date: "2026-08-16", value: null },
+    ],
+    info: {
+      id: "BAMLC0A0CM",
+      title: "ICE BofA US Corporate Index Option-Adjusted Spread",
+      units: "Percent",
+      frequency: "Daily, Close",
+      seasonalAdjustment: "Not Seasonally Adjusted",
+      source: "",
+      notes: "",
+      ...overrides,
+    },
+  };
+}
+
+describe("normalizeCreditSeries", () => {
+  test("converts the official percent OAS to basis points", () => {
+    const row = normalizeCreditSeries(CREDIT_SERIES[0], payload(), true);
+
+    expect(row).toMatchObject({
+      label: "US IG",
+      oasBp: 81,
+      dailyChangeBp: 1,
+      date: "2026-08-17",
+      units: "Percent",
+      frequency: "Daily, Close",
+      stale: true,
+    });
+  });
+
+  test("rejects metadata that would make spread normalization misleading", () => {
+    expect(() => normalizeCreditSeries(CREDIT_SERIES[0], payload({ units: "Index" }))).toThrow("unexpected FRED metadata");
+    expect(() => normalizeCreditSeries(CREDIT_SERIES[0], payload({ title: "Corporate Effective Yield" }))).toThrow("unexpected FRED metadata");
+  });
+});

package/src/plugins/builtin/credit-conditions/model.ts

@@ -0,0 +1,64 @@
+import type { CloudFredSeriesPayload } from "../../../api-client";
+
+export const CREDIT_SERIES = [
+  { seriesId: "BAMLC0A0CM", label: "US IG" },
+  { seriesId: "BAMLC0A1CAAA", label: "AAA" },
+  { seriesId: "BAMLC0A2CAA", label: "AA" },
+  { seriesId: "BAMLC0A3CA", label: "A" },
+  { seriesId: "BAMLC0A4CBBB", label: "BBB" },
+  { seriesId: "BAMLH0A0HYM2", label: "US HY" },
+] as const;
+
+export type CreditSeriesId = typeof CREDIT_SERIES[number]["seriesId"];
+
+export interface CreditConditionRow {
+  seriesId: CreditSeriesId;
+  label: string;
+  title: string;
+  units: string;
+  frequency: string;
+  oasBp: number;
+  dailyChangeBp: number | null;
+  date: string;
+  stale: boolean;
+}
+
+function roundTenth(value: number): number {
+  return Math.round(value * 10) / 10;
+}
+
+export function normalizeCreditSeries(
+  definition: typeof CREDIT_SERIES[number],
+  payload: CloudFredSeriesPayload,
+  stale = false,
+): CreditConditionRow {
+  const info = payload.info;
+  if (!info
+    || info.units.toLowerCase() !== "percent"
+    || !info.frequency.toLowerCase().startsWith("daily")
+    || !info.title.toLowerCase().includes("option-adjusted spread")) {
+    throw new Error(`${definition.seriesId}: unexpected FRED metadata`);
+  }
+
+  const observations = payload.observations
+    .filter((observation): observation is { date: string; value: number } =>
+      /^\d{4}-\d{2}-\d{2}$/.test(observation.date)
+      && observation.value != null
+      && Number.isFinite(observation.value),
+    )
+    .sort((left, right) => left.date.localeCompare(right.date));
+  const latest = observations.at(-1);
+  if (!latest) throw new Error(`${definition.seriesId}: no observations`);
+  const previous = observations.at(-2);
+
+  return {
+    ...definition,
+    title: info.title,
+    units: info.units,
+    frequency: info.frequency,
+    oasBp: roundTenth(latest.value * 100),
+    dailyChangeBp: previous ? roundTenth((latest.value - previous.value) * 100) : null,
+    date: latest.date,
+    stale,
+  };
+}

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

@@ -136,7 +136,7 @@ function DebugPane({ focused, width, height }: PaneProps) {
     }
 
     // Clear
-    if (event.name === "x") {
+    if (event.name === "c") {
       clearLogs();
       return;
     }
@@ -225,14 +225,17 @@ function DebugPane({ focused, width, height }: PaneProps) {
       ...(autoScroll ? [{ id: "auto", parts: [{ text: "AUTO", tone: "muted" as const }] }] : []),
     ],
     hints: [
+      // Every label is the mnemonic suffix of its key, so the footer reads
+      // "[l]evel [s]ource [e]xport [x] clear ..." consistently.
       { id: "level", key: "l", label: "evel", onPress: cycleLevelFilter },
       { id: "source", key: "s", label: "ource", onPress: cycleSourceFilter },
       { id: "export", key: "e", label: "xport", onPress: exportLogs },
-      { id: "clear", key: "x", label: "clear", onPress: clearLogs },
+      { id: "clear", key: "c", label: "lear", onPress: clearLogs },
       { id: "auto", key: "a", label: "uto", onPress: () => setAutoScroll((prev) => !prev) },
-      { id: "jump", key: "g/G", label: "jump", onPress: jumpBottom },
+      { id: "jump-top", key: "g", label: "o to top", onPress: jumpTop },
+      { id: "jump-end", key: "G", label: "o to end", onPress: jumpBottom },
     ],
-  }), [autoScroll, clearLogs, cycleLevelFilter, cycleSourceFilter, exportLogs, filterLevel, filterSource, jumpBottom]);
+  }), [autoScroll, clearLogs, cycleLevelFilter, cycleSourceFilter, exportLogs, filterLevel, filterSource, jumpBottom, jumpTop]);
 
   return (
     <Box flexDirection="column" width={width} height={height}>
@@ -265,9 +268,11 @@ function DebugPane({ focused, width, height }: PaneProps) {
           const ts = formatTimestamp(entry.timestamp);
           const lvl = LEVEL_LABELS[entry.level];
           const sourceTag = entry.source;
-          const maxMsg = Math.max(0, contentWidth - ts.length - lvl.length - sourceTag.length - 8);
+          // Floor of 1: at maxMsg 0 the old slice(0, -1) kept almost the whole
+          // message and only appended an ellipsis.
+          const maxMsg = Math.max(1, contentWidth - ts.length - lvl.length - sourceTag.length - 8);
           const msg = entry.message.length > maxMsg
-            ? entry.message.slice(0, maxMsg - 1) + "…"
+            ? `${entry.message.slice(0, Math.max(0, maxMsg - 1))}…`
             : entry.message;
 
           return (