sprag-cli 3.44.0 → 3.45.0

package/src/glyphs.js

@@ -0,0 +1,78 @@
+/**
+ * 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.
+ *
+ * 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: '🔄',
+};
+
+/**
+ * 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
+};
+
+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/litellm-budget.js

@@ -170,7 +170,7 @@ export function formatBudgetReport(state, now = new Date()) {
   const left = Math.max(0, max - used);
   const pct = Math.min(100, (used / max) * 100);
   const lines = [
-    `🔑 budget ${gaugeBar(pct)} ${Math.round(pct)}% ${formatMoney(used)}/${formatMoney(max)}`,
+    `💳 budget ${gaugeBar(pct)} ${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,86 @@
+/**
+ * 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'
+ * @returns {string|null} the line to inject, or null to stay quiet
+ */
+export function routeHint(text, { rules, lang = userLanguage() } = {}) {
+  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);
+  const phrase = ko ? agentPhrase : agentPhraseEn;
+
+  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/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' };
+}

package/src/window-labels.js

@@ -1,5 +1,9 @@
 /**
- * Friendly labels + icons for `rate_limits.*` keys from Claude Code's stdin
+ * Friendly labels + icons for `rate_limits.*` keys from Claude Code's stdin.
+ *
+ * Each window carries two glyphs. `icon` is the emoji; `narrowIcon` is the
+ * one-cell glyph used where emoji garble the line, chosen by JetBrains Mono
+ * coverage for the reason src/glyphs.js explains.
  * payload. Known keys (`five_hour`, `seven_day`) get curated short/long labels
  * and dedicated icons. Unknown keys are passed through with a derived label so
  * any future window Anthropic adds (e.g. `seven_day_sonnet`) renders without
@@ -17,15 +21,21 @@ const KNOWN = {
   // 'current' mirrors how `weekly` reads next to 7D — names the window in
   // plain English so a glance at `✦ current ████▒░ 72%` tells the eye what's
   // being measured without parsing the icon's meaning.
-  five_hour: { short: '5H', long: 'Current session', icon: '✦', usageLabel: 'current' },
-  seven_day: { short: '7D', long: 'Current week', icon: '📅', usageLabel: 'weekly' },
+  five_hour: { short: '5H', long: 'Current session', icon: '✦', narrowIcon: '✶', usageLabel: 'current' },
+  seven_day: { short: '7D', long: 'Current week', icon: '📅', narrowIcon: '⌸', usageLabel: 'weekly' },
   // Speculative — `/usage` shows a Sonnet-only weekly bucket, so if Anthropic
   // ever surfaces it on stdin we render with a sensible default already.
-  seven_day_sonnet: { short: '7D-S', long: 'Current week (Sonnet)', icon: '🅂', usageLabel: 'weekly (Sonnet)' },
-  seven_day_opus: { short: '7D-O', long: 'Current week (Opus)', icon: '🅾', usageLabel: 'weekly (Opus)' },
+  seven_day_sonnet: { short: '7D-S', long: 'Current week (Sonnet)', icon: '🅂', narrowIcon: '◇', usageLabel: 'weekly (Sonnet)' },
+  seven_day_opus: { short: '7D-O', long: 'Current week (Opus)', icon: '🅾', narrowIcon: '◆', usageLabel: 'weekly (Opus)' },
+  // 💳 는 지출 한도를 가리킨다. 이전에 쓰던 🔑 은 인증 수단을 연상시키므로,
+  // 이 칩이 새로 보는 사람에게 키 자신의 상태로 읽힐 여지가 있었다.
   // LiteLLM 게이트웨이 키 예산. rate_limits 가 없는 환경에서 cap 게이지를
   // 대신하는 합성 윈도우라서, 여기 라벨만 있으면 나머지 렌더는 공용 경로를 탄다.
-  litellm_budget: { short: 'BUDGET', long: 'LiteLLM key budget', icon: '🔑', usageLabel: 'budget' },
+  litellm_budget: {
+    short: 'BUDGET', long: 'LiteLLM key budget', icon: '💳', narrowIcon: '◫', usageLabel: 'budget',
+    // Budgets reset on a billing cycle, so "in 3d 4h" beats a bare weekday.
+    resetStyle: 'countdown',
+  },
 };
 
 function deriveShort(key) {
@@ -60,5 +70,5 @@ function deriveLong(key) {
 export function labelForKey(key) {
   if (KNOWN[key]) return KNOWN[key];
   const short = deriveShort(key);
-  return { short, long: deriveLong(key), icon: '⏱', usageLabel: short };
+  return { short, long: deriveLong(key), icon: '⏱', narrowIcon: '◕', usageLabel: short };
 }