sprag-cli 3.57.0 → 3.58.1

package/README.ko.md

@@ -36,50 +36,25 @@ Sprag는 Claude Code와 Codex가 남기는 세션 기록을 읽어 반복 실패
 npm i -g sprag-cli   # 예전 이름 claude-token-saver 와 같은 패키지입니다
 ```
 
-## Codex
+## 설치하면 바로 달라지는 것
 
-Codex 기본 훅과 `AGENTS.md` 하네스, 범위별 래칫 규칙,
-한국어 검사, 프롬프트의 문서 경로 자동 변환, 로컬 토큰 보고서를 사용할 수 있습니다.
-Codex가 설치되어 있으면 `npm i -g sprag-cli` 하나로 Codex도 설정하고, 추천 룰을 묻지 않고
-전역으로 등록합니다(단계마다 확인하려면 `sprag install --manual`). Claude Code를 건드리지 않고
-Codex만 쓴다면 다음과 같이 설치하십시오.
+1. `npm i -g sprag-cli` 를 실행합니다. 훅과 상태줄, 추천 룰이 모든 프로젝트에
+   설정되므로 프로젝트마다 따로 설정할 것은 없습니다. 이미 쓰던 상태줄이 있으면
+   둘 다 표시할지, 교체할지, 그대로 둘지 설치 중에 묻습니다.
+2. 아무 프로젝트에서나 Claude Code를 열고 평소처럼 일합니다.
+3. 상태줄을 봅니다. 세션에서 쓴 금액과 아낀 금액이 나오고, 캐시나 컨텍스트,
+   사용량 한도에 문제가 생기면 경고 칩이 줄 맨 앞에 나타납니다.
 
-```bash
-npm i -g sprag-cli --ignore-scripts
-sprag install --agent codex
-sprag --agent codex --days 7
-sprag panel --agent codex  # 별도 터미널에서 실시간 패널 실행
-sprag --statusline --agent codex --text
-sprag doctor --agent codex  # 문제가 생겼을 때만
-sprag route-scan --agent codex
-sprag seed --agent codex
+```
+🔀 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
 ```
 
-설치 후 Codex의 `/hooks`에서 새 훅을 검토하고 신뢰해야 실행됩니다. Codex가 요구하는
-절차입니다. 명령의 기본 대상은 여전히 Claude Code이며, `--agent codex`를 붙이면 Codex를 고릅니다. Codex에서도 세션 브리핑, 경고 이력, 인수인계
-파일을 지원합니다. `sprag delegate on --agent codex`로 모델 위임과 하위 에이전트
-지침 전달을 켤 수 있습니다. 상태 표시는 Sprag 터미널 상태줄과 패널을 사용하십시오.
-Codex 기본 상태줄은 셸 명령을 실행하지 않습니다. 반복된 단순 작업은 위임 후보로,
-반복된 도구 실패는 래칫 후보로 제안합니다. 규칙을 등록하려면 사용자의 승인이 필요하며,
-`seed`로 호환되는 기본 규칙을 선택할 수도 있습니다.
-`sprag route-scan savings --agent codex`는 Sprag가 위임한 실행만 집계하고,
-일치하는 LiteLLM 단가가 있을 때 예상 차액을 계산합니다. 청구 금액을 측정한 값은 아니며,
-단가를 확인하지 못하면 `n/a`로 표시합니다. Codex 문서 누계는 Claude 추정치와 분리합니다.
-아래의 기존 절감 수치는 Claude Code 기록이며 Codex 벤치마크가 아닙니다.
-[Codex 지원 범위와 제한](https://sprag.io/docs/ko/codex/)이나
-`sprag capabilities --agent codex`에서 기능별 지원 여부를 확인하십시오.
-
-| 기능 | Claude Code | Codex |
-|---|---|---|
-| 세션 지침 | `CLAUDE.md`와 훅 | `AGENTS.md`와 기본 훅 |
-| 실시간 상태 | 기본 상태줄에 명령 등록 | 별도 패널 또는 tmux 구성 |
-| 규칙 후보 | Claude 기록과 모델 등급 프리셋 | Codex 기록과 호환 래칫 프리셋 |
-| 모델 위임 | Haiku·Sonnet 등급 규칙 | 공급자 모델 ID와 범위별 규칙 |
-| 위임 원장 | Claude 실행별 예상 차액 | LiteLLM 단가와 하위 실행별 예상 차액 |
-
-두 연동을 함께 설치할 수 있습니다. `--agent codex`를 붙이지 않으면 기존 Claude 동작을 유지합니다.
+Sprag는 사용자가 고른 모델을 바꾸지 않습니다. 분석은 로컬 세션 기록만 읽으며,
+추가 모델 호출이나 API 키가 필요하지 않습니다. `sprag uninstall` 은 설치 때
+추가한 것을 모두 지우고, 함께 표시하던 기존 상태줄을 되돌려 놓습니다.
 
-![statusline 예시. 첫 줄은 라우팅 절감액, 둘째 줄은 문서 변환 절감액, 셋째 줄은 진단 칩입니다](https://raw.githubusercontent.com/rootstudioyaml/sprag/main/docs/statusline.png)
+Codex를 쓴다면 아래 [Codex](#codex) 절을 보십시오.
 
 ## 작동 방식
 
@@ -99,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등인 모델은 없기 때문입니다.
@@ -108,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일 기준 | |
@@ -147,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)에 정리했습니다.
@@ -176,11 +156,56 @@ 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 |
 
 래칫 규칙과 위임 규칙은 늘어나는 방식이 다릅니다. 래칫 규칙은 사람이 저지른 실수에서 나오므로 계속 늘어납니다. 위임 규칙은 멈춥니다. 기준이 알아보는 작업 유형이 정해져 있어서, 유형마다 규칙이 하나 생기면 더 승격할 것이 없습니다.
 
+## Codex
+
+Codex 기본 훅과 `AGENTS.md` 하네스, 범위별 래칫 규칙,
+한국어 검사, 프롬프트의 문서 경로 자동 변환, 로컬 토큰 보고서를 사용할 수 있습니다.
+Codex가 설치되어 있으면 `npm i -g sprag-cli` 하나로 Codex도 설정하고, 추천 룰을 묻지 않고
+전역으로 등록합니다(단계마다 확인하려면 `sprag install --manual`). Claude Code를 건드리지 않고
+Codex만 쓴다면 다음과 같이 설치하십시오.
+
+```bash
+npm i -g sprag-cli --ignore-scripts
+sprag install --agent codex
+sprag --agent codex --days 7
+sprag panel --agent codex  # 별도 터미널에서 실시간 패널 실행
+sprag --statusline --agent codex --text
+sprag doctor --agent codex  # 문제가 생겼을 때만
+sprag route-scan --agent codex
+sprag seed --agent codex
+```
+
+설치 후 Codex의 `/hooks`에서 새 훅을 검토하고 신뢰해야 실행됩니다. Codex가 요구하는
+절차입니다. 명령의 기본 대상은 여전히 Claude Code이며, `--agent codex`를 붙이면 Codex를 고릅니다. Codex에서도 세션 브리핑, 경고 이력, 인수인계
+파일을 지원합니다. `sprag delegate on --agent codex`로 모델 위임과 하위 에이전트
+지침 전달을 켤 수 있습니다. 상태 표시는 Sprag 터미널 상태줄과 패널을 사용하십시오.
+Codex 기본 상태줄은 셸 명령을 실행하지 않습니다. 반복된 단순 작업은 위임 후보로,
+반복된 도구 실패는 래칫 후보로 제안합니다. 규칙을 등록하려면 사용자의 승인이 필요하며,
+`seed`로 호환되는 기본 규칙을 선택할 수도 있습니다.
+`sprag route-scan savings --agent codex`는 Sprag가 위임한 실행만 집계하고,
+일치하는 LiteLLM 단가가 있을 때 예상 차액을 계산합니다. 청구 금액을 측정한 값은 아니며,
+단가를 확인하지 못하면 `n/a`로 표시합니다. Codex 문서 누계는 Claude 추정치와 분리합니다.
+아래의 기존 절감 수치는 Claude Code 기록이며 Codex 벤치마크가 아닙니다.
+[Codex 지원 범위와 제한](https://sprag.io/docs/ko/codex/)이나
+`sprag capabilities --agent codex`에서 기능별 지원 여부를 확인하십시오.
+
+| 기능 | Claude Code | Codex |
+|---|---|---|
+| 세션 지침 | `CLAUDE.md`와 훅 | `AGENTS.md`와 기본 훅 |
+| 실시간 상태 | 기본 상태줄에 명령 등록 | 별도 패널 또는 tmux 구성 |
+| 규칙 후보 | Claude 기록과 모델 등급 프리셋 | Codex 기록과 호환 래칫 프리셋 |
+| 모델 위임 | Haiku·Sonnet 등급 규칙 | 공급자 모델 ID와 범위별 규칙 |
+| 위임 원장 | Claude 실행별 예상 차액 | LiteLLM 단가와 하위 실행별 예상 차액 |
+
+두 연동을 함께 설치할 수 있습니다. `--agent codex`를 붙이지 않으면 기존 Claude 동작을 유지합니다.
+
+![statusline 예시. 첫 줄은 라우팅 절감액, 둘째 줄은 문서 변환 절감액, 셋째 줄은 진단 칩입니다](https://raw.githubusercontent.com/rootstudioyaml/sprag/main/docs/statusline.png)
+
 ## 자주 쓰는 명령
 
 | 명령 | 하는 일 |

package/README.md

@@ -48,51 +48,27 @@ existing credentials. The CLI requires Node.js 18+ and one TOML parser dependenc
 npm i -g sprag-cli   # Claude Code, plus Codex when it is installed
 ```
 
-## Codex
+## After you install
 
-Native hooks, an `AGENTS.md` harness, scoped ratchet rules, Korean lint,
-document conversion, token reports, and a session-bound companion panel.
-`npm i -g sprag-cli` sets Codex up too when it is installed, with the rule
-presets registered globally and nothing asked (`sprag install --manual` asks at
-each step). For a Codex-only install that leaves Claude Code alone:
+1. Run `npm i -g sprag-cli`. Hooks, the statusline and the starter rules are set
+   up for every project; there is nothing to configure per project. If you
+   already have a statusline, the install asks whether to show both, replace
+   yours, or keep yours.
+2. Open Claude Code in any project and work as usual.
+3. Watch the statusline. It shows what the session spent and saved, and a
+   warning chip leads the line when the cache, the context or a rate limit
+   needs attention:
 
-```bash
-npm i -g sprag-cli --ignore-scripts
-sprag install --agent codex
-sprag --agent codex --days 7
-sprag panel --agent codex  # live companion in a separate terminal
-sprag --statusline --agent codex --text
-sprag doctor --agent codex  # troubleshooting only
-sprag route-scan --agent codex
-sprag seed --agent codex
+```
+🔀 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
 ```
 
-Review and trust the new hooks in Codex's `/hooks` menu; Codex requires that
-step. Commands still default to Claude Code; add `--agent codex` to pick Codex.
-Codex also supports session briefings, warning history, handoffs, and opt-in
-model routing and subagent guidance (`sprag delegate on --agent codex`). The native Codex footer
-does not accept shell commands; Sprag provides a terminal statusline and panel.
-Recurring simple turns become route candidates; repeated tool failures become
-ratchet candidates. Both require your approval before a rule is registered.
-`seed` offers compatible starter rules with separate Codex decisions.
-`sprag route-scan savings --agent codex` records only Sprag-routed child runs
-and estimates their price difference when matching LiteLLM prices are available.
-It is not a billing measurement. Unknown prices remain `n/a`, and Codex document
-counts stay separate from Claude estimates. The historical dollar figures below
-are from Claude Code, not a Codex benchmark. See [Codex support and limits](https://sprag.io/docs/codex/), or run
-`sprag capabilities --agent codex` for the support matrix.
-
-| Workflow | Claude Code | Codex |
-|---|---|---|
-| Session instructions | `CLAUDE.md` and hooks | `AGENTS.md` and native hooks |
-| Live telemetry | Native statusline command | Companion panel or tmux layout |
-| Rule candidates | Claude transcripts and tier presets | Codex rollouts and compatible ratchet presets |
-| Model routing | Haiku/Sonnet tier rules | Explicit provider model IDs and scoped rules |
-| Routing ledger | Claude run estimates | Attributed child estimates with LiteLLM prices |
-
-Both integrations coexist. Commands without `--agent codex` retain Claude behavior.
+Sprag never swaps the model you picked. Analysis reads your local session
+logs only, with no extra model calls and no API key. `sprag uninstall` removes
+everything it added and restores a statusline it merged with.
 
-![statusline example: routing savings on row 1, document conversion savings on row 2, diagnostics on row 3](https://raw.githubusercontent.com/rootstudioyaml/sprag/main/docs/statusline.png)
+Using Codex? See [Codex](#codex) below.
 
 ## How it works
 
@@ -119,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
@@ -135,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 | |
@@ -179,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).
@@ -218,13 +200,59 @@ 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,
 so they keep coming. Delegation rules stop: the criteria recognize a fixed set of
 work types, and once each has a rule there is nothing left to promote.
 
+## Codex
+
+Native hooks, an `AGENTS.md` harness, scoped ratchet rules, Korean lint,
+document conversion, token reports, and a session-bound companion panel.
+`npm i -g sprag-cli` sets Codex up too when it is installed, with the rule
+presets registered globally and nothing asked (`sprag install --manual` asks at
+each step). For a Codex-only install that leaves Claude Code alone:
+
+```bash
+npm i -g sprag-cli --ignore-scripts
+sprag install --agent codex
+sprag --agent codex --days 7
+sprag panel --agent codex  # live companion in a separate terminal
+sprag --statusline --agent codex --text
+sprag doctor --agent codex  # troubleshooting only
+sprag route-scan --agent codex
+sprag seed --agent codex
+```
+
+Review and trust the new hooks in Codex's `/hooks` menu; Codex requires that
+step. Commands still default to Claude Code; add `--agent codex` to pick Codex.
+Codex also supports session briefings, warning history, handoffs, and opt-in
+model routing and subagent guidance (`sprag delegate on --agent codex`). The native Codex footer
+does not accept shell commands; Sprag provides a terminal statusline and panel.
+Recurring simple turns become route candidates; repeated tool failures become
+ratchet candidates. Both require your approval before a rule is registered.
+`seed` offers compatible starter rules with separate Codex decisions.
+`sprag route-scan savings --agent codex` records only Sprag-routed child runs
+and estimates their price difference when matching LiteLLM prices are available.
+It is not a billing measurement. Unknown prices remain `n/a`, and Codex document
+counts stay separate from Claude estimates. The historical dollar figures below
+are from Claude Code, not a Codex benchmark. See [Codex support and limits](https://sprag.io/docs/codex/), or run
+`sprag capabilities --agent codex` for the support matrix.
+
+| Workflow | Claude Code | Codex |
+|---|---|---|
+| Session instructions | `CLAUDE.md` and hooks | `AGENTS.md` and native hooks |
+| Live telemetry | Native statusline command | Companion panel or tmux layout |
+| Rule candidates | Claude transcripts and tier presets | Codex rollouts and compatible ratchet presets |
+| Model routing | Haiku/Sonnet tier rules | Explicit provider model IDs and scoped rules |
+| Routing ledger | Claude run estimates | Attributed child estimates with LiteLLM prices |
+
+Both integrations coexist. Commands without `--agent codex` retain Claude behavior.
+
+![statusline example: routing savings on row 1, document conversion savings on row 2, diagnostics on row 3](https://raw.githubusercontent.com/rootstudioyaml/sprag/main/docs/statusline.png)
+
 ## Day-to-day commands
 
 | Command | What it does |

package/bin/cli.js

@@ -590,10 +590,11 @@ async function main() {
           persistSnapshot({ caps, model });
         } catch (e) { debug('caps-cache:persist', e); }
       }
-      console.log(formatNoSession(
+      const { withBaseStatusline } = await import('../src/statusline-base.js');
+      console.log(withBaseStatusline(formatNoSession(
         { caps, model, effort, windowLabel, version: PKG_VERSION, update: readUpdateChip() },
         { color: colorOk, mode: labelMode },
-      ));
+      )));
       return;
     }
     // JSON mode stays JSON. A caller that asked for machine-readable output
@@ -901,6 +902,10 @@ async function main() {
     output = formatReport(data, { color: tableColor() });
   }
 
+  if (format === 'statusline') {
+    const { withBaseStatusline } = await import('../src/statusline-base.js');
+    output = withBaseStatusline(output);
+  }
   console.log(output);
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sprag-cli",
-  "version": "3.57.0",
-  "description": "Cut the tokens Claude Code and Codex spend: routes simple work to cheaper models, converts documents to compact Markdown, and shows spend and savings live. Ratchet rules and Korean writing checks included.",
+  "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": {
     "sprag": "bin/cli.js",
@@ -33,34 +33,22 @@
     "node": ">=18"
   },
   "keywords": [
-    "sprag",
-    "ratchet",
-    "harness",
-    "ai-agent",
-    "claude",
     "claude-code",
-    "codex",
-    "openai-codex",
-    "agents-md",
+    "claude",
     "anthropic",
-    "model-routing",
-    "llm-router",
-    "delegation",
-    "subagent",
-    "haiku",
-    "cost-savings",
+    "codex",
+    "token-usage",
     "token-saver",
     "reduce-tokens",
-    "token-usage",
-    "prompt-caching",
-    "cache",
-    "statusline",
-    "cli",
-    "1m-context",
-    "claude-code-statusline",
+    "cost-savings",
     "claude-code-cost",
-    "model-fitting",
-    "agent-harness"
+    "claude-code-statusline",
+    "statusline",
+    "model-routing",
+    "subagent",
+    "prompt-caching",
+    "haiku",
+    "cli"
   ],
   "license": "Apache-2.0",
   "repository": {

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/commands/install.js

@@ -11,6 +11,11 @@
  * registered globally, and Codex is set up too when ~/.codex exists. `--manual`
  * restores the step-by-step questions (they still need a terminal attached).
  * `--yes` and `--no-input` are accepted as the explicit spelling of the default.
+ *
+ * One question survives the automatic mode: when a statusline that is not ours
+ * is already configured and a terminal is attached, the install asks whether to
+ * merge (theirs first, sprag below; default), replace, or keep. Without a
+ * terminal (postinstall, CI, pipes) it keeps theirs, as before.
  */
 
 import { debug } from '../debug.js';
@@ -21,7 +26,7 @@ class SkipStep extends Error {}
 export async function run({ hasFlag }) {
     const { installAll } = await import('../installer.js');
     const { userLanguage, languageDecided, setUserLanguage } = await import('../config.js');
-    const { canPrompt, confirm } = await import('../prompt.js');
+    const { canPrompt, confirm, choose } = await import('../prompt.js');
     const force = hasFlag('--force');
     // Automatic unless asked otherwise. A question per step turned the install
     // into a dozen answers before any work, and every answer has a sensible
@@ -30,6 +35,9 @@ export async function run({ hasFlag }) {
     // attached, so postinstall, CI and pipes never wait on input.
     const manual = hasFlag('--manual') && !hasFlag('--yes') && !hasFlag('--no-input');
     const interactive = manual && canPrompt();
+    // The foreign-statusline question is asked in the automatic install too: it
+    // is the one decision with no safe default that preserves both parties.
+    const tty = canPrompt();
 
     // Output language, decided first because every line below it — and every
     // briefing the hooks inject from here on — is written in it. Until now it
@@ -82,25 +90,28 @@ export async function run({ hasFlag }) {
       let s = r.statusline;
       // A different statusline is already installed. Replacing it silently
       // would be rude and leaving it silently loses the tool's main surface,
-      // so with a human attached the install asks. Default is "keep yours":
-      // an accidental Enter must not clobber someone's custom statusline.
-      if (s.action === 'skipped' && s.conflict && interactive) {
+      // so with a human attached the install asks. Default is "merge": their
+      // output stays and ours goes below it, so nobody loses anything.
+      if (s.action === 'skipped' && s.conflict && tty) {
+        const { installStatusline } = await import('../installer.js');
         console.log('');
         console.log(lang === 'ko'
           ? `  statusline: 기존 statusline이 이미 설정되어 있습니다: ${s.existingCommand}`
           : `  statusline: an existing statusline is already configured: ${s.existingCommand}`);
-        console.log(lang === 'ko'
-          ? '              교체하면 토큰·캐시·상한 경고가 statusline에 표시됩니다. 기존 설정은 사라집니다.'
-          : '              replacing it shows token/cache/cap warnings in the statusline; the current one is removed.');
-        const replace = await confirm(lang === 'ko'
-          ? '              sprag statusline으로 교체할까요?'
-          : '              Replace it with the sprag statusline?', { defaultValue: false });
-        if (replace) {
-          const { installStatusline } = await import('../installer.js');
+        const pick = await choose(lang === 'ko'
+          ? '              statusline을 어떻게 표시할까요?'
+          : '              How should the statusline be shown?', [
+          { key: 'merge', label: lang === 'ko' ? '함께 표시: 기존 출력 아래에 sprag 줄을 붙입니다' : 'merge: your output first, sprag lines below' },
+          { key: 'replace', label: lang === 'ko' ? '교체: sprag statusline만 표시하고 기존 설정은 지웁니다' : 'replace: sprag statusline only, the old one is removed' },
+          { key: 'keep', label: lang === 'ko' ? '유지: 기존 statusline만 두고 sprag은 표시하지 않습니다' : 'keep: leave yours, no sprag statusline' },
+        ], { defaultIndex: 0, defaultHint: lang === 'ko' ? '(기본값)' : '(default)' });
+        if (pick === 'merge') {
+          s = installStatusline({ merge: true });
+        } else if (pick === 'replace') {
           s = installStatusline({ force: true });
         } else {
           s = { ...s, reason: lang === 'ko'
-            ? '기존 statusline을 유지했습니다. 교체하려면 `sprag install --force`'
+            ? '기존 statusline을 유지했습니다. 바꾸려면 `sprag install --force`'
             : 'kept your statusline — replace later with `sprag install --force`' };
         }
       }

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/installer.js

@@ -357,8 +357,10 @@ export function removeLegacyCommand() {
 // - No statusLine yet: insert ours with refreshInterval:STATUSLINE_REFRESH_INTERVAL.
 // - statusLine already points at sprag: ensure that refreshInterval
 //   (this is the bit that makes the TTL countdown tick every second while idle).
-// - statusLine points at a different command: leave it alone unless --force.
-export function installStatusline({ force = false } = {}) {
+// - statusLine points at a different command: leave it alone unless --force,
+//   or `merge`, which keeps their command running underneath ours (the original
+//   object is saved as config `statuslineBase` so uninstall can restore it).
+export function installStatusline({ force = false, merge = false } = {}) {
   const dir = claudeUserDir();
   const file = join(dir, 'settings.json');
   mkdirSync(dir, { recursive: true });
@@ -395,12 +397,13 @@ export function installStatusline({ force = false } = {}) {
     return { path: file, action: 'updated', reason: `set refreshInterval=${STATUSLINE_REFRESH_INTERVAL}` };
   }
 
-  if (!force) {
+  if (!force && !merge) {
     // `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.
     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;
   settings.statusLine = {
     type: 'command',
     command: STATUSLINE_COMMAND,
@@ -410,6 +413,17 @@ export function installStatusline({ force = false } = {}) {
     const writeProblem = writeSettings(file, settings);
     if (writeProblem) return { path: file, action: 'skipped', reason: writeProblem };
   }
+  // Config is touched only after settings were written, so a failed write
+  // never leaves a saved base for a statusline we did not take over.
+  const cfg = loadConfig();
+  if (merge) {
+    cfg.statuslineBase = base;
+    saveConfig(cfg);
+    return { path: file, action: 'updated', reason: 'merged with previous statusLine', merged: true };
+  }
+  // Replace means the old one is gone for good; a stale base would resurrect it
+  // (or keep running it) later.
+  if (cfg.statuslineBase) { delete cfg.statuslineBase; saveConfig(cfg); }
   return { path: file, action: 'updated', reason: 'replaced previous statusLine' };
 }
 
@@ -910,8 +924,18 @@ export function uninstallAll({ purge = false } = {}) {
     // where they put it.
     const cur = settings.statusLine;
     if (cur && isOurCommand(cur.command)) {
-      delete settings.statusLine;
-      result.removed.push('statusLine');
+      // A merged install saved the user's original statusline; give it back
+      // instead of leaving them with none.
+      const cfg = loadConfig();
+      if (cfg.statuslineBase) {
+        settings.statusLine = cfg.statuslineBase;
+        delete cfg.statuslineBase;
+        saveConfig(cfg);
+        result.removed.push('statusLine (restored previous)');
+      } else {
+        delete settings.statusLine;
+        result.removed.push('statusLine');
+      }
     } else if (cur) {
       result.kept.push(`statusLine (${cur.command || 'unrecognised'})`);
     }

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/prompt.js

@@ -50,3 +50,31 @@ export function confirm(question, { defaultValue = true, input = process.stdin,
     rl.on('close', () => { if (!answered) resolve(defaultValue); });
   });
 }
+
+/**
+ * Ask a multiple-choice question and resolve to the chosen `key`.
+ *
+ * Choices are printed as a numbered list; the answer may be the 1-based number
+ * or the key itself. Like confirm(), anything unrecognized (empty line, typo,
+ * closed stream) resolves to the default, so an unattended prompt ends with
+ * the same choice the non-interactive path would have made.
+ */
+export function choose(question, choices, { defaultIndex = 0, defaultHint = '(default)', input = process.stdin, output = process.stdout } = {}) {
+  const fallback = choices[defaultIndex]?.key ?? choices[0].key;
+  const lines = choices.map((c, i) => `    ${i + 1}) ${c.label}${i === defaultIndex ? ` ${defaultHint}` : ''}`);
+  return new Promise((resolve) => {
+    const rl = createInterface({ input, output });
+    let answered = false;
+    output.write(`${question}\n${lines.join('\n')}\n`);
+    rl.question(`  [1-${choices.length}] `, (answer) => {
+      answered = true;
+      rl.close();
+      const a = String(answer).trim().toLowerCase();
+      const n = Number(a);
+      if (Number.isInteger(n) && n >= 1 && n <= choices.length) return resolve(choices[n - 1].key);
+      const byKey = choices.find((c) => String(c.key).toLowerCase() === a);
+      resolve(byKey ? byKey.key : fallback);
+    });
+    rl.on('close', () => { if (!answered) resolve(fallback); });
+  });
+}

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/statusline-base.js

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

package/src/stdin-payload.js

@@ -25,10 +25,27 @@ import { readFileSync } from 'node:fs';
  * Anthropic adds (e.g. a Sonnet-only weekly bucket) flows through without code
  * changes — known keys get curated labels, unknowns get derived ones.
  */
+// fd 0 can only be drained once. The statusline needs the payload twice: once
+// to parse it, and once to forward it verbatim to a wrapped base statusline
+// command, so the raw text is read on first use and cached for the process.
+let rawCache = null;
+
+/** The raw stdin text, read once. '' when stdin is a TTY or empty. */
+export function readStdinRaw() {
+  if (rawCache !== null) return rawCache;
+  if (process.stdin.isTTY) return (rawCache = '');
+  try {
+    rawCache = readFileSync(0, 'utf8') || '';
+  } catch {
+    rawCache = '';
+  }
+  return rawCache;
+}
+
 export function readStdinJson() {
   if (process.stdin.isTTY) return null;
   try {
-    const raw = readFileSync(0, 'utf8');
+    const raw = readStdinRaw();
     if (!raw || !raw.trim()) return null;
     return JSON.parse(raw);
   } catch {

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));