sprag-cli 3.45.0 → 3.46.1

package/src/formatters/table.js

@@ -2,6 +2,7 @@
  * Terminal table formatter — zero dependencies.
  */
 import { ISSUE_MESSAGES } from '../advice.js';
+import { CLI_NAME } from '../cli-name.js';
 import { formatResetIn, formatResetClock } from '../format-time.js';
 import { labelForKey } from '../window-labels.js';
 
@@ -139,7 +140,7 @@ function renderSpikeSection(spikes, contextWindow) {
       lines.push('');
     }
   }
-  lines.push(rbl('  ▶ 상세 처치법: ') + rb('claude-token-saver last'));
+  lines.push(rbl('  ▶ 상세 처치법: ') + rb(`${CLI_NAME} last`));
   lines.push('');
   return lines;
 }
@@ -165,10 +166,10 @@ function renderCapWarnSection(caps) {
   }
   lines.push('');
   lines.push(r('  Back up work before the cap hits:'));
-  lines.push(rb('    claude-token-saver handoff'));
+  lines.push(rb(`    ${CLI_NAME} handoff`));
   lines.push(r('  (writes a HANDOFF-*.md so a fresh session can pick up.)'));
   lines.push('');
-  lines.push(rbl('  ▶ 상세 처치법: ') + rb('claude-token-saver last'));
+  lines.push(rbl('  ▶ 상세 처치법: ') + rb(`${CLI_NAME} last`));
   lines.push('');
   return lines;
 }
@@ -179,7 +180,7 @@ export function formatReport({ summary: sum, trend, ttl, anomalies, cost, option
   // Header
   lines.push('');
   lines.push(`  Claude Token Saver — Last ${options.days} day${options.days === 1 ? '' : 's'}`);
-  lines.push(`  (claude-token-saver v${options.version || ''})`.trimEnd());
+  lines.push(`  (${CLI_NAME} v${options.version || ''})`.trimEnd());
   lines.push(`  ${'═'.repeat(50)}`);
   lines.push('');
 

package/src/glyphs.js

@@ -19,6 +19,13 @@
  * Per-window glyphs (the 5h star, the weekly grid, the budget box) live in
  * src/window-labels.js instead, next to the labels they belong to.
  *
+ * The gauge cells live here too, for the same reason the chip glyphs do. The
+ * shapes differ by mode rather than only the vocabulary: ▰▱ read as a row of
+ * separate ticks, which is what a gauge is, but JetBrains Mono ships neither
+ * (verified via its cmap: U+25B0 and U+25B1 are absent, U+25A0 and U+25A1 are
+ * present). So the narrow set draws the same segmented shape with ■□ instead of
+ * falling back to a font whose advance width would garble the line.
+ *
  * Width still matters as a second filter — a fullwidth glyph would occupy two
  * cells — so every narrow glyph is also East Asian Width N/Na. The test suite
  * enforces both properties.
@@ -40,6 +47,12 @@ const ICON = {
   ctx: '📦',
   saved: '💰',
   reset: '🔄',
+  // Gauge cells. Separate ticks rather than one continuous block: the bar is a
+  // count of how much of a budget is gone, and ticks are countable where a solid
+  // run is not. Precision is not this bar's job — an exact percentage is printed
+  // immediately after it in every chip that draws one.
+  gaugeFull: '▰',
+  gaugeEmpty: '▱',
 };
 
 /**
@@ -62,6 +75,10 @@ const NARROW = {
   ctx: '◧',       // a box filling up
   saved: '✓',
   reset: '↩',     // the window turning over
+  // Same segmented shape as the icon set, in the two glyphs this font has.
+  // ▰▱ (U+25B0/25B1) are absent from JetBrains Mono; ■□ (U+25A0/25A1) are there.
+  gaugeFull: '■',
+  gaugeEmpty: '□',
 };
 
 const SETS = { icon: ICON, narrow: NARROW };

package/src/hook-manager.js

@@ -12,6 +12,7 @@
 import { readFile, writeFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { CLI_NAME } from './cli-name.js';
 
 const SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
 // Legacy copied-file location — removed on install/uninstall so machines that
@@ -48,7 +49,7 @@ export async function installHook({ threshold = 0.7 } = {}) {
     hooks: [
       {
         type: 'command',
-        command: `claude-token-saver --hook-run --threshold ${threshold}`,
+        command: `${CLI_NAME} --hook-run --threshold ${threshold}`,
         timeout: 10,
       },
     ],
@@ -59,7 +60,7 @@ export async function installHook({ threshold = 0.7 } = {}) {
   // Clean up the legacy copy left by older versions.
   await rm(LEGACY_HOOK_DEST, { force: true }).catch(() => {});
 
-  console.log('✓ Hook installed (PostToolUse → claude-token-saver --hook-run)');
+  console.log(`✓ Hook installed (PostToolUse → ${CLI_NAME} --hook-run)`);
   console.log(`  Settings updated: ${SETTINGS_PATH}`);
   console.log(`  Threshold: ${(threshold * 100).toFixed(0)}%`);
   console.log(`  Stats file: ~/.claude/cache-stats.jsonl`);

package/src/installer.js

@@ -14,10 +14,64 @@
  */
 
 import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync, rmSync } from 'node:fs';
+import { CLI_NAME, LEGACY_CLI_NAME } from './cli-name.js';
 import { join } from 'node:path';
 import { claudeUserDir, userDataDir } from './paths.js';
 
-const STATUSLINE_COMMAND = 'claude-token-saver --statusline --icon';
+/**
+ * The command every entry we write invokes.
+ *
+ * Both binaries ship in `package.json`'s `bin`, so either name works — but the
+ * package is `sprag-cli`, and a fresh install writing `claude-token-saver` into
+ * the user's settings puts a name they never typed in a file they read.
+ *
+ * The reverse direction is not symmetrical: entries ALREADY on disk carry the
+ * old name, so anything that recognises our own work has to accept both. That is
+ * what `isOurCommand` is for — narrowing it to the new name would make install
+ * miss an existing hook and add a second one beside it.
+ */
+const CLI = CLI_NAME;
+const LEGACY_CLI = LEGACY_CLI_NAME;
+
+/**
+ * Whether a settings command belongs to this tool, under either name.
+ *
+ * The name has to sit where the executable goes, not just appear somewhere in the
+ * string. `sprag` is five characters, and `uninstall` deletes what this returns
+ * true for: a substring test claims `node ~/.claude/probe/sprag-probe.mjs` and
+ * anyone's `my-sprag-wrapper`, then removes them as ours. That is not
+ * hypothetical — the probe entry is on this machine.
+ *
+ * A wrapper is allowed in front, because the entry may legitimately be run
+ * through one: `npx sprag-cli brief --hook` and `/usr/local/bin/sprag doc2md`
+ * are both ours. So the executable is taken as the last path segment of the
+ * first token — or of the token after a runner like `npx` or `yarn dlx` — and
+ * matched whole, with `sprag-cli` accepted there since that is what npx resolves.
+ *
+ * The runner list follows `upgradeCommand`, which already prints npm, pnpm, bun
+ * and yarn instructions. Missing one is the duplicate-hook failure rather than
+ * the deletion one: an entry we do not recognise gets a second hook added beside
+ * it, and both then run on every prompt.
+ */
+const RUNNERS = /^(npx|bunx|pnpx)$/;
+const RUNNER_SUBCOMMANDS = { pnpm: ['dlx', 'exec'], yarn: ['dlx', 'run'], bun: ['x', 'run'], npm: ['exec'] };
+
+function isOurCommand(command) {
+  if (typeof command !== 'string') return false;
+  const tokens = command.trim().split(/\s+/).filter(Boolean);
+  if (!tokens.length) return false;
+  // `npx <pkg>` puts the package one token in, `yarn dlx <pkg>` two.
+  let i = 0;
+  if (RUNNERS.test(tokens[0])) i = 1;
+  else if (RUNNER_SUBCOMMANDS[tokens[0]]?.includes(tokens[1])) i = 2;
+  const token = tokens[i];
+  if (!token) return false;
+  // A path invokes the binary by its last segment; strip a Windows .cmd/.exe too.
+  const exe = token.split(/[/\\]/).pop().replace(/\.(cmd|exe|ps1)$/i, '');
+  return exe === CLI || exe === LEGACY_CLI || exe === `${CLI}-cli`;
+}
+
+const STATUSLINE_COMMAND = `${CLI} --statusline --icon`;
 const STATUSLINE_REFRESH_INTERVAL = 5;
 
 const SKILL_BODY = `---
@@ -181,7 +235,7 @@ export function installStatusline({ force = false } = {}) {
   }
 
   const cur = settings.statusLine;
-  const targetsUs = cur && typeof cur.command === 'string' && cur.command.includes('claude-token-saver');
+  const targetsUs = !!cur && isOurCommand(cur.command);
 
   if (!cur) {
     settings.statusLine = {
@@ -221,7 +275,7 @@ export function installStatusline({ force = false } = {}) {
 // candidates as session context (startup + /clear). Idempotent: skips when a
 // sprag route-scan hook is already present; never touches other
 // hooks the user configured.
-const ROUTE_SCAN_HOOK_COMMAND = 'claude-token-saver route-scan --hook';
+const ROUTE_SCAN_HOOK_COMMAND = `${CLI} route-scan --hook`;
 
 export function installSessionStartHook() {
   const dir = claudeUserDir();
@@ -244,8 +298,11 @@ export function installSessionStartHook() {
     return { path: file, action: 'skipped', reason: 'hooks.SessionStart is not an array — fix settings.json manually' };
   }
   const list = Array.isArray(settings.hooks.SessionStart) ? settings.hooks.SessionStart : [];
+  // Match the flag exactly. `route-scan --hook-delegated` contains
+  // `route-scan --hook` as a prefix, so a substring test would see that hook and
+  // conclude this one is already installed.
   const already = list.some((m) =>
-    Array.isArray(m?.hooks) && m.hooks.some((h) => typeof h?.command === 'string' && h.command.includes('route-scan --hook')),
+    Array.isArray(m?.hooks) && m.hooks.some((h) => typeof h?.command === 'string' && /route-scan --hook(?![\w-])/.test(h.command)),
   );
   if (already) return { path: file, action: 'exists' };
 
@@ -263,7 +320,52 @@ export function installSessionStartHook() {
 // conversation — the model cannot see statusline chips, so without this a
 // change that happens mid-session goes unexplained until the user asks.
 // Silent (no output, zero context cost) when nothing changed. Idempotent.
-const BRIEF_HOOK_COMMAND = 'claude-token-saver brief --hook';
+/**
+ * PostToolUse hook for Task/Agent. The statusline's `Routing saved` figure comes
+ * from a cached scan, and the gate in front of that scan holds a fresh
+ * delegation back an hour at best. That gate is there to skip scans that would
+ * produce identical output; a delegation is precisely the event that changes it,
+ * so this hook rescans on the spot. Detached, so the tool call does not wait.
+ */
+const ROUTE_SCAN_DELEGATED_HOOK_COMMAND = `${CLI} route-scan --hook-delegated`;
+
+export function installDelegationHook() {
+  const dir = claudeUserDir();
+  const file = join(dir, 'settings.json');
+  mkdirSync(dir, { recursive: true });
+
+  let settings = {};
+  if (existsSync(file)) {
+    try {
+      settings = JSON.parse(readFileSync(file, 'utf8'));
+    } catch (e) {
+      return { path: file, action: 'skipped', reason: `unreadable JSON (${e.message})` };
+    }
+  }
+
+  settings.hooks = settings.hooks || {};
+  if (settings.hooks.PostToolUse !== undefined && !Array.isArray(settings.hooks.PostToolUse)) {
+    return { path: file, action: 'skipped', reason: 'hooks.PostToolUse is not an array — fix settings.json manually' };
+  }
+  const list = Array.isArray(settings.hooks.PostToolUse) ? settings.hooks.PostToolUse : [];
+  // Same exact-flag match as the SessionStart hook above, for the same reason:
+  // a substring test is what confused `--hook` with `--hook-delegated`, and a
+  // future `--hook-delegated-batch` would confuse this one in turn.
+  const already = list.some((m) =>
+    Array.isArray(m?.hooks) && m.hooks.some((h) => typeof h?.command === 'string' && /route-scan --hook-delegated(?![\w-])/.test(h.command)),
+  );
+  if (already) return { path: file, action: 'exists' };
+
+  list.push({
+    matcher: 'Task|Agent',
+    hooks: [{ type: 'command', command: ROUTE_SCAN_DELEGATED_HOOK_COMMAND, timeout: 10 }],
+  });
+  settings.hooks.PostToolUse = list;
+  writeFileSync(file, JSON.stringify(settings, null, 2) + '\n');
+  return { path: file, action: 'created' };
+}
+
+const BRIEF_HOOK_COMMAND = `${CLI} brief --hook`;
 
 export function installBriefHook() {
   const dir = claudeUserDir();
@@ -305,7 +407,7 @@ export function installBriefHook() {
 // drift surfaces only when a human reads the artifact. This hook closes that
 // gap: it runs on the file the model just wrote, while it can still fix it.
 // Installed by `korean on`, removed by `korean off`. Idempotent.
-const KOREAN_LINT_HOOK_COMMAND = 'claude-token-saver korean --hook';
+const KOREAN_LINT_HOOK_COMMAND = `${CLI} korean --hook`;
 // Bash belongs on this matcher because a heredoc, a `tee`, or a `sed -i` puts
 // Korean on disk exactly like Write does. A subagent without the Write tool
 // reaches for `cat > file` first, so leaving Bash off the list exempted every
@@ -388,8 +490,8 @@ export function removeKoreanLintHook() {
 // workbook adding a minute on top. The row cap inside the converter is what
 // actually bounds the work; the timeout is only a backstop.
 // Installed by `doc2md on`, removed by `doc2md off`. Idempotent.
-const DOC2MD_HOOK_COMMAND = 'claude-token-saver doc2md --hook';
-const DOC2MD_PROMPT_HOOK_COMMAND = 'claude-token-saver doc2md --hook-prompt';
+const DOC2MD_HOOK_COMMAND = `${CLI} doc2md --hook`;
+const DOC2MD_PROMPT_HOOK_COMMAND = `${CLI} doc2md --hook-prompt`;
 
 export function installDoc2mdHook() {
   const dir = claudeUserDir();
@@ -528,7 +630,7 @@ export function uninstallAll({ purge = false } = {}) {
     // Only our own statusline command goes. Someone else's stays exactly
     // where they put it.
     const cur = settings.statusLine;
-    if (cur && typeof cur.command === 'string' && cur.command.includes('claude-token-saver')) {
+    if (cur && isOurCommand(cur.command)) {
       delete settings.statusLine;
       result.removed.push('statusLine');
     } else if (cur) {
@@ -538,15 +640,28 @@ export function uninstallAll({ purge = false } = {}) {
     // Every event, every entry whose command is this CLI. Matching on the
     // binary name rather than a list of exact commands means a hook added by
     // an older version is still removed by a newer one.
+    //
+    // Removal is per hook, not per matcher group. Dropping whole groups was
+    // taking other tools' hooks with them whenever Claude Code had merged them
+    // into one group — which it does for entries sharing a matcher, so a user who
+    // installed us second lost the first tool's hook on uninstall. A group is
+    // deleted only once nothing of anyone else's is left in it.
+    const isOurs = (h) => isOurCommand(h?.command)
+      || (typeof h?.command === 'string' && h.command.includes('cache-monitor-hook'));
     for (const event of Object.keys(settings.hooks || {})) {
       const list = settings.hooks[event];
       if (!Array.isArray(list)) continue;
-      const kept = list.filter((m) => !(
-        Array.isArray(m?.hooks)
-        && m.hooks.some((h) => typeof h?.command === 'string'
-          && (h.command.includes('claude-token-saver') || h.command.includes('cache-monitor-hook')))
-      ));
-      if (kept.length === list.length) continue;
+      let touched = false;
+      const kept = [];
+      for (const m of list) {
+        if (!Array.isArray(m?.hooks)) { kept.push(m); continue; }
+        const hooks = m.hooks.filter((h) => !isOurs(h));
+        if (hooks.length === m.hooks.length) { kept.push(m); continue; }
+        touched = true;
+        // The group survives if it still carries someone else's hook.
+        if (hooks.length) kept.push({ ...m, hooks });
+      }
+      if (!touched) continue;
       result.removed.push(`hooks.${event}`);
       if (kept.length === 0) delete settings.hooks[event];
       else settings.hooks[event] = kept;
@@ -604,7 +719,7 @@ export function migrateLegacyCacheMonitorHook() {
     for (const h of m.hooks) {
       if (typeof h?.command !== 'string' || !h.command.includes('cache-monitor-hook')) continue;
       const th = h.command.match(/--threshold\s+([\d.]+)/);
-      h.command = `claude-token-saver --hook-run --threshold ${th ? th[1] : '0.7'}`;
+      h.command = `${CLI} --hook-run --threshold ${th ? th[1] : '0.7'}`;
       migrated = true;
     }
   }
@@ -623,6 +738,7 @@ export function installAll({ force = false } = {}) {
     skill: installSkill({ force }),
     statusline: installStatusline({ force }),
     sessionStartHook: installSessionStartHook(),
+    delegationHook: installDelegationHook(),
     briefHook: installBriefHook(),
     cacheMonitorMigration: migrateLegacyCacheMonitorHook(),
     legacy: removeLegacyCommand(),

package/src/litellm-budget.js

@@ -23,6 +23,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { userDataDir } from './paths.js';
 import { gaugeBar, formatMoney } from './formatters/statusline.js';
+import { labelForKey } from './window-labels.js';
 import { formatResetClock } from './format-time.js';
 import { cliEntryPath } from './update-check.js';
 import { debug } from './debug.js';
@@ -155,11 +156,16 @@ export function budgetWindow(env = process.env) {
  * 같은 모양(비주얼 바 + 백분율 + 금액)을 쓰되, 통계선에서는 폭이 부족해 생략하는
  * 잔여 금액과 예산 출처, 캐시 신선도를 함께 적습니다.
  *
+ * `mode` 는 통계선과 같은 판정 결과를 받습니다. 이 보고서도 결국 터미널에
+ * 출력되므로, IntelliJ 에서 실행하면 폰트에 없는 글리프가 대체 폰트로 그려져
+ * 통계선과 똑같이 어긋납니다. 게이지 눈금과 예산 아이콘을 함께 모드에 맞춥니다.
+ *
  * @param {object} state - readBudgetState() 가 돌려준 캐시 상태
  * @param {Date} [now]
+ * @param {string} [mode] - 라벨 모드 ('icon' | 'narrow' | 'text')
  * @returns {string[]} 출력할 줄들
  */
-export function formatBudgetReport(state, now = new Date()) {
+export function formatBudgetReport(state, now = new Date(), mode = 'icon') {
   const max = Number(state?.maxBudget);
   const spend = Number(state?.spend);
   if (!Number.isFinite(max) || max <= 0) {
@@ -169,8 +175,16 @@ export function formatBudgetReport(state, now = new Date()) {
   const used = Number.isFinite(spend) ? Math.max(0, spend) : 0;
   const left = Math.max(0, max - used);
   const pct = Math.min(100, (used / max) * 100);
+  const win = labelForKey('litellm_budget');
+  // 통계선의 text 모드는 게이지를 아예 그리지 않지만 이 보고서는 그립니다. text 는
+  // 이모지를 피하려고 고른 모드이므로, 그 선택을 존중해 눈금도 폰트 커버리지가
+  // 확인된 narrow 쪽 글리프를 씁니다. 라벨은 아이콘 없이 이름만 적습니다.
+  const bare = mode === 'text';
+  const tickMode = mode === 'icon' ? 'icon' : 'narrow';
+  const icon = bare ? '' : (mode === 'narrow' ? (win.narrowIcon || win.icon) : win.icon);
+  const head = bare ? 'budget' : `${icon} budget`;
   const lines = [
-    `💳 budget ${gaugeBar(pct)} ${Math.round(pct)}% ${formatMoney(used)}/${formatMoney(max)}`,
+    `${head} ${gaugeBar(pct, tickMode)} ${Math.round(pct)}% ${formatMoney(used)}/${formatMoney(max)}`,
     `   사용 ${formatMoney(used)} · 잔여 ${formatMoney(left)} (${(100 - pct).toFixed(1)}%)`,
   ];
   const resetMs = Number(state?.budgetResetAt);

package/src/route-inject.js

@@ -36,9 +36,12 @@ const MIN_LEN = 8;
  * @param {object} [opts]
  * @param {Array} [opts.rules] registered rules (defaults to the stored registry)
  * @param {string} [opts.lang] 'ko' | 'en'
+ * @param {string} [opts.root] project root used to look for a subagent's .md.
+ *   The hint names the agent when that file exists and only its model tier when
+ *   it does not, so a caller that needs a predictable phrase pins this.
  * @returns {string|null} the line to inject, or null to stay quiet
  */
-export function routeHint(text, { rules, lang = userLanguage() } = {}) {
+export function routeHint(text, { rules, lang = userLanguage(), root } = {}) {
   const t = String(text || '').trim();
   if (t.length < MIN_LEN) return null;
   // Judgement and irreversible work stay on the top tier. This check comes
@@ -57,7 +60,12 @@ export function routeHint(text, { rules, lang = userLanguage() } = {}) {
   const t1 = matched.find((r) => r.tier === 'T1');
   const ko = lang === 'ko';
   const label = ko ? (cat.label || cat.id) : (cat.labelEn || cat.label || cat.id);
-  const phrase = ko ? agentPhrase : agentPhraseEn;
+  // `root` is threaded through to agentPhrase, which names the subagent only
+  // when its .md actually exists on this machine. A caller that pins it can
+  // therefore get a deterministic phrase; a test that does not pin it reads
+  // whatever the developer happens to have installed.
+  const raw = ko ? agentPhrase : agentPhraseEn;
+  const phrase = (name) => raw(name, root === undefined ? undefined : { root });
 
   let target;
   if (t2 && t1) {

package/src/route-scan.js

@@ -67,6 +67,18 @@ export const RESCAN_MIN_INTERVAL_MS = 60 * 60 * 1000;      // never more than ho
 export const RESCAN_BIG_DELTA_BYTES = 5 * 1024 * 1024;     // this much new data → rescan now
 export const RESCAN_MAX_AGE_MS = 24 * 60 * 60 * 1000;      // any new data + a day old → rescan
 
+// One event is exempt from all three: a delegation that just finished. The
+// clauses above exist to skip scans that would produce identical output, and a
+// delegation is the one thing guaranteed to change it — savings and the rule's
+// own error rate both move. Its transcript is nowhere near 5MB, so the gate
+// would otherwise hold the figure back an hour at best and a day at worst,
+// which is exactly the window in which the user is asking whether delegating
+// paid off. Measured on this machine: a scan is ~0.5s over 14 days / 67MB, and
+// delegations run ~1.6×/day, so the exemption costs well under a second a day.
+// A short floor still applies, so a fan-out of parallel agents finishing
+// together triggers one scan rather than one per agent.
+export const RESCAN_AFTER_DELEGATION_MS = 30 * 1000;
+
 // Categories → recommended subagent. Classification is behavior-first with
 // weighted keyword scoring as fallback — see categorize().
 const PASTE_MIN_LEN = 400;
@@ -740,12 +752,23 @@ export function readRouteScan() {
 /**
  * Data-driven rescan gate (see constants above). Cheap: one stat() per
  * transcript file (~32 files on measured data) — a few milliseconds.
+ *
+ * @param {object|null} cache - readRouteScan() result
+ * @param {object} [opts]
+ * @param {number} [opts.days] - analysis window
+ * @param {boolean} [opts.afterDelegation] - a delegation just finished, so this
+ *   scan is known to produce different numbers. Skips the byte and age clauses
+ *   and applies only the anti-thrash floor.
+ * @returns {Promise<boolean>}
  */
-export async function shouldRescan(cache, { days = 14 } = {}) {
+export async function shouldRescan(cache, { days = 14, afterDelegation = false } = {}) {
   if (!cache?.scannedAt) return true;
   const ts = Date.parse(cache.scannedAt);
   if (!Number.isFinite(ts)) return true;
   const age = Date.now() - ts;
+  // A delegation just finished, so the numbers this scan produces are known to
+  // differ. Only the anti-thrash floor applies — see RESCAN_AFTER_DELEGATION_MS.
+  if (afterDelegation) return age >= RESCAN_AFTER_DELEGATION_MS;
   if (age < RESCAN_MIN_INTERVAL_MS) return false;
 
   let total = 0;

package/src/seed-rules.js

@@ -24,6 +24,7 @@
  */
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { CLI_NAME } from './cli-name.js';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createHash } from 'node:crypto';
@@ -242,43 +243,55 @@ export function seedOfferBlock({ lang = userLanguage(), root = findProjectRoot()
   const fixes = pending.filter((s) => s.kind === 'ratchet');
   const lines = [];
   if (lang === 'ko') {
-    lines.push(`[claude-token-saver seed] 아직 등록되지 않은 추천 룰이 ${pending.length}건 있습니다 (패키지 동봉 프리셋).`);
-    lines.push('**이 세션의 첫 응답에서 다른 작업보다 먼저 1번 룰의 등록 여부를 물어보십시오.** 사용자가 먼저 꺼낸 용건이 있으면 그 답변을 마친 직후에 이어서 묻고, 용건이 끝나기를 기다리지 마십시오. 사용자가 이 안내 문구에 대해 질문할 때까지 미루면 안 됩니다.');
-    lines.push('사용자에게 **한 건씩 순서대로** 보여 주고 등록할지 물어보십시오. 한 번에 전체 등록을 권하지 말고, 답을 받은 뒤 바로 아래 명령을 실행하십시오.');
-    lines.push('적용 범위를 물을 때는 선택지를 **글로벌(모든 프로젝트)을 먼저, 이 프로젝트만을 그다음**으로 제시하십시오.');
+    lines.push(`[${CLI_NAME} seed] 아직 등록되지 않은 추천 룰이 ${pending.length}건 있습니다 (패키지 동봉 프리셋).`);
+    lines.push('**이 세션의 첫 응답에서 다른 작업보다 먼저 물어보십시오.** 사용자가 먼저 꺼낸 용건이 있으면 그 답변을 마친 직후에 이어서 묻고, 용건이 끝나기를 기다리지 마십시오. 사용자가 이 안내 문구에 대해 질문할 때까지 미루면 안 됩니다.');
+    lines.push(`첫 질문에서 다음 네 선택지를 **이 순서대로** 제시하십시오. ${pending.length}건을 한 건씩 답하는 것은 대부분의 사용자에게 과한 부담이므로, 일괄 등록이 맨 앞에 옵니다.`);
+    lines.push('  1. 전부 글로벌로 등록 — `seed accept all --global`');
+    lines.push('  2. 전부 이 프로젝트만 등록 — `seed accept all --project`');
+    lines.push('  3. 한 건씩 보면서 결정 — 아래 목록을 순서대로 하나씩 묻고, 답을 받는 즉시 해당 명령을 실행합니다');
+    lines.push('  4. 전부 등록하지 않음 — `seed skip all` (다시 묻지 않습니다)');
+    lines.push('3번을 고른 경우에만 한 건씩 진행하고, 그때도 적용 범위는 **글로벌(모든 프로젝트)을 먼저, 이 프로젝트만을 그다음**으로 제시하십시오.');
     if (models.length > 0) {
       lines.push(`  · 모델 피팅 룰 ${models.length}건 — 등록하면 해당 유형 작업이 더 싼 서브에이전트로 위임됩니다.`);
       for (const s of models) {
         lines.push(`    [${s.id}] ${s.tier} · "${s.label}" → ${s.agent}`);
-        lines.push(`        "${s.ruleText}"`);
+        // No wrapping quotes: the composed rule text already opens with the
+        // quoted work-type name, so adding a pair produced `""명령 실행 …`.
+        lines.push(`        ${s.ruleText}`);
       }
     }
     if (fixes.length > 0) {
       lines.push(`  · 래칫 룰 ${fixes.length}건 — 같은 실수를 반복하지 않도록 세션마다 읽히는 규칙입니다.`);
       for (const s of fixes) lines.push(`    [${s.id}] ${s.ruleText}`);
     }
-    lines.push('  등록: claude-token-saver seed accept <id> --global|--project   # 적용 범위는 반드시 사용자에게 확인');
-    lines.push('  거절: claude-token-saver seed skip <id>                        # 다시 묻지 않습니다');
-    lines.push('  (사용자가 "전부 등록"이라고 답하면 `seed accept all --global` 을 쓸 수 있습니다)');
+    lines.push(`  일괄: ${CLI_NAME} seed accept all --global|--project   # 적용 범위는 반드시 사용자에게 확인`);
+    lines.push(`  개별: ${CLI_NAME} seed accept <id> --global|--project`);
+    lines.push(`  거절: ${CLI_NAME} seed skip <id>|all                    # 다시 묻지 않습니다`);
   } else {
-    lines.push(`[claude-token-saver seed] ${pending.length} recommended rule(s) from the bundled presets are not registered yet.`);
-    lines.push('**Ask about rule 1 in your very first reply of this session, before anything else.** If the user opened with their own request, answer it and then ask right away; do not wait for their task to finish, and never wait until they ask about this notice.');
-    lines.push('Walk the user through them **one at a time** and ask about each. Do not push the whole set at once; run the matching command as soon as they answer.');
-    lines.push('When you ask about the scope, offer **global (all projects) first, this project only second**.');
+    lines.push(`[${CLI_NAME} seed] ${pending.length} recommended rule(s) from the bundled presets are not registered yet.`);
+    lines.push('**Ask in your very first reply of this session, before anything else.** If the user opened with their own request, answer it and then ask right away; do not wait for their task to finish, and never wait until they ask about this notice.');
+    lines.push(`Offer these four choices, **in this order**. Answering ${pending.length} rules one by one is more than most users want to do, so registering them all comes first.`);
+    lines.push('  1. Register all, globally — `seed accept all --global`');
+    lines.push('  2. Register all, this project only — `seed accept all --project`');
+    lines.push('  3. Decide one at a time — walk the list below in order, running each command as soon as they answer');
+    lines.push('  4. Register none — `seed skip all` (never offered again)');
+    lines.push('Only go rule-by-rule if they pick 3, and even then offer **global (all projects) first, this project only second**.');
     if (models.length > 0) {
       lines.push(`  · ${models.length} model-fitting rule(s) — once registered, that kind of work goes to a cheaper subagent.`);
       for (const s of models) {
         lines.push(`    [${s.id}] ${s.tier} · "${s.label}" → ${s.agent}`);
-        lines.push(`        "${s.ruleText}"`);
+        // No wrapping quotes: the composed rule text already opens with the
+        // quoted work-type name, so adding a pair produced `""명령 실행 …`.
+        lines.push(`        ${s.ruleText}`);
       }
     }
     if (fixes.length > 0) {
       lines.push(`  · ${fixes.length} ratchet rule(s) — read at the start of every session so the same mistake is not repeated.`);
       for (const s of fixes) lines.push(`    [${s.id}] ${s.ruleText}`);
     }
-    lines.push('  register: claude-token-saver seed accept <id> --global|--project   # ALWAYS confirm the scope with the user');
-    lines.push('  decline:  claude-token-saver seed skip <id>                        # never offered again');
-    lines.push('  (if the user says "register them all", `seed accept all --global` does that)');
+    lines.push(`  all:      ${CLI_NAME} seed accept all --global|--project   # ALWAYS confirm the scope with the user`);
+    lines.push(`  one:      ${CLI_NAME} seed accept <id> --global|--project`);
+    lines.push(`  decline:  ${CLI_NAME} seed skip <id>|all                    # never offered again`);
   }
   return lines.join('\n');
 }