sprag-cli 3.57.0 → 3.58.0

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 $44.67  |  opus→sonnet 59× $39.75 · opus→haiku 10× $4.92
+🧠 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) 절을 보십시오.
 
 ## 작동 방식
 
@@ -181,6 +156,51 @@ JetBrains IDE 내장 터미널에서는 이모지 대신 한 칸 글리프로
 
 래칫 규칙과 위임 규칙은 늘어나는 방식이 다릅니다. 래칫 규칙은 사람이 저지른 실수에서 나오므로 계속 늘어납니다. 위임 규칙은 멈춥니다. 기준이 알아보는 작업 유형이 정해져 있어서, 유형마다 규칙이 하나 생기면 더 승격할 것이 없습니다.
 
+## 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 $44.67  |  opus→sonnet 59× $39.75 · opus→haiku 10× $4.92
+🧠 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
 
@@ -225,6 +201,52 @@ 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.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": {
     "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/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/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/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/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 {