cc-api-statusline 1.0.1 → 1.1.1

package/README.md

@@ -1,14 +1,15 @@
 # cc-api-statusline
 
-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.
+English | [简体中文](README.zh-CN.md)
+
+<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
@@ -43,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
@@ -54,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
@@ -61,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
@@ -142,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)).
@@ -177,7 +176,8 @@ All variables are optional at the shell level — `ANTHROPIC_BASE_URL` and `ANTH
 | `ANTHROPIC_AUTH_TOKEN` | Yes | API key or token |
 | `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 1000) |
+| `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
@@ -219,7 +219,7 @@ cc-api-statusline --once
 DEBUG=1 cc-api-statusline --once
 ```
 
-Verify `pipedRequestTimeoutMs` in config (default 800ms) and check `~/.claude/cc-api-statusline/cache-*.json` exists.
+Verify `pipedRequestTimeoutMs` in config (default 3000ms) and check `~/.claude/cc-api-statusline/cache-*.json` exists.
 
 ### Widget shows `[Exit: 1]` in Claude Code
 

package/README.zh-CN.md

@@ -0,0 +1,295 @@
+# cc-api-statusline
+
+[English](README.md) | 简体中文
+
+在ClaudeCode状态栏显示API用量，通过轮询 Claude API 服务（sub2api、claude-relay-service 或自定义提供商）获取用量数据，并以可配置显示样式。
+
+## 特性
+
+- 🎨 **高度可配置** — 布局、颜色、进度条样式、显示模式任意调整
+- 🔌 **提供商自动识别** — 开箱支持 sub2api、claude-relay-service 及自定义提供商
+- 🎯 **Claude Code 集成** — 一键 `--install` 完成安装
+- 📊 **多维度用量展示** — 每日/每周/每月配额、余额、Token数、速率限制
+- 🔁 **热切换** — 自动感知 API 端点和凭证变更，无需重启
+- 🔒 **高可靠性** — 无过期数据展示、无竞争条件写入、缓存自动清理
+
+## 快速上手
+
+### 1. 配置 API 端点
+
+需要准备 `ANTHROPIC_BASE_URL`（代理地址）和 `ANTHROPIC_AUTH_TOKEN`（API 密钥）两个变量。
+
+**推荐方式：写入 `~/.claude/settings.json` 的 env 字段**（会自动传递给组件）：
+
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "https://your-proxy.example.com",
+    "ANTHROPIC_AUTH_TOKEN": "your-api-token"
+  }
+}
+```
+
+也可以直接在 Shell 中导出：
+
+```bash
+export ANTHROPIC_BASE_URL="https://your-proxy.example.com"
+export ANTHROPIC_AUTH_TOKEN="your-api-token"
+```
+
+### 2. 预览效果
+
+```bash
+bunx cc-api-statusline@latest --once
+```
+
+### 3.a 安装为 Claude Code 状态栏组件
+
+```bash
+bunx cc-api-statusline@latest --install
+```
+
+此命令会自动向 `~/.claude/settings.json` 写入以下配置：
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "bunx -y cc-api-statusline@latest",
+    "padding": 0
+  }
+}
+```
+### 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` 可每次自动拉取最新版本，无需全局安装。如需卸载：
+
+```bash
+bunx cc-api-statusline --uninstall
+```
+
+也支持全局安装：
+
+```bash
+bun add -g cc-api-statusline
+# 或
+npm install -g cc-api-statusline
+```
+
+## 热切换
+
+当 `ANTHROPIC_BASE_URL` 或 `ANTHROPIC_AUTH_TOKEN` 发生变化时（例如切换 Claude Code 配置文件或轮换密钥），cc-api-statusline 会自动检测并触发切换。切换期间会短暂显示过渡提示（`⟳ Switching provider...`），随后从新端点刷新数据，全程无需重启。
+
+## 配置
+
+### 样式配置（`~/.claude/cc-api-statusline/config.json`）
+
+```json
+{
+  "display": {
+    "layout": "standard",
+    "displayMode": "text",
+    "progressStyle": "icon",
+    "barStyle": "block",
+    "divider": { "text": "|", "margin": 1, "color": "#555753" },
+    "maxWidth": 100
+  },
+  "components": {
+    "daily": true,
+    "weekly": true,
+    "monthly": true,
+    "balance": true,
+    "tokens": false,
+    "rateLimit": false
+  }
+}
+```
+
+主要配置项说明：
+
+| 配置项 | 可选值 | 默认值 | 说明 |
+|--------|--------|--------|------|
+| `layout` | `standard` / `percent-first` | `standard` | 标签、进度条、数值的排列顺序 |
+| `displayMode` | `text` / `compact` / `emoji` / `nerd` / `hidden` | `text` | 标签样式。`nerd` 需安装 [Nerd Font](https://www.nerdfonts.com/font-downloads) |
+| `progressStyle` | `bar` / `icon` / `hidden` | `icon` | 用量进度的可视化方式。`icon` 需安装 [Nerd Font](https://www.nerdfonts.com/font-downloads) |
+| `barStyle` | `block` / `classic` / `dot` / `shade` / `pipe` / `braille` / `square` / `star` | `block` | 进度条字符样式 |
+| `barSize` | `small` / `small-medium` / `medium` / `medium-large` / `large` | `medium` | 进度条宽度（4–12 个字符） |
+| `divider` | `DividerConfig` 或 `false` | `{ text: "\|", margin: 1, color: "#555753" }` | 组件间分隔符；设为 `false` 可禁用 |
+| `maxWidth` | 20–100 | `100` | 状态栏最大宽度占终端宽度的百分比 |
+
+完整样式参考（包含每组件独立配置、颜色别名、倒计时等高级选项）请查阅 [docs/spec-tui-style.md](docs/spec-tui-style.md)。
+
+#### User-Agent 伪装
+
+部分提供商会限制非 Claude Code 客户端的访问，可启用此选项绕过：
+
+```json
+{
+  "spoofClaudeCodeUA": true
+}
+```
+
+- `false` / `undefined` — 不发送 User-Agent 请求头（默认）
+- `true` — 自动获取当前 Claude Code 版本，获取失败则回退至 `claude-cli/2.1.56 (external, cli)`
+- `"string"` — 使用指定的自定义 User-Agent 字符串
+
+### API 提供商配置（`~/.claude/cc-api-statusline/api-config/`）
+
+在此目录下以 JSON 文件形式定义自定义提供商。添加或修改后，执行以下命令使其生效：
+
+```bash
+cc-api-statusline --apply-config
+```
+
+完整 Schema 请参阅 [docs/api-config-reference.md](docs/api-config-reference.md)。
+
+## 环境变量
+
+以下所有变量均为可选——`ANTHROPIC_BASE_URL` 和 `ANTHROPIC_AUTH_TOKEN` 可通过 `settings.json` 的 env 字段配置，无需在 Shell 中手动导出（详见[快速上手](#快速上手)）。
+
+| 变量 | 是否可选 | 说明 |
+|------|----------|------|
+| `ANTHROPIC_BASE_URL` | 是 | API 端点地址（如 `https://api.sub2api.com`） |
+| `ANTHROPIC_AUTH_TOKEN` | 是 | API 密钥或Token |
+| `CC_STATUSLINE_PROVIDER` | 是 | 手动指定提供商（`sub2api`、`claude-relay-service` 或自定义） |
+| `CC_STATUSLINE_POLL` | 是 | 轮询间隔（秒，最小 5） |
+| `CC_STATUSLINE_TIMEOUT` | 是 | 管道模式超时时间（毫秒，默认 5000） |
+| `DEBUG` 或 `CC_STATUSLINE_DEBUG` | 是 | 开启调试日志，输出至 `~/.claude/cc-api-statusline/debug.log` |
+
+## 常见问题
+
+### 提示 "Missing required environment variable"
+
+请通过 Shell 导出或 `settings.json` env 字段设置 `ANTHROPIC_BASE_URL` 和 `ANTHROPIC_AUTH_TOKEN`（详见[快速上手](#快速上手)）。
+
+### 提示 "Unknown provider"
+
+提供商自动识别失败，请手动指定：
+
+```bash
+export CC_STATUSLINE_PROVIDER="sub2api"
+```
+
+或在 `api-config/` 目录下定义自定义提供商。
+
+### 显示 "[offline]" 或 "[stale]"
+
+通常由网络错误或缓存过期导致，可开启调试日志排查：
+
+```bash
+DEBUG=1 cc-api-statusline --once
+tail -f ~/.claude/cc-api-statusline/debug.log
+```
+
+排查要点：
+- `ANTHROPIC_BASE_URL` 对应的网络是否可达
+- API 端点是否正常响应
+- Token是否有效且未过期
+
+### 管道模式响应较慢
+
+```bash
+# 单独预热缓存
+cc-api-statusline --once
+# 查看详细耗时
+DEBUG=1 cc-api-statusline --once
+```
+
+检查配置中的 `pipedRequestTimeoutMs`（默认 3000ms），并确认 `~/.claude/cc-api-statusline/cache-*.json` 文件已存在。
+
+### Claude Code 中组件显示 `[Exit: 1]`
+
+在 `~/.claude/settings.json` 中开启调试日志：
+
+```json
+{
+  "statusLine": {
+    "type": "command",
+    "command": "DEBUG=1 bunx -y cc-api-statusline@latest",
+    "padding": 0
+  }
+}
+```
+
+然后查看日志：`tail -f ~/.claude/cc-api-statusline/debug.log`
+
+## 开发
+
+| 命令 | 说明 |
+|------|------|
+| `bun install` | 安装依赖 |
+| `bun run start` | 单次获取（--once 模式），用于快速调试 |
+| `bun run example` | 模拟管道模式 |
+| `bun run test` | 运行测试 |
+| `bun run lint` | 代码检查 |
+| `bun run build` | 构建 |
+| `bun run check` | 运行全部检查 |
+
+### 调试日志
+
+启用详细执行日志：
+
+```bash
+# 开启调试
+DEBUG=1 cc-api-statusline --once
+
+# 用于 Claude Code 组件时，在 settings.json 中设置：
+# "command": "DEBUG=1 bunx -y cc-api-statusline@latest"
+
+# 实时追踪日志
+tail -f ~/.claude/cc-api-statusline/debug.log
+
+# 搜索错误记录
+grep "ERROR" ~/.claude/cc-api-statusline/debug.log
+```
+
+调试日志涵盖：执行时间戳、模式检测、配置与缓存状态、执行路径（A/B/C/D）、请求耗时及错误详情。
+
+日志文件自动轮转（约每 20 次调用触发一次）：
+- `debug.log` ≥ 500 KB → 归档为 `debug.YYYY-MM-DDTHH-MM.log`
+- 归档超过 24 小时 → gzip 压缩
+- 压缩归档超过 3 天 → 自动删除
+
+## 测试
+
+- **691 个测试**，覆盖 **39 个测试文件**
+- 所有服务、渲染器及工具函数的单元测试
+- 核心执行路径测试（A/B/C/D）
+- 隔离环境端到端冒烟测试
+- 性能测试（验证 p95 < 600ms）
+- 缓存垃圾回收测试
+- GitHub Actions CI/CD 流水线
+
+运行：`bun run check`
+
+## 许可证
+
+MIT
+
+## 相关文档
+
+- [实现手册](docs/implementation-handbook.md)
+- [当前实现说明](docs/current-implementation.md)
+- [TUI 样式规范](docs/spec-tui-style.md)
+- [API 轮询规范](docs/spec-api-polling.md)
+- [自定义提供商规范](docs/spec-custom-providers.md)

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.1",
+  version: "1.1.1",
   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 1000)
-  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,8 +184,10 @@ import { spawn } from "child_process";
 import { dirname, join } from "path";
 
 // src/core/constants.ts
-var DEFAULT_FETCH_TIMEOUT_MS = 5000;
+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;
@@ -189,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$/;
@@ -563,7 +578,7 @@ var DEFAULT_CONFIG = {
     chill: { tiers: buildTiers(["cyan", "cyan", "blue", "blue", "magenta"]) }
   },
   pollIntervalSeconds: 30,
-  pipedRequestTimeoutMs: 800
+  pipedRequestTimeoutMs: DEFAULT_TIMEOUT_BUDGET_MS
 };
 var BAR_SIZE_MAP = {
   small: 4,
@@ -635,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";
@@ -813,7 +827,6 @@ function getBuiltInEndpointConfigs() {
         resetSemantics: "rolling-window"
       },
       detection: {
-        urlPatterns: ["/apistats", "/api/user-stats"],
         healthMatch: { service: "*" }
       },
       responseMapping: {
@@ -998,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
     });
   }
@@ -1090,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,
@@ -1139,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 });
@@ -1152,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;
@@ -1167,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";
@@ -1289,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 {
@@ -1302,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;
@@ -1344,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,
@@ -1381,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();
 }
@@ -1539,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) {
@@ -1620,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);
@@ -1860,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}`);
@@ -2399,11 +2454,14 @@ var TEXT_PROGRESS_ICONS = [
   "◕",
   "●"
 ];
+function calcIconIndex(percent, bucketSize, maxIndex) {
+  return Math.min(maxIndex, Math.ceil(Math.round(percent) / bucketSize));
+}
 function calcNerdIconIndex(percent) {
-  return Math.min(8, Math.ceil(percent / 12.5));
+  return calcIconIndex(percent, 12.5, 8);
 }
 function calcTextIconIndex(percent) {
-  return Math.min(4, Math.ceil(percent / 25));
+  return calcIconIndex(percent, 25, 4);
 }
 function getProgressIcon(percent, nerdFontAvailable = true) {
   if (!nerdFontAvailable) {
@@ -2511,7 +2569,7 @@ function renderBalanceComponent(balance, options, componentConfig, globalConfig,
   const isUnlimited = balance.remaining === -1;
   let usagePercent = null;
   if (!isUnlimited && balance.initial !== null && balance.initial > 0) {
-    usagePercent = (balance.initial - balance.remaining) / balance.initial * 100;
+    usagePercent = calculateUsagePercent(balance.initial - balance.remaining, balance.initial);
   }
   const effectivePercent = isUnlimited ? 0 : usagePercent;
   const label = renderLabel("balance", displayMode, componentConfig);
@@ -2931,6 +2989,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;
@@ -2943,7 +3030,9 @@ async function executeCycle(ctx) {
         return {
           output: cachedEntry.renderedLine,
           exitCode: 0,
-          cacheUpdate: null
+          cacheUpdate: null,
+          invalidateProvider: false,
+          path: "A"
         };
       }
     }
@@ -2958,14 +3047,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)) {
@@ -2980,7 +3073,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;
@@ -2991,7 +3086,9 @@ async function executeCycle(ctx) {
     return {
       output: errorOutput,
       exitCode: 0,
-      cacheUpdate: null
+      cacheUpdate: null,
+      invalidateProvider: false,
+      path: "D"
     };
   }
   try {
@@ -3001,7 +3098,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 });
@@ -3027,23 +3126,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");
     }
@@ -3051,10 +3157,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";
@@ -3164,6 +3292,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) {
@@ -3176,15 +3332,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");
   }
@@ -3194,75 +3350,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 ?? 800, 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 = {
@@ -3278,82 +3434,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"] ?? 1000);
+  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.1",
+  "version": "1.1.1",
   "description": "Claude Code statusline tool that polls API usage from third-party proxy backends",
   "type": "module",
   "bin": {