cc-costline 0.4.1 → 0.5.0

package/README.es.md

@@ -54,10 +54,10 @@ cc-costline config --period both # Mostrar ambos períodos
 ## Cómo funciona
 
 1. `install` configura `~/.claude/settings.json` — establece el comando de statusline y añade hooks de fin de sesión. Tu configuración existente se conserva.
-2. `render` es llamado por Claude Code en cada turno de conversación. Lee el JSON de stdin para datos de sesión, luego actualiza todas las fuentes de datos en línea cuando su caché expira (TTL unificado de 2 minutos):
-   - **Costo local**: escanea `~/.claude/projects/**/*.jsonl`, aplica precios por modelo → `~/.cc-costline/cache.json`
-   - **Límites de uso**: obtiene de `api.anthropic.com/api/oauth/usage` → `/tmp/sl-claude-usage`
-   - **Ranking ccclub**: obtiene de `ccclub.dev/api/rank` → `/tmp/sl-ccclub-rank`
+2. `render` es llamado por Claude Code en cada turno de conversación. Lee el JSON de stdin para datos de sesión, luego actualiza las fuentes de datos con TTLs separados:
+   - **Costo local** (TTL 2 min): escanea `~/.claude/projects/**/*.jsonl`, aplica precios por modelo → `~/.cc-costline/cache.json`
+   - **Límites de uso** (retry 5 min, sensible al token): obtiene de `api.anthropic.com/api/oauth/usage` → `/tmp/sl-claude-usage`. Detecta la rotación del token OAuth para reintentar inmediatamente (nuevo token = nueva cuota de límite). Los datos obsoletos persisten ante fallos.
+   - **Ranking ccclub** (retry 5 min): obtiene de `ccclub.dev/api/rank` → `/tmp/sl-ccclub-rank`
 3. `refresh` también puede ejecutarse manualmente o mediante hooks de fin de sesión para precalentar la caché.
 
 <details>

package/README.fr.md

@@ -54,10 +54,10 @@ cc-costline config --period both # Afficher les deux périodes
 ## Fonctionnement
 
 1. `install` configure `~/.claude/settings.json` — définit la commande statusline et ajoute des hooks de fin de session. Vos paramètres existants sont préservés.
-2. `render` est appelé par Claude Code à chaque tour de conversation. Il lit le JSON stdin pour les données de session, puis rafraîchit toutes les sources de données en ligne lorsque leur cache expire (TTL unifié de 2 minutes) :
-   - **Coût local** : parcourt `~/.claude/projects/**/*.jsonl`, applique la tarification par modèle → `~/.cc-costline/cache.json`
-   - **Limites d'utilisation** : récupère depuis `api.anthropic.com/api/oauth/usage` → `/tmp/sl-claude-usage`
-   - **Rang ccclub** : récupère depuis `ccclub.dev/api/rank` → `/tmp/sl-ccclub-rank`
+2. `render` est appelé par Claude Code à chaque tour de conversation. Il lit le JSON stdin pour les données de session, puis rafraîchit les sources de données avec des TTL séparés :
+   - **Coût local** (TTL 2 min) : parcourt `~/.claude/projects/**/*.jsonl`, applique la tarification par modèle → `~/.cc-costline/cache.json`
+   - **Limites d'utilisation** (retry 5 min, sensible au token) : récupère depuis `api.anthropic.com/api/oauth/usage` → `/tmp/sl-claude-usage`. Détecte la rotation du token OAuth pour relancer immédiatement (nouveau token = nouveau quota de débit). Les données périmées persistent en cas d'échec.
+   - **Rang ccclub** (retry 5 min) : récupère depuis `ccclub.dev/api/rank` → `/tmp/sl-ccclub-rank`
 3. `refresh` peut aussi être exécuté manuellement ou via les hooks de fin de session pour préchauffer le cache.
 
 <details>

package/README.ja.md

@@ -54,10 +54,10 @@ cc-costline config --period both # 両方の期間を表示
 ## 仕組み
 
 1. `install` は `~/.claude/settings.json` を設定 — ステータスラインコマンドとセッション終了フックを追加します。既存の設定は保持されます。
-2. `render` は毎回の対話時に Claude Code から呼び出され、stdin JSON からセッションデータを読み取り、すべてのデータソースをキャッシュ期限切れ時にインラインで更新します（統一 2 分 TTL）：
-   - **ローカルコスト**：`~/.claude/projects/**/*.jsonl` をスキャン、モデル別価格を適用 → `~/.cc-costline/cache.json`
-   - **使用率**：`api.anthropic.com/api/oauth/usage` から取得 → `/tmp/sl-claude-usage`
-   - **ccclub ランキング**：`ccclub.dev/api/rank` から取得 → `/tmp/sl-ccclub-rank`
+2. `render` は毎回の対話時に Claude Code から呼び出され、stdin JSON からセッションデータを読み取り、各データソースを個別の TTL でインライン更新します：
+   - **ローカルコスト**（2 分 TTL）：`~/.claude/projects/**/*.jsonl` をスキャン、モデル別価格を適用 → `~/.cc-costline/cache.json`
+   - **使用率**（5 分リトライ、トークンローテーション検知）：`api.anthropic.com/api/oauth/usage` から取得 → `/tmp/sl-claude-usage`。OAuth トークンのローテーションを検知し、即座にリトライ（新トークン＝新レート制限枠）。API 失敗時も過去のデータを保持。
+   - **ccclub ランキング**（5 分リトライ）：`ccclub.dev/api/rank` から取得 → `/tmp/sl-ccclub-rank`
 3. `refresh` は手動実行やセッション終了フックによるキャッシュウォームアップにも使用できます。
 
 <details>

package/README.md

@@ -54,10 +54,10 @@ cc-costline config --period both # Show both periods
 ## How it works
 
 1. `install` configures `~/.claude/settings.json` — sets the statusline command and adds session-end hooks. Your existing settings are preserved.
-2. `render` is called by Claude Code on every turn. It reads stdin JSON for session data, then refreshes all data sources inline when their cache expires (2-minute TTL):
-   - **Local cost**: scans `~/.claude/projects/**/*.jsonl`, applies per-model pricing → `~/.cc-costline/cache.json`
-   - **Usage limits**: fetches `api.anthropic.com/api/oauth/usage` → `/tmp/sl-claude-usage`
-   - **ccclub rank**: fetches `ccclub.dev/api/rank` → `/tmp/sl-ccclub-rank`
+2. `render` is called by Claude Code on every turn. It reads stdin JSON for session data, then refreshes data sources inline with separate TTLs:
+   - **Local cost** (2-min TTL): scans `~/.claude/projects/**/*.jsonl`, applies per-model pricing → `~/.cc-costline/cache.json`
+   - **Usage limits** (5-min retry, token-aware): fetches `api.anthropic.com/api/oauth/usage` → `/tmp/sl-claude-usage`. Detects OAuth token rotation to retry immediately with fresh rate limit quota. Stale data persists across failures.
+   - **ccclub rank** (5-min retry): fetches `ccclub.dev/api/rank` → `/tmp/sl-ccclub-rank`
 3. `refresh` can also be run manually or via session-end hooks to warm the cost cache.
 
 <details>

package/README.zh-CN.md

@@ -54,10 +54,10 @@ cc-costline config --period both # 同时显示两个周期
 ## 工作原理
 
 1. `install` 配置 `~/.claude/settings.json` — 设置状态栏命令并添加会话结束 hook。你的现有设置会被保留。
-2. `render` 在每次对话时被 Claude Code 调用，读取 stdin JSON 获取会话数据，然后按需刷新所有数据源（统一 2 分钟 TTL）：
-   - **本地费用**：扫描 `~/.claude/projects/**/*.jsonl`，按模型定价计算 → `~/.cc-costline/cache.json`
-   - **使用率**：从 `api.anthropic.com/api/oauth/usage` 获取 → `/tmp/sl-claude-usage`
-   - **ccclub 排名**：从 `ccclub.dev/api/rank` 获取 → `/tmp/sl-ccclub-rank`
+2. `render` 在每次对话时被 Claude Code 调用，读取 stdin JSON 获取会话数据，然后按独立 TTL 刷新各数据源：
+   - **本地费用**（2 分钟 TTL）：扫描 `~/.claude/projects/**/*.jsonl`，按模型定价计算 → `~/.cc-costline/cache.json`
+   - **使用率**（5 分钟重试，感知 token 轮换）：从 `api.anthropic.com/api/oauth/usage` 获取 → `/tmp/sl-claude-usage`。检测 OAuth token 轮换后立即重试（新 token 有新的速率配额）。API 失败时保留历史数据。
+   - **ccclub 排名**（5 分钟重试）：从 `ccclub.dev/api/rank` 获取 → `/tmp/sl-ccclub-rank`
 3. `refresh` 也可以手动运行或通过会话结束 hook 预热缓存。
 
 <details>

package/dist/cache.d.ts

@@ -1,8 +1,14 @@
 declare const CACHE_DIR: string;
+export interface FileCostEntry {
+    mtimeMs: number;
+    size: number;
+    byDay: Record<string, number>;
+}
 export interface CacheData {
     cost7d: number;
     cost30d: number;
     updatedAt: string;
+    files?: Record<string, FileCostEntry>;
 }
 export interface ConfigData {
     period: "7d" | "30d" | "both";

package/dist/cli.js

@@ -6,8 +6,9 @@ import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
 import { collectCosts } from "./collector.js";
-import { writeCache, writeConfig, readConfig, CACHE_DIR } from "./cache.js";
+import { readCache, writeCache, writeConfig, readConfig, CACHE_DIR } from "./cache.js";
 import { render } from "./statusline.js";
+import { refreshAll } from "./refresh.js";
 const SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
 const RENDER_COMMAND = "cc-costline render";
 const REFRESH_COMMAND = "cc-costline refresh";
@@ -115,11 +116,13 @@ function cmdConfig(args) {
     console.log(`✓ Period set to: ${period}`);
 }
 function cmdRefresh() {
-    const result = collectCosts();
+    const prev = readCache();
+    const result = collectCosts(undefined, prev?.files);
     writeCache({
         cost7d: result.cost7d,
         cost30d: result.cost30d,
         updatedAt: new Date().toISOString(),
+        files: result.files,
     });
     console.log(`✓ Cache updated — 7d: $${result.cost7d.toFixed(2)} | 30d: $${result.cost30d.toFixed(2)}`);
 }
@@ -131,6 +134,10 @@ function cmdRender() {
     if (output)
         process.stdout.write(output);
 }
+function cmdRefreshBg(args) {
+    const transcriptPath = args[0] || "";
+    refreshAll(transcriptPath);
+}
 // ─── Main ─────────────────────────────────────────────────
 const args = process.argv.slice(2);
 const command = args[0];
@@ -147,6 +154,9 @@ switch (command) {
     case "refresh":
         cmdRefresh();
         break;
+    case "refresh-bg":
+        cmdRefreshBg(args.slice(1));
+        break;
     case "render":
         cmdRender();
         break;

package/dist/collector.d.ts

@@ -1,6 +1,12 @@
+import type { FileCostEntry } from "./cache.js";
 interface CollectResult {
     cost7d: number;
     cost30d: number;
+    files: Record<string, FileCostEntry>;
 }
-export declare function collectCosts(baseDir?: string): CollectResult;
+/**
+ * Scan all jsonl files under projectsDir and compute cost7d/cost30d.
+ * Reuses prevFiles entries whose mtime+size haven't changed (incremental scan).
+ */
+export declare function collectCosts(baseDir?: string, prevFiles?: Record<string, FileCostEntry>): CollectResult;
 export {};

package/dist/collector.js

@@ -31,63 +31,106 @@ function findJsonlFiles(dir) {
     }
     return results;
 }
-export function collectCosts(baseDir) {
+function dayKey(ms) {
+    const d = new Date(ms);
+    return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}-${String(d.getUTCDate()).padStart(2, "0")}`;
+}
+function dayStartMs(key) {
+    return new Date(key + "T00:00:00Z").getTime();
+}
+/** Parse a single jsonl file and bucket per-entry cost by UTC day. */
+function parseFile(file, mtimeMs, size, cutoffMs) {
+    const byDay = {};
+    let content;
+    try {
+        content = readFileSync(file, "utf-8");
+    }
+    catch {
+        return { mtimeMs, size, byDay };
+    }
+    const seen = new Set();
+    const lines = content.split("\n");
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (parsed.type !== "assistant" || !parsed.message?.usage)
+            continue;
+        const ts = new Date(parsed.timestamp).getTime();
+        if (isNaN(ts) || ts < cutoffMs)
+            continue;
+        const usage = parsed.message.usage;
+        const requestId = parsed.requestId || "";
+        const sessionId = parsed.sessionId || "";
+        const dedupeKey = requestId
+            ? `${sessionId}:${requestId}`
+            : `${sessionId}:${parsed.timestamp}:${parsed.message.model}:${usage.input_tokens}:${usage.output_tokens}:${usage.cache_creation_input_tokens || 0}:${usage.cache_read_input_tokens || 0}`;
+        if (seen.has(dedupeKey))
+            continue;
+        seen.add(dedupeKey);
+        const cost = calculateCost(parsed.message.model || "unknown", usage.input_tokens || 0, usage.output_tokens || 0, usage.cache_creation_input_tokens || 0, usage.cache_read_input_tokens || 0);
+        const day = dayKey(ts);
+        byDay[day] = (byDay[day] || 0) + cost;
+    }
+    return { mtimeMs, size, byDay };
+}
+/**
+ * Scan all jsonl files under projectsDir and compute cost7d/cost30d.
+ * Reuses prevFiles entries whose mtime+size haven't changed (incremental scan).
+ */
+export function collectCosts(baseDir, prevFiles) {
     const projectsDir = baseDir || join(homedir(), CLAUDE_PROJECTS_DIR);
     const files = findJsonlFiles(projectsDir);
     if (files.length === 0) {
-        return { cost7d: 0, cost30d: 0 };
+        return { cost7d: 0, cost30d: 0, files: {} };
     }
     const now = Date.now();
     const cutoff7d = now - 7 * 24 * 60 * 60 * 1000;
     const cutoff30d = now - 30 * 24 * 60 * 60 * 1000;
+    const prev = prevFiles || {};
+    const out = {};
     let cost7d = 0;
     let cost30d = 0;
-    // Deduplication set (same as ccclub)
-    const seen = new Set();
     for (const file of files) {
-        let content;
+        let stat;
         try {
-            content = readFileSync(file, "utf-8");
+            stat = statSync(file);
         }
         catch {
             continue;
         }
-        const lines = content.split("\n");
-        for (const line of lines) {
-            if (!line.trim())
-                continue;
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue;
+        // Files not touched in the last 30d cannot contribute to either window
+        // (jsonl is append-only, so all entries inside are ≤ mtime).
+        if (stat.mtimeMs < cutoff30d)
+            continue;
+        let entry;
+        const cached = prev[file];
+        if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+            // Prune day buckets that have slid past the 30d window to keep cache from growing
+            const pruned = {};
+            for (const [day, cost] of Object.entries(cached.byDay)) {
+                if (dayStartMs(day) >= cutoff30d)
+                    pruned[day] = cost;
             }
-            if (parsed.type !== "assistant" || !parsed.message?.usage)
-                continue;
-            const ts = new Date(parsed.timestamp).getTime();
-            if (isNaN(ts) || ts < cutoff30d)
-                continue;
-            const usage = parsed.message.usage;
-            const requestId = parsed.requestId || "";
-            const sessionId = parsed.sessionId || "";
-            const dedupeKey = requestId
-                ? `${sessionId}:${requestId}`
-                : `${sessionId}:${parsed.timestamp}:${parsed.message.model}:${usage.input_tokens}:${usage.output_tokens}:${usage.cache_creation_input_tokens || 0}:${usage.cache_read_input_tokens || 0}`;
-            if (seen.has(dedupeKey))
-                continue;
-            seen.add(dedupeKey);
-            const model = parsed.message.model || "unknown";
-            const inputTokens = usage.input_tokens || 0;
-            const outputTokens = usage.output_tokens || 0;
-            const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
-            const cacheReadTokens = usage.cache_read_input_tokens || 0;
-            const cost = calculateCost(model, inputTokens, outputTokens, cacheCreationTokens, cacheReadTokens);
-            cost30d += cost;
-            if (ts >= cutoff7d) {
+            entry = { mtimeMs: cached.mtimeMs, size: cached.size, byDay: pruned };
+        }
+        else {
+            entry = parseFile(file, stat.mtimeMs, stat.size, cutoff30d);
+        }
+        out[file] = entry;
+        for (const [day, cost] of Object.entries(entry.byDay)) {
+            const ms = dayStartMs(day);
+            if (ms >= cutoff30d)
+                cost30d += cost;
+            if (ms >= cutoff7d)
                 cost7d += cost;
-            }
         }
     }
-    return { cost7d, cost30d };
+    return { cost7d, cost30d, files: out };
 }

package/dist/refresh.d.ts

@@ -0,0 +1 @@
+export declare function refreshAll(transcriptPath?: string): void;

package/dist/refresh.js

@@ -0,0 +1,226 @@
+import { readFileSync, writeFileSync, existsSync, unlinkSync, statSync, utimesSync, closeSync, openSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
+import { readCache, writeCache } from "./cache.js";
+import { collectCosts } from "./collector.js";
+import { shouldRefreshLocalCostCache } from "./statusline.js";
+// Anthropic usage API: strict per-token rate limits (~5 req/token). NEVER shrink.
+const ANTHROPIC_TTL_MS = 300_000;
+// ccclub rank: self-hosted, no strict limits — refresh more aggressively for visible data.
+const CCCLUB_TTL_MS = 90_000;
+const REFRESH_LOCK = "/tmp/sl-refresh.lock";
+const REFRESH_LAST = "/tmp/sl-refresh.last";
+const LOCK_STALE_MS = 60_000;
+function acquireLock() {
+    try {
+        if (existsSync(REFRESH_LOCK)) {
+            try {
+                const stat = statSync(REFRESH_LOCK);
+                if (Date.now() - stat.mtimeMs < LOCK_STALE_MS)
+                    return false;
+                unlinkSync(REFRESH_LOCK);
+            }
+            catch {
+                return false;
+            }
+        }
+        const fd = openSync(REFRESH_LOCK, "wx");
+        try {
+            writeFileSync(fd, String(process.pid));
+        }
+        finally {
+            closeSync(fd);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseLock() {
+    try {
+        unlinkSync(REFRESH_LOCK);
+    }
+    catch { }
+    try {
+        const now = new Date();
+        if (!existsSync(REFRESH_LAST)) {
+            writeFileSync(REFRESH_LAST, "");
+        }
+        utimesSync(REFRESH_LAST, now, now);
+    }
+    catch { }
+}
+function refreshLocalCost(transcriptPath) {
+    const cache = readCache();
+    if (!shouldRefreshLocalCostCache(cache, transcriptPath))
+        return;
+    try {
+        const result = collectCosts(undefined, cache?.files);
+        // Don't overwrite valid cache with zeros (directory read failure)
+        if (result.cost7d > 0 || result.cost30d > 0 || !cache) {
+            writeCache({
+                cost7d: result.cost7d,
+                cost30d: result.cost30d,
+                updatedAt: new Date().toISOString(),
+                files: result.files,
+            });
+        }
+    }
+    catch { }
+}
+function refreshClaudeUsage() {
+    const cacheFile = "/tmp/sl-claude-usage";
+    const hitFile = "/tmp/sl-claude-usage-hit";
+    const now = Date.now();
+    let staleData = null;
+    let lastAttempt = 0;
+    let cachedTokenPrefix = "";
+    if (existsSync(cacheFile)) {
+        try {
+            const cached = JSON.parse(readFileSync(cacheFile, "utf-8"));
+            staleData = cached.data ?? null;
+            lastAttempt = cached.lastAttempt || 0;
+            cachedTokenPrefix = cached.tokenPrefix || "";
+        }
+        catch { }
+    }
+    let accessToken = "";
+    try {
+        const username = process.env.USER || process.env.USERNAME;
+        const keychainCmd = `security find-generic-password -s "Claude Code-credentials" -a "${username}" -w 2>/dev/null`;
+        const credentialsJSON = execSync(keychainCmd, { encoding: "utf-8", timeout: 2000 }).trim();
+        if (!credentialsJSON)
+            return;
+        const credentials = JSON.parse(credentialsJSON);
+        accessToken = credentials.claudeAiOauth?.accessToken || "";
+        if (!accessToken)
+            return;
+        const expiresAt = credentials.claudeAiOauth?.expiresAt;
+        if (expiresAt && now > expiresAt)
+            return;
+    }
+    catch {
+        return;
+    }
+    const currentTokenPrefix = accessToken.slice(-20);
+    const tokenChanged = cachedTokenPrefix && currentTokenPrefix !== cachedTokenPrefix;
+    // Skip if cache is fresh and token hasn't rotated
+    if (!tokenChanged && lastAttempt && now - lastAttempt < ANTHROPIC_TTL_MS)
+        return;
+    // Mark attempt before HTTP — protects against repeated failures hammering the API
+    try {
+        writeFileSync(cacheFile, JSON.stringify({ data: staleData, lastAttempt: now, tokenPrefix: currentTokenPrefix }), "utf-8");
+    }
+    catch { }
+    try {
+        const apiUrl = "https://api.anthropic.com/api/oauth/usage";
+        const curlCmd = `curl -sf "${apiUrl}" -H "Authorization: Bearer ${accessToken}" -H "anthropic-beta: oauth-2025-04-20"`;
+        const response = execSync(curlCmd, { encoding: "utf-8", timeout: 5000 });
+        if (!response)
+            return;
+        const data = JSON.parse(response);
+        try {
+            writeFileSync("/tmp/sl-claude-usage-raw", JSON.stringify(data, null, 2), "utf-8");
+        }
+        catch { }
+        const parseUtil = (val) => {
+            if (typeof val === "number")
+                return Math.round(val);
+            if (typeof val === "string")
+                return Math.round(parseFloat(val.replace("%", "")));
+            return 0;
+        };
+        const fiveHour = parseUtil(data.five_hour?.utilization);
+        const sevenDay = parseUtil(data.seven_day?.utilization);
+        let fiveHourResetsAt;
+        const resetsAtRaw = data.five_hour?.resets_at ?? data.five_hour?.reset_at ?? data.five_hour?.next_reset;
+        if (resetsAtRaw) {
+            const ts = typeof resetsAtRaw === "string" ? new Date(resetsAtRaw).getTime() : resetsAtRaw * 1000;
+            if (!isNaN(ts) && ts > now)
+                fiveHourResetsAt = ts;
+        }
+        if (fiveHour >= 100) {
+            if (!fiveHourResetsAt) {
+                if (existsSync(hitFile)) {
+                    const hitTime = parseFloat(readFileSync(hitFile, "utf-8").trim());
+                    if (!isNaN(hitTime))
+                        fiveHourResetsAt = hitTime + 5 * 3600 * 1000;
+                }
+                else {
+                    writeFileSync(hitFile, String(now), "utf-8");
+                    fiveHourResetsAt = now + 5 * 3600 * 1000;
+                }
+            }
+        }
+        else {
+            try {
+                if (existsSync(hitFile))
+                    unlinkSync(hitFile);
+            }
+            catch { }
+        }
+        const result = { fiveHour, sevenDay };
+        if (fiveHourResetsAt)
+            result.fiveHourResetsAt = fiveHourResetsAt;
+        writeFileSync(cacheFile, JSON.stringify({ data: result, lastAttempt: now, tokenPrefix: currentTokenPrefix }), "utf-8");
+    }
+    catch { }
+}
+function refreshCcclubRank() {
+    const configPath = join(homedir(), ".ccclub", "config.json");
+    if (!existsSync(configPath))
+        return;
+    const cacheFile = "/tmp/sl-ccclub-rank";
+    const now = Date.now();
+    let staleData = null;
+    let lastAttempt = 0;
+    if (existsSync(cacheFile)) {
+        try {
+            const cached = JSON.parse(readFileSync(cacheFile, "utf-8"));
+            staleData = cached.data ?? null;
+            lastAttempt = cached.lastAttempt || cached.timestamp || 0;
+            if (now - lastAttempt < CCCLUB_TTL_MS)
+                return;
+        }
+        catch { }
+    }
+    // Mark attempt before HTTP
+    try {
+        writeFileSync(cacheFile, JSON.stringify({ data: staleData, timestamp: staleData ? (lastAttempt || now) : 0, lastAttempt: now }), "utf-8");
+    }
+    catch { }
+    try {
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        const code = config.groups?.[0];
+        const userId = config.userId;
+        if (!code || !userId)
+            return;
+        const tz = -(new Date()).getTimezoneOffset();
+        const url = `${config.apiUrl}/api/rank/${code}?period=today&tz=${tz}`;
+        const response = execSync(`curl -sf "${url}"`, { encoding: "utf-8", timeout: 5000 });
+        if (!response)
+            return;
+        const data = JSON.parse(response);
+        const rankings = data.rankings || [];
+        const me = rankings.find((r) => r.userId === userId);
+        if (!me)
+            return;
+        const result = { rank: me.rank, total: rankings.length, cost: me.costUSD };
+        writeFileSync(cacheFile, JSON.stringify({ data: result, timestamp: now, lastAttempt: now }), "utf-8");
+    }
+    catch { }
+}
+export function refreshAll(transcriptPath = "") {
+    if (!acquireLock())
+        return;
+    try {
+        refreshLocalCost(transcriptPath);
+        refreshClaudeUsage();
+        refreshCcclubRank();
+    }
+    finally {
+        releaseLock();
+    }
+}

package/dist/statusline.js

@@ -1,11 +1,13 @@
-import { readFileSync, existsSync, statSync, writeFileSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { execSync } from "node:child_process";
-import { readCache, writeCache, readConfig } from "./cache.js";
-import { collectCosts } from "./collector.js";
-// Unified TTL for all cached data (2 minutes)
+import { readFileSync, statSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { readCache, readConfig } from "./cache.js";
+// TTL for local cost cache (2 minutes) — used by refresh-bg to decide whether to rescan jsonl
 const CACHE_TTL_MS = 120_000;
+// Throttle: render only spawns a background refresh if the last one finished > 30s ago.
+// refresh-bg internally honors per-API TTLs (Anthropic 5min, ccclub 90s) so this is just
+// a coarse "don't fork node every turn" gate.
+const REFRESH_SPAWN_THROTTLE_MS = 30_000;
+const REFRESH_LAST_MARKER = "/tmp/sl-refresh.last";
 // ANSI colors (matching original statusline.sh)
 const FG_GRAY = "\x1b[38;5;245m";
 const FG_GRAY_DIM = "\x1b[38;5;102m";
@@ -65,51 +67,6 @@ export function shouldRefreshLocalCostCache(cache, transcriptPath = "", now = Da
     }
     return now - cacheUpdatedAt >= CACHE_TTL_MS;
 }
-// ccclub rank fetcher — TTL-based cache (stale fallback on failure)
-function getCcclubRank() {
-    const configPath = join(homedir(), ".ccclub", "config.json");
-    if (!existsSync(configPath))
-        return null;
-    const cacheFile = "/tmp/sl-ccclub-rank";
-    let staleData = null;
-    if (existsSync(cacheFile)) {
-        try {
-            const cached = JSON.parse(readFileSync(cacheFile, "utf-8"));
-            staleData = cached.data ?? null;
-            const cacheAge = Date.now() - (cached.timestamp || 0);
-            if (cacheAge < CACHE_TTL_MS)
-                return staleData;
-        }
-        catch { }
-    }
-    try {
-        const config = JSON.parse(readFileSync(configPath, "utf-8"));
-        const code = config.groups?.[0];
-        const userId = config.userId;
-        if (!code || !userId)
-            return staleData;
-        const tz = -(new Date()).getTimezoneOffset();
-        const url = `${config.apiUrl}/api/rank/${code}?period=today&tz=${tz}`;
-        const response = execSync(`curl -sf "${url}"`, { encoding: "utf-8", timeout: 5000 });
-        if (!response)
-            return staleData;
-        const data = JSON.parse(response);
-        const rankings = data.rankings || [];
-        const me = rankings.find((r) => r.userId === userId);
-        if (!me)
-            return staleData;
-        const result = { rank: me.rank, total: rankings.length, cost: me.costUSD };
-        writeFileSync(cacheFile, JSON.stringify({ data: result, timestamp: Date.now() }), "utf-8");
-        return result;
-    }
-    catch {
-        try {
-            writeFileSync(cacheFile, JSON.stringify({ data: staleData, timestamp: Date.now() }), "utf-8");
-        }
-        catch { }
-        return staleData;
-    }
-}
 export function rankColor(rank) {
     if (rank === 1)
         return FG_YELLOW;
@@ -119,98 +76,45 @@ export function rankColor(rank) {
         return FG_ORANGE;
     return FG_CYAN;
 }
-// Claude usage fetcher — TTL-based cache (stale fallback on failure)
-function getClaudeUsage() {
-    const cacheFile = "/tmp/sl-claude-usage";
-    const hitFile = "/tmp/sl-claude-usage-hit";
-    const now = Date.now();
-    let staleData = null;
-    if (existsSync(cacheFile)) {
-        try {
-            const cached = JSON.parse(readFileSync(cacheFile, "utf-8"));
-            staleData = cached.data ?? null;
-            const cacheAge = now - (cached.timestamp || 0);
-            if (cacheAge < CACHE_TTL_MS)
-                return staleData;
-        }
-        catch { }
+// Read-only: usage data from /tmp cache. Refresh is done by `cc-costline refresh-bg`.
+function readUsageCache() {
+    try {
+        const cached = JSON.parse(readFileSync("/tmp/sl-claude-usage", "utf-8"));
+        return cached.data ?? null;
     }
+    catch {
+        return null;
+    }
+}
+// Read-only: ccclub rank from /tmp cache.
+function readRankCache() {
     try {
-        const username = process.env.USER || process.env.USERNAME;
-        const keychainCmd = `security find-generic-password -s "Claude Code-credentials" -a "${username}" -w 2>/dev/null`;
-        const credentialsJSON = execSync(keychainCmd, { encoding: "utf-8", timeout: 2000 }).trim();
-        if (!credentialsJSON)
-            return null;
-        const credentials = JSON.parse(credentialsJSON);
-        const accessToken = credentials.claudeAiOauth?.accessToken;
-        if (!accessToken)
-            return null;
-        const expiresAt = credentials.claudeAiOauth?.expiresAt;
-        if (expiresAt && Date.now() / 1000 > expiresAt)
-            return null;
-        const apiUrl = "https://api.anthropic.com/api/oauth/usage";
-        const curlCmd = `curl -sf "${apiUrl}" -H "Authorization: Bearer ${accessToken}" -H "anthropic-beta: oauth-2025-04-20"`;
-        const response = execSync(curlCmd, { encoding: "utf-8", timeout: 5000 });
-        if (!response) {
-            // API failed — write cache with null data to prevent retry flood
-            writeFileSync(cacheFile, JSON.stringify({ data: null, timestamp: now }), "utf-8");
-            return staleData;
-        }
-        const data = JSON.parse(response);
-        const parseUtil = (val) => {
-            if (typeof val === "number")
-                return Math.round(val);
-            if (typeof val === "string")
-                return Math.round(parseFloat(val.replace("%", "")));
-            return 0;
-        };
-        const fiveHour = parseUtil(data.five_hour?.utilization);
-        const sevenDay = parseUtil(data.seven_day?.utilization);
-        let fiveHourResetsAt;
-        // Strategy 1: Use reset time from API if available
-        const resetsAtRaw = data.five_hour?.resets_at ?? data.five_hour?.reset_at ?? data.five_hour?.next_reset;
-        if (resetsAtRaw) {
-            const ts = typeof resetsAtRaw === "string" ? new Date(resetsAtRaw).getTime() : resetsAtRaw * 1000;
-            if (!isNaN(ts) && ts > now)
-                fiveHourResetsAt = ts;
-        }
-        // Strategy 2: Fallback - track when we first saw 100%
-        if (fiveHour >= 100) {
-            if (!fiveHourResetsAt) {
-                if (existsSync(hitFile)) {
-                    const hitTime = parseFloat(readFileSync(hitFile, "utf-8").trim());
-                    if (!isNaN(hitTime)) {
-                        fiveHourResetsAt = hitTime + 5 * 3600 * 1000;
-                    }
-                }
-                else {
-                    writeFileSync(hitFile, String(now), "utf-8");
-                    fiveHourResetsAt = now + 5 * 3600 * 1000;
-                }
-            }
-        }
-        else {
-            // Usage dropped below 100%, clear hit tracker
-            try {
-                if (existsSync(hitFile))
-                    unlinkSync(hitFile);
-            }
-            catch { }
-        }
-        const result = { fiveHour, sevenDay };
-        if (fiveHourResetsAt)
-            result.fiveHourResetsAt = fiveHourResetsAt;
-        writeFileSync(cacheFile, JSON.stringify({ data: result, timestamp: now }), "utf-8");
-        return result;
+        const cached = JSON.parse(readFileSync("/tmp/sl-ccclub-rank", "utf-8"));
+        return cached.data ?? null;
     }
     catch {
-        // Write cache with stale/null data to prevent retry flood on persistent failures
-        try {
-            writeFileSync(cacheFile, JSON.stringify({ data: staleData, timestamp: now }), "utf-8");
-        }
-        catch { }
-        return staleData;
+        return null;
+    }
+}
+// Spawn detached `cc-costline refresh-bg` subprocess. Render does NOT wait for it.
+// The subprocess uses a lockfile to prevent concurrent refresh across multiple Claude Code windows.
+function maybeSpawnRefresh(transcriptPath) {
+    if (process.env.CC_COSTLINE_NO_SPAWN)
+        return;
+    const entry = process.argv[1] || "";
+    if (!/cc-costline|cli\.js$/.test(entry))
+        return;
+    try {
+        const stat = statSync(REFRESH_LAST_MARKER);
+        if (Date.now() - stat.mtimeMs < REFRESH_SPAWN_THROTTLE_MS)
+            return;
+    }
+    catch { }
+    try {
+        const child = spawn(process.execPath, [entry, "refresh-bg", transcriptPath], { detached: true, stdio: "ignore" });
+        child.unref();
     }
+    catch { }
 }
 export function render(input) {
     let data;
@@ -222,10 +126,10 @@ export function render(input) {
     }
     // Session data from Claude Code stdin
     const cost = data.cost?.total_cost_usd ?? 0;
-    const model = data.model?.display_name ?? "—";
+    const model = (data.model?.display_name ?? "—").replace(/\s*\((\d+[KMB])\s+context\)/i, " ($1)");
     const contextPct = Math.floor(data.context_window?.used_percentage ?? 0);
     const transcriptPath = data.transcript_path ?? "";
-    // Token stats from transcript
+    // Token stats from transcript (synchronous — small per-session file, typically < 1ms)
     let totalTokens = 0;
     if (transcriptPath) {
         try {
@@ -245,22 +149,13 @@ export function render(input) {
         }
         catch { }
     }
-    // Refresh local cost cache if stale
-    let cache = readCache();
-    if (shouldRefreshLocalCostCache(cache, transcriptPath)) {
-        try {
-            const result = collectCosts();
-            // Don't overwrite valid cache with zeros (directory read failure)
-            if (result.cost7d > 0 || result.cost30d > 0 || !cache) {
-                const newCache = { cost7d: result.cost7d, cost30d: result.cost30d, updatedAt: new Date().toISOString() };
-                writeCache(newCache);
-                cache = newCache;
-            }
-        }
-        catch { }
-    }
+    // All external data is read-only here. refresh-bg writes these caches in the background.
+    const cache = readCache();
     const config = readConfig();
-    const claudeUsage = getClaudeUsage();
+    const claudeUsage = readUsageCache();
+    const ccclubRank = readRankCache();
+    // Fire-and-forget background refresh (throttled to once per 30s)
+    maybeSpawnRefresh(transcriptPath);
     const g = FG_GRAY_DIM;
     const y = FG_YELLOW;
     const m = FG_MODEL;
@@ -299,7 +194,6 @@ export function render(input) {
         segments.push(usageParts.join(` ${g}·${r} `));
     }
     // #2 $53.6
-    const ccclubRank = getCcclubRank();
     if (ccclubRank) {
         const rc = rankColor(ccclubRank.rank);
         segments.push(`${rc}#${ccclubRank.rank} ${formatCost(ccclubRank.cost)}${r}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-costline",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Enhanced statusline for Claude Code with cost tracking, usage limits, and leaderboard",
   "type": "module",
   "bin": {