claude-code-cache-fix 1.7.1 → 1.8.0

package/README.md

@@ -105,6 +105,103 @@ The module intercepts `globalThis.fetch` before Claude Code makes API calls to `
 
 All fixes are idempotent — if nothing needs fixing, the request passes through unmodified. The interceptor is read-only with respect to your conversation; it only normalizes the request structure before it hits the API.
 
+## Graduating from Fixes
+
+The interceptor serves three purposes with different lifecycles:
+
+| Purpose | Examples | When to disable |
+|---------|----------|-----------------|
+| **Bug fixes** | Block relocation, fingerprint, tool sort, TTL | When CC fixes the underlying bug — check the health line |
+| **Monitoring** | Quota tracking, microcompact detection, GrowthBook flags | Keep permanently — these detect future regressions |
+| **Optimizations** | Image stripping, output efficiency rewrite | Keep as long as they help your workflow |
+
+### Health status
+
+On first API call, the interceptor logs a health status line (requires `CACHE_FIX_DEBUG=1`):
+
+```
+cache-fix health: relocate=active(2h ago) fingerprint=dormant(5 clean sessions) tool_sort=active ttl=active identity=waiting
+```
+
+Status meanings:
+- **active(Xh ago)** — fix was applied recently
+- **dormant(N clean sessions)** — bug not detected in N resume sessions; CC may have fixed it
+- **safety-blocked(Nx)** — round-trip verification failed; CC changed its algorithm, fix auto-disabled
+- **waiting** — fix hasn't been triggered yet
+
+When a fix shows `dormant`, you can safely disable it:
+```bash
+export CACHE_FIX_SKIP_RELOCATE=1  # example
+```
+
+To disable all fixes but keep monitoring:
+```bash
+export CACHE_FIX_DISABLED=1
+```
+
+### Regression detection
+
+If cache_read ratio drops below 50% across 5+ calls after disabling fixes, you'll see:
+```
+REGRESSION WARNING: cache_read ratio averaged 12% across last 5 calls.
+Fixes are disabled — consider re-enabling to recover cache performance.
+```
+
+## Safety
+
+### Fingerprint round-trip verification
+
+Before rewriting the `cc_version` fingerprint, the interceptor verifies that its
+hardcoded salt and character indices reproduce the fingerprint Claude Code sent.
+If verification fails (CC changed its algorithm), the rewrite is skipped automatically.
+This ensures the interceptor can never make cache performance *worse* than stock CC.
+
+### Fail-safe design
+
+Every fix is designed to fail to a no-op:
+- If block detection regexes don't match → blocks aren't relocated (CC behavior)
+- If fingerprint format changes → fingerprint isn't rewritten (CC behavior)
+- If tool sort produces no changes → payload passes through untouched
+- If TTL injection target structure changes → TTL isn't injected (CC behavior)
+
+The interceptor can only *help* or *do nothing*. It cannot make things worse.
+
+## Status line — quota warnings in real time
+
+The interceptor writes quota state to `~/.claude/quota-status.json` on every API call. The included `tools/quota-statusline.sh` script reads this file and displays a live status line in Claude Code showing:
+
+- **Q5h %** with burn rate (%/min)
+- **Q7d %** with burn rate (%/hr)
+- **TTL tier** — shows `TTL:1h` when healthy, **`TTL:5m` in red when the server has downgraded you** (typically at Q5h ≥ 100%)
+- **PEAK** in yellow during weekday peak hours (13:00–19:00 UTC)
+- **Cache hit rate %**
+- **OVERAGE** flag when active
+
+### Setup
+
+Copy the script and configure Claude Code to use it:
+
+```bash
+# Copy from the npm package to Claude Code's hooks directory
+mkdir -p ~/.claude/hooks
+cp "$(npm root -g)/claude-code-cache-fix/tools/quota-statusline.sh" ~/.claude/hooks/
+chmod +x ~/.claude/hooks/quota-statusline.sh
+```
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "statusLine": {
+    "command": "~/.claude/hooks/quota-statusline.sh"
+  }
+}
+```
+
+### Why this matters
+
+When the server downgrades your TTL to 5m (Layer 2 — quota-aware downgrade at Q5h ≥ 100%), **every idle longer than 5 minutes causes a full context rebuild**. Without the status line, this is invisible — you just notice things getting slower and more expensive. With the status line, the red `TTL:5m` warning tells you immediately: **stop working, wait for the Q5h window to reset, then resume**. Powering through overage compounds the drain; pausing breaks the cycle.
+
 ## Image stripping
 
 Images read via the Read tool are encoded as base64 and stored in `tool_result` blocks in conversation history. They ride along on **every subsequent API call** until compaction. A single 500KB image costs ~62,500 tokens per turn in carry-forward.
@@ -305,6 +402,12 @@ Snapshots are saved to `~/.claude/cache-fix-snapshots/` and diff reports are gen
 | `CACHE_FIX_IMAGE_KEEP_LAST` | `0` | Keep images in last N user messages (0 = disabled) |
 | `CACHE_FIX_OUTPUT_EFFICIENCY_REPLACEMENT` | unset | Replace Claude Code's `# Output efficiency` system-prompt section before the request is sent |
 | `CACHE_FIX_USAGE_LOG` | `~/.claude/usage.jsonl` | Path for per-call usage telemetry log |
+| `CACHE_FIX_DISABLED` | `0` | Disable all bug fixes; keep monitoring + optimizations active |
+| `CACHE_FIX_SKIP_RELOCATE` | `0` | Skip block relocation fix (Bug 1) |
+| `CACHE_FIX_SKIP_FINGERPRINT` | `0` | Skip fingerprint stabilization (Bug 2b) |
+| `CACHE_FIX_SKIP_TOOL_SORT` | `0` | Skip tool ordering stabilization (Bug 2a) |
+| `CACHE_FIX_SKIP_TTL` | `0` | Skip 1h TTL injection (Bug 5) |
+| `CACHE_FIX_SKIP_IDENTITY` | `0` | Skip identity normalization (Bug 6) |
 
 ## Limitations
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-cache-fix",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Fixes prompt cache regression in Claude Code that causes up to 20x cost increase on resumed sessions",
   "type": "module",
   "exports": "./preload.mjs",

package/preload.mjs

@@ -83,6 +83,25 @@ function extractRealUserMessageText(messages) {
   return "";
 }
 
+/**
+ * Extract text from messages[0] the way CC's original fingerprint code does —
+ * including meta/attachment blocks. Used only for round-trip verification.
+ */
+function extractFirstMessageText(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return "";
+  const first = messages[0];
+  if (!first || first.role !== "user") return "";
+  const content = first.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  for (const block of content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      return block.text;
+    }
+  }
+  return "";
+}
+
 /**
  * Extract current cc_version from system prompt blocks and recompute with
  * stable fingerprint. Returns { oldVersion, newVersion, stableFingerprint }.
@@ -107,6 +126,23 @@ function stabilizeFingerprint(system, messages) {
   const baseVersion = dotParts.slice(0, 3).join("."); // "2.1.87"
   const oldFingerprint = dotParts[3]; // "a3f"
 
+  // --- SAFETY: Round-trip verification ---
+  // Verify our salt/indices reproduce CC's fingerprint for the ORIGINAL
+  // message text (messages[0] content, which is what CC used).
+  // If our computation doesn't match, our constants are stale — skip rewrite.
+  const originalText = extractFirstMessageText(messages);
+  const verification = computeFingerprint(originalText, baseVersion);
+  if (verification !== oldFingerprint) {
+    debugLog(
+      "FINGERPRINT SAFETY: round-trip verification failed.",
+      `CC sent '${oldFingerprint}', we computed '${verification}'.`,
+      "Salt/indices may have changed in this CC version. Skipping rewrite."
+    );
+    recordFixResult("fingerprint", "safety_blocked");
+    return null;
+  }
+  // --- END SAFETY ---
+
   // Compute stable fingerprint from real user text
   const realText = extractRealUserMessageText(messages);
   const stableFingerprint = computeFingerprint(realText, baseVersion);
@@ -588,7 +624,7 @@ function replaceOutputEfficiencySection(text) {
 // Set CACHE_FIX_DEBUG=1 to enable
 // --------------------------------------------------------------------------
 
-import { appendFileSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { appendFileSync, readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -605,6 +641,103 @@ function debugLog(...args) {
   try { appendFileSync(LOG_PATH, line); } catch {}
 }
 
+// --------------------------------------------------------------------------
+// Kill switches — disable fixes while keeping monitoring active
+// --------------------------------------------------------------------------
+
+const FIXES_DISABLED = process.env.CACHE_FIX_DISABLED === "1";
+
+/**
+ * Check if a specific fix should be applied.
+ * Returns false if master kill switch is on OR individual fix is skipped.
+ * Monitoring and optimizations (image strip, output efficiency) are NOT
+ * affected by CACHE_FIX_DISABLED — only bug fixes are.
+ */
+function shouldApplyFix(fixName) {
+  if (FIXES_DISABLED) return false;
+  const skipKey = `CACHE_FIX_SKIP_${fixName.toUpperCase()}`;
+  if (process.env[skipKey] === "1") return false;
+  return true;
+}
+
+// --------------------------------------------------------------------------
+// Persistent effectiveness stats
+// --------------------------------------------------------------------------
+
+const STATS_PATH = join(homedir(), ".claude", "cache-fix-stats.json");
+
+const _STATS_SCHEMA = {
+  relocate: { applied: 0, skipped: 0, bugPresent: 0, resumeScanned: 0, lastApplied: null, lastScanned: null },
+  fingerprint: { applied: 0, skipped: 0, safetyBlocked: 0, lastApplied: null },
+  tool_sort: { applied: 0, skipped: 0, lastApplied: null },
+  ttl: { applied: 0, skipped: 0, lastApplied: null },
+  identity: { applied: 0, skipped: 0, lastApplied: null },
+};
+
+function _createEmptyStats() {
+  return {
+    version: 1,
+    created: new Date().toISOString(),
+    lastUpdated: null,
+    fixes: JSON.parse(JSON.stringify(_STATS_SCHEMA)),
+  };
+}
+
+/** Read stats from disk. Returns empty stats on any error. */
+function readStats() {
+  try {
+    const data = JSON.parse(readFileSync(STATS_PATH, "utf8"));
+    if (data.created) {
+      const ageDays = (Date.now() - new Date(data.created).getTime()) / (1000 * 60 * 60 * 24);
+      if (ageDays > 30) return _createEmptyStats();
+    }
+    for (const [key, schema] of Object.entries(_STATS_SCHEMA)) {
+      if (!data.fixes[key]) data.fixes[key] = { ...schema };
+    }
+    return data;
+  } catch {
+    return _createEmptyStats();
+  }
+}
+
+/** Atomic write: temp file + rename to avoid corruption. */
+function writeStats(stats) {
+  try {
+    stats.lastUpdated = new Date().toISOString();
+    const tmp = STATS_PATH + ".tmp";
+    writeFileSync(tmp, JSON.stringify(stats, null, 2));
+    renameSync(tmp, STATS_PATH);
+  } catch (e) {
+    debugLog("STATS WRITE ERROR:", e?.message);
+  }
+}
+
+function recordFixResult(fixName, result) {
+  const stats = readStats();
+  if (!stats.fixes[fixName]) return;
+  const now = new Date().toISOString();
+  stats.lastUpdated = now;
+  if (result === "applied") {
+    stats.fixes[fixName].applied++;
+    stats.fixes[fixName].lastApplied = now;
+  } else if (result === "skipped") {
+    stats.fixes[fixName].skipped++;
+  } else if (result === "safety_blocked") {
+    stats.fixes[fixName].safetyBlocked = (stats.fixes[fixName].safetyBlocked || 0) + 1;
+  }
+  writeStats(stats);
+}
+
+function recordRelocateScan(bugFound) {
+  const stats = readStats();
+  const now = new Date().toISOString();
+  stats.lastUpdated = now;
+  stats.fixes.relocate.resumeScanned++;
+  stats.fixes.relocate.lastScanned = now;
+  if (bugFound) stats.fixes.relocate.bugPresent++;
+  writeStats(stats);
+}
+
 // --------------------------------------------------------------------------
 // Prefix snapshot — captures message prefix for cross-process diff.
 // Set CACHE_FIX_PREFIXDIFF=1 to enable.
@@ -656,6 +789,59 @@ function dumpGrowthBookFlags() {
   }
 }
 
+// --------------------------------------------------------------------------
+// Startup health status line
+// --------------------------------------------------------------------------
+
+let _healthLinePrinted = false;
+
+function _formatTimeSince(isoString) {
+  if (!isoString) return "never";
+  const ms = Date.now() - new Date(isoString).getTime();
+  const hours = Math.floor(ms / (1000 * 60 * 60));
+  const days = Math.floor(hours / 24);
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  const mins = Math.floor(ms / (1000 * 60));
+  return `${mins}m ago`;
+}
+
+function _formatFixStatus(fixName, fixStats, dormantThreshold = 5) {
+  if (fixName === "relocate") {
+    if (fixStats.resumeScanned >= dormantThreshold && fixStats.bugPresent === 0) {
+      return `dormant(${fixStats.resumeScanned} clean sessions)`;
+    }
+  } else {
+    if (fixStats.skipped >= dormantThreshold && fixStats.applied === 0) {
+      return `dormant(${fixStats.skipped} skips)`;
+    }
+  }
+  if (fixStats.safetyBlocked > 0) return `safety-blocked(${fixStats.safetyBlocked}x)`;
+  if (fixStats.lastApplied) return `active(${_formatTimeSince(fixStats.lastApplied)})`;
+  return "waiting";
+}
+
+function printHealthLine() {
+  if (_healthLinePrinted) return;
+  _healthLinePrinted = true;
+  const stats = readStats();
+  const parts = [];
+  for (const [name, fixStats] of Object.entries(stats.fixes)) {
+    const status = _formatFixStatus(name, fixStats);
+    parts.push(`${name}=${status}`);
+    if (status.startsWith("dormant")) {
+      debugLog(`DORMANT: ${name} — CC may have fixed this. Consider CACHE_FIX_SKIP_${name.toUpperCase()}=1`);
+    }
+    if (status.startsWith("safety-blocked")) {
+      debugLog(`SAFETY: ${name} — salt/indices may have changed. Fix is auto-disabled.`);
+    }
+  }
+  debugLog(`HEALTH: ${parts.join(" ")}`);
+  if (FIXES_DISABLED) {
+    debugLog("HEALTH: all fixes disabled via CACHE_FIX_DISABLED=1 (monitoring active)");
+  }
+}
+
 // --------------------------------------------------------------------------
 // Microcompact / budget monitoring
 // --------------------------------------------------------------------------
@@ -801,6 +987,50 @@ function snapshotPrefix(payload) {
   }
 }
 
+// --------------------------------------------------------------------------
+// Cache regression detector
+// --------------------------------------------------------------------------
+
+const _cacheHistory = []; // in-memory ring buffer of { ratio, turn }
+const REGRESSION_MIN_CALLS = 5;
+const REGRESSION_MIN_RATIO = 0.5;
+let _apiCallCount = 0;
+
+function _computeCacheRatio(usage) {
+  if (!usage) return null;
+  const read = usage.cache_read_input_tokens || 0;
+  const creation = usage.cache_creation_input_tokens || 0;
+  const input = usage.input_tokens || 0;
+  const total = read + creation + input;
+  if (total === 0) return null;
+  return read / total;
+}
+
+function _checkCacheRegression() {
+  if (_cacheHistory.length < REGRESSION_MIN_CALLS) return;
+  const recent = _cacheHistory.slice(-REGRESSION_MIN_CALLS);
+  const allLow = recent.every((h) => h.ratio < REGRESSION_MIN_RATIO);
+  if (allLow) {
+    const avgRatio = recent.reduce((sum, h) => sum + h.ratio, 0) / recent.length;
+    debugLog(
+      `REGRESSION WARNING: cache_read ratio averaged ${Math.round(avgRatio * 100)}%`,
+      `across last ${REGRESSION_MIN_CALLS} calls (threshold: ${REGRESSION_MIN_RATIO * 100}%).`,
+      FIXES_DISABLED
+        ? "Fixes are disabled — consider re-enabling to recover cache performance."
+        : "Fixes are active but cache is still degraded — CC may have introduced a new bug."
+    );
+  }
+}
+
+function _trackCacheRatio(usage) {
+  if (_apiCallCount <= 1) return; // skip first call (cache creation, no reads)
+  const ratio = _computeCacheRatio(usage);
+  if (ratio === null) return;
+  _cacheHistory.push({ ratio, turn: _apiCallCount });
+  if (_cacheHistory.length > 20) _cacheHistory.shift(); // ring buffer
+  _checkCacheRegression();
+}
+
 // --------------------------------------------------------------------------
 // Fetch interceptor
 // --------------------------------------------------------------------------
@@ -817,11 +1047,17 @@ globalThis.fetch = async function (url, options) {
 
   if (isMessagesEndpoint && options?.body && typeof options.body === "string") {
     try {
+      _apiCallCount++;
       const payload = JSON.parse(options.body);
       let modified = false;
 
       // One-time GrowthBook flag dump on first API call
       dumpGrowthBookFlags();
+      printHealthLine();
+
+      if (FIXES_DISABLED) {
+        debugLog("CACHE_FIX_DISABLED=1 — all bug fixes bypassed, monitoring active");
+      }
 
       debugLog("--- API call to", urlStr);
       debugLog("message count:", payload.messages?.length);
@@ -832,7 +1068,7 @@ globalThis.fetch = async function (url, options) {
       }
 
       // Bug 1: Relocate resume attachment blocks
-      if (payload.messages) {
+      if (payload.messages && shouldApplyFix("relocate")) {
         // Log message structure for debugging
         if (DEBUG) {
           let firstUserIdx = -1, lastUserIdx = -1;
@@ -868,13 +1104,21 @@ globalThis.fetch = async function (url, options) {
         }
 
         const normalized = normalizeResumeMessages(payload.messages);
+        // Track bug presence for dormancy detection (resume = messages > 5)
+        const isResume = payload.messages.length > 5;
+        if (isResume) recordRelocateScan(normalized !== payload.messages);
+
         if (normalized !== payload.messages) {
           payload.messages = normalized;
           modified = true;
           debugLog("APPLIED: resume message relocation");
+          recordFixResult("relocate", "applied");
         } else {
           debugLog("SKIPPED: resume relocation (not a resume or already correct)");
+          recordFixResult("relocate", "skipped");
         }
+      } else if (payload.messages && !shouldApplyFix("relocate")) {
+        debugLog("SKIPPED: relocate fix disabled via env var");
       }
 
       // Image stripping: remove old tool_result images to reduce token waste
@@ -895,7 +1139,7 @@ globalThis.fetch = async function (url, options) {
       }
 
       // Bug 2a: Stabilize tool ordering
-      if (payload.tools) {
+      if (payload.tools && shouldApplyFix("tool_sort")) {
         const sorted = stabilizeToolOrder(payload.tools);
         const changed = sorted.some(
           (t, i) => t.name !== payload.tools[i]?.name
@@ -904,11 +1148,16 @@ globalThis.fetch = async function (url, options) {
           payload.tools = sorted;
           modified = true;
           debugLog("APPLIED: tool order stabilization");
+          recordFixResult("tool_sort", "applied");
+        } else {
+          recordFixResult("tool_sort", "skipped");
         }
+      } else if (payload.tools && !shouldApplyFix("tool_sort")) {
+        debugLog("SKIPPED: tool sort fix disabled via env var");
       }
 
       // Bug 2b: Stabilize fingerprint in attribution header
-      if (payload.system && payload.messages) {
+      if (payload.system && payload.messages && shouldApplyFix("fingerprint")) {
         const fix = stabilizeFingerprint(payload.system, payload.messages);
         if (fix) {
           payload.system = [...payload.system];
@@ -918,7 +1167,12 @@ globalThis.fetch = async function (url, options) {
           };
           modified = true;
           debugLog("APPLIED: fingerprint stabilized from", fix.oldFingerprint, "to", fix.stableFingerprint);
+          recordFixResult("fingerprint", "applied");
+        } else {
+          recordFixResult("fingerprint", "skipped");
         }
+      } else if (payload.system && payload.messages && !shouldApplyFix("fingerprint")) {
+        debugLog("SKIPPED: fingerprint fix disabled via env var");
       }
 
       // Bug 6: Identity string normalization for Agent()/SendMessage() cache parity
@@ -931,7 +1185,7 @@ globalThis.fetch = async function (url, options) {
       // turn even though system[2] (the actual instructions) is byte-identical.
       // Confirmed by @labzink via mitmproxy on #44724.
       // Opt-in because it's a model-perceivable behavior change (subagent thinks it's CC).
-      if (NORMALIZE_IDENTITY && payload.system && Array.isArray(payload.system)) {
+      if (NORMALIZE_IDENTITY && shouldApplyFix("identity") && payload.system && Array.isArray(payload.system)) {
         const CANONICAL = "You are Claude Code, Anthropic's official CLI for Claude.";
         const AGENT_SDK = "You are a Claude agent, built on Anthropic's Claude Agent SDK.";
         let normalized = 0;
@@ -949,6 +1203,9 @@ globalThis.fetch = async function (url, options) {
         if (normalized > 0) {
           modified = true;
           debugLog(`APPLIED: identity normalized on ${normalized} system block(s) (Agent SDK → Claude Code)`);
+          recordFixResult("identity", "applied");
+        } else {
+          recordFixResult("identity", "skipped");
         }
       }
 
@@ -971,7 +1228,7 @@ globalThis.fetch = async function (url, options) {
       // send cache_control without ttl (defaulting to 5m server-side).
       // The server honors whatever TTL the client requests — so we inject it.
       // Discovered by @TigerKay1926 on #42052 using our GrowthBook flag dump.
-      if (payload.system) {
+      if (payload.system && shouldApplyFix("ttl")) {
         let ttlInjected = 0;
         payload.system = payload.system.map((block) => {
           if (block.cache_control?.type === "ephemeral" && !block.cache_control.ttl) {
@@ -996,7 +1253,12 @@ globalThis.fetch = async function (url, options) {
         if (ttlInjected > 0) {
           modified = true;
           debugLog(`APPLIED: 1h TTL injected on ${ttlInjected} cache_control block(s)`);
+          recordFixResult("ttl", "applied");
+        } else {
+          recordFixResult("ttl", "skipped");
         }
+      } else if (payload.system && !shouldApplyFix("ttl")) {
+        debugLog("SKIPPED: TTL injection disabled via env var");
       }
 
       if (modified) {
@@ -1199,6 +1461,7 @@ async function drainTTLFromClone(clone, model, quotaHeaders) {
           if (event.type === "message_start" && event.message?.usage) {
             const u = event.message.usage;
             startUsage = u;
+            _trackCacheRatio(u);
             const cc = u.cache_creation || {};
             const e1h = cc.ephemeral_1h_input_tokens ?? 0;
             const e5m = cc.ephemeral_5m_input_tokens ?? 0;

package/tools/quota-statusline.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# Status line: show quota % and burn rate from claude-meter JSONL
+# Rate is calculated from window start (reset_time - window_size) to now
+# No prev file needed — each reading is self-contained
+
+input=$(cat)
+
+JSONL="$HOME/.claude/claude-meter.jsonl"
+
+if [ -f "$JSONL" ]; then
+  last=$(tail -1 "$JSONL" 2>/dev/null)
+
+  result=$(echo "$last" | python3 -c "
+import sys, json
+from datetime import datetime, timezone
+
+r = json.load(sys.stdin)
+q5h = int(r['q5h'] * 100)
+q7d = int(r.get('q7d', 0) * 100)
+overage = r.get('qoverage', '')
+ts = r.get('ts', '')
+q5h_reset = r.get('q5h_reset', 0)
+q7d_reset = r.get('q7d_reset', 0)
+
+now = datetime.fromisoformat(ts.replace('Z', '+00:00'))
+
+# Q5h: 5-hour window, rate = pct / minutes elapsed since window start
+rate5 = ''
+if q5h_reset > 0:
+    window_start = datetime.fromtimestamp(q5h_reset, tz=timezone.utc) - __import__('datetime').timedelta(hours=5)
+    elapsed_min = (now - window_start).total_seconds() / 60
+    if elapsed_min > 1 and q5h > 0:
+        rate5 = '{:+.1f}'.format(q5h / elapsed_min)
+
+# Q7d: 7-day window
+rate7 = ''
+if q7d_reset > 0:
+    window_start_7d = datetime.fromtimestamp(q7d_reset, tz=timezone.utc) - __import__('datetime').timedelta(days=7)
+    elapsed_min_7d = (now - window_start_7d).total_seconds() / 60
+    if elapsed_min_7d > 1 and q7d > 0:
+        rate7 = '{:+.1f}'.format(q7d / (elapsed_min_7d / 60))
+
+label = 'Q5h: {}%'.format(q5h)
+if rate5:
+    label += ' ({}%/m)'.format(rate5)
+label += ' | Q7d: {}%'.format(q7d)
+if rate7:
+    label += ' ({}%/hr)'.format(rate7)
+if overage == 'active':
+    label += ' | OVERAGE'
+
+# Add TTL tier from quota-status.json (written by interceptor)
+import os, pathlib
+qs_path = pathlib.Path.home() / '.claude' / 'quota-status.json'
+try:
+    qs = json.load(open(qs_path))
+    ttl = qs.get('cache', {}).get('ttl_tier', '')
+    hit = qs.get('cache', {}).get('hit_rate', '')
+    if ttl:
+        if ttl == '5m':
+            label += ' | \033[31mTTL:5m\033[0m'  # red
+            # When on 5m tier, show the cold-rebuild size so users know
+            # the cost of idling past 5 minutes
+            cache_cr = qs.get('cache', {}).get('cache_creation', 0)
+            cache_rd = qs.get('cache', {}).get('cache_read', 0)
+            prefix = cache_cr + cache_rd
+            if prefix > 0:
+                if prefix >= 1_000_000:
+                    label += ' \033[31m\u26A0 idle >5m = {:.1f}M rebuild\033[0m'.format(prefix / 1_000_000)
+                else:
+                    label += ' \033[31m\u26A0 idle >5m = {:.0f}K rebuild\033[0m'.format(prefix / 1_000)
+        else:
+            label += ' | TTL:' + ttl
+    if hit and hit != 'N/A':
+        label += ' ' + hit + '%'
+    peak = qs.get('peak_hour', False)
+    if peak:
+        label += ' | \033[33mPEAK\033[0m'  # yellow
+except:
+    pass
+
+print(label)
+" 2>/dev/null)
+
+  [ -n "$result" ] && echo "$result"
+fi