sprag-cli 3.58.0 → 3.59.0

package/README.ko.md

@@ -46,7 +46,7 @@ npm i -g sprag-cli   # 예전 이름 claude-token-saver 와 같은 패키지입
    사용량 한도에 문제가 생기면 경고 칩이 줄 맨 앞에 나타납니다.
 
 ```
-🔀 Routing saved $44.67  |  opus→sonnet 59× $39.75 · opus→haiku 10× $4.92
+🔀 Routing saved $188  |  opus→sonnet 67× $93.4 · fable→sonnet 26× $83.7 · opus→haiku 25× $7.41 · fable→haiku 6× $3.73
 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 🅷 5/5 · 📦 Ctx 47% of 1M
 ```
 
@@ -74,7 +74,7 @@ Sprag 는 사용자가 지정한 모델을 바꾸지 않습니다. 이미 실행
 | 공개 벤치마크 정확도 | **59.1%** · 단일 최고 모델 57.9% | `▰▰▰▰▰▰▰▰▰▰▰▰` | [벤치마크](https://github.com/rootstudioyaml/sprag/blob/main/docs/BENCHMARK.md) |
 | 같은 문항 총비용 | **$268** · gpt-5 $388 · gemini-2.5-pro $734 | `▰▰▰▰▰▱▱▱▱▱▱▱` | [벤치마크](https://github.com/rootstudioyaml/sprag/blob/main/docs/BENCHMARK.md) |
 | 같은 문서들의 토큰 | **−95.9%** · 2,011,178 → 82,209 (12건) | `▰▱▱▱▱▱▱▱▱▱▱▱` | [doc2md](https://github.com/rootstudioyaml/sprag/blob/main/docs/DOC2MD.md) |
-| 위임 절감액 (원장) | **$44.67** · 위임 69건 | `▰▰▰▰▰▰▰▰▰▰▰▱` | `sprag route-scan savings` |
+| 위임 절감액 (원장) | **$188.27** · 위임 124건 | `▰▰▰▰▰▰▰▰▰▰▰▱` | `sprag route-scan savings` |
 | 같은 프롬프트를 저가 등급에 | **비용 24%** · 여덟 건 중 한 건이 더 틀림 | `▰▰▰▱▱▱▱▱▱▱▱▱` | [A/B 실측](#같은-프롬프트를-저가-등급에-돌리면) |
 
 앞의 두 줄은 다음 반박에 답하려고 있습니다. 저가 모델에 일을 내려보내면 정확도가 떨어질 것이라는 반박입니다. 공개 데이터에서는 떨어지지 않았습니다. 같은 판정 기준을 라우터로 만들어 11,696건에 적용했더니 정확도가 단일 최고 모델보다 1.2%p 높고 비용은 3분의 1이었습니다. 정확도가 오른 까닭은 간단합니다. 모든 유형에서 1등인 모델은 없기 때문입니다.
@@ -83,15 +83,20 @@ LLMRouterBench(Findings of ACL 2026)에서 오프라인으로 측정했습니다
 
 다만 이렇게 확인한 것은 판정 기준이고, sprag 가 실제로 쓰는 모델 조합은 아닙니다. 데이터셋에 Claude 계열이 없어서 deepseek-v3 와 qwen3-235b, gpt-5 가 각각 저가·중간·상위 등급을 대신했습니다.
 
-뒤의 세 줄은 이 머신에서 실제로 쌓인 기록이라 시간이 지나면 값이 커집니다. 아래 수치는 2026-09-18 에 뽑았습니다.
+뒤의 세 줄은 이 머신에서 실제로 쌓인 기록이라 시간이 지나면 값이 커집니다. 위임 수치는 2026-10-09 에, 문서 변환 수치는 2026-09-18 에 뽑았습니다. 모델 이름은 각 실행이 실제로 쓴 모델입니다.
 
 ### 지금 이 머신의 최근 30일
 
 ```
-🔀 라우팅 절감 누적 $44.67        (최근 7일 $23.21 · 30일 $42.73)
-
-   opus-5 → sonnet-5     59회    $39.75   ▰▰▰▰▰▰▰▰▰▰▱▱
-   opus-5 → haiku-4.5    10회     $4.92   ▰▱▱▱▱▱▱▱▱▱▱▱
+🔀 라우팅 절감 누적 $188.27        (최근 7일 $13.31 · 30일 $150.64)
+
+   fable-5 → sonnet-5      24회    $81.19   ▰▰▰▰▰▰▰▰▰▰▰▰
+   opus-5  → sonnet-5      54회    $68.85   ▰▰▰▰▰▰▰▰▰▰▱▱
+   opus-5  → sonnet-5.5    13회    $24.58   ▰▰▰▰▱▱▱▱▱▱▱▱
+   opus-5  → haiku-4.5     25회     $7.41   ▰▱▱▱▱▱▱▱▱▱▱▱
+   fable-5 → haiku-4.5      5회     $3.22   ▰▱▱▱▱▱▱▱▱▱▱▱
+   fable-5 → sonnet-5.5     2회     $2.51   ▰▱▱▱▱▱▱▱▱▱▱▱
+   fable-5 → haiku-5.5      1회      $0.51   ▰▱▱▱▱▱▱▱▱▱▱▱
 ```
 
 | 함께 측정한 값 | 30일 기준 | |
@@ -122,8 +127,8 @@ LLMRouterBench(Findings of ACL 2026)에서 오프라인으로 측정했습니다
 ## statusline 한 줄로 보는 상태
 
 ```
-🔀 라우팅 절감 $44.67  |  opus→sonnet 59회 $39.75 · opus→haiku 10회 $4.92
-🚨 5H ▰▰▰▰▰▰▰▰▰▰▰▱ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 5 · 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 📅 weekly ▰▰▰▰▰▱▱▱▱▱▱▱ 38% · 💵 Sep $42 · 📦 Ctx 47% of 1M
+🔀 라우팅 절감 $188  |  opus→sonnet 67회 $93.4 · fable→sonnet 26회 $83.7 · opus→haiku 25회 $7.41 · fable→haiku 6회 $3.73
+🚨 5H ▰▰▰▰▰▰▰▰▰▰▰▱ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 5.5 · 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 📅 weekly ▰▰▰▰▰▱▱▱▱▱▱▱ 38% · 💵 Sep $42 · 📦 Ctx 47% of 1M
 ```
 
 문제가 생기면 경고 칩이 줄 맨 앞으로 옵니다. `🚨 5H/7D NN%`, `⚠ Ctx 500k+`, `⚠ Cache miss`, `⚠ Input spike`, `⚠ Output heavy`, `⚠ Call surge`, `⚠ Rebuild churn`, `⚠ 5m TTL` 여덟 가지입니다. 칩 문구를 Claude 에게 그대로 붙여 넣으면 Skill 이 원인 코드와 조치 순서를 꺼내 줍니다. 세그먼트마다 무엇을 뜻하는지는 [statusline 문서](https://github.com/rootstudioyaml/sprag/blob/main/docs/STATUSLINE.ko.md)에 정리했습니다.
@@ -151,7 +156,7 @@ JetBrains IDE 내장 터미널에서는 이모지 대신 한 칸 글리프로
 | 측정 항목 | 값 | 표본 | 기간 |
 |---|---|---|---|
 | 문서 변환 | 2,011,178 → 82,209 토큰 | 12건 (xlsx·pptx·pdf) | 2026-09-18 까지 누적 |
-| 위임 실행 | $44.67 절감 · 건당 $0.65 | 69건 | 2026-09-18 까지 누적 |
+| 위임 실행 | $188.27 절감 · 건당 $1.52 | 124건 | 2026-10-09 까지 누적 |
 | 래칫 규칙 누적 | 37건 (글로벌 30 · 프로젝트 7) | 저장소 4곳 | 2026-05-08 ~ 09-16 |
 
 래칫 규칙과 위임 규칙은 늘어나는 방식이 다릅니다. 래칫 규칙은 사람이 저지른 실수에서 나오므로 계속 늘어납니다. 위임 규칙은 멈춥니다. 기준이 알아보는 작업 유형이 정해져 있어서, 유형마다 규칙이 하나 생기면 더 승격할 것이 없습니다.

package/README.md

@@ -60,7 +60,7 @@ npm i -g sprag-cli   # Claude Code, plus Codex when it is installed
    needs attention:
 
 ```
-🔀 Routing saved $44.67  |  opus→sonnet 59× $39.75 · opus→haiku 10× $4.92
+🔀 Routing saved $188  |  opus→sonnet 67× $93.4 · fable→sonnet 26× $83.7 · opus→haiku 25× $7.41 · fable→haiku 6× $3.73
 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 🅷 5/5 · 📦 Ctx 47% of 1M
 ```
 
@@ -95,7 +95,7 @@ holding.
 | Public benchmark accuracy | **59.1%** vs 57.9% best single model | `▰▰▰▰▰▰▰▰▰▰▰▰` | [benchmark](https://github.com/rootstudioyaml/sprag/blob/main/docs/BENCHMARK.md) |
 | Cost for the same queries | **$268** vs gpt-5 $388, gemini-2.5-pro $734 | `▰▰▰▰▰▱▱▱▱▱▱▱` | [benchmark](https://github.com/rootstudioyaml/sprag/blob/main/docs/BENCHMARK.md) |
 | Tokens for the same documents | **−95.9%**, 2,011,178 → 82,209 over 12 files | `▰▱▱▱▱▱▱▱▱▱▱▱` | [doc2md](https://github.com/rootstudioyaml/sprag/blob/main/docs/DOC2MD.md) |
-| Delegation savings, from the ledger | **$44.67** over 69 delegated runs | `▰▰▰▰▰▰▰▰▰▰▰▱` | `sprag route-scan savings` |
+| Delegation savings, from the ledger | **$188.27** over 124 delegated runs | `▰▰▰▰▰▰▰▰▰▰▰▱` | `sprag route-scan savings` |
 | Cheap tier on the same prompts | **24% of the cost**, one answer worse out of eight | `▰▰▰▱▱▱▱▱▱▱▱▱` | [A/B run](#the-cheap-tier-on-the-same-prompts) |
 
 The first two rows answer the objection that comes up first: that moving work to
@@ -111,16 +111,22 @@ it again and you get the same figures. It validates the criteria, not sprag's ow
 routing: the dataset has no Claude models, so deepseek-v3, qwen3-235b and gpt-5
 stood in for cheap, mid and flagship.
 
-The last three rows are ledgers on this machine. They grow as it runs. These were
-read on 2026-09-18.
+The last three rows are ledgers on this machine. They grow as it runs. The
+routing figures were read on 2026-10-09, the document figures on 2026-09-18.
+Model names are the ones each run actually used.
 
 ### Current, on one machine, last 30 days
 
 ```
-🔀 Routing saved $44.67 total        (last 7d $23.21 · last 30d $42.73)
-
-   opus-5 → sonnet-5     59 runs    $39.75   ▰▰▰▰▰▰▰▰▰▰▱▱
-   opus-5 → haiku-4.5    10 runs     $4.92   ▰▱▱▱▱▱▱▱▱▱▱▱
+🔀 Routing saved $188.27 total        (last 7d $13.31 · last 30d $150.64)
+
+   fable-5 → sonnet-5      24 runs    $81.19   ▰▰▰▰▰▰▰▰▰▰▰▰
+   opus-5  → sonnet-5      54 runs    $68.85   ▰▰▰▰▰▰▰▰▰▰▱▱
+   opus-5  → sonnet-5.5    13 runs    $24.58   ▰▰▰▰▱▱▱▱▱▱▱▱
+   opus-5  → haiku-4.5     25 runs     $7.41   ▰▱▱▱▱▱▱▱▱▱▱▱
+   fable-5 → haiku-4.5      5 runs     $3.22   ▰▱▱▱▱▱▱▱▱▱▱▱
+   fable-5 → sonnet-5.5     2 runs     $2.51   ▰▱▱▱▱▱▱▱▱▱▱▱
+   fable-5 → haiku-5.5      1 run      $0.51   ▰▱▱▱▱▱▱▱▱▱▱▱
 ```
 
 | Also measured | Over 30 days | |
@@ -155,8 +161,8 @@ arrives as fewer round-trips rather than as cheaper ones.
 ## The statusline in one line
 
 ```
-🔀 Routing saved $44.67  |  opus→sonnet 59× $39.75 · opus→haiku 10× $4.92
-🚨 5H ▰▰▰▰▰▰▰▰▰▰▰▱ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 5 · 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 📅 weekly ▰▰▰▰▰▱▱▱▱▱▱▱ 38% · 💵 Sep $42 · 📦 Ctx 47% of 1M
+🔀 Routing saved $188  |  opus→sonnet 67× $93.4 · fable→sonnet 26× $83.7 · opus→haiku 25× $7.41 · fable→haiku 6× $3.73
+🚨 5H ▰▰▰▰▰▰▰▰▰▰▰▱ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 5.5 · 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 📅 weekly ▰▰▰▰▰▱▱▱▱▱▱▱ 38% · 💵 Sep $42 · 📦 Ctx 47% of 1M
 ```
 
 When something is wrong the warning chip leads the line: `🚨 5H/7D NN%`, `⚠ Ctx 500k+`, `⚠ Cache miss`, `⚠ Input spike`, `⚠ Output heavy`, `⚠ Call surge`, `⚠ Rebuild churn`, `⚠ 5m TTL`. Paste the chip text into Claude and the Skill names the root-cause code and the fix. Every segment is explained in [the statusline reference](https://github.com/rootstudioyaml/sprag/blob/main/docs/STATUSLINE.md).
@@ -194,7 +200,7 @@ surfaces, and never send design or diagnosis.
 | Measured | Value | Sample | Window |
 |---|---|---|---|
 | Documents converted | 2,011,178 → 82,209 tokens | 12 files (xlsx, pptx, pdf) | to 2026-09-18 |
-| Delegated runs | $44.67 saved, $0.65 per run | 69 runs | to 2026-09-18 |
+| Delegated runs | $188.27 saved, $1.52 per run | 124 runs | to 2026-10-09 |
 | Ratchet rules accumulated | 37 (30 global, 7 per-project) | 4 repositories | 2026-05-08 to 09-16 |
 
 The two counts grow differently. Ratchet rules come from mistakes a person made,

package/bin/cli.js

@@ -106,7 +106,7 @@ function tableColor() {
 const KNOWN_SUBCOMMANDS = new Set([
   'last', 'brief', 'history', 'handoff', 'install', 'uninstall', 'mode', 'korean', 'cohesion',
   'doc2md', 'delegate', 'harness', 'route-scan', 'compact-window', 'update-check', 'upgrade',
-  'seed', 'litellm-budget', 'profile-map', 'feedback',
+  'seed', 'litellm-budget', 'profile-map', 'feedback', 'saved',
 ]);
 
 const USAGE = `sprag — Claude Code and Codex agent harness
@@ -148,6 +148,7 @@ Usage:
   sprag doc2md on|off|<file>     convert documents to Markdown before the model reads them
   sprag delegate on|off|status   add bounds and context to Task/Agent delegation prompts
   sprag compact-window     audit or pin autoCompactWindow for 1M sessions
+  sprag saved [reset|undo] show, reset or restore the saved-money counters (--agent codex for Codex)
   sprag litellm-budget     LiteLLM gateway key budget and spend
   sprag update-check       is a newer version out?
   sprag brief --hook       internal: the UserPromptSubmit hook entry point
@@ -305,6 +306,12 @@ async function main() {
     return (await import('../src/commands/seed.js')).run({ args, hasFlag });
   }
 
+  // Subcommand: saved — stopwatch reset for the lifetime "saved" counters.
+  //   sprag saved | saved reset [routing|doc2md|all] | saved undo
+  if (args[0] === 'saved') {
+    return (await import('../src/commands/saved.js')).run({ args, hasFlag });
+  }
+
   // Subcommand: harness — manage the project's CLAUDE.md harness rules.
   //   sprag harness init       # write CLAUDE.md (5 sections) + ratchet.md
   //   sprag harness uninit     # remove harness block from CLAUDE.md (backup kept)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.58.0",
+  "version": "3.59.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/agents.js

@@ -45,22 +45,29 @@ export function agentExists(name, root = process.cwd()) {
 
 /**
  * Korean phrase for a delegation target, e.g.
- *   agent present → `haiku-explore(model: haiku)`
+ *   agent present → `haiku-explore(model 인자 생략)`
  *   agent absent  → `model: haiku`
+ *
+ * A named agent carries its model in its own definition, and the Agent tool's
+ * `model` argument overrides that definition. The old phrase
+ * `haiku-explore(model: haiku)` read as "pass model: haiku", and Claude Code
+ * resolves the bare `haiku` alias to an older Haiku than a definition pinned to
+ * a full id (claude-haiku-5-5), so following the rule undid the pin. The phrase
+ * now says to leave the argument out.
  */
 export function agentPhrase(name, { model, root } = {}) {
   const tier = model || AGENT_MODEL[name] || 'haiku';
-  return agentExists(name, root) ? `${name}(model: ${tier})` : `model: ${tier}`;
+  return agentExists(name, root) ? `${name}(model 인자 생략)` : `model: ${tier}`;
 }
 
 /**
  * English phrase, including the article, e.g.
- *   agent present → `the haiku-explore (model: haiku) subagent`
+ *   agent present → `the haiku-explore subagent (omit the model argument)`
  *   agent absent  → `a model: haiku subagent`
  */
 export function agentPhraseEn(name, { model, root } = {}) {
   const tier = model || AGENT_MODEL[name] || 'haiku';
   return agentExists(name, root)
-    ? `the ${name} (model: ${tier}) subagent`
+    ? `the ${name} subagent (omit the model argument)`
     : `a model: ${tier} subagent`;
 }

package/src/codex-doc2md-ledger.js

@@ -1,8 +1,9 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync, realpathSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync, realpathSync, statSync } from 'node:fs';
 import { extname, join, resolve } from 'node:path';
 import { codexUserDir } from './agent.js';
 import { userDataDir } from './paths.js';
+import { readResetMarks, isBeforeReset } from './saved-reset.cjs';
 
 const hash = (value) => createHash('sha256').update(value).digest('hex');
 const ledgerDir = ({ home = codexUserDir(), dir = userDataDir() } = {}) => join(dir, 'codex-doc2md', hash(resolve(home)));
@@ -26,13 +27,17 @@ export function recordCodexDocument(source, result, opts) {
   } catch { /* Accounting must not prevent document conversion. */ }
 }
 
+// Records carry no timestamp field, so the reset mark is compared with the
+// file's mtime. A source converted again rewrites its record and counts as new.
 export function codexDocumentTotals(opts) {
-  const total = { docs: 0, byExt: [], scope: 'codex-total' };
+  const since = readResetMarks(opts?.dir ?? userDataDir())['codex-docs'];
+  const total = { docs: 0, byExt: [], scope: 'codex-total', since };
   const byExt = new Map();
   try {
     const dir = ledgerDir(opts);
     for (const file of readdirSync(dir).filter((name) => /^[a-f0-9]{64}\.json$/.test(name))) {
       try {
+        if (since !== null && isBeforeReset(statSync(join(dir, file)).mtimeMs, since)) continue;
         const event = JSON.parse(readFileSync(join(dir, file), 'utf8'));
         if (event?.version !== 1 || !['pdf', 'pptx', 'xlsx', 'xls', 'docx', 'fig'].includes(event.ext)) continue;
         total.docs++;

package/src/codex-ledger.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { userDataDir } from './paths.js';
 import { roundUsd } from './savings-ledger.js';
+import { readResetMarks, isBeforeReset } from './saved-reset.cjs';
 import { discoverCodexSessionFiles, parseCodexTurns } from './codex-parser.js';
 import { codexRunCost, codexPriceBook, readCodexPrices } from './codex-cache-policy.js';
 
@@ -262,10 +263,15 @@ export async function refreshCodexLedger({ dir = userDataDir(), home, now = Date
   return ledger;
 }
 
-/** Signed totals over priced runs; unpriced runs are counted, never summed as zero. */
+/**
+ * Signed totals over priced runs; unpriced runs are counted, never summed as zero.
+ * Runs before the `codex-routing` reset mark are left out of every figure,
+ * `runs` and `priced` included; `since` reports the mark.
+ */
 export function codexRoutingSavedTotals({ dir = userDataDir(), now = Date.now() } = {}) {
-  const events = Object.values(loadCodexLedger({ dir }).events);
-  const totals = { week: 0, month: 0, total: 0, runs: events.length, priced: 0 };
+  const since = readResetMarks(dir)['codex-routing'];
+  const events = Object.values(loadCodexLedger({ dir }).events).filter((e) => !isBeforeReset(e.ts, since));
+  const totals = { week: 0, month: 0, total: 0, runs: events.length, priced: 0, since };
   for (const e of events) {
     if (!Number.isFinite(e.usd)) continue;
     totals.priced++;

package/src/commands/codex.js

@@ -23,6 +23,7 @@ Usage: sprag <command> --agent codex [options]
   brief [on|off|status]          Current warnings or prompt-briefing preference
   last / history                Context/rate-limit warnings and handoffs; --days, --session, --project
   handoff [--cwd path]           Write Git state and Codex usage to HANDOFF-*.md
+  saved [reset|undo]             Show, reset or restore the saved-money counters
   delegate on|off|status         Native model routing and SubagentStart guidance
   delegate model <model>         Default target for spawns without an explicit model
   delegate rules                Codex-only category rules; add/rm with explicit scope
@@ -144,6 +145,7 @@ export async function run({ args, version }) {
     return;
   }
   if (cmd === 'delegate') return (await import('./codex-delegate.js')).run({ args, getArg, hasFlag, root });
+  if (cmd === 'saved') return (await import('./saved.js')).run({ args, hasFlag, agent: 'codex' });
   if (cmd === 'seed') return (await import('./seed.js')).run({ args, hasFlag, agent: 'codex', root });
   if (cmd === 'route-scan') {
     const rs = await import('../codex-route-scan.js');

package/src/commands/route-scan.js

@@ -56,9 +56,22 @@ export async function run({ args, hasFlag, numArg }) {
     // which model actually ran it.
     if (args[1] === 'savings') {
       const { loadLedger, delegationSavedTotals } = await import('../savings-ledger.js');
+      // Runs from before `sprag saved reset` are kept in the ledger but not listed.
+      const { readResetMarks, isBeforeReset } = await import('../saved-reset.cjs');
+      const { userDataDir } = await import('../paths.js');
+      const since = readResetMarks(userDataDir()).routing;
       const events = Object.entries(loadLedger().events)
         .map(([key, e]) => ({ key, ...e }))
+        .filter((e) => !isBeforeReset(e.ts, since))
         .sort((a, b) => b.ts - a.ts);
+      if (events.length === 0 && since !== null) {
+        // After a reset an empty list is the expected state, not a setup gap.
+        const at = new Date(since).toLocaleString(lang === 'ko' ? 'ko-KR' : 'en-US');
+        console.log(lang === 'ko'
+          ? `${at}에 카운터를 초기화한 뒤로 기록된 라우팅 절감이 아직 없습니다. 되돌리려면 \`sprag saved undo\` 를 실행하십시오.`
+          : `No routing savings recorded since the counter was reset at ${at}. Run \`sprag saved undo\` to restore it.`);
+        return;
+      }
       if (events.length === 0) {
         console.log(lang === 'ko'
           ? '기록된 라우팅 절감 없음. 승격된 룰이 실제로 위임을 일으킨 뒤 `route-scan --refresh` 를 돌리면 채워집니다.'
@@ -72,6 +85,12 @@ export async function run({ args, hasFlag, numArg }) {
       console.log(lang === 'ko'
         ? `🔀 라우팅 절감 누적 ${money(t.total)}  (최근 7일 ${money(t.week)} · 30일 ${money(t.month)})`
         : `🔀 Routing saved, lifetime ${money(t.total)}  (last 7d ${money(t.week)} · 30d ${money(t.month)})`);
+      if (since !== null) {
+        const at = new Date(since).toLocaleString(lang === 'ko' ? 'ko-KR' : 'en-US');
+        console.log(lang === 'ko'
+          ? `  ${at}에 카운터를 초기화했습니다. 이후 기록만 집계합니다.`
+          : `  Counter reset at ${at}; only later runs are counted.`);
+      }
 
       // Per model-pair rollup first: the "what moved where" question is what
       // this view exists to answer, and it is easier to read than the log.

package/src/commands/saved.js

@@ -0,0 +1,115 @@
+/**
+ * Subcommand: saved — a stopwatch reset for the lifetime "saved" counters.
+ *
+ *   sprag saved                              # totals since the last reset
+ *   sprag saved reset [routing|doc2md|all]   # start counting from now
+ *   sprag saved undo                         # put the previous counters back
+ *   (add --agent codex for the Codex counters: codex-routing, codex-docs)
+ *
+ * Nothing is deleted. A reset only records a timestamp, and the totals count
+ * events from that moment on; see src/saved-reset.cjs.
+ */
+
+const SCOPE_SETS = {
+  claude: ['routing', 'doc2md'],
+  codex: ['codex-routing', 'codex-docs'],
+};
+
+/** Totals since each scope's mark: { usd } for money counters, { docs } for the Codex document counter. */
+async function currentTotals(scope, dir) {
+  if (scope === 'routing') {
+    const { delegationSavedTotals } = await import('../savings-ledger.js');
+    return { usd: delegationSavedTotals(Date.now(), dir).total };
+  }
+  if (scope === 'doc2md') {
+    const { doc2mdSavedTotals } = await import('../doc2md-ledger.cjs');
+    return { usd: doc2mdSavedTotals(dir).total };
+  }
+  if (scope === 'codex-routing') {
+    const { codexRoutingSavedTotals } = await import('../codex-ledger.js');
+    return { usd: codexRoutingSavedTotals({ dir }).total };
+  }
+  const { codexDocumentTotals } = await import('../codex-doc2md-ledger.js');
+  return { docs: codexDocumentTotals({ dir }).docs };
+}
+
+export async function run({ args, hasFlag, agent = 'claude', dir: dirArg }) {
+  const { userLanguage } = await import('../config.js');
+  const { userDataDir } = await import('../paths.js');
+  const { readResetMarks, resetSaved, undoReset } = await import('../saved-reset.cjs');
+  const ko = userLanguage() === 'ko';
+  const dir = dirArg || userDataDir();
+  const scopes = SCOPE_SETS[agent === 'codex' ? 'codex' : 'claude'];
+  const suffix = agent === 'codex' ? ' --agent codex' : '';
+
+  const money = (v) => (v < 0 ? `-$${(-v).toFixed(2)}` : `$${v.toFixed(2)}`);
+  const fmtTotal = (t) => (t.docs !== undefined ? (ko ? `${t.docs}건` : `${t.docs} doc(s)`) : money(t.usd));
+  const fmtTime = (ms) => new Date(ms).toLocaleString(ko ? 'ko-KR' : 'en-US');
+  const label = (scope) => ({
+    routing: ko ? '라우팅 절감' : 'Routing saved',
+    doc2md: ko ? '문서 변환 절감' : 'Document conversion saved',
+    'codex-routing': ko ? 'Codex 라우팅 절감' : 'Codex routing saved',
+    'codex-docs': ko ? 'Codex 문서 변환' : 'Codex documents converted',
+  })[scope];
+
+  const sub = args[1];
+
+  if (sub === undefined) {
+    const marks = readResetMarks(dir);
+    for (const s of scopes) {
+      const t = await currentTotals(s, dir);
+      const since = marks[s] === null
+        ? (ko ? '초기화한 적 없음' : 'not reset')
+        : (ko ? `${fmtTime(marks[s])} 이후` : `since ${fmtTime(marks[s])}`);
+      console.log(`${label(s)}: ${fmtTotal(t)} (${since})`);
+    }
+    return;
+  }
+
+  if (sub === 'reset') {
+    const arg = args[2] || 'all';
+    const base = agent === 'codex' ? { routing: 'codex-routing', doc2md: 'codex-docs' } : { routing: 'routing', doc2md: 'doc2md' };
+    let targets;
+    if (arg === 'all') targets = scopes;
+    else if (scopes.includes(arg)) targets = [arg];
+    else if (base[arg]) targets = [base[arg]];
+    else {
+      console.error(ko
+        ? `알 수 없는 범위입니다: ${arg}. 사용할 수 있는 범위는 ${scopes.join(', ')}, all 입니다.`
+        : `Unknown scope: ${arg}. Valid scopes are ${scopes.join(', ')}, all.`);
+      process.exit(1);
+    }
+    const before = {};
+    for (const s of targets) before[s] = await currentTotals(s, dir);
+    resetSaved(targets, { dir });
+    for (const s of targets) {
+      console.log(ko
+        ? `${label(s)} 카운터를 0으로 초기화했습니다. 이전 합계는 ${fmtTotal(before[s])}입니다.`
+        : `Reset the ${label(s)} counter to zero. The previous total was ${fmtTotal(before[s])}.`);
+    }
+    console.log(ko
+      ? `원장 기록은 지우지 않았습니다. \`sprag saved undo${suffix}\`로 되돌릴 수 있습니다.`
+      : `No ledger data was deleted. Run \`sprag saved undo${suffix}\` to restore the previous counters.`);
+    return;
+  }
+
+  if (sub === 'undo') {
+    const undone = undoReset({ dir });
+    if (!undone) {
+      console.log(ko ? '되돌릴 초기화 기록이 없습니다.' : 'There is no reset to undo.');
+      return;
+    }
+    for (const s of undone.scopes) {
+      const t = await currentTotals(s, dir);
+      console.log(ko
+        ? `${label(s)} 카운터를 되돌렸습니다. 현재 합계는 ${fmtTotal(t)}입니다.`
+        : `Restored the ${label(s)} counter. The total is now ${fmtTotal(t)}.`);
+    }
+    return;
+  }
+
+  console.error(ko
+    ? `알 수 없는 하위 명령입니다: ${sub}. 사용법은 sprag saved [reset|undo] 입니다.`
+    : `Unknown subcommand: ${sub}. Usage: sprag saved [reset|undo].`);
+  process.exit(1);
+}

package/src/cost.js

@@ -1,13 +1,29 @@
 /**
  * Cost impact estimation based on Anthropic pricing.
- * Source: https://docs.claude.com/en/docs/about-claude/pricing
- * Prices per million tokens (USD). Updated 2026-04 for Opus 4.7 release.
+ * Source: https://platform.claude.com/docs/en/about-claude/pricing
+ * Prices per million tokens (USD). Updated 2026-10 for Fable 5.1, Opus 5.5,
+ * Sonnet 5 / 5.5 and Haiku 5.5 (checked against the pricing page 2026-10-09).
  *
  * Note: Opus 4.5/4.6/4.7 use reduced pricing ($5/$25) vs. older Opus 4/4.1 ($15/$75).
  * Cache writes are now tracked separately for 5m and 1h TTLs, each with their own rate.
  */
 
+// Haiku 5.5 charges a request whose prompt (input + cache writes + cache
+// reads) exceeds this many tokens at the higher 'claude-haiku-5-5-long' rates.
+// Each request is priced on its own, so callers accumulate such requests into
+// `totals.long` (see parser.js) rather than relying on session-wide sums.
+export const LONG_PROMPT_THRESHOLD = 100_000;
+
 const PRICING = {
+  // Fable 5.1 / Mythos 5.1 — same prices as Fable 5 except cache reads, which
+  // drop to $0.25.
+  'claude-fable-5-1': {
+    input: 10.0,
+    cacheWrite5m: 12.5,
+    cacheWrite1h: 20.0,
+    cacheRead: 0.25,
+    output: 50.0,
+  },
   // Fable 5 / Mythos 5 — premium tier above Opus ($10/$50). Cache write
   // rates follow the standard multipliers (1.25x input for 5m, 2x for 1h),
   // cache read is 0.1x input.
@@ -18,6 +34,14 @@ const PRICING = {
     cacheRead: 1.0,
     output: 50.0,
   },
+  // Opus 5.5 — cheaper than the Opus 4.5-5 tier below.
+  'claude-opus-5-5': {
+    input: 4.0,
+    cacheWrite5m: 5.0,
+    cacheWrite1h: 8.0,
+    cacheRead: 0.2,
+    output: 20.0,
+  },
   // Opus 4.5+ (new pricing tier — includes 4.5, 4.6, 4.7, 4.8, and future)
   'claude-opus-new': {
     input: 5.0,
@@ -34,6 +58,23 @@ const PRICING = {
     cacheRead: 1.5,
     output: 75.0,
   },
+  // Sonnet 5 — standard price is $2/$10. The rise to $3/$15 planned for
+  // 2026-09-01 was cancelled, so this is not an introductory rate.
+  'claude-sonnet-5': {
+    input: 2.0,
+    cacheWrite5m: 2.5,
+    cacheWrite1h: 4.0,
+    cacheRead: 0.2,
+    output: 10.0,
+  },
+  // Sonnet 5.5 — same as Sonnet 5 except cache reads at $0.10.
+  'claude-sonnet-5-5': {
+    input: 2.0,
+    cacheWrite5m: 2.5,
+    cacheWrite1h: 4.0,
+    cacheRead: 0.1,
+    output: 10.0,
+  },
   // Sonnet 4 / 4.5 / 4.6 / 3.7
   'claude-sonnet': {
     input: 3.0,
@@ -42,6 +83,23 @@ const PRICING = {
     cacheRead: 0.3,
     output: 15.0,
   },
+  // Haiku 5.5, prompt <= LONG_PROMPT_THRESHOLD tokens.
+  'claude-haiku-5-5': {
+    input: 0.1,
+    cacheWrite5m: 0.125,
+    cacheWrite1h: 0.2,
+    cacheRead: 0.01,
+    output: 0.5,
+  },
+  // Haiku 5.5, prompt > LONG_PROMPT_THRESHOLD tokens. Not returned by
+  // detectPricingTier: estimateCost applies it to `totals.long` only.
+  'claude-haiku-5-5-long': {
+    input: 0.5,
+    cacheWrite5m: 0.625,
+    cacheWrite1h: 1.0,
+    cacheRead: 0.05,
+    output: 2.5,
+  },
   // Haiku 4.5
   'claude-haiku-4-5': {
     input: 1.0,
@@ -72,16 +130,23 @@ const PRICING = {
  * Detect pricing tier from Claude model identifier.
  * Examples: 'claude-opus-4-7', 'claude-sonnet-4-5', 'claude-haiku-4-5'.
  */
-function detectPricingTier(model) {
+export function detectPricingTier(model) {
   if (!model) return 'claude-sonnet';
   const m = model.toLowerCase();
 
   // Fable 5 / Mythos 5 — must be checked before the generic fallback:
   // without this, 'claude-fable-5' fell through to the Sonnet tier and
   // under-estimated costs ~3x ($3/$15 vs the real $10/$50).
-  if (m.includes('fable') || m.includes('mythos')) return 'claude-fable-5';
+  if (m.includes('fable') || m.includes('mythos')) {
+    // `(?!\d)` keeps a date suffix (`fable-5-20261001`) from reading as 5.1.
+    if (/(fable|mythos)[-_.]?5[-_.]1(?!\d)/.test(m)) return 'claude-fable-5-1';
+    return 'claude-fable-5';
+  }
 
   if (m.includes('opus')) {
+    // 5.5 first: `opus-5-5` would otherwise match the generic 5+ pattern, and
+    // `(?!\d)` keeps `opus-5-20260101` (Opus 5 with a date) out of 5.5.
+    if (/opus[-_.]?5[-_.]5(?!\d)/.test(m)) return 'claude-opus-5-5';
     // Opus 4.5, 4.6, 4.7, and future 5+ use the new reduced pricing.
     if (/opus[-_.]?4[-_.]?[5-9]\b/.test(m)) return 'claude-opus-new';
     if (/opus[-_.]?[5-9]/.test(m)) return 'claude-opus-new';
@@ -90,6 +155,7 @@ function detectPricingTier(model) {
   }
 
   if (m.includes('haiku')) {
+    if (/haiku[-_.]?5[-_.]5(?!\d)/.test(m)) return 'claude-haiku-5-5';
     if (/haiku[-_.]?4[-_.]?5/.test(m)) return 'claude-haiku-4-5';
     // The 3.x ids put the version first (`claude-3-5-haiku-20241022`,
     // `claude-3-haiku-20240307`), so both orders are matched. With only the
@@ -99,6 +165,13 @@ function detectPricingTier(model) {
     return 'claude-haiku-4-5';
   }
 
+  if (m.includes('sonnet')) {
+    if (/sonnet[-_.]?5[-_.]5(?!\d)/.test(m)) return 'claude-sonnet-5-5';
+    // Sonnet 5 incl. date-suffixed ids; the 3.x/4.x ids never put a 5 right
+    // after the family name (`claude-3-5-sonnet-2024…` has it before).
+    if (/sonnet[-_.]?5(?!\d)/.test(m)) return 'claude-sonnet-5';
+  }
+
   // Sonnet (default fallback): 3.7, 4, 4.5, 4.6 all share the same pricing.
   return 'claude-sonnet';
 }
@@ -112,9 +185,14 @@ function detectPricingTier(model) {
  */
 const TIER_RANK = {
   'claude-fable-5': 3,
+  'claude-fable-5-1': 3,
+  'claude-opus-5-5': 2,
   'claude-opus-legacy': 2,
   'claude-opus-new': 2,
   'claude-sonnet': 1,
+  'claude-sonnet-5': 1,
+  'claude-sonnet-5-5': 1,
+  'claude-haiku-5-5': 0,
   'claude-haiku-4-5': 0,
   'claude-haiku-3-5': 0,
   'claude-haiku-3': 0,
@@ -203,8 +281,54 @@ function tokensToMillions(n) {
 export function estimateCost(totals, model, { price } = {}) {
   if (price) return estimateCostAtPrice(totals, price);
   const tier = detectPricingTier(model);
-  const p = PRICING[tier];
 
+  // Haiku 5.5 prices each request by its own prompt length, so the long-prompt
+  // part (`totals.long`, same shape) is priced at the long rates and the rest
+  // at the short rates. Every other tier ignores `long`.
+  let c;
+  if (tier === 'claude-haiku-5-5' && totals.long) {
+    const short = subtractTotals(totals, totals.long);
+    const a = priceTotals(short, PRICING[tier]);
+    const b = priceTotals(totals.long, PRICING['claude-haiku-5-5-long']);
+    c = {
+      actual: a.actual + b.actual,
+      noCacheCost: a.noCacheCost + b.noCacheCost,
+      scenario5mCost: a.scenario5mCost + b.scenario5mCost,
+      write1h: a.write1h + b.write1h,
+    };
+  } else {
+    c = priceTotals(totals, PRICING[tier]);
+  }
+  const { actual, noCacheCost, scenario5mCost, write1h } = c;
+
+  return {
+    tier,
+    actual: round(actual),
+    noCacheCost: round(noCacheCost),
+    savings: round(noCacheCost - actual),
+    savingsRate: noCacheCost > 0 ? (noCacheCost - actual) / noCacheCost : 0,
+    scenario5mCost: round(scenario5mCost),
+    extraCostIf5m: round(scenario5mCost - actual),
+    // The row asks a counterfactual: what would dropping to 5m-only cost you?
+    // With no 1h writes there is nothing to lose, and the arithmetically
+    // honest `+$0` it printed read as "5m-only is free" — the opposite of the
+    // truth for a gateway user already confined to 5m. The display layer has
+    // to change the question rather than the number.
+    extraCostIf5mApplicable: write1h > 0,
+  };
+}
+
+const TOTAL_FIELDS = ['input', 'cacheCreation', 'cacheRead', 'ephemeral5m', 'ephemeral1h', 'output'];
+
+/** totals - part, field by field (clamped at 0), dropping the `long` key. */
+function subtractTotals(totals, part) {
+  const out = {};
+  for (const f of TOTAL_FIELDS) out[f] = Math.max(0, (totals[f] ?? 0) - (part[f] ?? 0));
+  return out;
+}
+
+/** Unrounded cost figures for one set of totals at one rate card. */
+function priceTotals(totals, p) {
   // Prefer explicit 5m/1h split when available; fall back to cacheCreation at 5m rate
   // (conservative — 5m is cheaper than 1h).
   const write5m = totals.ephemeral5m ?? 0;
@@ -235,21 +359,7 @@ export function estimateCost(totals, model, { price } = {}) {
     tokensToMillions(Math.max(0, totals.cacheRead - extra5mCreation)) * p.cacheRead +
     tokensToMillions(totals.output) * p.output;
 
-  return {
-    tier,
-    actual: round(actual),
-    noCacheCost: round(noCacheCost),
-    savings: round(noCacheCost - actual),
-    savingsRate: noCacheCost > 0 ? (noCacheCost - actual) / noCacheCost : 0,
-    scenario5mCost: round(scenario5mCost),
-    extraCostIf5m: round(scenario5mCost - actual),
-    // The row asks a counterfactual: what would dropping to 5m-only cost you?
-    // With no 1h writes there is nothing to lose, and the arithmetically
-    // honest `+$0` it printed read as "5m-only is free" — the opposite of the
-    // truth for a gateway user already confined to 5m. The display layer has
-    // to change the question rather than the number.
-    extraCostIf5mApplicable: write1h > 0,
-  };
+  return { actual, noCacheCost, scenario5mCost, write1h };
 }
 
 /**

package/src/doc2md-ledger.cjs

@@ -69,6 +69,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { readResetMarks, isBeforeReset } = require('./saved-reset.cjs');
 
 const WEEK_MS = 7 * 24 * 3600 * 1000;
 const MONTH_MS = 30 * 24 * 3600 * 1000;
@@ -185,13 +186,18 @@ function recordConversion(userDataDir, event) {
  * the lifetime rollup per format, priciest first, then most-converted. Never
  * throws; an unreadable ledger yields zeros, and the statusline hides the
  * chip on a zero.
+ *
+ * Events before the `doc2md` reset mark (`sprag saved reset`) are skipped in
+ * every figure, and `since` reports the mark (null when never reset).
  */
 function doc2mdSavedTotals(userDataDir, now = Date.now()) {
-  const empty = () => ({ week: 0, month: 0, total: 0, docs: 0, tokens: 0, byExt: [] });
+  const since = readResetMarks(userDataDir).doc2md;
+  const empty = () => ({ week: 0, month: 0, total: 0, docs: 0, tokens: 0, byExt: [], since });
   const totals = empty();
   const byExt = new Map();
   try {
     for (const e of Object.values(loadLedger(userDataDir).events)) {
+      if (isBeforeReset(e.ts, since)) continue;
       const usd = Number(e.usd) || 0;
       totals.total += usd;
       totals.docs += 1;

package/src/parser.js

@@ -5,6 +5,7 @@ import { join, isAbsolute, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { loadCache, getCached, putCached, saveCache, getCachedSince, putCachedSince } from './session-cache.js';
 import { resolveModelAlias, isGatewayModelId } from './model-alias.js';
+import { LONG_PROMPT_THRESHOLD } from './cost.js';
 
 const CLAUDE_DIR = join(homedir(), '.claude', 'projects');
 
@@ -135,6 +136,20 @@ function addRequest(acc, r) {
   acc.ephemeral5m += r.ephemeral5mTokens;
   acc.ephemeral1h += r.ephemeral1hTokens;
   acc.output += r.outputTokens;
+  // Haiku 5.5 bills a request whose prompt exceeds LONG_PROMPT_THRESHOLD at
+  // higher rates, per request. The sums above lose that, so such requests are
+  // also accumulated into `long` (same shape). The key only appears once a long
+  // request exists, which keeps the usual totals shape unchanged.
+  if (r.inputTokens + r.cacheCreationTokens + r.cacheReadTokens > LONG_PROMPT_THRESHOLD) {
+    if (!acc.long) acc.long = emptyTotals();
+    const l = acc.long;
+    l.input += r.inputTokens;
+    l.cacheCreation += r.cacheCreationTokens;
+    l.cacheRead += r.cacheReadTokens;
+    l.ephemeral5m += r.ephemeral5mTokens;
+    l.ephemeral1h += r.ephemeral1hTokens;
+    l.output += r.outputTokens;
+  }
 }
 
 /**

package/src/route-scan.js

@@ -366,6 +366,7 @@ export function runSaving(run, mainModel) {
     ephemeral5m: run.ephemeral5m,
     ephemeral1h: run.ephemeral1h,
     output: run.out,
+    ...(run.long ? { long: run.long } : {}),
   };
   const actual = sessionCost(totals, run.model);
   const counterfactual = sessionCost(totals, mainModel);

package/src/saved-reset.cjs

@@ -0,0 +1,118 @@
+/**
+ * saved-reset — a stopwatch reset for the lifetime "saved" counters.
+ *
+ * The ledgers are append-only evidence, so a reset must not delete anything.
+ * Instead this file records one timestamp per counter ("mark"), and every
+ * totals function counts only events at or after its mark. Undo pops the
+ * latest reset and puts the previous marks back, so a reset is always
+ * reversible and the underlying ledger data is never touched.
+ *
+ * File: <userDataDir>/saved-reset.json
+ *   { "version": 1,
+ *     "marks": { "routing", "doc2md", "codex-routing", "codex-docs" },  // ms | null
+ *     "history": [ { "at", "scopes": [...], "prev": { "<scope>": ms | null } } ] }
+ *
+ * CJS because doc2md-ledger.cjs reads it; ESM code imports it the same way.
+ * Every caller passes the data directory, so tests can point at a temp dir.
+ *
+ * Best-effort like every other state file here: a missing or unreadable file
+ * reads as "never reset", so a broken marker can only over-count, never hide
+ * events.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const VERSION = 1;
+const SCOPES = ['routing', 'doc2md', 'codex-routing', 'codex-docs'];
+/** Cap on remembered resets, so the file cannot grow without bound. */
+const MAX_HISTORY = 50;
+
+const emptyMarks = () => Object.fromEntries(SCOPES.map((s) => [s, null]));
+
+function resetPath(dir) {
+  return path.join(dir, 'saved-reset.json');
+}
+
+const markOrNull = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+
+function readState(dir) {
+  try {
+    const data = JSON.parse(fs.readFileSync(resetPath(dir), 'utf8'));
+    if (!data || typeof data !== 'object' || data.version !== VERSION) return { marks: emptyMarks(), history: [] };
+    const marks = emptyMarks();
+    for (const s of SCOPES) marks[s] = markOrNull(data.marks && data.marks[s]);
+    const history = Array.isArray(data.history)
+      ? data.history.filter((h) => h && Array.isArray(h.scopes) && h.prev && typeof h.prev === 'object')
+      : [];
+    return { marks, history };
+  } catch {
+    return { marks: emptyMarks(), history: [] };
+  }
+}
+
+/** Atomic write: a temp file renamed over the target, so a reader never sees half a file. */
+function writeState(dir, state) {
+  const file = resetPath(dir);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  const text = JSON.stringify({ version: VERSION, marks: state.marks, history: state.history }) + '\n';
+  try {
+    fs.writeFileSync(tmp, text);
+    fs.renameSync(tmp, file);
+  } catch {
+    try { fs.rmSync(tmp, { force: true }); } catch { /* nothing to clean */ }
+    fs.writeFileSync(file, text);
+  }
+}
+
+/** Current marks. Never throws; a missing or corrupt file means no reset. */
+function readResetMarks(dir) {
+  return readState(dir).marks;
+}
+
+/**
+ * Reset the given scopes to `now`. Returns the new marks. Unknown scopes are
+ * ignored; the caller validates user input.
+ */
+function resetSaved(scopes, { dir, now = Date.now() } = {}) {
+  const state = readState(dir);
+  const valid = [...new Set(scopes)].filter((s) => SCOPES.includes(s));
+  if (valid.length === 0) return state.marks;
+  const prev = {};
+  for (const s of valid) {
+    prev[s] = state.marks[s];
+    state.marks[s] = now;
+  }
+  state.history.push({ at: now, scopes: valid, prev });
+  if (state.history.length > MAX_HISTORY) state.history.splice(0, state.history.length - MAX_HISTORY);
+  writeState(dir, state);
+  return state.marks;
+}
+
+/**
+ * Undo the latest reset. Returns { scopes, marks } with the restored marks,
+ * or null when there is nothing to undo.
+ */
+function undoReset({ dir } = {}) {
+  const state = readState(dir);
+  const last = state.history.pop();
+  if (!last) return null;
+  for (const s of last.scopes) {
+    if (SCOPES.includes(s)) state.marks[s] = markOrNull(last.prev[s]);
+  }
+  writeState(dir, state);
+  return { scopes: last.scopes, marks: state.marks };
+}
+
+/**
+ * True when an event at `ts` is excluded by `mark`: a mark exists and the
+ * event is older than it. An event with no usable timestamp cannot be shown
+ * to postdate the reset, so it is excluded too.
+ */
+function isBeforeReset(ts, mark) {
+  if (mark === null || mark === undefined) return false;
+  return !Number.isFinite(ts) || ts < mark;
+}
+
+module.exports = { SCOPES, resetPath, readResetMarks, resetSaved, undoReset, isBeforeReset };

package/src/savings-ledger.js

@@ -26,6 +26,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { userDataDir } from './paths.js';
 import { writeStateFile } from './state-file.js';
+import { readResetMarks, isBeforeReset } from './saved-reset.cjs';
 
 const WEEK_MS = 7 * 24 * 3600 * 1000;
 const MONTH_MS = 30 * 24 * 3600 * 1000;
@@ -140,13 +141,19 @@ export function modelFamily(model) {
  * Rolling totals: last 7 days, last 30 days, and lifetime, plus `pairs` — the
  * lifetime rollup by family-level model change, priciest first. `now` is
  * injectable for tests. Never throws — an unreadable ledger yields zeros.
+ *
+ * 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()) {
-  const empty = () => ({ week: 0, month: 0, total: 0, pairs: [] });
+export function delegationSavedTotals(now = Date.now(), dir = userDataDir()) {
+  const since = readResetMarks(dir).routing;
+  const empty = () => ({ week: 0, month: 0, total: 0, pairs: [], since });
   const totals = empty();
   const byPair = new Map();
   try {
     for (const e of Object.values(loadLedger().events)) {
+      if (isBeforeReset(e.ts, since)) continue;
       const usd = Number(e.usd);
       if (!Number.isFinite(usd)) continue;
       totals.total += usd;

package/src/session-cache.js

@@ -35,7 +35,11 @@ const CACHE_PATH = join(userDataDir(), 'session-cache.json');
 // 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;
+// 5: totals (and each modelTotals entry) may carry `long`, the part of the
+// tokens from requests whose prompt exceeds 100k, which Haiku 5.5 prices at a
+// higher rate. A v4 entry lacks it, so a Haiku 5.5 session cached before the
+// bump would keep being priced at the short rate until its transcript changed.
+const CACHE_VERSION = 5;
 // 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).

package/src/stats.js

@@ -10,6 +10,15 @@ function dateKey(date) {
   return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
 }
 
+// Sum a session's optional `long` sub-totals (requests whose prompt exceeds
+// 100k tokens; see parser.js) into an aggregate, creating it on first use.
+function addLong(acc, totals) {
+  const l = totals.long;
+  if (!l) return;
+  const a = (acc.long ||= { input: 0, cacheCreation: 0, cacheRead: 0, ephemeral5m: 0, ephemeral1h: 0, output: 0 });
+  for (const k of Object.keys(a)) a[k] += l[k] || 0;
+}
+
 function hitRate(read, creation, input) {
   const total = read + creation + input;
   return total > 0 ? read / total : 0;
@@ -43,6 +52,7 @@ export function dailyTrend(sessions) {
     d.cacheRead += s.totals.cacheRead;
     d.ephemeral5m += s.totals.ephemeral5m;
     d.ephemeral1h += s.totals.ephemeral1h;
+    addLong(d, s.totals);
     d.output += s.totals.output;
     d.apiCalls += s.requestCount;
     d.sessions += 1;
@@ -377,6 +387,7 @@ export function summary(sessions) {
       acc.cacheRead += s.totals.cacheRead;
       acc.ephemeral5m += s.totals.ephemeral5m;
       acc.ephemeral1h += s.totals.ephemeral1h;
+      addLong(acc, s.totals);
       acc.output += s.totals.output;
       acc.apiCalls += s.requestCount;
       acc.sessions += 1;

package/src/subagent-records.js

@@ -30,6 +30,7 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { join, dirname, basename } from 'node:path';
 import { collectSessionRecords, normalizeModelId } from './session-records.js';
+import { LONG_PROMPT_THRESHOLD } from './cost.js';
 
 /** Directory holding a session's subagent transcripts (may not exist). */
 export function subagentDirFor(sessionPath) {
@@ -98,6 +99,17 @@ export async function collectSubagentRun(jsonlPath) {
     run.cacheRead += r.cache_read_tokens || 0;
     run.ephemeral5m += r.ephemeral5m || 0;
     run.ephemeral1h += r.ephemeral1h || 0;
+    // Haiku 5.5 long-prompt split (see cost.js LONG_PROMPT_THRESHOLD); only
+    // present once a request this large exists.
+    if ((r.prompt_tokens || 0) > LONG_PROMPT_THRESHOLD) {
+      const l = (run.long ||= { input: 0, cacheCreation: 0, cacheRead: 0, ephemeral5m: 0, ephemeral1h: 0, output: 0 });
+      l.input += r.input_tokens || 0;
+      l.cacheCreation += r.cache_creation_tokens || 0;
+      l.cacheRead += r.cache_read_tokens || 0;
+      l.ephemeral5m += r.ephemeral5m || 0;
+      l.ephemeral1h += r.ephemeral1h || 0;
+      l.output += r.completion_tokens || 0;
+    }
     run.toolErrors += r.toolErrors || 0;
     const model = normalizeModelId(r.model);
     byModelOut.set(model, (byModelOut.get(model) || 0) + (r.completion_tokens || 0));