sprag-cli 3.67.0 → 3.69.0

package/src/formatters/table.js

@@ -181,17 +181,48 @@ function renderCapWarnSection(caps) {
   return lines;
 }
 
-export function formatReport({ summary: sum, trend, ttl, anomalies, cost, options, spikeReport, contextWindow, caps }, { color } = {}) {
+// Opens the report with what the tool is for, before any warning. A first run
+// (`npx sprag-cli`) has nothing installed yet, so the pitch has to be on screen.
+function renderRoutingSection(routing) {
+  if (!routing || typeof routing !== 'object') return [];
+  const lines = [];
+  lines.push(b(`  🔀 Routing — last ${routing.days}d`));
+  lines.push(`  ${'─'.repeat(50)}`);
+  const total = Number(routing.total) || 0;
+  if (total === 0) {
+    lines.push(`  No Claude Code sessions in the last ${routing.days} days to scan.`);
+    lines.push('');
+    return lines;
+  }
+  const easy = Number(routing.easy) || 0;
+  const pct = Math.round(easy / total * 100);
+  lines.push(`  ${easy} of ${total} requests (${pct}%) were lookups, checks or test runs a cheaper model handles.`);
+  const cands = Array.isArray(routing.candidates) ? routing.candidates : [];
+  if (cands.length === 0) {
+    lines.push('  No recurring delegable work yet (a pattern needs 3 repeats). Approved rules apply from the next session.');
+  } else {
+    for (const c of cands) {
+      lines.push(`  R${c.id}  "${c.labelEn || c.label}" ×${c.count}  →  delegate to ${c.agent}`);
+    }
+    lines.push(`  Approve one:  ${b(`${CLI_NAME} harness promote R${cands[0].id} --global`)}      All candidates:  ${b(`${CLI_NAME} route-scan`)}`);
+  }
+  lines.push('');
+  return lines;
+}
+
+export function formatReport({ summary: sum, trend, ttl, anomalies, cost, options, spikeReport, contextWindow, caps, routing }, { color } = {}) {
   colorOk = color ?? !process.env.NO_COLOR;
   const lines = [];
 
   // Header
   lines.push('');
-  lines.push(`  Claude Token Saver — Last ${options.days} day${options.days === 1 ? '' : 's'}`);
+  lines.push(`  Sprag — Last ${options.days} day${options.days === 1 ? '' : 's'}`);
   lines.push(`  (${CLI_NAME} v${options.version || ''})`.trimEnd());
   lines.push(`  ${'═'.repeat(50)}`);
   lines.push('');
 
+  lines.push(...renderRoutingSection(routing));
+
   // Cap warning leads — it's the most time-sensitive signal we can show.
   if (caps) {
     lines.push(...renderCapWarnSection(caps));

package/src/glyphs.js

@@ -53,6 +53,7 @@ const ICON = {
   month: '💵',
   ctx: '📦',
   saved: '💰',
+  used: '📊',
   reset: '🔄',
   // Gauge cells. Separate ticks rather than one continuous block: the bar is a
   // count of how much of a budget is gone, and ticks are countable where a solid
@@ -82,6 +83,7 @@ const NARROW = {
   month: '∑',     // a running total
   ctx: '◧',       // a box filling up
   saved: '✓',
+  used: '◩',      // a split square: what the spend is made of
   reset: '↩',     // the window turning over
   // Same segmented shape as the icon set, in the two glyphs this font has.
   // ▰▱ (U+25B0/25B1) are absent from JetBrains Mono; ■□ (U+25A0/25A1) are there.

package/src/installer.js

@@ -16,7 +16,8 @@
 import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync, rmSync, copyFileSync, renameSync, realpathSync, statSync } from 'node:fs';
 import { loadConfig, saveConfig } from './config.js';
 import { CLI_NAME, LEGACY_CLI_NAME } from './cli-name.js';
-import { join, dirname } from 'node:path';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { claudeUserDir, userDataDir } from './paths.js';
 
@@ -354,6 +355,65 @@ export function removeLegacyCommand() {
   return { path: file, action: 'removed' };
 }
 
+/**
+ * Whether a foreign statusLine command is a script that calls this tool, as
+ * opposed to someone else's statusline.
+ *
+ * Both look the same to isOurCommand(): the command is `bash ~/.claude/x.sh`,
+ * not `sprag ...`. The difference matters to the person reading the install
+ * output. "Existing statusLine command (bash ~/.claude/x.sh)" reads as another
+ * tool's slot, when the script is their own wrapper around `sprag --statusline`
+ * and replacing it with the direct command loses nothing. The usual reason such a
+ * wrapper exists is an `npx` fallback written before the package was renamed, and
+ * `npx claude-token-saver@latest` now resolves to the deprecated package, which
+ * stopped at 3.55.0: the line it draws is frozen there, quietly, while the
+ * statusline appears to work.
+ *
+ * Recognised commands are `bash <path>`, `sh <path>` and a bare path ending in
+ * `.sh`. The script must exist and its text must name this tool next to
+ * `--statusline`; a script that only mentions the tool (a comment, an unrelated
+ * `sprag` directory) is not a wrapper. Best-effort throughout: an unreadable or
+ * oversized file is simply "not a wrapper", and the caller falls back to the
+ * generic conflict message.
+ *
+ * @returns {{ script: string, name: string, deprecatedFallback: boolean } | null}
+ *   `script` is the path as written in the command, for display.
+ */
+function detectStatuslineWrapper(command) {
+  if (typeof command !== 'string') return null;
+  const m = command.trim().match(/^(?:(?:bash|sh)\s+)?("[^"]+"|'[^']+'|\S+)(?:\s.*)?$/);
+  if (!m) return null;
+  const hasShell = /^(?:bash|sh)\s/.test(command.trim());
+  const script = m[1].replace(/^["']|["']$/g, '');
+  if (!hasShell && !script.endsWith('.sh')) return null;
+  // Settings commands spell the home directory three ways; the shell Claude Code
+  // runs them in would expand all of them.
+  const home = homedir();
+  const onDisk = resolve(script
+    .replace(/^~(?=$|[/\\])/, home)
+    .replace(/^\$\{?HOME\}?(?=$|[/\\])/, home));
+  let body;
+  try {
+    const st = statSync(onDisk);
+    // A statusline wrapper is a few lines; anything this large is not one.
+    if (!st.isFile() || st.size > 256 * 1024) return null;
+    body = readFileSync(onDisk, 'utf8');
+  } catch {
+    return null;
+  }
+  if (!body.includes('--statusline')) return null;
+  const nameAt = (text) => {
+    const k = text.match(new RegExp(`${LEGACY_CLI}|${CLI}`));
+    return k ? k[0] : null;
+  };
+  // The name on the `--statusline` line is the one being called; failing that,
+  // whichever comes first (the command may sit in a variable set elsewhere).
+  const callLine = body.split('\n').find((l) => l.includes('--statusline') && nameAt(l));
+  const name = nameAt(callLine ?? body);
+  if (!name) return null;
+  return { script, name, deprecatedFallback: body.includes(`${LEGACY_CLI}@latest`) };
+}
+
 // Registers/repairs the Claude Code statusLine entry in ~/.claude/settings.json.
 // - No statusLine yet: insert ours with refreshInterval:STATUSLINE_REFRESH_INTERVAL.
 // - statusLine already points at sprag: ensure that refreshInterval
@@ -402,6 +462,22 @@ export function installStatusline({ force = false, merge = false } = {}) {
     // `conflict` lets the interactive install distinguish "someone else's
     // statusline is here" (worth asking about) from other skip reasons
     // (unreadable JSON), which a prompt cannot fix.
+    const wrapper = detectStatuslineWrapper(cur.command);
+    if (wrapper) {
+      // Still a conflict, for the same reason: the entry is not ours to rewrite
+      // unasked. Only the wording changes, to say what the entry is.
+      const fallback = wrapper.deprecatedFallback
+        ? ` (its npx fallback resolves to the deprecated ${LEGACY_CLI} package, last published as 3.55.0)`
+        : '';
+      return {
+        path: file,
+        action: 'skipped',
+        conflict: true,
+        wrapper: true,
+        existingCommand: cur.command,
+        reason: `existing statusLine wrapper script (${wrapper.script}) calls ${wrapper.name}; re-run with --force to replace it with \`${STATUSLINE_COMMAND}\`${fallback}`,
+      };
+    }
     return { path: file, action: 'skipped', conflict: true, existingCommand: cur.command, reason: `existing statusLine command (${cur.command}) — re-run with --force to overwrite` };
   }
   const base = cur;

package/src/model-alias.js

@@ -36,9 +36,9 @@
  * package is published to npm, so neither may live in the source.
  */
 
-import { readFileSync, mkdirSync, existsSync, createReadStream, statSync } from 'node:fs';
+import { readFileSync, mkdirSync, existsSync, statSync } from 'node:fs';
 import { readFile, readdir } from 'node:fs/promises';
-import { createInterface } from 'node:readline';
+import { transcriptLines } from './transcript-lines.js';
 import { join, dirname, basename } from 'node:path';
 import { userDataDir, claudeUserDir } from './paths.js';
 import { gatewayBase } from './gateway-auth.js';
@@ -416,49 +416,41 @@ export function voteRole(requested, declared, parentDeclared) {
 async function scanMainTranscript(path, votes, requestedByToolUse, agentTypeCache) {
   let sawGateway = false;
   let declared = null;
-  const rl = createInterface({
-    input: createReadStream(path, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-  try {
-    for await (const line of rl) {
-      if (!line.includes('arn:aws:bedrock:') && !line.includes('"Task"') && !line.includes('"Agent"')
-        && !line.includes('"identity"')) {
-        continue;
-      }
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (!declared && entry.isSidechain !== true) declared = declaredModelOf(entry);
-      const msg = entry.message;
-      if (!msg) continue;
-
-      // The session's own model: the parent side of the transcript.
-      if (msg.model && entry.isSidechain !== true) {
-        const pid = profileIdFrom(msg.model);
-        if (pid) {
-          sawGateway = true;
-          // Circumstantial: a subagent's records also land in the parent file
-          // without the flag often enough to outvote real evidence.
-          addVote(votes, pid, 'main', 'inferred');
-        }
+  for await (const line of transcriptLines(path)) {
+    if (!line.includes('arn:aws:bedrock:') && !line.includes('"Task"') && !line.includes('"Agent"')
+      && !line.includes('"identity"')) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!declared && entry.isSidechain !== true) declared = declaredModelOf(entry);
+    const msg = entry.message;
+    if (!msg) continue;
+
+    // The session's own model: the parent side of the transcript.
+    if (msg.model && entry.isSidechain !== true) {
+      const pid = profileIdFrom(msg.model);
+      if (pid) {
+        sawGateway = true;
+        // Circumstantial: a subagent's records also land in the parent file
+        // without the flag often enough to outvote real evidence.
+        addVote(votes, pid, 'main', 'inferred');
       }
+    }
 
-      if (!Array.isArray(msg.content)) continue;
-      for (const block of msg.content) {
-        if (!block || block.type !== 'tool_use') continue;
-        if (block.name !== 'Task' && block.name !== 'Agent') continue;
-        const input = block.input || {};
-        const role = roleFromModelParam(input.model)
-          || roleFromAgentType(input.subagent_type, agentTypeCache);
-        if (block.id && role) requestedByToolUse.set(block.id, role);
-      }
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (!block || block.type !== 'tool_use') continue;
+      if (block.name !== 'Task' && block.name !== 'Agent') continue;
+      const input = block.input || {};
+      const role = roleFromModelParam(input.model)
+        || roleFromAgentType(input.subagent_type, agentTypeCache);
+      if (block.id && role) requestedByToolUse.set(block.id, role);
     }
-  } finally {
-    rl.close();
   }
   return { sawGateway, declared };
 }
@@ -469,25 +461,18 @@ async function scanMainTranscript(path, votes, requestedByToolUse, agentTypeCach
  */
 async function subagentModelInfo(path) {
   let declared = null;
-  const rl = createInterface({
-    input: createReadStream(path, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-  try {
-    for await (const line of rl) {
-      if (!line.includes('arn:aws:bedrock:') && !line.includes('"identity"')) continue;
-      let entry;
-      try {
-        entry = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      declared ??= declaredModelOf(entry);
-      const pid = profileIdFrom(entry.message?.model);
-      if (pid) return { pid, declared };
+  // transcriptLines() closes the file on the early return below; see its header.
+  for await (const line of transcriptLines(path)) {
+    if (!line.includes('arn:aws:bedrock:') && !line.includes('"identity"')) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
     }
-  } finally {
-    rl.close();
+    declared ??= declaredModelOf(entry);
+    const pid = profileIdFrom(entry.message?.model);
+    if (pid) return { pid, declared };
   }
   return { pid: null, declared };
 }

package/src/model-rules.js

@@ -272,13 +272,23 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '  알려 주는 작업은 하위 티어가 안전하다. 검증 게이트가 품질 하한이 된다.',
     '  틀려도 조용한 작업(진단, 근본 원인 판정, 보안, 설계)은 티어를 내리지',
     '  않는다. 싼 모델은 결정을 옮겨 적을 뿐, 결정을 내리지 못한다.',
+    '- **effort**: 모델 티어와 다른 축이다. 설치된 서브에이전트는 검증 형태에 따라',
+    '  effort가 고정되어 있다. 명령 출력이나 파일 대조로 검증되는 위임(조회·명령',
+    '  실행·정형 변환을 맡는 haiku 에이전트)은 low, 확정된 설계를 테스트에 맞춰',
+    '  구현하는 위임(sonnet 워커)은 medium이다. 메인 세션의 effort는 바꾸지 않고,',
+    '  CLAUDE_CODE_EFFORT_LEVEL은 서브에이전트의 effort를 덮어쓰므로 설정하지 않는다.',
     '- **위임 배치**: 서브에이전트 비용의 지배 항은 생성이 아니라 컨텍스트',
     '  적재다. 같은 파일들을 읽어야 하는 작업 여러 개는 에이전트 하나에 묶어',
     '  보내고, 읽는 영역이 다른 작업만 나눈다.',
     implementationDelegationRule('claude', lang),
     '- **에스컬레이션**: 같은 에러 2회 반복, 답이 복수 후보로 갈림, 서브에이전트가',
-    '  질문을 멈추고 헛도는 징후가 보이면 즉시 인계한다. 대응 순서는',
-    '  ① 재지시 후 재시도 → ② 한 티어 상향 → ③ 메인 모델이 직접 수습.',
+    '  질문을 멈추고 헛도는 징후가 보이면 즉시 인계한다. 어느 축을 올릴지는 실패',
+    '  종류로 정한다. 파일을 읽지 않았거나 테스트를 돌리지 않았거나 상한에 걸려',
+    '  멈춘 누락형 실패는 같은 모델에서 effort를 한 단계 올려 한 번만 재시도하고,',
+    '  컨텍스트를 다 보고도 틀린 오판형 실패는 모델을 한 티어 올린다. 순서는',
+    '  ① 재지시 후 재시도(누락형이면 effort 한 단계 위) → ② 한 티어 상향(오판형)',
+    '  → ③ 메인 모델이 직접 수습. effort를 올릴 때는 에이전트 파일을 고치지 않고',
+    '  Agent 도구 호출의 effort 인자에 한 단계 위 값(low → medium → high)을 넘긴다.',
     '',
     '## Rules',
     '',
@@ -323,14 +333,25 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '  the verification gate is the quality floor. Never drop the tier on work',
     '  that fails silently (diagnosis, root-cause calls, security posture,',
     '  design). Cheap models transcribe decisions; they do not make them.',
+    '- **Effort**: a separate axis from the tier. The installed subagents pin it',
+    '  by how their work is verified: low where the check is command output or a',
+    '  file comparison (the haiku agents for lookups, command runs and mechanical',
+    '  conversion), medium where a fixed design is implemented against tests (the',
+    '  sonnet worker). Leave the main session\'s effort alone, and never set',
+    '  CLAUDE_CODE_EFFORT_LEVEL: it overrides every subagent\'s own value.',
     '- **Batching**: a subagent\'s dominant cost is context ingestion, not',
     '  generation. Bundle tasks that read the same files into one agent; split',
     '  only when the areas they read differ.',
     implementationDelegationRule('claude', lang),
     '- **Escalation**: hand off immediately on the same error twice, an answer',
     '  splitting into multiple candidates, or a subagent spinning without asking',
-    '  questions. Order: ① re-instruct and retry → ② move up one tier → ③ the',
-    '  main model takes over directly.',
+    '  questions. Which axis moves depends on the failure: an omission (a file',
+    '  not read, tests not run, a cap hit mid-task) retries once on the same',
+    '  model one effort step up; a wrong answer with the full context in hand',
+    '  moves up one tier. Order: ① re-instruct and retry (effort +1 on an',
+    '  omission) → ② move up one tier (on a wrong answer) → ③ the main model',
+    '  takes over directly. To raise effort, pass the next level (low → medium →',
+    '  high) in the Agent call\'s effort argument instead of editing the agent file.',
     '',
     '## Rules',
     '',

package/src/model-share.js

@@ -0,0 +1,136 @@
+/**
+ * Model share: how the spend since the routing counter's mark splits across
+ * model families, by cost. Feeds the statusline's bar and `sprag saved`'s table.
+ *
+ * "Same period" as `sprag saved`: the routing reset mark, or the start of the
+ * calendar month when nothing was ever reset, capped at 90 days of parsing.
+ */
+import { pricedParts, sessionCost } from './claude-price.js';
+import { modelFamily } from './savings-ledger.js';
+import { readResetMarks } from './saved-reset.cjs';
+import { RESET, RED, GREEN, YELLOW, CYAN, MAGENTA, GRAY } from './formatters/statusline.js';
+
+const DAY = 86400000;
+export const MAX_DAYS = 90;
+
+/**
+ * Split `slots` whole units across `values` in proportion, largest remainder
+ * first, so the parts always add up to exactly `slots`. Ties keep input order.
+ */
+export function roundShares(values, slots) {
+  const vs = (values || []).map((v) => (Number.isFinite(v) && v > 0 ? v : 0));
+  const total = vs.reduce((a, b) => a + b, 0);
+  if (total <= 0 || !(slots > 0)) return vs.map(() => 0);
+  const exact = vs.map((v) => (v / total) * slots);
+  const out = exact.map((x) => Math.floor(x + 1e-9));
+  let left = slots - out.reduce((a, b) => a + b, 0);
+  const order = exact
+    .map((x, i) => ({ i, frac: x - Math.floor(x + 1e-9) }))
+    .sort((a, b) => b.frac - a.frac || a.i - b.i);
+  for (let k = 0; left > 0 && order.length; k = (k + 1) % order.length, left--) out[order[k].i] += 1;
+  return out;
+}
+
+function rank(families) {
+  return families
+    .map((f, i) => ({ ...f, i }))
+    .sort((a, b) => b.usd - a.usd || a.i - b.i);
+}
+
+function toneOf(family) {
+  switch (family) {
+    case 'opus': return MAGENTA;
+    case 'sonnet': return CYAN;
+    case 'haiku': return GREEN;
+    case 'fable': return YELLOW;
+    case 'mythos': return RED;
+    default: return GRAY;
+  }
+}
+
+const FAMILY_NAMES = { opus: 'Opus', sonnet: 'Sonnet', haiku: 'Haiku', fable: 'Fable', mythos: 'Mythos' };
+
+/**
+ * Statusline legend, `● Opus 90%  ● Sonnet 10%`: a dot in the family's colour,
+ * the name, and a gray whole percent. Reads without a key, which the bar and
+ * letters did not. Without colour the dot carries nothing, so it is dropped.
+ * A family that spent money but rounds to 0% shows as `<1%`: dropping it made
+ * a model that had just been delegated to look unused.
+ */
+export function shareLegend(families, { color = true } = {}) {
+  const ranked = rank(families || []);
+  const pcts = roundShares(ranked.map((f) => f.usd), 100);
+  return ranked
+    .map((f, idx) => {
+      if (!(f.usd > 0)) return null;
+      const name = FAMILY_NAMES[f.family] || f.family;
+      const pct = pcts[idx] > 0 ? `${pcts[idx]}%` : '<1%';
+      return color
+        ? `${toneOf(f.family)}●${RESET} ${name} ${GRAY}${pct}${RESET}`
+        : `${name} ${pct}`;
+    })
+    .filter(Boolean)
+    .join('  ');
+}
+
+/** Cost per family over the given sessions, subagent runs split out. Pure. */
+export function computeModelShare(sessions, { env = process.env } = {}) {
+  const all = new Map();
+  const sub = new Map();
+  let unpriced = 0;
+  let totalUsd = 0;
+  let subUsd = 0;
+  for (const s of sessions || []) {
+    for (const part of pricedParts(s)) {
+      if (!part || !part.totals) continue;
+      let cost = null;
+      try { cost = sessionCost(part.totals, part.model, { env }); } catch { cost = null; }
+      if (!cost || !Number.isFinite(cost.actual)) { unpriced++; continue; }
+      const family = modelFamily(part.model);
+      all.set(family, (all.get(family) || 0) + cost.actual);
+      totalUsd += cost.actual;
+      if (!part.own) {
+        sub.set(family, (sub.get(family) || 0) + cost.actual);
+        subUsd += cost.actual;
+      }
+    }
+  }
+  const list = (m) => [...m.entries()]
+    .map(([family, usd]) => ({ family, usd, pct: totalUsd > 0 ? (usd / totalUsd) * 100 : 0 }))
+    .sort((a, b) => b.usd - a.usd);
+  if (!(totalUsd > 0)) {
+    return { totalUsd: 0, unpriced, families: [], subagent: { usd: 0, pct: 0, families: [] } };
+  }
+  return {
+    totalUsd,
+    unpriced,
+    families: list(all),
+    subagent: { usd: subUsd, pct: (subUsd / totalUsd) * 100, families: list(sub) },
+  };
+}
+
+/**
+ * Collect the sessions for the routing counter's period and compute the share.
+ * `monthSessions` (already parsed by the statusline) is reused when the period
+ * starts inside the month; otherwise, or when absent, the transcripts are parsed.
+ */
+export async function loadModelShare({ dir, env = process.env, projectFilter, now = Date.now(), monthSessions } = {}) {
+  const { parseAllSessions, sessionsSince } = await import('./parser.js');
+  const { monthStartMs } = await import('./month-spend.js');
+  const reset = readResetMarks(dir).routing;
+  const monthStart = monthStartMs(new Date(now));
+  let since = Number.isFinite(reset) && reset > 0 ? reset : monthStart;
+  let sinceKind = since === monthStart && !(Number.isFinite(reset) && reset > 0) ? 'month' : 'reset';
+  if (now - since > MAX_DAYS * DAY) {
+    since = now - MAX_DAYS * DAY;
+    sinceKind = 'capped';
+  }
+  let sessions;
+  if (monthSessions && since >= monthStart) {
+    sessions = await sessionsSince(monthSessions, since);
+  } else {
+    const days = Math.max(1, Math.ceil((now - since) / DAY));
+    sessions = await sessionsSince(await parseAllSessions({ days, projectFilter, sinceMs: since }), since);
+  }
+  return { ...computeModelShare(sessions, { env }), since, sinceKind };
+}

package/src/parser.js

@@ -1,6 +1,6 @@
-import { createReadStream, openSync, readSync, closeSync, fstatSync } from 'node:fs';
+import { openSync, readSync, closeSync, fstatSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
-import { createInterface } from 'node:readline';
+import { transcriptLines } from './transcript-lines.js';
 import { join, isAbsolute, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { loadCache, getCached, putCached, saveCache, getCachedSince, putCachedSince } from './session-cache.js';
@@ -33,12 +33,7 @@ export async function parseSessionFile(filePath) {
   let lastTimestamp = null;
   let gatewayObserved = false;
 
-  const rl = createInterface({
-    input: createReadStream(filePath, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
+  for await (const line of transcriptLines(filePath)) {
     let entry;
     try {
       entry = JSON.parse(line);
@@ -277,11 +272,7 @@ export async function getLastUserMessageTime(filePath) {
   const tail = lastUserTsFromTail(filePath);
   if (tail.found) return tail.ts ? new Date(tail.ts) : null;
   try {
-    const rl = createInterface({
-      input: createReadStream(filePath, { encoding: 'utf8' }),
-      crlfDelay: Infinity,
-    });
-    for await (const line of rl) {
+    for await (const line of transcriptLines(filePath)) {
       if (!line) continue;
       try {
         const entry = JSON.parse(line);

package/src/session-records.js

@@ -7,8 +7,7 @@
  * requestId (last-write-wins, matching parser.js).
  */
 
-import { createReadStream } from 'node:fs';
-import { createInterface } from 'node:readline';
+import { transcriptLines } from './transcript-lines.js';
 import { resolveModelAlias } from './model-alias.js';
 
 /**
@@ -94,12 +93,7 @@ export async function collectSessionRecords(filePath, { includeContent = true }
   let lastCwd = '';
   let lastRecord = null;
 
-  const rl = createInterface({
-    input: createReadStream(filePath, { encoding: 'utf8' }),
-    crlfDelay: Infinity,
-  });
-
-  for await (const line of rl) {
+  for await (const line of transcriptLines(filePath)) {
     let entry;
     try {
       entry = JSON.parse(line);

package/src/star-note.js

@@ -0,0 +1,62 @@
+/**
+ * star-note — a one-time "star the repo" ask in the statusline.
+ *
+ * The package is downloaded thousands of times a month and starred a handful
+ * of times: all of the value lands in the statusline, so users never see the
+ * repository. This asks once, at the moment the value is visible — when the
+ * savings sprag itself produced (routing + doc2md) first reach $10.
+ *
+ * Once, because a chip that keeps asking is an advertisement. For 24 hours,
+ * which is long enough to be seen across a day of sessions and short enough
+ * not to linger. CTS_NO_NOTE=1 suppresses it, the same opt-out as every
+ * other one-time note.
+ */
+
+import { createRequire } from 'node:module';
+import { delegationSavedTotals } from './savings-ledger.js';
+import { noteShownAt, markNoteShown } from './first-run-note.js';
+import { userDataDir } from './paths.js';
+import { debug } from './debug.js';
+
+const require = createRequire(import.meta.url);
+
+export const STAR_THRESHOLD_USD = 10;
+export const STAR_WINDOW_MS = 24 * 60 * 60 * 1000;
+export const STAR_URL = 'github.com/rootstudioyaml/sprag';
+
+/** Lifetime dollars saved by routing and doc2md; an unreadable ledger counts as 0. */
+export function toolSavedUsd(now = Date.now(), dir = userDataDir()) {
+  let total = 0;
+  try {
+    total += Number(delegationSavedTotals(now, dir).total) || 0;
+  } catch (e) {
+    debug('star-note:routing', e);
+  }
+  try {
+    total += Number(require('./doc2md-ledger.cjs').doc2mdSavedTotals(dir).total) || 0;
+  } catch (e) {
+    debug('star-note:doc2md', e);
+  }
+  return total;
+}
+
+/** `{ usd, shownAt }` while the chip should show, else null. Never throws. */
+export function readStarChip({ now = Date.now(), dir = userDataDir(), savedUsd } = {}) {
+  try {
+    if (process.env.CTS_NO_NOTE === '1') return null;
+    const shownAt = noteShownAt('star');
+    if (shownAt === null) {
+      const usd = savedUsd ?? toolSavedUsd(now, dir);
+      if (!(usd >= STAR_THRESHOLD_USD)) return null;
+      markNoteShown('star', now);
+      return { usd, shownAt: now };
+    }
+    if (now - shownAt < STAR_WINDOW_MS) {
+      return { usd: savedUsd ?? toolSavedUsd(now, dir), shownAt };
+    }
+    return null;
+  } catch (e) {
+    debug('star-note', e);
+    return null;
+  }
+}

package/src/statusline-base.js

@@ -9,7 +9,6 @@
 
 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.
@@ -19,12 +18,19 @@ const OURS = /(^|[\s/\\])(sprag|claude-token-saver)(-cli)?(\.cmd|\.exe|\.ps1)?(\
 // that inner run must not start the base again, so the child carries a marker.
 const NESTED = 'SPRAG_STATUSLINE_BASE';
 
-export function withBaseStatusline(output) {
+/**
+ * `input` is the payload Claude Code wrote on stdin, forwarded to the base
+ * verbatim; the caller passes the text it already read. This function must not
+ * read fd 0 itself: the statusline has drained it by now, and a process whose
+ * stdin is still open (the test runner on Windows keeps the pipe to each test
+ * file open) blocks in readFileSync(0) with no timeout at all.
+ */
+export function withBaseStatusline(output, { input = '' } = {}) {
   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 opts = { input, 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);

package/src/stdin-payload.js

@@ -109,7 +109,7 @@ export function bedrockDisplayFromId(id) {
   // 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);
+  const m = id.match(/claude[-_](opus|sonnet|haiku|fable|mythos)[-_](\d+)(?:[-_](\d{1,2})(?!\d))?/i);
   if (!m) return null;
   const family = m[1].charAt(0).toUpperCase() + m[1].slice(1).toLowerCase();
   return m[3] === undefined ? `${family} ${m[2]}` : `${family} ${m[2]}.${m[3]}`;