sprag-cli 3.45.0 → 3.46.1

package/README.ko.md

@@ -66,7 +66,7 @@ gemini-2.5-pro        57.9%             $734  ▰▰▰▰▰▰▰▰▰▰▰
 
 ```
 🔀 라우팅 절감 $2.09  |  fable→sonnet 1회 $0.72 · opus→haiku 1회 $0.57
-🚨 5H █████▓ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 5 · 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 📅 weekly ██▒░░░ 38% · 💵 Sep $42 · 📦 Ctx 47% of 1M
+🚨 5H ▰▰▰▰▰▰▰▰▰▰▰▱ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 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` 여덟 가지이며, 칩 문구를 그대로 말하면 Skill이 원인 코드와 조치 순서를 꺼내 줍니다. 세그먼트별 의미와 색 기준은 [statusline 문서](https://github.com/rootstudioyaml/sprag/blob/main/docs/STATUSLINE.md)에 정리했습니다.

package/README.md

@@ -72,7 +72,7 @@ gemini-2.5-pro        57.9%             $734  ▰▰▰▰▰▰▰▰▰▰▰
 
 ```
 🔀 라우팅 절감 $2.09  |  fable→sonnet 1회 $0.72 · opus→haiku 1회 $0.57
-🚨 5H █████▓ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 5 · 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 📅 weekly ██▒░░░ 38% · 💵 Sep $42 · 📦 Ctx 47% of 1M
+🚨 5H ▰▰▰▰▰▰▰▰▰▰▰▱ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 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` 여덟 가지이며, 칩 문구를 그대로 말하면 Skill이 원인 코드와 조치 순서를 꺼내 줍니다. 세그먼트별 의미와 색 기준은 [statusline 문서](https://github.com/rootstudioyaml/sprag/blob/main/docs/STATUSLINE.md)에 정리했습니다.
@@ -211,7 +211,7 @@ The measured −18.6% comes from the harness and ratchet; routing and conversion
 
 ```
 🔀 Routing saved $2.09  |  fable→sonnet 1× $0.72 · opus→haiku 1× $0.57
-🚨 5H █████▓ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 5 · 🧠 Cache hit 98.8% · ⏳ Cache expires 59:46 · 📅 weekly ██▒░░░ 38% · 💵 Sep $42 · 📦 Ctx 47% of 1M
+🚨 5H ▰▰▰▰▰▰▰▰▰▰▰▱ 94% 🔄 12:36 · 🅷 5/5 · 🤖 Opus 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`. Say the chip wording inside Claude and the Skill surfaces the root-cause code and the fix. Segment-by-segment meanings live in [the statusline reference](./docs/STATUSLINE.md).

package/bin/cli.js

@@ -325,7 +325,12 @@ async function main() {
       console.log('예산 캐시가 비어 있습니다. `sprag litellm-budget --refresh` 로 먼저 조회하십시오.');
       return;
     }
-    for (const line of formatBudgetReport(state)) console.log(line);
+    // Same resolver the statusline uses: this report draws a gauge too, and a
+    // glyph the terminal's font lacks garbles here exactly as it does there.
+    const { resolveLabelMode } = await import('../src/statusline-mode.js');
+    const { statuslineDefaults } = await import('../src/config.js');
+    const { mode: labelMode } = resolveLabelMode({ hasFlag, cfg: statuslineDefaults() });
+    for (const line of formatBudgetReport(state, new Date(), labelMode)) console.log(line);
     return;
   }
 

package/examples/statusline-command.ps1

@@ -1,9 +1,9 @@
 # Claude Code statusline (Windows PowerShell version)
 # Mirrors the POSIX sh script — prints "user@host:cwd" then appends
-# claude-token-saver output as a second segment.
+# sprag output as a second segment.
 #
 # Install:
-#   1) npm install -g claude-token-saver
+#   1) npm install -g sprag-cli
 #   2) Save this file as: %USERPROFILE%\.claude\statusline-command.ps1
 #   3) In %USERPROFILE%\.claude\settings.json add:
 #      {
@@ -30,14 +30,20 @@ Write-Host -NoNewline "$esc[01;32m$env:USERNAME@$env:COMPUTERNAME$esc[00m`:$esc[
 # 2) cache monitor (appended). Separator " | ". Falls back silently.
 Write-Host -NoNewline " $esc[90m|$esc[00m "
 
-$cacheMonitor = Get-Command claude-token-saver -ErrorAction SilentlyContinue
+# `claude-token-saver` is the older binary name, still installed by the current
+# package; the npx fallback names `sprag-cli`, since the old package name is
+# deprecated on npm and would fetch a version that stopped receiving releases.
+$cacheMonitor = Get-Command sprag -ErrorAction SilentlyContinue
+if (-not $cacheMonitor) {
+  $cacheMonitor = Get-Command claude-token-saver -ErrorAction SilentlyContinue
+}
 if ($cacheMonitor) {
   try {
-    & claude-token-saver --statusline --icon 2>$null
+    & $cacheMonitor.Name --statusline --icon 2>$null
   } catch { }
 } else {
   # fallback: npx (first run downloads the package; subsequent runs are warm)
   try {
-    & npx --yes claude-token-saver@latest --statusline --icon 2>$null
+    & npx --yes sprag-cli@latest --statusline --icon 2>$null
   } catch { }
 }

package/examples/statusline-command.sh

@@ -1,9 +1,9 @@
 #!/bin/sh
 # Claude Code statusline (POSIX sh — works on macOS, Linux, and WSL)
-# Prints "user@host:cwd" then appends claude-token-saver as a second segment.
+# Prints "user@host:cwd" then appends sprag as a second segment.
 #
 # Install:
-#   1) npm install -g claude-token-saver
+#   1) npm install -g sprag-cli
 #   2) Save this file as: ~/.claude/statusline-command.sh
 #      chmod +x ~/.claude/statusline-command.sh  (optional)
 #   3) In ~/.claude/settings.json:
@@ -29,8 +29,13 @@ printf '\033[01;32m%s@%s\033[00m:\033[01;34m%s\033[00m' "$(whoami)" "$(hostname
 
 # 2) cache monitor (appended). Separator " | ". Falls back silently.
 printf ' \033[90m|\033[00m '
-if command -v claude-token-saver >/dev/null 2>&1; then
+# `claude-token-saver` is the older binary name, still installed by the current
+# package; the npx fallback names `sprag-cli`, since the old package name is
+# deprecated on npm and would fetch a version that stopped receiving releases.
+if command -v sprag >/dev/null 2>&1; then
+  sprag --statusline --icon 2>/dev/null || true
+elif command -v claude-token-saver >/dev/null 2>&1; then
   claude-token-saver --statusline --icon 2>/dev/null || true
 else
-  npx --yes claude-token-saver@latest --statusline --icon 2>/dev/null || true
+  npx --yes sprag-cli@latest --statusline --icon 2>/dev/null || true
 fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.45.0",
+  "version": "3.46.1",
   "description": "Sprag - a quality ratchet harness for AI coding agents: model-fitting delegation, ratchet rules, doc2md, Korean style gate. Same tool as claude-token-saver, under its new name.",
   "type": "module",
   "bin": {
@@ -8,12 +8,14 @@
     "claude-token-saver": "bin/cli.js"
   },
   "scripts": {
-    "test": "node --test",
+    "deploy": "node scripts/deploy.mjs",
     "docs:statusline": "node scripts/docs-statusline.mjs",
     "postinstall": "node bin/cli.js install || true",
+    "prepublishOnly": "node scripts/sync-readme-ko.mjs",
     "publish:legacy": "node scripts/publish-legacy.mjs",
+    "release:notes": "node scripts/release-notes.mjs",
     "sync:ko": "node scripts/sync-readme-ko.mjs",
-    "prepublishOnly": "node scripts/sync-readme-ko.mjs"
+    "test": "node --test"
   },
   "files": [
     "bin/",

package/src/changelog.js

@@ -0,0 +1,70 @@
+/**
+ * changelog — read one version's section out of CHANGELOG.md, and say whether a
+ * notes draft is still waiting on a person.
+ *
+ * Separate from scripts/release-notes.mjs, which is a CLI: importing that file
+ * runs its argument parsing and exits, so the extraction it depends on cannot be
+ * tested through it. The boundary logic is the part worth pinning — a section
+ * pulled one line short drops the release's last item, and one line long carries
+ * the previous release's first, and the upgrade offer shows either without
+ * complaint.
+ *
+ * The draft marker lives here for a reason. Two scripts gate on it — the one that
+ * writes drafts and the one that deploys — and they used to carry the string
+ * separately. Renaming it in one left the other looking for text that no longer
+ * existed, and a gate that greps for an absent string does not fail: it passes,
+ * and an unreviewed draft goes out as the release. One definition, imported.
+ */
+
+/**
+ * The body of one version's section, heading excluded.
+ *
+ * @param {string} changelog - CHANGELOG.md contents
+ * @param {string} version - e.g. "3.45.0"
+ * @returns {string|null} the section text, or null when that version has none
+ */
+export function sectionFor(changelog, version) {
+  const lines = String(changelog).split(/\r?\n/);
+  // The version has to match to its end: without the boundary, "3.42.0" would
+  // also match the "### v3.42.7" heading and publish the wrong notes.
+  const head = new RegExp(`^### v${String(version).replace(/\./g, '\\.')}(\\s|$|\\()`);
+  const start = lines.findIndex((l) => head.test(l));
+  if (start < 0) return null;
+  const out = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    // The next version heading ends this section, and so does a shallower one:
+    // "## All releases" is a container, not part of any release.
+    if (/^### v/.test(lines[i]) || /^## /.test(lines[i])) break;
+    out.push(lines[i]);
+  }
+  return out.join('\n').trim();
+}
+
+/**
+ * The line `release-notes.mjs` writes at the top of a fresh draft, and the line
+ * every gate refuses on. A draft still carrying it has not been through a person.
+ */
+export const DRAFT_MARKER =
+  '<!-- REVIEW: edit this draft, add the English half, then delete this line -->';
+
+/** Heading that opens the Korean half of a bilingual release body. */
+export const KO_HEADING = '## 한국어';
+
+/**
+ * The opening of the marker, which is what the gate actually matches. Spelled out
+ * rather than sliced off `DRAFT_MARKER`, so that editing the marker's front does
+ * not silently change what is being tested for.
+ */
+const REVIEW_OPENING = '<!-- REVIEW:';
+
+/**
+ * Whether a draft still needs review. Matches on the `<!-- REVIEW:` opening
+ * rather than the whole line, so editing the wording of the instruction does not
+ * quietly disarm the gate.
+ *
+ * @param {string} draft - the draft file's contents
+ * @returns {boolean} true while the draft is unreviewed
+ */
+export function needsReview(draft) {
+  return String(draft || '').includes(REVIEW_OPENING);
+}

package/src/cli-name.js

@@ -0,0 +1,25 @@
+/**
+ * cli-name — the name this tool tells the user to type.
+ *
+ * One definition, because the alternative was measured: the marker string in the
+ * release scripts lived in two files, one was renamed, and the gate that grepped
+ * for the other silently stopped gating. A command name printed for the user to
+ * copy fails more quietly still — nothing errors, the user simply types a name
+ * that is not the package they installed.
+ *
+ * `sprag-cli` is the package; `claude-token-saver` is the deprecated name it
+ * shipped under, and both binaries are still in `package.json`'s `bin`, so the
+ * old name keeps working for anyone whose settings or notes carry it.
+ *
+ * NOT the same thing as the on-disk identifiers. The state directory, the harness
+ * block markers, and the skill directory are all still spelled with the old name
+ * on purpose: renaming those would orphan existing users' ledgers and stop the
+ * harness markers matching text already in their CLAUDE.md. Those are addresses,
+ * not instructions, and an address only has to be stable.
+ */
+
+/** The command name to print in anything a user is expected to type or read. */
+export const CLI_NAME = 'sprag';
+
+/** The deprecated name. Still a working binary; recognised, never printed. */
+export const LEGACY_CLI_NAME = 'claude-token-saver';

package/src/commands/install.js

@@ -71,6 +71,7 @@ export async function run({ hasFlag }) {
     const r = installAll({ force });
     print('skill', r.skill);
     print('SessionStart hook (route-scan)', r.sessionStartHook);
+    print('PostToolUse hook (delegation rescan)', r.delegationHook);
     print('UserPromptSubmit hook (brief)', r.briefHook);
     {
       let s = r.statusline;

package/src/commands/route-scan.js

@@ -174,11 +174,27 @@ export async function run({ args, hasFlag, numArg }) {
       const scan = rs.readRouteScan();
       if (scan?.unresolvedRuns > 0) {
         const ids = (scan.unresolvedModels || []).join(', ');
+        // Unlike the statusline chip, this listing reports even a single one: the
+        // user ran this command to find out why a rule reads as never fired, and
+        // there is room here to answer properly. But a gateway's opaque profile
+        // ARN is normally resolved by learning from observed runs, which needs
+        // MIN_VOTES of them — so below that, the honest advice is to wait rather
+        // than to go edit a config file.
+        const { MIN_VOTES } = await import('../model-alias.js');
+        const learning = scan.unresolvedRuns < MIN_VOTES;
+        const remedyKo = learning
+          ? `\n  위임이 ${MIN_VOTES}건 이상 쌓이면 자동으로 해석될 수 있습니다. 그때까지 기다렸다가 다시 확인하고,`
+            + '\n  게이트웨이가 모델 이름을 아예 알려 주지 않는 환경이라면 profile-map.json 의 modelAliases 에'
+            + '\n  해당 ID 를 매핑한 뒤 route-scan --refresh 를 실행하십시오.'
+          : '\n  profile-map.json 의 modelAliases 에 해당 ID 를 매핑한 뒤 route-scan --refresh 를 실행하십시오.';
+        const remedyEn = learning
+          ? `\n  These may resolve on their own once ${MIN_VOTES} or more delegated runs accumulate — check again then.`
+            + '\n  If the gateway never reports a model name at all, map the id under modelAliases in'
+            + '\n  profile-map.json and run route-scan --refresh.'
+          : '\n  Map it under modelAliases in profile-map.json, then run route-scan --refresh.';
         console.log(lang === 'ko'
-          ? `\n⚠ 해석되지 않은 모델 ID 때문에 위임 ${scan.unresolvedRuns}건이 집계에서 제외됐습니다${ids ? ` (${ids})` : ''}.`
-            + '\n  profile-map.json 의 modelAliases 에 해당 ID 를 매핑한 뒤 route-scan --refresh 를 실행하십시오.'
-          : `\n⚠ ${scan.unresolvedRuns} delegated run(s) were excluded — unpriceable model id${ids ? ` (${ids})` : ''}.`
-            + '\n  Map it under modelAliases in profile-map.json, then run route-scan --refresh.');
+          ? `\n⚠ 해석되지 않은 모델 ID 때문에 위임 ${scan.unresolvedRuns}건이 집계에서 제외됐습니다${ids ? ` (${ids})` : ''}.` + remedyKo
+          : `\n⚠ ${scan.unresolvedRuns} delegated run(s) were excluded — unpriceable model id${ids ? ` (${ids})` : ''}.` + remedyEn);
       }
       console.log(lang === 'ko'
         ? '\n제거: sprag route-scan rules rm <N>'
@@ -203,6 +219,33 @@ export async function run({ args, hasFlag, numArg }) {
       return;
     }
 
+    // --hook-delegated: PostToolUse hook for Task/Agent. A delegation just
+    // finished, which is the one event guaranteed to change what a scan
+    // produces — its savings and its error rate both move. Kicks a detached
+    // refresh so the statusline shows the new figure on its next render
+    // instead of waiting out the hourly gate, and prints nothing: a tool
+    // result is not a place for our commentary.
+    if (hasFlag('--hook-delegated')) {
+      const payload = readStdinJson() || {};
+      // Claude Code matches the hook by tool name already, but the payload is
+      // the only thing that proves it: a mis-registered matcher would otherwise
+      // have us rescanning after every Read.
+      const tool = payload.tool_name;
+      if (tool !== 'Task' && tool !== 'Agent') return;
+      try {
+        const cache = rs.readRouteScan();
+        if (!(await rs.shouldRescan(cache, { afterDelegation: true }))) return;
+        const { spawn } = await import('node:child_process');
+        spawn(process.execPath, [process.argv[1], 'route-scan', '--refresh', '--quiet'],
+          { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+      } catch (e) {
+        // A missed refresh only means the figure lags, which is what happened
+        // before this hook existed. Never fail the tool call over it.
+        debug('route-scan:delegated-refresh', e);
+      }
+      return;
+    }
+
     // --hook: SessionStart hook mode. Never scans inline (session start must
     // stay fast) — reads the cache, kicks a detached refresh when stale, and
     // prints delegation-candidate context for the new session.
@@ -299,16 +342,32 @@ export async function run({ args, hasFlag, numArg }) {
         // `dismissed` is the whole point of asking once: a user who said no to
         // this version must not be asked again every `/clear`.
         if (u && u.available && !u.dismissed) {
+          // What the release adds, when we managed to read it. "A newer version
+          // exists" is not a reason to upgrade; the reason is in this list, and
+          // without it the user is being asked to decide on no information.
+          const notes = Array.isArray(u.highlights) ? u.highlights : [];
+          const koNotes = notes.length
+            ? ['  이 버전에서 새로 생긴 것:', ...notes.map((n) => `    · ${n}`)]
+            : [];
+          const enNotes = notes.length
+            ? ['  What this release adds:', ...notes.map((n) => `    · ${n}`)]
+            : [];
           updateBlock = lang === 'ko'
             ? [
                 `[sprag update] 새 버전이 나와 있습니다: v${u.current} → ${u.latest}.`,
-                '사용자에게 지금 업그레이드할지 물어보고, 승낙하면 아래 명령을 실행하십시오. 묻지 않고 설치하지는 마십시오.',
-                '  sprag upgrade            # 업그레이드 실행',
+                ...koNotes,
+                notes.length
+                  ? '  위 내용을 사용자에게 보여 주고 업그레이드할지 물어보십시오. 승낙하면 아래 명령을 실행하고, 묻지 않고 설치하지는 마십시오.'
+                  : '  사용자에게 지금 업그레이드할지 물어보고, 승낙하면 아래 명령을 실행하십시오. 묻지 않고 설치하지는 마십시오.',
+                '  sprag upgrade                  # 업그레이드 실행',
                 '  sprag update-check --dismiss   # 사용자가 원치 않으면 (다음 버전이 나올 때까지 다시 묻지 않습니다)',
               ].join('\n')
             : [
                 `[sprag update] A newer version is available: v${u.current} → ${u.latest}.`,
-                'Ask the user whether to upgrade now, and run the command below only if they agree. Do not install without asking.',
+                ...enNotes,
+                notes.length
+                  ? '  Show that list to the user and ask whether to upgrade. Run the command below only if they agree; do not install without asking.'
+                  : 'Ask the user whether to upgrade now, and run the command below only if they agree. Do not install without asking.',
                 '  sprag upgrade                  # perform the upgrade',
                 '  sprag update-check --dismiss   # if they decline (stays quiet until a newer release)',
               ].join('\n');

package/src/commands/uninstall.js

@@ -1,8 +1,8 @@
 /**
  * Subcommand: uninstall — take the integration back out of ~/.claude.
  *
- *   claude-token-saver uninstall           # hooks, statusline, skill
- *   claude-token-saver uninstall --purge   # the above plus recorded state
+ *   sprag uninstall           # hooks, statusline, skill
+ *   sprag uninstall --purge   # the above plus recorded state
  *
  * Recorded savings are kept by default. Someone removing an integration is
  * usually not asking to throw away the ledger that says what it saved, and
@@ -12,6 +12,7 @@
 export async function run({ hasFlag, args = [] }) {
   const { uninstallAll } = await import('../installer.js');
   const { userLanguage } = await import('../config.js');
+  const { CLI_NAME } = await import('../cli-name.js');
   const lang = userLanguage();
   const purge = hasFlag('--purge') || args.includes('--purge');
 
@@ -36,7 +37,7 @@ export async function run({ hasFlag, args = [] }) {
   }
   if (!purge) {
     console.log(lang === 'ko'
-      ? '  기록된 절감액과 설정까지 지우려면 `claude-token-saver uninstall --purge` 를 실행하십시오.'
-      : '  To remove recorded savings and settings too: `claude-token-saver uninstall --purge`.');
+      ? `  기록된 절감액과 설정까지 지우려면 \`${CLI_NAME} uninstall --purge\` 를 실행하십시오.`
+      : `  To remove recorded savings and settings too: \`${CLI_NAME} uninstall --purge\`.`);
   }
 }

package/src/formatters/statusline.js

@@ -23,6 +23,7 @@ import { labelForKey } from '../window-labels.js';
 import { harnessStatusForStatusline } from '../harness.js';
 import { loadConfig } from '../config.js';
 import { koreanStyleEnabled } from '../korean-style.js';
+import { MIN_VOTES } from '../model-alias.js';
 
 // The 8-color ANSI defaults (RED=31, GREEN=32, YELLOW=33…) read as garish
 // next to each other — terminal palettes set them with unbalanced perceptual
@@ -67,88 +68,86 @@ function formatPct(v) {
 }
 
 /**
- * Render a 6-cell density-gradient gauge for `pct` (0..100). All cells share
- * the same Unicode "Block Elements" density family — `█` (100%) → `▓` (75%)
- * → `▒` (50%) → `░` (25%) — so the fill→empty boundary reads as one smooth
- * gradient instead of an awkward step.
+ * Render the gauge for `pct` (0..100) as a row of separate ticks.
  *
- * Earlier we used partial-fill glyphs (`▏▎▍▌▋▊▉`) for sub-cell precision, but
- * those have transparent halves that clash visually with the `░` track next
- * to them (the eye sees "solid edge | gap | dotted track" — three zones).
- * Density chars are the same shape, just darker/lighter, so the boundary
- * cell reads as a single smooth fade.
+ * The bar used to be six cells of one continuous block, with the boundary cell
+ * subdivided into eighths for sub-cell precision. That precision had no reader:
+ * every chip that draws a gauge prints the exact percentage immediately after it
+ * (`▰▰▰▱▱▱ 26%`), so the bar's job is the glance, not the number. What the solid
+ * run cost instead was legibility — adjacent full cells fuse into one shape, and
+ * a shape has no quantity you can read off it. Separate ticks do: twelve of them
+ * are countable at a glance and land on a familiar 1/12 grid.
  *
- * Each cell is ~17% wide; the boundary cell uses 3 intermediate density steps
- * for ~4% effective precision around the fill edge. Stable monospace width
- * across all terminal fonts that ship Block Elements (U+2580–U+259F).
+ * Two ends get special treatment, because they are the two readings that change
+ * a decision. A full row means the limit is reached, so nothing below 100% may
+ * draw one; conversely anything above zero draws at least one tick, so "barely
+ * started" never looks like "untouched". Rounding alone gets both wrong: it fills
+ * the last cell from 96% and leaves the first empty until 5%.
+ *
+ * Glyphs come from the mode's set (src/glyphs.js) rather than being fixed here.
+ * ▰▱ is the shape we want, but JetBrains Mono ships neither character, and a
+ * missing glyph is drawn by a fallback font whose advance width does not match
+ * the cell grid — which is the whole reason narrow mode exists. So narrow draws
+ * the same segmented bar with ■□, which that font does have.
+ *
+ * @param {number} pct
+ * @param {string} [mode] label mode; selects the tick glyphs
+ * @returns {{ filled: string, empty: string }} the two halves, so a caller can
+ *   color them separately
  */
-export function gaugeParts(pct) {
-  const cells = 6;
+export function gaugeParts(pct, mode = 'icon') {
+  const CELLS = 12;
+  const g = glyphsFor(mode);
   const clamped = Math.max(0, Math.min(100, pct));
-  const filled = (clamped / 100) * cells; // e.g. 4.32 cells filled
-  const fullCells = Math.floor(filled);
-  const remainder = filled - fullCells; // 0..1 — fill fraction of the boundary cell
-  // Boundary cell in eighths. The earlier version had three steps (░ ▒ ▓), which
-  // meant 25% and 31% drew the same bar; eighths keep the resolution the width
-  // of the bar can carry, so the gauge moves as the number does. Every character
-  // here is present in JetBrains Mono, which is why the gauge was the one part
-  // of the line that never garbled under IntelliJ (see src/glyphs.js).
-  const EIGHTHS = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉'];
-  // Empty cells use ▒ rather than ░. In JetBrains Mono the eighth blocks all sit
-  // at yMin -300 / xMin 0, while ░ sits at yMin -240 / xMin 60 — about 4% of the
-  // cell height and 10% of its width inset — so a bar mixing them looks visibly
-  // misaligned, the empty half riding high and shifted inward. ▒ shares the box
-  // with the filled glyphs and still reads clearly lighter than █.
-  const step = Math.round(remainder * 8);
-  // A boundary cell rounded up to 8/8 is a full cell, not a ninth glyph.
-  const extra = step === 8 ? 1 : 0;
-  const totalFull = Math.min(cells, fullCells + extra);
-  const partial = totalFull < cells && extra === 0 ? EIGHTHS[step] : '';
-  const usedCells = totalFull + (partial ? 1 : 0);
-  const empty = '▒'.repeat(Math.max(0, cells - usedCells));
-  return { filled: '█'.repeat(totalFull) + partial, empty };
+  let ticks = Math.round((clamped / 100) * CELLS);
+  // A full row is reserved for an actual 100%: at the cap the gauge alone has to
+  // say so, and 96% rounding up to twelve would spend that signal on a window
+  // that still has room.
+  if (ticks >= CELLS && clamped < 100) ticks = CELLS - 1;
+  // And any nonzero usage earns a tick, so an empty row means untouched.
+  if (ticks === 0 && clamped > 0) ticks = 1;
+  return {
+    filled: g.gaugeFull.repeat(ticks),
+    empty: g.gaugeEmpty.repeat(CELLS - ticks),
+  };
 }
 
 /**
  * The bar as one string, for callers that render it in a single color.
  * @param {number} pct
+ * @param {string} [mode] label mode; selects the tick glyphs
  * @returns {string}
  */
-export function gaugeBar(pct) {
-  const { filled, empty } = gaugeParts(pct);
+export function gaugeBar(pct, mode = 'icon') {
+  const { filled, empty } = gaugeParts(pct, mode);
   return filled + empty;
 }
 
 /**
- * The bar with the unused cells dimmed.
+ * The bar with the unused ticks dimmed.
  *
- * ▒ shares its glyph box with the filled blocks, which is why it replaced ░, but
- * it is also denser than ░ was — in one color the used and unused halves stop
- * reading as different. Graying the remainder restores the contrast that the
- * shading alone used to carry. The segment tone is reinstated at the end so the
- * text after the bar keeps the color it started in.
+ * The hollow tick already distinguishes the two halves by shape, so color is not
+ * carrying that distinction the way it had to when both halves were the same
+ * solid block. It still helps: graying the remainder keeps the filled run as the
+ * only thing at full brightness, which is what the eye should land on. The
+ * segment tone is reinstated at the end so the text after the bar keeps the color
+ * it started in.
  *
  * @param {number} pct
  * @param {(code: string) => string} c - color emitter (returns '' when color is off)
  * @param {string} tone - the segment's own color code
  * @param {boolean} color - whether ANSI is allowed. Passed explicitly rather
  *   than inferred from `c` emitting nothing: that inference reads the emitter's
- *   current implementation, and a caller that wraps or replaces `c` would flip
- *   the track glyph as a side effect nobody asked for.
+ *   current implementation, and a caller that wraps or replaces `c` would change
+ *   behaviour here as a side effect nobody asked for.
+ * @param {string} [mode] label mode; selects the tick glyphs
  * @returns {string}
  */
-function gaugeColored(pct, c, tone, color) {
-  const { filled, empty } = gaugeParts(pct);
+function gaugeColored(pct, c, tone, color, mode = 'icon') {
+  const { filled, empty } = gaugeParts(pct, mode);
   if (!empty) return filled;
-  // With color available, the unused cells are the same solid block as the used
-  // ones, just gray. Shading characters (░ ▒) carry a dither pattern that reads
-  // as noise beside a solid fill — the two halves look like different materials
-  // rather than two states of one bar. One glyph in two colors reads as a track
-  // filling up, and it sidesteps the glyph-box mismatch between the shades and
-  // the blocks entirely. Without color there is nothing but texture to tell them
-  // apart, so the shading stays.
-  const track = color ? '█'.repeat(empty.length) : empty;
-  return `${filled}${c(RESET)}${c(GRAY)}${track}${c(RESET)}${c(tone)}`;
+  if (!color) return filled + empty;
+  return `${filled}${c(RESET)}${c(GRAY)}${empty}${c(RESET)}${c(tone)}`;
 }
 
 /**
@@ -266,11 +265,9 @@ function buildHarnessSeg(c, isIcon, g) {
  * the wall-clock reset time rides along in the same `🔄 HH:MM` shape as the
  * always-on usage segments.
  */
-function buildCapWarnSeg(capWarn, c, isIcon, g, color) {
-  // `color` is only for the gauge. At 90%+ the bar has no unused cells left, so
-  // gaugeColored returns early and never reads it today — it is threaded through
-  // anyway, because a change to the cap-warn threshold or the bar width would
-  // otherwise start drawing the wrong track with nothing to catch it.
+function buildCapWarnSeg(capWarn, c, isIcon, g, color, mode) {
+  // `color` and `mode` are both for the gauge: the first decides whether the
+  // unused ticks are dimmed, the second which pair of tick glyphs to draw.
   if (!capWarn) return null;
   const pct = Math.round(capWarn.usedPct);
   const clock = formatResetClock(capWarn.resetsAt);
@@ -281,7 +278,7 @@ function buildCapWarnSeg(capWarn, c, isIcon, g, color) {
     // Gauge keeps shape parity with the always-on usage segment — the
     // cap-warn is just the same gauge "filled to alarm". Visual continuity
     // helps the eye understand "this is the 5H bar I was watching, just red now."
-    const bar = gaugeColored(pct, c, RED, color);
+    const bar = gaugeColored(pct, c, RED, color, mode);
     return `${c(BOLD)}${c(RED)}${g.capWarn} ${capWarn.label} ${bar} ${pct}%${clockTail}${c(RESET)}`;
   }
   return `${c(BOLD)}${c(RED)}${capWarn.label} cap ${pct}%${clockTail}${c(RESET)}`;
@@ -301,7 +298,7 @@ export function formatNoSession({ caps = null, model = null, windowLabel = '', v
   const isIcon = mode === 'icon' || mode === 'narrow';
   const g = glyphsFor(mode);
   const segs = [];
-  const capSeg = buildCapWarnSeg(pickCapWarn(caps), c, isIcon, g, color);
+  const capSeg = buildCapWarnSeg(pickCapWarn(caps), c, isIcon, g, color, mode);
   if (capSeg) segs.push(capSeg);
   const versionSeg = buildVersionSeg(version, update, c, isIcon, false, g);
   if (versionSeg && update && update.available) segs.push(versionSeg);
@@ -443,10 +440,18 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // identical, so users in the second case had no reason to suspect anything
   // was wrong. The count gets a chip; the explanation stays in `route-scan
   // rules`, where there is room for it.
+  //
+  // But only once there are enough of them to mean anything. A gateway reports
+  // an opaque profile ARN, and the fix for that is learned from observed runs —
+  // which needs MIN_VOTES of them before it can conclude anything. Below that
+  // threshold an unresolved run is not a problem, it is the first day of a
+  // working mechanism, and warning about it makes a fresh install look broken.
+  // Tied to MIN_VOTES rather than a literal so the two cannot drift: the chip
+  // appears exactly when learning has had its chance and still came up short.
   const unresolvedRuns = Number(data.unresolvedRuns) || 0;
   const delegateSeg = delegationSaved > 0
     ? `${c(GREEN)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}`
-    : (unresolvedRuns > 0
+    : (unresolvedRuns >= MIN_VOTES
       ? `${c(YELLOW)}${g.routing} ${unresolvedRuns} unresolved${c(RESET)}`
       : null);
 
@@ -750,7 +755,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     const src = info.source === 'user' ? ' (user)' : '';
     if (isIcon) {
       const labelPart = labels.usageLabel ? `${labels.usageLabel}${src} ` : '';
-      const bar = gaugeColored(pct, c, tone, color);
+      const bar = gaugeColored(pct, c, tone, color, mode);
       const winGlyph = mode === 'narrow' ? (labels.narrowIcon || labels.icon) : labels.icon;
       return `${c(tone)}${winGlyph} ${labelPart}${bar} ${pct}%${money}${tail}${c(RESET)}`;
     }
@@ -787,7 +792,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     }
   }
 
-  const capWarnSeg = buildCapWarnSeg(capWarn, c, isIcon, g, color);
+  const capWarnSeg = buildCapWarnSeg(capWarn, c, isIcon, g, color, mode);
 
   // Warning chip leads — a glance at the statusline catches "something's wrong"
   // before parsing any numbers. Healthy states have no chip and look unchanged.