sprag-cli 3.58.0 → 3.58.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.58.0",
+  "version": "3.58.1",
   "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/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/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/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));