claude-token-saver 2.17.0 → 2.18.0

package/README.en.md

@@ -55,7 +55,7 @@ The statusline appears at the bottom of Claude Code right away. If auto-registra
 | `🧠` | Cache hit rate (green at 85%+) |
 | `⏳` | Cache TTL countdown — send a message before expiry to keep the cache warm |
 | `✦ current` / `📅 weekly` | 5-hour / 7-day rate-limit window usage + reset time |
-| `📦` | Context window (1M shows red — a major cost driver) |
+| `📦` | Context usage (e.g. `Ctx 68% of 1M`) — colored by fill. Current models default to 1M with no premium, but token volume itself drives per-turn cost and 5H/7D burn |
 | `💰` | Cumulative savings from prompt caching |
 
 When something is wrong, a **warning chip leads the line**:
@@ -64,7 +64,7 @@ When something is wrong, a **warning chip leads the line**:
 🚨 5H █████▓ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 4.8 · 🧠 Cache hit 72.1% · ⚠ Cache miss · 📅 weekly ▓░░░░░ 12% 🔄 Sun 14:26 · 📦 Ctx 200k · last 1d
 ```
 
-Chips — `🚨 5H/7D NN%` (cap imminent) · `⚠ 1M ON` · `⚠ Cache miss` · `⚠ Input spike` · `⚠ Output heavy` · `⚠ Call surge` · `⚠ Rebuild churn` · `⚠ 5m TTL`. When both windows cross 90% at once, the sooner-resetting one is promoted to 🚨 and the other stays visible as a red segment (v2.16.0+).
+Chips — `🚨 5H/7D NN%` (cap imminent) · `⚠ Ctx 200k+` (a single request actually exceeded 200k) · `⚠ Cache miss` · `⚠ Input spike` · `⚠ Output heavy` · `⚠ Call surge` · `⚠ Rebuild churn` · `⚠ 5m TTL`. When both windows cross 90% at once, the sooner-resetting one is promoted to 🚨 and the other stays visible as a red segment (v2.16.0+).
 
 ### When a chip appears
 
@@ -137,7 +137,7 @@ An auto `.bak` is kept, but **the session context that earned the rule its place
 
 | Code | Meaning |
 |---|---|
-| `LARGE_INPUT_PER_REQUEST` | single request > 250k tokens → 1M context likely |
+| `LARGE_INPUT_PER_REQUEST` | single request > 200k input tokens — per-turn re-billing and cap burn spike |
 | `LOW_HIT_RATE` | cache hit rate < 50% |
 | `BUCKET_5M_DOMINANT` | > 70% of cache writes hit the 5m bucket |
 | `HIGH_OUTPUT_RATIO` | output/input > 0.15 (output is 5× input price) |
@@ -213,6 +213,11 @@ Also update `statusLine.command` in `~/.claude/settings.json` to `claude-token-s
 
 ## Release notes
 
+### v2.18.0 (2026-07-02)
+- **1M-context warning re-scoped** — current models (Fable 5, Opus 4.6–4.8, Sonnet 5) all default to a 1M window with no long-context premium since Opus 4.7, so the "1M mode ON = expensive" framing is retired. The warning is now a **usage signal**: `⚠ 1M ON` → `⚠ Ctx 200k+` (a single request actually exceeded 200k), and remediation is reordered to lead with `/compact`/`/clear` + `/effort` instead of "disable 1M". The incorrect "long-context pricing kicks in past 200k" copy is fixed.
+- **📦 segment shows live usage** — reads `context_window.used_percentage` from Claude Code's stdin and renders `📦 Ctx 68% of 1M`, colored by fill (green <70 / yellow 70–89 / red 90+). Falls back to transcript-inferred size when stdin is absent (1M now yellow, not red).
+- Back-compat: the legacy `⚠ 1M ON` chip and old detail strings in existing history files still resolve.
+
 ### v2.17.0 (2026-07-02)
 - **Fable 5 pricing tier** — `claude-fable-5`/`claude-mythos-5` previously fell through to the Sonnet tier ($3/$15), under-estimating costs ~3×. Now priced at the real rates ($10 input / $50 output / $12.50 5m-write / $20 1h-write / $1 read).
 - README overhaul — top-level impact summary, segment table, harness scope-flag docs, pricing table brought current.

package/README.md

@@ -55,7 +55,7 @@ npm i -g claude-token-saver
 | `🧠` | 캐시 히트율 (85%+ 녹색) |
 | `⏳` | 캐시 TTL 카운트다운 — 만료 전에 메시지를 보내면 캐시 유지 |
 | `✦ current` / `📅 weekly` | 5시간 / 7일 rate-limit 윈도 사용률 + 리셋 시각 |
-| `📦` | 컨텍스트 윈도 (1M이면 빨간 경고 — 비용 급증 요인) |
+| `📦` | 컨텍스트 사용률 (예: `Ctx 68% of 1M`) — 사용률 기준 녹/황/적. 현재 모델은 1M이 기본·프리미엄 없음이지만, 토큰량 자체가 턴당 비용과 5H/7D 한도를 태웁니다 |
 | `💰` | 캐시가 절약해준 누적 금액 |
 
 문제가 감지되면 **경고 칩이 맨 앞에** 붙습니다:
@@ -64,7 +64,7 @@ npm i -g claude-token-saver
 🚨 5H █████▓ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 4.8 · 🧠 Cache hit 72.1% · ⚠ Cache miss · 📅 weekly ▓░░░░░ 12% 🔄 Sun 14:26 · 📦 Ctx 200k · last 1d
 ```
 
-칩 종류 — `🚨 5H/7D NN%`(캡 임박) · `⚠ 1M ON` · `⚠ Cache miss` · `⚠ Input spike` · `⚠ Output heavy` · `⚠ Call surge` · `⚠ Rebuild churn` · `⚠ 5m TTL`. 두 윈도가 동시에 90%+면 리셋이 임박한 쪽이 🚨로 승격되고 나머지는 빨간 세그먼트로 유지됩니다 (v2.16.0+).
+칩 종류 — `🚨 5H/7D NN%`(캡 임박) · `⚠ Ctx 200k+`(단일 요청이 실제로 200k 초과) · `⚠ Cache miss` · `⚠ Input spike` · `⚠ Output heavy` · `⚠ Call surge` · `⚠ Rebuild churn` · `⚠ 5m TTL`. 두 윈도가 동시에 90%+면 리셋이 임박한 쪽이 🚨로 승격되고 나머지는 빨간 세그먼트로 유지됩니다 (v2.16.0+).
 
 ### 경고 칩이 떴을 때
 
@@ -118,7 +118,7 @@ ratchet의 가치는 **한 방향 누적**에 있습니다. 룰을 가볍게 지
 
 | 코드 | 의미 |
 |---|---|
-| `LARGE_INPUT_PER_REQUEST` | 단일 요청 250k+ → 1M 컨텍스트 의심 |
+| `LARGE_INPUT_PER_REQUEST` | 단일 요청 입력이 200k 초과 — 턴당 재과금·한도 소모 급증 |
 | `LOW_HIT_RATE` | 캐시 히트율 50% 미만 |
 | `BUCKET_5M_DOMINANT` | 캐시 쓰기의 70%+가 5분 버킷 (Pro 플랜/Max 다운그레이드) |
 | `HIGH_OUTPUT_RATIO` | 출력/입력 비율 0.15 초과 (출력 단가는 입력의 5배) |
@@ -170,6 +170,11 @@ npm uninstall -g claude-cache-monitor && npm i -g claude-token-saver
 
 ## 릴리스 노트
 
+### v2.18.0 (2026-07-02)
+- **1M 컨텍스트 경고 의미 재정의** — 현재 모델(Fable 5, Opus 4.6~4.8, Sonnet 5)은 전부 1M 윈도가 기본이고 Opus 4.7부터 장기 컨텍스트 프리미엄도 없어, "1M 모드 ON = 비쌈" 프레임을 폐기했습니다. 경고는 이제 **실사용 신호**입니다: `⚠ 1M ON` → `⚠ Ctx 200k+`(단일 요청이 실제로 200k 초과), 처방도 "1M 끄기" 우선에서 "`/compact`/`/clear` + `/effort` 점검" 우선으로 재정렬. 잘못된 "200k 초과 시 장기 요금 적용" 문구 정정.
+- **📦 세그먼트가 실시간 사용률 표시** — Claude Code stdin의 `context_window.used_percentage`를 사용해 `📦 Ctx 68% of 1M` 형태로 렌더 (사용률 기준 녹 <70 / 황 70–89 / 적 90+). stdin이 없으면 기존 크기 추론으로 폴백하되 1M은 빨강 대신 노랑.
+- 구버전 히스토리 호환: `⚠ 1M ON` 칩·구 디테일 문구도 계속 해석됩니다.
+
 ### v2.17.0 (2026-07-02)
 - **Fable 5 가격 티어 추가** — `claude-fable-5`/`claude-mythos-5`가 Sonnet 단가($3/$15)로 폴백돼 비용이 ~3배 과소 추정되던 문제 수정. 실제 단가(입력 $10 / 출력 $50 / 캐시쓰기 5m $12.50·1h $20 / 캐시읽기 $1) 적용.
 - README 전면 개편 — 최상위 임팩트 요약, 세그먼트 표, harness scope 플래그 문서화, 가격 테이블 최신화.

package/bin/cli.js

@@ -93,6 +93,24 @@ function bedrockDisplayFromId(id) {
   return `${family} ${m[2]}.${m[3]}`;
 }
 
+/**
+ * Live context usage from Claude Code's stdin payload (`context_window`).
+ * More accurate than inferring from transcripts: it's the CURRENT session's
+ * real fill level, updated every refresh. Shape (subset):
+ *   "context_window": { "context_window_size": 200000, "used_percentage": 68 }
+ */
+function extractContextUsage(stdinJson) {
+  const cw = stdinJson && stdinJson.context_window;
+  if (!cw || typeof cw !== 'object') return null;
+  const usedPct = Number(cw.used_percentage);
+  const size = Number(cw.context_window_size);
+  if (!Number.isFinite(usedPct)) return null;
+  return {
+    usedPct,
+    size: Number.isFinite(size) && size > 0 ? size : null,
+  };
+}
+
 function extractModel(stdinJson) {
   if (!stdinJson || !stdinJson.model) return null;
   const m = stdinJson.model;
@@ -894,6 +912,7 @@ async function main() {
   const stdinJson = readStdinJson();
   let caps = extractCaps(stdinJson);
   let model = extractModel(stdinJson);
+  const ctxLive = extractContextUsage(stdinJson);
   if (isStatusline && (caps || model)) {
     try {
       const { persistSnapshot } = await import('../src/caps-cache.js');
@@ -923,7 +942,7 @@ async function main() {
   if (format === 'statusline') {
     if (contextWindow.size === '1M') {
       spikeChip = chipForIssues([], contextWindow);
-      chipDetail = `Context auto-promoted to 1M (max single-request ${Math.round(contextWindow.maxContext / 1000)}k tokens)`;
+      chipDetail = `Single-request context exceeded 200k (max ${Math.round(contextWindow.maxContext / 1000)}k tokens)`;
     } else {
       const recentSession = sessions
         .slice()
@@ -994,6 +1013,7 @@ async function main() {
     lastActivity,
     spikeReport,
     contextWindow,
+    ctxLive,
     spikeChip,
     caps,
     model,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-token-saver",
-  "version": "2.17.0",
+  "version": "2.18.0",
   "description": "Save tokens on Claude Code — spike diagnosis, 1M-context detection, TTL countdown, statusline. (formerly claude-cache-monitor)",
   "type": "module",
   "bin": {

package/src/advice.js

@@ -39,25 +39,33 @@ function toggleShortcut() {
  */
 export const ISSUE_MESSAGES = {
   LARGE_INPUT_PER_REQUEST: {
-    title: 'Per-request input tokens are unusually large (1M context suspected)',
-    titleKo: '요청당 입력 토큰이 비정상적으로 큼 (1M 컨텍스트 의심)',
+    title: 'Per-request input tokens are unusually large (context past 200k)',
+    titleKo: '요청당 입력 토큰이 비정상적으로 큼 (컨텍스트 200k 초과)',
+    // Since Opus 4.7 there is NO long-context price premium — 1M is standard
+    // rate and the default window on current models. The cost driver is the
+    // token volume itself: a 500k-token context re-reads ~500k tokens every
+    // turn (cache-read billed) and burns the subscription 5H/7D windows
+    // several times faster. That's what this warning is about.
     explain:
-      'Since Opus 4.7, 1M context is priced at the standard rate, and Max plans auto-promote ' +
-      'sessions to 1M. Once context goes past 200k, long-context pricing kicks in and cache reuse drops.',
+      'Current models default to a 1M window with no long-context premium — but the token ' +
+      'volume itself is the cost: every turn re-reads the whole context (billed as cache reads) ' +
+      'and drains the 5H/7D rate-limit windows several times faster. Cache reuse also drops.',
     explainKo:
-      'Opus 4.7부터 1M 컨텍스트가 표준 요금이 되었고, Max 플랜은 세션을 자동으로 1M으로 승격합니다. ' +
-      '200k를 넘는 순간 장기 컨텍스트 요금이 적용되며 캐시 재사용률도 떨어집니다.',
+      '현재 모델은 1M 윈도가 기본이고 장기 컨텍스트 프리미엄도 없습니다 — 하지만 토큰량 자체가 비용입니다. ' +
+      '매 턴 컨텍스트 전체를 다시 읽고(캐시 읽기 과금) 5H/7D 한도도 몇 배 빠르게 소모됩니다. ' +
+      '캐시 재사용률도 떨어집니다.',
     actions: () => [
       {
-        label: 'Disable 1M context (env var)',
-        labelKo: '1M 컨텍스트 끄기 (환경변수)',
-        commands: disable1mEnvSnippet(),
-      },
-      {
-        label: 'In-session toggle',
-        labelKo: '세션 내 즉시 토글',
-        commands: [`Press ${toggleShortcut()} to toggle on/off instantly`],
-        commandsKo: [`${toggleShortcut()} 누르면 즉시 on/off 토글`],
+        label: 'Compact or clear when context grows (first lever)',
+        labelKo: '컨텍스트가 커지면 /compact 또는 /clear (1순위)',
+        commands: [
+          '/compact  — summarize the session history in place',
+          '/clear    — drop history entirely at a clean task boundary',
+        ],
+        commandsKo: [
+          '/compact — 세션 히스토리를 그 자리에서 요약',
+          '/clear   — 작업 분기점에서 히스토리를 통째로 비우기',
+        ],
       },
       {
         label: 'Cap extended-thinking budget (⚠ check /effort first)',
@@ -90,16 +98,14 @@ export const ISSUE_MESSAGES = {
         ],
       },
       {
-        label: 'Compact or clear when context grows',
-        labelKo: '컨텍스트가 커지면 /compact 또는 /clear',
-        commands: [
-          '/compact  — summarize the session history in place',
-          '/clear    — drop history entirely at a clean task boundary',
-        ],
-        commandsKo: [
-          '/compact — 세션 히스토리를 그 자리에서 요약',
-          '/clear   — 작업 분기점에서 히스토리를 통째로 비우기',
-        ],
+        label: 'Cap the window at 200k if you never need more (optional)',
+        labelKo: '더 큰 윈도가 필요 없으면 200k로 제한 (선택)',
+        commands: disable1mEnvSnippet().concat([
+          `Or press ${toggleShortcut()} to toggle in-session`,
+        ]),
+        commandsKo: disable1mEnvSnippet().concat([
+          `또는 ${toggleShortcut()}로 세션 내 즉시 토글`,
+        ]),
       },
       {
         label: '⚠ Known bug #31640',
@@ -337,11 +343,13 @@ export const ISSUE_MESSAGES = {
     title: 'Context window is approaching the limit',
     titleKo: '컨텍스트 창이 한계에 근접',
     explain:
-      'As context grows toward 200k (or 1M), each turn becomes more expensive and cache ' +
-      'reuse efficiency drops. Past 200k, long-context pricing applies.',
+      'As context grows, each turn becomes more expensive (the whole context is re-read every ' +
+      'turn) and cache reuse efficiency drops. There is no price premium past 200k on current ' +
+      'models — the token volume itself is the cost, and it drains the 5H/7D caps faster.',
     explainKo:
-      '컨텍스트가 200k(또는 1M)에 가까워질수록 매 턴 비용이 높아지고 캐시 재사용 효율이 떨어집니다. ' +
-      '200k를 넘으면 장기 컨텍스트 요금이 적용됩니다.',
+      '컨텍스트가 커질수록 매 턴 비용이 높아지고(전체 컨텍스트를 매 턴 다시 읽음) 캐시 재사용 효율이 ' +
+      '떨어집니다. 현재 모델은 200k 초과 프리미엄이 없습니다 — 토큰량 자체가 비용이며 5H/7D 한도도 ' +
+      '더 빠르게 소모됩니다.',
     actions: () => [
       {
         label: '/compact at the next natural break',
@@ -435,8 +443,8 @@ export const ISSUE_MESSAGES = {
  */
 export const ISSUE_TIPS = {
   LARGE_INPUT_PER_REQUEST: {
-    en: 'Check `/effort` — `xhigh` is the #1 cap killer; switch to `/effort medium` (or `low`); disable 1M context; `/compact` when context grows',
-    ko: '`/effort` 확인 — `xhigh`가 캡 소진 1순위 원인, `medium`(또는 `low`)으로 복귀; 1M 컨텍스트 끄기; 컨텍스트 커지면 `/compact`',
+    en: '`/compact` or `/clear` — big contexts re-bill every turn and burn the 5H/7D caps; check `/effort` (`xhigh` is the #1 cap killer)',
+    ko: '`/compact` 또는 `/clear` — 큰 컨텍스트는 매 턴 재과금되고 5H/7D 한도를 태움; `/effort` 확인 (`xhigh`가 캡 소진 1순위)',
   },
   LOW_HIT_RATE: {
     en: 'Continue with `claude --continue`; keep CLAUDE.md trim — every line ships every turn',
@@ -463,8 +471,8 @@ export const ISSUE_TIPS = {
     ko: '지금 바로 아무 프롬프트나 보내 TTL 타이머 리셋; 또는 자리 비우기 전 `/compact` (Pro = 5분, Max = 1시간)',
   },
   CONTEXT_NEAR_LIMIT: {
-    en: '`/compact` before hitting the limit; `/clear` + re-attach only needed files; disable 1M: `export CLAUDE_MODEL_CONTEXT=200000`',
-    ko: '한계 도달 전 `/compact`; `/clear` 후 필요한 파일만 재첨부; 1M 끄기: `export CLAUDE_MODEL_CONTEXT=200000`',
+    en: '`/compact` before hitting the limit; `/clear` + re-attach only needed files',
+    ko: '한계 도달 전 `/compact`; `/clear` 후 필요한 파일만 재첨부',
   },
 };
 
@@ -474,6 +482,9 @@ export const ISSUE_TIPS = {
  * need a fallback so history.js can still surface the right tip.
  */
 export const CHIP_TO_CODES = {
+  '⚠ Ctx 200k+': ['LARGE_INPUT_PER_REQUEST'],
+  // Legacy chip name (pre-v2.18) — kept so `last`/`history` can still resolve
+  // codes from history files written by older versions.
   '⚠ 1M ON': ['LARGE_INPUT_PER_REQUEST'],
   '⚠ Cache miss': ['LOW_HIT_RATE'],
   '⚠ Input spike': ['LARGE_INPUT_PER_REQUEST'],
@@ -502,7 +513,11 @@ export const CAP_TIPS = {
  * shown to a global audience.
  */
 export function chipForIssues(issues, contextWindow) {
-  if (contextWindow?.size === '1M') return '⚠ 1M ON';
+  // Fires on *actual usage* (a real request carried >210k input tokens), not
+  // on the model merely supporting 1M — current models are all 1M by default
+  // with no price premium, so "1M ON" stopped being a meaningful alarm. The
+  // meaningful signal is "your context genuinely exceeded 200k".
+  if (contextWindow?.size === '1M') return '⚠ Ctx 200k+';
   const codes = issues.map((i) => i.code);
   if (codes.includes('LARGE_INPUT_PER_REQUEST')) return '⚠ Input spike';
   if (codes.includes('BUCKET_5M_DOMINANT')) return '⚠ 5m TTL';

package/src/demo.js

@@ -26,6 +26,7 @@ const SCENARIOS = [
       savings: 2123,
       elapsedSec: 30,
       contextSize: '200k',
+      ctxUsedPct: 34,
       spikeChip: null,
       caps: HEALTHY_CAPS,
     },
@@ -98,14 +99,15 @@ const SCENARIOS = [
   },
   {
     name: 'ctx-1m',
-    label: '⚠ 1M context auto-on',
+    label: '⚠ Context past 200k',
     data: {
       hitRate: 0.78,
       pct1h: 0.92,
       savings: 1340,
       elapsedSec: 30,
       contextSize: '1M',
-      spikeChip: '⚠ 1M ON',
+      ctxUsedPct: 28, // 28% of 1M ≈ 280k actually in context
+      spikeChip: '⚠ Ctx 200k+',
       caps: HEALTHY_CAPS,
     },
   },
@@ -271,7 +273,7 @@ export function buildTableDemoData(options = {}) {
     spikeReport: { spikes, baseline: { p95: 940_000 } },
     contextWindow: { size: '1M', maxContext: 280_000 },
     lastActivity: Date.now() - 60 * 1000,
-    spikeChip: '⚠ 1M ON',
+    spikeChip: '⚠ Ctx 200k+',
   };
 }
 
@@ -301,7 +303,7 @@ export function buildScenarioData(scenarioName, options) {
     if (!scenario) return null;
   }
 
-  const { hitRate, pct1h, pct5m, savings, elapsedSec, contextSize, spikeChip, caps } = scenario.data;
+  const { hitRate, pct1h, pct5m, savings, elapsedSec, contextSize, ctxUsedPct, spikeChip, caps } = scenario.data;
   return {
     summary: { hitRate },
     ttl: { pct1h, pct5m: pct5m ?? (1 - pct1h) },
@@ -314,6 +316,11 @@ export function buildScenarioData(scenarioName, options) {
     },
     lastActivity: Date.now() - elapsedSec * 1000,
     contextWindow: { size: contextSize },
+    // Live fill level (`📦 68%`) — scenarios that set ctxUsedPct exercise the
+    // stdin-driven segment; the rest fall back to the size-based chip.
+    ctxLive: ctxUsedPct != null
+      ? { usedPct: ctxUsedPct, size: contextSize === '1M' ? 1_000_000 : 200_000 }
+      : undefined,
     spikeChip,
     caps: buildCapsShape(caps),
     model: DEFAULT_MODEL,

package/src/formatters/statusline.js

@@ -214,7 +214,7 @@ export function formatNoSession({ caps = null, model = null, windowLabel = '' }
  * @param {string[]|null} [opts.segments] - whitelist of segments to render. Names: cap-warn, spike, harness, model, hit, ttl, saved, ctx, period, plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. Null/undefined = all.
  */
 export function formatReport(data, { color = true, verbose = false, timer = true, mode = 'text', segments = null } = {}) {
-  const { summary, ttl, cost, options, lastActivity, contextWindow, spikeChip, caps, model } = data;
+  const { summary, ttl, cost, options, lastActivity, contextWindow, ctxLive, spikeChip, caps, model } = data;
   const { hitRate } = summary;
 
   // Hit rate → color signal
@@ -321,15 +321,36 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     }
   }
 
-  // Context window chip (e.g. "📦 1M" or "📦 200k"). 1M gets a warning color
-  // because it's the expensive default on Max plans after Opus 4.7.
+  // Context chip. Two data sources, best first:
+  //
+  //  1. Live fill level from Claude Code's stdin (`context_window.used_percentage`)
+  //     — the current session's actual usage, refreshed every render. Rendered
+  //     as `📦 68%` and colored by fill (green <70, yellow 70–89, red 90+),
+  //     matching the cap-segment tone scale.
+  //  2. Fallback (table view / older Claude Code): transcript-inferred window
+  //     size. Note the semantics: `size === '1M'` means a real request already
+  //     carried >210k input tokens — actual heavy usage, not just the model
+  //     supporting 1M. Current models are all 1M by default with no price
+  //     premium, so this renders yellow ("your context is genuinely big"),
+  //     not red ("expensive mode on") like it used to.
   let ctxSeg = null;
-  if (contextWindow && contextWindow.size && contextWindow.size !== 'unknown') {
+  if (ctxLive && Number.isFinite(ctxLive.usedPct)) {
+    const pct = Math.max(0, Math.round(ctxLive.usedPct));
+    const tone = pct >= 90 ? RED : pct >= 70 ? YELLOW : GREEN;
+    const sizeLabel = ctxLive.size
+      ? (ctxLive.size >= 900_000 ? '1M' : `${Math.round(ctxLive.size / 1000)}k`)
+      : null;
+    const longLabel = sizeLabel ? `${pct}% of ${sizeLabel}` : `${pct}%`;
+    if (isIcon && verbose) {
+      ctxSeg = `${c(tone)}📦 Ctx ${longLabel}${c(RESET)}`;
+    } else if (isIcon) {
+      ctxSeg = `${c(tone)}📦 ${pct}%${c(RESET)}`;
+    } else {
+      ctxSeg = `${c(tone)}Ctx ${longLabel}${c(RESET)}`;
+    }
+  } else if (contextWindow && contextWindow.size && contextWindow.size !== 'unknown') {
     const label = contextWindow.size === '1M' ? '1M' : '200k';
-    const ctxColor = contextWindow.size === '1M' ? RED : GREEN;
-    // `Ctx` (not the full word `Context`) across every mode — the icon already
-    // tells the eye what the chip is, and the short form fits the same cadence
-    // as `Hit`/`Saved` peers when we eventually shorten those too.
+    const ctxColor = contextWindow.size === '1M' ? YELLOW : GREEN;
     if (isIcon && verbose) {
       ctxSeg = `${c(ctxColor)}📦 Ctx ${label}${c(RESET)}`;
     } else if (isIcon) {

package/src/formatters/table.js

@@ -86,7 +86,7 @@ function renderSpikeSection(spikes, contextWindow) {
   lines.push(r(`  ${'─'.repeat(50)}`));
   if (contextWindow && contextWindow.size === '1M') {
     lines.push(
-      r(`  Context mode: 1M  (max recent single-request input ${formatContextSize(contextWindow.maxContext)} tokens)`),
+      r(`  Context usage exceeded 200k  (max recent single-request input ${formatContextSize(contextWindow.maxContext)} tokens)`),
     );
     lines.push('');
   }
@@ -197,7 +197,7 @@ export function formatReport({ summary: sum, trend, ttl, anomalies, cost, option
   if (contextWindow && contextWindow.size !== 'unknown') {
     const note =
       contextWindow.size === '1M'
-        ? '⚠ 1M context active (Opus 4.7+ Max default). Disable with CLAUDE_CODE_DISABLE_1M_CONTEXT=1'
+        ? '⚠ Context exceeded 200k in recent requests — big contexts re-bill every turn and drain the 5H/7D caps. Use /compact or /clear.'
         : '✓ 200k context (standard)';
     lines.push(`  Context window: ${contextWindow.size}  ${note}`);
     lines.push(`  (max recent single-request input ${formatContextSize(contextWindow.maxContext)} tokens)`);

package/src/history.js

@@ -69,7 +69,8 @@ function saveState(state) {
 function chipKo(chip) {
   if (!chip) return chip;
   const map = {
-    '⚠ 1M ON': '⚠ 1M 컨텍스트 활성',
+    '⚠ Ctx 200k+': '⚠ 컨텍스트 200k 초과',
+    '⚠ 1M ON': '⚠ 1M 컨텍스트 활성', // legacy (pre-v2.18)
     '⚠ Cache miss': '⚠ 캐시 미스',
     '⚠ Rebuild churn': '⚠ 캐시 재빌드 빈발',
     '⚠ Input spike': '⚠ 입력 급증',
@@ -92,6 +93,9 @@ function chipKo(chip) {
  */
 function detailKo(detail) {
   if (!detail) return detail;
+  const m0 = detail.match(/^Single-request context exceeded 200k \(max (\d+)k tokens\)$/);
+  if (m0) return `단일 요청 컨텍스트 200k 초과 (최대 ${m0[1]}k 토큰)`;
+  // legacy detail shape (pre-v2.18)
   const m1 = detail.match(/^Context auto-promoted to 1M \(max single-request (\d+)k tokens\)$/);
   if (m1) return `1M 컨텍스트 자동 활성 (단일 요청 최대 ${m1[1]}k 토큰)`;
   const m2 = detail.match(/^session ([^:]+): (.+)$/);