sprag-cli 3.44.0 → 3.46.0

package/src/glyphs.js

@@ -0,0 +1,95 @@
+/**
+ * Statusline glyph sets, one per label mode.
+ *
+ * Why a narrow set exists at all: IntelliJ's terminal draws a character its
+ * configured font lacks through a fallback font, and the fallback's advance
+ * width does not match the cell grid. The mismatch is invisible on static text,
+ * but a segment whose value changes every second (the TTL countdown, a gauge
+ * percentage) repaints partially, and the leftover characters read as garbage:
+ * `Cache expires 4:54` renders as `4:545`, `$4.0K` as `$4.:0K`. Dragging a
+ * selection forces a full repaint and the line looks correct again, which is the
+ * tell that the buffer was always right and only the painting was off.
+ *
+ * Measured on this machine (JetBrainsMono-Regular.ttf, the IDE default):
+ * every emoji the icon set uses is absent from the font, while the gauge
+ * characters (█ ▉ … ░) are present — and the gauge is the one part of the line
+ * that never garbled. So the narrow set is chosen by font coverage, not by
+ * Unicode width: each glyph below is one JetBrains Mono actually ships.
+ *
+ * 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.
+ */
+
+/** Emoji set: what a terminal with proper emoji support should show. */
+const ICON = {
+  capWarn: '🚨',
+  spike: '⚠',
+  upgrade: '⬆',
+  harness: '🅷',
+  korean: '✍️',
+  model: '🤖',
+  routing: '🔀',
+  doc: '📄',
+  hit: '🧠',
+  ttl: '⏳',
+  month: '💵',
+  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: '▱',
+};
+
+/**
+ * Narrow set: every glyph is present in JetBrains Mono and one cell wide.
+ * Shapes were picked to stay distinguishable from each other at a glance, since
+ * compact mode shows the glyph with no label beside it.
+ */
+const NARROW = {
+  capWarn: '‼',   // doubled bang reads as an alarm
+  spike: '⚠',     // the one emoji-adjacent glyph the font does ship
+  upgrade: '↑',
+  harness: '⍟',   // circled star: a score out of five
+  korean: '⌨',    // an input/typing convention rather than a hand
+  model: '◈',
+  routing: '⇉',   // sent down a different path
+  doc: '≣',       // stacked lines: a page of text
+  hit: '◉',       // bullseye: a cache hit
+  ttl: '◔',       // a partly elapsed dial
+  month: '∑',     // a running total
+  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 };
+
+/**
+ * Glyphs for a label mode. Text mode never reads a glyph, but it resolves to the
+ * emoji set so a caller that asks anyway gets a complete object rather than
+ * undefined lookups.
+ */
+export function glyphsFor(mode) {
+  return SETS[mode] || ICON;
+}
+
+export { ICON as ICON_GLYPHS, NARROW as NARROW_GLYPHS };

package/src/installer.js

@@ -244,8 +244,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,6 +266,51 @@ 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.
+/**
+ * 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 = 'claude-token-saver 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 = 'claude-token-saver brief --hook';
 
 export function installBriefHook() {
@@ -623,6 +671,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/model-rules.js

@@ -94,10 +94,14 @@ export function budgetCapPhrase(rule, lang = userLanguage()) {
  */
 export function composeRuleText(baseText, rule, lang = userLanguage()) {
   const cap = budgetCapPhrase(rule, lang);
-  const clause = lang === 'ko'
-    ? `위임 상한은 ${cap}이며, 넘길 것 같거나 에러가 나면 거기서 멈춰 진행분만 보고하고 메인 모델이 이어받는다. 세션 모델이 이미 위임 목표와 같은 급 이하면 위임하지 않는다`
-    : `Cap the run at ${cap}; if it looks likely to exceed that or hits an error, it stops there and reports partial progress while the main model takes over. Skip delegation entirely when the session model is already at or below the target tier`;
-  return `${baseText.replace(/\s*$/, '')}. ${clause}`;
+  // Only the cap. The stop condition and the same-tier skip used to repeat in
+  // every rule; they are identical across all of them, so they now live once in
+  // the file header's shared-clause section. A rule the model re-reads on every
+  // request should be one line it can match against, not four clauses it has to
+  // re-derive — three sentences per rule made delegating cost more thought than
+  // doing the work, and measured delegation ran at 3.6% of eligible episodes.
+  const clause = lang === 'ko' ? `상한 ${cap}` : `cap ${cap}`;
+  return `${baseText.replace(/\s*$/, '')} (${clause})`;
 }
 
 /**
@@ -109,16 +113,27 @@ export function composeRuleText(baseText, rule, lang = userLanguage()) {
  *
  * `g` carries { tier, label, labelEn, example, exampleEn, agent }.
  */
+/**
+ * Trim an example to something a reader takes in at a glance. Scan-derived
+ * examples are raw user messages, and some ran long enough to bury the rule that
+ * followed them.
+ */
+const EXAMPLE_MAX = 30;
+function shortExample(text) {
+  const one = String(text || '').replace(/\s+/g, ' ').trim();
+  return one.length <= EXAMPLE_MAX ? one : `${one.slice(0, EXAMPLE_MAX - 1)}…`;
+}
+
 export function modelRuleBaseText(g, lang = userLanguage()) {
   if (lang === 'ko') {
     return g.tier === 'T2'
-      ? `"${g.label}" 유형의 단순 요청(예: "${g.example}")은 ${agentPhrase(g.agent)} 서브에이전트로 위임한다 (설계 판단·배포·스토어 제출 같은 비가역 작업이 섞이면 위임하지 않음)`
-      : `"${g.label}" 유형의 중간 난도 요청(예: "${g.example}")은 model: sonnet 서브에이전트로 위임한다 (설계 판단·비가역 작업·반복 에러 발생 시 메인 모델이 이어받음)`;
+      ? `"${g.label}" 단순 요청(예: "${shortExample(g.example)}")은 ${agentPhrase(g.agent)}에 위임`
+      : `"${g.label}" 중간 난도 요청(예: "${shortExample(g.example)}")은 model: sonnet에 위임`;
   }
   const example = g.exampleEn || g.example;
   return g.tier === 'T2'
-    ? `Delegate simple "${g.labelEn}" requests (e.g. "${example}") to ${agentPhraseEn(g.agent)} — never when the request mixes in design judgement or irreversible work like deploy/release/submission`
-    : `Delegate moderate "${g.labelEn}" requests (e.g. "${example}") to a model: sonnet subagent — hand back to the main model on design judgement, irreversible work, or repeated errors`;
+    ? `Simple "${g.labelEn}" requests (e.g. "${shortExample(example)}") go to ${agentPhraseEn(g.agent)}`
+    : `Moderate "${g.labelEn}" requests (e.g. "${shortExample(example)}") go to a model: sonnet subagent`;
 }
 
 // See the note in route-scan.js — paths.js is the only place that resolves
@@ -214,6 +229,15 @@ export function renderModelRatchet(rules, lang = userLanguage()) {
     '(어떤 도구가 토큰을 아끼고 있는지 가시화):',
     '`🔀 [sprag] 모델 피팅: "<유형>" → <agent> 위임`',
     '',
+    '## 공통 조항 (룰마다 반복하지 않으므로 여기서 한 번만 읽으십시오)',
+    '',
+    '- 상한을 넘길 것 같거나 에러가 나면 그 자리에서 멈추고 진행분만 보고합니다.',
+    '  메인 모델이 이어받습니다.',
+    '- 세션 모델이 위임 목표와 같은 급이거나 그보다 낮으면 위임하지 않습니다.',
+    '  절감이 발생하지 않기 때문입니다.',
+    '- 설계 판단이나 되돌릴 수 없는 작업(배포·릴리스·머지·제출)이 섞여 있으면',
+    '  위임하지 않습니다.',
+    '',
     '## 티어 판별 기준 (모든 룰에 공통 적용)',
     '',
     '- **도구 오케스트레이션**: 한 도구의 결과를 다음 호출의 입력으로 잇는 다단계',
@@ -262,6 +286,15 @@ export function renderModelRatchet(rules, lang = userLanguage()) {
     'visible which tool is saving tokens:',
     '`🔀 [sprag] model fitting: "<category>" → delegated to <agent>`',
     '',
+    '## Shared clauses (stated once here, not repeated per rule)',
+    '',
+    '- A run likely to exceed its cap, or hitting an error, stops there and reports',
+    '  partial progress. The main model takes over.',
+    '- Skip delegation when the session model is already at or below the target',
+    '  tier: there is nothing to save.',
+    '- Skip it when the request mixes in design judgement or irreversible work',
+    '  (deploy, release, merge, submission).',
+    '',
     '## Tier criteria (apply to every rule below)',
     '',
     '- **Tool orchestration**: a multi-step flow that feeds one tool result into',
@@ -329,8 +362,8 @@ export function renderModelRatchet(rules, lang = userLanguage()) {
   // Merged T2+T1 rules carry two caps, so they state both once rather than
   // repeating the whole stop-condition per tier.
   const mergedBudget = (t2, t1) => ko
-    ? `위임 상한은 haiku ${budgetCapPhrase(t2, 'ko')}, sonnet ${budgetCapPhrase(t1, 'ko')}이며, 넘길 것 같거나 에러가 나면 거기서 멈춰 진행분만 보고하고 메인 모델이 이어받는다. 세션 모델이 이미 위임 목표와 같은 급 이하면 위임하지 않는다`
-    : `Cap haiku runs at ${budgetCapPhrase(t2, 'en')} and sonnet runs at ${budgetCapPhrase(t1, 'en')}; a run likely to exceed its cap, or hitting an error, stops there and reports partial progress while the main model takes over. Skip delegation entirely when the session model is already at or below the target tier`;
+    ? `상한 haiku ${budgetCapPhrase(t2, 'ko')} / sonnet ${budgetCapPhrase(t1, 'ko')}`
+    : `cap haiku ${budgetCapPhrase(t2, 'en')} / sonnet ${budgetCapPhrase(t1, 'en')}`;
 
   // A category can carry both a T2 (haiku) and a T1 (sonnet) rule. Tier is
   // only known after an episode finishes, so two separate bullets give the
@@ -349,15 +382,18 @@ export function renderModelRatchet(rules, lang = userLanguage()) {
     if (t2 && t1) {
       // Seeded rules carry a localized example; scan-produced ones only have the
       // user's own prompt, so exampleEn is a preference, not a requirement.
-      const ex = (r) => (ko ? r.example : (r.exampleEn || r.example));
+      const ex = (r) => shortExample(ko ? r.example : (r.exampleEn || r.example));
+      // One line per category, stating only what differs between the two tiers.
+      // The exceptions this used to spell out (design judgement, irreversible
+      // work) are identical in every rule and now sit in the header's shared
+      // clauses, so a rule the model re-reads on every request is short enough to
+      // match at a glance.
       const rule = ko
-        ? `"${t2.label}" 유형 요청은 기본적으로 ${agentPhrase(t2.agent)} 서브에이전트로 위임한다(예: "${ex(t2)}"). ` +
-          `여러 단계·여러 파일 수정이 얽힌 중간 난도 요청(예: "${ex(t1)}")은 model: sonnet 서브에이전트로 위임한다. ` +
-          `설계 판단이나 배포·릴리스·스토어 제출 같은 비가역 작업이 섞여 있을 때만 위임하지 않는다. ` +
+        ? `"${t2.label}": 기본 ${agentPhrase(t2.agent)}(예: "${ex(t2)}"), ` +
+          `여러 단계·여러 파일이 얽히면 model: sonnet(예: "${ex(t1)}"). ` +
           mergedBudget(t2, t1)
-        : `Delegate "${t2.labelEn || t2.label}" requests to ${agentPhraseEn(t2.agent)} by default (e.g. "${ex(t2)}"). ` +
-          `Escalate moderate ones that span multiple steps or file edits (e.g. "${ex(t1)}") to a model: sonnet subagent. ` +
-          `Keep it on the main model only when the request mixes in design judgement or irreversible work (deploy, release, store submission). ` +
+        : `"${t2.labelEn || t2.label}": ${agentPhraseEn(t2.agent)} by default (e.g. "${ex(t2)}"), ` +
+          `model: sonnet when it spans multiple steps or file edits (e.g. "${ex(t1)}"). ` +
           mergedBudget(t2, t1);
       lines.push(`- ${rule}${healthOf(t2)}${healthOf(t1)} <!-- T2 ${statsOf(t2)} / T1 ${statsOf(t1)} -->`);
       for (const r of group) {

package/src/route-inject.js

@@ -0,0 +1,94 @@
+/**
+ * Turn a registered delegation rule into a per-request instruction.
+ *
+ * Why this exists: rules were registered and then not used. Measured on the
+ * author's logs, 337 of 1296 episodes were delegation-eligible and 12 were
+ * delegated (3.6%); five of ten registered rules had never fired. Rule wording
+ * was not the whole story — the session also carries a general instruction not
+ * to spawn subagents unless asked, and ratchet-model.md tries to overrule it in
+ * prose. Between two instructions that disagree, the cautious one wins.
+ *
+ * So this stops arguing in prose. The hook classifies the request that just
+ * arrived and states the matching rule as a fact about THIS request, which
+ * leaves the model nothing to resolve: no rule list to scan, no self-matching
+ * step, no conflict to weigh.
+ *
+ * Deliberately silent when it cannot be sure:
+ *   - the request text does not classify (about half of them, by measurement —
+ *     difficulty mostly surfaces after the first tool call, and at prompt time
+ *     there are no tool calls yet)
+ *   - the text trips ESCALATE_RE (design, analysis, deploy, merge …), where the
+ *     top tier is the right answer and a nudge downward would be wrong
+ *   - no registered rule covers that category
+ * A hint that fires on the wrong request costs more than one that stays quiet.
+ */
+
+import { categorize, ESCALATE_RE } from './route-scan.js';
+import { loadModelRules, budgetCapPhrase } from './model-rules.js';
+import { agentPhrase, agentPhraseEn } from './agents.js';
+import { userLanguage } from './config.js';
+
+/** Shortest text worth classifying; below this a prompt is an ack, not a task. */
+const MIN_LEN = 8;
+
+/**
+ * @param {string} text the prompt just submitted
+ * @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(), 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
+  // before classification because such a request often looks like a light
+  // "run" or "check" in its wording.
+  if (ESCALATE_RE.test(t)) return null;
+
+  const cat = categorize(t, null);
+  if (!cat) return null;
+
+  const all = rules || loadModelRules().rules || [];
+  const matched = all.filter((r) => r && r.category === cat.id);
+  if (!matched.length) return null;
+
+  const t2 = matched.find((r) => r.tier === 'T2');
+  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);
+  // `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) {
+    target = ko
+      ? `기본 ${phrase(t2.agent)}, 여러 단계·여러 파일이 얽히면 model: sonnet`
+      : `${phrase(t2.agent)} by default, model: sonnet when it spans multiple steps or file edits`;
+  } else {
+    const only = t2 || t1;
+    target = ko ? phrase(only.agent) : phrase(only.agent);
+  }
+
+  const caps = [t2, t1].filter(Boolean).map((r) => budgetCapPhrase(r, lang));
+  const capText = caps.length === 2
+    ? (ko ? `상한 haiku ${caps[0]} / sonnet ${caps[1]}` : `cap haiku ${caps[0]} / sonnet ${caps[1]}`)
+    : (ko ? `상한 ${caps[0]}` : `cap ${caps[0]}`);
+
+  // The marker line is the one in ratchet-model.md, so the user sees the same
+  // string whichever path decided to delegate.
+  return ko
+    ? `[sprag] 이 요청은 사용자가 이미 승인한 위임 룰 "${label}" 에 해당합니다: ${target} 로 위임하십시오 (${capText}). `
+      + `되묻지 말고 위임하고, 위임할 때 \`🔀 [sprag] 모델 피팅: "${label}" → <agent> 위임\` 을 먼저 표시하십시오. `
+      + `상한을 넘길 것 같거나 에러가 나면 그 자리에서 멈추고 메인 모델이 이어받습니다.`
+    : `[sprag] This request matches a delegation rule the user already approved — "${label}": delegate to ${target} (${capText}). `
+      + `Do not ask again; print \`🔀 [sprag] model fit: "${label}" → <agent>\` first. `
+      + `If the run is likely to exceed its cap or hits an error, stop there and the main model takes over.`;
+}

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

@@ -243,42 +243,54 @@ export function seedOfferBlock({ lang = userLanguage(), root = findProjectRoot()
   const lines = [];
   if (lang === 'ko') {
     lines.push(`[claude-token-saver seed] 아직 등록되지 않은 추천 룰이 ${pending.length}건 있습니다 (패키지 동봉 프리셋).`);
-    lines.push('**이 세션의 첫 응답에서 다른 작업보다 먼저 1번 룰의 등록 여부를 물어보십시오.** 사용자가 먼저 꺼낸 용건이 있으면 그 답변을 마친 직후에 이어서 묻고, 용건이 끝나기를 기다리지 마십시오. 사용자가 이 안내 문구에 대해 질문할 때까지 미루면 안 됩니다.');
-    lines.push('사용자에게 **한 건씩 순서대로** 보여 주고 등록할지 물어보십시오. 한 번에 전체 등록을 권하지 말고, 답을 받은 뒤 바로 아래 명령을 실행하십시오.');
-    lines.push('적용 범위를 물을 때는 선택지를 **글로벌(모든 프로젝트)을 먼저, 이 프로젝트만을 그다음**으로 제시하십시오.');
+    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('  일괄: claude-token-saver seed accept all --global|--project   # 적용 범위는 반드시 사용자에게 확인');
+    lines.push('  개별: claude-token-saver seed accept <id> --global|--project');
+    lines.push('  거절: claude-token-saver 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('**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:      claude-token-saver seed accept all --global|--project   # ALWAYS confirm the scope with the user');
+    lines.push('  one:      claude-token-saver seed accept <id> --global|--project');
+    lines.push('  decline:  claude-token-saver seed skip <id>|all                    # never offered again');
   }
   return lines.join('\n');
 }

package/src/statusline-mode.js

@@ -0,0 +1,95 @@
+/**
+ * Statusline label-mode resolution — the single place that decides icon vs text.
+ *
+ * The real statusline path and the `--demo` path both route through here. They
+ * used to carry separate copies of the decision and the copies drifted: only
+ * the real path applied the IntelliJ guard, so inside IntelliJ
+ * `--statusline --demo` rendered emoji while the actual statusline rendered
+ * plain text. That gap makes our own deliberate downgrade look like a terminal
+ * bug, and it cost a full diagnosis session to rule out.
+ */
+
+const JETBRAINS_TERMINAL = 'JetBrains-JediTerm';
+
+/**
+ * IntelliJ's built-in terminal sets this for every shell it opens, whether or
+ * not the Claude Code plugin is involved.
+ */
+export function isJetBrainsTerminal(env = process.env) {
+  return env.TERMINAL_EMULATOR === JETBRAINS_TERMINAL;
+}
+
+/**
+ * Whether the user has explicitly asked for icons inside IntelliJ regardless.
+ *
+ * Scope: this lifts the IntelliJ guard and nothing else. It is not a general
+ * "always icons" switch, and outside IntelliJ it is never consulted — there is
+ * no guard there to lift, and `icon` / `text` already own that choice. Letting
+ * it win everywhere would mean `sprag mode text` could no longer turn icons off
+ * while it was set, which is a worse trade than the narrow name.
+ *
+ * The guard below exists for the IntelliJ Claude Code *plugin*, whose
+ * statusline widget fuses consecutive frames at the character level when emoji
+ * are present ("59:548"). JediTerm itself renders our output cleanly, so a user
+ * who runs `claude` straight in the built-in terminal loses icons for a bug
+ * that cannot reach them. TERMINAL_EMULATOR alone cannot tell the two apart,
+ * so the escape hatch is explicit rather than inferred:
+ *
+ *   SPRAG_ICON=force            one-off, e.g. while checking a render
+ *   sprag mode icon-force       persisted, so wrappers that hardcode --icon
+ *                               do not have to be edited
+ */
+export function iconForceRequested({ cfg = {}, env = process.env } = {}) {
+  const raw = String(env.SPRAG_ICON ?? '').trim().toLowerCase();
+  if (raw === 'force') return true;
+  return cfg.iconForce === true;
+}
+
+/**
+ * The user's stored label preference, as one of the three modes.
+ *
+ * `labels` is the current key. Configs written before it existed carry a boolean
+ * `icon` instead, so that is read as a fallback: absent means icons, since icons
+ * are the default for a fresh install.
+ */
+export function labelPreference(cfg = {}) {
+  if (cfg.labels === 'icon' || cfg.labels === 'narrow' || cfg.labels === 'text') return cfg.labels;
+  return cfg.icon === false ? 'text' : 'icon';
+}
+
+/**
+ * Resolve the label mode.
+ *
+ * @param {object} opts
+ * @param {(name: string) => boolean} [opts.hasFlag] argv accessor
+ * @param {object} [opts.cfg] statuslineDefaults() result
+ * @param {object} [opts.env] environment to read
+ * @returns {{ mode: 'icon'|'narrow'|'text', reason: string }} `reason` names the rule
+ *   that decided, so `sprag mode` can explain a downgrade instead of leaving
+ *   the user to guess why `--icon` did nothing. One of `flag:--no-icon`,
+ *   `flag:--text`, `flag:--narrow`, `intellij-narrow`, `intellij-forced`,
+ *   `flag:--icon`, `config`.
+ *
+ * Precedence: explicit opt-out, then the IntelliJ guard (and the escape hatch
+ * out of it, which applies only there), then `--icon`, then persisted config.
+ */
+export function resolveLabelMode({ hasFlag = () => false, cfg = {}, env = process.env } = {}) {
+  // An explicit opt-out wins everywhere. Nothing below should talk a user out
+  // of the mode they just asked for. The two flags are reported separately so
+  // the diagnostic line names the flag the user actually typed.
+  if (hasFlag('--no-icon')) return { mode: 'text', reason: 'flag:--no-icon' };
+  if (hasFlag('--text')) return { mode: 'text', reason: 'flag:--text' };
+  if (hasFlag('--narrow')) return { mode: 'narrow', reason: 'flag:--narrow' };
+  const pref = labelPreference(cfg);
+  if (isJetBrainsTerminal(env)) {
+    // Emoji on request, accepting that they garble here.
+    if (iconForceRequested({ cfg, env })) return { mode: 'icon', reason: 'intellij-forced' };
+    // Someone who asked for plain text gets plain text.
+    if (pref === 'text') return { mode: 'text', reason: 'config' };
+    // Otherwise narrow: the glyphs still mark each chip, and every one of them
+    // is a character the IDE font actually has, so the line does not garble.
+    return { mode: 'narrow', reason: 'intellij-narrow' };
+  }
+  if (hasFlag('--icon')) return { mode: 'icon', reason: 'flag:--icon' };
+  return { mode: pref, reason: 'config' };
+}