@jameslovespancakes/pi-plus 1.0.0 → 1.0.1

package/src/domains/subscriptions/routing.ts

@@ -1,72 +1,72 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { accountProvider, routableProviders, type RoutingMode } from "../../core/accounts/registry.ts";
-
-/**
- * `/routing [standard|optimal] [provider]`
- *
- *   standard  main account first, fall back only when exhausted
- *   optimal   balance across accounts by remaining quota and time to reset
- *
- * With no provider named, the mode is applied to every provider that supports
- * routing. With no mode, the current modes are reported.
- */
-
-const MODES: RoutingMode[] = ["standard", "optimal"];
-
-function isMode(value: string): value is RoutingMode {
-  return (MODES as string[]).includes(value);
-}
-
-export function registerRoutingCommands(pi: ExtensionAPI): void {
-  pi.registerCommand("routing", {
-    description: "Account routing: standard (main first) or optimal (quota balanced)",
-    getArgumentCompletions: (prefix) =>
-      MODES.filter((mode) => mode.startsWith(prefix)).map((mode) => ({
-        value: mode,
-        label: mode === "optimal" ? "optimal: balance by remaining quota" : "standard: main account first",
-      })),
-    handler: async (args, ctx) => {
-      const [first, second] = args.trim().toLowerCase().split(/\s+/).filter(Boolean);
-      const providers = second ? [accountProvider(second)].filter((entry) => !!entry) : routableProviders();
-
-      if (providers.length === 0) {
-        ctx.ui.notify(
-          second ? `“${second}” does not support account routing.` : "No providers support account routing.",
-          "warning",
-        );
-        return;
-      }
-
-      // No mode given: report current state.
-      if (!first) {
-        const lines: string[] = [];
-        for (const provider of providers) {
-          try {
-            const mode = await provider.routing!.get();
-            lines.push(`${provider.label} (${provider.id}): ${mode}`, `  ${provider.routing!.describe(mode)}`);
-          } catch (error) {
-            lines.push(`${provider.label}: ${error instanceof Error ? error.message : String(error)}`);
-          }
-        }
-        ctx.ui.notify(lines.join("\n"), "info");
-        return;
-      }
-
-      if (!isMode(first)) {
-        ctx.ui.notify(`Usage: /routing [standard|optimal] [provider]`, "warning");
-        return;
-      }
-
-      const results: string[] = [];
-      for (const provider of providers) {
-        try {
-          const mode = await provider.routing!.set(first);
-          results.push(`${provider.label}: ${mode}`, `  ${provider.routing!.describe(mode)}`);
-        } catch (error) {
-          results.push(`${provider.label}: failed, ${error instanceof Error ? error.message : String(error)}`);
-        }
-      }
-      ctx.ui.notify(results.join("\n"), "info");
-    },
-  });
-}
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { accountProvider, routableProviders, type RoutingMode } from "../../core/accounts/registry.ts";
+
+/**
+ * `/routing [standard|optimal] [provider]`
+ *
+ *   standard  main account first, fall back only when exhausted
+ *   optimal   balance across accounts by remaining quota and time to reset
+ *
+ * With no provider named, the mode is applied to every provider that supports
+ * routing. With no mode, the current modes are reported.
+ */
+
+const MODES: RoutingMode[] = ["standard", "optimal"];
+
+function isMode(value: string): value is RoutingMode {
+  return (MODES as string[]).includes(value);
+}
+
+export function registerRoutingCommands(pi: ExtensionAPI): void {
+  pi.registerCommand("routing", {
+    description: "Account routing: standard (main first) or optimal (quota balanced)",
+    getArgumentCompletions: (prefix) =>
+      MODES.filter((mode) => mode.startsWith(prefix)).map((mode) => ({
+        value: mode,
+        label: mode === "optimal" ? "optimal: balance by remaining quota" : "standard: main account first",
+      })),
+    handler: async (args, ctx) => {
+      const [first, second] = args.trim().toLowerCase().split(/\s+/).filter(Boolean);
+      const providers = second ? [accountProvider(second)].filter((entry) => !!entry) : routableProviders();
+
+      if (providers.length === 0) {
+        ctx.ui.notify(
+          second ? `“${second}” does not support account routing.` : "No providers support account routing.",
+          "warning",
+        );
+        return;
+      }
+
+      // No mode given: report current state.
+      if (!first) {
+        const lines: string[] = [];
+        for (const provider of providers) {
+          try {
+            const mode = await provider.routing!.get();
+            lines.push(`${provider.label} (${provider.id}): ${mode}`, `  ${provider.routing!.describe(mode)}`);
+          } catch (error) {
+            lines.push(`${provider.label}: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        ctx.ui.notify(lines.join("\n"), "info");
+        return;
+      }
+
+      if (!isMode(first)) {
+        ctx.ui.notify(`Usage: /routing [standard|optimal] [provider]`, "warning");
+        return;
+      }
+
+      const results: string[] = [];
+      for (const provider of providers) {
+        try {
+          const mode = await provider.routing!.set(first);
+          results.push(`${provider.label}: ${mode}`, `  ${provider.routing!.describe(mode)}`);
+        } catch (error) {
+          results.push(`${provider.label}: failed, ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      ctx.ui.notify(results.join("\n"), "info");
+    },
+  });
+}

package/src/services/usage-service.ts

@@ -1,186 +1,186 @@
-import { agentPath, readJson, writeJson } from "../core/store.ts";
-import { isClaudeAccount, type UsageRow } from "../core/quota/pool.ts";
-import { fetchAll } from "../core/quota/usage-source.ts";
-
-/**
- * The single owner of subscription usage state.
- *
- * Previously the only poller lived inside the footer extension and was gated on
- * `ctx.hasUI`, so `list_models` silently read empty rows whenever the footer was
- * hidden or the session was headless (including every workflow subagent).
- * Consumers now call `ensureFresh()` for on-demand data and `subscribe()` for
- * push updates; only one poll is ever in flight regardless of consumer count.
- */
-
-export const REFRESH_MS = 5 * 60 * 1000;
-const MIN_INTERVAL_MS = 90_000;
-const BACKOFF_MS = 10 * 60 * 1000;
-const CACHE_MAX_AGE_MS = 60 * 60 * 1000;
-
-export interface UsageState {
-  rows: UsageRow[];
-  errors: string[];
-  updatedAt?: number;
-  loading: boolean;
-  accounts: number;
-  codexPlan?: string;
-  /**
-   * Last time each account group's quota was observed to drop. This is the only
-   * available proxy for "recently used": providers expose remaining quota but
-   * never report which account served a request.
-   */
-  lastUsedAt?: Record<string, number>;
-}
-
-const state: UsageState = { rows: [], errors: [], loading: true, accounts: 0, lastUsedAt: {} };
-const listeners = new Set<() => void>();
-
-let nextAllowedFetch = 0;
-let inFlight: Promise<void> | undefined;
-let timer: NodeJS.Timeout | undefined;
-let started = false;
-
-function cachePath(): string {
-  return agentPath("usage-bar-cache.json");
-}
-
-/** Seed from the last session so a restart shows figures before the first fetch. */
-function loadCache(): void {
-  const cached = readJson<UsageState | undefined>(cachePath(), undefined);
-  if (!cached || !Array.isArray(cached.rows) || !cached.updatedAt) return;
-  if (Date.now() - cached.updatedAt > CACHE_MAX_AGE_MS) return;
-  state.rows = cached.rows.filter((row) => !row.group.startsWith("Claude pool ×"));
-  state.accounts = cached.accounts ?? 0;
-  state.codexPlan = cached.codexPlan;
-  state.updatedAt = cached.updatedAt;
-  state.lastUsedAt = cached.lastUsedAt ?? {};
-  state.loading = false;
-}
-
-function saveCache(): void {
-  writeJson(cachePath(), {
-    rows: state.rows,
-    accounts: state.accounts,
-    codexPlan: state.codexPlan,
-    updatedAt: state.updatedAt,
-    lastUsedAt: state.lastUsedAt,
-  });
-}
-
-loadCache();
-
-function emit(): void {
-  for (const listener of listeners) {
-    try {
-      listener();
-    } catch { /* a bad subscriber must not break the poll */ }
-  }
-}
-
-/**
- * Stamps an account as recently used when its headline window falls. A rise
- * (quota reset) or an unchanged figure is not a usage signal.
- */
-function recordUsageDrops(fresh: UsageRow[]): void {
-  const previous = new Map(
-    state.rows.filter((row) => row.label === "5h").map((row) => [row.group, row.remaining]),
-  );
-  const stamps = { ...(state.lastUsedAt ?? {}) };
-  for (const row of fresh) {
-    if (row.label !== "5h") continue;
-    const before = previous.get(row.group);
-    if (before !== undefined && row.remaining < before - 0.01) stamps[row.group] = Date.now();
-  }
-  state.lastUsedAt = stamps;
-}
-
-export function usageState(): UsageState {
-  return state;
-}
-
-/**
- * Account groups ordered by most recent observed use, capped at `limit`.
- * Accounts never seen in use fall back to alphabetical, so the list is stable.
- */
-export function recentAccounts(limit: number): string[] {
-  const stamps = state.lastUsedAt ?? {};
-  const groups = [...new Set(state.rows.filter(isClaudeAccount).map((row) => row.group))];
-  return groups
-    .sort((a, b) => (stamps[b] ?? 0) - (stamps[a] ?? 0) || a.localeCompare(b))
-    .slice(0, limit);
-}
-
-/** Notified after every state change. Returns an unsubscribe function. */
-export function subscribe(listener: () => void): () => void {
-  listeners.add(listener);
-  return () => listeners.delete(listener);
-}
-
-/**
- * The endpoints are rate limited, so results are cached and refreshes are
- * throttled. Failures keep the previous figures on screen.
- */
-export async function refreshUsage(ctx: any, force = false): Promise<void> {
-  if (inFlight) return inFlight;
-  const now = Date.now();
-  const dueAt = Math.max(nextAllowedFetch, (state.updatedAt ?? 0) + MIN_INTERVAL_MS);
-  if (!force && state.updatedAt && now < dueAt) return;
-
-  inFlight = (async () => {
-    try {
-      const result = await fetchAll(ctx);
-      const rateLimited = result.errors.some((error) => error.includes("429"));
-      recordUsageDrops(result.rows);
-
-      // Per-account merge: groups that failed this cycle keep their last figures.
-      const freshGroups = new Set(result.rows.map((row) => row.group));
-      const retained = state.rows
-        .filter((row) => !row.group.startsWith("Claude pool ×")
-          && !freshGroups.has(row.group)
-          && (!isClaudeAccount(row) || result.groups.includes(row.group)))
-        .map((row) => ({ ...row, stale: true }));
-
-      state.rows = [...result.rows, ...retained];
-      state.accounts = result.groups.length;
-      state.updatedAt = Date.now(); // poll time only; rows retain their own checkedAt
-      state.errors = result.errors;
-      if (result.codexPlan !== undefined) state.codexPlan = result.codexPlan;
-      nextAllowedFetch = rateLimited ? Date.now() + BACKOFF_MS : 0;
-      saveCache();
-    } catch (error) {
-      state.errors = [`Usage refresh failed: ${error instanceof Error ? error.message : String(error)}`];
-    } finally {
-      state.loading = false;
-    }
-  })().finally(() => {
-    inFlight = undefined;
-    emit();
-  });
-
-  return inFlight;
-}
-
-/**
- * Guarantees usable data for a caller that does not own the poll loop.
- * This is what makes `list_models` correct in headless sessions.
- */
-export async function ensureFresh(ctx: any): Promise<UsageState> {
-  const stale = !state.updatedAt || Date.now() - state.updatedAt > REFRESH_MS;
-  if (stale) await refreshUsage(ctx);
-  return state;
-}
-
-/** Starts the shared interval. Safe to call from multiple domains. */
-export function startPolling(ctx: any): void {
-  if (started) return;
-  started = true;
-  void refreshUsage(ctx);
-  timer ??= setInterval(() => void refreshUsage(ctx), REFRESH_MS);
-  timer.unref?.();
-}
-
-export function stopPolling(): void {
-  if (timer) clearInterval(timer);
-  timer = undefined;
-  started = false;
-}
+import { agentPath, readJson, writeJson } from "../core/store.ts";
+import { isClaudeAccount, type UsageRow } from "../core/quota/pool.ts";
+import { fetchAll } from "../core/quota/usage-source.ts";
+
+/**
+ * The single owner of subscription usage state.
+ *
+ * Previously the only poller lived inside the footer extension and was gated on
+ * `ctx.hasUI`, so `list_models` silently read empty rows whenever the footer was
+ * hidden or the session was headless (including every workflow subagent).
+ * Consumers now call `ensureFresh()` for on-demand data and `subscribe()` for
+ * push updates; only one poll is ever in flight regardless of consumer count.
+ */
+
+export const REFRESH_MS = 5 * 60 * 1000;
+const MIN_INTERVAL_MS = 90_000;
+const BACKOFF_MS = 10 * 60 * 1000;
+const CACHE_MAX_AGE_MS = 60 * 60 * 1000;
+
+export interface UsageState {
+  rows: UsageRow[];
+  errors: string[];
+  updatedAt?: number;
+  loading: boolean;
+  accounts: number;
+  codexPlan?: string;
+  /**
+   * Last time each account group's quota was observed to drop. This is the only
+   * available proxy for "recently used": providers expose remaining quota but
+   * never report which account served a request.
+   */
+  lastUsedAt?: Record<string, number>;
+}
+
+const state: UsageState = { rows: [], errors: [], loading: true, accounts: 0, lastUsedAt: {} };
+const listeners = new Set<() => void>();
+
+let nextAllowedFetch = 0;
+let inFlight: Promise<void> | undefined;
+let timer: NodeJS.Timeout | undefined;
+let started = false;
+
+function cachePath(): string {
+  return agentPath("usage-bar-cache.json");
+}
+
+/** Seed from the last session so a restart shows figures before the first fetch. */
+function loadCache(): void {
+  const cached = readJson<UsageState | undefined>(cachePath(), undefined);
+  if (!cached || !Array.isArray(cached.rows) || !cached.updatedAt) return;
+  if (Date.now() - cached.updatedAt > CACHE_MAX_AGE_MS) return;
+  state.rows = cached.rows.filter((row) => !row.group.startsWith("Claude pool ×"));
+  state.accounts = cached.accounts ?? 0;
+  state.codexPlan = cached.codexPlan;
+  state.updatedAt = cached.updatedAt;
+  state.lastUsedAt = cached.lastUsedAt ?? {};
+  state.loading = false;
+}
+
+function saveCache(): void {
+  writeJson(cachePath(), {
+    rows: state.rows,
+    accounts: state.accounts,
+    codexPlan: state.codexPlan,
+    updatedAt: state.updatedAt,
+    lastUsedAt: state.lastUsedAt,
+  });
+}
+
+loadCache();
+
+function emit(): void {
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch { /* a bad subscriber must not break the poll */ }
+  }
+}
+
+/**
+ * Stamps an account as recently used when its headline window falls. A rise
+ * (quota reset) or an unchanged figure is not a usage signal.
+ */
+function recordUsageDrops(fresh: UsageRow[]): void {
+  const previous = new Map(
+    state.rows.filter((row) => row.label === "5h").map((row) => [row.group, row.remaining]),
+  );
+  const stamps = { ...(state.lastUsedAt ?? {}) };
+  for (const row of fresh) {
+    if (row.label !== "5h") continue;
+    const before = previous.get(row.group);
+    if (before !== undefined && row.remaining < before - 0.01) stamps[row.group] = Date.now();
+  }
+  state.lastUsedAt = stamps;
+}
+
+export function usageState(): UsageState {
+  return state;
+}
+
+/**
+ * Account groups ordered by most recent observed use, capped at `limit`.
+ * Accounts never seen in use fall back to alphabetical, so the list is stable.
+ */
+export function recentAccounts(limit: number): string[] {
+  const stamps = state.lastUsedAt ?? {};
+  const groups = [...new Set(state.rows.filter(isClaudeAccount).map((row) => row.group))];
+  return groups
+    .sort((a, b) => (stamps[b] ?? 0) - (stamps[a] ?? 0) || a.localeCompare(b))
+    .slice(0, limit);
+}
+
+/** Notified after every state change. Returns an unsubscribe function. */
+export function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/**
+ * The endpoints are rate limited, so results are cached and refreshes are
+ * throttled. Failures keep the previous figures on screen.
+ */
+export async function refreshUsage(ctx: any, force = false): Promise<void> {
+  if (inFlight) return inFlight;
+  const now = Date.now();
+  const dueAt = Math.max(nextAllowedFetch, (state.updatedAt ?? 0) + MIN_INTERVAL_MS);
+  if (!force && state.updatedAt && now < dueAt) return;
+
+  inFlight = (async () => {
+    try {
+      const result = await fetchAll(ctx);
+      const rateLimited = result.errors.some((error) => error.includes("429"));
+      recordUsageDrops(result.rows);
+
+      // Per-account merge: groups that failed this cycle keep their last figures.
+      const freshGroups = new Set(result.rows.map((row) => row.group));
+      const retained = state.rows
+        .filter((row) => !row.group.startsWith("Claude pool ×")
+          && !freshGroups.has(row.group)
+          && (!isClaudeAccount(row) || result.groups.includes(row.group)))
+        .map((row) => ({ ...row, stale: true }));
+
+      state.rows = [...result.rows, ...retained];
+      state.accounts = result.groups.length;
+      state.updatedAt = Date.now(); // poll time only; rows retain their own checkedAt
+      state.errors = result.errors;
+      if (result.codexPlan !== undefined) state.codexPlan = result.codexPlan;
+      nextAllowedFetch = rateLimited ? Date.now() + BACKOFF_MS : 0;
+      saveCache();
+    } catch (error) {
+      state.errors = [`Usage refresh failed: ${error instanceof Error ? error.message : String(error)}`];
+    } finally {
+      state.loading = false;
+    }
+  })().finally(() => {
+    inFlight = undefined;
+    emit();
+  });
+
+  return inFlight;
+}
+
+/**
+ * Guarantees usable data for a caller that does not own the poll loop.
+ * This is what makes `list_models` correct in headless sessions.
+ */
+export async function ensureFresh(ctx: any): Promise<UsageState> {
+  const stale = !state.updatedAt || Date.now() - state.updatedAt > REFRESH_MS;
+  if (stale) await refreshUsage(ctx);
+  return state;
+}
+
+/** Starts the shared interval. Safe to call from multiple domains. */
+export function startPolling(ctx: any): void {
+  if (started) return;
+  started = true;
+  void refreshUsage(ctx);
+  timer ??= setInterval(() => void refreshUsage(ctx), REFRESH_MS);
+  timer.unref?.();
+}
+
+export function stopPolling(): void {
+  if (timer) clearInterval(timer);
+  timer = undefined;
+  started = false;
+}

package/src/ui/format.ts

@@ -1,73 +1,73 @@
-/** Presentation helpers with no domain knowledge. */
-
-export function formatTokens(count: number): string {
-  if (count < 1000) return String(count);
-  if (count < 10_000) return `${(count / 1000).toFixed(1)}k`;
-  if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
-  if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
-  return `${Math.round(count / 1_000_000)}M`;
-}
-
-export function sanitize(text: string): string {
-  return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
-}
-
-/** Keep long ids readable by trimming the middle rather than the tail. */
-export function fitId(id: string, width: number): string {
-  if (id.length <= width) return id.padEnd(width);
-  return `${id.slice(0, 12)}…${id.slice(id.length - (width - 13))}`;
-}
-
-export function formatShortReset(resetAt?: number): string {
-  if (!resetAt) return "";
-  const seconds = Math.max(0, Math.round((resetAt - Date.now()) / 1000));
-  if (seconds < 3600) return `${Math.max(1, Math.round(seconds / 60))}m`;
-  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
-  return `${Math.floor(seconds / 86400)}d`;
-}
-
-export function formatReset(resetAt?: number): string {
-  if (!resetAt) return "";
-  const seconds = Math.max(0, Math.round((resetAt - Date.now()) / 1000));
-  if (seconds < 60) return "resets <1m";
-  const days = Math.floor(seconds / 86400);
-  const hours = Math.floor((seconds % 86400) / 3600);
-  const minutes = Math.floor((seconds % 3600) / 60);
-  if (days > 0) return `resets ${days}d ${hours}h`;
-  if (hours > 0) return `resets ${hours}h ${minutes}m`;
-  return `resets ${minutes}m`;
-}
-
-const TRUECOLOR = /truecolor|24bit/i.test(process.env.COLORTERM ?? "") || !!process.env.WT_SESSION;
-
-export function hasTruecolor(): boolean {
-  return TRUECOLOR;
-}
-
-function hslToAnsi(hue: number, saturation: number, lightness: number): string {
-  const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
-  const secondary = chroma * (1 - Math.abs(((hue / 60) % 2) - 1));
-  const match = lightness - chroma / 2;
-  const [r, g, b] = hue < 60 ? [chroma, secondary, 0]
-    : hue < 120 ? [secondary, chroma, 0]
-    : hue < 180 ? [0, chroma, secondary]
-    : hue < 240 ? [0, secondary, chroma]
-    : hue < 300 ? [secondary, 0, chroma]
-    : [chroma, 0, secondary];
-  const to255 = (value: number) => Math.round((value + match) * 255);
-  return `\u001b[38;2;${to255(r)};${to255(g)};${to255(b)}m`;
-}
-
-/** Smooth red (empty) to green (full) ramp for a 0-100 fullness value. */
-export function levelColor(remaining: number): (text: string) => string {
-  const clamped = Math.min(100, Math.max(0, remaining));
-  if (!TRUECOLOR) return (text: string) => text;
-  const hue = 120 * Math.pow(clamped / 100, 1.35);
-  const lightness = clamped <= 12 ? 0.58 : 0.48;
-  const escape = hslToAnsi(hue, 0.85, lightness);
-  return (text: string) => `${escape}${text}\u001b[39m`;
-}
-
-export function themeLevel(remaining: number): "error" | "warning" | "success" {
-  return remaining <= 10 ? "error" : remaining <= 25 ? "warning" : "success";
-}
+/** Presentation helpers with no domain knowledge. */
+
+export function formatTokens(count: number): string {
+  if (count < 1000) return String(count);
+  if (count < 10_000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+  if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+  return `${Math.round(count / 1_000_000)}M`;
+}
+
+export function sanitize(text: string): string {
+  return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+}
+
+/** Keep long ids readable by trimming the middle rather than the tail. */
+export function fitId(id: string, width: number): string {
+  if (id.length <= width) return id.padEnd(width);
+  return `${id.slice(0, 12)}…${id.slice(id.length - (width - 13))}`;
+}
+
+export function formatShortReset(resetAt?: number): string {
+  if (!resetAt) return "";
+  const seconds = Math.max(0, Math.round((resetAt - Date.now()) / 1000));
+  if (seconds < 3600) return `${Math.max(1, Math.round(seconds / 60))}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+
+export function formatReset(resetAt?: number): string {
+  if (!resetAt) return "";
+  const seconds = Math.max(0, Math.round((resetAt - Date.now()) / 1000));
+  if (seconds < 60) return "resets <1m";
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  if (days > 0) return `resets ${days}d ${hours}h`;
+  if (hours > 0) return `resets ${hours}h ${minutes}m`;
+  return `resets ${minutes}m`;
+}
+
+const TRUECOLOR = /truecolor|24bit/i.test(process.env.COLORTERM ?? "") || !!process.env.WT_SESSION;
+
+export function hasTruecolor(): boolean {
+  return TRUECOLOR;
+}
+
+function hslToAnsi(hue: number, saturation: number, lightness: number): string {
+  const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  const secondary = chroma * (1 - Math.abs(((hue / 60) % 2) - 1));
+  const match = lightness - chroma / 2;
+  const [r, g, b] = hue < 60 ? [chroma, secondary, 0]
+    : hue < 120 ? [secondary, chroma, 0]
+    : hue < 180 ? [0, chroma, secondary]
+    : hue < 240 ? [0, secondary, chroma]
+    : hue < 300 ? [secondary, 0, chroma]
+    : [chroma, 0, secondary];
+  const to255 = (value: number) => Math.round((value + match) * 255);
+  return `\u001b[38;2;${to255(r)};${to255(g)};${to255(b)}m`;
+}
+
+/** Smooth red (empty) to green (full) ramp for a 0-100 fullness value. */
+export function levelColor(remaining: number): (text: string) => string {
+  const clamped = Math.min(100, Math.max(0, remaining));
+  if (!TRUECOLOR) return (text: string) => text;
+  const hue = 120 * Math.pow(clamped / 100, 1.35);
+  const lightness = clamped <= 12 ? 0.58 : 0.48;
+  const escape = hslToAnsi(hue, 0.85, lightness);
+  return (text: string) => `${escape}${text}\u001b[39m`;
+}
+
+export function themeLevel(remaining: number): "error" | "warning" | "success" {
+  return remaining <= 10 ? "error" : remaining <= 25 ? "warning" : "success";
+}