cc-api-statusline 1.0.2 → 1.1.2

package/README.md

@@ -2,15 +2,14 @@
 
 English | [简体中文](README.zh-CN.md)
 
-A high-performance TUI statusline tool that polls API usage data from Claude API proxy services (sub2api, claude-relay-service, or custom providers) and renders a configurable one-line status display.
+<img src="docs/images/banner-screenshot.png" width="800" alt="cc-api-statusline banner">
+
+A high-performance TUI statusline tool that polls API usage data from Claude API services (sub2api, claude-relay-service, or custom providers) and renders a configurable one-line status display.
 
 ## Features
 
-- ⚡ **Fast piped mode** — <25ms warm cache, <100ms p95
 - 🎨 **Highly configurable** — Layouts, colors, bar styles, display modes
 - 🔌 **Provider autodetection** — Works with sub2api, claude-relay-service, custom providers
-- 💾 **Smart caching** — Disk cache with atomic writes, TTL validation, automatic garbage collection
-- 🎯 **Claude Code integration** — Auto-setup with `--install` command
 - 📊 **Multiple components** — Daily/weekly/monthly quotas, balance, tokens, rate limits
 - 🔁 **Hot switching** — Auto-detects API endpoint and credential changes at runtime
 - 🔒 **Reliability** — No stale data display, race-condition-free writes, auto cache cleanup
@@ -45,7 +44,7 @@ export ANTHROPIC_AUTH_TOKEN="your-api-token"
 bunx cc-api-statusline@latest --once
 ```
 
-### 3. Install as Claude Code widget (optional)
+### 3.a Install as Claude Code widget
 
 ```bash
 bunx cc-api-statusline@latest --install
@@ -56,6 +55,7 @@ This adds to `~/.claude/settings.json`:
 ```json
 {
   "statusLine": {
+    "id": "e62435aa-bdf5-4ded-a2e3-ae13582439db",
     "type": "command",
     "command": "bunx -y cc-api-statusline@latest",
     "padding": 0
@@ -63,6 +63,28 @@ This adds to `~/.claude/settings.json`:
 }
 ```
 
+### 3.b Install as [ccstatusline](https://github.com/anthropics/claude-code) Custom Command
+<img src="docs/images/ccstatusline-command.png" width="800" alt="ccstatusline-command mode">
+Add to `~/.claude/ccstatusline/config.json`:
+
+```json
+{
+  "lines": [
+    [
+      {
+        "id": "e62435aa-bdf5-4ded-a2e3-ae13582439db",
+        "type": "custom-command",
+        "commandPath": "bunx -y cc-api-statusline@latest --embedded",
+        "preserveColors": true,
+        "timeout": 10000
+      }
+    ]
+  ]
+}
+```
+
+> **`--embedded` is required here.** Without it, cc-api-statusline prepends an ANSI reset (`\x1b[0m`) that breaks cc-statusline's powerline background colors. The flag tells cc-api-statusline it's running inside a host renderer that handles its own formatting.
+
 Using `bunx` ensures you always run the latest version without a global install. To uninstall:
 
 ```bash
@@ -144,31 +166,6 @@ cc-api-statusline --apply-config
 
 See [docs/api-config-reference.md](docs/api-config-reference.md) for the full schema.
 
-## [ccstatusline](https://github.com/anthropics/claude-code) Custom Command
-
-Add to `~/.claude/ccstatusline/config.json`:
-
-```json
-{
-  "customCommands": {
-    "usage": {
-      "command": "cc-api-statusline",
-      "description": "API usage statusline",
-      "type": "piped"
-    }
-  },
-  "widgets": [
-    {
-      "type": "customCommand",
-      "command": "usage",
-      "refreshIntervalMs": 30000,
-      "maxWidth": 100,
-      "preserveColors": true
-    }
-  ]
-}
-```
-
 ## Environment Variables
 
 All variables are optional at the shell level — `ANTHROPIC_BASE_URL` and `ANTHROPIC_AUTH_TOKEN` can be set via `settings.json` env overlay instead of shell exports (see [Quick Start](#quick-start)).
@@ -180,6 +177,7 @@ All variables are optional at the shell level — `ANTHROPIC_BASE_URL` and `ANTH
 | `CC_STATUSLINE_PROVIDER` | Yes | Override provider detection (`sub2api`, `claude-relay-service`, or custom) |
 | `CC_STATUSLINE_POLL` | Yes | Override poll interval (seconds, min 5) |
 | `CC_STATUSLINE_TIMEOUT` | Yes | Piped mode timeout (milliseconds, default 5000) |
+| `CC_API_STATUSLINE_EMBEDDED` | Yes | Skip host formatting when set to `"1"` or `"true"`. Alternative to `--embedded` flag; prefer the flag in `commandPath` configs |
 | `DEBUG` or `CC_STATUSLINE_DEBUG` | Yes | Enable debug logging to `~/.claude/cc-api-statusline/debug.log` |
 
 ## Troubleshooting

package/README.zh-CN.md

@@ -2,13 +2,12 @@
 
 [English](README.md) | 简体中文
 
-在ClaudeCode状态栏显示API用量，通过轮询 Claude API 代理服务（sub2api、claude-relay-service 或自定义提供商）获取用量数据，并以可配置显示样式。
+在ClaudeCode状态栏显示API用量，通过轮询 Claude API 服务（sub2api、claude-relay-service 或自定义提供商）获取用量数据，并以可配置显示样式。
 
 ## 特性
 
 - 🎨 **高度可配置** — 布局、颜色、进度条样式、显示模式任意调整
 - 🔌 **提供商自动识别** — 开箱支持 sub2api、claude-relay-service 及自定义提供商
-- 💾 **智能缓存** — 原子写入磁盘缓存、TTL 验证、自动垃圾回收
 - 🎯 **Claude Code 集成** — 一键 `--install` 完成安装
 - 📊 **多维度用量展示** — 每日/每周/每月配额、余额、Token数、速率限制
 - 🔁 **热切换** — 自动感知 API 端点和凭证变更，无需重启
@@ -44,7 +43,7 @@ export ANTHROPIC_AUTH_TOKEN="your-api-token"
 bunx cc-api-statusline@latest --once
 ```
 
-### 3. 安装为 Claude Code 状态栏组件（可选）
+### 3.a 安装为 Claude Code 状态栏组件
 
 ```bash
 bunx cc-api-statusline@latest --install
@@ -61,6 +60,27 @@ bunx cc-api-statusline@latest --install
   }
 }
 ```
+### 3.b 安装为 [ccstatusline](https://github.com/anthropics/claude-code) 自定义命令
+<img src="docs/images/ccstatusline-command.png" width="800" alt="ccstatusline-command mode">
+在 `~/.claude/ccstatusline/config.json` 中添加如下配置：
+
+```json
+{
+  "lines": [
+    [
+      {
+        "id": "e62435aa-bdf5-4ded-a2e3-ae13582439db",
+        "type": "custom-command",
+        "commandPath": "bunx -y cc-api-statusline@latest --embedded",
+        "preserveColors": true,
+        "timeout": 10000
+      }
+    ]
+  ]
+}
+```
+
+> **此处必须加 `--embedded`。** 不加的话，cc-api-statusline 会在输出前插入 ANSI 重置码（`\x1b[0m`），破坏 cc-statusline 的 powerline 背景色。该标志告知 cc-api-statusline 当前运行在宿主渲染器内部，由宿主负责格式化。
 
 使用 `bunx` 可每次自动拉取最新版本，无需全局安装。如需卸载：
 
@@ -143,31 +163,6 @@ cc-api-statusline --apply-config
 
 完整 Schema 请参阅 [docs/api-config-reference.md](docs/api-config-reference.md)。
 
-## [ccstatusline](https://github.com/anthropics/claude-code) 自定义命令
-
-在 `~/.claude/ccstatusline/config.json` 中添加如下配置：
-
-```json
-{
-  "customCommands": {
-    "usage": {
-      "command": "cc-api-statusline",
-      "description": "API usage statusline",
-      "type": "piped"
-    }
-  },
-  "widgets": [
-    {
-      "type": "customCommand",
-      "command": "usage",
-      "refreshIntervalMs": 30000,
-      "maxWidth": 100,
-      "preserveColors": true
-    }
-  ]
-}
-```
-
 ## 环境变量
 
 以下所有变量均为可选——`ANTHROPIC_BASE_URL` 和 `ANTHROPIC_AUTH_TOKEN` 可通过 `settings.json` 的 env 字段配置，无需在 Shell 中手动导出（详见[快速上手](#快速上手)）。

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: "1.0.2",
+  version: "1.1.2",
   description: "Claude Code statusline tool that polls API usage from third-party proxy backends",
   type: "module",
   bin: {
@@ -70,6 +70,7 @@ function parseArgs() {
   let uninstall = false;
   let applyConfig = false;
   let force = false;
+  let embedded = false;
   let configPath;
   let runner;
   for (let i = 0;i < args.length; i++) {
@@ -88,6 +89,8 @@ function parseArgs() {
       applyConfig = true;
     } else if (arg === "--force") {
       force = true;
+    } else if (arg === "--embedded") {
+      embedded = true;
     } else if (arg === "--config" && i + 1 < args.length) {
       configPath = args[i + 1];
       i++;
@@ -99,7 +102,9 @@ function parseArgs() {
       i++;
     }
   }
-  return { help, version, once, install, uninstall, applyConfig, force, configPath, runner };
+  const envVal = process.env["CC_API_STATUSLINE_EMBEDDED"];
+  embedded = embedded || envVal === "1" || envVal === "true";
+  return { help, version, once, install, uninstall, applyConfig, force, embedded, configPath, runner };
 }
 function showHelp() {
   console.log(`
@@ -118,14 +123,16 @@ Options:
   --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
+  --embedded         Skip host formatting (for use inside cc-statusline)
 
 Environment Variables:
-  ANTHROPIC_BASE_URL       API endpoint (required)
-  ANTHROPIC_AUTH_TOKEN     API key (required)
-  CC_STATUSLINE_PROVIDER   Override provider detection
-  CC_STATUSLINE_POLL       Override poll interval (seconds)
-  CC_STATUSLINE_TIMEOUT    Piped mode timeout (milliseconds, default 5000)
-  DEBUG or CC_STATUSLINE_DEBUG  Enable debug logging to ~/.claude/cc-api-statusline/debug.log
+  ANTHROPIC_BASE_URL           API endpoint (required)
+  ANTHROPIC_AUTH_TOKEN         API key (required)
+  CC_STATUSLINE_PROVIDER       Override provider detection
+  CC_STATUSLINE_POLL           Override poll interval (seconds)
+  CC_STATUSLINE_TIMEOUT        Piped mode timeout (milliseconds, default 5000)
+  DEBUG or CC_STATUSLINE_DEBUG Enable debug logging to ~/.claude/cc-api-statusline/debug.log
+  CC_API_STATUSLINE_EMBEDDED   Skip host formatting when set to "1" or "true" (for use inside cc-statusline)
 
 Config File:
   ~/.claude/cc-api-statusline/config.json
@@ -177,9 +184,10 @@ import { spawn } from "child_process";
 import { dirname, join } from "path";
 
 // src/core/constants.ts
-var DEFAULT_FETCH_TIMEOUT_MS = 5000;
-var DEFAULT_PIPED_REQUEST_TIMEOUT_MS = 3000;
+var DEFAULT_TIMEOUT_BUDGET_MS = 5000;
+var TTY_TIMEOUT_BUDGET_MS = DEFAULT_TIMEOUT_BUDGET_MS * 2;
 var EXIT_BUFFER_MS = 50;
+var TIMEOUT_HEADROOM_MS = 100;
 var STALENESS_THRESHOLD_MINUTES = 5;
 var VERY_STALE_THRESHOLD_MINUTES = 30;
 var GC_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
@@ -190,6 +198,12 @@ 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;
+var HEALTH_MATCH_WILDCARD = "*";
+var DETECTION_TTL_BASE_S = 86400;
+var DETECTION_TTL_MAX_S = 604800;
+var DETECTION_TTL_CHANGED_S = 3600;
+var DETECTION_TTL_FAILED_S = 300;
+var MAINTENANCE_GC_PROBABILITY = 0.1;
 
 // src/services/log-rotator.ts
 var ARCHIVE_LOG_RE = /^debug\.\d{4}-\d{2}-\d{2}T\d{2}-\d{2}\.log$/;
@@ -564,7 +578,7 @@ var DEFAULT_CONFIG = {
     chill: { tiers: buildTiers(["cyan", "cyan", "blue", "blue", "magenta"]) }
   },
   pollIntervalSeconds: 30,
-  pipedRequestTimeoutMs: 3000
+  pipedRequestTimeoutMs: DEFAULT_TIMEOUT_BUDGET_MS
 };
 var BAR_SIZE_MAP = {
   small: 4,
@@ -636,12 +650,11 @@ function isCacheEntry(value) {
   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["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) {
   if (typeof value !== "object" || value === null)
     return false;
   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";
+  return typeof c["baseUrl"] === "string" && typeof c["provider"] === "string" && (c["detectedVia"] === "health-probe" || c["detectedVia"] === "override") && typeof c["detectedAt"] === "string" && typeof c["ttlSeconds"] === "number";
 }
 // src/services/endpoint-config.ts
 import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
@@ -814,7 +827,6 @@ function getBuiltInEndpointConfigs() {
         resetSemantics: "rolling-window"
       },
       detection: {
-        urlPatterns: ["/apistats", "/api/user-stats"],
         healthMatch: { service: "*" }
       },
       responseMapping: {
@@ -999,7 +1011,15 @@ function writeDefaultConfigs(customDir) {
   ensureDir(apiConfigDir);
   if (!existsSync4(configPath)) {
     const styleConfigWithoutColors = serializableConfig(getDefaultStyleConfig());
-    atomicWriteFile(configPath, JSON.stringify(styleConfigWithoutColors, null, 2), {
+    const autoColorEntry = DEFAULT_CONFIG.colors?.auto;
+    if (!autoColorEntry || typeof autoColorEntry === "string") {
+      throw new Error("DEFAULT_CONFIG is missing the built-in auto color alias");
+    }
+    const configWithAutoColor = {
+      ...styleConfigWithoutColors,
+      colors: { auto: { tiers: autoColorEntry.tiers } }
+    };
+    atomicWriteFile(configPath, JSON.stringify(configWithAutoColor, null, 2), {
       appendNewline: true
     });
   }
@@ -1091,7 +1111,7 @@ async function readBodyWithLimit(response) {
     throw new HttpError(`Failed to read response body: ${error}`);
   }
 }
-async function secureFetch(url, options = {}, timeoutMs = 5000, userAgent) {
+async function secureFetch(url, options = {}, timeoutMs = DEFAULT_TIMEOUT_BUDGET_MS, userAgent) {
   const signal = AbortSignal.timeout(timeoutMs);
   const fetchOptions = {
     ...options,
@@ -1140,7 +1160,33 @@ function extractOrigin(baseUrl) {
     return baseUrl;
   }
 }
-async function probeHealth(baseUrl, timeoutMs = 1500) {
+function matchHealthResponse(data, endpointConfigs) {
+  const candidates = Object.entries(endpointConfigs).reduce((acc, [providerId, config]) => {
+    const healthMatch = config.detection?.healthMatch;
+    if (healthMatch != null && Object.keys(healthMatch).length > 0) {
+      acc.push({ providerId, healthMatch });
+    }
+    return acc;
+  }, []);
+  candidates.sort((a, b) => {
+    const diff = Object.keys(b.healthMatch).length - Object.keys(a.healthMatch).length;
+    return diff !== 0 ? diff : a.providerId.localeCompare(b.providerId);
+  });
+  for (const { providerId, healthMatch } of candidates) {
+    const matches = Object.entries(healthMatch).every(([field, expected]) => {
+      const actual = data[field];
+      if (expected === HEALTH_MATCH_WILDCARD) {
+        return typeof actual === "string";
+      }
+      return actual === expected;
+    });
+    if (matches) {
+      return providerId;
+    }
+  }
+  return null;
+}
+async function probeHealth(baseUrl, timeoutMs = DEFAULT_TIMEOUT_BUDGET_MS, endpointConfigs = {}) {
   const origin = extractOrigin(baseUrl);
   const healthUrl = `${origin}/health`;
   logger.debug("Probing health endpoint", { healthUrl, timeoutMs });
@@ -1153,13 +1199,10 @@ async function probeHealth(baseUrl, timeoutMs = 1500) {
     }, 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";
+    const matched = matchHealthResponse(data, endpointConfigs);
+    if (matched) {
+      logger.debug("Detected provider from health response", { provider: matched });
+      return matched;
     }
     logger.debug("Health probe returned unrecognized pattern", { data });
     return null;
@@ -1168,6 +1211,15 @@ async function probeHealth(baseUrl, timeoutMs = 1500) {
     return null;
   }
 }
+async function probeHealthWithMetrics(baseUrl, timeoutMs, endpointConfigs) {
+  const start = Date.now();
+  const matchedProvider = await probeHealth(baseUrl, timeoutMs, endpointConfigs);
+  return {
+    success: matchedProvider !== null,
+    matchedProvider,
+    responseTimeMs: Date.now() - start
+  };
+}
 
 // src/services/cache.ts
 import { readFileSync as readFileSync6, unlinkSync as unlinkSync4 } from "fs";
@@ -1290,6 +1342,37 @@ function readProviderDetectionCache(baseUrl) {
     return null;
   }
 }
+function deleteProviderDetectionCache(baseUrl) {
+  const path = getProviderDetectionCachePath(baseUrl);
+  try {
+    unlinkSync4(path);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
+      return;
+    }
+    logger.warn(`Failed to delete provider detection cache at ${path}: ${err}`);
+  }
+}
+function readDetectionCacheMeta(baseUrl) {
+  const defaultTtlMs = DETECTION_TTL_BASE_S * 1000;
+  const path = getProviderDetectionCachePath(baseUrl);
+  let content;
+  try {
+    content = readFileSync6(path, "utf-8");
+  } catch {
+    return { ageMs: null, ttlMs: defaultTtlMs };
+  }
+  try {
+    const data = JSON.parse(content);
+    if (!isProviderDetectionCacheEntry(data))
+      return { ageMs: null, ttlMs: defaultTtlMs };
+    const detectedAt = new Date(data.detectedAt).getTime();
+    const ageMs = isNaN(detectedAt) ? null : Date.now() - detectedAt;
+    return { ageMs, ttlMs: data.ttlSeconds * 1000 };
+  } catch {
+    return { ageMs: null, ttlMs: defaultTtlMs };
+  }
+}
 function writeProviderDetectionCache(baseUrl, entry) {
   const path = getProviderDetectionCachePath(baseUrl);
   try {
@@ -1303,27 +1386,7 @@ function writeProviderDetectionCache(baseUrl, entry) {
 
 // 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) {
+async function resolveProvider(baseUrl, providerOverride, endpointConfigs = {}, probeTimeoutMs = DEFAULT_TIMEOUT_BUDGET_MS) {
   if (providerOverride) {
     logger.debug("Provider override detected", { provider: providerOverride });
     return providerOverride;
@@ -1345,33 +1408,18 @@ async function resolveProvider(baseUrl, providerOverride, endpointConfigs = {},
     });
     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);
+  const probedProvider = await probeHealth(baseUrl, probeTimeoutMs, endpointConfigs);
   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;
+  logger.debug("Health probe failed, defaulting to sub2api");
+  cacheProviderDetection(baseUrl, "sub2api", "health-probe");
+  return "sub2api";
 }
-function cacheProviderDetection(baseUrl, provider, detectedVia) {
+function cacheProviderDetection(baseUrl, provider, detectedVia, ttlSeconds = DETECTION_TTL_BASE_S) {
   const now = new Date().toISOString();
   detectionCache.set(baseUrl, {
     provider,
@@ -1382,9 +1430,15 @@ function cacheProviderDetection(baseUrl, provider, detectedVia) {
     provider,
     detectedVia,
     detectedAt: now,
-    ttlSeconds: PROVIDER_DETECTION_TTL_SECONDS
+    ttlSeconds
   });
 }
+function cacheProviderDetectionWithTtl(baseUrl, provider, ttlSeconds) {
+  cacheProviderDetection(baseUrl, provider, "health-probe", ttlSeconds);
+}
+function invalidateDetectionCache(baseUrl) {
+  detectionCache.delete(baseUrl);
+}
 function clearDetectionCache() {
   detectionCache.clear();
 }
@@ -1540,7 +1594,7 @@ function mapPeriodTokens(data) {
     cost: data.cost ?? 0
   };
 }
-async function fetchSub2api(baseUrl, token, config, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+async function fetchSub2api(baseUrl, token, config, timeoutMs = DEFAULT_TIMEOUT_BUDGET_MS) {
   const url = `${baseUrl}/v1/usage`;
   const resolvedUA = resolveUserAgent(config.spoofClaudeCodeUA);
   if (resolvedUA) {
@@ -1621,7 +1675,7 @@ function computeWeeklyResetTime(resetDay, resetHour) {
   const resetDate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() + daysUntilReset, resetHour, 0, 0, 0));
   return resetDate.toISOString();
 }
-async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+async function fetchClaudeRelayService(baseUrl, token, config, timeoutMs = DEFAULT_TIMEOUT_BUDGET_MS) {
   const origin = extractOrigin(baseUrl);
   const url = `${origin}/apiStats/api/user-stats`;
   const resolvedUA = resolveUserAgent(config.spoofClaudeCodeUA);
@@ -1861,7 +1915,7 @@ function validateEndpointConfigSemantics(config) {
   }
   return null;
 }
-async function fetchEndpoint(baseUrl, token, appConfig, endpointConfig, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+async function fetchEndpoint(baseUrl, token, appConfig, endpointConfig, timeoutMs = DEFAULT_TIMEOUT_BUDGET_MS) {
   const validationError = validateEndpointConfigSemantics(endpointConfig);
   if (validationError) {
     throw new Error(`Invalid endpoint config: ${validationError}`);
@@ -1951,7 +2005,7 @@ var ANSI_COLORS = {
   grey: "\x1B[90m"
 };
 var THEME_COLORS = {
-  cool: "#56B6C2",
+  cool: "#569AD4",
   comfortable: "#5EBE8A",
   warm: "#C9A84C",
   hot: "#D68B45",
@@ -2428,6 +2482,10 @@ function getProgressIcon(percent, nerdFontAvailable = true) {
 
 // src/renderer/format.ts
 function formatCurrency(n) {
+  if (n > 0 && n < 10) {
+    const rounded = Math.round(n * 10) / 10;
+    return `$${rounded.toFixed(1)}`;
+  }
   return `$${Math.floor(n)}`;
 }
 function formatCurrencyQuota(used, limit) {
@@ -2504,7 +2562,8 @@ function renderQuotaComponent(componentId, quota, options, componentConfig, glob
   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 = showPercentage ? ansiColor(`${Math.round(usagePercent)}%`, valueColor, renderContext) : "";
+  const percentText = usagePercent > 0 && usagePercent < 10 ? `${(Math.round(usagePercent * 10) / 10).toFixed(1)}%` : `${Math.round(usagePercent)}%`;
+  const value = showPercentage ? ansiColor(percentText, valueColor, renderContext) : "";
   const countdown = renderSecondaryDisplay(quota.resetsAt, quota, componentConfig.countdown, countdownColor, clockFormat, renderContext);
   return assembleComponent(layout, label, labelColor, progress, value, countdown, renderContext);
 }
@@ -2935,6 +2994,35 @@ function isComponentId(key) {
   return DEFAULT_COMPONENT_ORDER.includes(key);
 }
 
+// src/core/error-classifier.ts
+function classifyFetchError(error) {
+  if (error && typeof error === "object") {
+    if ("statusCode" in error) {
+      const statusCode = error.statusCode;
+      if (statusCode === 404 || statusCode === 410) {
+        return "site-closed";
+      }
+      return "transient";
+    }
+    if (error instanceof Error) {
+      if (error.name === "TimeoutError") {
+        return "transient";
+      }
+      if (error.name === "ResponseTooLargeError") {
+        return "provider-mismatch";
+      }
+      if (error instanceof SyntaxError) {
+        return "provider-mismatch";
+      }
+      const msg = error.message.toLowerCase();
+      if (msg.includes("invalid response") || msg.includes("expected object") || msg.includes("missing data") || msg.includes("missing limits")) {
+        return "provider-mismatch";
+      }
+    }
+  }
+  return "transient";
+}
+
 // src/core/execute-cycle.ts
 async function executeCycle(ctx) {
   const { env, config, configHash, endpointConfigHash, endpointLock, cachedEntry, providerId, provider, timeoutBudgetMs, startTime, fetchTimeoutMs } = ctx;
@@ -2947,7 +3035,9 @@ async function executeCycle(ctx) {
         return {
           output: cachedEntry.renderedLine,
           exitCode: 0,
-          cacheUpdate: null
+          cacheUpdate: null,
+          invalidateProvider: false,
+          path: "A"
         };
       }
     }
@@ -2962,14 +3052,18 @@ async function executeCycle(ctx) {
       return {
         output: statusline,
         exitCode: 0,
-        cacheUpdate: null
+        cacheUpdate: null,
+        invalidateProvider: false,
+        path: "B2"
       };
     }
     const errorOutput = renderError("endpoint-config-changed", "without-cache");
     return {
       output: errorOutput,
       exitCode: 0,
-      cacheUpdate: null
+      cacheUpdate: null,
+      invalidateProvider: false,
+      path: "B2"
     };
   }
   if (cachedEntry && isCacheValid(cachedEntry, env) && isCacheProviderValid(cachedEntry, providerId)) {
@@ -2984,7 +3078,9 @@ async function executeCycle(ctx) {
     return {
       output: statusline,
       exitCode: 0,
-      cacheUpdate: updatedEntry
+      cacheUpdate: updatedEntry,
+      invalidateProvider: false,
+      path: "B"
     };
   }
   const deadline = startTime + timeoutBudgetMs - EXIT_BUFFER_MS;
@@ -2995,7 +3091,9 @@ async function executeCycle(ctx) {
     return {
       output: errorOutput,
       exitCode: 0,
-      cacheUpdate: null
+      cacheUpdate: null,
+      invalidateProvider: false,
+      path: "D"
     };
   }
   try {
@@ -3005,7 +3103,9 @@ async function executeCycle(ctx) {
       return {
         output: renderError("missing-env", "without-cache"),
         exitCode: 0,
-        cacheUpdate: null
+        cacheUpdate: null,
+        invalidateProvider: false,
+        path: "D"
       };
     }
     logger.debug("Path C: Fetching from provider", { providerId, fetchTimeoutMs });
@@ -3031,23 +3131,30 @@ async function executeCycle(ctx) {
     return {
       output: statusline,
       exitCode: 0,
-      cacheUpdate: newEntry
+      cacheUpdate: newEntry,
+      invalidateProvider: false,
+      path: "C"
     };
   } catch (error) {
     logger.error("Path D: Fetch error", { error: String(error), hasCachedEntry: !!cachedEntry });
+    const errorCategory = classifyFetchError(error);
     let errorState = "network-error";
     if (error && typeof error === "object" && "statusCode" in error) {
       const statusCode = error.statusCode;
       if (statusCode === 429) {
         errorState = "rate-limited";
+      } else if (errorCategory === "site-closed") {
+        errorState = "network-error";
       } else if (statusCode && statusCode >= 500) {
         errorState = "server-error";
       } else if (statusCode === 401 || statusCode === 403) {
         errorState = "auth-error";
       }
+    } else if (errorCategory === "provider-mismatch") {
+      errorState = "parse-error";
     }
     if (cachedEntry) {
-      logger.debug("Discarding stale cache, showing error", { errorState });
+      logger.debug("Discarding stale cache, showing error", { errorState, errorCategory });
     } else {
       logger.warn("No cache available for error fallback");
     }
@@ -3055,10 +3162,32 @@ async function executeCycle(ctx) {
     return {
       output: errorOutput,
       exitCode: 0,
-      cacheUpdate: null
+      cacheUpdate: null,
+      invalidateProvider: errorCategory === "provider-mismatch",
+      path: "D"
     };
   }
 }
+// src/core/maintenance-scheduler.ts
+function selectMaintenanceTask(ctx) {
+  if (ctx.path !== "A" && ctx.path !== "B")
+    return "none";
+  if (ctx.detectionCacheAgeMs === null)
+    return "health-probe";
+  if (ctx.detectionCacheAgeMs >= ctx.detectionCacheTtlMs * 0.5)
+    return "health-probe";
+  if (Math.random() < MAINTENANCE_GC_PROBABILITY)
+    return "cache-gc";
+  return "none";
+}
+function computeDynamicDetectionTtl(outcome, currentProvider, currentTtlSeconds) {
+  if (!outcome.success)
+    return DETECTION_TTL_FAILED_S;
+  if (outcome.matchedProvider !== currentProvider)
+    return DETECTION_TTL_CHANGED_S;
+  return Math.min(currentTtlSeconds * 2, DETECTION_TTL_MAX_S);
+}
+
 // src/services/cache-gc.ts
 import { readdirSync as readdirSync4, statSync as statSync2, unlinkSync as unlinkSync6, existsSync as existsSync6 } from "fs";
 import { join as join12 } from "path";
@@ -3168,6 +3297,34 @@ function runCacheGC(cacheDir) {
 }
 
 // src/cli/piped-mode.ts
+var DEFAULT_PIPED_MODE_DEPS = {
+  readCurrentEnv,
+  validateRequiredEnv,
+  readCache,
+  writeCache,
+  getCacheDir,
+  isCacheValid,
+  loadConfigWithHash,
+  loadEndpointConfigs,
+  computeEndpointConfigHash,
+  readEndpointLock,
+  writeEndpointLock,
+  needsConfigInit,
+  writeDefaultConfigs,
+  resolveProvider,
+  getProvider,
+  invalidateDetectionCache,
+  deleteProviderDetectionCache,
+  renderError,
+  dimText,
+  executeCycle,
+  logger,
+  runCacheGC,
+  probeHealthWithMetrics,
+  readDetectionCacheMeta,
+  cacheProviderDetectionWithTtl
+};
+
 class StatuslineError extends Error {
   errorType;
   constructor(errorType) {
@@ -3180,15 +3337,15 @@ function safeStdoutWrite(data) {
     process.stdout["write"](data);
   } catch {}
 }
-function readAndValidateEnv() {
-  const env = readCurrentEnv();
-  logger.debug("Environment loaded", {
+function readAndValidateEnv(deps) {
+  const env = deps.readCurrentEnv();
+  deps.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);
+  const envError = deps.validateRequiredEnv(env);
   if (envError) {
     throw new StatuslineError("missing-env");
   }
@@ -3198,75 +3355,75 @@ function readAndValidateEnv() {
   }
   return { env, baseUrl };
 }
-function ensureDefaultConfigs() {
-  if (needsConfigInit()) {
-    logger.debug("First run detected - initializing default configs");
-    writeDefaultConfigs();
+function ensureDefaultConfigs(deps) {
+  if (deps.needsConfigInit()) {
+    deps.logger.debug("First run detected - initializing default configs");
+    deps.writeDefaultConfigs();
   }
 }
-function loadEndpointConfigsWithHash() {
-  const endpointConfigs = loadEndpointConfigs();
-  const endpointConfigHash = computeEndpointConfigHash();
-  logger.debug("Endpoint configs loaded", {
+function loadEndpointConfigsWithHash(deps) {
+  const endpointConfigs = deps.loadEndpointConfigs();
+  const endpointConfigHash = deps.computeEndpointConfigHash();
+  deps.logger.debug("Endpoint configs loaded", {
     configCount: Object.keys(endpointConfigs).length,
     endpointConfigHash
   });
   return { endpointConfigs, endpointConfigHash };
 }
-function resolveEndpointLock(hash) {
-  const existing = readEndpointLock();
+function resolveEndpointLock(hash, deps) {
+  const existing = deps.readEndpointLock();
   if (existing) {
-    logger.debug("Endpoint lock file loaded", {
+    deps.logger.debug("Endpoint lock file loaded", {
       lockedHash: existing.hash,
       currentHash: hash,
       locked: existing.hash === hash
     });
     return existing;
   }
-  logger.debug("Endpoint lock file missing - creating with current hash");
-  writeEndpointLock(hash);
+  deps.logger.debug("Endpoint lock file missing - creating with current hash");
+  deps.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 });
+async function resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, timeoutMs, deps) {
+  const probeTimeout = isPiped ? Math.floor(timeoutMs / 2) : timeoutMs;
+  const providerId = await deps.resolveProvider(baseUrl, env.providerOverride, endpointConfigs, probeTimeout);
+  const provider = deps.getProvider(providerId, endpointConfigs);
+  deps.logger.debug("Provider resolved", { providerId, probeTimeout });
   if (!provider) {
-    logger.error("Provider not found", { providerId });
+    deps.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 ?? DEFAULT_PIPED_REQUEST_TIMEOUT_MS, timeoutBudgetMs - 100) : 1e4;
+  const timeoutBudgetMs = isPiped ? timeoutMs : TTY_TIMEOUT_BUDGET_MS;
+  const fetchTimeoutMs = isPiped ? Math.min(config.pipedRequestTimeoutMs ?? DEFAULT_TIMEOUT_BUDGET_MS, timeoutBudgetMs - TIMEOUT_HEADROOM_MS) : TTY_TIMEOUT_BUDGET_MS;
   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", {
+async function buildExecutionContext(args, isPiped, startTime, rawTimeoutMs, deps) {
+  const { env, baseUrl } = readAndValidateEnv(deps);
+  ensureDefaultConfigs(deps);
+  const { config, configHash } = deps.loadConfigWithHash(args.configPath);
+  const { endpointConfigs, endpointConfigHash } = loadEndpointConfigsWithHash(deps);
+  const endpointLock = resolveEndpointLock(endpointConfigHash, deps);
+  const cachedEntry = deps.readCache(baseUrl);
+  deps.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 (cachedEntry && deps.isCacheValid(cachedEntry, env)) {
+    const cachedProvider = deps.getProvider(cachedEntry.provider, endpointConfigs);
     if (cachedProvider) {
       providerId = cachedEntry.provider;
       provider = cachedProvider;
-      logger.debug("Cache-first: skipping provider probe", { providerId });
+      deps.logger.debug("Cache-first: skipping provider probe", { providerId });
     } else {
-      ({ providerId, provider } = await resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, rawTimeoutMs));
+      ({ providerId, provider } = await resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, rawTimeoutMs, deps));
     }
   } else {
-    ({ providerId, provider } = await resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, rawTimeoutMs));
+    ({ providerId, provider } = await resolveProviderWithTimeout(baseUrl, env, endpointConfigs, isPiped, rawTimeoutMs, deps));
   }
   const { timeoutBudgetMs, fetchTimeoutMs } = computeTimeoutBudgets(isPiped, config, rawTimeoutMs);
   const ctx = {
@@ -3282,82 +3439,124 @@ async function buildExecutionContext(args, isPiped, startTime, rawTimeoutMs) {
     startTime,
     fetchTimeoutMs
   };
-  return { ctx, baseUrl };
+  return { ctx, baseUrl, endpointConfigs };
 }
-function formatOutput(output, isPiped) {
+function formatOutput(output, mode, log) {
   let normalizedOutput = output;
   if (!normalizedOutput || normalizedOutput.trim().length === 0) {
-    logger.debug("Empty output detected, using fallback");
+    log.debug("Empty output detected, using fallback");
     normalizedOutput = "[loading...]";
   }
-  if (isPiped) {
-    logger.debug("Output formatted for piped mode (ANSI reset + NBSP)");
-    return "\x1B[0m" + normalizedOutput.replace(/ /g, " ");
-  } else {
-    logger.debug("Output written (TTY mode)");
-    return normalizedOutput;
+  switch (mode) {
+    case "piped-embedded":
+      log.debug("Output written (embedded piped mode - no host formatting)");
+      return normalizedOutput;
+    case "piped":
+      log.debug("Output formatted for piped mode (ANSI reset + NBSP)");
+      return "\x1B[0m" + normalizedOutput.replace(/ /g, " ");
+    case "tty":
+      log.debug("Output written (TTY mode)");
+      return normalizedOutput + `
+`;
   }
 }
-async function executePipedMode(args) {
+async function runMaintenance(result, baseUrl, startTime, budgetMs, endpointConfigs, currentProviderId, deps) {
+  const { ageMs, ttlMs } = deps.readDetectionCacheMeta(baseUrl);
+  const task = selectMaintenanceTask({
+    path: result.path,
+    detectionCacheAgeMs: ageMs,
+    detectionCacheTtlMs: ttlMs
+  });
+  if (task === "none")
+    return;
+  deps.logger.debug("Maintenance task selected", { task, path: result.path });
+  if (task === "health-probe") {
+    const elapsed = Date.now() - startTime;
+    const remainingMs = Math.max(50, budgetMs - elapsed - TIMEOUT_HEADROOM_MS);
+    const currentTtlS = Math.floor(ttlMs / 1000) || DETECTION_TTL_BASE_S;
+    const outcome = await deps.probeHealthWithMetrics(baseUrl, remainingMs, endpointConfigs);
+    deps.logger.debug("Maintenance probe completed", {
+      success: outcome.success,
+      matchedProvider: outcome.matchedProvider,
+      responseTimeMs: outcome.responseTimeMs
+    });
+    if (outcome.success && outcome.matchedProvider) {
+      const newTtlS = computeDynamicDetectionTtl(outcome, currentProviderId, currentTtlS);
+      deps.cacheProviderDetectionWithTtl(baseUrl, outcome.matchedProvider, newTtlS);
+      deps.logger.debug("Detection cache refreshed", { ttlSeconds: newTtlS, provider: outcome.matchedProvider });
+    }
+  } else if (task === "cache-gc") {
+    deps.runCacheGC(deps.getCacheDir());
+    deps.logger.debug("Cache GC completed");
+  }
+}
+async function executePipedMode(args, deps = DEFAULT_PIPED_MODE_DEPS) {
   const startTime = Date.now();
-  logger.debug("=== cc-api-statusline execution started ===");
-  logger.debug("Start time", { startTime });
+  deps.logger.debug("=== cc-api-statusline execution started ===");
+  deps.logger.debug("Start time", { startTime });
   const isPiped = !process.stdin.isTTY;
-  logger.debug("Mode detection", { isPiped, once: args.once });
-  const rawTimeoutMs = Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? 5000);
+  const outputMode = !isPiped ? "tty" : args.embedded ? "piped-embedded" : "piped";
+  deps.logger.debug("Mode detection", { isPiped, once: args.once, outputMode });
+  const rawTimeoutMs = Number(process.env["CC_STATUSLINE_TIMEOUT"] ?? DEFAULT_TIMEOUT_BUDGET_MS);
   if (isPiped) {
-    const watchdogMs = rawTimeoutMs - 100;
+    const watchdogMs = rawTimeoutMs - TIMEOUT_HEADROOM_MS;
     setTimeout(() => {
-      logger.error("Watchdog timeout - forcing clean exit", { watchdogMs });
-      const fallback = dimText("⟳ Refreshing...");
-      const formatted = formatOutput(fallback, isPiped);
+      deps.logger.error("Watchdog timeout - forcing clean exit", { watchdogMs });
+      const fallback = deps.dimText("⟳ Refreshing...");
+      const formatted = formatOutput(fallback, outputMode, deps.logger);
       safeStdoutWrite(formatted);
       process.exit(0);
     }, watchdogMs).unref();
   }
   let ctx;
   let baseUrl;
+  let endpointConfigs;
   try {
-    ({ ctx, baseUrl } = await buildExecutionContext(args, isPiped, startTime, rawTimeoutMs));
+    ({ ctx, baseUrl, endpointConfigs } = await buildExecutionContext(args, isPiped, startTime, rawTimeoutMs, deps));
   } catch (error) {
-    logger.error("Failed to build execution context", { error: String(error) });
+    deps.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);
+    const errorOutput = deps.renderError(errorType, "without-cache");
+    const formattedOutput2 = formatOutput(errorOutput, outputMode, deps.logger);
     safeStdoutWrite(formattedOutput2);
-    logger.debug("=== cc-api-statusline execution completed ===");
+    deps.logger.debug("=== cc-api-statusline execution completed ===");
     process.exit(0);
   }
-  logger.debug("Execution context prepared", {
+  deps.logger.debug("Execution context prepared", {
     timeoutBudgetMs: ctx.timeoutBudgetMs,
     fetchTimeoutMs: ctx.fetchTimeoutMs
   });
   let result;
   try {
-    result = await executeCycle(ctx);
+    result = await deps.executeCycle(ctx);
   } catch (error) {
-    logger.error("Execution cycle failed", { error: String(error) });
-    const errorOutput = renderError("network-error", "without-cache");
-    const formattedOutput2 = formatOutput(errorOutput, isPiped);
+    deps.logger.error("Execution cycle failed", { error: String(error) });
+    const errorOutput = deps.renderError("network-error", "without-cache");
+    const formattedOutput2 = formatOutput(errorOutput, outputMode, deps.logger);
     safeStdoutWrite(formattedOutput2);
-    logger.debug("=== cc-api-statusline execution completed ===");
+    deps.logger.debug("=== cc-api-statusline execution completed ===");
     process.exit(0);
   }
   const executionTime = Date.now() - startTime;
-  logger.debug("Execution completed", {
+  deps.logger.debug("Execution completed", {
     exitCode: result.exitCode,
     executionTime: `${executionTime}ms`,
     outputLength: result.output.length,
     cacheUpdate: !!result.cacheUpdate
   });
-  const formattedOutput = formatOutput(result.output, isPiped);
+  const formattedOutput = formatOutput(result.output, outputMode, deps.logger);
   safeStdoutWrite(formattedOutput);
+  if (result.invalidateProvider) {
+    deps.invalidateDetectionCache(baseUrl);
+    deps.deleteProviderDetectionCache(baseUrl);
+    deps.logger.debug("Provider detection cache invalidated", { baseUrl });
+  }
   if (result.cacheUpdate) {
-    writeCache(baseUrl, result.cacheUpdate);
-    logger.debug("Cache written", { baseUrl });
-    runCacheGC(getCacheDir());
+    deps.writeCache(baseUrl, result.cacheUpdate);
+    deps.logger.debug("Cache written", { baseUrl });
   }
-  logger.debug("=== cc-api-statusline execution completed ===");
+  await runMaintenance(result, baseUrl, startTime, rawTimeoutMs, endpointConfigs, ctx.providerId, deps);
+  deps.logger.debug("=== cc-api-statusline execution completed ===");
   process.exit(result.exitCode);
 }
 // src/main.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-api-statusline",
-  "version": "1.0.2",
+  "version": "1.1.2",
   "description": "Claude Code statusline tool that polls API usage from third-party proxy backends",
   "type": "module",
   "bin": {