cc-api-statusline 0.1.3 → 0.1.9

package/dist/cc-api-statusline.js

@@ -1,6 +1,141 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
+// package.json
+var package_default = {
+  name: "cc-api-statusline",
+  version: "0.1.9",
+  description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
+  type: "module",
+  bin: {
+    "cc-api-statusline": "dist/cc-api-statusline.js"
+  },
+  scripts: {
+    start: "bun run src/main.ts --once",
+    dev: "bun run src/main.ts",
+    example: "cat docs/fixtures/ccstatusline-context.sample.json | bun run src/main.ts",
+    test: "bun run build && vitest run",
+    "test:watch": "vitest",
+    lint: "eslint src",
+    build: "bun build src/main.ts --target=node --outfile=dist/cc-api-statusline.js",
+    check: "bun run test && bun run lint",
+    prepublishOnly: "bun run check"
+  },
+  files: [
+    "dist/"
+  ],
+  keywords: [
+    "claude",
+    "statusline",
+    "api",
+    "usage",
+    "monitoring",
+    "tui",
+    "cli"
+  ],
+  author: "Liafonx",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/liafonx/cc-api-statusline.git"
+  },
+  homepage: "https://github.com/liafonx/cc-api-statusline#readme",
+  bugs: {
+    url: "https://github.com/liafonx/cc-api-statusline/issues"
+  },
+  dependencies: {},
+  devDependencies: {
+    "@eslint/js": "^9.17.0",
+    "@types/bun": "^1.1.14",
+    eslint: "^9.17.0",
+    typescript: "^5.7.2",
+    "typescript-eslint": "^8.18.2",
+    vitest: "^2.1.8"
+  },
+  engines: {
+    node: ">=18.0.0"
+  },
+  publishConfig: {
+    provenance: true
+  }
+};
+
+// src/cli/args.ts
+function parseArgs() {
+  const args = process.argv.slice(2);
+  let help = false;
+  let version = false;
+  let once = false;
+  let install = false;
+  let uninstall = false;
+  let force = false;
+  let configPath;
+  let runner;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") {
+      help = true;
+    } else if (arg === "--version" || arg === "-v") {
+      version = true;
+    } else if (arg === "--once") {
+      once = true;
+    } else if (arg === "--install") {
+      install = true;
+    } else if (arg === "--uninstall") {
+      uninstall = true;
+    } else if (arg === "--force") {
+      force = true;
+    } else if (arg === "--config" && i + 1 < args.length) {
+      configPath = args[i + 1];
+      i++;
+    } else if (arg === "--runner" && i + 1 < args.length) {
+      const nextArg = args[i + 1];
+      if (nextArg === "npx" || nextArg === "bunx") {
+        runner = nextArg;
+      }
+      i++;
+    }
+  }
+  return { help, version, once, install, uninstall, force, configPath, runner };
+}
+function showHelp() {
+  console.log(`
+cc-api-statusline — Claude API statusline widget
+
+Usage:
+  cc-api-statusline [options]
+
+Options:
+  --help, -h         Show this help message
+  --version, -v      Show version
+  --once             Fetch once and exit (no polling)
+  --config <path>    Use custom config file
+  --install          Register as Claude Code statusline widget
+  --uninstall        Remove statusline widget registration
+  --runner <runner>  Package runner: npx or bunx (default: auto-detect)
+  --force            Force overwrite existing statusline configuration
+
+Environment Variables:
+  ANTHROPIC_BASE_URL       API endpoint (required)
+  ANTHROPIC_AUTH_TOKEN     API key (required)
+  CC_STATUSLINE_PROVIDER   Override provider detection
+  CC_STATUSLINE_POLL       Override poll interval (seconds)
+  CC_STATUSLINE_TIMEOUT    Piped mode timeout (milliseconds, default 1000)
+  DEBUG or CC_STATUSLINE_DEBUG  Enable debug logging to ~/.claude/cc-api-statusline/debug.log
+
+Config File:
+  ~/.claude/cc-api-statusline/config.json
+
+Documentation:
+  https://github.com/liafonx/cc-api-statusline
+  `.trim());
+}
+function showVersion() {
+  console.log(`cc-api-statusline v${package_default.version}`);
+}
+// src/services/settings.ts
+import { readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
+import { execSync } from "child_process";
 
 // src/services/env.ts
 import { readFileSync, existsSync } from "fs";
@@ -91,8 +226,131 @@ function validateRequiredEnv(env) {
   return null;
 }
 
+// src/services/atomic-write.ts
+import { writeFileSync, renameSync, unlinkSync, existsSync as existsSync3, chmodSync } from "fs";
+import { dirname } from "path";
+
+// src/services/ensure-dir.ts
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+function ensureDir(dirPath) {
+  if (!existsSync2(dirPath)) {
+    mkdirSync(dirPath, { recursive: true, mode: 448 });
+  }
+}
+
+// src/services/atomic-write.ts
+function atomicWriteFile(filePath, content, opts = {}) {
+  const { mode = 384, ensureParentDir: ensureParent = false, appendNewline = false } = opts;
+  const nonce = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const tmpPath = `${filePath}.${nonce}.tmp`;
+  try {
+    if (ensureParent) {
+      const dir = dirname(filePath);
+      ensureDir(dir);
+    }
+    const finalContent = appendNewline ? `${content}
+` : content;
+    writeFileSync(tmpPath, finalContent, { encoding: "utf-8", mode });
+    try {
+      chmodSync(tmpPath, mode);
+    } catch {}
+    renameSync(tmpPath, filePath);
+  } catch (error) {
+    try {
+      if (existsSync3(tmpPath)) {
+        unlinkSync(tmpPath);
+      }
+    } catch {}
+    throw new Error(`Failed to write file atomically: ${error}`);
+  }
+}
+
+// src/services/settings.ts
+function loadClaudeSettings() {
+  const path = getSettingsJsonPath();
+  if (!existsSync4(path)) {
+    return {};
+  }
+  try {
+    const content = readFileSync2(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.warn(`Failed to read settings from ${path}: ${error}`);
+    return {};
+  }
+}
+function saveClaudeSettings(settings) {
+  const path = getSettingsJsonPath();
+  try {
+    const content = JSON.stringify(settings, null, 2);
+    atomicWriteFile(path, content, { ensureParentDir: true, appendNewline: true });
+  } catch (error) {
+    console.error(`Failed to write settings to ${path}: ${error}`);
+    throw error;
+  }
+}
+function getExistingStatusLine() {
+  const settings = loadClaudeSettings();
+  return settings.statusLine?.command ?? null;
+}
+function isBunxAvailable() {
+  try {
+    execSync("which bunx", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function installStatusLine(runner) {
+  const settings = loadClaudeSettings();
+  const updatedSettings = {
+    ...settings,
+    statusLine: {
+      type: "command",
+      command: `${runner} -y cc-api-statusline@latest`,
+      padding: 0
+    }
+  };
+  saveClaudeSettings(updatedSettings);
+}
+function uninstallStatusLine() {
+  const settings = loadClaudeSettings();
+  if ("statusLine" in settings) {
+    const { statusLine: _, ...rest } = settings;
+    saveClaudeSettings(rest);
+  }
+}
+
+// src/cli/commands.ts
+function handleInstall(args) {
+  const existing = getExistingStatusLine();
+  if (existing && !args.force) {
+    console.error("Error: statusLine is already configured in settings.json");
+    console.error(`Current command: ${existing}`);
+    console.error("Use --force to overwrite, or --uninstall to remove first.");
+    process.exit(1);
+  }
+  const runner = args.runner ?? (isBunxAvailable() ? "bunx" : "npx");
+  installStatusLine(runner);
+  console.log("✓ Statusline installed successfully!");
+  console.log(`  Runner: ${runner}`);
+  console.log(`  Command: ${runner} -y cc-api-statusline@latest`);
+  console.log(`  Config: ~/.claude/settings.json`);
+  process.exit(0);
+}
+function handleUninstall() {
+  const existing = getExistingStatusLine();
+  if (!existing) {
+    console.log("No statusLine configuration found in settings.json");
+    process.exit(0);
+  }
+  uninstallStatusLine();
+  console.log("✓ Statusline uninstalled successfully");
+  console.log("  Removed statusLine from ~/.claude/settings.json");
+  process.exit(0);
+}
 // src/services/cache.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, unlinkSync, renameSync, chmodSync, mkdirSync } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync5, unlinkSync as unlinkSync2 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 
@@ -123,19 +381,22 @@ function computeSoonestReset(usage) {
     times.push(usage.monthly.resetsAt);
   if (times.length === 0)
     return null;
-  times.sort();
-  return times[0] ?? null;
+  const sorted = [...times].sort();
+  return sorted[0] ?? null;
 }
 // src/types/config.ts
 var DEFAULT_CONFIG = {
   display: {
     layout: "standard",
-    displayMode: "bar",
+    displayMode: "text",
+    progressStyle: "icon",
     barSize: "medium",
-    barStyle: "classic",
+    barStyle: "block",
     separator: " | ",
     maxWidth: 100,
-    clockFormat: "24h"
+    clockFormat: "24h",
+    colorMode: "auto",
+    nerdFont: "auto"
   },
   components: {
     daily: true,
@@ -144,7 +405,8 @@ var DEFAULT_CONFIG = {
     balance: true,
     tokens: false,
     rateLimit: false,
-    plan: false
+    plan: false,
+    divider: true
   },
   colors: {
     auto: {
@@ -201,6 +463,33 @@ var COMPONENT_FULL_LABELS = {
   rateLimit: "Rate",
   plan: "Plan"
 };
+var COMPONENT_EMOJI_LABELS = {
+  daily: "\uD83D\uDCC5",
+  weekly: "\uD83D\uDCC6",
+  monthly: "\uD83D\uDDD3️",
+  balance: "\uD83D\uDCB0",
+  tokens: "\uD83D\uDD22",
+  rateLimit: "⚡",
+  plan: "\uD83D\uDCCB"
+};
+var COMPONENT_NERD_LABELS = {
+  daily: "",
+  weekly: "",
+  monthly: "",
+  balance: "",
+  tokens: "",
+  rateLimit: "",
+  plan: ""
+};
+var DEFAULT_COMPONENT_ORDER = [
+  "daily",
+  "weekly",
+  "monthly",
+  "balance",
+  "tokens",
+  "rateLimit",
+  "plan"
+];
 // src/types/cache.ts
 var CACHE_VERSION = 1;
 function isCacheEntry(value) {
@@ -226,9 +515,7 @@ function getCacheDir() {
 }
 function ensureCacheDir() {
   const dir = getCacheDir();
-  if (!existsSync2(dir)) {
-    mkdirSync(dir, { recursive: true, mode: 448 });
-  }
+  ensureDir(dir);
 }
 function getCachePath(baseUrl) {
   const hash = shortHash(baseUrl, 12);
@@ -236,11 +523,11 @@ function getCachePath(baseUrl) {
 }
 function readCache(baseUrl) {
   const path = getCachePath(baseUrl);
-  if (!existsSync2(path)) {
+  if (!existsSync5(path)) {
     return null;
   }
   try {
-    const content = readFileSync2(path, "utf-8");
+    const content = readFileSync3(path, "utf-8");
     const data = JSON.parse(content);
     if (!isCacheEntry(data)) {
       console.warn(`Invalid cache structure at ${path}`);
@@ -254,22 +541,12 @@ function readCache(baseUrl) {
 }
 function writeCache(baseUrl, entry) {
   const path = getCachePath(baseUrl);
-  const tmpPath = `${path}.tmp`;
   try {
     ensureCacheDir();
     const content = JSON.stringify(entry, null, 2);
-    writeFileSync(tmpPath, content, { encoding: "utf-8", mode: 384 });
-    try {
-      chmodSync(tmpPath, 384);
-    } catch {}
-    renameSync(tmpPath, path);
+    atomicWriteFile(path, content);
   } catch (error) {
     console.warn(`Failed to write cache to ${path}: ${error}`);
-    try {
-      if (existsSync2(tmpPath)) {
-        unlinkSync(tmpPath);
-      }
-    } catch {}
   }
 }
 function isCacheValid(entry, currentEnv) {
@@ -298,11 +575,11 @@ function isCacheRenderedLineUsable(entry, currentConfigHash) {
   return entry.configHash === currentConfigHash;
 }
 function computeConfigHash(configPath) {
-  if (!existsSync2(configPath)) {
+  if (!existsSync5(configPath)) {
     return sha256("").slice(0, 12);
   }
   try {
-    const bytes = readFileSync2(configPath);
+    const bytes = readFileSync3(configPath);
     return shortHash(bytes.toString("utf-8"), 12);
   } catch (error) {
     console.warn(`Failed to read config for hash: ${error}`);
@@ -323,11 +600,11 @@ function getProviderDetectionCachePath(baseUrl) {
 }
 function readProviderDetectionCache(baseUrl) {
   const path = getProviderDetectionCachePath(baseUrl);
-  if (!existsSync2(path)) {
+  if (!existsSync5(path)) {
     return null;
   }
   try {
-    const content = readFileSync2(path, "utf-8");
+    const content = readFileSync3(path, "utf-8");
     const data = JSON.parse(content);
     if (!isProviderDetectionCacheEntry(data)) {
       console.warn(`Invalid provider detection cache structure at ${path}`);
@@ -339,7 +616,7 @@ function readProviderDetectionCache(baseUrl) {
     const ttlMs = data.ttlSeconds * 1000;
     if (age >= ttlMs) {
       try {
-        unlinkSync(path);
+        unlinkSync2(path);
       } catch {}
       return null;
     }
@@ -351,27 +628,17 @@ function readProviderDetectionCache(baseUrl) {
 }
 function writeProviderDetectionCache(baseUrl, entry) {
   const path = getProviderDetectionCachePath(baseUrl);
-  const tmpPath = `${path}.tmp`;
   try {
     ensureCacheDir();
     const content = JSON.stringify(entry, null, 2);
-    writeFileSync(tmpPath, content, { encoding: "utf-8", mode: 384 });
-    try {
-      chmodSync(tmpPath, 384);
-    } catch {}
-    renameSync(tmpPath, path);
+    atomicWriteFile(path, content);
   } catch (error) {
     console.warn(`Failed to write provider detection cache to ${path}: ${error}`);
-    try {
-      if (existsSync2(tmpPath)) {
-        unlinkSync(tmpPath);
-      }
-    } catch {}
   }
 }
 
 // src/services/config.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync3, renameSync as renameSync2, unlinkSync as unlinkSync2 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 function getConfigDir() {
@@ -397,31 +664,42 @@ function deepMerge(target, source) {
   return result;
 }
 function validateConfig(config) {
-  if (config.display.maxWidth < 20) {
+  let maxWidth = config.display.maxWidth;
+  let pollIntervalSeconds = config.pollIntervalSeconds;
+  let pipedRequestTimeoutMs = config.pipedRequestTimeoutMs;
+  if (maxWidth < 20) {
     console.warn("Warning: display.maxWidth < 20, clamping to 20");
-    config.display.maxWidth = 20;
+    maxWidth = 20;
   }
-  if (config.display.maxWidth > 100) {
+  if (maxWidth > 100) {
     console.warn("Warning: display.maxWidth > 100, clamping to 100");
-    config.display.maxWidth = 100;
+    maxWidth = 100;
   }
-  if (config.pollIntervalSeconds !== undefined && config.pollIntervalSeconds < 5) {
+  if (pollIntervalSeconds !== undefined && pollIntervalSeconds < 5) {
     console.warn("Warning: pollIntervalSeconds < 5, clamping to 5");
-    config.pollIntervalSeconds = 5;
+    pollIntervalSeconds = 5;
   }
-  if (config.pipedRequestTimeoutMs !== undefined && config.pipedRequestTimeoutMs < 100) {
+  if (pipedRequestTimeoutMs !== undefined && pipedRequestTimeoutMs < 100) {
     console.warn("Warning: pipedRequestTimeoutMs < 100, clamping to 100");
-    config.pipedRequestTimeoutMs = 100;
+    pipedRequestTimeoutMs = 100;
   }
-  return config;
+  return {
+    ...config,
+    display: {
+      ...config.display,
+      maxWidth
+    },
+    pollIntervalSeconds,
+    pipedRequestTimeoutMs
+  };
 }
 function loadConfig(configPath) {
   const path = getConfigPath(configPath);
-  if (!existsSync3(path)) {
+  if (!existsSync6(path)) {
     return DEFAULT_CONFIG;
   }
   try {
-    const content = readFileSync3(path, "utf-8");
+    const content = readFileSync4(path, "utf-8");
     const userConfig = JSON.parse(content);
     const merged = deepMerge(DEFAULT_CONFIG, userConfig);
     return validateConfig(merged);
@@ -451,43 +729,12 @@ class TimeoutError extends Error {
   }
 }
 
-class RedirectError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "RedirectError";
-  }
-}
-
 class ResponseTooLargeError extends Error {
   constructor(message = "Response body exceeds 1MB limit") {
     super(message);
     this.name = "ResponseTooLargeError";
   }
 }
-function isSecureUrl(url) {
-  try {
-    const parsed = new URL(url);
-    if (parsed.protocol === "https:") {
-      return true;
-    }
-    if (parsed.protocol === "http:") {
-      const hostname = parsed.hostname.toLowerCase();
-      if (hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1") {
-        return true;
-      }
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-function getHostname(url) {
-  try {
-    return new URL(url).hostname.toLowerCase();
-  } catch {
-    return null;
-  }
-}
 async function readBodyWithLimit(response) {
   const MAX_SIZE = 1024 * 1024;
   let bytesRead = 0;
@@ -528,17 +775,10 @@ async function readBodyWithLimit(response) {
   }
 }
 async function secureFetch(url, options = {}, timeoutMs = 5000, userAgent) {
-  if (!isSecureUrl(url)) {
-    throw new HttpError(`Insecure URL rejected (must be HTTPS or localhost): ${url}`);
-  }
-  const originalHostname = getHostname(url);
-  if (!originalHostname) {
-    throw new HttpError(`Invalid URL: ${url}`);
-  }
   const signal = AbortSignal.timeout(timeoutMs);
   const fetchOptions = {
     ...options,
-    redirect: "manual",
+    redirect: "follow",
     signal
   };
   if (userAgent) {
@@ -548,17 +788,6 @@ async function secureFetch(url, options = {}, timeoutMs = 5000, userAgent) {
   }
   try {
     const response = await fetch(url, fetchOptions);
-    if (response.status >= 300 && response.status < 400) {
-      const location = response.headers.get("Location");
-      if (location) {
-        const redirectHostname = getHostname(location);
-        if (redirectHostname && redirectHostname !== originalHostname) {
-          throw new RedirectError(`Cross-domain redirect blocked: ${originalHostname} → ${redirectHostname}`);
-        }
-        throw new RedirectError(`Redirect detected to: ${location}`);
-      }
-      throw new RedirectError("Redirect detected but Location header missing");
-    }
     if (!response.ok) {
       let errorContext = response.statusText;
       try {
@@ -575,7 +804,7 @@ async function secureFetch(url, options = {}, timeoutMs = 5000, userAgent) {
         throw new TimeoutError(`Request timed out after ${timeoutMs}ms`);
       }
     }
-    if (error instanceof HttpError || error instanceof TimeoutError || error instanceof RedirectError || error instanceof ResponseTooLargeError) {
+    if (error instanceof HttpError || error instanceof TimeoutError || error instanceof ResponseTooLargeError) {
       throw error;
     }
     if (error instanceof Error && error.message.includes("timed out")) {
@@ -586,15 +815,14 @@ async function secureFetch(url, options = {}, timeoutMs = 5000, userAgent) {
 }
 
 // src/services/user-agent.ts
-import { execSync } from "child_process";
+import { execSync as execSync2 } from "child_process";
 import { join as join5 } from "path";
 import { homedir as homedir5 } from "os";
 
 // src/services/logger.ts
-import { appendFileSync, mkdirSync as mkdirSync3, existsSync as existsSync4 } from "fs";
-import { join as join4, dirname } from "path";
+import { appendFileSync } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
 import { homedir as homedir4 } from "os";
-
 class Logger {
   enabled;
   logPath;
@@ -608,10 +836,8 @@ class Logger {
   }
   ensureLogDir() {
     try {
-      const dir = dirname(this.logPath);
-      if (!existsSync4(dir)) {
-        mkdirSync3(dir, { recursive: true, mode: 448 });
-      }
+      const dir = dirname2(this.logPath);
+      ensureDir(dir);
     } catch {
       this.enabled = false;
     }
@@ -685,7 +911,7 @@ function detectClaudeVersion() {
       return null;
     }
     const claudePath = join5(homedir5(), ".claude", "bin", "claude");
-    const result = execSync(`"${claudePath}" --version`, {
+    const result = execSync2(`"${claudePath}" --version`, {
       encoding: "utf-8",
       timeout: 1000,
       stdio: ["ignore", "pipe", "ignore"]
@@ -697,24 +923,33 @@ function detectClaudeVersion() {
   }
 }
 
-// src/providers/sub2api.ts
-function computeNextMidnightLocal() {
-  const now = new Date;
-  const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 0, 0, 0);
-  return tomorrow.toISOString();
-}
-function computeNextMondayLocal() {
-  const now = new Date;
-  const dayOfWeek = now.getDay();
-  const daysUntilMonday = dayOfWeek === 0 ? 1 : 8 - dayOfWeek;
-  const nextMonday = new Date(now.getFullYear(), now.getMonth(), now.getDate() + daysUntilMonday, 0, 0, 0, 0);
-  return nextMonday.toISOString();
-}
-function computeFirstOfNextMonthLocal() {
-  const now = new Date;
-  const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1, 0, 0, 0, 0);
-  return nextMonth.toISOString();
+// src/providers/quota-window.ts
+function createQuotaWindow(used, limit, resetsAt) {
+  if (used === undefined) {
+    return null;
+  }
+  if (!limit || limit <= 0) {
+    return null;
+  }
+  const remaining = Math.max(0, limit - used);
+  return {
+    used,
+    limit,
+    remaining,
+    resetsAt
+  };
 }
+
+// src/core/constants.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 5000;
+var EXIT_BUFFER_MS = 50;
+var STALENESS_THRESHOLD_MINUTES = 5;
+var VERY_STALE_THRESHOLD_MINUTES = 30;
+var GC_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+var GC_MAX_CACHE_FILES = 20;
+var GC_ORPHAN_TMP_AGE_MS = 60 * 60 * 1000;
+
+// src/providers/sub2api.ts
 function mapPeriodTokens(data) {
   if (!data)
     return null;
@@ -728,108 +963,66 @@ function mapPeriodTokens(data) {
     cost: data.cost ?? 0
   };
 }
-function createQuotaWindow(used, limit, resetsAt) {
-  if (used === undefined)
-    return null;
-  if (limit === null || limit === undefined)
-    return null;
-  const remaining = Math.max(0, limit - used);
-  return {
-    used,
-    limit,
-    remaining,
-    resetsAt
-  };
-}
-async function fetchSub2api(baseUrl, token, config, timeoutMs = 5000) {
+async function fetchSub2api(baseUrl, token, config, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
   const url = `${baseUrl}/v1/usage`;
   const resolvedUA = resolveUserAgent(config.spoofClaudeCodeUA);
   if (resolvedUA) {
     logger.debug(`Using User-Agent: ${resolvedUA}`);
   }
-  try {
-    const responseText = await secureFetch(url, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        Accept: "application/json"
-      }
-    }, timeoutMs, resolvedUA);
-    const data = JSON.parse(responseText);
-    const hasSubscription = !!data.subscription;
-    const billingMode = hasSubscription ? "subscription" : "balance";
-    const result = {
-      provider: "sub2api",
-      billingMode,
-      planName: data.planName ?? "Unknown",
-      fetchedAt: new Date().toISOString(),
-      resetSemantics: "end-of-day",
-      daily: null,
-      weekly: null,
-      monthly: null,
-      balance: null,
-      resetsAt: null,
-      tokenStats: null,
-      rateLimit: null
-    };
-    if (billingMode === "balance") {
-      const remaining = data.remaining ?? 0;
-      if (remaining === -1) {
-        result.balance = {
-          remaining: -1,
-          initial: null,
-          unit: data.unit ?? "USD"
-        };
-      } else {
-        result.balance = {
-          remaining,
-          initial: null,
-          unit: data.unit ?? "USD"
-        };
-      }
-    } else {
-      const sub = data.subscription;
-      if (!sub) {
-        throw new Error("Subscription mode but no subscription object in response");
-      }
-      result.daily = createQuotaWindow(sub.daily_usage_usd, sub.daily_limit_usd, computeNextMidnightLocal());
-      result.weekly = createQuotaWindow(sub.weekly_usage_usd, sub.weekly_limit_usd, computeNextMondayLocal());
-      result.monthly = createQuotaWindow(sub.monthly_usage_usd, sub.monthly_limit_usd, computeFirstOfNextMonthLocal());
-      result.resetsAt = computeSoonestReset(result);
-    }
-    if (data.usage) {
-      result.tokenStats = {
-        today: mapPeriodTokens(data.usage.today),
-        total: mapPeriodTokens(data.usage.total),
-        rpm: data.usage.rpm ?? null,
-        tpm: data.usage.tpm ?? null
-      };
+  const responseText = await secureFetch(url, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
     }
-    return result;
-  } catch (error) {
-    if (error instanceof HttpError && error.statusCode === 429) {
-      return {
-        provider: "sub2api",
-        billingMode: "subscription",
-        planName: "Quota Exhausted",
-        fetchedAt: new Date().toISOString(),
-        resetSemantics: "end-of-day",
-        daily: {
-          used: 0,
-          limit: 0,
-          remaining: 0,
-          resetsAt: computeNextMidnightLocal()
-        },
-        weekly: null,
-        monthly: null,
-        balance: null,
-        resetsAt: computeNextMidnightLocal(),
-        tokenStats: null,
-        rateLimit: null
-      };
+  }, timeoutMs, resolvedUA);
+  const data = JSON.parse(responseText);
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid response: expected object");
+  }
+  if (typeof data.planName !== "string" && data.planName !== undefined) {
+    throw new Error("Invalid response: planName must be string or undefined");
+  }
+  const hasSubscription = !!data.subscription;
+  const billingMode = hasSubscription ? "subscription" : "balance";
+  const base = createEmptyNormalizedUsage("sub2api", billingMode, data.planName ?? "Unknown");
+  let balance = null;
+  let daily = null;
+  let weekly = null;
+  let monthly = null;
+  let resetsAt = null;
+  if (billingMode === "balance") {
+    balance = {
+      remaining: data.remaining ?? 0,
+      initial: null,
+      unit: data.unit ?? "USD"
+    };
+  } else {
+    const sub = data.subscription;
+    if (!sub) {
+      throw new Error("Subscription mode but no subscription object in response");
     }
-    throw error;
-  }
+    daily = createQuotaWindow(sub.daily_usage_usd, sub.daily_limit_usd, null);
+    weekly = createQuotaWindow(sub.weekly_usage_usd, sub.weekly_limit_usd, null);
+    monthly = createQuotaWindow(sub.monthly_usage_usd, sub.monthly_limit_usd, null);
+    const tempResult = { ...base, daily, weekly, monthly };
+    resetsAt = computeSoonestReset(tempResult);
+  }
+  const tokenStats = data.usage ? {
+    today: mapPeriodTokens(data.usage.today),
+    total: mapPeriodTokens(data.usage.total),
+    rpm: data.usage.rpm ?? null,
+    tpm: data.usage.tpm ?? null
+  } : null;
+  return {
+    ...base,
+    balance,
+    daily,
+    weekly,
+    monthly,
+    resetsAt,
+    tokenStats
+  };
 }
 
 // src/providers/health-probe.ts
@@ -870,6 +1063,13 @@ async function probeHealth(baseUrl, timeoutMs = 1500) {
   }
 }
 
+// src/services/time.ts
+function computeNextMidnightLocal() {
+  const now = new Date;
+  const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1, 0, 0, 0, 0);
+  return tomorrow.toISOString();
+}
+
 // src/providers/claude-relay-service.ts
 function computeWeeklyResetTime(resetDay, resetHour) {
   const now = new Date;
@@ -882,20 +1082,7 @@ function computeWeeklyResetTime(resetDay, resetHour) {
   const resetDate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilReset, resetHour, 0, 0, 0));
   return resetDate.toISOString();
 }
-function createQuotaWindow2(used, limit, resetsAt) {
-  if (used === undefined)
-    return null;
-  if (!limit || limit <= 0)
-    return null;
-  const remaining = Math.max(0, limit - used);
-  return {
-    used,
-    limit,
-    remaining,
-    resetsAt
-  };
-}
-async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = 5000) {
+async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
   const origin = extractOrigin(baseUrl);
   const url = `${origin}/apiStats/api/user-stats`;
   const resolvedUA = resolveUserAgent(config.spoofClaudeCodeUA);
@@ -911,67 +1098,65 @@ async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = 5000)
     body: JSON.stringify({ apiKey: token })
   }, timeoutMs, resolvedUA);
   const response = JSON.parse(responseText);
+  if (!response || typeof response !== "object") {
+    throw new Error("Invalid response: expected object");
+  }
   if (!response.success) {
     throw new HttpError("Relay API returned success: false");
   }
   const data = response.data;
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid response: missing data object");
+  }
   const limits = data.limits;
-  const result = {
-    provider: "claude-relay-service",
-    billingMode: "subscription",
-    planName: data.name ?? "API Key",
-    fetchedAt: new Date().toISOString(),
+  if (!limits || typeof limits !== "object") {
+    throw new Error("Invalid response: missing limits object");
+  }
+  const base = createEmptyNormalizedUsage("claude-relay-service", "subscription", data.name ?? "API Key");
+  const daily = createQuotaWindow(limits.currentDailyCost, limits.dailyCostLimit, computeNextMidnightLocal());
+  const weeklyResetsAt = limits.weeklyResetDay !== undefined && limits.weeklyResetHour !== undefined ? computeWeeklyResetTime(limits.weeklyResetDay, limits.weeklyResetHour) : null;
+  const weeklyBase = createQuotaWindow(limits.weeklyOpusCost, limits.weeklyOpusCostLimit, weeklyResetsAt);
+  const weekly = weeklyBase ? { ...weeklyBase, qualifier: "Opus" } : null;
+  const monthly = createQuotaWindow(limits.currentTotalCost, limits.totalCostLimit, null);
+  const resetsAt = limits.windowEndTime ? new Date(limits.windowEndTime).toISOString() : (() => {
+    const tempResult = { ...base, daily, weekly, monthly };
+    return computeSoonestReset(tempResult);
+  })();
+  const tokenStats = data.usage?.total ? {
+    today: null,
+    total: {
+      requests: data.usage.total.requests ?? 0,
+      inputTokens: data.usage.total.inputTokens ?? 0,
+      outputTokens: data.usage.total.outputTokens ?? 0,
+      cacheCreationTokens: data.usage.total.cacheCreateTokens ?? 0,
+      cacheReadTokens: data.usage.total.cacheReadTokens ?? 0,
+      totalTokens: data.usage.total.tokens ?? (data.usage.total.inputTokens ?? 0) + (data.usage.total.outputTokens ?? 0),
+      cost: data.usage.total.cost ?? 0
+    },
+    rpm: null,
+    tpm: null
+  } : null;
+  const rateLimit = limits.rateLimitWindow !== undefined ? {
+    windowSeconds: limits.rateLimitWindow * 60,
+    requestsUsed: limits.currentWindowRequests ?? 0,
+    requestsLimit: limits.rateLimitRequests && limits.rateLimitRequests > 0 ? limits.rateLimitRequests : null,
+    costUsed: limits.currentWindowCost ?? 0,
+    costLimit: limits.rateLimitCost && limits.rateLimitCost > 0 ? limits.rateLimitCost : null,
+    remainingSeconds: limits.windowRemainingSeconds ?? 0
+  } : null;
+  return {
+    ...base,
     resetSemantics: "rolling-window",
-    daily: null,
-    weekly: null,
-    monthly: null,
-    balance: null,
-    resetsAt: null,
-    tokenStats: null,
-    rateLimit: null
+    daily,
+    weekly,
+    monthly,
+    resetsAt,
+    tokenStats,
+    rateLimit
   };
-  result.daily = createQuotaWindow2(limits.currentDailyCost, limits.dailyCostLimit, null);
-  if (limits.weeklyResetDay !== undefined && limits.weeklyResetHour !== undefined) {
-    const weeklyResetsAt = computeWeeklyResetTime(limits.weeklyResetDay, limits.weeklyResetHour);
-    result.weekly = createQuotaWindow2(limits.weeklyOpusCost, limits.weeklyOpusCostLimit, weeklyResetsAt);
-  } else {
-    result.weekly = createQuotaWindow2(limits.weeklyOpusCost, limits.weeklyOpusCostLimit, null);
-  }
-  result.monthly = null;
-  if (limits.windowEndTime) {
-    result.resetsAt = new Date(limits.windowEndTime).toISOString();
-  }
-  if (data.usage?.total) {
-    const total = data.usage.total;
-    result.tokenStats = {
-      today: null,
-      total: {
-        requests: total.requests ?? 0,
-        inputTokens: total.inputTokens ?? 0,
-        outputTokens: total.outputTokens ?? 0,
-        cacheCreationTokens: total.cacheCreateTokens ?? 0,
-        cacheReadTokens: total.cacheReadTokens ?? 0,
-        totalTokens: total.tokens ?? (total.inputTokens ?? 0) + (total.outputTokens ?? 0),
-        cost: total.cost ?? 0
-      },
-      rpm: null,
-      tpm: null
-    };
-  }
-  if (limits.rateLimitWindow !== undefined) {
-    result.rateLimit = {
-      windowSeconds: limits.rateLimitWindow * 60,
-      requestsUsed: limits.currentWindowRequests ?? 0,
-      requestsLimit: limits.rateLimitRequests && limits.rateLimitRequests > 0 ? limits.rateLimitRequests : null,
-      costUsed: limits.currentWindowCost ?? 0,
-      costLimit: limits.rateLimitCost && limits.rateLimitCost > 0 ? limits.rateLimitCost : null,
-      remainingSeconds: limits.windowRemainingSeconds ?? 0
-    };
-  }
-  return result;
 }
 
-// src/providers/custom.ts
+// src/providers/custom-mapping.ts
 function resolveJsonPath(data, path) {
   if (!path.startsWith("$.")) {
     return path;
@@ -1016,6 +1201,107 @@ function extractString(data, mapping, defaultValue = "") {
     return value;
   return String(value);
 }
+function extractQuotaWindow(data, mapping, prefix) {
+  const usedKey = `${prefix}.used`;
+  const limitKey = `${prefix}.limit`;
+  const resetsAtKey = `${prefix}.resetsAt`;
+  const used = extractNumber(data, mapping[usedKey]);
+  if (used === null) {
+    return null;
+  }
+  const limitRaw = extractNumber(data, mapping[limitKey]);
+  const limit = limitRaw === 0 ? null : limitRaw;
+  return {
+    used,
+    limit,
+    remaining: limit !== null ? Math.max(0, limit - used) : null,
+    resetsAt: extractString(data, mapping[resetsAtKey], "") || null
+  };
+}
+function extractTokenStatsPeriod(data, mapping, prefix) {
+  const requestsKey = `${prefix}.requests`;
+  const requests = extractNumber(data, mapping[requestsKey]);
+  if (requests === null) {
+    return null;
+  }
+  return {
+    requests,
+    inputTokens: extractNumber(data, mapping[`${prefix}.inputTokens`]) ?? 0,
+    outputTokens: extractNumber(data, mapping[`${prefix}.outputTokens`]) ?? 0,
+    cacheCreationTokens: extractNumber(data, mapping[`${prefix}.cacheCreationTokens`]) ?? 0,
+    cacheReadTokens: extractNumber(data, mapping[`${prefix}.cacheReadTokens`]) ?? 0,
+    totalTokens: extractNumber(data, mapping[`${prefix}.totalTokens`]) ?? 0,
+    cost: extractNumber(data, mapping[`${prefix}.cost`]) ?? 0
+  };
+}
+function mapResponseToUsage(responseData, mapping, providerConfig) {
+  const billingModeStr = extractString(responseData, mapping.billingMode, "subscription");
+  const billingMode = billingModeStr === "balance" ? "balance" : "subscription";
+  const planName = extractString(responseData, mapping.planName, providerConfig.displayName ?? providerConfig.id);
+  const base = createEmptyNormalizedUsage(providerConfig.id, billingMode, planName);
+  const balance = mapping["balance.remaining"] ? (() => {
+    const remaining = extractNumber(responseData, mapping["balance.remaining"]);
+    if (remaining === null)
+      return null;
+    return {
+      remaining,
+      initial: extractNumber(responseData, mapping["balance.initial"]),
+      unit: extractString(responseData, mapping["balance.unit"], "USD")
+    };
+  })() : null;
+  const daily = extractQuotaWindow(responseData, mapping, "daily");
+  const weekly = extractQuotaWindow(responseData, mapping, "weekly");
+  const monthly = extractQuotaWindow(responseData, mapping, "monthly");
+  const todayStats = extractTokenStatsPeriod(responseData, mapping, "tokenStats.today");
+  const totalStats = extractTokenStatsPeriod(responseData, mapping, "tokenStats.total");
+  const rpm = extractNumber(responseData, mapping["tokenStats.rpm"]);
+  const tpm = extractNumber(responseData, mapping["tokenStats.tpm"]);
+  const tokenStats = todayStats || totalStats || rpm !== null || tpm !== null ? {
+    today: todayStats,
+    total: totalStats,
+    rpm,
+    tpm
+  } : null;
+  const rateLimit = (() => {
+    const windowSeconds = extractNumber(responseData, mapping["rateLimit.windowSeconds"]);
+    if (windowSeconds === null)
+      return null;
+    return {
+      windowSeconds,
+      requestsUsed: extractNumber(responseData, mapping["rateLimit.requestsUsed"]) ?? 0,
+      requestsLimit: extractNumber(responseData, mapping["rateLimit.requestsLimit"]),
+      costUsed: extractNumber(responseData, mapping["rateLimit.costUsed"]) ?? 0,
+      costLimit: extractNumber(responseData, mapping["rateLimit.costLimit"]),
+      remainingSeconds: extractNumber(responseData, mapping["rateLimit.remainingSeconds"]) ?? 0
+    };
+  })();
+  const resetsAt = (() => {
+    const times = [];
+    if (daily?.resetsAt)
+      times.push(daily.resetsAt);
+    if (weekly?.resetsAt)
+      times.push(weekly.resetsAt);
+    if (monthly?.resetsAt)
+      times.push(monthly.resetsAt);
+    if (times.length === 0)
+      return null;
+    const sorted = [...times].sort();
+    return sorted[0] ?? null;
+  })();
+  return {
+    ...base,
+    resetSemantics: billingMode === "balance" ? "expiry" : "end-of-day",
+    balance,
+    daily,
+    weekly,
+    monthly,
+    tokenStats,
+    rateLimit,
+    resetsAt
+  };
+}
+
+// src/providers/custom.ts
 function validateCustomProvider(providerConfig) {
   if (!providerConfig.id)
     return "Custom provider missing required field: id";
@@ -1044,7 +1330,7 @@ function validateCustomProvider(providerConfig) {
   }
   return null;
 }
-async function fetchCustom(baseUrl, token, appConfig, providerConfig, timeoutMs = 5000) {
+async function fetchCustom(baseUrl, token, appConfig, providerConfig, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
   const validationError = validateCustomProvider(providerConfig);
   if (validationError) {
     throw new Error(`Invalid custom provider providerConfig: ${validationError}`);
@@ -1083,117 +1369,7 @@ async function fetchCustom(baseUrl, token, appConfig, providerConfig, timeoutMs
     body
   }, timeoutMs, resolvedUA);
   const responseData = JSON.parse(responseText);
-  const mapping = providerConfig.responseMapping;
-  const billingModeStr = extractString(responseData, mapping.billingMode, "subscription");
-  const billingMode = billingModeStr === "balance" ? "balance" : "subscription";
-  const planName = extractString(responseData, mapping.planName, providerConfig.displayName ?? providerConfig.id);
-  const result = createEmptyNormalizedUsage(providerConfig.id, billingMode, planName);
-  result.resetSemantics = billingMode === "balance" ? "expiry" : "end-of-day";
-  if (mapping["balance.remaining"]) {
-    const remaining = extractNumber(responseData, mapping["balance.remaining"]);
-    if (remaining !== null) {
-      result.balance = {
-        remaining,
-        initial: extractNumber(responseData, mapping["balance.initial"]),
-        unit: extractString(responseData, mapping["balance.unit"], "USD")
-      };
-    }
-  }
-  const dailyUsed = extractNumber(responseData, mapping["daily.used"]);
-  const dailyLimitRaw = extractNumber(responseData, mapping["daily.limit"]);
-  const dailyLimit = dailyLimitRaw === 0 ? null : dailyLimitRaw;
-  if (dailyUsed !== null) {
-    result.daily = {
-      used: dailyUsed,
-      limit: dailyLimit,
-      remaining: dailyLimit !== null ? Math.max(0, dailyLimit - dailyUsed) : null,
-      resetsAt: extractString(responseData, mapping["daily.resetsAt"], "") || null
-    };
-  }
-  const weeklyUsed = extractNumber(responseData, mapping["weekly.used"]);
-  const weeklyLimitRaw = extractNumber(responseData, mapping["weekly.limit"]);
-  const weeklyLimit = weeklyLimitRaw === 0 ? null : weeklyLimitRaw;
-  if (weeklyUsed !== null) {
-    result.weekly = {
-      used: weeklyUsed,
-      limit: weeklyLimit,
-      remaining: weeklyLimit !== null ? Math.max(0, weeklyLimit - weeklyUsed) : null,
-      resetsAt: extractString(responseData, mapping["weekly.resetsAt"], "") || null
-    };
-  }
-  const monthlyUsed = extractNumber(responseData, mapping["monthly.used"]);
-  const monthlyLimitRaw = extractNumber(responseData, mapping["monthly.limit"]);
-  const monthlyLimit = monthlyLimitRaw === 0 ? null : monthlyLimitRaw;
-  if (monthlyUsed !== null) {
-    result.monthly = {
-      used: monthlyUsed,
-      limit: monthlyLimit,
-      remaining: monthlyLimit !== null ? Math.max(0, monthlyLimit - monthlyUsed) : null,
-      resetsAt: extractString(responseData, mapping["monthly.resetsAt"], "") || null
-    };
-  }
-  if (mapping["tokenStats.today.requests"]) {
-    const todayRequests = extractNumber(responseData, mapping["tokenStats.today.requests"]);
-    if (todayRequests !== null) {
-      result.tokenStats = result.tokenStats ?? { today: null, total: null, rpm: null, tpm: null };
-      result.tokenStats.today = {
-        requests: todayRequests,
-        inputTokens: extractNumber(responseData, mapping["tokenStats.today.inputTokens"]) ?? 0,
-        outputTokens: extractNumber(responseData, mapping["tokenStats.today.outputTokens"]) ?? 0,
-        cacheCreationTokens: extractNumber(responseData, mapping["tokenStats.today.cacheCreationTokens"]) ?? 0,
-        cacheReadTokens: extractNumber(responseData, mapping["tokenStats.today.cacheReadTokens"]) ?? 0,
-        totalTokens: extractNumber(responseData, mapping["tokenStats.today.totalTokens"]) ?? 0,
-        cost: extractNumber(responseData, mapping["tokenStats.today.cost"]) ?? 0
-      };
-    }
-  }
-  if (mapping["tokenStats.total.requests"]) {
-    const totalRequests = extractNumber(responseData, mapping["tokenStats.total.requests"]);
-    if (totalRequests !== null) {
-      result.tokenStats = result.tokenStats ?? { today: null, total: null, rpm: null, tpm: null };
-      result.tokenStats.total = {
-        requests: totalRequests,
-        inputTokens: extractNumber(responseData, mapping["tokenStats.total.inputTokens"]) ?? 0,
-        outputTokens: extractNumber(responseData, mapping["tokenStats.total.outputTokens"]) ?? 0,
-        cacheCreationTokens: extractNumber(responseData, mapping["tokenStats.total.cacheCreationTokens"]) ?? 0,
-        cacheReadTokens: extractNumber(responseData, mapping["tokenStats.total.cacheReadTokens"]) ?? 0,
-        totalTokens: extractNumber(responseData, mapping["tokenStats.total.totalTokens"]) ?? 0,
-        cost: extractNumber(responseData, mapping["tokenStats.total.cost"]) ?? 0
-      };
-    }
-  }
-  if (mapping["tokenStats.rpm"]) {
-    result.tokenStats = result.tokenStats ?? { today: null, total: null, rpm: null, tpm: null };
-    result.tokenStats.rpm = extractNumber(responseData, mapping["tokenStats.rpm"]);
-  }
-  if (mapping["tokenStats.tpm"]) {
-    result.tokenStats = result.tokenStats ?? { today: null, total: null, rpm: null, tpm: null };
-    result.tokenStats.tpm = extractNumber(responseData, mapping["tokenStats.tpm"]);
-  }
-  if (mapping["rateLimit.windowSeconds"]) {
-    const windowSeconds = extractNumber(responseData, mapping["rateLimit.windowSeconds"]);
-    if (windowSeconds !== null) {
-      result.rateLimit = {
-        windowSeconds,
-        requestsUsed: extractNumber(responseData, mapping["rateLimit.requestsUsed"]) ?? 0,
-        requestsLimit: extractNumber(responseData, mapping["rateLimit.requestsLimit"]),
-        costUsed: extractNumber(responseData, mapping["rateLimit.costUsed"]) ?? 0,
-        costLimit: extractNumber(responseData, mapping["rateLimit.costLimit"]),
-        remainingSeconds: extractNumber(responseData, mapping["rateLimit.remainingSeconds"]) ?? 0
-      };
-    }
-  }
-  if (result.daily?.resetsAt || result.weekly?.resetsAt || result.monthly?.resetsAt) {
-    const times = [];
-    if (result.daily?.resetsAt)
-      times.push(result.daily.resetsAt);
-    if (result.weekly?.resetsAt)
-      times.push(result.weekly.resetsAt);
-    if (result.monthly?.resetsAt)
-      times.push(result.monthly.resetsAt);
-    times.sort();
-    result.resetsAt = times[0] ?? null;
-  }
+  const result = mapResponseToUsage(responseData, providerConfig.responseMapping, providerConfig);
   return result;
 }
 
@@ -1323,13 +1499,25 @@ var ANSI_COLORS = {
 };
 var ANSI_RESET = "\x1B[0m";
 var ANSI_DIM = "\x1B[2m";
-function ansiColor(text, color) {
+function ansiColor(text, color, capabilities) {
   if (!color)
     return text;
   if (ANSI_COLORS[color.toLowerCase()]) {
     return `${ANSI_COLORS[color.toLowerCase()]}${text}${ANSI_RESET}`;
   }
   if (color.startsWith("#")) {
+    const colorMode = capabilities?.colorMode ?? "truecolor";
+    if (colorMode === "16") {
+      const named = hexToNearestNamedAnsi(color);
+      return named ? `${named}${text}${ANSI_RESET}` : text;
+    }
+    if (colorMode === "256") {
+      const index = hexTo256(color);
+      if (index !== null) {
+        return `\x1B[38;5;${index}m${text}${ANSI_RESET}`;
+      }
+      return text;
+    }
     const rgb = hexToRgb(color);
     if (rgb) {
       return `\x1B[38;2;${rgb.r};${rgb.g};${rgb.b}m${text}${ANSI_RESET}`;
@@ -1337,6 +1525,43 @@ function ansiColor(text, color) {
   }
   return text;
 }
+function hexTo256(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb)
+    return null;
+  const r6 = Math.round(rgb.r / 255 * 5);
+  const g6 = Math.round(rgb.g / 255 * 5);
+  const b6 = Math.round(rgb.b / 255 * 5);
+  return 16 + 36 * r6 + 6 * g6 + b6;
+}
+var ANSI_COLOR_RGB = [
+  { name: "black", r: 0, g: 0, b: 0 },
+  { name: "red", r: 170, g: 0, b: 0 },
+  { name: "green", r: 0, g: 170, b: 0 },
+  { name: "yellow", r: 170, g: 170, b: 0 },
+  { name: "blue", r: 0, g: 0, b: 170 },
+  { name: "magenta", r: 170, g: 0, b: 170 },
+  { name: "cyan", r: 0, g: 170, b: 170 },
+  { name: "white", r: 170, g: 170, b: 170 }
+];
+function hexToNearestNamedAnsi(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb)
+    return null;
+  let minDist = Infinity;
+  let nearest = "white";
+  for (const entry of ANSI_COLOR_RGB) {
+    const dr = rgb.r - entry.r;
+    const dg = rgb.g - entry.g;
+    const db = rgb.b - entry.b;
+    const dist = dr * dr + dg * dg + db * db;
+    if (dist < minDist) {
+      minDist = dist;
+      nearest = entry.name;
+    }
+  }
+  return ANSI_COLORS[nearest] ?? null;
+}
 function hexToRgb(hex) {
   const cleanHex = hex.replace(/^#/, "");
   if (cleanHex.length === 3) {
@@ -1391,10 +1616,14 @@ function resolveColorAlias(alias, usagePercent) {
   }
 }
 
+// src/renderer/transition.ts
+function isTransitionState(errorState) {
+  return errorState === "switching-provider" || errorState === "new-credentials" || errorState === "new-endpoint" || errorState === "auth-error-waiting";
+}
+
 // src/renderer/error.ts
 function renderError(errorState, mode, provider, message, cacheAge) {
-  const isTransition = errorState === "switching-provider" || errorState === "new-credentials" || errorState === "new-endpoint" || errorState === "auth-error-waiting";
-  if (isTransition) {
+  if (isTransitionState(errorState)) {
     return renderTransitionState(errorState);
   }
   if (mode === "without-cache") {
@@ -1428,11 +1657,13 @@ function renderStandaloneError(errorState, provider, message) {
     case "auth-error":
       return `${warningIcon} Auth error`;
     case "rate-limited":
-      return `${warningIcon} Rate limited`;
+      return `${warningIcon} Usage limit reached`;
     case "provider-unknown":
       return `${warningIcon} Unknown provider`;
     case "missing-env":
       return `${warningIcon} Set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN`;
+    case "timeout":
+      return `${warningIcon} Fetching...`;
     case "network-error":
     case "server-error":
     case "parse-error":
@@ -1456,7 +1687,9 @@ function renderErrorIndicator(errorState, cacheAge) {
     case "parse-error":
       return "[parse error]";
     case "rate-limited":
-      return "[rate limited]";
+      return "[limit reached]";
+    case "timeout":
+      return "[timeout]";
     default:
       return "[error]";
   }
@@ -1467,7 +1700,7 @@ function renderStalenessIndicator(label, cacheAge, showAge = true) {
   }
   const stalenessLevel = getStalenessLevel(cacheAge);
   let text = label;
-  if (showAge && cacheAge >= 5) {
+  if (showAge && cacheAge >= STALENESS_THRESHOLD_MINUTES) {
     text = `[stale ${cacheAge}m]`;
   }
   switch (stalenessLevel) {
@@ -1480,9 +1713,9 @@ function renderStalenessIndicator(label, cacheAge, showAge = true) {
   }
 }
 function getStalenessLevel(ageMinutes) {
-  if (ageMinutes < 5) {
+  if (ageMinutes < STALENESS_THRESHOLD_MINUTES) {
     return "fresh";
-  } else if (ageMinutes <= 30) {
+  } else if (ageMinutes <= VERY_STALE_THRESHOLD_MINUTES) {
     return "stale";
   } else {
     return "very-stale";
@@ -1500,6 +1733,8 @@ function getDefaultMessage(errorState) {
       return "authentication failed";
     case "rate-limited":
       return "rate limited";
+    case "timeout":
+      return "fetching...";
     default:
       return "error";
   }
@@ -1665,56 +1900,117 @@ var PROGRESS_ICONS = [
   "\uDB82\uDEA4",
   "\uDB82\uDEA5"
 ];
-function getProgressIcon(percent) {
+var TEXT_PROGRESS_ICONS = [
+  "○",
+  "◔",
+  "◑",
+  "◕",
+  "●"
+];
+function calcNerdIconIndex(percent) {
+  return Math.min(8, Math.ceil(percent / 12.5));
+}
+function calcTextIconIndex(percent) {
+  return Math.min(4, Math.ceil(percent / 25));
+}
+function getProgressIcon(percent, nerdFontAvailable = true) {
+  if (!nerdFontAvailable) {
+    if (percent === null) {
+      return TEXT_PROGRESS_ICONS[0] ?? "○";
+    }
+    const clampedPercent2 = Math.max(0, Math.min(100, percent));
+    const index2 = calcTextIconIndex(clampedPercent2);
+    return TEXT_PROGRESS_ICONS[index2] ?? TEXT_PROGRESS_ICONS[0] ?? "○";
+  }
   if (percent === null) {
     return PROGRESS_ICONS[0] ?? "";
   }
   const clampedPercent = Math.max(0, Math.min(100, percent));
-  const index = Math.min(8, Math.ceil(clampedPercent / 12.5));
+  const index = calcNerdIconIndex(clampedPercent);
   return PROGRESS_ICONS[index] ?? PROGRESS_ICONS[0] ?? "";
 }
 
+// src/renderer/format.ts
+function formatCurrency(n) {
+  return `$${Math.floor(n)}`;
+}
+function formatCurrencyQuota(used, limit) {
+  return `${formatCurrency(used)}/$${Math.floor(limit)}`;
+}
+function formatCompactNumber(n) {
+  const absN = Math.abs(n);
+  const sign = n < 0 ? "-" : "";
+  if (absN < 1000) {
+    return `${sign}${Math.round(absN)}`;
+  }
+  let threshold;
+  let suffix;
+  if (absN >= 1e9) {
+    threshold = 1e9;
+    suffix = "B";
+  } else if (absN >= 1e6) {
+    threshold = 1e6;
+    suffix = "M";
+  } else {
+    threshold = 1000;
+    suffix = "K";
+    const kValue = absN / 1000;
+    if (Math.round(kValue) >= 1000) {
+      threshold = 1e6;
+      suffix = "M";
+    }
+  }
+  const value = absN / threshold;
+  const roundedToOneDec = Math.round(value * 10) / 10;
+  if (roundedToOneDec < 10) {
+    return `${sign}${roundedToOneDec.toFixed(1)}${suffix}`;
+  } else {
+    return `${sign}${Math.round(value)}${suffix}`;
+  }
+}
+
 // src/renderer/component.ts
-function renderComponent(componentId, data, componentConfig, globalConfig) {
+function renderComponent(componentId, data, componentConfig, globalConfig, renderContext) {
   const effectiveLayout = componentConfig.layout ?? globalConfig.display.layout;
-  const effectiveDisplayMode = componentConfig.displayMode ?? globalConfig.display.displayMode;
+  const effectiveDisplayMode = resolveEffectiveDisplayMode(componentConfig.displayMode ?? globalConfig.display.displayMode, renderContext);
+  const effectiveProgressStyle = resolveEffectiveProgressStyle(componentConfig.progressStyle ?? globalConfig.display.progressStyle, renderContext);
   const effectiveBarSize = componentConfig.barSize ?? globalConfig.display.barSize;
   const effectiveBarStyle = componentConfig.barStyle ?? globalConfig.display.barStyle;
   const clockFormat = globalConfig.display.clockFormat;
   switch (componentId) {
     case "daily":
-      return renderQuotaComponent("daily", data.daily, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat);
+      return renderQuotaComponent("daily", data.daily, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
     case "weekly":
-      return renderQuotaComponent("weekly", data.weekly, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat);
+      return renderQuotaComponent("weekly", data.weekly, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
     case "monthly":
-      return renderQuotaComponent("monthly", data.monthly, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat);
+      return renderQuotaComponent("monthly", data.monthly, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
     case "balance":
-      return renderBalanceComponent(data.balance, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig);
+      return renderBalanceComponent(data.balance, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, renderContext);
     case "tokens":
-      return renderTokensComponent(data.tokenStats, effectiveLayout, effectiveDisplayMode, componentConfig, globalConfig);
+      return renderTokensComponent(data.tokenStats, effectiveLayout, effectiveDisplayMode, componentConfig, globalConfig, renderContext);
     case "rateLimit":
-      return renderRateLimitComponent(data.rateLimit, effectiveLayout, effectiveDisplayMode, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig);
+      return renderRateLimitComponent(data.rateLimit, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, renderContext);
     case "plan":
-      return renderPlanComponent(data.planName, effectiveLayout, componentConfig, globalConfig);
+      return renderPlanComponent(data.planName, effectiveLayout, effectiveDisplayMode, componentConfig, globalConfig, renderContext);
     default:
       return null;
   }
 }
-function renderQuotaComponent(componentId, quota, layout, displayMode, barSize, barStyle, componentConfig, globalConfig, clockFormat) {
+function renderQuotaComponent(componentId, quota, layout, displayMode, progressStyle, barSize, barStyle, componentConfig, globalConfig, clockFormat, renderContext) {
   if (!quota)
     return null;
   const usagePercent = calculateUsagePercent(quota.used, quota.limit);
-  const label = renderLabel(componentId, layout, componentConfig, globalConfig, displayMode);
+  const label = renderLabel(componentId, displayMode, componentConfig, quota.qualifier);
   const barColor = resolvePartColor("bar", usagePercent, componentConfig, globalConfig);
   const valueColor = resolvePartColor("value", usagePercent, componentConfig, globalConfig);
   const labelColor = resolvePartColor("label", usagePercent, componentConfig, globalConfig);
   const countdownColor = resolvePartColor("countdown", usagePercent, componentConfig, globalConfig);
-  const display = renderDisplayMode(displayMode, usagePercent, barSize, barStyle, barColor, null);
-  const value = ansiColor(`${Math.round(usagePercent)}%`, valueColor);
-  const countdown = renderCountdownSubComponent(quota.resetsAt, componentConfig.countdown, countdownColor, clockFormat);
-  return assembleComponent(layout, label, labelColor, display, value, countdown);
+  const progress = renderProgress(progressStyle, usagePercent, barSize, barStyle, barColor, null);
+  const value = ansiColor(`${Math.round(usagePercent)}%`, valueColor, renderContext);
+  const countdown = renderSecondaryDisplay(quota.resetsAt, quota, componentConfig.countdown, countdownColor, clockFormat, renderContext);
+  return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderBalanceComponent(balance, layout, displayMode, barSize, barStyle, componentConfig, globalConfig) {
+function renderBalanceComponent(balance, layout, displayMode, progressStyle, barSize, barStyle, componentConfig, globalConfig, renderContext) {
   if (!balance)
     return null;
   const isUnlimited = balance.remaining === -1;
@@ -1723,120 +2019,171 @@ function renderBalanceComponent(balance, layout, displayMode, barSize, barStyle,
     usagePercent = (balance.initial - balance.remaining) / balance.initial * 100;
   }
   const effectivePercent = isUnlimited ? 0 : usagePercent;
-  const label = renderLabel("balance", layout, componentConfig, globalConfig, displayMode);
+  const label = renderLabel("balance", displayMode, componentConfig);
   const barColor = resolvePartColor("bar", effectivePercent, componentConfig, globalConfig);
   const valueColor = resolvePartColor("value", effectivePercent, componentConfig, globalConfig);
   const labelColor = resolvePartColor("label", effectivePercent, componentConfig, globalConfig);
-  const display = isUnlimited ? "" : renderDisplayMode(displayMode, effectivePercent ?? 0, barSize, barStyle, barColor, null);
+  const progress = isUnlimited ? "" : renderProgress(progressStyle, effectivePercent ?? 0, barSize, barStyle, barColor, null);
   const valueText = isUnlimited ? "∞" : `$${balance.remaining.toFixed(2)}`;
-  const value = ansiColor(valueText, valueColor);
+  const value = ansiColor(valueText, valueColor, renderContext);
   const countdown = "";
-  return assembleComponent(layout, label, labelColor, display, value, countdown);
+  return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderTokensComponent(tokenStats, layout, displayMode, componentConfig, globalConfig) {
+function renderTokensComponent(tokenStats, layout, displayMode, componentConfig, globalConfig, renderContext) {
   if (!tokenStats)
     return null;
   const stats = tokenStats.total ?? tokenStats.today;
   if (!stats)
     return null;
-  const label = renderLabel("tokens", layout, componentConfig, globalConfig, displayMode);
+  const label = renderLabel("tokens", displayMode, componentConfig);
   const labelColor = resolvePartColor("label", null, componentConfig, globalConfig);
   const valueColor = resolvePartColor("value", null, componentConfig, globalConfig);
   const tokenCount = stats.totalTokens ?? stats.inputTokens + stats.outputTokens;
-  const valueText = formatLargeNumber(tokenCount);
-  const value = ansiColor(valueText, valueColor);
-  const display = "";
+  const valueText = formatCompactNumber(tokenCount);
+  const value = ansiColor(valueText, valueColor, renderContext);
+  const progress = "";
   const countdown = "";
-  return assembleComponent(layout, label, labelColor, display, value, countdown);
+  return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderRateLimitComponent(rateLimit, layout, displayMode, barSize, barStyle, componentConfig, globalConfig) {
+function renderRateLimitComponent(rateLimit, layout, displayMode, progressStyle, barSize, barStyle, componentConfig, globalConfig, renderContext) {
   if (!rateLimit)
     return null;
   let usagePercent = null;
   if (rateLimit.requestsLimit !== null && rateLimit.requestsLimit > 0) {
     usagePercent = rateLimit.requestsUsed / rateLimit.requestsLimit * 100;
   }
-  const label = renderLabel("rateLimit", layout, componentConfig, globalConfig, displayMode);
+  const label = renderLabel("rateLimit", displayMode, componentConfig);
   const barColor = resolvePartColor("bar", usagePercent, componentConfig, globalConfig);
   const valueColor = resolvePartColor("value", usagePercent, componentConfig, globalConfig);
   const labelColor = resolvePartColor("label", usagePercent, componentConfig, globalConfig);
-  const display = usagePercent !== null ? renderDisplayMode(displayMode, usagePercent, barSize, barStyle, barColor, null) : "";
+  const progress = usagePercent !== null ? renderProgress(progressStyle, usagePercent, barSize, barStyle, barColor, null) : "";
   const valueText = rateLimit.requestsLimit !== null ? `${rateLimit.requestsUsed}/${rateLimit.requestsLimit}` : `${rateLimit.requestsUsed}`;
-  const value = ansiColor(valueText, valueColor);
+  const value = ansiColor(valueText, valueColor, renderContext);
   const countdown = "";
-  return assembleComponent(layout, label, labelColor, display, value, countdown);
+  return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderPlanComponent(planName, layout, componentConfig, globalConfig) {
-  if (layout === "minimal")
+function renderPlanComponent(planName, layout, displayMode, componentConfig, globalConfig, renderContext) {
+  if (displayMode === "hidden")
     return null;
   const labelColor = resolvePartColor("label", null, componentConfig, globalConfig);
-  const value = ansiColor(planName, labelColor);
+  const value = ansiColor(planName, labelColor, renderContext);
   if (typeof componentConfig.label === "object" && componentConfig.label.text) {
-    const labelText = ansiColor(componentConfig.label.text, labelColor);
+    const labelText = ansiColor(componentConfig.label.text, labelColor, renderContext);
     return `${labelText} ${value}`;
   }
   return value;
 }
-function renderLabel(componentId, layout, componentConfig, globalConfig, displayMode) {
-  if (layout === "minimal")
+function renderLabel(componentId, displayMode, componentConfig, qualifier) {
+  if (displayMode === "hidden")
     return "";
   if (componentConfig.label === false)
     return "";
-  if (displayMode === "icon-pct" && typeof componentConfig.label === "object" && componentConfig.label.icon) {
-    return componentConfig.label.icon;
-  }
-  if (typeof componentConfig.label === "string") {
-    return layout === "compact" ? componentConfig.label.charAt(0) : componentConfig.label;
-  }
-  if (typeof componentConfig.label === "object" && componentConfig.label.text) {
-    return layout === "compact" ? componentConfig.label.text.charAt(0) : componentConfig.label.text;
+  const label = componentConfig.label;
+  let baseLabel;
+  switch (displayMode) {
+    case "emoji": {
+      if (typeof label === "object" && label.emoji) {
+        baseLabel = label.emoji;
+      } else {
+        baseLabel = COMPONENT_EMOJI_LABELS[componentId] ?? COMPONENT_FULL_LABELS[componentId] ?? "";
+      }
+      break;
+    }
+    case "nerd": {
+      if (typeof label === "object" && label.nerd) {
+        baseLabel = label.nerd;
+      } else {
+        baseLabel = COMPONENT_NERD_LABELS[componentId] ?? COMPONENT_FULL_LABELS[componentId] ?? "";
+      }
+      break;
+    }
+    case "compact": {
+      if (typeof label === "string") {
+        baseLabel = label.charAt(0);
+      } else if (typeof label === "object" && label.text) {
+        baseLabel = label.text.charAt(0);
+      } else {
+        baseLabel = COMPONENT_SHORT_LABELS[componentId] ?? "";
+      }
+      break;
+    }
+    case "text":
+    default: {
+      if (typeof label === "string") {
+        baseLabel = label;
+      } else if (typeof label === "object" && label.text) {
+        baseLabel = label.text;
+      } else {
+        baseLabel = COMPONENT_FULL_LABELS[componentId] ?? "";
+      }
+      break;
+    }
   }
-  if (layout === "compact") {
-    return COMPONENT_SHORT_LABELS[componentId] ?? "";
+  if (qualifier) {
+    if (displayMode === "compact") {
+      return `${baseLabel}(${qualifier.charAt(0)})`;
+    }
+    return `${baseLabel}(${qualifier})`;
   }
-  return COMPONENT_FULL_LABELS[componentId] ?? "";
+  return baseLabel;
 }
-function renderDisplayMode(displayMode, usagePercent, barSize, barStyle, barColor, emptyColor) {
-  switch (displayMode) {
+function renderProgress(progressStyle, usagePercent, barSize, barStyle, barColor, emptyColor) {
+  switch (progressStyle) {
     case "bar":
       return renderBar(usagePercent, barSize, barStyle, barColor, emptyColor);
-    case "percentage":
+    case "icon":
+      return getProgressIcon(usagePercent, true);
+    case "hidden":
       return "";
-    case "icon-pct":
-      return getProgressIcon(usagePercent);
     default:
       return "";
   }
 }
-function renderCountdownSubComponent(resetsAt, countdownConfig, countdownColor, clockFormat) {
-  if (countdownConfig === false || !resetsAt)
+function resolveEffectiveProgressStyle(requested, renderContext) {
+  if (requested === "icon" && renderContext && !renderContext.nerdFontAvailable) {
+    return "bar";
+  }
+  return requested;
+}
+function resolveEffectiveDisplayMode(requested, renderContext) {
+  if (requested === "nerd" && renderContext && !renderContext.nerdFontAvailable) {
+    return "text";
+  }
+  return requested;
+}
+function renderSecondaryDisplay(resetsAt, quota, countdownConfig, countdownColor, clockFormat, renderContext) {
+  if (countdownConfig === false)
     return "";
   const config = typeof countdownConfig === "object" ? countdownConfig : {};
-  const countdown = renderCountdown(resetsAt, config, clockFormat);
-  return countdownColor ? ansiColor(countdown, countdownColor) : countdown;
+  const divider = config.divider ?? " · ";
+  const prefix = config.prefix ?? "";
+  if (quota.limit !== null && quota.limit > 0) {
+    const costDisplay = formatCurrencyQuota(quota.used, quota.limit);
+    const display = `${prefix}${divider}${costDisplay}`;
+    return countdownColor ? ansiColor(display, countdownColor, renderContext) : display;
+  }
+  if (resetsAt !== null) {
+    const countdown = renderCountdown(resetsAt, config, clockFormat);
+    return countdownColor ? ansiColor(countdown, countdownColor, renderContext) : countdown;
+  }
+  return "";
 }
-function assembleComponent(layout, label, labelColor, display, value, countdown) {
-  const coloredLabel = label && labelColor ? ansiColor(label, labelColor) : label;
+function assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext) {
+  const coloredLabel = label && labelColor ? ansiColor(label, labelColor, renderContext) : label;
   const parts = [];
-  if (layout === "minimal") {
-    if (display)
-      parts.push(display);
-    parts.push(value);
-    if (countdown)
-      parts.push(countdown);
-  } else if (layout === "percent-first") {
+  if (layout === "percent-first") {
     if (coloredLabel)
       parts.push(coloredLabel);
     parts.push(value);
-    if (display)
-      parts.push(display);
+    if (progress)
+      parts.push(progress);
     if (countdown)
       parts.push(countdown);
   } else {
     if (coloredLabel)
       parts.push(coloredLabel);
-    if (display)
-      parts.push(display);
+    if (progress)
+      parts.push(progress);
     parts.push(value);
     if (countdown)
       parts.push(countdown);
@@ -1844,8 +2191,10 @@ function assembleComponent(layout, label, labelColor, display, value, countdown)
   return parts.filter((p) => p).join(" ").replace(/ (\x1b\[[0-9;]*m)? ([·•])/g, "$1 $2");
 }
 function calculateUsagePercent(used, limit) {
-  if (limit === null || limit === 0)
+  if (limit === null)
     return 0;
+  if (limit === 0)
+    return 100;
   return used / limit * 100;
 }
 function resolvePartColor(part, usagePercent, componentConfig, globalConfig) {
@@ -1856,16 +2205,6 @@ function resolvePartColor(part, usagePercent, componentConfig, globalConfig) {
   const color = componentConfig.color ?? "auto";
   return resolveColor(color, usagePercent, globalConfig);
 }
-function formatLargeNumber(n) {
-  if (n >= 1e9) {
-    return `${(n / 1e9).toFixed(1)}B`;
-  } else if (n >= 1e6) {
-    return `${(n / 1e6).toFixed(1)}M`;
-  } else if (n >= 1000) {
-    return `${(n / 1000).toFixed(1)}K`;
-  }
-  return n.toString();
-}
 
 // src/renderer/truncate.ts
 function getTerminalWidth() {
@@ -1931,17 +2270,75 @@ var COMPONENT_DROP_PRIORITY = [
   "balance"
 ];
 
+// src/renderer/divider.ts
+function renderDivider(divider) {
+  const text = divider.text ?? "|";
+  const padding = divider.padding ?? 1;
+  const pad = " ".repeat(padding);
+  const padded = `${pad}${text}${pad}`;
+  return divider.color ? ansiColor(padded, divider.color) : padded;
+}
+
+// src/services/capabilities.ts
+var TRUECOLOR_TERMINALS = ["iTerm.app", "WezTerm", "Alacritty", "kitty", "Hyper", "vscode"];
+var NERD_TERMINALS = ["iTerm.app", "WezTerm", "Alacritty", "kitty", "Hyper"];
+function detectColorMode() {
+  if (process.env["NO_COLOR"] !== undefined) {
+    return "16";
+  }
+  const colorterm = process.env["COLORTERM"] ?? "";
+  if (colorterm === "truecolor" || colorterm === "24bit") {
+    return "truecolor";
+  }
+  const termProgram = process.env["TERM_PROGRAM"] ?? "";
+  if (TRUECOLOR_TERMINALS.some((t) => termProgram.includes(t))) {
+    return "truecolor";
+  }
+  const term = process.env["TERM"] ?? "";
+  if (term.includes("256color")) {
+    return "256";
+  }
+  return "truecolor";
+}
+function resolveColorMode(configured) {
+  if (!configured || configured === "auto") {
+    return detectColorMode();
+  }
+  return configured;
+}
+function detectNerdFont() {
+  const override = process.env["CC_STATUSLINE_NERD_FONT"];
+  if (override === "1" || override === "true")
+    return true;
+  if (override === "0" || override === "false")
+    return false;
+  const termProgram = process.env["TERM_PROGRAM"] ?? "";
+  if (NERD_TERMINALS.some((t) => termProgram.includes(t)))
+    return true;
+  if (termProgram === "vscode")
+    return true;
+  return true;
+}
+function resolveNerdFont(configured) {
+  if (configured === true)
+    return true;
+  if (configured === false)
+    return false;
+  return detectNerdFont();
+}
+
+// src/renderer/context.ts
+function createRenderContext(config, isPiped) {
+  return {
+    colorMode: resolveColorMode(config.display.colorMode),
+    nerdFontAvailable: resolveNerdFont(config.display.nerdFont),
+    isPiped
+  };
+}
+
 // src/renderer/index.ts
-var DEFAULT_COMPONENT_ORDER2 = [
-  "daily",
-  "weekly",
-  "monthly",
-  "balance",
-  "tokens",
-  "rateLimit",
-  "plan"
-];
-function renderStatusline(data, config, errorState, cacheAge) {
+function renderStatusline(data, config, errorState, cacheAge, isPiped = false) {
+  const renderContext = createRenderContext(config, isPiped);
   const componentOrder = getComponentOrder(config);
   const componentMap = new Map;
   for (const componentId of componentOrder) {
@@ -1949,26 +2346,21 @@ function renderStatusline(data, config, errorState, cacheAge) {
     if (componentConfig === false) {
       continue;
     }
-    const rendered = renderComponent(componentId, data, componentConfig === true || componentConfig === undefined ? {} : componentConfig, config);
+    const rendered = renderComponent(componentId, data, componentConfig === true || componentConfig === undefined ? {} : componentConfig, config, renderContext);
     if (rendered !== null) {
       componentMap.set(componentId, rendered);
     }
   }
-  const termWidth = getTerminalWidth();
-  const maxWidth = computeMaxWidth(termWidth, config.display.maxWidth ?? 100);
-  const separator = config.display.separator ?? " | ";
+  const separator = computeSeparator(config);
   const activeComponents = new Set(componentMap.keys());
   let currentWidth = calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge);
   for (const dropCandidate of COMPONENT_DROP_PRIORITY) {
-    if (dropCandidate === "countdown") {
+    if (dropCandidate === "countdown")
       continue;
-    }
-    if (currentWidth <= maxWidth) {
+    if (currentWidth <= maxWidth(config))
       break;
-    }
-    if (activeComponents.size <= 1) {
+    if (activeComponents.size <= 1)
       break;
-    }
     if (activeComponents.has(dropCandidate)) {
       activeComponents.delete(dropCandidate);
       currentWidth = calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge);
@@ -1978,54 +2370,56 @@ function renderStatusline(data, config, errorState, cacheAge) {
   for (const componentId of componentOrder) {
     if (activeComponents.has(componentId)) {
       const rendered = componentMap.get(componentId);
-      if (rendered) {
+      if (rendered)
         renderedComponents.push(rendered);
-      }
     }
   }
   let statusline = renderedComponents.join(separator);
   if (errorState) {
-    const isTransition = errorState === "switching-provider" || errorState === "new-credentials" || errorState === "new-endpoint" || errorState === "auth-error-waiting";
-    if (isTransition) {
+    if (isTransitionState(errorState)) {
       statusline = renderError(errorState, "with-cache", data.provider, undefined, cacheAge);
     } else {
       const hasCache = renderedComponents.length > 0;
       const errorMode = hasCache ? "with-cache" : "without-cache";
       const errorIndicator = renderError(errorState, errorMode, data.provider, undefined, cacheAge);
-      if (hasCache) {
-        statusline = `${statusline} ${errorIndicator}`;
-      } else {
-        statusline = errorIndicator;
-      }
+      statusline = hasCache ? `${statusline} ${errorIndicator}` : errorIndicator;
     }
   }
-  statusline = ansiAwareTruncate(statusline, maxWidth);
+  const termWidth = getTerminalWidth();
+  const maxW = computeMaxWidth(termWidth, config.display.maxWidth ?? 100);
+  statusline = ansiAwareTruncate(statusline, maxW);
   return statusline;
 }
+function computeSeparator(config) {
+  const dividerConfig = config.components.divider;
+  if (dividerConfig === false)
+    return "";
+  if (typeof dividerConfig === "object")
+    return renderDivider(dividerConfig);
+  return config.display.separator ?? " | ";
+}
+function maxWidth(config) {
+  const termWidth = getTerminalWidth();
+  return computeMaxWidth(termWidth, config.display.maxWidth ?? 100);
+}
 function calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge) {
   const components = [];
   for (const id of componentOrder) {
     if (activeComponents.has(id)) {
       const rendered = componentMap.get(id);
-      if (rendered) {
+      if (rendered)
         components.push(rendered);
-      }
     }
   }
   let statusline = components.join(separator);
   if (errorState) {
-    const isTransition = errorState === "switching-provider" || errorState === "new-credentials" || errorState === "new-endpoint" || errorState === "auth-error-waiting";
-    if (isTransition) {
+    if (isTransitionState(errorState)) {
       statusline = renderError(errorState, "with-cache", data.provider, undefined, cacheAge);
     } else {
       const hasCache = components.length > 0;
       const errorMode = hasCache ? "with-cache" : "without-cache";
       const errorIndicator = renderError(errorState, errorMode, data.provider, undefined, cacheAge);
-      if (hasCache) {
-        statusline = `${statusline} ${errorIndicator}`;
-      } else {
-        statusline = errorIndicator;
-      }
+      statusline = hasCache ? `${statusline} ${errorIndicator}` : errorIndicator;
     }
   }
   return visibleLength(statusline);
@@ -2040,7 +2434,7 @@ function getComponentOrder(config) {
     }
   }
   const order = [...explicitOrder];
-  for (const componentId of DEFAULT_COMPONENT_ORDER2) {
+  for (const componentId of DEFAULT_COMPONENT_ORDER) {
     if (!explicitSet.has(componentId)) {
       order.push(componentId);
     }
@@ -2048,7 +2442,7 @@ function getComponentOrder(config) {
   return order;
 }
 function isComponentId(key) {
-  return DEFAULT_COMPONENT_ORDER2.includes(key);
+  return DEFAULT_COMPONENT_ORDER.includes(key);
 }
 
 // src/core/execute-cycle.ts
@@ -2082,23 +2476,16 @@ async function executeCycle(ctx) {
       cacheUpdate: updatedEntry
     };
   }
-  const deadline = startTime + timeoutBudgetMs - 50;
+  const deadline = startTime + timeoutBudgetMs - EXIT_BUFFER_MS;
   const remainingBudget = deadline - Date.now();
   if (remainingBudget <= 50) {
-    logger.debug("Path D: Timeout fallback (insufficient budget)", { remainingBudget });
-    if (cachedEntry && cachedEntry.renderedLine) {
-      return {
-        output: cachedEntry.renderedLine,
-        exitCode: 0,
-        cacheUpdate: null
-      };
-    } else {
-      return {
-        output: "[loading...]",
-        exitCode: 0,
-        cacheUpdate: null
-      };
-    }
+    logger.debug("Path D1: Timeout fallback", { remainingBudget });
+    const errorOutput = renderError("timeout", "without-cache", providerId);
+    return {
+      output: errorOutput,
+      exitCode: 0,
+      cacheUpdate: null
+    };
   }
   try {
     const baseUrl = env.baseUrl;
@@ -2136,225 +2523,221 @@ async function executeCycle(ctx) {
     };
   } catch (error) {
     logger.error("Path D: Fetch error", { error: String(error), hasCachedEntry: !!cachedEntry });
+    let errorState = "network-error";
+    if (error && typeof error === "object" && "statusCode" in error) {
+      const statusCode = error.statusCode;
+      if (statusCode === 429) {
+        errorState = "rate-limited";
+      } else if (statusCode && statusCode >= 500) {
+        errorState = "server-error";
+      } else if (statusCode === 401 || statusCode === 403) {
+        errorState = "auth-error";
+      }
+    }
     if (cachedEntry) {
-      const ageMinutes = Math.floor((Date.now() - new Date(cachedEntry.fetchedAt).getTime()) / 60000);
-      const statusline = renderStatusline(cachedEntry.data, config, "network-error", ageMinutes);
-      logger.debug("Using stale cache with error indicator", { ageMinutes });
-      return {
-        output: statusline,
-        exitCode: 0,
-        cacheUpdate: null
-      };
+      logger.debug("Discarding stale cache, showing error", { errorState });
     } else {
       logger.warn("No cache available for error fallback");
-      const errorOutput = renderError("network-error", "without-cache", providerId);
-      return {
-        output: errorOutput,
-        exitCode: 0,
-        cacheUpdate: null
-      };
     }
+    const errorOutput = renderError(errorState, "without-cache", providerId);
+    return {
+      output: errorOutput,
+      exitCode: 0,
+      cacheUpdate: null
+    };
   }
 }
-// src/services/settings.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync5, renameSync as renameSync3, unlinkSync as unlinkSync3, mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname2 } from "path";
-import { execSync as execSync2 } from "child_process";
-function loadClaudeSettings() {
-  const path = getSettingsJsonPath();
-  if (!existsSync5(path)) {
-    return {};
-  }
-  try {
-    const content = readFileSync4(path, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    console.warn(`Failed to read settings from ${path}: ${error}`);
-    return {};
-  }
-}
-function saveClaudeSettings(settings) {
-  const path = getSettingsJsonPath();
-  const tmpPath = `${path}.tmp`;
+// src/services/cache-gc.ts
+import { readdirSync, statSync, unlinkSync as unlinkSync3, existsSync as existsSync7 } from "fs";
+import { join as join6 } from "path";
+function runCacheGC(cacheDir) {
   try {
-    const dir = dirname2(path);
-    if (!existsSync5(dir)) {
-      mkdirSync4(dir, { recursive: true, mode: 448 });
+    if (!existsSync7(cacheDir)) {
+      logger.debug("GC: Cache directory does not exist, skipping", { cacheDir });
+      return;
     }
-    const content = JSON.stringify(settings, null, 2) + `
-`;
-    writeFileSync3(tmpPath, content, { encoding: "utf-8", mode: 384 });
-    renameSync3(tmpPath, path);
-  } catch (error) {
-    console.error(`Failed to write settings to ${path}: ${error}`);
-    try {
-      if (existsSync5(tmpPath)) {
-        unlinkSync3(tmpPath);
+    logger.debug("GC: Starting garbage collection", { cacheDir });
+    const files = readdirSync(cacheDir);
+    const cacheFiles = [];
+    const providerDetectFiles = [];
+    const tmpFiles = [];
+    for (const file of files) {
+      try {
+        const filePath = join6(cacheDir, file);
+        const stats = statSync(filePath);
+        const mtime = stats.mtimeMs;
+        if (file.startsWith("cache-") && file.endsWith(".json")) {
+          cacheFiles.push({ name: file, mtime });
+        } else if (file.startsWith("provider-detect-") && file.endsWith(".json")) {
+          providerDetectFiles.push({ name: file, mtime });
+        } else if (file.endsWith(".tmp")) {
+          tmpFiles.push({ name: file, mtime });
+        }
+      } catch (error) {
+        logger.debug("GC: Failed to stat file, skipping", { file, error: String(error) });
       }
-    } catch {}
-    throw error;
+    }
+    const now = Date.now();
+    let deletedCount = 0;
+    for (const file of cacheFiles) {
+      const age = now - file.mtime;
+      if (age > GC_MAX_AGE_MS) {
+        try {
+          unlinkSync3(join6(cacheDir, file.name));
+          deletedCount++;
+          logger.debug("GC: Deleted old cache file", { file: file.name, ageDays: Math.floor(age / (24 * 60 * 60 * 1000)) });
+        } catch (error) {
+          logger.debug("GC: Failed to delete cache file", { file: file.name, error: String(error) });
+        }
+      }
+    }
+    for (const file of providerDetectFiles) {
+      const age = now - file.mtime;
+      if (age > GC_MAX_AGE_MS) {
+        try {
+          unlinkSync3(join6(cacheDir, file.name));
+          deletedCount++;
+          logger.debug("GC: Deleted old provider-detect file", { file: file.name, ageDays: Math.floor(age / (24 * 60 * 60 * 1000)) });
+        } catch (error) {
+          logger.debug("GC: Failed to delete provider-detect file", { file: file.name, error: String(error) });
+        }
+      }
+    }
+    for (const file of tmpFiles) {
+      const age = now - file.mtime;
+      if (age > GC_ORPHAN_TMP_AGE_MS) {
+        try {
+          unlinkSync3(join6(cacheDir, file.name));
+          deletedCount++;
+          logger.debug("GC: Deleted orphaned tmp file", { file: file.name, ageMinutes: Math.floor(age / (60 * 1000)) });
+        } catch (error) {
+          logger.debug("GC: Failed to delete tmp file", { file: file.name, error: String(error) });
+        }
+      }
+    }
+    const remainingCacheFiles = cacheFiles.filter((file) => {
+      const age = now - file.mtime;
+      return age <= GC_MAX_AGE_MS;
+    });
+    if (remainingCacheFiles.length > GC_MAX_CACHE_FILES) {
+      remainingCacheFiles.sort((a, b) => a.mtime - b.mtime);
+      const toDelete = remainingCacheFiles.slice(0, remainingCacheFiles.length - GC_MAX_CACHE_FILES);
+      for (const file of toDelete) {
+        try {
+          unlinkSync3(join6(cacheDir, file.name));
+          deletedCount++;
+          logger.debug("GC: Deleted cache file (count limit)", { file: file.name });
+        } catch (error) {
+          logger.debug("GC: Failed to delete cache file", { file: file.name, error: String(error) });
+        }
+      }
+    }
+    logger.debug("GC: Garbage collection completed", { deletedCount });
+  } catch (error) {
+    logger.debug("GC: Garbage collection failed", { error: String(error) });
   }
 }
-function getExistingStatusLine() {
-  const settings = loadClaudeSettings();
-  return settings.statusLine?.command ?? null;
+
+// src/cli/piped-mode.ts
+function buildExecutionContext(args, isPiped, startTime) {
+  return (async () => {
+    const env = readCurrentEnv();
+    logger.debug("Environment loaded", {
+      baseUrl: env.baseUrl ? `${env.baseUrl.substring(0, 30)}...` : undefined,
+      hasToken: !!env.authToken,
+      providerOverride: env.providerOverride,
+      pollIntervalOverride: env.pollIntervalOverride
+    });
+    const envError = validateRequiredEnv(env);
+    if (envError) {
+      const errorOutput = renderError("missing-env", "without-cache");
+      process.stdout.write(errorOutput);
+      process.exit(0);
+    }
+    const baseUrl = env.baseUrl;
+    const authToken = env.authToken;
+    if (!baseUrl || !authToken) {
+      process.exit(1);
+    }
+    const config = loadConfig(args.configPath);
+    const configPath = getConfigPath(args.configPath);
+    const configHash = computeConfigHash(configPath);
+    logger.debug("Config loaded", { configPath, configHash });
+    const probeTimeout = isPiped ? Math.min(1500, Math.max(200, Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 1000) - 200)) : 3000;
+    const providerId = await resolveProvider(baseUrl, env.providerOverride, config.customProviders ?? {}, probeTimeout);
+    const provider = getProvider(providerId, config.customProviders ?? {});
+    logger.debug("Provider resolved", { providerId, probeTimeout });
+    if (!provider) {
+      logger.error("Provider not found", { providerId });
+      const errorOutput = renderError("provider-unknown", "without-cache");
+      process.stdout.write(errorOutput);
+      process.exit(0);
+    }
+    const cachedEntry = readCache(baseUrl);
+    logger.debug("Cache read", {
+      cacheHit: !!cachedEntry,
+      cacheAge: cachedEntry ? `${Math.floor((Date.now() - new Date(cachedEntry.fetchedAt).getTime()) / 1000)}s` : "N/A"
+    });
+    const timeoutBudgetMs = isPiped ? Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 1000) : 1e4;
+    const fetchTimeoutMs = isPiped ? Math.min(config.pipedRequestTimeoutMs ?? 800, timeoutBudgetMs - 100) : 1e4;
+    const ctx = {
+      env,
+      config,
+      configHash,
+      cachedEntry,
+      providerId,
+      provider,
+      timeoutBudgetMs,
+      startTime,
+      fetchTimeoutMs
+    };
+    return { ctx, baseUrl };
+  })();
 }
-function isBunxAvailable() {
-  try {
-    execSync2("which bunx", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
+function formatOutput(output, isPiped) {
+  let normalizedOutput = output;
+  if (!normalizedOutput || normalizedOutput.trim().length === 0) {
+    logger.debug("Empty output detected, using fallback");
+    normalizedOutput = "[loading...]";
   }
-}
-function installStatusLine(runner) {
-  const settings = loadClaudeSettings();
-  settings.statusLine = {
-    type: "command",
-    command: `${runner} -y cc-api-statusline@latest`,
-    padding: 0
-  };
-  saveClaudeSettings(settings);
-}
-function uninstallStatusLine() {
-  const settings = loadClaudeSettings();
-  if ("statusLine" in settings) {
-    delete settings.statusLine;
-    saveClaudeSettings(settings);
+  if (isPiped) {
+    logger.debug("Output formatted for piped mode (ANSI reset + NBSP)");
+    return "\x1B[0m" + normalizedOutput.replace(/ /g, " ");
+  } else {
+    logger.debug("Output written (TTY mode)");
+    return normalizedOutput;
   }
 }
-// package.json
-var package_default = {
-  name: "cc-api-statusline",
-  version: "0.1.3",
-  description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
-  type: "module",
-  bin: {
-    "cc-api-statusline": "dist/cc-api-statusline.js"
-  },
-  scripts: {
-    start: "bun run src/main.ts --once",
-    dev: "bun run src/main.ts",
-    example: "cat docs/fixtures/ccstatusline-context.sample.json | bun run src/main.ts",
-    test: "bun run build && vitest run",
-    "test:watch": "vitest",
-    lint: "eslint src",
-    build: "bun build src/main.ts --target=node --outfile=dist/cc-api-statusline.js",
-    check: "bun run test && bun run lint",
-    prepublishOnly: "bun run check"
-  },
-  files: [
-    "dist/"
-  ],
-  keywords: [
-    "claude",
-    "statusline",
-    "api",
-    "usage",
-    "monitoring",
-    "tui",
-    "cli"
-  ],
-  author: "Liafonx",
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/liafonx/cc-api-statusline.git"
-  },
-  homepage: "https://github.com/liafonx/cc-api-statusline#readme",
-  bugs: {
-    url: "https://github.com/liafonx/cc-api-statusline/issues"
-  },
-  dependencies: {},
-  devDependencies: {
-    "@eslint/js": "^9.17.0",
-    "@types/bun": "^1.1.14",
-    eslint: "^9.17.0",
-    typescript: "^5.7.2",
-    "typescript-eslint": "^8.18.2",
-    vitest: "^2.1.8"
-  },
-  engines: {
-    node: ">=18.0.0"
-  },
-  publishConfig: {
-    provenance: true
-  }
-};
-
-// src/main.ts
-function parseArgs() {
-  const args = process.argv.slice(2);
-  let help = false;
-  let version = false;
-  let once = false;
-  let install = false;
-  let uninstall = false;
-  let force = false;
-  let configPath;
-  let runner;
-  for (let i = 0;i < args.length; i++) {
-    const arg = args[i];
-    if (arg === "--help" || arg === "-h") {
-      help = true;
-    } else if (arg === "--version" || arg === "-v") {
-      version = true;
-    } else if (arg === "--once") {
-      once = true;
-    } else if (arg === "--install") {
-      install = true;
-    } else if (arg === "--uninstall") {
-      uninstall = true;
-    } else if (arg === "--force") {
-      force = true;
-    } else if (arg === "--config" && i + 1 < args.length) {
-      configPath = args[i + 1];
-      i++;
-    } else if (arg === "--runner" && i + 1 < args.length) {
-      const nextArg = args[i + 1];
-      if (nextArg === "npx" || nextArg === "bunx") {
-        runner = nextArg;
-      }
-      i++;
-    }
+async function executePipedMode(args) {
+  const startTime = Date.now();
+  logger.debug("=== cc-api-statusline execution started ===");
+  logger.debug("Start time", { startTime });
+  const isPiped = !process.stdin.isTTY;
+  logger.debug("Mode detection", { isPiped, once: args.once });
+  const { ctx, baseUrl } = await buildExecutionContext(args, isPiped, startTime);
+  logger.debug("Execution context prepared", {
+    timeoutBudgetMs: ctx.timeoutBudgetMs,
+    fetchTimeoutMs: ctx.fetchTimeoutMs
+  });
+  const result = await executeCycle(ctx);
+  const executionTime = Date.now() - startTime;
+  logger.debug("Execution completed", {
+    exitCode: result.exitCode,
+    executionTime: `${executionTime}ms`,
+    outputLength: result.output.length,
+    cacheUpdate: !!result.cacheUpdate
+  });
+  const formattedOutput = formatOutput(result.output, isPiped);
+  process.stdout.write(formattedOutput);
+  if (result.cacheUpdate) {
+    writeCache(baseUrl, result.cacheUpdate);
+    logger.debug("Cache written", { baseUrl });
+    runCacheGC(getCacheDir());
   }
-  return { help, version, once, install, uninstall, force, configPath, runner };
-}
-function showHelp() {
-  console.log(`
-cc-api-statusline — Claude API statusline widget
-
-Usage:
-  cc-api-statusline [options]
-
-Options:
-  --help, -h         Show this help message
-  --version, -v      Show version
-  --once             Fetch once and exit (no polling)
-  --config <path>    Use custom config file
-  --install          Register as Claude Code statusline widget
-  --uninstall        Remove statusline widget registration
-  --runner <runner>  Package runner: npx or bunx (default: auto-detect)
-  --force            Force overwrite existing statusline configuration
-
-Environment Variables:
-  ANTHROPIC_BASE_URL       API endpoint (required)
-  ANTHROPIC_AUTH_TOKEN     API key (required)
-  CC_STATUSLINE_PROVIDER   Override provider detection
-  CC_STATUSLINE_POLL       Override poll interval (seconds)
-  CC_STATUSLINE_TIMEOUT    Piped mode timeout (milliseconds, default 1000)
-  DEBUG or CC_STATUSLINE_DEBUG  Enable debug logging to ~/.claude/cc-api-statusline/debug.log
-
-Config File:
-  ~/.claude/cc-api-statusline/config.json
-
-Documentation:
-  https://github.com/liafonx/cc-api-statusline
-  `.trim());
-}
-function showVersion() {
-  console.log(`cc-api-statusline v${package_default.version}`);
+  logger.debug("=== cc-api-statusline execution completed ===");
+  process.exit(result.exitCode);
 }
+// src/main.ts
 function discardStdin() {
   if (!process.stdin.isTTY) {
     process.stdin.resume();
@@ -2362,9 +2745,7 @@ function discardStdin() {
   }
 }
 async function main() {
-  const startTime = Date.now();
-  logger.debug("=== cc-api-statusline execution started ===");
-  logger.debug("Start time", { startTime, version: package_default.version });
+  logger.debug("=== cc-api-statusline execution started ===", { version: package_default.version });
   discardStdin();
   const args = parseArgs();
   logger.debug("Parsed arguments", { args });
@@ -2377,119 +2758,22 @@ async function main() {
     process.exit(0);
   }
   if (args.install) {
-    const existing = getExistingStatusLine();
-    if (existing && !args.force) {
-      console.error("Error: statusLine is already configured in settings.json");
-      console.error(`Current command: ${existing}`);
-      console.error("Use --force to overwrite, or --uninstall to remove first.");
-      process.exit(1);
-    }
-    const runner = args.runner ?? (isBunxAvailable() ? "bunx" : "npx");
-    installStatusLine(runner);
-    console.log("✓ Statusline installed successfully!");
-    console.log(`  Runner: ${runner}`);
-    console.log(`  Command: ${runner} -y cc-api-statusline@latest`);
-    console.log(`  Config: ~/.claude/settings.json`);
-    process.exit(0);
+    handleInstall(args);
+    return;
   }
   if (args.uninstall) {
-    const existing = getExistingStatusLine();
-    if (!existing) {
-      console.log("No statusLine configuration found in settings.json");
-      process.exit(0);
-    }
-    uninstallStatusLine();
-    console.log("✓ Statusline uninstalled successfully");
-    console.log("  Removed statusLine from ~/.claude/settings.json");
-    process.exit(0);
+    handleUninstall();
+    return;
   }
-  const isPiped = !process.stdin.isTTY;
-  logger.debug("Mode detection", { isPiped, once: args.once });
-  if (!isPiped && !args.once) {
+  if (process.stdin.isTTY && !args.once) {
     console.log("Interactive configuration mode coming soon.");
     console.log("Use --once for a single fetch, or configure as a Claude Code statusline command.");
     process.exit(0);
   }
-  const env = readCurrentEnv();
-  logger.debug("Environment loaded", {
-    baseUrl: env.baseUrl ? `${env.baseUrl.substring(0, 30)}...` : undefined,
-    hasToken: !!env.authToken,
-    providerOverride: env.providerOverride,
-    pollIntervalOverride: env.pollIntervalOverride
-  });
-  const envError = validateRequiredEnv(env);
-  if (envError) {
-    const errorOutput = renderError("missing-env", "without-cache");
-    process.stdout.write(errorOutput);
-    process.exit(0);
-  }
-  const baseUrl = env.baseUrl;
-  const authToken = env.authToken;
-  if (!baseUrl || !authToken) {
-    process.exit(1);
-  }
-  const config = loadConfig(args.configPath);
-  const configPath = getConfigPath(args.configPath);
-  const configHash = computeConfigHash(configPath);
-  logger.debug("Config loaded", { configPath, configHash });
-  const probeTimeout = isPiped ? Math.min(1500, Math.max(200, Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 1000) - 200)) : 3000;
-  const providerId = await resolveProvider(baseUrl, env.providerOverride, config.customProviders ?? {}, probeTimeout);
-  const provider = getProvider(providerId, config.customProviders ?? {});
-  logger.debug("Provider resolved", { providerId, probeTimeout });
-  if (!provider) {
-    logger.error("Provider not found", { providerId });
-    const errorOutput = renderError("provider-unknown", "without-cache");
-    process.stdout.write(errorOutput);
-    process.exit(0);
-  }
-  const cachedEntry = readCache(baseUrl);
-  logger.debug("Cache read", {
-    cacheHit: !!cachedEntry,
-    cacheAge: cachedEntry ? `${Math.floor((Date.now() - new Date(cachedEntry.fetchedAt).getTime()) / 1000)}s` : "N/A"
-  });
-  const timeoutBudgetMs = isPiped ? Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 1000) : 1e4;
-  const fetchTimeoutMs = isPiped ? Math.min(config.pipedRequestTimeoutMs ?? 800, timeoutBudgetMs - 100) : 1e4;
-  const ctx = {
-    env,
-    config,
-    configHash,
-    cachedEntry,
-    providerId,
-    provider,
-    timeoutBudgetMs,
-    startTime,
-    fetchTimeoutMs
-  };
-  logger.debug("Execution context prepared", { timeoutBudgetMs, fetchTimeoutMs });
-  const result = await executeCycle(ctx);
-  const executionTime = Date.now() - startTime;
-  logger.debug("Execution completed", {
-    exitCode: result.exitCode,
-    executionTime: `${executionTime}ms`,
-    outputLength: result.output.length,
-    cacheUpdate: !!result.cacheUpdate
-  });
-  let output = result.output;
-  if (!output || output.trim().length === 0) {
-    output = "[loading...]";
-    logger.debug("Empty output detected, using fallback");
-  }
-  if (isPiped) {
-    const formatted = "\x1B[0m" + output.replace(/ /g, " ");
-    process.stdout.write(formatted);
-    logger.debug("Output formatted for piped mode (ANSI reset + NBSP)");
-  } else {
-    process.stdout.write(output);
-    logger.debug("Output written (TTY mode)");
-  }
-  if (result.cacheUpdate) {
-    writeCache(baseUrl, result.cacheUpdate);
-    logger.debug("Cache updated");
-  }
-  logger.debug("=== Execution finished ===", { exitCode: result.exitCode });
-  process.exit(result.exitCode);
+  await executePipedMode(args);
 }
 main().catch((error) => {
-  console.error("Fatal error:", error);
+  logger.error("Unhandled error in main", { error: String(error) });
+  console.error(`Fatal error: ${error}`);
   process.exit(1);
 });