claude-token-saver 2.1.0 → 2.5.0

package/src/history.js

@@ -3,6 +3,11 @@
  * (none → warning, warning A → warning B, warning → none). One markdown file
  * per calendar day so users can pinpoint "when did this start" easily.
  *
+ * Each event is written bilingually: the canonical English line first, the
+ * Korean translation as an indented "└" continuation right below. The chip
+ * text itself stays as-is (its symbol+English is part of the UX surface), but
+ * the diagnostic detail and resolved-status verbs are translated.
+ *
  * Storage path is platform-aware (see paths.userDataDir):
  *   Windows: %APPDATA%\claude-token-saver\history\YYYY-MM-DD.md
  *   macOS:   ~/Library/Application Support/claude-token-saver/history/YYYY-MM-DD.md
@@ -15,6 +20,9 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { userDataDir } from './paths.js';
+import { formatResetIn, formatResetClock } from './format-time.js';
+import { labelForKey } from './window-labels.js';
+import { ISSUE_TIPS, CHIP_TO_CODES, CAP_TIPS } from './advice.js';
 
 const BASE_DIR = userDataDir();
 const HISTORY_DIR = join(BASE_DIR, 'history');
@@ -53,14 +61,116 @@ function saveState(state) {
   writeFileSync(STATE_PATH, JSON.stringify(state) + '\n');
 }
 
-function appendDayLine(line, date = new Date()) {
+/**
+ * Map a chip's English label to its Korean equivalent.
+ * Returns the input unchanged if no mapping is registered (forward-compat
+ * with chips added in advice.js after this map was last updated).
+ */
+function chipKo(chip) {
+  if (!chip) return chip;
+  const map = {
+    '⚠ 1M ON': '⚠ 1M 컨텍스트 활성',
+    '⚠ Cache miss': '⚠ 캐시 미스',
+    '⚠ Rebuild churn': '⚠ 캐시 재빌드 빈발',
+    '⚠ Input spike': '⚠ 입력 급증',
+    '⚠ Output heavy': '⚠ 출력 과다',
+    '⚠ Call surge': '⚠ 호출 급증',
+    '⚠ 5m TTL': '⚠ 5분 TTL',
+    '⏳ Cache expires': '⏳ 캐시 만료 임박',
+    '💰 Cache saved': '💰 캐시 절약',
+    '🧠 Cache hit': '🧠 캐시 적중',
+  };
+  return map[chip] || chip;
+}
+
+/**
+ * Translate the diagnostic detail string to Korean. The detail is constructed
+ * in cli.js and follows two stable shapes:
+ *   "Context auto-promoted to 1M (max single-request {N}k tokens)"
+ *   "session {ID}: CODE_A, CODE_B"
+ * Anything else falls through unchanged.
+ */
+function detailKo(detail) {
+  if (!detail) return detail;
+  const m1 = detail.match(/^Context auto-promoted to 1M \(max single-request (\d+)k tokens\)$/);
+  if (m1) return `1M 컨텍스트 자동 활성 (단일 요청 최대 ${m1[1]}k 토큰)`;
+  const m2 = detail.match(/^session ([^:]+): (.+)$/);
+  if (m2) {
+    const codeKo = {
+      LOW_HIT_RATE: '캐시 적중률 낮음',
+      FREQUENT_CACHE_REBUILD: '캐시 재빌드 빈발',
+      OUTPUT_HEAVY: '출력 과다',
+      INPUT_SPIKE: '입력 급증',
+      CALL_SURGE: '호출 급증',
+      TTL_5M: '5분 TTL',
+    };
+    const codes = m2[2]
+      .split(',')
+      .map((c) => c.trim())
+      .map((c) => codeKo[c] || c)
+      .join(', ');
+    return `세션 ${m2[1]}: ${codes}`;
+  }
+  return detail;
+}
+
+/**
+ * Resolve the diagnostic codes that apply to a transition. We try, in order:
+ *   1. `detail` of shape "session ID: CODE_A, CODE_B" (chip transitions with
+ *      explicit per-session codes — the richest source).
+ *   2. `chip` text mapped via CHIP_TO_CODES (covers 1M ON and chips that fire
+ *      without a per-session detail).
+ * Returns an array of unique codes, possibly empty.
+ */
+function codesForEvent(chip, detail) {
+  const out = [];
+  if (detail) {
+    const m = detail.match(/^session [^:]+:\s*(.+)$/);
+    if (m) {
+      for (const c of m[1].split(',').map((s) => s.trim()).filter(Boolean)) {
+        if (!out.includes(c)) out.push(c);
+      }
+    }
+  }
+  if (chip && CHIP_TO_CODES[chip]) {
+    for (const c of CHIP_TO_CODES[chip]) if (!out.includes(c)) out.push(c);
+  }
+  return out;
+}
+
+/**
+ * Build the "💡 ..." tip block for a given chip+detail pair. Returns
+ * { en: string, ko: string } where each may be empty if no tips apply
+ * (resolution events, unknown chips, etc.).
+ */
+function tipsForEvent(chip, detail) {
+  const codes = codesForEvent(chip, detail);
+  const enLines = [];
+  const koLines = [];
+  for (const code of codes) {
+    const tip = ISSUE_TIPS[code];
+    if (!tip) continue;
+    enLines.push(`  💡 ${tip.en}`);
+    koLines.push(`  💡 ${tip.ko}`);
+  }
+  return { en: enLines.join('\n'), ko: koLines.join('\n') };
+}
+
+function appendDayLine(en, ko, date = new Date(), tips = null) {
   ensureDir(HISTORY_DIR);
   const path = join(HISTORY_DIR, `${ymd(date)}.md`);
+  // Bilingual event line. Tip lines (when present) follow on their own lines so
+  // the file reads as: event-en / └ event-ko / 💡 tip-en / 💡 tip-ko.
+  let block = ko && ko !== en ? `${en}\n  └ ${ko}\n` : `${en}\n`;
+  if (tips && tips.en) block += `${tips.en}\n`;
+  if (tips && tips.ko) block += `${tips.ko}\n`;
   if (!existsSync(path)) {
-    writeFileSync(path, `# Token Monitor — ${ymd(date)}\n\n## Events\n${line}\n`);
+    const header = `# Token Monitor / 토큰 모니터 — ${ymd(date)}\n\n## Events / 이벤트\n`;
+    writeFileSync(path, header + block);
   } else {
     const existing = readFileSync(path, 'utf8');
-    writeFileSync(path, existing.endsWith('\n') ? existing + line + '\n' : existing + '\n' + line + '\n');
+    const sep = existing.endsWith('\n') ? '' : '\n';
+    writeFileSync(path, existing + sep + block);
   }
 }
 
@@ -77,16 +187,28 @@ export function recordChip(chip, contextHints = {}) {
 
   if (current === last) return false;
 
-  let line;
+  const detail = contextHints.detail || null;
+  const detailEn = detail ? `  — ${detail}` : '';
+  const detailKr = detail ? `  — ${detailKo(detail)}` : '';
+
+  let en, ko;
+  // Tips only on warning entry/transition (not resolution) — based on the
+  // *new* chip so users see how to handle what's currently active.
+  let tips = null;
   if (current && !last) {
-    line = `- ${hms(now)} ${current}` + (contextHints.detail ? `  — ${contextHints.detail}` : '');
+    en = `- ${hms(now)} ${current}${detailEn}`;
+    ko = `${chipKo(current)}${detailKr}`;
+    tips = tipsForEvent(current, detail);
   } else if (current && last) {
-    line = `- ${hms(now)} ${last} → ${current}` + (contextHints.detail ? `  — ${contextHints.detail}` : '');
+    en = `- ${hms(now)} ${last} → ${current}${detailEn}`;
+    ko = `${chipKo(last)} → ${chipKo(current)}${detailKr}`;
+    tips = tipsForEvent(current, detail);
   } else {
     // current === null, last was something — warning resolved
-    line = `- ${hms(now)} ✓ resolved (was ${last})`;
+    en = `- ${hms(now)} ✓ resolved (was ${last})`;
+    ko = `✓ 해소됨 (이전: ${chipKo(last)})`;
   }
-  appendDayLine(line, now);
+  appendDayLine(en, ko, now, tips);
   saveState({ chip: current, ts: now.toISOString() });
   return true;
 }
@@ -110,6 +232,84 @@ export function readRecent(days = 7) {
   return out;
 }
 
+/**
+ * Record entering or exiting the cap-warn (>=90%) zone for a rate-limit
+ * window. Each window (keyed by its stdin name — e.g. `five_hour`, `seven_day`)
+ * has its own dedup slot, so the daily file gets two transitions max per
+ * window per warning episode.
+ *
+ * @param {{ key: string, usedPct: number, resetsAt: number|null } | null} window
+ * @returns {boolean} true when a line was appended
+ */
+export function recordCapTransition(window) {
+  if (!window || typeof window.key !== 'string') return false;
+  const state = loadState();
+  const slotKey = `cap_${window.key}`;
+  const wasWarn = !!state[slotKey];
+  const isWarn = Number.isFinite(window.usedPct) && window.usedPct >= 90;
+  if (wasWarn === isWarn) return false;
+
+  const now = new Date();
+  const labels = labelForKey(window.key);
+  const labelEn = labels.short;
+  // Korean labels map only the well-known windows; everything else falls back
+  // to the English short label (still readable for the bilingual line).
+  const KO_OVERRIDES = {
+    five_hour: '5시간 윈도',
+    seven_day: '7일 윈도',
+    seven_day_sonnet: '7일 윈도 (Sonnet)',
+    seven_day_opus: '7일 윈도 (Opus)',
+  };
+  const labelKo = KO_OVERRIDES[window.key] || labels.short;
+  let en;
+  let ko;
+  if (isWarn) {
+    const pct = Math.round(window.usedPct);
+    const reset = formatResetIn(window.resetsAt, now);
+    const clock = formatResetClock(window.resetsAt, now);
+    const tail = reset && clock
+      ? ` (resets in ${reset}, at ${clock})`
+      : reset
+        ? ` (resets in ${reset})`
+        : clock
+          ? ` (resets at ${clock})`
+          : '';
+    const tailKo = reset && clock
+      ? ` (${clock}에 리셋, 남은 ${reset})`
+      : reset
+        ? ` (리셋까지 ${reset})`
+        : clock
+          ? ` (${clock}에 리셋)`
+          : '';
+    en = `- ${hms(now)} 🚨 ${labelEn} ${pct}% cap warning${tail}`;
+    ko = `🚨 ${labelKo} ${pct}% 캡 경고${tailKo}`;
+  } else {
+    en = `- ${hms(now)} ✓ ${labelEn} cap warning resolved`;
+    ko = `✓ ${labelKo} 캡 경고 해소`;
+  }
+  // Cap-warn entry → handoff tip; resolution → no tip (just the ✓ line).
+  const capTips = isWarn ? { en: `  💡 ${CAP_TIPS.en}`, ko: `  💡 ${CAP_TIPS.ko}` } : null;
+  appendDayLine(en, ko, now, capTips);
+  state[slotKey] = isWarn;
+  saveState(state);
+  return true;
+}
+
+/**
+ * Record a handoff write — invoked by the `handoff` subcommand so
+ * `claude-token-saver history` shows when work was backed up to a HANDOFF file.
+ *
+ * @param {string} filePath
+ * @returns {boolean}
+ */
+export function recordHandoff(filePath) {
+  const now = new Date();
+  const en = `- ${hms(now)} 📝 handoff written: ${filePath}`;
+  const ko = `📝 핸드오프 백업 작성: ${filePath}`;
+  appendDayLine(en, ko, now);
+  return true;
+}
+
 /**
  * List all available history file dates (sorted newest first).
  */

package/src/installer.js

@@ -15,7 +15,7 @@ import { claudeUserDir } from './paths.js';
 
 const SKILL_BODY = `---
 name: claude-token-saver
-description: Use when the user mentions Claude Code token usage, prompt cache hit rate, TTL/expiry, the 1M context window, cache misses, output spikes, or anything in the statusline produced by claude-token-saver (chips like "⚠ 1M ON", "⚠ Input spike", "⚠ Cache miss", "⚠ 5m TTL", "⚠ Rebuild churn", "⚠ Output heavy", "⚠ Call surge", "⏳ Cache expires", "💰 Cache saved", "🧠 Cache hit"). Also use when they ask to view token-usage history or want to understand a warning they just saw.
+description: Use when the user mentions Claude Code token usage, prompt cache hit rate, TTL/expiry, the 1M context window, cache misses, output spikes, rate-limit caps (5h/7d), or anything in the statusline produced by claude-token-saver (chips like "🚨 5H 94%", "🚨 7D 92%", "⚠ 1M ON", "⚠ Input spike", "⚠ Cache miss", "⚠ 5m TTL", "⚠ Rebuild churn", "⚠ Output heavy", "⚠ Call surge", "⏳ Cache expires", "💰 Cache saved", "🧠 Cache hit"). Also use when they ask to view token-usage history, want to understand a warning they just saw, or want to back up work before a session cap with \`claude-token-saver handoff\`.
 ---
 
 # claude-token-saver — Claude Code Token Monitor
@@ -26,28 +26,38 @@ countdown, savings, and (when relevant) a leading warning chip.
 
 ## When this skill should activate
 
-- The user references any chip wording: \`⚠ 1M ON\`, \`⚠ Input spike\`,
-  \`⚠ Cache miss\`, \`⚠ 5m TTL\`, \`⚠ Rebuild churn\`, \`⚠ Output heavy\`,
-  \`⚠ Call surge\`.
+- The user references any chip wording: \`🚨 5H NN%\`, \`🚨 7D NN%\`,
+  \`⚠ 1M ON\`, \`⚠ Input spike\`, \`⚠ Cache miss\`, \`⚠ 5m TTL\`,
+  \`⚠ Rebuild churn\`, \`⚠ Output heavy\`, \`⚠ Call surge\`.
 - The user asks "why is my cache hit rate low", "what does this warning mean",
   "when did this start happening", or similar.
+- The user is approaching a rate-limit cap and wants to back up the current
+  work so a fresh session can continue (point them at
+  \`claude-token-saver handoff\`).
 - The user wants to see the token-usage history file or asks for a summary
   of recent warnings.
 
 ## What to do
 
-1. **Identify the chip.** If the user pasted a statusline, pull out the leading
-   \`⚠ ...\` chip. That maps to a specific issue category.
-2. **Show recent history.** Run \`claude-token-saver history\` (default last 7
-   days) to see the chronology of warning transitions. Each entry is timestamped
-   and includes a short detail string.
-3. **Drill down on the live state.** Run \`claude-token-saver --days 1\` (or
+1. **Lead with the most recent warning + how to handle it.** Run
+   \`claude-token-saver last\` first. It returns the most recent warning event
+   (chip + detail + timestamp) plus the full advice block for it. Surface that
+   to the user before anything else — this is what they came for.
+2. **Identify the chip.** If the user pasted a statusline (instead of relying
+   on \`last\`), pull out the leading \`⚠ ...\` chip. That maps to a specific
+   issue category.
+3. **Show recent history.** Run \`claude-token-saver history\` (default last 7
+   days) to see the chronology of warning transitions. Each entry is timestamped,
+   bilingual (English line + 한국어), and includes a \`💡\` action tip inline.
+4. **Drill down on the live state.** Run \`claude-token-saver --days 1\` (or
    another window) to render the full table view, which lists per-session
    spikes and recommended actions.
-4. **Explain the warning** in plain language. Use the chip → cause table:
+5. **Explain the warning** in plain language. Use the chip → cause table:
 
    | Chip               | Likely cause                                          |
    | ------------------ | ----------------------------------------------------- |
+   | \`🚨 5H NN%\`       | 5-hour rate-limit window at NN% (>=90%). Cap is imminent. |
+   | \`🚨 7D NN%\`       | 7-day rate-limit window at NN% (>=90%). Pace yourself.   |
    | \`⚠ 1M ON\`         | Auto-promoted to 1M context (Opus 4.7+ Max default).  |
    | \`⚠ Input spike\`   | One request consumed >250k or >3× the recent p95.     |
    | \`⚠ Cache miss\`    | Cache hit rate dropped below ~70%.                    |
@@ -56,17 +66,24 @@ countdown, savings, and (when relevant) a leading warning chip.
    | \`⚠ Output heavy\`  | Output ratio dominates input — inspect long generations. |
    | \`⚠ Call surge\`    | Request count is well above baseline.                 |
 
-5. **Suggest the next action.** For 1M ON, mention
-   \`CLAUDE_CODE_DISABLE_1M_CONTEXT=1\`. For 5m TTL, point at the Max plan's
-   1h bucket. For input spike, suggest splitting the conversation or
-   compacting context.
+6. **Suggest the next action.** For \`🚨 5H/7D\` chips, recommend running
+   \`claude-token-saver handoff\` to back up the current work to a
+   \`HANDOFF-*.md\` file before the cap hits, then continue in a fresh
+   session. For 1M ON, mention \`CLAUDE_CODE_DISABLE_1M_CONTEXT=1\`. For
+   5m TTL, point at the Max plan's 1h bucket. For input spike, suggest
+   splitting the conversation or compacting context.
 
 ## Useful commands
 
+- \`claude-token-saver last\` — most recent warning + full advice (start here).
+- \`claude-token-saver last --days 7\` — widen the lookback window.
 - \`claude-token-saver\` — full table report (default last 1 day).
 - \`claude-token-saver --days 7\` — wider window.
-- \`claude-token-saver history\` — recent warning transitions per day.
+- \`claude-token-saver history\` — recent warning transitions per day, with
+  inline \`💡\` action tips.
 - \`claude-token-saver history --days 30\` — longer history.
+- \`claude-token-saver handoff\` — write a HANDOFF-*.md template in cwd
+  capturing git status + cap snapshot, so a fresh session can resume cleanly.
 - \`claude-token-saver mode\` — show statusline preferences.
 - \`claude-token-saver mode icon verbose 1d\` — change preferences.
 
@@ -85,23 +102,31 @@ description: Show recent claude-token-saver warning history and a fresh report.
 ---
 
 You are responding to the \`/token-monitor\` slash command. The user wants a
-quick read of their Claude Code token usage and any active warnings.
+quick read of their Claude Code token usage and any active warnings — most
+importantly: **what just happened, and how do I handle it?**
 
 Steps:
 
-1. Run \`claude-token-saver history --days 7\` and capture the output. This
-   prints recent warning transitions (timestamps + chip + short detail).
-2. Run \`claude-token-saver --days 1\` and capture the output. This prints the
-   full table view: TTL breakdown, cost impact, daily trend, and any active
-   spikes with recommended actions.
-3. Summarize for the user:
-   - **Active warnings** — list the most recent unresolved chip(s) with the
-     time they appeared.
-   - **Today's pattern** — when warnings cluster in time, mention it.
-   - **Recommended action** — pick the highest-leverage suggestion from the
-     table report's "Recommended actions" section.
-4. If the history is empty, say so plainly — no warnings means the cache has
-   been healthy in the configured window.
+1. **Lead with the most recent warning.** Run \`claude-token-saver last\`
+   first and surface its output verbatim (or lightly summarized) at the top
+   of your reply. This returns the latest warning event (chip + detail +
+   timestamp) followed by the full advice block. If \`last\` says no recent
+   warnings, mention that and skip ahead — you can stop here unless the user
+   asked for more.
+2. Run \`claude-token-saver history --days 7\` and capture the output. Use it
+   only to add context — e.g. "this is the 3rd cache miss today" — not to
+   re-print the whole file. Each entry is bilingual and includes a \`💡\`
+   action tip inline.
+3. Run \`claude-token-saver --days 1\` and capture the output for any extra
+   color you want to add: TTL breakdown, cost impact, daily trend, or active
+   spikes. Skip if step 1 already covered what the user needs.
+4. Summarize for the user:
+   - **What just fired** — the chip + the time + a sentence on what caused it
+     (from \`last\`).
+   - **What to do** — the action tip from \`last\`. For cap-warn (\`🚨 5H/7D NN%\`),
+     surface \`claude-token-saver handoff\` prominently so they can back up
+     state before the cap blocks them.
+   - **Today's pattern** (optional) — when warnings cluster in time, mention it.
 
 Keep the summary to ~10 lines. The user can re-run the underlying commands
 themselves for the full output.

package/src/window-labels.js

@@ -0,0 +1,61 @@
+/**
+ * Friendly labels + icons for `rate_limits.*` keys from Claude Code's stdin
+ * payload. Known keys (`five_hour`, `seven_day`) get curated short/long labels
+ * and dedicated icons. Unknown keys are passed through with a derived label so
+ * any future window Anthropic adds (e.g. `seven_day_sonnet`) renders without
+ * a code change.
+ */
+
+// `short` is used by the cap-warn chip and history records (stable shape so
+// parsers/dedup keep working). `usageLabel` is the friendlier word that the
+// always-on usage segment renders next to the icon — empty string means the
+// icon alone carries the meaning (5H 'session/now' is the implicit default).
+const KNOWN = {
+  // ✦ reads as "AI token unit" (Anthropic/OpenAI/Gemini sparkle motif), more
+  // on-theme than the 🪙 coin which suggested in-app currency. Same width as
+  // 📅 in monospace terminals so the chip alignment stays stable.
+  // 'current' mirrors how `weekly` reads next to 7D — names the window in
+  // plain English so a glance at `✦ current ████▒░ 72%` tells the eye what's
+  // being measured without parsing the icon's meaning.
+  five_hour: { short: '5H', long: 'Current session', icon: '✦', usageLabel: 'current' },
+  seven_day: { short: '7D', long: 'Current week', icon: '📅', usageLabel: 'weekly' },
+  // Speculative — `/usage` shows a Sonnet-only weekly bucket, so if Anthropic
+  // ever surfaces it on stdin we render with a sensible default already.
+  seven_day_sonnet: { short: '7D-S', long: 'Current week (Sonnet)', icon: '🅂', usageLabel: 'weekly (Sonnet)' },
+  seven_day_opus: { short: '7D-O', long: 'Current week (Opus)', icon: '🅾', usageLabel: 'weekly (Opus)' },
+};
+
+function deriveShort(key) {
+  // "five_hour" → "5H"; "seven_day_sonnet" → "7DS"; arbitrary key → uppercase initials
+  const m = key.match(/^(\d+)_?([a-z]+)/);
+  if (m) {
+    const num = m[1];
+    const word = m[2];
+    const letter = word.charAt(0).toUpperCase();
+    const tail = key.slice(m[0].length);
+    const suffix = tail
+      .split('_')
+      .filter(Boolean)
+      .map((s) => s.charAt(0).toUpperCase())
+      .join('');
+    return `${num}${letter}${suffix}`;
+  }
+  return key
+    .split('_')
+    .filter(Boolean)
+    .map((s) => s.charAt(0).toUpperCase())
+    .join('') || key;
+}
+
+function deriveLong(key) {
+  return key
+    .split('_')
+    .map((w) => (w ? w[0].toUpperCase() + w.slice(1) : w))
+    .join(' ');
+}
+
+export function labelForKey(key) {
+  if (KNOWN[key]) return KNOWN[key];
+  const short = deriveShort(key);
+  return { short, long: deriveLong(key), icon: '⏱', usageLabel: short };
+}

package/examples/statusline-with-rz1989s.sh

@@ -1,52 +0,0 @@
-#!/bin/sh
-# Combine rz1989s/claude-code-statusline (rich layout: repo, cost, MCP, prayer times)
-# with claude-token-saver (cache hit rate, TTL countdown, 1M-context detection,
-# spike diagnosis). The two projects don't overlap — rz1989s runs first, our
-# cache chip is appended as the final segment.
-#
-# Install:
-#   1) Follow rz1989s install instructions so bash ~/.claude/statusline.sh works:
-#      https://github.com/rz1989s/claude-code-statusline
-#   2) npm install -g claude-token-saver   (or rely on npx — fallback below)
-#   3) Save this file as: ~/.claude/statusline-with-rz1989s.sh
-#      chmod +x ~/.claude/statusline-with-rz1989s.sh
-#   4) In ~/.claude/settings.json:
-#      {
-#        "statusLine": {
-#          "type": "command",
-#          "command": "bash ~/.claude/statusline-with-rz1989s.sh",
-#          "refreshInterval": 1
-#        }
-#      }
-#
-# refreshInterval: 1 keeps our TTL countdown ticking while you're idle.
-# Drop to 2 or 5 for lower local CPU if your rz1989s config does heavy work.
-
-# Claude Code sends the session JSON on stdin. Both tools want to read it,
-# so we buffer it and tee to each.
-input=$(cat)
-
-# --- 1) rz1989s layout (if installed) ---
-RZ_STATUSLINE="${CLAUDE_RZ_STATUSLINE:-$HOME/.claude/statusline.sh}"
-if [ -f "$RZ_STATUSLINE" ]; then
-  printf '%s' "$input" | bash "$RZ_STATUSLINE"
-  # Separator between the two tools. Dim pipe.
-  printf ' \033[90m|\033[00m '
-fi
-
-# --- 2) claude-token-saver ---
-# Pass --exclude-session so the current session's tool calls don't reset the
-# TTL countdown. The path comes from the session JSON if present.
-session_path=$(printf '%s' "$input" | sed -n 's/.*"path"[[:space:]]*:[[:space:]]*"\([^"]*\.jsonl\)".*/\1/p' | head -n1)
-exclude_flag=""
-if [ -n "$session_path" ]; then
-  exclude_flag="--exclude-session $session_path"
-fi
-
-if command -v claude-token-saver >/dev/null 2>&1; then
-  # shellcheck disable=SC2086
-  claude-token-saver --statusline --icon $exclude_flag 2>/dev/null || true
-else
-  # shellcheck disable=SC2086
-  npx --yes claude-token-saver@latest --statusline --icon $exclude_flag 2>/dev/null || true
-fi