@aliou/pi-synthetic 0.11.0 → 0.13.0

package/src/extensions/{command-quotas/sub-integration.ts → sub-bar-integration/index.ts}

@@ -1,4 +1,11 @@
 import type { AuthStorage, ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import {
+  configLoader,
+  SYNTHETIC_CONFIG_UPDATED_EVENT,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticConfigUpdatedPayload,
+} from "../../config";
 import { getSyntheticApiKey } from "../../lib/env";
 import type { QuotasResponse } from "../../types/quotas";
 import { fetchQuotas, formatResetTime } from "../../utils/quotas";
@@ -28,7 +35,6 @@ interface SubCoreSettingsPayload {
 function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
   const windows: RateWindow[] = [];
 
-  // Weekly token limit (credits-based)
   if (quotas.weeklyTokenLimit) {
     const { weeklyTokenLimit } = quotas;
     windows.push({
@@ -41,7 +47,6 @@ function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
     });
   }
 
-  // Rolling 5-hour limit (request-based)
   if (quotas.rollingFiveHourLimit && quotas.rollingFiveHourLimit.max > 0) {
     const { rollingFiveHourLimit } = quotas;
     const used = rollingFiveHourLimit.max - rollingFiveHourLimit.remaining;
@@ -55,7 +60,6 @@ function toUsageSnapshot(quotas: QuotasResponse): UsageSnapshot {
     });
   }
 
-  // Legacy subscription (fallback if rollingFiveHourLimit not available)
   if (
     !quotas.rollingFiveHourLimit &&
     quotas.subscription?.limit &&
@@ -117,15 +121,16 @@ async function emitCurrentUsage(
   });
 }
 
-export function registerSubIntegration(pi: ExtensionAPI): void {
+export function registerSubBarIntegration(pi: ExtensionAPI): void {
   let interval: NodeJS.Timeout | undefined;
   let refreshMs = 60000;
   let subCoreReady = false;
   let currentProvider: string | undefined;
   let currentAuthStorage: AuthStorage | undefined;
+  let enabled = configLoader.getConfig().subBarIntegration;
 
   function isSynthetic(): boolean {
-    return currentProvider === "synthetic";
+    return enabled && currentProvider === "synthetic";
   }
 
   function stop(): void {
@@ -148,24 +153,33 @@ export function registerSubIntegration(pi: ExtensionAPI): void {
     interval.unref?.();
   }
 
-  // Custom events (inter-extension bus)
+  pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    enabled = (data as SyntheticConfigUpdatedPayload).config.subBarIntegration;
+
+    if (!enabled) {
+      stop();
+      return;
+    }
+
+    if (subCoreReady && currentAuthStorage && currentProvider === "synthetic") {
+      startPolling(currentAuthStorage);
+    }
+  });
+
   pi.events.on("sub-core:ready", () => {
     subCoreReady = true;
-    // Polling starts in session_start/model_select when provider is synthetic
   });
 
   pi.events.on("sub-core:settings:updated", (data: unknown) => {
     const payload = data as SubCoreSettingsPayload;
     if (payload.settings?.behavior?.refreshInterval) {
       refreshMs = payload.settings.behavior.refreshInterval * 1000;
-      // Restart with new interval if currently running
       if (interval && isSynthetic() && currentAuthStorage) {
         startPolling(currentAuthStorage);
       }
     }
   });
 
-  // Lifecycle events
   pi.on("session_start", async (_event, ctx) => {
     currentProvider = ctx.model?.provider;
     currentAuthStorage = ctx.modelRegistry.authStorage;
@@ -200,3 +214,14 @@ export function registerSubIntegration(pi: ExtensionAPI): void {
     stop();
   });
 }
+
+export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+  registerSubBarIntegration(pi);
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, {
+      feature: "subBarIntegration",
+    });
+  });
+}

package/src/extensions/usage-status/index.ts

@@ -0,0 +1,245 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import {
+  configLoader,
+  SYNTHETIC_CONFIG_UPDATED_EVENT,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticConfigUpdatedPayload,
+} from "../../config";
+import { getSyntheticApiKey } from "../../lib/env";
+import type { QuotasResponse } from "../../types/quotas";
+import { fetchQuotas, formatResetTime } from "../../utils/quotas";
+import {
+  assessWindow,
+  getSeverityColor,
+  type RiskSeverity,
+  toWindows,
+} from "../../utils/quotas-severity";
+
+const EXTENSION_ID = "synthetic-usage";
+const REFRESH_INTERVAL_MS = 60_000;
+
+type WindowStatus = {
+  label: string;
+  usedPercent: number;
+  severity: RiskSeverity;
+  resetsAt: string | null;
+  limited: boolean;
+};
+
+function parseSnapshot(quotas: QuotasResponse): WindowStatus[] {
+  const windows = toWindows(quotas);
+  return windows.map((w) => {
+    const assessment = assessWindow(w);
+    return {
+      label: w.label,
+      usedPercent: w.usedPercent,
+      severity: assessment.severity,
+      resetsAt: w.resetsAt.toISOString(),
+      limited: w.limited ?? false,
+    };
+  });
+}
+
+const SHORT_LABELS: Record<string, string> = {
+  "Credits / week": "week",
+  "Requests / 5h": "5h",
+  "Search / hour": "search",
+  "Free Tool Calls / day": "tools",
+};
+
+function formatStatus(ctx: ExtensionContext, windows: WindowStatus[]): string {
+  const theme = ctx.ui.theme;
+  const parts: string[] = [];
+
+  for (const w of windows) {
+    const short = SHORT_LABELS[w.label] ?? w.label;
+    const remaining = Math.max(
+      0,
+      Math.min(100, Math.round(100 - w.usedPercent)),
+    );
+    const color = getSeverityColor(w.severity);
+    const pctText = theme.fg(color, `${remaining}%`);
+    const reset = w.resetsAt
+      ? theme.fg("dim", ` (\u21ba${formatResetTime(w.resetsAt)})`)
+      : "";
+    const limitTag = w.limited ? theme.fg("error", " [limited]") : "";
+    parts.push(`${theme.fg("dim", `${short}:`)}${pctText}${reset}${limitTag}`);
+  }
+
+  return parts.join(" ");
+}
+
+function createStatusRefresher() {
+  let refreshTimer: ReturnType<typeof setInterval> | undefined;
+  let activeContext: ExtensionContext | undefined;
+  let isRefreshInFlight = false;
+  let queuedRefresh = false;
+  let lastSnapshot: WindowStatus[] | undefined;
+
+  async function updateFooterStatus(ctx: ExtensionContext): Promise<void> {
+    if (!ctx.hasUI) return;
+    if (isRefreshInFlight) {
+      queuedRefresh = true;
+      return;
+    }
+    isRefreshInFlight = true;
+    try {
+      const apiKey = await getSyntheticApiKey(ctx.modelRegistry.authStorage);
+      if (!apiKey) {
+        lastSnapshot = undefined;
+        ctx.ui.setStatus(EXTENSION_ID, undefined);
+        return;
+      }
+      const result = await fetchQuotas(apiKey);
+      if (!result.success) {
+        ctx.ui.setStatus(
+          EXTENSION_ID,
+          ctx.ui.theme.fg("warning", "usage unavailable"),
+        );
+        return;
+      }
+      const windows = parseSnapshot(result.data.quotas);
+      lastSnapshot = windows;
+      if (windows.length === 0) {
+        ctx.ui.setStatus(EXTENSION_ID, undefined);
+        return;
+      }
+      ctx.ui.setStatus(EXTENSION_ID, formatStatus(ctx, windows));
+    } catch {
+      ctx.ui.setStatus(
+        EXTENSION_ID,
+        ctx.ui.theme.fg("warning", "usage unavailable"),
+      );
+    } finally {
+      isRefreshInFlight = false;
+      if (queuedRefresh) {
+        queuedRefresh = false;
+        void updateFooterStatus(ctx);
+      }
+    }
+  }
+
+  function refreshFor(ctx: ExtensionContext): Promise<void> {
+    activeContext = ctx;
+    return updateFooterStatus(ctx);
+  }
+
+  function startAutoRefresh(): void {
+    if (refreshTimer) clearInterval(refreshTimer);
+    refreshTimer = setInterval(() => {
+      if (!activeContext) return;
+      void updateFooterStatus(activeContext);
+    }, REFRESH_INTERVAL_MS);
+    refreshTimer.unref?.();
+  }
+
+  function stopAutoRefresh(ctx?: ExtensionContext): void {
+    if (refreshTimer) {
+      clearInterval(refreshTimer);
+      refreshTimer = undefined;
+    }
+    ctx?.ui.setStatus(EXTENSION_ID, undefined);
+  }
+
+  async function setLoadingStatus(ctx: ExtensionContext): Promise<void> {
+    if (!ctx.hasUI) return;
+    const apiKey = await getSyntheticApiKey(
+      ctx.modelRegistry.authStorage,
+    ).catch(() => undefined);
+    if (!apiKey) {
+      ctx.ui.setStatus(EXTENSION_ID, undefined);
+      return;
+    }
+    ctx.ui.setStatus(EXTENSION_ID, ctx.ui.theme.fg("dim", "loading usage..."));
+  }
+
+  function renderFromLastSnapshot(ctx: ExtensionContext): boolean {
+    if (!ctx.hasUI || !lastSnapshot) return false;
+    ctx.ui.setStatus(EXTENSION_ID, formatStatus(ctx, lastSnapshot));
+    return true;
+  }
+
+  return {
+    refreshFor,
+    startAutoRefresh,
+    stopAutoRefresh,
+    setLoadingStatus,
+    renderFromLastSnapshot,
+  };
+}
+
+export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+
+  const refresher = createStatusRefresher();
+  let enabled = configLoader.getConfig().usageStatus;
+  let currentContext: ExtensionContext | undefined;
+  let currentProvider: string | undefined;
+
+  pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    enabled = (data as SyntheticConfigUpdatedPayload).config.usageStatus;
+
+    if (!enabled) {
+      refresher.stopAutoRefresh(currentContext);
+      return;
+    }
+
+    if (currentContext && currentProvider === "synthetic") {
+      refresher.startAutoRefresh();
+      void refresher.refreshFor(currentContext);
+    }
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
+    if (!enabled || ctx.model?.provider !== "synthetic") return;
+    refresher.startAutoRefresh();
+    await refresher.setLoadingStatus(ctx);
+    await refresher.refreshFor(ctx);
+  });
+
+  pi.on("turn_end", (_event, ctx) => {
+    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
+    if (!enabled || ctx.model?.provider !== "synthetic") return;
+    void refresher.refreshFor(ctx);
+  });
+
+  pi.on("session_switch", (_event, ctx) => {
+    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
+    if (enabled && ctx.model?.provider === "synthetic") {
+      void refresher.refreshFor(ctx);
+    } else {
+      refresher.stopAutoRefresh(ctx);
+    }
+  });
+
+  pi.on("model_select", (_event, ctx) => {
+    currentContext = ctx;
+    currentProvider = ctx.model?.provider;
+    if (enabled && ctx.model?.provider === "synthetic") {
+      refresher.startAutoRefresh();
+      void refresher.refreshFor(ctx);
+    } else {
+      refresher.stopAutoRefresh(ctx);
+    }
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => {
+    currentContext = undefined;
+    currentProvider = undefined;
+    refresher.stopAutoRefresh(ctx);
+  });
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, {
+      feature: "usageStatus",
+    });
+  });
+}

package/src/extensions/web-search/index.ts

@@ -1,6 +1,50 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { registerSyntheticWebSearchTool } from "./tool";
+import {
+  configLoader,
+  SYNTHETIC_CONFIG_UPDATED_EVENT,
+  SYNTHETIC_EXTENSIONS_REGISTER_EVENT,
+  SYNTHETIC_EXTENSIONS_REQUEST_EVENT,
+  type SyntheticConfigUpdatedPayload,
+} from "../../config";
+import {
+  registerSyntheticWebSearchTool,
+  SYNTHETIC_WEB_SEARCH_TOOL,
+} from "./tool";
+
+function syncToolActivation(pi: ExtensionAPI, enabled: boolean): void {
+  const allToolNames = new Set(pi.getAllTools().map((tool) => tool.name));
+  const activeTools = new Set(pi.getActiveTools());
+
+  if (!allToolNames.has(SYNTHETIC_WEB_SEARCH_TOOL)) return;
+
+  if (enabled) {
+    activeTools.add(SYNTHETIC_WEB_SEARCH_TOOL);
+  } else {
+    activeTools.delete(SYNTHETIC_WEB_SEARCH_TOOL);
+  }
+
+  pi.setActiveTools([...activeTools].filter((name) => allToolNames.has(name)));
+}
 
 export default async function (pi: ExtensionAPI) {
+  await configLoader.load();
+
+  let webSearchEnabled = configLoader.getConfig().webSearch;
+
   registerSyntheticWebSearchTool(pi);
+
+  pi.on("session_start", async () => {
+    syncToolActivation(pi, webSearchEnabled);
+  });
+
+  pi.events.on(SYNTHETIC_CONFIG_UPDATED_EVENT, (data: unknown) => {
+    webSearchEnabled = (data as SyntheticConfigUpdatedPayload).config.webSearch;
+    syncToolActivation(pi, webSearchEnabled);
+  });
+
+  pi.events.on(SYNTHETIC_EXTENSIONS_REQUEST_EVENT, () => {
+    pi.events.emit(SYNTHETIC_EXTENSIONS_REGISTER_EVENT, {
+      feature: "webSearch",
+    });
+  });
 }

package/src/extensions/web-search/tool.ts

@@ -9,6 +9,7 @@ import type {
 import { getMarkdownTheme, keyHint } from "@mariozechner/pi-coding-agent";
 import { Container, Markdown, Text } from "@mariozechner/pi-tui";
 import { type Static, Type } from "@sinclair/typebox";
+import { configLoader } from "../../config";
 import { getSyntheticApiKey } from "../../lib/env";
 
 export const SYNTHETIC_WEB_SEARCH_TOOL = "synthetic_web_search" as const;
@@ -59,6 +60,12 @@ export function registerSyntheticWebSearchTool(pi: ExtensionAPI): void {
         details: { query: params.query },
       });
 
+      if (!configLoader.getConfig().webSearch) {
+        throw new Error(
+          "Synthetic web search is disabled. Re-enable it with synthetic:settings or pi config.",
+        );
+      }
+
       const apiKey = await getSyntheticApiKey(ctx.modelRegistry.authStorage);
       if (!apiKey) {
         throw new Error(

package/src/utils/quotas-severity.test.ts

@@ -0,0 +1,278 @@
+import { assert, describe, expect, it } from "vitest";
+import {
+  assessWindow,
+  getPacePercent,
+  getProjectedPercent,
+  getSeverityColor,
+  parseCurrency,
+  type QuotaWindow,
+  safePercent,
+} from "./quotas-severity";
+
+// Helper to create a QuotaWindow with sensible defaults
+function makeWindow(
+  overrides: Partial<QuotaWindow> & Pick<QuotaWindow, "usedPercent">,
+): QuotaWindow {
+  const windowSeconds = overrides.windowSeconds ?? 3600;
+  // resetsAt defaults to 30 minutes from now (50% through a 1h window)
+  const resetsAt =
+    overrides.resetsAt ?? new Date(Date.now() + windowSeconds * 500);
+  return {
+    label: "Test Window",
+    resetsAt,
+    windowSeconds,
+    usedValue: 0,
+    limitValue: 100,
+    ...overrides,
+  };
+}
+
+describe("safePercent", () => {
+  it("returns 0 for zero/invalid limit", () => {
+    expect(safePercent(50, 0)).toBe(0);
+    expect(safePercent(50, -1)).toBe(0);
+    expect(safePercent(50, NaN)).toBe(0);
+    expect(safePercent(NaN, 100)).toBe(0);
+  });
+
+  it("computes correct percentage", () => {
+    expect(safePercent(50, 100)).toBe(50);
+    expect(safePercent(75, 100)).toBe(75);
+    expect(safePercent(1, 3)).toBeCloseTo(33.33);
+  });
+
+  it("clamps to 0-100", () => {
+    expect(safePercent(150, 100)).toBe(100);
+    expect(safePercent(-10, 100)).toBe(0);
+  });
+});
+
+describe("parseCurrency", () => {
+  it("parses dollar amounts", () => {
+    expect(parseCurrency("$1,234.56")).toBe(1234.56);
+    expect(parseCurrency("$10.00")).toBe(10);
+  });
+
+  it("returns 0 for invalid input", () => {
+    expect(parseCurrency("")).toBe(0);
+    expect(parseCurrency("abc")).toBe(0);
+  });
+});
+
+describe("getPacePercent", () => {
+  it("returns null for zero window", () => {
+    const w = makeWindow({ usedPercent: 50, windowSeconds: 0 });
+    expect(getPacePercent(w)).toBeNull();
+  });
+
+  it("returns ~50 for a window 50% elapsed", () => {
+    const w = makeWindow({
+      usedPercent: 50,
+      windowSeconds: 3600,
+      resetsAt: new Date(Date.now() + 1800 * 1000), // 30 min remaining
+    });
+    const pace = getPacePercent(w);
+    assert(pace, "pace should not be null");
+    expect(pace).toBeCloseTo(50, 0);
+  });
+
+  it("clamps to 0-100", () => {
+    const w = makeWindow({
+      usedPercent: 50,
+      windowSeconds: 3600,
+      resetsAt: new Date(Date.now() + 7200 * 1000), // way past
+    });
+    expect(getPacePercent(w)).toBe(0);
+  });
+});
+
+describe("getProjectedPercent", () => {
+  it("returns usedPercent when no pace", () => {
+    expect(getProjectedPercent(42, null)).toBe(42);
+  });
+
+  it("projects based on pace", () => {
+    // 50% used, 25% through window => projected 200%
+    expect(getProjectedPercent(50, 25)).toBe(200);
+  });
+
+  it("uses minimum pace of 5", () => {
+    // Very low pace should not blow up projection
+    expect(getProjectedPercent(1, 0)).toBe(20); // 1 / 5 * 100
+    expect(getProjectedPercent(1, 1)).toBe(20); // clamped to 5
+  });
+});
+
+describe("assessWindow", () => {
+  describe("no pace (showPace: false)", () => {
+    it("returns none for low usage", () => {
+      const w = makeWindow({ usedPercent: 10, showPace: false });
+      expect(assessWindow(w).severity).toBe("none");
+    });
+
+    it("returns warning at 80% projected", () => {
+      const w = makeWindow({ usedPercent: 85, showPace: false });
+      expect(assessWindow(w).severity).toBe("warning");
+    });
+
+    it("returns high at 90% projected", () => {
+      const w = makeWindow({ usedPercent: 92, showPace: false });
+      expect(assessWindow(w).severity).toBe("high");
+    });
+
+    it("returns critical at 100% projected", () => {
+      const w = makeWindow({ usedPercent: 100, showPace: false });
+      expect(assessWindow(w).severity).toBe("critical");
+    });
+
+    it("returns critical for limited window regardless of usage", () => {
+      const w = makeWindow({ usedPercent: 5, showPace: false, limited: true });
+      expect(assessWindow(w).severity).toBe("critical");
+    });
+  });
+
+  describe("with pace (showPace: true)", () => {
+    it("returns none when usage is low and pace is normal", () => {
+      const w = makeWindow({
+        usedPercent: 20,
+        showPace: true,
+        paceScale: 1,
+        windowSeconds: 3600,
+        resetsAt: new Date(Date.now() + 1800 * 1000), // 50% through
+      });
+      expect(assessWindow(w).severity).toBe("none");
+    });
+
+    it("returns warning when projected exceeds warn threshold", () => {
+      // 50% used, 50% through => projected 100%, well above warn at 50% progress (190)
+      // But usedFloor at 50% progress is 20.5, so 50% > 20.5 => passes floor check
+      const w = makeWindow({
+        usedPercent: 50,
+        showPace: true,
+        paceScale: 1,
+        windowSeconds: 3600,
+        resetsAt: new Date(Date.now() + 1800 * 1000),
+      });
+      const result = assessWindow(w);
+      // projected = 50 / 50 * 100 = 100
+      // At 50% progress: warn = 260 - (260-120)*0.5 = 190, high = 232.5, critical = 285
+      // 100 < 190 => none actually. Let me pick better numbers.
+      expect(result.severity).toBe("none");
+    });
+
+    it("returns warning when projected exceeds dynamic warn threshold", () => {
+      // 95% used, 50% through => projected 190%
+      // At 50% progress: warn = 190, so 190 >= 190 => warning
+      // usedFloor at 50% = 20.5, 95 >= 20.5 => passes
+      const w = makeWindow({
+        usedPercent: 95,
+        showPace: true,
+        paceScale: 1,
+        windowSeconds: 3600,
+        resetsAt: new Date(Date.now() + 1800 * 1000),
+      });
+      const result = assessWindow(w);
+      expect(result.severity).toBe("warning");
+    });
+
+    it("uses paceScale to normalize pace", () => {
+      // Weekly window with daily pace: paceScale = 1/7
+      // At 50% through the day (12h), raw pace = 50%, scaled = 50/7 ≈ 7.14%
+      // So progress ≈ 0.0714, projected = 95 / max(5, 7.14) * 100 ≈ 1330%
+      const w = makeWindow({
+        usedPercent: 95,
+        showPace: true,
+        paceScale: 1 / 7,
+        windowSeconds: 7 * 24 * 3600, // 1 week
+        resetsAt: new Date(Date.now() + 6 * 24 * 3600 * 1000), // 6 days remaining
+      });
+      const result = assessWindow(w);
+      // With paceScale applied, projected should be much higher
+      assert(result.pacePercent, "pacePercent should not be null");
+      expect(result.pacePercent).toBeLessThan(15); // scaled down
+      expect(result.projectedPercent).toBeGreaterThan(500);
+      expect(result.severity).toBe("critical");
+    });
+
+    it("does not use pace when showPace is false", () => {
+      // Same timestamps but showPace: false
+      const w = makeWindow({
+        usedPercent: 50,
+        showPace: false,
+        windowSeconds: 5 * 3600,
+        resetsAt: new Date(Date.now() + 2.5 * 3600 * 1000),
+      });
+      const result = assessWindow(w);
+      expect(result.pacePercent).toBeNull();
+      expect(result.progress).toBeNull();
+      // Static thresholds: 50% < 80 => none
+      expect(result.severity).toBe("none");
+    });
+
+    it("suppresses warning when usage is below usedFloor", () => {
+      // Early window: raw pace ~10%, with paceScale=1 => progress=0.1
+      // usedFloor at 10% progress = 33 - (33-8)*0.1 = 33 - 2.5 = 30.5
+      // If used = 15% (< 30.5), projected might exceed warn but floor blocks it
+      const w = makeWindow({
+        usedPercent: 15,
+        showPace: true,
+        paceScale: 1,
+        windowSeconds: 3600,
+        // 10% through: 54 min remaining
+        resetsAt: new Date(Date.now() + 54 * 60 * 1000),
+      });
+      const result = assessWindow(w);
+      // projected = 15 / 10 * 100 = 150, which exceeds warn at 10% progress (246)
+      // But usedFloor = 30.5, and 15 < 30.5 => suppressed
+      expect(result.severity).toBe("none");
+    });
+
+    it("allows warning when usage exceeds usedFloor", () => {
+      // Same timing but higher usage
+      const w = makeWindow({
+        usedPercent: 50,
+        showPace: true,
+        paceScale: 1,
+        windowSeconds: 3600,
+        resetsAt: new Date(Date.now() + 54 * 60 * 1000),
+      });
+      const result = assessWindow(w);
+      // projected = 50 / 10 * 100 = 500
+      // warn at 10% progress = 246, high = 282.5, critical = 357
+      // 500 >= 357 => critical, usedFloor = 30.5, 50 >= 30.5 => passes
+      expect(result.severity).toBe("critical");
+    });
+  });
+
+  describe("limited flag", () => {
+    it("overrides severity to critical even with low usage", () => {
+      const w = makeWindow({
+        usedPercent: 5,
+        showPace: false,
+        limited: true,
+      });
+      expect(assessWindow(w).severity).toBe("critical");
+    });
+
+    it("overrides severity to critical even with pace showing none", () => {
+      const w = makeWindow({
+        usedPercent: 5,
+        showPace: true,
+        paceScale: 1,
+        limited: true,
+        windowSeconds: 3600,
+        resetsAt: new Date(Date.now() + 54 * 60 * 1000),
+      });
+      expect(assessWindow(w).severity).toBe("critical");
+    });
+  });
+});
+
+describe("getSeverityColor", () => {
+  it("maps severity levels to display colors", () => {
+    expect(getSeverityColor("none")).toBe("success");
+    expect(getSeverityColor("warning")).toBe("warning");
+    expect(getSeverityColor("high")).toBe("error");
+    expect(getSeverityColor("critical")).toBe("error");
+  });
+});