claude-token-saver 2.15.0 → 2.16.0

package/bin/cli.js

@@ -838,12 +838,31 @@ async function main() {
   const sessions = await parseAllSessions({ days, projectFilter });
 
   if (sessions.length === 0) {
-    // Statusline must always emit a single line (no multi-line help spam every 300ms)
+    // Statusline must always emit a single line (no multi-line help spam every
+    // 300ms) — but the stdin payload (rate limits, model) is still live even
+    // with an empty analysis window (e.g. `mode 1h` + idle), and cap-warn /
+    // harness are exactly the signals that must not vanish then.
     if (format === 'statusline') {
-      const colorOk = !hasFlag('--no-color') && !process.env.NO_COLOR;
-      const gray = colorOk ? '\x1b[90m' : '';
-      const reset = colorOk ? '\x1b[0m' : '';
-      console.log(`${gray}🧠 no session data · ${days}d${reset}`);
+      const { formatNoSession } = await import('../src/formatters/statusline.js');
+      const { statuslineDefaults } = await import('../src/config.js');
+      const cfg = statuslineDefaults();
+      const colorOk = !hasFlag('--no-color') && !process.env.NO_COLOR && cfg.color;
+      const isIcon = hasFlag('--icon')
+        ? true
+        : (hasFlag('--no-icon') || hasFlag('--text') ? false : cfg.icon);
+      const stdinJson = readStdinJson();
+      const caps = extractCaps(stdinJson);
+      const model = extractModel(stdinJson);
+      if (caps || model) {
+        try {
+          const { persistSnapshot } = await import('../src/caps-cache.js');
+          persistSnapshot({ caps, model });
+        } catch { /* non-critical */ }
+      }
+      console.log(formatNoSession(
+        { caps, model, windowLabel },
+        { color: colorOk, mode: isIcon ? 'icon' : 'text' },
+      ));
       return;
     }
     console.log('No session data found for the given period.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-token-saver",
-  "version": "2.15.0",
+  "version": "2.16.0",
   "description": "Save tokens on Claude Code — spike diagnosis, 1M-context detection, TTL countdown, statusline. (formerly claude-cache-monitor)",
   "type": "module",
   "bin": {

package/src/formatters/statusline.js

@@ -137,6 +137,73 @@ export function pickCapWarn(caps) {
   return candidates[0];
 }
 
+/**
+ * Harness 🅷 segment builder — shared by the full report and the no-session
+ * fallback line. Best-effort: never throws into the statusline (corrupted
+ * CLAUDE.md, permission issue, etc. → null).
+ */
+function buildHarnessSeg(c, isIcon) {
+  try {
+    const harnessInfo = harnessStatusForStatusline(loadConfig());
+    if (!harnessInfo) return null;
+    const icon = isIcon ? '🅷' : 'H';
+    if (harnessInfo.warning) {
+      // Warning state outranks the N/5 count — a runtime issue (repeated
+      // error / no-evidence / racing edits) is more actionable than a
+      // missing ratchet section. Always red so it stands out.
+      return `${c(RED)}${icon}⚠ ${harnessInfo.warning}${c(RESET)}`;
+    }
+    if (harnessInfo.custom) return `${c(CYAN)}${icon} custom${c(RESET)}`;
+    const tone = harnessInfo.configured >= harnessInfo.total ? GREEN : YELLOW;
+    return `${c(tone)}${icon} ${harnessInfo.configured}/${harnessInfo.total}${c(RESET)}`;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Cap-warn chip builder — shared by the full report and the no-session
+ * fallback line. At 90%+ the user wants to know "when can I send again", so
+ * the wall-clock reset time rides along in the same `🔄 HH:MM` shape as the
+ * always-on usage segments.
+ */
+function buildCapWarnSeg(capWarn, c, isIcon) {
+  if (!capWarn) return null;
+  const pct = Math.round(capWarn.usedPct);
+  const clock = formatResetClock(capWarn.resetsAt);
+  const clockTail = clock ? ` 🔄 ${clock}` : '';
+  if (isIcon) {
+    // Gauge keeps shape parity with the always-on usage segment — the
+    // cap-warn is just the same gauge "filled to alarm". Visual continuity
+    // helps the eye understand "this is the 5H bar I was watching, just red now."
+    const bar = gaugeBar(pct);
+    return `${c(BOLD)}${c(RED)}🚨 ${capWarn.label} ${bar} ${pct}%${clockTail}${c(RESET)}`;
+  }
+  return `${c(BOLD)}${c(RED)}${capWarn.label} cap ${pct}%${clockTail}${c(RESET)}`;
+}
+
+/**
+ * Fallback line for when no session data exists in the analysis window.
+ * The stdin payload (rate limits, model) is still live in that case, and a
+ * 90%+ cap warning is exactly the kind of signal that must not disappear
+ * just because the user has been idle past the window — so cap-warn,
+ * harness, and model chips still render around the "no session data" note.
+ */
+export function formatNoSession({ caps = null, model = null, windowLabel = '' } = {}, { color = true, mode = 'icon' } = {}) {
+  const c = (v) => (color ? v : '');
+  const isIcon = mode === 'icon';
+  const segs = [];
+  const capSeg = buildCapWarnSeg(pickCapWarn(caps), c, isIcon);
+  if (capSeg) segs.push(capSeg);
+  const harnessSeg = buildHarnessSeg(c, isIcon);
+  if (harnessSeg) segs.push(harnessSeg);
+  if (typeof model === 'string' && model.length > 0) {
+    segs.push(isIcon ? `${c(MAGENTA)}🤖 ${model}${c(RESET)}` : `${c(MAGENTA)}${model}${c(RESET)}`);
+  }
+  segs.push(`${c(GRAY)}🧠 no session data${windowLabel ? ` · ${windowLabel}` : ''}${c(RESET)}`);
+  return segs.join(' · ') + (color ? '\x1b[K' : '');
+}
+
 /**
  * @param {object} data - output of main report pipeline (summary, ttl, cost, options, lastActivity)
  * @param {object} [opts]
@@ -144,7 +211,7 @@ export function pickCapWarn(caps) {
  * @param {boolean} [opts.verbose=false] - longer layout with labels
  * @param {boolean} [opts.timer=true] - show TTL countdown segment
  * @param {'text'|'icon'} [opts.mode='text'] - label style. 'icon' uses 🧠 ⏳ 💰 instead of word labels.
- * @param {string[]|null} [opts.segments] - whitelist of segments to render. Names: cap-warn, spike, model, hit, ttl, saved, ctx, period, plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. Null/undefined = all.
+ * @param {string[]|null} [opts.segments] - whitelist of segments to render. Names: cap-warn, spike, harness, model, hit, ttl, saved, ctx, period, plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. Null/undefined = all.
  */
 export function formatReport(data, { color = true, verbose = false, timer = true, mode = 'text', segments = null } = {}) {
   const { summary, ttl, cost, options, lastActivity, contextWindow, spikeChip, caps, model } = data;
@@ -279,28 +346,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // Silent when the project hasn't opted in (no CLAUDE.md and no .claude/);
   // otherwise renders 🅷 5/5 (green) / 🅷 N/5 (yellow) so the user can spot
   // a missing section at a glance and know to run `harness init`.
-  let harnessSeg = null;
-  try {
-    const harnessInfo = harnessStatusForStatusline(loadConfig());
-    if (harnessInfo) {
-      const icon = isIcon ? '🅷' : 'H';
-      if (harnessInfo.warning) {
-        // Warning state outranks the N/5 count — a runtime issue (repeated
-        // error / no-evidence / racing edits) is more actionable than a
-        // missing ratchet section. Always red so it stands out.
-        harnessSeg = `${c(RED)}${icon}⚠ ${harnessInfo.warning}${c(RESET)}`;
-      } else if (harnessInfo.custom) {
-        harnessSeg = `${c(CYAN)}${icon} custom${c(RESET)}`;
-      } else {
-        const tone = harnessInfo.configured >= harnessInfo.total ? GREEN : YELLOW;
-        harnessSeg = `${c(tone)}${icon} ${harnessInfo.configured}/${harnessInfo.total}${c(RESET)}`;
-      }
-    }
-  } catch {
-    // Harness check is best-effort — never break the statusline if the file
-    // read fails (corrupted CLAUDE.md, permission issue, etc.).
-    harnessSeg = null;
-  }
+  const harnessSeg = buildHarnessSeg(c, isIcon);
 
   // Model chip — pulled from Claude Code's stdin payload (`model.display_name`).
   // Cheap identity context: useful when the user toggles between Sonnet/Opus
@@ -322,12 +368,14 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // Today the stdin payload exposes the 5h ("Current session") and 7-day
   // rolling ("Current week") windows; if Anthropic ships more (e.g. a
   // Sonnet-only weekly), they render automatically with derived labels.
-  // Each renders as `{label} {pct}% · {countdown}`. When a window is at >=90%
-  // the cap-warn chip already shouts about it, so we suppress the always-on
-  // segment to avoid duplicate noise.
-  function buildUsageSeg({ labels, info, color: tone }) {
+  // Each renders as `{label} {pct}% · {countdown}`. The window promoted to the
+  // cap-warn chip is suppressed here to avoid duplicate noise — but ONLY that
+  // one. When several windows are at 90%+ the chip shows just the most
+  // imminent, so the others must keep their always-on segment (red) or they'd
+  // vanish from the statusline entirely at the worst possible moment.
+  function buildUsageSeg({ labels, info, color: tone, suppressed }) {
     if (!info || !Number.isFinite(info.usedPct)) return null;
-    if (info.usedPct >= 90) return null; // cap-warn chip handles this case
+    if (suppressed) return null; // cap-warn chip handles this window
     const pct = Math.round(info.usedPct);
     // Show only the wall-clock reset time (e.g. `🔄 21:10`). Absolute time
     // doesn't tick second-by-second so the statusline reads stable, and the
@@ -351,14 +399,20 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     }
     return `${c(tone)}${labels.short} cap ${pct}%${tail}${c(RESET)}`;
   }
-  // Color tone: green when <70%, yellow 70-89% (the segment is suppressed at
-  // 90+% in favor of cap-warn). Lets the user spot "I'm getting close" without
-  // waiting for the alarm chip.
+  // Color tone: green <70%, yellow 70-89%, red 90+% (a 90+% window only
+  // renders here when a *different* window won the cap-warn chip slot).
   function usageTone(info) {
     if (!info || !Number.isFinite(info.usedPct)) return GRAY;
+    if (info.usedPct >= 90) return RED;
     if (info.usedPct >= 70) return YELLOW;
     return GREEN;
   }
+  // Cap-warn chip — leads everything when ANY rate-limit window is at 90%+.
+  // It's the most actionable signal we can show: no point optimizing cache
+  // hits if you're about to be rate-limited anyway. The chip body matches the
+  // English shape `🚨 5H 94%` / `🚨 7D 92%` so history parsers can dedupe on it.
+  // Computed before the usage segments so they know which window it claimed.
+  const capWarn = pickCapWarn(caps);
   const usageSegs = [];
   if (caps && Array.isArray(caps.windows)) {
     for (const win of caps.windows) {
@@ -367,34 +421,13 @@ export function formatReport(data, { color = true, verbose = false, timer = true
         labels,
         info: win,
         color: usageTone(win),
+        suppressed: !!capWarn && capWarn.key === win.key,
       });
       if (seg) usageSegs.push({ key: win.key, seg });
     }
   }
 
-  // Cap-warn chip — leads everything when ANY rate-limit window is at 90%+.
-  // It's the most actionable signal we can show: no point optimizing cache
-  // hits if you're about to be rate-limited anyway. The chip body matches the
-  // English shape `🚨 5H 94%` / `🚨 7D 92%` so history parsers can dedupe on it.
-  const capWarn = pickCapWarn(caps);
-  let capWarnSeg = null;
-  if (capWarn) {
-    const pct = Math.round(capWarn.usedPct);
-    // At 90%+ the user wants to know "when can I send again" — wall-clock is
-    // the actionable bit. Same `🔄 HH:MM` shape as the always-on segments so
-    // the icon's meaning carries over to the alarm chip.
-    const clock = formatResetClock(capWarn.resetsAt);
-    const clockTail = clock ? ` 🔄 ${clock}` : '';
-    if (isIcon) {
-      // Gauge keeps shape parity with the always-on usage segment — the
-      // cap-warn is just the same gauge "filled to alarm". Visual continuity
-      // helps the eye understand "this is the 5H bar I was watching, just red now."
-      const bar = gaugeBar(pct);
-      capWarnSeg = `${c(BOLD)}${c(RED)}🚨 ${capWarn.label} ${bar} ${pct}%${clockTail}${c(RESET)}`;
-    } else {
-      capWarnSeg = `${c(BOLD)}${c(RED)}${capWarn.label} cap ${pct}%${clockTail}${c(RESET)}`;
-    }
-  }
+  const capWarnSeg = buildCapWarnSeg(capWarn, c, isIcon);
 
   // Warning chip leads — a glance at the statusline catches "something's wrong"
   // before parsing any numbers. Healthy states have no chip and look unchanged.
@@ -431,7 +464,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   if (want('period')) segs.push(periodSeg);
   // Trailing erase-to-end-of-line so any leftover characters from a previous
   // (longer) statusline render don't bleed into ours. \x1b[K is the standard
-  // "erase from cursor to EOL" CSI; safe on any ANSI-compatible terminal and
-  // a no-op when stdout isn't a TTY.
-  return segs.join(' · ') + '\x1b[K';
+  // "erase from cursor to EOL" CSI. Only emitted when color (i.e. ANSI) is
+  // allowed — --no-color/NO_COLOR consumers expect escape-free output.
+  return segs.join(' · ') + (color ? '\x1b[K' : '');
 }

package/src/harness-analyzer.cjs

@@ -12,9 +12,11 @@
  *    keywords). <30% → ⚠ no-evidence — high chance the model is reporting
  *    "done" without showing it.
  *
- * 3. PEV-skip — many tool_use calls (5+) in the last 15 turns with no plan
- *    signal (no TodoWrite, no "plan"/"Phase"/"단계" mention). Suggests the
- *    model is racing through edits without a verify pass.
+ * 3. PEV-skip — many *mutating* tool_use calls (Edit/Write/Bash…, 5+) in the
+ *    last 15 assistant turns with no plan signal (no TodoWrite, no
+ *    "plan"/"Phase"/"단계" mention). Suggests the model is racing through
+ *    edits without a verify pass. Read-only exploration (Read/Grep/Glob)
+ *    deliberately doesn't count — reading five files is research, not racing.
  *
  * CommonJS so hook.cjs can `require()` it without a bundler step.
  */
@@ -28,10 +30,14 @@ const os = require('node:os');
 const STATE_DIR = stateDir();
 const STATE_PATH = path.join(STATE_DIR, 'harness-state.json');
 
-const RECENT_TURNS = 15;        // PEV / evidence window
+const RECENT_TURNS = 15;        // PEV / evidence window (assistant turns)
 const RATCHET_TURNS = 30;       // ratchet-candidate window
 const EVIDENCE_THRESHOLD = 0.3; // <30% → ⚠ no-evidence
 const PEV_TOOLUSE_THRESHOLD = 5;
+// Tools that change state. Only these count toward PEV-skip — an agentic
+// session trivially racks up 5+ *read* tool calls (Read/Grep/Glob) while
+// researching, which is exactly the behavior we don't want to punish.
+const MUTATING_TOOL_RE = /^(edit|write|multiedit|notebookedit|bash)$/i;
 
 function stateDir() {
   if (process.platform === 'win32') {
@@ -167,39 +173,42 @@ function findRatchetCandidates(entries) {
  * the immediate next user message also count as "shown the work."
  */
 function computeEvidenceRate(entries) {
-  const recent = entries.slice(-RECENT_TURNS * 2); // both user/assistant
-  const assistants = [];
-  for (let i = 0; i < recent.length; i++) {
-    const e = recent[i];
-    if (e && e.type === 'assistant') {
-      const text = assistantText(e.message);
-      let proof = looksLikeEvidence(text);
-      // If the *next* entry is a user message with tool_result blocks, count
-      // that as evidence for the assistant turn that triggered it.
-      const next = recent[i + 1];
-      if (!proof && next && next.type === 'user' && toolResultsIn(next.message).length > 0) {
-        proof = true;
-      }
-      assistants.push(proof);
+  // Window by *assistant turns*, not raw JSONL entries — one agentic turn can
+  // span dozens of entries, so an entry-sliced window covered only 1-2 real
+  // turns and made the rate jumpy.
+  const idxs = [];
+  for (let i = 0; i < entries.length; i++) {
+    if (entries[i] && entries[i].type === 'assistant') idxs.push(i);
+  }
+  const recentIdxs = idxs.slice(-RECENT_TURNS);
+  if (recentIdxs.length === 0) return null;
+  let proofCount = 0;
+  for (const i of recentIdxs) {
+    const text = assistantText(entries[i].message);
+    let proof = looksLikeEvidence(text);
+    // If the *next* entry is a user message with tool_result blocks, count
+    // that as evidence for the assistant turn that triggered it.
+    const next = entries[i + 1];
+    if (!proof && next && next.type === 'user' && toolResultsIn(next.message).length > 0) {
+      proof = true;
     }
+    if (proof) proofCount++;
   }
-  if (assistants.length === 0) return null;
-  const proofCount = assistants.filter(Boolean).length;
-  return proofCount / assistants.length;
+  return proofCount / recentIdxs.length;
 }
 
 function computePevSkip(entries) {
-  const recent = entries.slice(-RECENT_TURNS);
-  let toolUseCount = 0;
+  const assistants = entries.filter((e) => e && e.type === 'assistant');
+  const recent = assistants.slice(-RECENT_TURNS);
+  let mutatingCount = 0;
   let planSignal = false;
   for (const e of recent) {
-    if (!e || e.type !== 'assistant') continue;
     const text = assistantText(e.message);
     const tus = toolUsesIn(e.message);
-    toolUseCount += tus.length;
+    mutatingCount += tus.filter((t) => MUTATING_TOOL_RE.test(t.name || '')).length;
     if (looksLikePlanSignal(text, tus)) planSignal = true;
   }
-  return toolUseCount >= PEV_TOOLUSE_THRESHOLD && !planSignal;
+  return mutatingCount >= PEV_TOOLUSE_THRESHOLD && !planSignal;
 }
 
 function analyzeTranscript(transcriptPath, opts) {

package/src/harness.js

@@ -101,7 +101,9 @@ function statusForFile(filePath) {
   try {
     content = readFileSync(filePath, 'utf8');
   } catch {
-    return { configured: 0, total: HARNESS_SECTIONS.length, missing: [], hasBlock: false, hasFile: true, optOut: false, custom: false, file: filePath };
+    // Unreadable file (permissions, etc.) — report every section missing so
+    // `harness check` can't print "All 5 sections present ✅" over a 0/5.
+    return { configured: 0, total: HARNESS_SECTIONS.length, missing: HARNESS_SECTIONS.map((s) => s.id), hasBlock: false, hasFile: true, optOut: false, custom: false, file: filePath };
   }
   const hasBlock = content.includes(HARNESS_BLOCK_BEGIN);
   // Opt-out marker — when the user intentionally customizes the harness block
@@ -334,13 +336,24 @@ export function harnessStatusForStatusline(cfg, { root } = {}) {
   if (!status.hasFile && !existsSync(join(projectRoot, '.claude'))) return null;
   if (status.optOut) return null;
   // Attach a warning derived from the analyzer state file (if any). Precedence:
-  //   ratchet? > no-evidence > PEV-skip. Only surfaces when the state's
-  //   sessionId or cwd matches this project, so unrelated sessions don't leak.
+  //   ratchet? > no-evidence > PEV-skip. Guards, in order:
+  //   - freshness: the hook rewrites the state on every tool use, so anything
+  //     older than WARNING_TTL_MS is a dead session's leftovers — a red 🅷⚠
+  //     must never linger for days after the triggering session ended.
+  //   - project match: state.cwd is the *session* cwd, which may be a subdir
+  //     of the repo, while projectRoot is the walked-up root. Normalize both
+  //     through findProjectRoot so launching Claude Code in a subdirectory
+  //     still surfaces (and correctly scopes) the warning. A state with no
+  //     cwd at all is unattributable — stay silent rather than leak it into
+  //     every project.
+  const WARNING_TTL_MS = 30 * 60 * 1000;
   const state = readHarnessState();
   let warning = null;
   if (state) {
-    const matches = (state.cwd && state.cwd === projectRoot) || !state.cwd;
-    if (matches) {
+    const ts = state.timestamp ? Date.parse(state.timestamp) : NaN;
+    const fresh = Number.isFinite(ts) && Date.now() - ts <= WARNING_TTL_MS;
+    const matches = !!state.cwd && findProjectRoot(state.cwd) === projectRoot;
+    if (fresh && matches) {
       if (state.ratchetCandidate && state.ratchetCandidate.count >= 2) {
         const id = state.ratchetCandidate.id || 1;
         warning = `ratchet? #${id}`;