cc-api-statusline 0.2.1 → 1.0.0

package/dist/cc-api-statusline.js

@@ -4,7 +4,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // package.json
 var package_default = {
   name: "cc-api-statusline",
-  version: "0.2.1",
+  version: "1.0.0",
   description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
   type: "module",
   bin: {
@@ -68,6 +68,7 @@ function parseArgs() {
   let once = false;
   let install = false;
   let uninstall = false;
+  let applyConfig = false;
   let force = false;
   let configPath;
   let runner;
@@ -83,6 +84,8 @@ function parseArgs() {
       install = true;
     } else if (arg === "--uninstall") {
       uninstall = true;
+    } else if (arg === "--apply-config") {
+      applyConfig = true;
     } else if (arg === "--force") {
       force = true;
     } else if (arg === "--config" && i + 1 < args.length) {
@@ -96,7 +99,7 @@ function parseArgs() {
       i++;
     }
   }
-  return { help, version, once, install, uninstall, force, configPath, runner };
+  return { help, version, once, install, uninstall, applyConfig, force, configPath, runner };
 }
 function showHelp() {
   console.log(`
@@ -110,8 +113,9 @@ Options:
   --version, -v      Show version
   --once             Fetch once and exit (no polling)
   --config <path>    Use custom config file
-  --install          Register as Claude Code statusline widget
+  --install          Register as Claude Code statusline widget and create default configs
   --uninstall        Remove statusline widget registration
+  --apply-config     Apply endpoint config changes (updates lock file, clears caches)
   --runner <runner>  Package runner: npx or bunx (default: auto-detect)
   --force            Force overwrite existing statusline configuration
 
@@ -134,13 +138,13 @@ 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 { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
 import { execSync } from "child_process";
 
 // src/services/env.ts
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { readFileSync } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/services/hash.ts
 function sha256(input) {
@@ -157,21 +161,193 @@ function shortHash(input, length = 12) {
   return fullHash.slice(0, length);
 }
 
+// src/services/logger.ts
+import { appendFileSync } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
+
+// src/services/ensure-dir.ts
+import { mkdirSync } from "fs";
+function ensureDir(dirPath) {
+  mkdirSync(dirPath, { recursive: true, mode: 448 });
+}
+
+// src/services/log-rotator.ts
+import { statSync, renameSync, readdirSync, unlinkSync } from "fs";
+import { spawn } from "child_process";
+import { dirname, join } from "path";
+
+// 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;
+var LOG_ROTATION_PROBABILITY = 0.05;
+var LOG_MAX_SIZE_BYTES = 512 * 1024;
+var LOG_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+var LOG_RETENTION_MS = 3 * 24 * 60 * 60 * 1000;
+
+// src/services/log-rotator.ts
+var ARCHIVE_LOG_RE = /^debug\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}\.log$/;
+var ARCHIVE_GZ_RE = /^debug\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}\.log\.gz$/;
+function archiveName(logPath, now = new Date) {
+  const pad = (n) => n.toString().padStart(2, "0");
+  const y = now.getFullYear();
+  const mo = pad(now.getMonth() + 1);
+  const d = pad(now.getDate());
+  const h = pad(now.getHours());
+  const min = pad(now.getMinutes());
+  return join(dirname(logPath), `debug.${y}-${mo}-${d}T${h}-${min}.log`);
+}
+function spawnGzip(filePath) {
+  try {
+    const child = spawn("gzip", ["-f", filePath], {
+      detached: true,
+      stdio: "ignore"
+    });
+    child.unref();
+  } catch {}
+}
+function runCleanup(logDir, excludePath) {
+  try {
+    const files = readdirSync(logDir);
+    const now = Date.now();
+    for (const name of files) {
+      const filePath = join(logDir, name);
+      if (filePath === excludePath)
+        continue;
+      if (ARCHIVE_LOG_RE.test(name)) {
+        const s = statSync(filePath, { throwIfNoEntry: false });
+        if (s && now - s.mtimeMs >= LOG_MAX_AGE_MS) {
+          spawnGzip(filePath);
+        }
+        continue;
+      }
+      if (ARCHIVE_GZ_RE.test(name)) {
+        const s = statSync(filePath, { throwIfNoEntry: false });
+        if (s && now - s.mtimeMs >= LOG_RETENTION_MS) {
+          try {
+            unlinkSync(filePath);
+          } catch {}
+        }
+      }
+    }
+  } catch {}
+}
+function maybeRotateLogs(logPath) {
+  if (Math.random() > LOG_ROTATION_PROBABILITY)
+    return;
+  const logDir = dirname(logPath);
+  const stat = statSync(logPath, { throwIfNoEntry: false });
+  let rotatedArchive = null;
+  if (stat) {
+    const age = Date.now() - stat.mtimeMs;
+    const archive = archiveName(logPath);
+    try {
+      if (age >= LOG_MAX_AGE_MS) {
+        renameSync(logPath, archive);
+        spawnGzip(archive);
+        rotatedArchive = archive;
+      } else if (stat.size >= LOG_MAX_SIZE_BYTES) {
+        renameSync(logPath, archive);
+        rotatedArchive = archive;
+      }
+    } catch {}
+  }
+  runCleanup(logDir, rotatedArchive);
+}
+
+// src/services/paths.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+function getConfigDir() {
+  return join2(homedir(), ".claude", "cc-api-statusline");
+}
+
+// src/services/logger.ts
+class Logger {
+  enabled;
+  logPath;
+  constructor() {
+    this.enabled = !!(process.env["DEBUG"] || process.env["CC_STATUSLINE_DEBUG"]);
+    const logDir = process.env["CC_API_STATUSLINE_LOG_DIR"] || getConfigDir();
+    this.logPath = join3(logDir, "debug.log");
+    if (this.enabled) {
+      this.ensureLogDir();
+      maybeRotateLogs(this.logPath);
+    }
+  }
+  ensureLogDir() {
+    try {
+      const dir = dirname2(this.logPath);
+      ensureDir(dir);
+    } catch {
+      this.enabled = false;
+    }
+  }
+  formatLocalTimestamp() {
+    const d = new Date;
+    const pad = (n, len = 2) => n.toString().padStart(len, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+  }
+  format(level, message, data) {
+    const timestamp = this.formatLocalTimestamp();
+    const dataStr = data ? ` ${JSON.stringify(data)}` : "";
+    return `[${timestamp}] [${level.toUpperCase()}] ${message}${dataStr}
+`;
+  }
+  write(level, message, data) {
+    if (!this.enabled) {
+      return;
+    }
+    try {
+      const entry = this.format(level, message, data);
+      appendFileSync(this.logPath, entry, { encoding: "utf-8" });
+    } catch {}
+  }
+  debug(message, data) {
+    this.write("debug", message, data);
+  }
+  info(message, data) {
+    this.write("info", message, data);
+  }
+  warn(message, data) {
+    this.write("warn", message, data);
+  }
+  error(message, data) {
+    this.write("error", message, data);
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  getLogPath() {
+    return this.logPath;
+  }
+}
+var logger = new Logger;
+
 // src/services/env.ts
 function getSettingsJsonPath() {
   const configDir = process.env["CLAUDE_CONFIG_DIR"];
   if (configDir) {
-    return join(configDir, "settings.json");
+    return join4(configDir, "settings.json");
   }
-  return join(homedir(), ".claude", "settings.json");
+  return join4(homedir2(), ".claude", "settings.json");
 }
 function readSettingsJsonEnv() {
   const settingsPath = getSettingsJsonPath();
-  if (!existsSync(settingsPath)) {
-    return {};
+  let content;
+  try {
+    content = readFileSync(settingsPath, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return {};
+    }
+    throw err;
   }
   try {
-    const content = readFileSync(settingsPath, "utf-8");
     const settings = JSON.parse(content);
     if (settings["env"] && typeof settings["env"] === "object") {
       const env = settings["env"];
@@ -186,8 +362,8 @@ function readSettingsJsonEnv() {
       return result;
     }
     return {};
-  } catch (error) {
-    console.warn(`Warning: Could not read settings.json: ${error}`);
+  } catch (err) {
+    logger.warn(`Could not read settings.json: ${err}`);
     return {};
   }
 }
@@ -227,25 +403,15 @@ function validateRequiredEnv(env) {
 }
 
 // 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
+import { writeFileSync, renameSync as renameSync2, unlinkSync as unlinkSync2, existsSync, chmodSync } from "fs";
+import { dirname as dirname3 } from "path";
 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);
+      const dir = dirname3(filePath);
       ensureDir(dir);
     }
     const finalContent = appendNewline ? `${content}
@@ -254,11 +420,11 @@ function atomicWriteFile(filePath, content, opts = {}) {
     try {
       chmodSync(tmpPath, mode);
     } catch {}
-    renameSync(tmpPath, filePath);
+    renameSync2(tmpPath, filePath);
   } catch (error) {
     try {
-      if (existsSync3(tmpPath)) {
-        unlinkSync(tmpPath);
+      if (existsSync(tmpPath)) {
+        unlinkSync2(tmpPath);
       }
     } catch {}
     throw new Error(`Failed to write file atomically: ${error}`);
@@ -268,14 +434,14 @@ function atomicWriteFile(filePath, content, opts = {}) {
 // src/services/settings.ts
 function loadClaudeSettings() {
   const path = getSettingsJsonPath();
-  if (!existsSync4(path)) {
+  if (!existsSync2(path)) {
     return {};
   }
   try {
     const content = readFileSync2(path, "utf-8");
     return JSON.parse(content);
   } catch (error) {
-    console.warn(`Failed to read settings from ${path}: ${error}`);
+    logger.warn(`Failed to read settings from ${path}: ${error}`);
     return {};
   }
 }
@@ -321,38 +487,9 @@ function uninstallStatusLine() {
   }
 }
 
-// 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 readFileSync3, existsSync as existsSync5, unlinkSync as unlinkSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
+// src/services/config-defaults.ts
+import { join as join8 } from "path";
+import { existsSync as existsSync4 } from "fs";
 
 // src/types/normalized-usage.ts
 function createEmptyNormalizedUsage(provider, billingMode, planName) {
@@ -385,6 +522,14 @@ function computeSoonestReset(usage) {
   return sorted[0] ?? null;
 }
 // src/types/config.ts
+var DEFAULT_DIVIDER_CONFIG = { text: "|", margin: 1, color: "#555753" };
+var DEFAULT_TIER_THRESHOLDS = [37.5, 62.5, 75, 87.5, 100];
+function buildTiers(colors, thresholds = DEFAULT_TIER_THRESHOLDS) {
+  if (colors.length !== thresholds.length) {
+    throw new Error(`buildTiers: colors.length (${colors.length}) must equal thresholds.length (${thresholds.length})`);
+  }
+  return colors.map((color, i) => ({ color, maxPercent: thresholds[i] }));
+}
 var DEFAULT_CONFIG = {
   display: {
     layout: "standard",
@@ -392,7 +537,7 @@ var DEFAULT_CONFIG = {
     progressStyle: "icon",
     barSize: "medium",
     barStyle: "block",
-    separator: " | ",
+    divider: DEFAULT_DIVIDER_CONFIG,
     maxWidth: 100,
     clockFormat: "24h",
     colorMode: "auto",
@@ -405,28 +550,17 @@ var DEFAULT_CONFIG = {
     balance: true,
     tokens: false,
     rateLimit: false,
-    plan: false,
-    divider: true
+    plan: false
   },
   colors: {
-    auto: {
-      tiers: [
-        { color: "cool", maxPercent: 30 },
-        { color: "comfortable", maxPercent: 65 },
-        { color: "warm", maxPercent: 80 },
-        { color: "hot", maxPercent: 90 },
-        { color: "critical", maxPercent: 100 }
-      ]
-    },
-    chill: {
-      low: "cyan",
-      medium: "blue",
-      high: "magenta",
-      lowThreshold: 50,
-      highThreshold: 80
-    }
+    auto: { tiers: buildTiers(["cool", "comfortable", "warm", "hot", "critical"]) },
+    vibrant: { tiers: buildTiers(["#00D9FF", "#4ADE80", "#FDE047", "#FB923C", "#F87171"]) },
+    pastel: { tiers: buildTiers(["pastel-cool", "pastel-comfortable", "pastel-medium", "pastel-warm", "pastel-hot"]) },
+    bright: { tiers: buildTiers(["bright-cool", "bright-comfortable", "bright-medium", "bright-warm", "bright-hot"]) },
+    ocean: { tiers: buildTiers(["ocean-cool", "ocean-comfortable", "ocean-medium", "ocean-warm", "ocean-hot"]) },
+    neutral: { tiers: buildTiers(["neutral-cool", "neutral-comfortable", "neutral-warm", "neutral-hot", "neutral-critical"]) },
+    chill: { tiers: buildTiers(["cyan", "cyan", "blue", "blue", "magenta"]) }
   },
-  customProviders: {},
   pollIntervalSeconds: 30,
   pipedRequestTimeoutMs: 800
 };
@@ -493,12 +627,12 @@ var DEFAULT_COMPONENT_ORDER = [
   "plan"
 ];
 // src/types/cache.ts
-var CACHE_VERSION = 1;
+var CACHE_VERSION = 2;
 function isCacheEntry(value) {
   if (typeof value !== "object" || value === null)
     return false;
   const c = value;
-  return typeof c["version"] === "number" && typeof c["provider"] === "string" && typeof c["baseUrl"] === "string" && typeof c["tokenHash"] === "string" && typeof c["configHash"] === "string" && typeof c["data"] === "object" && c["data"] !== null && typeof c["renderedLine"] === "string" && typeof c["fetchedAt"] === "string" && typeof c["ttlSeconds"] === "number" && (c["errorState"] === null || typeof c["errorState"] === "object");
+  return typeof c["version"] === "number" && typeof c["provider"] === "string" && typeof c["baseUrl"] === "string" && typeof c["tokenHash"] === "string" && typeof c["configHash"] === "string" && typeof c["endpointConfigHash"] === "string" && typeof c["data"] === "object" && c["data"] !== null && typeof c["renderedLine"] === "string" && typeof c["fetchedAt"] === "string" && typeof c["ttlSeconds"] === "number" && (c["errorState"] === null || typeof c["errorState"] === "object");
 }
 var PROVIDER_DETECTION_TTL_SECONDS = 86400;
 function isProviderDetectionCacheEntry(value) {
@@ -507,150 +641,260 @@ function isProviderDetectionCacheEntry(value) {
   const c = value;
   return typeof c["baseUrl"] === "string" && typeof c["provider"] === "string" && (c["detectedVia"] === "health-probe" || c["detectedVia"] === "url-pattern" || c["detectedVia"] === "override") && typeof c["detectedAt"] === "string" && typeof c["ttlSeconds"] === "number";
 }
-// src/services/cache.ts
-function getCacheDir() {
-  const override = process.env["CC_API_STATUSLINE_CACHE_DIR"];
-  if (override) {
-    return override;
+// src/services/endpoint-config.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
+function getEndpointConfigDir(customRoot) {
+  const envRoot = process.env["CC_API_STATUSLINE_CONFIG_DIR"];
+  const root = customRoot || envRoot || getConfigDir();
+  return join5(root, "api-config");
+}
+function loadEndpointConfigs(customDir) {
+  const configDir = getEndpointConfigDir(customDir);
+  if (!existsSync3(configDir)) {
+    return getBuiltInEndpointConfigs();
+  }
+  const registry = {};
+  const files = readdirSync2(configDir).filter((f) => f.endsWith(".json"));
+  if (files.length === 0) {
+    return getBuiltInEndpointConfigs();
+  }
+  for (const file of files) {
+    const filePath = join5(configDir, file);
+    try {
+      const config = loadEndpointConfigFile(filePath);
+      registry[config.provider] = config;
+    } catch (error) {
+      logger.error(`Failed to load endpoint config ${file}`, { error: String(error) });
+    }
   }
-  return join2(homedir2(), ".claude", "cc-api-statusline");
-}
-function ensureCacheDir() {
-  const dir = getCacheDir();
-  ensureDir(dir);
+  if (Object.keys(registry).length === 0) {
+    return getBuiltInEndpointConfigs();
+  }
+  return registry;
 }
-function getCachePath(baseUrl) {
-  const hash = shortHash(baseUrl, 12);
-  return join2(getCacheDir(), `cache-${hash}.json`);
+function loadEndpointConfigFile(filePath) {
+  const content = readFileSync3(filePath, "utf-8");
+  const data = JSON.parse(content);
+  validateEndpointConfig(data, filePath);
+  return data;
 }
-function readCache(baseUrl) {
-  const path = getCachePath(baseUrl);
-  if (!existsSync5(path)) {
-    return null;
+function validateEndpointConfig(data, filename) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error(`${filename}: Config must be an object`);
   }
-  try {
-    const content = readFileSync3(path, "utf-8");
-    const data = JSON.parse(content);
-    if (!isCacheEntry(data)) {
-      console.warn(`Invalid cache structure at ${path}`);
-      return null;
-    }
-    return data;
-  } catch (error) {
-    console.warn(`Failed to read cache from ${path}: ${error}`);
-    return null;
+  const config = data;
+  if (typeof config.provider !== "string" || !config.provider) {
+    throw new Error(`${filename}: Missing or invalid 'provider' field`);
   }
-}
-function writeCache(baseUrl, entry) {
-  const path = getCachePath(baseUrl);
-  try {
-    ensureCacheDir();
-    const content = JSON.stringify(entry, null, 2);
-    atomicWriteFile(path, content);
-  } catch (error) {
-    console.warn(`Failed to write cache to ${path}: ${error}`);
+  if (typeof config.endpoint !== "object" || config.endpoint === null) {
+    throw new Error(`${filename}: Missing or invalid 'endpoint' field`);
   }
-}
-function isCacheValid(entry, currentEnv) {
-  const fetchedAt = new Date(entry.fetchedAt).getTime();
-  const now = Date.now();
-  const age = now - fetchedAt;
-  const ttlMs = entry.ttlSeconds * 1000;
-  if (age >= ttlMs) {
-    return false;
+  const endpoint = config.endpoint;
+  if (typeof endpoint.path !== "string" || !endpoint.path) {
+    throw new Error(`${filename}: Missing or invalid 'endpoint.path' field`);
   }
-  if (entry.baseUrl !== currentEnv.baseUrl) {
-    return false;
+  if (endpoint.method !== "GET" && endpoint.method !== "POST") {
+    throw new Error(`${filename}: Invalid 'endpoint.method' (must be GET or POST)`);
   }
-  if (entry.version !== CACHE_VERSION) {
-    return false;
+  if (typeof config.auth !== "object" || config.auth === null) {
+    throw new Error(`${filename}: Missing or invalid 'auth' field`);
   }
-  if (entry.tokenHash !== currentEnv.tokenHash) {
-    return false;
+  const auth = config.auth;
+  if (!["bearer-header", "body-key", "custom-header"].includes(auth.type)) {
+    throw new Error(`${filename}: Invalid 'auth.type' (must be bearer-header, body-key, or custom-header)`);
   }
-  return true;
-}
-function isCacheProviderValid(entry, currentProvider) {
-  return entry.provider === currentProvider;
-}
-function isCacheRenderedLineUsable(entry, currentConfigHash) {
-  return entry.configHash === currentConfigHash;
-}
-function computeConfigHash(configPath) {
-  if (!existsSync5(configPath)) {
-    return sha256("").slice(0, 12);
+  if (typeof config.responseMapping !== "object" || config.responseMapping === null) {
+    throw new Error(`${filename}: Missing or invalid 'responseMapping' field`);
   }
-  try {
-    const bytes = readFileSync3(configPath);
-    return shortHash(bytes.toString("utf-8"), 12);
-  } catch (error) {
-    console.warn(`Failed to read config for hash: ${error}`);
-    return sha256("").slice(0, 12);
+  const mapping = config.responseMapping;
+  for (const [key, val] of Object.entries(mapping)) {
+    if (val !== undefined && typeof val !== "string") {
+      throw new Error(`${filename}: responseMapping.${key} must be a string`);
+    }
+  }
+  if (config.displayName !== undefined && typeof config.displayName !== "string") {
+    throw new Error(`${filename}: Invalid 'displayName' field (must be string)`);
+  }
+  if (config.defaults !== undefined && typeof config.defaults !== "object") {
+    throw new Error(`${filename}: Invalid 'defaults' field (must be object)`);
+  }
+  if (config.detection !== undefined && typeof config.detection !== "object") {
+    throw new Error(`${filename}: Invalid 'detection' field (must be object)`);
   }
 }
-var DEFAULT_POLL_INTERVAL_SECONDS = 30;
-function getEffectivePollInterval(config, envOverride) {
-  if (envOverride !== null) {
-    return Math.max(5, envOverride);
+function computeEndpointConfigHash(customDir) {
+  const configDir = getEndpointConfigDir(customDir);
+  if (!existsSync3(configDir)) {
+    const builtIn = getBuiltInEndpointConfigs();
+    const serialized = JSON.stringify(builtIn, Object.keys(builtIn).sort());
+    return shortHash(serialized, 12);
   }
-  const fromConfig = config.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS;
-  return Math.max(5, fromConfig);
+  const files = readdirSync2(configDir).filter((f) => f.endsWith(".json")).sort();
+  if (files.length === 0) {
+    const builtIn = getBuiltInEndpointConfigs();
+    const serialized = JSON.stringify(builtIn, Object.keys(builtIn).sort());
+    return shortHash(serialized, 12);
+  }
+  let combined = "";
+  for (const file of files) {
+    const filePath = join5(configDir, file);
+    try {
+      const content = readFileSync3(filePath, "utf-8");
+      combined += `\x00${file}\x00${content}`;
+    } catch {
+      continue;
+    }
+  }
+  return shortHash(combined, 12);
 }
-function getProviderDetectionCachePath(baseUrl) {
-  const hash = shortHash(baseUrl, 12);
-  return join2(getCacheDir(), `provider-detect-${hash}.json`);
+function getBuiltInEndpointConfigs() {
+  return {
+    sub2api: {
+      provider: "sub2api",
+      displayName: "sub2api",
+      endpoint: {
+        path: "/v1/usage",
+        method: "GET"
+      },
+      auth: {
+        type: "bearer-header"
+      },
+      defaults: {
+        unit: "USD",
+        planName: "Unknown"
+      },
+      detection: {
+        healthMatch: { status: "ok" }
+      },
+      responseMapping: {
+        billingMode: "subscription",
+        planName: "$.planName",
+        "balance.remaining": "$.remaining",
+        "balance.unit": "$.unit",
+        "daily.used": "$.subscription.daily_usage_usd",
+        "daily.limit": "$.subscription.daily_limit_usd",
+        "weekly.used": "$.subscription.weekly_usage_usd",
+        "weekly.limit": "$.subscription.weekly_limit_usd",
+        "monthly.used": "$.subscription.monthly_usage_usd",
+        "monthly.limit": "$.subscription.monthly_limit_usd",
+        "tokenStats.today.requests": "$.usage.today.requests",
+        "tokenStats.today.inputTokens": "$.usage.today.input_tokens",
+        "tokenStats.today.outputTokens": "$.usage.today.output_tokens",
+        "tokenStats.today.cacheCreationTokens": "$.usage.today.cache_creation_tokens",
+        "tokenStats.today.cacheReadTokens": "$.usage.today.cache_read_tokens",
+        "tokenStats.today.totalTokens": "$.usage.today.total_tokens",
+        "tokenStats.today.cost": "$.usage.today.cost",
+        "tokenStats.total.requests": "$.usage.total.requests",
+        "tokenStats.total.inputTokens": "$.usage.total.input_tokens",
+        "tokenStats.total.outputTokens": "$.usage.total.output_tokens",
+        "tokenStats.total.totalTokens": "$.usage.total.total_tokens",
+        "tokenStats.total.cost": "$.usage.total.cost",
+        "tokenStats.rpm": "$.usage.rpm",
+        "tokenStats.tpm": "$.usage.tpm"
+      }
+    },
+    "claude-relay-service": {
+      provider: "claude-relay-service",
+      displayName: "CRS",
+      endpoint: {
+        path: "/apiStats/api/user-stats",
+        method: "POST",
+        contentType: "application/json"
+      },
+      auth: {
+        type: "body-key",
+        bodyField: "apiKey"
+      },
+      defaults: {
+        billingMode: "subscription",
+        planName: "API Key",
+        resetSemantics: "rolling-window"
+      },
+      detection: {
+        urlPatterns: ["/apistats", "/api/user-stats"],
+        healthMatch: { service: "*" }
+      },
+      responseMapping: {
+        billingMode: "subscription",
+        planName: "$.data.name",
+        "daily.used": "$.data.limits.currentDailyCost",
+        "daily.limit": "$.data.limits.dailyCostLimit",
+        "weekly.used": "$.data.limits.weeklyOpusCost",
+        "weekly.limit": "$.data.limits.weeklyOpusCostLimit",
+        "monthly.used": "$.data.limits.currentTotalCost",
+        "monthly.limit": "$.data.limits.totalCostLimit",
+        "tokenStats.total.requests": "$.data.usage.total.requests",
+        "tokenStats.total.inputTokens": "$.data.usage.total.inputTokens",
+        "tokenStats.total.outputTokens": "$.data.usage.total.outputTokens",
+        "tokenStats.total.cacheCreationTokens": "$.data.usage.total.cacheCreateTokens",
+        "tokenStats.total.cacheReadTokens": "$.data.usage.total.cacheReadTokens",
+        "tokenStats.total.totalTokens": "$.data.usage.total.tokens",
+        "tokenStats.total.cost": "$.data.usage.total.cost",
+        "rateLimit.windowSeconds": "$.data.limits.rateLimitWindow",
+        "rateLimit.requestsUsed": "$.data.limits.currentWindowRequests",
+        "rateLimit.requestsLimit": "$.data.limits.rateLimitRequests",
+        "rateLimit.costUsed": "$.data.limits.currentWindowCost",
+        "rateLimit.costLimit": "$.data.limits.rateLimitCost",
+        "rateLimit.remainingSeconds": "$.data.limits.windowRemainingSeconds"
+      }
+    }
+  };
 }
-function readProviderDetectionCache(baseUrl) {
-  const path = getProviderDetectionCachePath(baseUrl);
-  if (!existsSync5(path)) {
-    return null;
+
+// src/services/endpoint-lock.ts
+import { readFileSync as readFileSync4, unlinkSync as unlinkSync3 } from "fs";
+import { join as join6 } from "path";
+function getLockFilePath(customDir) {
+  if (customDir) {
+    return join6(customDir, ".endpoint-config.lock");
   }
+  return join6(getConfigDir(), ".endpoint-config.lock");
+}
+function readEndpointLock(customDir) {
+  const lockPath = getLockFilePath(customDir);
+  let content;
   try {
-    const content = readFileSync3(path, "utf-8");
-    const data = JSON.parse(content);
-    if (!isProviderDetectionCacheEntry(data)) {
-      console.warn(`Invalid provider detection cache structure at ${path}`);
+    content = readFileSync4(lockPath, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
       return null;
     }
-    const detectedAt = new Date(data.detectedAt).getTime();
-    const now = Date.now();
-    const age = now - detectedAt;
-    const ttlMs = data.ttlSeconds * 1000;
-    if (age >= ttlMs) {
-      try {
-        unlinkSync2(path);
-      } catch {}
-      return null;
+    throw err;
+  }
+  try {
+    const data = JSON.parse(content);
+    if (typeof data === "object" && data !== null && "hash" in data && "lockedAt" in data && typeof data.hash === "string" && typeof data.lockedAt === "string") {
+      return {
+        hash: data.hash,
+        lockedAt: data.lockedAt
+      };
     }
-    return data;
-  } catch (error) {
-    console.warn(`Failed to read provider detection cache from ${path}: ${error}`);
+    return null;
+  } catch {
     return null;
   }
 }
-function writeProviderDetectionCache(baseUrl, entry) {
-  const path = getProviderDetectionCachePath(baseUrl);
-  try {
-    ensureCacheDir();
-    const content = JSON.stringify(entry, null, 2);
-    atomicWriteFile(path, content);
-  } catch (error) {
-    console.warn(`Failed to write provider detection cache to ${path}: ${error}`);
-  }
+function writeEndpointLock(hash, customDir) {
+  const lockPath = getLockFilePath(customDir);
+  const entry = {
+    hash,
+    lockedAt: new Date().toISOString()
+  };
+  atomicWriteFile(lockPath, JSON.stringify(entry, null, 2), {
+    ensureParentDir: true,
+    appendNewline: true
+  });
 }
 
 // src/services/config.ts
-import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
-function getConfigDir() {
-  return join3(homedir3(), ".claude", "cc-api-statusline");
-}
+import { readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
 function getConfigPath(customPath) {
   if (customPath) {
     return customPath;
   }
-  return join3(getConfigDir(), "config.json");
+  return join7(getConfigDir(), "config.json");
 }
 function deepMerge(target, source) {
   const result = { ...target };
@@ -670,19 +914,19 @@ function validateConfig(config) {
   let pollIntervalSeconds = config.pollIntervalSeconds;
   let pipedRequestTimeoutMs = config.pipedRequestTimeoutMs;
   if (maxWidth < 20) {
-    console.warn("Warning: display.maxWidth < 20, clamping to 20");
+    logger.warn("display.maxWidth < 20, clamping to 20");
     maxWidth = 20;
   }
   if (maxWidth > 100) {
-    console.warn("Warning: display.maxWidth > 100, clamping to 100");
+    logger.warn("display.maxWidth > 100, clamping to 100");
     maxWidth = 100;
   }
   if (pollIntervalSeconds !== undefined && pollIntervalSeconds < 5) {
-    console.warn("Warning: pollIntervalSeconds < 5, clamping to 5");
+    logger.warn("pollIntervalSeconds < 5, clamping to 5");
     pollIntervalSeconds = 5;
   }
   if (pipedRequestTimeoutMs !== undefined && pipedRequestTimeoutMs < 100) {
-    console.warn("Warning: pipedRequestTimeoutMs < 100, clamping to 100");
+    logger.warn("pipedRequestTimeoutMs < 100, clamping to 100");
     pipedRequestTimeoutMs = 100;
   }
   return {
@@ -695,22 +939,91 @@ function validateConfig(config) {
     pipedRequestTimeoutMs
   };
 }
-function loadConfig(configPath) {
-  const path = getConfigPath(configPath);
-  if (!existsSync6(path)) {
-    return DEFAULT_CONFIG;
-  }
+function parseConfigContent(content, path) {
   try {
-    const content = readFileSync4(path, "utf-8");
     const userConfig = JSON.parse(content);
     const merged = deepMerge(DEFAULT_CONFIG, userConfig);
     return validateConfig(merged);
-  } catch (error) {
-    console.warn(`Warning: Could not load config from ${path}: ${error}`);
-    console.warn("Using default configuration");
+  } catch (err) {
+    logger.warn(`Could not load config from ${path}: ${err}`);
+    logger.warn("Using default configuration");
     return DEFAULT_CONFIG;
   }
 }
+function loadConfigWithHash(configPath) {
+  const path = getConfigPath(configPath);
+  let content;
+  try {
+    content = readFileSync5(path, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return { config: DEFAULT_CONFIG, configHash: shortHash("", 12) };
+    }
+    throw err;
+  }
+  return {
+    config: parseConfigContent(content, path),
+    configHash: shortHash(content, 12)
+  };
+}
+function serializableConfig(config) {
+  const { colors: _colors, ...rest } = config;
+  return rest;
+}
+
+// src/services/config-defaults.ts
+function getDefaultStyleConfig() {
+  return DEFAULT_CONFIG;
+}
+function getDefaultSub2apiConfig() {
+  const configs = getBuiltInEndpointConfigs();
+  const config = configs["sub2api"];
+  if (!config)
+    throw new Error("Built-in sub2api config not found");
+  return config;
+}
+function getDefaultCrsConfig() {
+  const configs = getBuiltInEndpointConfigs();
+  const config = configs["claude-relay-service"];
+  if (!config)
+    throw new Error("Built-in claude-relay-service config not found");
+  return config;
+}
+function writeDefaultConfigs(customDir) {
+  const configDir = customDir || getConfigDir();
+  const configPath = join8(configDir, "config.json");
+  const apiConfigDir = getEndpointConfigDir(customDir);
+  ensureDir(configDir);
+  ensureDir(apiConfigDir);
+  if (!existsSync4(configPath)) {
+    const styleConfigWithoutColors = serializableConfig(getDefaultStyleConfig());
+    atomicWriteFile(configPath, JSON.stringify(styleConfigWithoutColors, null, 2), {
+      appendNewline: true
+    });
+  }
+  const sub2apiPath = join8(apiConfigDir, "sub2api.json");
+  if (!existsSync4(sub2apiPath)) {
+    const sub2apiConfig = getDefaultSub2apiConfig();
+    atomicWriteFile(sub2apiPath, JSON.stringify(sub2apiConfig, null, 2), {
+      appendNewline: true
+    });
+  }
+  const crsPath = join8(apiConfigDir, "crs.json");
+  if (!existsSync4(crsPath)) {
+    const crsConfig = getDefaultCrsConfig();
+    atomicWriteFile(crsPath, JSON.stringify(crsConfig, null, 2), {
+      appendNewline: true
+    });
+  }
+  const currentHash = computeEndpointConfigHash(customDir);
+  writeEndpointLock(currentHash, customDir);
+}
+function needsConfigInit(customDir) {
+  const configDir = customDir || getConfigDir();
+  const configPath = join8(configDir, "config.json");
+  const apiConfigDir = getEndpointConfigDir(customDir);
+  return !existsSync4(configPath) || !existsSync4(apiConfigDir);
+}
 
 // src/providers/http.ts
 class HttpError extends Error {
@@ -816,76 +1129,345 @@ async function secureFetch(url, options = {}, timeoutMs = 5000, userAgent) {
   }
 }
 
-// src/services/user-agent.ts
-import { execSync as execSync2 } from "child_process";
-import { join as join5 } from "path";
-import { homedir as homedir5 } from "os";
+// src/providers/health-probe.ts
+function extractOrigin(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    return url.origin;
+  } catch {
+    return baseUrl;
+  }
+}
+async function probeHealth(baseUrl, timeoutMs = 1500) {
+  const origin = extractOrigin(baseUrl);
+  const healthUrl = `${origin}/health`;
+  logger.debug("Probing health endpoint", { healthUrl, timeoutMs });
+  try {
+    const responseText = await secureFetch(healthUrl, {
+      method: "GET",
+      headers: {
+        Accept: "application/json"
+      }
+    }, timeoutMs);
+    const data = JSON.parse(responseText);
+    logger.debug("Health probe response", { data });
+    if (typeof data["service"] === "string") {
+      logger.debug("Detected provider from service field", { provider: data["service"] });
+      return data["service"];
+    }
+    if (data["status"] === "ok") {
+      logger.debug("Detected sub2api from status: ok pattern");
+      return "sub2api";
+    }
+    logger.debug("Health probe returned unrecognized pattern", { data });
+    return null;
+  } catch (error) {
+    logger.debug("Health probe failed", { error: String(error) });
+    return null;
+  }
+}
 
-// src/services/logger.ts
-import { appendFileSync } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
-import { homedir as homedir4 } from "os";
-class Logger {
-  enabled;
-  logPath;
-  constructor() {
-    this.enabled = !!(process.env["DEBUG"] || process.env["CC_STATUSLINE_DEBUG"]);
-    const logDir = process.env["CC_API_STATUSLINE_LOG_DIR"] || join4(homedir4(), ".claude", "cc-api-statusline");
-    this.logPath = join4(logDir, "debug.log");
-    if (this.enabled) {
-      this.ensureLogDir();
+// src/services/cache.ts
+import { readFileSync as readFileSync6, unlinkSync as unlinkSync4 } from "fs";
+import { join as join9 } from "path";
+function getCacheDir() {
+  const override = process.env["CC_API_STATUSLINE_CACHE_DIR"];
+  if (override) {
+    return override;
+  }
+  return getConfigDir();
+}
+function ensureCacheDir() {
+  const dir = getCacheDir();
+  ensureDir(dir);
+}
+function getCachePath(baseUrl) {
+  const hash = shortHash(baseUrl, 12);
+  return join9(getCacheDir(), `cache-${hash}.json`);
+}
+function readCache(baseUrl) {
+  const path = getCachePath(baseUrl);
+  let content;
+  try {
+    content = readFileSync6(path, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return null;
     }
+    throw err;
   }
-  ensureLogDir() {
-    try {
-      const dir = dirname2(this.logPath);
-      ensureDir(dir);
-    } catch {
-      this.enabled = false;
+  try {
+    const data = JSON.parse(content);
+    if (!isCacheEntry(data)) {
+      logger.warn(`Invalid cache structure at ${path}`);
+      return null;
     }
+    return data;
+  } catch (err) {
+    logger.warn(`Failed to parse cache from ${path}: ${err}`);
+    return null;
   }
-  formatLocalTimestamp() {
-    const d = new Date;
-    const pad = (n, len = 2) => n.toString().padStart(len, "0");
-    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}.${pad(d.getMilliseconds(), 3)}`;
+}
+function writeCache(baseUrl, entry) {
+  const path = getCachePath(baseUrl);
+  try {
+    ensureCacheDir();
+    const content = JSON.stringify(entry, null, 2);
+    atomicWriteFile(path, content);
+  } catch (error) {
+    logger.warn(`Failed to write cache to ${path}: ${error}`);
   }
-  format(level, message, data) {
-    const timestamp = this.formatLocalTimestamp();
-    const dataStr = data ? ` ${JSON.stringify(data)}` : "";
-    return `[${timestamp}] [${level.toUpperCase()}] ${message}${dataStr}
-`;
+}
+function isCacheValid(entry, currentEnv) {
+  const fetchedAt = new Date(entry.fetchedAt).getTime();
+  const now = Date.now();
+  const age = now - fetchedAt;
+  const ttlMs = entry.ttlSeconds * 1000;
+  if (age >= ttlMs) {
+    return false;
   }
-  write(level, message, data) {
-    if (!this.enabled) {
-      return;
+  if (entry.baseUrl !== currentEnv.baseUrl) {
+    return false;
+  }
+  if (entry.version !== CACHE_VERSION) {
+    return false;
+  }
+  if (entry.tokenHash !== currentEnv.tokenHash) {
+    return false;
+  }
+  return true;
+}
+function isCacheProviderValid(entry, currentProvider) {
+  return entry.provider === currentProvider;
+}
+function isCacheRenderedLineUsable(entry, currentConfigHash) {
+  return entry.configHash === currentConfigHash;
+}
+var DEFAULT_POLL_INTERVAL_SECONDS = 30;
+function getEffectivePollInterval(config, envOverride) {
+  if (envOverride !== null) {
+    return Math.max(5, envOverride);
+  }
+  const fromConfig = config.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS;
+  return Math.max(5, fromConfig);
+}
+function getProviderDetectionCachePath(baseUrl) {
+  const hash = shortHash(baseUrl, 12);
+  return join9(getCacheDir(), `provider-detect-${hash}.json`);
+}
+function readProviderDetectionCache(baseUrl) {
+  const path = getProviderDetectionCachePath(baseUrl);
+  let content;
+  try {
+    content = readFileSync6(path, "utf-8");
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return null;
     }
-    try {
-      const entry = this.format(level, message, data);
-      appendFileSync(this.logPath, entry, { encoding: "utf-8" });
-    } catch {}
+    throw err;
   }
-  debug(message, data) {
-    this.write("debug", message, data);
+  try {
+    const data = JSON.parse(content);
+    if (!isProviderDetectionCacheEntry(data)) {
+      logger.warn(`Invalid provider detection cache structure at ${path}`);
+      return null;
+    }
+    const detectedAt = new Date(data.detectedAt).getTime();
+    const now = Date.now();
+    const age = now - detectedAt;
+    const ttlMs = data.ttlSeconds * 1000;
+    if (age >= ttlMs) {
+      try {
+        unlinkSync4(path);
+      } catch {}
+      return null;
+    }
+    return data;
+  } catch (err) {
+    logger.warn(`Failed to parse provider detection cache from ${path}: ${err}`);
+    return null;
   }
-  info(message, data) {
-    this.write("info", message, data);
+}
+function writeProviderDetectionCache(baseUrl, entry) {
+  const path = getProviderDetectionCachePath(baseUrl);
+  try {
+    ensureCacheDir();
+    const content = JSON.stringify(entry, null, 2);
+    atomicWriteFile(path, content);
+  } catch (error) {
+    logger.warn(`Failed to write provider detection cache to ${path}: ${error}`);
   }
-  warn(message, data) {
-    this.write("warn", message, data);
+}
+
+// src/providers/autodetect.ts
+var detectionCache = new Map;
+function detectProviderFromUrlPattern(baseUrl, endpointConfigs = {}, options = {}) {
+  const includeBuiltInPatterns = options.includeBuiltInPatterns ?? true;
+  const fallbackProvider = Object.prototype.hasOwnProperty.call(options, "fallbackProvider") ? options.fallbackProvider ?? null : "sub2api";
+  const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
+  for (const [providerId, config] of Object.entries(endpointConfigs)) {
+    const urlPatterns = config.detection?.urlPatterns;
+    if (urlPatterns && urlPatterns.length > 0) {
+      for (const pattern of urlPatterns) {
+        const normalizedPattern = pattern.toLowerCase();
+        if (normalizedUrl.includes(normalizedPattern)) {
+          return providerId;
+        }
+      }
+    }
+  }
+  if (includeBuiltInPatterns && (normalizedUrl.includes("/apistats") || normalizedUrl.includes("/api/user-stats"))) {
+    return "claude-relay-service";
+  }
+  return fallbackProvider;
+}
+async function resolveProvider(baseUrl, providerOverride, endpointConfigs = {}, probeTimeoutMs = 1500) {
+  if (providerOverride) {
+    logger.debug("Provider override detected", { provider: providerOverride });
+    return providerOverride;
+  }
+  const cached = detectionCache.get(baseUrl);
+  if (cached) {
+    logger.debug("Provider detection cache hit (memory)", { provider: cached.provider });
+    return cached.provider;
+  }
+  const diskCached = readProviderDetectionCache(baseUrl);
+  if (diskCached) {
+    logger.debug("Provider detection cache hit (disk)", {
+      provider: diskCached.provider,
+      detectedVia: diskCached.detectedVia
+    });
+    detectionCache.set(baseUrl, {
+      provider: diskCached.provider,
+      detectedAt: diskCached.detectedAt
+    });
+    return diskCached.provider;
+  }
+  const endpointPatternProvider = detectProviderFromUrlPattern(baseUrl, endpointConfigs, {
+    includeBuiltInPatterns: false,
+    fallbackProvider: null
+  });
+  if (endpointPatternProvider) {
+    logger.debug("Provider detected via endpoint URL pattern", { provider: endpointPatternProvider });
+    cacheProviderDetection(baseUrl, endpointPatternProvider, "url-pattern");
+    return endpointPatternProvider;
+  }
+  logger.debug("Attempting health probe", { baseUrl, timeoutMs: probeTimeoutMs });
+  const probedProvider = await probeHealth(baseUrl, probeTimeoutMs);
+  if (probedProvider) {
+    logger.debug("Provider detected via health probe", { provider: probedProvider });
+    cacheProviderDetection(baseUrl, probedProvider, "health-probe");
+    return probedProvider;
+  }
+  const patternProvider = detectProviderFromUrlPattern(baseUrl, {});
+  if (!patternProvider) {
+    logger.debug("Provider URL pattern detection had no match, defaulting to sub2api");
+    cacheProviderDetection(baseUrl, "sub2api", "url-pattern");
+    return "sub2api";
+  }
+  logger.debug("Provider detected via built-in URL pattern", { provider: patternProvider });
+  cacheProviderDetection(baseUrl, patternProvider, "url-pattern");
+  return patternProvider;
+}
+function cacheProviderDetection(baseUrl, provider, detectedVia) {
+  const now = new Date().toISOString();
+  detectionCache.set(baseUrl, {
+    provider,
+    detectedAt: now
+  });
+  writeProviderDetectionCache(baseUrl, {
+    baseUrl,
+    provider,
+    detectedVia,
+    detectedAt: now,
+    ttlSeconds: PROVIDER_DETECTION_TTL_SECONDS
+  });
+}
+function clearDetectionCache() {
+  detectionCache.clear();
+}
+
+// src/cli/commands.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, unlinkSync as unlinkSync5 } from "fs";
+import { join as join10 } from "path";
+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);
   }
-  error(message, data) {
-    this.write("error", message, data);
+  const runner = args.runner ?? (isBunxAvailable() ? "bunx" : "npx");
+  console.log("Creating default configuration files...");
+  writeDefaultConfigs();
+  console.log("✓ Config files created:");
+  console.log("  - ~/.claude/cc-api-statusline/config.json");
+  console.log("  - ~/.claude/cc-api-statusline/api-config/sub2api.json");
+  console.log("  - ~/.claude/cc-api-statusline/api-config/crs.json");
+  console.log("  - ~/.claude/cc-api-statusline/.endpoint-config.lock");
+  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);
   }
-  isEnabled() {
-    return this.enabled;
+  uninstallStatusLine();
+  console.log("✓ Statusline uninstalled successfully");
+  console.log("  Removed statusLine from ~/.claude/settings.json");
+  process.exit(0);
+}
+function handleApplyConfig() {
+  console.log("Applying endpoint configuration changes...");
+  const currentHash = computeEndpointConfigHash();
+  console.log(`Current endpoint config hash: ${currentHash}`);
+  clearDetectionCache();
+  console.log("✓ Provider detection cache cleared");
+  const cacheDir = getCacheDir();
+  let failCount = 0;
+  if (existsSync5(cacheDir)) {
+    const files = readdirSync3(cacheDir).filter((f) => f.startsWith("cache-") && f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const filePath = join10(cacheDir, file);
+        unlinkSync5(filePath);
+      } catch {
+        failCount++;
+      }
+    }
+    if (failCount > 0) {
+      console.log(`⚠ Cleared ${files.length - failCount}/${files.length} cache files (${failCount} failed)`);
+    } else {
+      console.log(`✓ Cleared ${files.length} data cache file(s)`);
+    }
   }
-  getLogPath() {
-    return this.logPath;
+  writeEndpointLock(currentHash);
+  console.log("✓ Lock file updated");
+  console.log("");
+  console.log("✓ Endpoint config changes applied successfully!");
+  console.log("  Changes will take effect on next statusline refresh.");
+  console.log("");
+  console.log("Config files:");
+  const apiConfigDir = getEndpointConfigDir();
+  if (existsSync5(apiConfigDir)) {
+    const configFiles = readdirSync3(apiConfigDir).filter((f) => f.endsWith(".json"));
+    for (const file of configFiles) {
+      console.log(`  - ${apiConfigDir}/${file}`);
+    }
   }
+  process.exit(0);
 }
-var logger = new Logger;
-
 // src/services/user-agent.ts
+import { execSync as execSync2 } from "child_process";
+import { join as join11 } from "path";
+import { homedir as homedir3 } from "os";
 var FALLBACK_UA = "claude-cli/2.1.56 (external, cli)";
 function resolveUserAgent(config) {
   if (!config) {
@@ -912,10 +1494,10 @@ function detectClaudeVersion() {
     if (!process.env["CLAUDECODE"]) {
       return null;
     }
-    const claudePath = join5(homedir5(), ".claude", "bin", "claude");
+    const claudePath = join11(homedir3(), ".claude", "bin", "claude");
     const result = execSync2(`"${claudePath}" --version`, {
       encoding: "utf-8",
-      timeout: 1000,
+      timeout: 100,
       stdio: ["ignore", "pipe", "ignore"]
     });
     const match = result.match(/(\d+\.\d+\.\d+)/);
@@ -942,15 +1524,6 @@ function createQuotaWindow(used, limit, 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)
@@ -1027,44 +1600,6 @@ async function fetchSub2api(baseUrl, token, config, timeoutMs = DEFAULT_FETCH_TI
   };
 }
 
-// src/providers/health-probe.ts
-function extractOrigin(baseUrl) {
-  try {
-    const url = new URL(baseUrl);
-    return url.origin;
-  } catch {
-    return baseUrl;
-  }
-}
-async function probeHealth(baseUrl, timeoutMs = 1500) {
-  const origin = extractOrigin(baseUrl);
-  const healthUrl = `${origin}/health`;
-  logger.debug("Probing health endpoint", { healthUrl, timeoutMs });
-  try {
-    const responseText = await secureFetch(healthUrl, {
-      method: "GET",
-      headers: {
-        Accept: "application/json"
-      }
-    }, timeoutMs);
-    const data = JSON.parse(responseText);
-    logger.debug("Health probe response", { data });
-    if (typeof data["service"] === "string") {
-      logger.debug("Detected provider from service field", { provider: data["service"] });
-      return data["service"];
-    }
-    if (data["status"] === "ok") {
-      logger.debug("Detected sub2api from status: ok pattern");
-      return "sub2api";
-    }
-    logger.debug("Health probe returned unrecognized pattern", { data });
-    return null;
-  } catch (error) {
-    logger.debug("Health probe failed", { error: String(error) });
-    return null;
-  }
-}
-
 // src/services/time.ts
 function computeNextMidnightLocal() {
   const now = new Date;
@@ -1158,7 +1693,7 @@ async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = DEFAU
   };
 }
 
-// src/providers/custom-mapping.ts
+// src/providers/response-mapping.ts
 function resolveJsonPath(data, path) {
   if (!path.startsWith("$.")) {
     return path;
@@ -1236,11 +1771,11 @@ function extractTokenStatsPeriod(data, mapping, prefix) {
     cost: extractNumber(data, mapping[`${prefix}.cost`]) ?? 0
   };
 }
-function mapResponseToUsage(responseData, mapping, providerConfig) {
+function mapResponseToUsage(responseData, mapping, endpointConfig) {
   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 planName = extractString(responseData, mapping.planName, endpointConfig.displayName ?? endpointConfig.provider);
+  const base = createEmptyNormalizedUsage(endpointConfig.provider, billingMode, planName);
   const balance = mapping["balance.remaining"] ? (() => {
     const remaining = extractNumber(responseData, mapping["balance.remaining"]);
     if (remaining === null)
@@ -1277,19 +1812,17 @@ function mapResponseToUsage(responseData, mapping, providerConfig) {
       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;
-  })();
+  const resetsAt = computeSoonestReset({
+    ...base,
+    resetSemantics: billingMode === "balance" ? "expiry" : "end-of-day",
+    balance,
+    daily,
+    weekly,
+    monthly,
+    tokenStats,
+    rateLimit,
+    resetsAt: null
+  });
   return {
     ...base,
     resetSemantics: billingMode === "balance" ? "expiry" : "end-of-day",
@@ -1303,159 +1836,75 @@ function mapResponseToUsage(responseData, mapping, providerConfig) {
   };
 }
 
-// src/providers/custom.ts
-function validateCustomProvider(providerConfig) {
-  if (!providerConfig.id)
-    return "Custom provider missing required field: id";
-  if (!providerConfig.endpoint)
-    return "Custom provider missing required field: endpoint";
-  if (!providerConfig.method)
-    return "Custom provider missing required field: method";
-  if (!providerConfig.auth)
-    return "Custom provider missing required field: auth";
-  if (!providerConfig.responseMapping)
-    return "Custom provider missing required field: responseMapping";
-  if (!providerConfig.endpoint.startsWith("/")) {
-    return "Custom provider endpoint must start with /";
-  }
-  if (!providerConfig.responseMapping.billingMode) {
-    return "Custom provider responseMapping must include billingMode";
-  }
-  if (providerConfig.auth.type === "header" && !providerConfig.auth.header) {
-    return 'Custom provider auth.type="header" requires auth.header';
-  }
-  if (providerConfig.auth.type === "body" && !providerConfig.auth.bodyField) {
-    return 'Custom provider auth.type="body" requires auth.bodyField';
-  }
-  if (providerConfig.urlPatterns && !Array.isArray(providerConfig.urlPatterns)) {
-    return "Custom provider urlPatterns must be an array";
+// src/providers/endpoint-fetch.ts
+function validateEndpointConfigSemantics(config) {
+  if (!config.provider)
+    return "Endpoint config missing required field: provider";
+  if (!config.endpoint?.path)
+    return "Endpoint config missing required field: endpoint.path";
+  if (!config.endpoint?.method)
+    return "Endpoint config missing required field: endpoint.method";
+  if (!config.auth)
+    return "Endpoint config missing required field: auth";
+  if (!config.responseMapping)
+    return "Endpoint config missing required field: responseMapping";
+  if (!config.endpoint.path.startsWith("/")) {
+    return "Endpoint path must start with /";
+  }
+  if (config.auth.type === "custom-header" && !config.auth.header) {
+    return 'Auth type="custom-header" requires auth.header';
+  }
+  if (config.auth.type === "body-key" && !config.auth.bodyField) {
+    return 'Auth type="body-key" requires auth.bodyField';
   }
   return null;
 }
-async function fetchCustom(baseUrl, token, appConfig, providerConfig, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
-  const validationError = validateCustomProvider(providerConfig);
+async function fetchEndpoint(baseUrl, token, appConfig, endpointConfig, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+  const validationError = validateEndpointConfigSemantics(endpointConfig);
   if (validationError) {
-    throw new Error(`Invalid custom provider providerConfig: ${validationError}`);
+    throw new Error(`Invalid endpoint config: ${validationError}`);
   }
-  const url = `${baseUrl}${providerConfig.endpoint}`;
+  const url = `${baseUrl}${endpointConfig.endpoint.path}`;
   const headers = {
     Accept: "application/json"
   };
-  if (providerConfig.contentType) {
-    headers["Content-Type"] = providerConfig.contentType;
+  if (endpointConfig.endpoint.contentType) {
+    headers["Content-Type"] = endpointConfig.endpoint.contentType;
   }
-  if (providerConfig.auth.type === "header" && providerConfig.auth.header) {
-    const prefix = providerConfig.auth.prefix ?? "";
-    headers[providerConfig.auth.header] = `${prefix}${token}`;
+  if (endpointConfig.auth.type === "bearer-header") {
+    const prefix = endpointConfig.auth.prefix ?? "Bearer ";
+    headers["Authorization"] = `${prefix}${token}`;
+  } else if (endpointConfig.auth.type === "custom-header" && endpointConfig.auth.header) {
+    const prefix = endpointConfig.auth.prefix ?? "";
+    headers[endpointConfig.auth.header] = `${prefix}${token}`;
   }
   let body;
-  if (providerConfig.method === "POST") {
-    if (providerConfig.auth.type === "body" && providerConfig.auth.bodyField) {
-      const bodyObj = { ...providerConfig.requestBody };
-      bodyObj[providerConfig.auth.bodyField] = token;
+  if (endpointConfig.endpoint.method === "POST") {
+    if (endpointConfig.auth.type === "body-key" && endpointConfig.auth.bodyField) {
+      const bodyObj = { ...endpointConfig.requestBody ?? {} };
+      bodyObj[endpointConfig.auth.bodyField] = token;
       body = JSON.stringify(bodyObj);
-    } else if (providerConfig.requestBody) {
-      body = JSON.stringify(providerConfig.requestBody);
+    } else if (endpointConfig.requestBody) {
+      body = JSON.stringify(endpointConfig.requestBody);
     }
   }
-  const providerUA = providerConfig.spoofClaudeCodeUA;
+  const endpointUA = endpointConfig.spoofClaudeCodeUA;
   const globalUA = appConfig.spoofClaudeCodeUA;
-  const effectiveUA = providerUA !== undefined ? providerUA : globalUA;
+  const effectiveUA = endpointUA !== undefined ? endpointUA : globalUA;
   const resolvedUA = resolveUserAgent(effectiveUA);
   if (resolvedUA) {
-    logger.debug(`Using User-Agent for ${providerConfig.id}: ${resolvedUA}`);
+    logger.debug(`Using User-Agent for ${endpointConfig.provider}: ${resolvedUA}`);
   }
   const responseText = await secureFetch(url, {
-    method: providerConfig.method,
+    method: endpointConfig.endpoint.method,
     headers,
     body
   }, timeoutMs, resolvedUA);
   const responseData = JSON.parse(responseText);
-  const result = mapResponseToUsage(responseData, providerConfig.responseMapping, providerConfig);
+  const result = mapResponseToUsage(responseData, endpointConfig.responseMapping, endpointConfig);
   return result;
 }
 
-// src/providers/autodetect.ts
-var detectionCache = new Map;
-function detectProviderFromUrlPattern(baseUrl, customProviders = {}) {
-  const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
-  for (const [providerId, config] of Object.entries(customProviders)) {
-    if (config.urlPatterns && config.urlPatterns.length > 0) {
-      for (const pattern of config.urlPatterns) {
-        const normalizedPattern = pattern.toLowerCase();
-        if (normalizedUrl.includes(normalizedPattern)) {
-          return providerId;
-        }
-      }
-    }
-  }
-  if (normalizedUrl.includes("/apistats") || normalizedUrl.includes("/api/user-stats")) {
-    return "claude-relay-service";
-  }
-  return "sub2api";
-}
-async function resolveProvider(baseUrl, providerOverride, customProviders = {}, probeTimeoutMs = 1500) {
-  if (providerOverride) {
-    logger.debug("Provider override detected", { provider: providerOverride });
-    return providerOverride;
-  }
-  const cached = detectionCache.get(baseUrl);
-  if (cached) {
-    logger.debug("Provider detection cache hit (memory)", { provider: cached.provider });
-    return cached.provider;
-  }
-  const diskCached = readProviderDetectionCache(baseUrl);
-  if (diskCached) {
-    logger.debug("Provider detection cache hit (disk)", {
-      provider: diskCached.provider,
-      detectedVia: diskCached.detectedVia
-    });
-    detectionCache.set(baseUrl, {
-      provider: diskCached.provider,
-      detectedAt: diskCached.detectedAt
-    });
-    return diskCached.provider;
-  }
-  for (const [providerId, config] of Object.entries(customProviders)) {
-    if (config.urlPatterns && config.urlPatterns.length > 0) {
-      const normalizedUrl = baseUrl.toLowerCase().replace(/\/$/, "");
-      for (const pattern of config.urlPatterns) {
-        const normalizedPattern = pattern.toLowerCase();
-        if (normalizedUrl.includes(normalizedPattern)) {
-          logger.debug("Provider detected via custom URL pattern", { provider: providerId, pattern });
-          cacheProviderDetection(baseUrl, providerId, "url-pattern");
-          return providerId;
-        }
-      }
-    }
-  }
-  logger.debug("Attempting health probe", { baseUrl, timeoutMs: probeTimeoutMs });
-  const probedProvider = await probeHealth(baseUrl, probeTimeoutMs);
-  if (probedProvider) {
-    logger.debug("Provider detected via health probe", { provider: probedProvider });
-    cacheProviderDetection(baseUrl, probedProvider, "health-probe");
-    return probedProvider;
-  }
-  const patternProvider = detectProviderFromUrlPattern(baseUrl, {});
-  logger.debug("Provider detected via built-in URL pattern", { provider: patternProvider });
-  cacheProviderDetection(baseUrl, patternProvider, "url-pattern");
-  return patternProvider;
-}
-function cacheProviderDetection(baseUrl, provider, detectedVia) {
-  const now = new Date().toISOString();
-  detectionCache.set(baseUrl, {
-    provider,
-    detectedAt: now
-  });
-  writeProviderDetectionCache(baseUrl, {
-    baseUrl,
-    provider,
-    detectedVia,
-    detectedAt: now,
-    ttlSeconds: PROVIDER_DETECTION_TTL_SECONDS
-  });
-}
-
 // src/providers/index.ts
 var BUILT_IN_ADAPTERS = {
   sub2api: {
@@ -1465,14 +1914,14 @@ var BUILT_IN_ADAPTERS = {
     fetch: fetchClaudeRelayService
   }
 };
-function getProvider(providerId, customProviders = {}) {
+function getProvider(providerId, endpointConfigs = {}) {
   if (BUILT_IN_ADAPTERS[providerId]) {
     return BUILT_IN_ADAPTERS[providerId];
   }
-  const customConfig = customProviders[providerId];
-  if (customConfig) {
+  const endpointConfig = endpointConfigs[providerId];
+  if (endpointConfig) {
     return {
-      fetch: (baseUrl, token, config, timeoutMs) => fetchCustom(baseUrl, token, config, customConfig, timeoutMs)
+      fetch: (baseUrl, token, config, timeoutMs) => fetchEndpoint(baseUrl, token, config, endpointConfig, timeoutMs)
     };
   }
   return null;
@@ -1501,10 +1950,30 @@ var ANSI_COLORS = {
 };
 var THEME_COLORS = {
   cool: "#56B6C2",
-  comfortable: "#6BAF8D",
+  comfortable: "#5EBE8A",
   warm: "#C9A84C",
-  hot: "#CB7E55",
-  critical: "#C96B6B"
+  hot: "#D68B45",
+  critical: "#D45A5A",
+  "pastel-cool": "#BAD7F2",
+  "pastel-comfortable": "#BAF2D8",
+  "pastel-medium": "#BAF2BB",
+  "pastel-warm": "#F2E2BA",
+  "pastel-hot": "#F2BAC9",
+  "bright-cool": "#90F1EF",
+  "bright-comfortable": "#7BF1A8",
+  "bright-medium": "#C1FBA4",
+  "bright-warm": "#FFEF9F",
+  "bright-hot": "#FFD6E0",
+  "ocean-cool": "#0081A7",
+  "ocean-comfortable": "#00AFB9",
+  "ocean-medium": "#FDFCDC",
+  "ocean-warm": "#FED9B7",
+  "ocean-hot": "#F07167",
+  "neutral-cool": "#D8E2DC",
+  "neutral-comfortable": "#FFE5D9",
+  "neutral-warm": "#FFCAD4",
+  "neutral-hot": "#F4ACB7",
+  "neutral-critical": "#9D8189"
 };
 var ANSI_RESET = "\x1B[0m";
 var ANSI_DIM = "\x1B[2m";
@@ -1596,6 +2065,9 @@ function hexToRgb(hex) {
 function dimText(text) {
   return `${ANSI_DIM}${text}${ANSI_RESET}`;
 }
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
 function resolveColor(colorName, usagePercent, config) {
   const effectiveColor = colorName ?? "auto";
   if (effectiveColor.startsWith("#") || ANSI_COLORS[effectiveColor.toLowerCase()]) {
@@ -1614,9 +2086,6 @@ function resolveColor(colorName, usagePercent, config) {
   }
   return resolveColorAlias(alias, usagePercent);
 }
-function isTieredEntry(alias) {
-  return "tiers" in alias;
-}
 function resolveTieredColor(entry, usagePercent) {
   if (entry.tiers.length === 0)
     return null;
@@ -1633,19 +2102,7 @@ function resolveTieredColor(entry, usagePercent) {
 function resolveColorAlias(alias, usagePercent) {
   if (!alias)
     return null;
-  if (isTieredEntry(alias)) {
-    return resolveTieredColor(alias, usagePercent);
-  }
-  if (usagePercent === null) {
-    return alias.low;
-  }
-  if (usagePercent < alias.lowThreshold) {
-    return alias.low;
-  } else if (usagePercent < alias.highThreshold) {
-    return alias.medium;
-  } else {
-    return alias.high;
-  }
+  return resolveTieredColor(alias, usagePercent);
 }
 
 // src/renderer/transition.ts
@@ -1696,6 +2153,8 @@ function renderStandaloneError(errorState, provider, message) {
       return `${warningIcon} Set ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN`;
     case "timeout":
       return `${warningIcon} Fetching...`;
+    case "endpoint-config-changed":
+      return `${warningIcon} Endpoint config changed — run: cc-api-statusline --apply-config`;
     case "network-error":
     case "server-error":
     case "parse-error":
@@ -2003,46 +2462,49 @@ function formatCompactNumber(n) {
 
 // src/renderer/component.ts
 function renderComponent(componentId, data, componentConfig, globalConfig, renderContext) {
-  const effectiveLayout = componentConfig.layout ?? globalConfig.display.layout;
-  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;
+  const options = {
+    layout: componentConfig.layout ?? globalConfig.display.layout,
+    displayMode: resolveEffectiveDisplayMode(componentConfig.displayMode ?? globalConfig.display.displayMode, renderContext),
+    progressStyle: resolveEffectiveProgressStyle(componentConfig.progressStyle ?? globalConfig.display.progressStyle, renderContext),
+    barSize: componentConfig.barSize ?? globalConfig.display.barSize,
+    barStyle: componentConfig.barStyle ?? globalConfig.display.barStyle,
+    clockFormat: globalConfig.display.clockFormat
+  };
   switch (componentId) {
     case "daily":
-      return renderQuotaComponent("daily", data.daily, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
     case "weekly":
-      return renderQuotaComponent("weekly", data.weekly, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
     case "monthly":
-      return renderQuotaComponent("monthly", data.monthly, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, clockFormat, renderContext);
+      return renderQuotaComponent(componentId, data[componentId], options, componentConfig, globalConfig, renderContext);
     case "balance":
-      return renderBalanceComponent(data.balance, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, renderContext);
+      return renderBalanceComponent(data.balance, options, componentConfig, globalConfig, renderContext);
     case "tokens":
-      return renderTokensComponent(data.tokenStats, effectiveLayout, effectiveDisplayMode, componentConfig, globalConfig, renderContext);
+      return renderTokensComponent(data.tokenStats, options, componentConfig, globalConfig, renderContext);
     case "rateLimit":
-      return renderRateLimitComponent(data.rateLimit, effectiveLayout, effectiveDisplayMode, effectiveProgressStyle, effectiveBarSize, effectiveBarStyle, componentConfig, globalConfig, renderContext);
+      return renderRateLimitComponent(data.rateLimit, options, componentConfig, globalConfig, renderContext);
     case "plan":
-      return renderPlanComponent(data.planName, effectiveLayout, effectiveDisplayMode, componentConfig, globalConfig, renderContext);
+      return renderPlanComponent(data.planName, options, componentConfig, globalConfig, renderContext);
     default:
       return null;
   }
 }
-function renderQuotaComponent(componentId, quota, layout, displayMode, progressStyle, barSize, barStyle, componentConfig, globalConfig, clockFormat, renderContext) {
+function renderQuotaComponent(componentId, quota, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (!quota)
     return null;
   const usagePercent = calculateUsagePercent(quota.used, quota.limit);
   const label = renderLabel(componentId, displayMode, componentConfig, quota.qualifier);
+  const showPercentage = componentConfig.percentage !== false;
   const barColor = resolvePartColor("bar", usagePercent, componentConfig, globalConfig);
-  const valueColor = resolvePartColor("value", usagePercent, componentConfig, globalConfig);
+  const valueColor = showPercentage ? resolvePartColor("value", usagePercent, componentConfig, globalConfig) : null;
   const labelColor = resolvePartColor("label", usagePercent, componentConfig, globalConfig);
   const countdownColor = resolvePartColor("countdown", usagePercent, componentConfig, globalConfig);
   const progress = renderProgress(progressStyle, usagePercent, barSize, barStyle, barColor, null, renderContext);
-  const value = ansiColor(`${Math.round(usagePercent)}%`, valueColor, renderContext);
+  const value = showPercentage ? 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, progressStyle, barSize, barStyle, componentConfig, globalConfig, renderContext) {
+function renderBalanceComponent(balance, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (!balance)
     return null;
   const isUnlimited = balance.remaining === -1;
@@ -2061,7 +2523,8 @@ function renderBalanceComponent(balance, layout, displayMode, progressStyle, bar
   const countdown = "";
   return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderTokensComponent(tokenStats, layout, displayMode, componentConfig, globalConfig, renderContext) {
+function renderTokensComponent(tokenStats, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (!tokenStats)
     return null;
   const stats = tokenStats.total ?? tokenStats.today;
@@ -2077,7 +2540,8 @@ function renderTokensComponent(tokenStats, layout, displayMode, componentConfig,
   const countdown = "";
   return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderRateLimitComponent(rateLimit, layout, displayMode, progressStyle, barSize, barStyle, componentConfig, globalConfig, renderContext) {
+function renderRateLimitComponent(rateLimit, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (!rateLimit)
     return null;
   let usagePercent = null;
@@ -2094,7 +2558,8 @@ function renderRateLimitComponent(rateLimit, layout, displayMode, progressStyle,
   const countdown = "";
   return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
-function renderPlanComponent(planName, layout, displayMode, componentConfig, globalConfig, renderContext) {
+function renderPlanComponent(planName, options, componentConfig, globalConfig, renderContext) {
+  const { layout, displayMode, progressStyle, barSize, barStyle, clockFormat } = options;
   if (displayMode === "hidden")
     return null;
   const labelColor = resolvePartColor("label", null, componentConfig, globalConfig);
@@ -2208,21 +2673,25 @@ function assembleComponent(layout, label, labelColor, progress, value, countdown
   if (layout === "percent-first") {
     if (coloredLabel)
       parts.push(coloredLabel);
-    parts.push(value);
+    if (value)
+      parts.push(value);
     if (progress)
       parts.push(progress);
-    if (countdown)
-      parts.push(countdown);
   } else {
     if (coloredLabel)
       parts.push(coloredLabel);
     if (progress)
       parts.push(progress);
-    parts.push(value);
-    if (countdown)
-      parts.push(countdown);
+    if (value)
+      parts.push(value);
+  }
+  if (countdown && parts.length > 0) {
+    const idx = parts.length - 1;
+    parts[idx] = (parts[idx] ?? "") + countdown;
+  } else if (countdown) {
+    parts.push(countdown);
   }
-  return parts.filter((p) => p).join(" ").replace(/ (\x1b\[[0-9;]*m)? ([·•])/g, "$1 $2");
+  return parts.join(" ");
 }
 function calculateUsagePercent(used, limit) {
   if (limit === null)
@@ -2259,8 +2728,7 @@ function computeMaxWidth(termWidth, maxWidthPct) {
   return Math.floor(termWidth * pct / 100);
 }
 function visibleLength(text) {
-  const stripped = text.replace(/\x1b\[[0-9;]*m/g, "");
-  return stripped.length;
+  return stripAnsi(text).length;
 }
 function ansiAwareTruncate(text, maxWidth) {
   const visible = visibleLength(text);
@@ -2307,8 +2775,8 @@ var COMPONENT_DROP_PRIORITY = [
 // src/renderer/divider.ts
 function renderDivider(divider) {
   const text = divider.text ?? "|";
-  const padding = divider.padding ?? 1;
-  const pad = " ".repeat(padding);
+  const margin = divider.margin ?? 1;
+  const pad = " ".repeat(margin);
   const padded = `${pad}${text}${pad}`;
   return ansiColor(padded, divider.color ?? "#555753");
 }
@@ -2400,63 +2868,46 @@ function renderStatusline(data, config, errorState, cacheAge, isPiped = false) {
       currentWidth = calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge);
     }
   }
-  const renderedComponents = [];
-  for (const componentId of componentOrder) {
-    if (activeComponents.has(componentId)) {
-      const rendered = componentMap.get(componentId);
-      if (rendered)
-        renderedComponents.push(rendered);
-    }
-  }
-  let statusline = renderedComponents.join(separator);
-  if (errorState) {
-    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);
-      statusline = hasCache ? `${statusline} ${errorIndicator}` : errorIndicator;
-    }
-  }
+  let statusline = assembleStatuslineString(componentOrder, componentMap, activeComponents, separator, errorState, data, cacheAge);
   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;
+  const dividerConfig = config.display.divider;
   if (dividerConfig === false)
     return "";
-  if (typeof dividerConfig === "object")
-    return renderDivider(dividerConfig);
-  return config.display.separator ?? " | ";
+  return renderDivider(dividerConfig ?? DEFAULT_DIVIDER_CONFIG);
 }
 function maxWidth(config) {
   const termWidth = getTerminalWidth();
   return computeMaxWidth(termWidth, config.display.maxWidth ?? 100);
 }
-function calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge) {
-  const components = [];
+function assembleStatuslineString(componentOrder, componentMap, activeComponents, separator, errorState, data, cacheAge) {
+  const rendered = [];
   for (const id of componentOrder) {
     if (activeComponents.has(id)) {
-      const rendered = componentMap.get(id);
-      if (rendered)
-        components.push(rendered);
+      const r = componentMap.get(id);
+      if (r)
+        rendered.push(r);
     }
   }
-  let statusline = components.join(separator);
+  let statusline = rendered.join(separator);
   if (errorState) {
     if (isTransitionState(errorState)) {
       statusline = renderError(errorState, "with-cache", data.provider, undefined, cacheAge);
     } else {
-      const hasCache = components.length > 0;
+      const hasCache = rendered.length > 0;
       const errorMode = hasCache ? "with-cache" : "without-cache";
       const errorIndicator = renderError(errorState, errorMode, data.provider, undefined, cacheAge);
       statusline = hasCache ? `${statusline} ${errorIndicator}` : errorIndicator;
     }
   }
-  return visibleLength(statusline);
+  return statusline;
+}
+function calculateStatuslineWidth(componentMap, activeComponents, componentOrder, separator, errorState, data, cacheAge) {
+  return visibleLength(assembleStatuslineString(componentOrder, componentMap, activeComponents, separator, errorState, data, cacheAge));
 }
 function getComponentOrder(config) {
   const explicitOrder = [];
@@ -2481,10 +2932,10 @@ function isComponentId(key) {
 
 // src/core/execute-cycle.ts
 async function executeCycle(ctx) {
-  const { env, config, configHash, cachedEntry, providerId, provider, timeoutBudgetMs, startTime, fetchTimeoutMs } = ctx;
+  const { env, config, configHash, endpointConfigHash, endpointLock, cachedEntry, providerId, provider, timeoutBudgetMs, startTime, fetchTimeoutMs } = ctx;
   if (cachedEntry) {
     if (isCacheValid(cachedEntry, env) && isCacheProviderValid(cachedEntry, providerId)) {
-      if (cachedEntry.renderedLine && isCacheRenderedLineUsable(cachedEntry, configHash)) {
+      if (cachedEntry.renderedLine && isCacheRenderedLineUsable(cachedEntry, configHash) && cachedEntry.endpointConfigHash === endpointConfigHash) {
         logger.debug("Path A: Fast path (cached renderedLine)", {
           cacheAge: `${Math.floor((Date.now() - new Date(cachedEntry.fetchedAt).getTime()) / 1000)}s`
         });
@@ -2496,13 +2947,34 @@ async function executeCycle(ctx) {
       }
     }
   }
+  if (endpointLock && endpointLock.hash !== endpointConfigHash) {
+    logger.debug("Path B2: Endpoint config changed (locked out)", {
+      lockedHash: endpointLock.hash,
+      currentHash: endpointConfigHash
+    });
+    if (cachedEntry && isCacheValid(cachedEntry, env) && isCacheProviderValid(cachedEntry, providerId)) {
+      const statusline = renderStatusline(cachedEntry.data, config);
+      return {
+        output: statusline,
+        exitCode: 0,
+        cacheUpdate: null
+      };
+    }
+    const errorOutput = renderError("endpoint-config-changed", "without-cache");
+    return {
+      output: errorOutput,
+      exitCode: 0,
+      cacheUpdate: null
+    };
+  }
   if (cachedEntry && isCacheValid(cachedEntry, env) && isCacheProviderValid(cachedEntry, providerId)) {
     logger.debug("Path B: Re-render (config changed, cache data valid)");
     const statusline = renderStatusline(cachedEntry.data, config);
     const updatedEntry = {
       ...cachedEntry,
       renderedLine: statusline,
-      configHash
+      configHash,
+      endpointConfigHash
     };
     return {
       output: statusline,
@@ -2548,6 +3020,7 @@ async function executeCycle(ctx) {
       data,
       renderedLine: statusline,
       configHash,
+      endpointConfigHash,
       errorState: null
     };
     return {
@@ -2582,23 +3055,23 @@ async function executeCycle(ctx) {
   }
 }
 // src/services/cache-gc.ts
-import { readdirSync, statSync, unlinkSync as unlinkSync3, existsSync as existsSync7 } from "fs";
-import { join as join6 } from "path";
+import { readdirSync as readdirSync4, statSync as statSync2, unlinkSync as unlinkSync6, existsSync as existsSync6 } from "fs";
+import { join as join12 } from "path";
 function runCacheGC(cacheDir) {
   try {
-    if (!existsSync7(cacheDir)) {
+    if (!existsSync6(cacheDir)) {
       logger.debug("GC: Cache directory does not exist, skipping", { cacheDir });
       return;
     }
     logger.debug("GC: Starting garbage collection", { cacheDir });
-    const files = readdirSync(cacheDir);
+    const files = readdirSync4(cacheDir);
     const cacheFiles = [];
     const providerDetectFiles = [];
     const tmpFiles = [];
     for (const file of files) {
       try {
-        const filePath = join6(cacheDir, file);
-        const stats = statSync(filePath);
+        const filePath = join12(cacheDir, file);
+        const stats = statSync2(filePath);
         const mtime = stats.mtimeMs;
         if (file.startsWith("cache-") && file.endsWith(".json")) {
           cacheFiles.push({ name: file, mtime });
@@ -2617,7 +3090,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_MAX_AGE_MS) {
         try {
-          unlinkSync3(join6(cacheDir, file.name));
+          unlinkSync6(join12(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted old cache file", { file: file.name, ageDays: Math.floor(age / (24 * 60 * 60 * 1000)) });
         } catch (error) {
@@ -2629,7 +3102,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_MAX_AGE_MS) {
         try {
-          unlinkSync3(join6(cacheDir, file.name));
+          unlinkSync6(join12(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) {
@@ -2641,7 +3114,7 @@ function runCacheGC(cacheDir) {
       const age = now - file.mtime;
       if (age > GC_ORPHAN_TMP_AGE_MS) {
         try {
-          unlinkSync3(join6(cacheDir, file.name));
+          unlinkSync6(join12(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted orphaned tmp file", { file: file.name, ageMinutes: Math.floor(age / (60 * 1000)) });
         } catch (error) {
@@ -2658,7 +3131,7 @@ function runCacheGC(cacheDir) {
       const toDelete = remainingCacheFiles.slice(0, remainingCacheFiles.length - GC_MAX_CACHE_FILES);
       for (const file of toDelete) {
         try {
-          unlinkSync3(join6(cacheDir, file.name));
+          unlinkSync6(join12(cacheDir, file.name));
           deletedCount++;
           logger.debug("GC: Deleted cache file (count limit)", { file: file.name });
         } catch (error) {
@@ -2673,60 +3146,121 @@ function runCacheGC(cacheDir) {
 }
 
 // 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
+class StatuslineError extends Error {
+  errorType;
+  constructor(errorType) {
+    super(errorType);
+    this.errorType = errorType;
+  }
+}
+function safeStdoutWrite(data) {
+  try {
+    process.stdout["write"](data);
+  } catch {}
+}
+function readAndValidateEnv() {
+  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) {
+    throw new StatuslineError("missing-env");
+  }
+  const { baseUrl } = env;
+  if (!baseUrl) {
+    process.exit(0);
+  }
+  return { env, baseUrl };
+}
+function ensureDefaultConfigs() {
+  if (needsConfigInit()) {
+    logger.debug("First run detected - initializing default configs");
+    writeDefaultConfigs();
+  }
+}
+function loadEndpointConfigsWithHash() {
+  const endpointConfigs = loadEndpointConfigs();
+  const endpointConfigHash = computeEndpointConfigHash();
+  logger.debug("Endpoint configs loaded", {
+    configCount: Object.keys(endpointConfigs).length,
+    endpointConfigHash
+  });
+  return { endpointConfigs, endpointConfigHash };
+}
+function resolveEndpointLock(hash) {
+  const existing = readEndpointLock();
+  if (existing) {
+    logger.debug("Endpoint lock file loaded", {
+      lockedHash: existing.hash,
+      currentHash: hash,
+      locked: existing.hash === hash
     });
-    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);
+    return existing;
+  }
+  logger.debug("Endpoint lock file missing - creating with current hash");
+  writeEndpointLock(hash);
+  return { hash, lockedAt: new Date().toISOString() };
+}
+async function resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, timeoutMs) {
+  const probeTimeout = isPiped ? Math.min(1500, Math.max(200, timeoutMs - 200)) : 3000;
+  const providerId = await resolveProvider(baseUrl, env.providerOverride, endpointConfigs, probeTimeout);
+  const provider = getProvider(providerId, endpointConfigs);
+  logger.debug("Provider resolved", { providerId, probeTimeout });
+  if (!provider) {
+    logger.error("Provider not found", { providerId });
+    throw new StatuslineError("provider-unknown");
+  }
+  return { providerId, provider };
+}
+function computeTimeoutBudgets(isPiped, config, timeoutMs) {
+  const timeoutBudgetMs = isPiped ? timeoutMs : 1e4;
+  const fetchTimeoutMs = isPiped ? Math.min(config.pipedRequestTimeoutMs ?? 800, timeoutBudgetMs - 100) : 1e4;
+  return { timeoutBudgetMs, fetchTimeoutMs };
+}
+async function buildExecutionContext(args, isPiped, startTime, rawTimeoutMs) {
+  const { env, baseUrl } = readAndValidateEnv();
+  ensureDefaultConfigs();
+  const { config, configHash } = loadConfigWithHash(args.configPath);
+  const { endpointConfigs, endpointConfigHash } = loadEndpointConfigsWithHash();
+  const endpointLock = resolveEndpointLock(endpointConfigHash);
+  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"
+  });
+  let providerId;
+  let provider;
+  if (cachedEntry && isCacheValid(cachedEntry, env)) {
+    const cachedProvider = getProvider(cachedEntry.provider, endpointConfigs);
+    if (cachedProvider) {
+      providerId = cachedEntry.provider;
+      provider = cachedProvider;
+      logger.debug("Cache-first: skipping provider probe", { providerId });
+    } else {
+      ({ providerId, provider } = await resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, rawTimeoutMs));
     }
-    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 };
-  })();
+  } else {
+    ({ providerId, provider } = await resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, rawTimeoutMs));
+  }
+  const { timeoutBudgetMs, fetchTimeoutMs } = computeTimeoutBudgets(isPiped, config, rawTimeoutMs);
+  const ctx = {
+    env,
+    config,
+    configHash,
+    endpointConfigHash,
+    endpointLock,
+    cachedEntry,
+    providerId,
+    provider,
+    timeoutBudgetMs,
+    startTime,
+    fetchTimeoutMs
+  };
+  return { ctx, baseUrl };
 }
 function formatOutput(output, isPiped) {
   let normalizedOutput = output;
@@ -2748,12 +3282,45 @@ async function executePipedMode(args) {
   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);
+  const rawTimeoutMs = Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 1000);
+  if (isPiped) {
+    const watchdogMs = rawTimeoutMs - 100;
+    setTimeout(() => {
+      logger.error("Watchdog timeout - forcing clean exit", { watchdogMs });
+      const fallback = dimText("⟳ Refreshing...");
+      const formatted = formatOutput(fallback, isPiped);
+      safeStdoutWrite(formatted);
+      process.exit(0);
+    }, watchdogMs).unref();
+  }
+  let ctx;
+  let baseUrl;
+  try {
+    ({ ctx, baseUrl } = await buildExecutionContext(args, isPiped, startTime, rawTimeoutMs));
+  } catch (error) {
+    logger.error("Failed to build execution context", { error: String(error) });
+    const errorType = error instanceof StatuslineError ? error.errorType : "network-error";
+    const errorOutput = renderError(errorType, "without-cache");
+    const formattedOutput2 = formatOutput(errorOutput, isPiped);
+    safeStdoutWrite(formattedOutput2);
+    logger.debug("=== cc-api-statusline execution completed ===");
+    process.exit(0);
+  }
   logger.debug("Execution context prepared", {
     timeoutBudgetMs: ctx.timeoutBudgetMs,
     fetchTimeoutMs: ctx.fetchTimeoutMs
   });
-  const result = await executeCycle(ctx);
+  let result;
+  try {
+    result = await executeCycle(ctx);
+  } catch (error) {
+    logger.error("Execution cycle failed", { error: String(error) });
+    const errorOutput = renderError("network-error", "without-cache");
+    const formattedOutput2 = formatOutput(errorOutput, isPiped);
+    safeStdoutWrite(formattedOutput2);
+    logger.debug("=== cc-api-statusline execution completed ===");
+    process.exit(0);
+  }
   const executionTime = Date.now() - startTime;
   logger.debug("Execution completed", {
     exitCode: result.exitCode,
@@ -2762,7 +3329,7 @@ async function executePipedMode(args) {
     cacheUpdate: !!result.cacheUpdate
   });
   const formattedOutput = formatOutput(result.output, isPiped);
-  process.stdout.write(formattedOutput);
+  safeStdoutWrite(formattedOutput);
   if (result.cacheUpdate) {
     writeCache(baseUrl, result.cacheUpdate);
     logger.debug("Cache written", { baseUrl });
@@ -2776,6 +3343,7 @@ function discardStdin() {
   if (!process.stdin.isTTY) {
     process.stdin.resume();
     process.stdin.on("data", () => {});
+    process.stdin.on("error", () => {});
   }
 }
 async function main() {
@@ -2799,6 +3367,10 @@ async function main() {
     handleUninstall();
     return;
   }
+  if (args.applyConfig) {
+    handleApplyConfig();
+    return;
+  }
   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.");
@@ -2806,8 +3378,14 @@ async function main() {
   }
   await executePipedMode(args);
 }
+process.on("SIGTERM", () => {
+  process.exit(0);
+});
+process.on("uncaughtException", (error) => {
+  logger.error("Uncaught exception", { error: String(error) });
+  process.exit(0);
+});
 main().catch((error) => {
   logger.error("Unhandled error in main", { error: String(error) });
-  console.error(`Fatal error: ${error}`);
-  process.exit(1);
+  process.exit(0);
 });