sprag-cli 3.64.0 → 3.65.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.64.0",
+  "version": "3.65.0",
   "description": "Lower your Claude Code bill without changing how you work: simple tasks go to cheaper models, documents go in as compact Markdown, and the statusline shows spend and savings live. Works with Codex too.",
   "type": "module",
   "bin": {

package/src/formatters/statusline.js

@@ -396,10 +396,16 @@ function buildRulesSeg(stats, c, g) {
 }
 
 /**
- * This session's subagent runs: `3 (haiku 2 · sonnet 1)`. Counts every
- * subagent the session started, not only the ones a routing rule sent, so it
- * answers "how much did this session fan out" rather than "how many rules
- * fired". Null when the session ran none, which is the common case.
+ * This session's subagent runs: `3 (haiku 2 · sonnet 1) spent $0.42`. Counts
+ * every subagent the session started, not only the ones a routing rule sent,
+ * so it answers "how much did this session fan out" rather than "how many
+ * rules fired", and what that fan-out cost. Null when the session ran none,
+ * which is the common case.
+ *
+ * The cost uses the routing headline's word, `spent`, and its shape: runs a
+ * gateway could not price are counted (`+1 unpriced`) rather than read as
+ * free, and a session whose every run went unpriced reads `n/a`. A summary
+ * without `usd` (an older caller) draws no cost at all.
  */
 function buildSessionDelegationSeg(sd, c, isIcon, verbose, g) {
   const total = Number(sd && sd.total) || 0;
@@ -411,7 +417,14 @@ function buildSessionDelegationSeg(sd, c, isIcon, verbose, g) {
     ? `${g.routing} ${verbose ? 'Subagents this session' : 'this session'}`
     : 'Subagents this session';
   const split = families.length ? ` ${c(GRAY)}(${families.join(' · ')})${c(RESET)}` : '';
-  return `${c(CYAN)}${label} ${total}${c(RESET)}${split}`;
+  const usd = Number(sd.usd);
+  const unpriced = Number(sd.unpriced) || 0;
+  let spent = '';
+  if (sd.usd != null && Number.isFinite(usd)) {
+    const amt = usd > 0 || unpriced === 0 ? formatMoney(usd) : 'n/a';
+    spent = ` ${c(GRAY)}spent ${amt}${unpriced > 0 ? ` +${unpriced} unpriced` : ''}${c(RESET)}`;
+  }
+  return `${c(CYAN)}${label} ${total}${c(RESET)}${split}${spent}`;
 }
 
 /**
@@ -634,9 +647,23 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     ? ` ${c(GRAY)}${verbose ? `last scan ${scanAge} ago` : `scan ${scanAge}`}${c(RESET)}`
     : '';
 
+  // What the same delegated runs cost on the models they ran on, read beside
+  // the saving so the reader sees what it was bought with: "saved $14.7 ·
+  // spent $5.2". Gray, since it is context for the saving rather than a result.
+  // Shown once any run carries a cost; runs whose event has none (recorded
+  // before costs were kept and not rescanned since, or unpriced) are counted
+  // instead of being read as free.
+  //   text:  "Routing saved $14.7 · spent $5.2 since 10/9"
+  //   icon:  "🔀 $14.7 · spent $5.2 (10/9~)"
+  const spentUsd = Number(totals && totals.spent) || 0;
+  const spentMissing = Number(totals && totals.spentMissing) || 0;
+  const spentTag = spentUsd > 0
+    ? ` ${c(GRAY)}· spent ${formatMoney(spentUsd)}${spentMissing > 0 ? ` +${spentMissing} unpriced` : ''}${c(RESET)}`
+    : '';
+
   const savedTone = delegationSaved < 0 ? RED : delegationSaved > 0 ? GREEN : GRAY;
   const savingsChip = delegationSaved !== 0 || routingSince
-    ? `${c(savedTone)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}${sinceInline(routingSince)}${scanTag}`
+    ? `${c(savedTone)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}${spentTag}${sinceInline(routingSince)}${scanTag}`
     : null;
   // The unresolved count stands in only while there are no savings to show, so
   // a dated zero keeps both: the reset and the dropped runs are separate facts.
@@ -707,8 +734,8 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // a row of rolling windows it read as a breakdown of whichever one it
   // touched. A single lifetime total makes the whole line one timeframe with
   // nothing to mismatch.
-  //   icon:  "🔀 Routing saved $9.8 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
-  //   text:  "Routing saved $9.8 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
+  //   icon:  "🔀 Routing saved $9.8 · spent $3.1 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
+  //   text:  "Routing saved $9.8 · spent $3.1 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
   let totalsLine = null;
   const totalsNum = Number(totals && totals.total);
   // A zero total gets its line only when a reset mark explains it; see the
@@ -737,7 +764,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     totalsLine =
       `${c(tone)}${c(BOLD)}${head}${c(RESET)} ` +
       `${c(tone)}${formatMoney(totalsNum)}${c(RESET)}` +
-      sinceWord(routingSince) + scanTag +
+      spentTag + sinceWord(routingSince) + scanTag +
       (pairText ? `  ${c(GRAY)}|${c(RESET)}  ${pairText}` : '');
   }
 

package/src/route-scan.js

@@ -374,7 +374,26 @@ export function worthDelegating(tier, rank) {
  */
 export function runSaving(run, mainModel) {
   if (!run.model || !mainModel) return null;
-  const totals = {
+  const totals = runTotals(run);
+  const actual = sessionCost(totals, run.model);
+  const counterfactual = sessionCost(totals, mainModel);
+  if (!actual || !counterfactual) return null;
+  return counterfactual.actual - actual.actual;
+}
+
+/**
+ * USD a delegated run cost on the model it ran on: the price side of
+ * runSaving, recorded beside the saving so the statusline can show what the
+ * saving was bought with. null when the model has no price.
+ */
+export function runCost(run) {
+  if (!run.model) return null;
+  const actual = sessionCost(runTotals(run), run.model);
+  return actual ? actual.actual : null;
+}
+
+function runTotals(run) {
+  return {
     input: run.input,
     cacheCreation: run.cacheCreation,
     cacheRead: run.cacheRead,
@@ -383,10 +402,6 @@ export function runSaving(run, mainModel) {
     output: run.out,
     ...(run.long ? { long: run.long } : {}),
   };
-  const actual = sessionCost(totals, run.model);
-  const counterfactual = sessionCost(totals, mainModel);
-  if (!actual || !counterfactual) return null;
-  return counterfactual.actual - actual.actual;
 }
 
 const clamp = (v, [lo, hi]) => Math.min(hi, Math.max(lo, v));
@@ -865,6 +880,7 @@ export async function runRouteScan({ days = 14 } = {}) {
         key: e.run.path,
         ts: e.run.endedAt ?? e.run.startedAt ?? Date.now(),
         usd,
+        cost: runCost(e.run),
         rule: rule.signature,
         from: baseline,
         to: e.run.model,

package/src/savings-ledger.js

@@ -10,10 +10,13 @@
  *
  * File: <userDataDir>/delegation-ledger.json
  *   { "version": 2,
- *     "events": { "<run path>": { "ts", "usd", "rule", "from", "to" } } }
+ *     "events": { "<run path>": { "ts", "usd", "cost", "rule", "from", "to" } } }
  *
  * `from`/`to` are the models the routing decision moved between, and `usd` is
- * the price difference between them for this run's tokens. Version 1 priced
+ * the price difference between them for this run's tokens. `cost` is what the
+ * run itself cost on the model it ran on, so the statusline can show what the
+ * saving was bought with. Events written before `cost` existed lack it until a
+ * scan that still covers the run fills it in. Version 1 priced
  * every downgraded subagent run against the session's priciest model, which
  * credited the tool for runs no rule of its own had routed; those events are
  * discarded rather than migrated, since the number they carry cannot be
@@ -81,11 +84,12 @@ export function loadLedger() {
 
 /**
  * Upsert saving events. `events` is an array of
- * { key, ts, usd, rule, from, to } where `key` is the run's transcript path
- * (unique per subagent run) and `from`/`to` name the models the routing
+ * { key, ts, usd, cost, rule, from, to } where `key` is the run's transcript
+ * path (unique per subagent run) and `from`/`to` name the models the routing
  * decision moved between. `usd` is signed: a run on a pricier model is a loss
  * and is recorded as a negative amount so it reduces the totals. Only
- * non-finite amounts (unpriced runs) are skipped.
+ * non-finite amounts (unpriced runs) are skipped. A non-finite `cost` is left
+ * out of the event while its saving is still recorded.
  */
 export function recordDelegationEvents(events) {
   if (!Array.isArray(events) || events.length === 0) return;
@@ -101,12 +105,16 @@ export function recordDelegationEvents(events) {
     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;
+    const cost = Number.isFinite(e.cost) ? roundUsd(e.cost) : undefined;
+    // An event recorded before `cost` existed compares unequal here, so the
+    // first scan that still covers the run fills its cost in.
+    if (prev && prev.ts === e.ts && prev.usd === usd && prev.cost === cost) continue;
     if (prevKey !== e.key) delete data.events[prevKey];
     keyOf.set(id, e.key);
     data.events[e.key] = {
       ts: e.ts,
       usd,
+      ...(cost !== undefined ? { cost } : {}),
       ...(e.rule ? { rule: e.rule } : {}),
       ...(e.from ? { from: e.from } : {}),
       ...(e.to ? { to: e.to } : {}),
@@ -143,13 +151,17 @@ export function modelFamily(model) {
  * lifetime rollup by family-level model change, priciest first. `now` is
  * injectable for tests. Never throws — an unreadable ledger yields zeros.
  *
+ * `spent` is the lifetime sum of what the same runs cost on the models they
+ * ran on, and `spentMissing` counts the runs whose event carries no `cost`
+ * (written before the field existed, or unpriced), which `spent` leaves out.
+ *
  * Events before the `routing` reset mark (`sprag saved reset`) are skipped
  * everywhere, and `since` reports the mark (null when never reset). `dir` is
  * the user data directory the mark is read from.
  */
 export function delegationSavedTotals(now = Date.now(), dir = userDataDir()) {
   const since = readResetMarks(dir).routing;
-  const empty = () => ({ week: 0, month: 0, total: 0, pairs: [], since });
+  const empty = () => ({ week: 0, month: 0, total: 0, spent: 0, spentMissing: 0, pairs: [], since });
   const totals = empty();
   const byPair = new Map();
   try {
@@ -158,6 +170,8 @@ export function delegationSavedTotals(now = Date.now(), dir = userDataDir()) {
       const usd = Number(e.usd);
       if (!Number.isFinite(usd)) continue;
       totals.total += usd;
+      if (Number.isFinite(e.cost)) totals.spent += e.cost;
+      else totals.spentMissing += 1;
       if (Number.isFinite(e.ts)) {
         if (now - e.ts <= WEEK_MS) totals.week += usd;
         if (now - e.ts <= MONTH_MS) totals.month += usd;

package/src/statusline-data.js

@@ -10,6 +10,7 @@
 import { resolve } from 'node:path';
 import { modelFamily } from './savings-ledger.js';
 import { loadModelRules } from './model-rules.js';
+import { sessionCostAcross } from './claude-price.js';
 
 /** Longest family name shown before it is cut. Keeps an opaque gateway id from taking the line. */
 const FAMILY_MAX = 14;
@@ -32,12 +33,17 @@ const shortFamily = (name) => (name.length > FAMILY_MAX ? `${name.slice(0, FAMIL
  * is rather than folding it into a neighbour; the name is shortened here so an
  * ARN cannot flood the line.
  *
+ * `usd` is what the runs cost, each priced at its own model by the same path
+ * the session's own cost takes (a gateway session from the gateway's table),
+ * and `unpriced` counts the priced parts that had no rate and were left out.
+ *
  * @param {Array} sessions parseAllSessions result
- * @param {{ transcriptPath?: string|null, sessionId?: string|null }} [ids]
- * @returns {{ total: number, families: Array<{ family: string, runs: number }> }|null}
+ * @param {{ transcriptPath?: string|null, sessionId?: string|null, env?: object }} [ids]
+ *   `env` decides the pricing path, as in sessionCost
+ * @returns {{ total: number, families: Array<{ family: string, runs: number }>, usd: number, unpriced: number }|null}
  *   null when the session cannot be found or ran no subagents
  */
-export function sessionSubagentSummary(sessions, { transcriptPath = null, sessionId = null } = {}) {
+export function sessionSubagentSummary(sessions, { transcriptPath = null, sessionId = null, env = process.env } = {}) {
   if (!Array.isArray(sessions) || (!transcriptPath && !sessionId)) return null;
   let hit = null;
   if (transcriptPath) {
@@ -62,7 +68,10 @@ export function sessionSubagentSummary(sessions, { transcriptPath = null, sessio
   const families = [...byFamily.entries()]
     .map(([family, n]) => ({ family, runs: n }))
     .sort((a, b) => b.runs - a.runs || a.family.localeCompare(b.family));
-  return { total: runs.length, families };
+  // A run is a session-shaped record (totals, model, modelTotals when it
+  // switched model), so it is priced the way a session is.
+  const cost = sessionCostAcross(runs, { env });
+  return { total: runs.length, families, usd: cost.actual, unpriced: cost.unpriced };
 }
 
 /**