sprag-cli 3.56.0 → 3.58.0

package/src/route-scan.js

@@ -17,7 +17,7 @@
  * ratchet promote flow (`harness promote R<N> --global|--project`).
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { userDataDir } from './paths.js';
 import { discoverSessionFiles } from './parser.js';
@@ -55,7 +55,16 @@ export const MIN_DELEGABLE_OUT = 100;
 // Measured 2026-09-20 on 1,276 local prompts: '퍼블리시' (npm publish, 15 hits)
 // and '이유' (root-cause asks) were slipping through as run/translate, and a
 // bare '머지' matched inside '나머지' ("나머지 진행하자" ×7), hence the lookbehind.
-export const ESCALATE_RE = /설계|아키텍처|리팩토링|원인 분석|개선할|검토해보|비교|왜(?=[\s?]|$)|이유|제출|배포|출시|퍼블리시|릴리[스즈](?!\s*노트)|(?<!나)머지|analyze|compare|evaluate|architect|refactor|submit|deploy|release|publish|merge/i;
+//
+// Measured 2026-10-01 on 10,958 local prompts: reviews, security checks and
+// root-cause asks were hinted to haiku because they are phrased as a check
+// ("보안 취약점 있는지 확인해줘", "개선점 확인해보자", "버그 원인 확인"). Of the
+// 300 short prompts that got a hint, the added terms and the whole-word
+// keywords further down take it away from 18: judgement requests, and
+// questions that merely contained "statusline". None gained a hint. Bare
+// '리뷰' and '보안' are left out on purpose: they are product nouns in ordinary
+// status checks ("리뷰 허브 배치 확인"), so only the request-shaped forms count.
+export const ESCALATE_RE = /설계|아키텍처|리팩토링|원인\s*(?:분석|파악|확인|규명|조사)|원인을?\s*찾|버그|개선할|개선점|개선\s*(?:사항|방안)|검토해보|검수|코드\s*리뷰|리뷰\s*해|취약|보안\s*(?:점검|검토|감사|리뷰|이슈)|비교|왜(?=[\s?]|$)|이유|제출|배포|출시|퍼블리시|릴리[스즈](?!\s*노트)|(?<!나)머지|analyze|compare|evaluate|architect|refactor|submit|deploy|release|publish|merge|root cause|code review|security (?:review|audit)|vulnerabilit/i;
 
 // Implementation asks phrased around a run/check verb ("설치와 동시에 설정되도록
 // 하자", "피드백 확인해주고 아이콘도 만들자"). Editing is not delegable, and at
@@ -116,7 +125,7 @@ const CATEGORIES = [
     label: '탐색·조회 (파일/값 찾기)',
     labelEn: 'lookup (finding files/values)',
     agent: 'haiku-explore',
-    kw: [[/grep|검색|search|find/i, 2], [/찾아|어디|위치|목록|살펴/i, 1],
+    kw: [[/\bgrep\b|검색|\bsearch|\bfind\b/i, 2], [/찾아|어디|위치|목록|살펴/i, 1],
       [/정의(?:돼|되어)\s*있|어느\s*파일|어떤\s*파일에|\bwhich\s+file\b|\bwhere\s+(?:is|are)\b[^?\n]*\bdefined\b/i, 1]],
   },
   {
@@ -124,23 +133,31 @@ const CATEGORIES = [
     label: '읽기·요약·설명',
     labelEn: 'reading / summarizing / explaining',
     agent: 'haiku-explore',
-    kw: [[/요약|summar|explain/i, 2], [/읽어|설명|정리해|보여줘|알려줘|뭐야|what/i, 1]],
+    kw: [[/요약|summar|explain/i, 2], [/읽어|설명|정리해|보여줘|알려줘|뭐야|\bwhat\b/i, 1]],
   },
   {
     id: 'check',
     label: '상태 확인·검증',
     labelEn: 'status checks / verification',
     agent: 'haiku-explore',
-    kw: [[/확인|검증|verify|점검/i, 2], [/맞아\?|되나|됐나|됐어|되는지|괜찮|체크|check|status/i, 1]],
+    kw: [[/확인|검증|\bverif|점검/i, 2], [/맞아\?|되나|됐나|됐어|되는지|괜찮|체크|\bcheck\b|\bstatus\b/i, 1]],
   },
   {
     id: 'run',
     label: '명령 실행 (빌드·테스트·git)',
     labelEn: 'running commands (build/test/git)',
     agent: 'haiku-runner',
-    kw: [[/git |commit|push|npm |pip|빌드해|빌드 돌/i, 2], [/실행|돌려|run |build|빌드|테스트|설치/i, 1]],
+    kw: [[/\bgit |\bcommit(?:s|ted)?\b|\bpush(?:ed|es)?\b|\bnpm |\bpip3? |빌드해|빌드 돌/i, 2], [/실행|돌려|\brun\b|\bbuild\b|빌드|테스트|설치/i, 1]],
   },
 ];
+// English keywords are matched as whole words. As bare substrings, `pip`
+// claimed "pipeline", `commit` "commitment", `find` "findings" and `status`
+// "statusline", which filed questions about those under run, explore or check.
+// `\b` works next to Hangul here because the keyword itself is ASCII: the
+// boundary falls between its last letter and the syllable that follows.
+// `git`, `npm` and `pip` keep the trailing space they always had: followed by
+// a subcommand they are a command to run, while "npm, github 쪽에도" and
+// "git은 나중에" only mention the tool.
 
 // ── Behavior signal (1st) — what the episode actually DID ────────────────
 // The tool-call histogram is ground truth the prompt's wording is not:
@@ -411,6 +428,42 @@ export function ruleCouldHaveRouted(rule, run) {
   return run.startedAt >= promoted;
 }
 
+/**
+ * Number the candidates of a scan, in place, and return the highest number in
+ * use. A candidate keeps its number for as long as it stays listed. Numbering
+ * by rank let a rescan between "R2 is a candidate" and `promote R2` hand the
+ * number to another pattern, and the wrong rule was registered. A new candidate
+ * takes a number no listed candidate has held; numbering starts over only once
+ * the list has been empty.
+ *
+ * @param {Array} candidates this scan's candidates
+ * @param {object|null} prev the previous scan's cache
+ */
+export function assignCandidateIds(candidates, prev) {
+  const prevIds = new Map((prev?.candidates || [])
+    .filter((c) => Number.isInteger(c?.id) && c.id > 0).map((c) => [c.signature, c.id]));
+  let last = prevIds.size ? Math.max(Number(prev?.lastCandidateId) || 0, ...prevIds.values()) : 0;
+  for (const c of candidates) c.id = prevIds.get(c.signature) ?? ++last;
+  return last;
+}
+
+/**
+ * Bytes in the scan window: each transcript and the subagent transcripts under
+ * it. The scan records this figure and the rescan gate diffs a fresh one
+ * against it, so both take it from here. Counted separately, the scan included
+ * subagent bytes and the gate did not: the gate's total came out smaller than
+ * the recorded one by that amount, and the "enough new data" clause could not
+ * fire for a workload made mostly of delegations.
+ */
+export function windowBytes(files) {
+  let total = 0;
+  for (const f of files || []) {
+    total += f.size || 0;
+    for (const a of f.subagentFiles || []) total += a.size || 0;
+  }
+  return total;
+}
+
 export async function runRouteScan({ days = 14 } = {}) {
   const files = await discoverSessionFiles({ days });
 
@@ -427,12 +480,11 @@ export async function runRouteScan({ days = 14 } = {}) {
   // Pass 1 — collect episodes (needed up front: thresholds are calibrated
   // from the full window's output distribution before any tiering).
   const all = []; // { ep, projectDir, sessionPath }
-  let dataBytes = 0; // window size snapshot — the rescan gate diffs against it
+  const dataBytes = windowBytes(files); // window size snapshot — the rescan gate diffs against it
   const runIndexBySession = new Map(); // sessionPath → indexRuns() result
   for (const f of files) {
     let records;
     try {
-      dataBytes += statSync(f.path).size;
       records = await collectSessionRecords(f.path, { includeContent: true });
     } catch {
       continue;
@@ -445,12 +497,7 @@ export async function runRouteScan({ days = 14 } = {}) {
     // delegation it made. Best-effort: sessions that never delegated have no
     // directory and cost one failed readdir.
     const runs = await collectSubagentRuns(f.path);
-    if (runs.length > 0) {
-      runIndexBySession.set(f.path, indexRuns(runs));
-      // Subagent bytes count toward the window size so the rescan gate stays
-      // accurate for delegation-heavy workloads.
-      for (const r of runs) dataBytes += r.bytes || 0;
-    }
+    if (runs.length > 0) runIndexBySession.set(f.path, indexRuns(runs));
   }
   const totalEpisodes = all.length;
   const thresholds = calibrateThresholds(all.map((x) => x.ep.out));
@@ -573,9 +620,11 @@ export async function runRouteScan({ days = 14 } = {}) {
   // savings here would credit the tool for work it did not route.
   const ledgerEvents = [];
   let ledgerRules = [];
+  let ruleForProject = () => undefined;
   try {
-    const { loadModelRules } = await import('./model-rules.js');
-    ledgerRules = loadModelRules().rules.filter((r) => r.status !== 'off');
+    const rules = await import('./model-rules.js');
+    ledgerRules = rules.loadModelRules().rules.filter((r) => r.status !== 'off');
+    ruleForProject = rules.ruleForProject;
   } catch { /* no registry → no attributable savings, which is the honest zero */ }
   // A rule's baseline: what it stored at promotion, else what this scan still
   // observes handling the category directly (a rule promoted before baselines
@@ -586,9 +635,9 @@ export async function runRouteScan({ days = 14 } = {}) {
       || (rule.scope === 'global' ? episodeStats.get(`${tier}|${catId}|*`) : null);
     return s?.baselineModel || null;
   };
-  const ruleForRun = (tier, catId, projectDir) => ledgerRules.find((r) =>
-    r.tier === tier && r.category === catId &&
-    (r.scope === 'global' || r.project === projectDir));
+  // The same choice rule health makes (model-rules.js), so the ledger and the
+  // registry credit a run to the same rule.
+  const ruleForRun = (tier, catId, projectDir) => ruleForProject(ledgerRules, tier, catId, projectDir);
   for (const [sessionPath, index] of runIndexBySession) {
     const used = new Set();
     const eps = all.filter((x) => x.sessionPath === sessionPath);
@@ -681,8 +730,8 @@ export async function runRouteScan({ days = 14 } = {}) {
     .filter((g) => g.count >= MIN_RECURRENCE && !hasRule(g))
     .sort((a, b) => b.count - a.count)
     .slice(0, 8)
-    .map((g, i) => ({
-      id: i + 1,
+    .map((g) => ({
+      id: null, // assigned below, from the previous scan where there was one
       signature: `${g.tier}|${g.category}|${g.project}`,
       tier: g.tier,
       category: g.category,
@@ -709,6 +758,8 @@ export async function runRouteScan({ days = 14 } = {}) {
       ruleEn: ruleTextEn(g),
     }));
 
+  const lastCandidateId = assignCandidateIds(candidates, prev);
+
   // Same category appearing in 2+ projects → suggest global for each.
   const catProjects = new Map();
   for (const c of candidates) {
@@ -727,6 +778,7 @@ export async function runRouteScan({ days = 14 } = {}) {
     easyEpisodes: tieredEpisodes,
     thresholds,
     candidates,
+    lastCandidateId,
     resolved: [...resolved],
     unresolvedRuns,
     unresolvedModels: [...unresolvedModels].slice(0, 5),
@@ -819,11 +871,11 @@ export async function shouldRescan(cache, { days = 14, afterDelegation = false }
   let total = 0;
   let anyNew = false;
   try {
-    for (const f of await discoverSessionFiles({ days })) {
-      const s = statSync(f.path);
-      total += s.size;
-      if (s.mtimeMs > ts) anyNew = true;
-    }
+    const files = await discoverSessionFiles({ days });
+    total = windowBytes(files);
+    // A subagent transcript is new data too: a delegation writes there and may
+    // leave the parent transcript untouched until the run returns.
+    anyNew = files.some((f) => f.mtime > ts || (f.subagentFiles || []).some((a) => a.mtime > ts));
   } catch {
     return age >= RESCAN_MAX_AGE_MS; // can't stat — degrade to daily
   }

package/src/savings-ledger.js

@@ -22,9 +22,10 @@
  * empty, and the statusline renders totals of 0 as "no chip".
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { userDataDir } from './paths.js';
+import { writeStateFile } from './state-file.js';
 
 const WEEK_MS = 7 * 24 * 3600 * 1000;
 const MONTH_MS = 30 * 24 * 3600 * 1000;
@@ -38,6 +39,19 @@ export function ledgerPath() {
 
 export const LEDGER_VERSION = 2;
 
+/**
+ * Which run a ledger key names, wherever its transcript sits:
+ * `<session id>/subagents/<agent file>`. A project folder that was renamed or
+ * copied holds the same run under two paths, and keyed by full path alone the
+ * ledger counted its saving twice. Keys that are not subagent transcript paths
+ * identify themselves.
+ */
+export function runIdentity(key) {
+  const parts = String(key).split(/[\\/]/);
+  const i = parts.lastIndexOf('subagents');
+  return i > 0 ? parts.slice(i - 1).join('/') : String(key);
+}
+
 export function loadLedger() {
   try {
     const data = JSON.parse(readFileSync(ledgerPath(), 'utf8'));
@@ -48,6 +62,15 @@ export function loadLedger() {
     // instead of mixing two meanings into one total. The next scan rebuilds
     // whatever is still attributable.
     if (data.version !== LEDGER_VERSION) return { version: LEDGER_VERSION, events: {} };
+    // One event per run: duplicates recorded from a second copy of the same
+    // transcript are dropped here, so every reader sums each run once and the
+    // next write persists the cleanup.
+    const seen = new Set();
+    for (const key of Object.keys(data.events)) {
+      const id = runIdentity(key);
+      if (seen.has(id)) delete data.events[key];
+      else seen.add(id);
+    }
     return data;
   } catch {
     return { version: LEDGER_VERSION, events: {} };
@@ -67,11 +90,18 @@ export function recordDelegationEvents(events) {
   const data = loadLedger();
   data.version = LEDGER_VERSION;
   let changed = false;
+  const keyOf = new Map(Object.keys(data.events).map((k) => [runIdentity(k), k]));
   for (const e of events) {
     if (!e || !e.key || typeof e.usd !== 'number' || !Number.isFinite(e.usd) || !Number.isFinite(e.ts)) continue;
-    const prev = data.events[e.key];
+    // The run may already be recorded under the path of another copy of its
+    // transcript; that entry is the one to compare with and to replace.
+    const id = runIdentity(e.key);
+    const prevKey = keyOf.get(id) ?? e.key;
+    const prev = data.events[prevKey];
     const usd = roundUsd(e.usd);
     if (prev && prev.ts === e.ts && prev.usd === usd) continue;
+    if (prevKey !== e.key) delete data.events[prevKey];
+    keyOf.set(id, e.key);
     data.events[e.key] = {
       ts: e.ts,
       usd,
@@ -83,9 +113,7 @@ export function recordDelegationEvents(events) {
   }
   if (!changed) return;
   try {
-    const dir = userDataDir();
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync(ledgerPath(), JSON.stringify(data) + '\n');
+    writeStateFile(ledgerPath(), JSON.stringify(data) + '\n');
   } catch {
     // statusline totals just stay stale until the next successful scan
   }

package/src/seed-rules.js

@@ -23,13 +23,14 @@
  *   { decided: { "<id>": { action: 'accepted' | 'skipped', at, scope? } } }
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { CLI_NAME } from './cli-name.js';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createHash } from 'node:crypto';
 import { userDataDir } from './paths.js';
 import { userLanguage } from './config.js';
+import { writeStateFile } from './state-file.js';
 import {
   addModelRule,
   composeRuleText,
@@ -62,9 +63,7 @@ export function loadSeedState(opts = {}) {
 }
 
 export function saveSeedState(state, opts = {}) {
-  const dir = userDataDir();
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(seedStatePath(opts), JSON.stringify(state, null, 2) + '\n');
+  writeStateFile(seedStatePath(opts), JSON.stringify(state, null, 2) + '\n');
 }
 
 /** Bundled tier-delegation presets (empty array when the file is unreadable). */

package/src/session-cache.js

@@ -31,7 +31,11 @@ const CACHE_PATH = join(userDataDir(), 'session-cache.json');
 // the users the flag exists for.
 // 3: version 2's serialize() never actually wrote `gatewayObserved`, so every
 // v2 entry lacks the flag it was bumped for. Bumped again to discard them.
-const CACHE_VERSION = 3;
+// 4: sessions that used more than one model carry `modelTotals`, and
+// zero-token `<synthetic>` stubs no longer count as requests. A v3 entry has
+// neither, so a mixed-model session cached before the bump would go on being
+// priced at one rate until its transcript changed.
+const CACHE_VERSION = 4;
 // Entries for transcripts this old are pruned on write. Keeps the file
 // bounded without an existence check per entry (which would cost the syscalls
 // the cache exists to avoid).
@@ -47,6 +51,7 @@ const PRUNE_AFTER_MS = 90 * 24 * 60 * 60 * 1000;
  * @property {object} totals
  * @property {number} maxContextPerRequest
  * @property {string} model
+ * @property {Record<string, object>} [modelTotals] totals per model, present only when more than one model spent tokens
  * @property {string} [projectDir]
  */
 
@@ -60,6 +65,7 @@ function serialize(session) {
     totals: session.totals,
     maxContextPerRequest: session.maxContextPerRequest,
     model: session.model,
+    ...(session.modelTotals ? { modelTotals: session.modelTotals } : {}),
     gatewayObserved: !!session.gatewayObserved,
   };
 }
@@ -75,6 +81,7 @@ function deserialize(stored, filePath, projectDir) {
     totals: stored.totals,
     maxContextPerRequest: stored.maxContextPerRequest || 0,
     model: stored.model || 'unknown',
+    ...(stored.modelTotals && typeof stored.modelTotals === 'object' ? { modelTotals: stored.modelTotals } : {}),
     gatewayObserved: !!stored.gatewayObserved,
   };
 }
@@ -132,6 +139,33 @@ export function putCached(cache, file, session) {
   };
 }
 
+/**
+ * A session re-aggregated from a fixed point in time (the start of the month),
+ * stored beside the full summary of the same file. One slot per entry: the
+ * point moves once a month, and an entry whose file changed is replaced whole
+ * by putCached, which drops the slot with it.
+ *
+ * @returns {SessionSummary|null} null when the file changed or the slot is for another point
+ */
+export function getCachedSince(cache, file, sinceMs) {
+  const e = cache.entries[file.path];
+  if (!e || e.mtimeMs !== file.mtime || e.size !== file.size || !e.t || e.t.since !== sinceMs || !e.t.s) return null;
+  try {
+    return deserialize(e.t.s, file.path, file.projectDir);
+  } catch (err) {
+    debug('session-cache:deserialize-since', err);
+    return null;
+  }
+}
+
+/** Returns false when there is no current entry for the file to attach the slot to. */
+export function putCachedSince(cache, file, sinceMs, session) {
+  const e = cache.entries[file.path];
+  if (!e || e.mtimeMs !== file.mtime || e.size !== file.size) return false;
+  e.t = { since: sinceMs, s: serialize(session) };
+  return true;
+}
+
 /**
  * Atomically persist the cache (tmp + rename), pruning long-dead transcripts.
  * Concurrent statusline refreshes are expected — rename is atomic on POSIX and

package/src/state-file.js

@@ -0,0 +1,43 @@
+/**
+ * Writes for the state files this tool owns: the rule registry, the savings
+ * ledger, the seed answers, the config.
+ *
+ * Their loaders read a file that fails to parse as empty state, which is the
+ * right thing for a report but meant the next save replaced the whole file
+ * with that empty state. The savings ledger is a lifetime total, so one
+ * half-written file (two statuslines saving at once, a full disk) erased it
+ * for good. Two things stop that here: the write goes to a temp file that is
+ * renamed over the target, so a reader never sees half a file, and a target
+ * that does not parse is copied aside before it is replaced.
+ */
+
+import { writeFileSync, renameSync, readFileSync, existsSync, mkdirSync, copyFileSync, rmSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+/** Where an unreadable state file is kept. One slot: the first copy holds the data worth recovering. */
+export const corruptCopyPath = (file) => `${file}.corrupt`;
+
+function keepUnreadable(file) {
+  let raw;
+  try { raw = readFileSync(file, 'utf8'); } catch { return; }
+  if (!raw.trim()) return;
+  try { JSON.parse(raw); return; } catch { /* does not parse: keep it */ }
+  try {
+    if (!existsSync(corruptCopyPath(file))) copyFileSync(file, corruptCopyPath(file));
+  } catch { /* best effort; the write below still goes ahead */ }
+}
+
+export function writeStateFile(file, text) {
+  mkdirSync(dirname(file), { recursive: true });
+  keepUnreadable(file);
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, text);
+    renameSync(tmp, file);
+  } catch {
+    // Windows refuses the rename while another process holds the target open.
+    // Writing in place is what this did before, and better than not saving.
+    try { rmSync(tmp, { force: true }); } catch { /* nothing to clean */ }
+    writeFileSync(file, text);
+  }
+}

package/src/stats.js

@@ -2,8 +2,12 @@
  * Aggregate session data into daily trends, TTL breakdown, and anomalies.
  */
 
+// The local calendar day. toISOString() gives the UTC day, which put a session
+// started at 08:00 in Seoul under the previous date, while the month total and
+// the history files next to this trend count in local time.
 function dateKey(date) {
-  return date.toISOString().slice(0, 10);
+  const pad = (n) => String(n).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
 }
 
 function hitRate(read, creation, input) {
@@ -167,9 +171,17 @@ function percentile(values, p) {
  * we're diagnosing — if we let them into the baseline they'd drag the baseline
  * toward themselves and never register as anomalies.
  */
+// A session this short is a one-shot call, not a conversation: `claude -p`
+// from a script, a hook, a batch job. They are tiny and can outnumber real
+// sessions a hundred to one (measured: 1,924 of 1,941 sessions in 7 days were
+// single-request), which put the "normal" p95 at 51k tokens and reported an
+// ordinary 13M session as 252x p95. The baseline describes conversations, so
+// only conversations go into it.
+export const BASELINE_MIN_REQUESTS = 3;
+
 export function computeBaseline(sessions, recentWindowMs = 24 * 60 * 60 * 1000) {
   const cutoff = Date.now() - recentWindowMs;
-  const older = sessions.filter((s) => s.startTime && s.startTime.getTime() < cutoff && s.requestCount > 0);
+  const older = sessions.filter((s) => s.startTime && s.startTime.getTime() < cutoff && s.requestCount >= BASELINE_MIN_REQUESTS);
   if (older.length < 3) {
     return { enough: false, sampleSize: older.length };
   }
@@ -295,15 +307,18 @@ export function detectSpikes(sessions, { recentHours = 24, multiplier = 3 } = {}
       ? m.totalInput / baseline.p95TotalInput
       : null;
 
-    const isSpike =
-      (ratio !== null && ratio >= multiplier) ||
-      m.maxContextPerRequest > 250_000;
+    const byRatio = ratio !== null && ratio >= multiplier;
+    const isSpike = byRatio || m.maxContextPerRequest > 250_000;
 
     if (!isSpike) continue;
 
     spikes.push({
       metrics: m,
       ratio,
+      // Which of the two tests it met. A session listed for one large request
+      // alone has a ratio too, and printing that ratio ("0.1x p95") as the
+      // reason would name the test it did not meet.
+      byRatio,
       issues: diagnoseSession(m, baseline),
     });
   }

package/src/statusline-base.js

@@ -0,0 +1,37 @@
+/**
+ * statusline-base — run the user's original statusline underneath ours.
+ *
+ * `sprag install` can merge with a statusline that was already configured: the
+ * original settings.json entry is saved as config `statuslineBase`, and each
+ * refresh prints that command's output first, sprag's lines after it.
+ * The statusline runs every few seconds, so nothing here may throw or stall.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { loadConfig } from './config.js';
+import { readStdinRaw } from './stdin-payload.js';
+
+// A light name check instead of importing installer.js (heavy for a hot path).
+// If the saved base were ourselves, running it would recurse without end.
+const OURS = /(^|[\s/\\])(sprag|claude-token-saver)(-cli)?(\.cmd|\.exe|\.ps1)?(\s|$)/i;
+
+// A wrapper script saved as the base may itself call `sprag --statusline`;
+// that inner run must not start the base again, so the child carries a marker.
+const NESTED = 'SPRAG_STATUSLINE_BASE';
+
+export function withBaseStatusline(output) {
+  if (process.env[NESTED] === '1') return output;
+  try {
+    const cmd = loadConfig().statuslineBase?.command;
+    if (typeof cmd !== 'string' || !cmd.trim() || OURS.test(cmd)) return output;
+    const opts = { input: readStdinRaw(), encoding: 'utf8', timeout: 1500, env: { ...process.env, [NESTED]: '1' } };
+    const r = process.platform === 'win32'
+      ? spawnSync(cmd, { ...opts, shell: true })
+      : spawnSync('/bin/sh', ['-c', cmd], opts);
+    if (r.error || r.status !== 0) return output;
+    const base = String(r.stdout || '').replace(/[\r\n]+$/, '');
+    return base ? `${base}\n${output}` : output;
+  } catch {
+    return output;
+  }
+}

package/src/stdin-payload.js

@@ -25,10 +25,27 @@ import { readFileSync } from 'node:fs';
  * Anthropic adds (e.g. a Sonnet-only weekly bucket) flows through without code
  * changes — known keys get curated labels, unknowns get derived ones.
  */
+// fd 0 can only be drained once. The statusline needs the payload twice: once
+// to parse it, and once to forward it verbatim to a wrapped base statusline
+// command, so the raw text is read on first use and cached for the process.
+let rawCache = null;
+
+/** The raw stdin text, read once. '' when stdin is a TTY or empty. */
+export function readStdinRaw() {
+  if (rawCache !== null) return rawCache;
+  if (process.stdin.isTTY) return (rawCache = '');
+  try {
+    rawCache = readFileSync(0, 'utf8') || '';
+  } catch {
+    rawCache = '';
+  }
+  return rawCache;
+}
+
 export function readStdinJson() {
   if (process.stdin.isTTY) return null;
   try {
-    const raw = readFileSync(0, 'utf8');
+    const raw = readStdinRaw();
     if (!raw || !raw.trim()) return null;
     return JSON.parse(raw);
   } catch {
@@ -59,11 +76,16 @@ export function extractCaps(stdinJson) {
     if (!value || typeof value !== 'object') continue;
     const usedPct = normalizePct(value.used_percentage);
     if (usedPct === null) continue;
-    const resetsAt = Number(value.resets_at);
+    // Same trap as the percentage: Number(null) is 0, and a reset "at 0" is
+    // 1970, which renders as a window that reset long ago. Only a positive
+    // number is a time.
+    const rawReset = typeof value.resets_at === 'string' && value.resets_at.trim() !== ''
+      ? Number(value.resets_at)
+      : value.resets_at;
     windows.push({
       key,
       usedPct,
-      resetsAt: Number.isFinite(resetsAt) ? resetsAt : null,
+      resetsAt: typeof rawReset === 'number' && Number.isFinite(rawReset) && rawReset > 0 ? rawReset : null,
     });
   }
   return windows.length ? { windows } : null;
@@ -84,10 +106,13 @@ export function extractCaps(stdinJson) {
 // model in use (Opus 4.7 vs 4.6 matters a lot for token budgeting).
 export function bedrockDisplayFromId(id) {
   if (typeof id !== 'string') return null;
-  const m = id.match(/claude[-_](opus|sonnet|haiku)[-_](\d+)[-_](\d+)/i);
+  // The minor version is one or two digits. An id with no minor goes straight
+  // to its date stamp (`claude-opus-4-20250514`), and reading that stamp as the
+  // minor printed "Opus 4.20250514".
+  const m = id.match(/claude[-_](opus|sonnet|haiku)[-_](\d+)(?:[-_](\d{1,2})(?!\d))?/i);
   if (!m) return null;
   const family = m[1].charAt(0).toUpperCase() + m[1].slice(1).toLowerCase();
-  return `${family} ${m[2]}.${m[3]}`;
+  return m[3] === undefined ? `${family} ${m[2]}` : `${family} ${m[2]}.${m[3]}`;
 }
 
 /**
@@ -108,6 +133,12 @@ export function extractContextUsage(stdinJson) {
   };
 }
 
+/** The session the payload belongs to, or null when the field is absent. */
+export function extractSessionId(stdinJson) {
+  const id = stdinJson?.session_id;
+  return typeof id === 'string' && id !== '' ? id : null;
+}
+
 export function extractModel(stdinJson) {
   if (!stdinJson || !stdinJson.model) return null;
   const m = stdinJson.model;