sprag-cli 3.68.0 → 3.70.0

package/src/formatters/statusline.js

@@ -28,6 +28,7 @@ import { MIN_VOTES } from '../model-alias.js';
 import { bedrockDisplayFromId } from '../stdin-payload.js';
 import { modelFamily } from '../savings-ledger.js';
 import { shareLegend } from '../model-share.js';
+import { STAR_URL } from '../star-note.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
@@ -1032,6 +1033,13 @@ function buildDelegatedSeg(data, singleLine, c, isIcon, verbose, g, color) {
   };
 }
 
+/** The one-time star ask (see star-note.js); null unless the CLI passed a chip. */
+function buildStarSeg(star, c, isIcon) {
+  if (!star || typeof star !== 'object' || !Number.isFinite(star.usd)) return null;
+  const text = `${isIcon ? '⭐ ' : ''}${formatMoney(star.usd)} saved · star ${STAR_URL}`;
+  return `${c(YELLOW)}${text}${c(RESET)}`;
+}
+
 /**
  * Doc2md chip and headline line. As with routing, they are alternatives: money
  * earns the headline line, and the chip is for what a line would be all frame
@@ -1142,6 +1150,8 @@ export const DEFAULT_SEGMENT_ORDER = [
   // Lifetime, from the savings ledgers. Delegation stays ahead of the cache
   // figure: routing is what the tool is for, the cache number is a brag stat.
   'delegated', 'doc2md',
+  // One-time star ask; renders only while readStarChip returns an object.
+  'star',
   // Analysis window. These two are the only chips measured over it, so the label
   // sits with them and the three render as one group.
   'hit', 'saved', 'period',
@@ -1182,6 +1192,7 @@ function segmentsNamed(name, s, usageByKey) {
     // the session's own subagent runs.
     case 'delegated': return [...s.delegated, s.subagents];
     case 'doc2md':    return s.doc2md;
+    case 'star':      return [s.star];
     case 'hit':       return [s.hit];
     case 'ttl':       return [s.ttl];
     case 'month':     return [s.month];
@@ -1287,7 +1298,7 @@ function buildHeadlines(delegated, doc2md, want, eol) {
  * @param {boolean} [opts.verbose=false] - longer layout with labels
  * @param {boolean} [opts.timer=true] - show TTL countdown segment
  * @param {'text'|'icon'} [opts.mode='text'] - label style. 'icon' uses 🧠 ⏳ 💰 instead of word labels.
- * @param {string[]|null} [opts.segments] - segments to render, in the order given. Names: cap-warn, spike, version, harness (a full score with no warning draws only when named here), korean (draws only when named here), model, effort, hit, ttl, month, saved, delegated, doc2md, ctx, period, `subagents` (this session's subagent runs; also rides with `delegated`), `rules` (only when named here), `usage` (every rate-limit window), plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. cap-warn and spike keep the lead regardless of where they appear. Null/undefined = all, in the default order.
+ * @param {string[]|null} [opts.segments] - segments to render, in the order given. Names: cap-warn, spike, version, harness (a full score with no warning draws only when named here), korean (draws only when named here), model, effort, hit, ttl, month, saved, delegated, doc2md, star, ctx, period, `subagents` (this session's subagent runs; also rides with `delegated`), `rules` (only when named here), `usage` (every rate-limit window), plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. cap-warn and spike keep the lead regardless of where they appear. Null/undefined = all, in the default order.
  * @param {boolean} [opts.singleLine=false] - force the legacy one-line layout. By default, when the delegation ledger has lifetime savings, the routing totals lead on their own first line and everything else moves to line 2 (Claude Code renders multi-line statuslines; `--single-line` is the escape hatch for terminals that only show the first line).
  */
 export function formatReport(data, { color = true, verbose = false, timer = true, mode = 'text', segments = null, singleLine = false } = {}) {
@@ -1344,6 +1355,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     delegated: delegated.chips,
     // The inline chip steps aside when a headline line owns the story.
     doc2md: doc2md.headline ? [] : [doc2md.chip],
+    star: buildStarSeg(data.star, c, isIcon),
     // This session's subagent runs by model family. It is a session figure, so
     // it sits with the routing chips rather than with the lifetime totals.
     subagents: buildSessionDelegationSeg(data.sessionDelegation, c, isIcon, verbose, g),

package/src/formatters/table.js

@@ -181,17 +181,48 @@ function renderCapWarnSection(caps) {
   return lines;
 }
 
-export function formatReport({ summary: sum, trend, ttl, anomalies, cost, options, spikeReport, contextWindow, caps }, { color } = {}) {
+// Opens the report with what the tool is for, before any warning. A first run
+// (`npx sprag-cli`) has nothing installed yet, so the pitch has to be on screen.
+function renderRoutingSection(routing) {
+  if (!routing || typeof routing !== 'object') return [];
+  const lines = [];
+  lines.push(b(`  🔀 Routing — last ${routing.days}d`));
+  lines.push(`  ${'─'.repeat(50)}`);
+  const total = Number(routing.total) || 0;
+  if (total === 0) {
+    lines.push(`  No Claude Code sessions in the last ${routing.days} days to scan.`);
+    lines.push('');
+    return lines;
+  }
+  const easy = Number(routing.easy) || 0;
+  const pct = Math.round(easy / total * 100);
+  lines.push(`  ${easy} of ${total} requests (${pct}%) were lookups, checks or test runs a cheaper model handles.`);
+  const cands = Array.isArray(routing.candidates) ? routing.candidates : [];
+  if (cands.length === 0) {
+    lines.push('  No recurring delegable work yet (a pattern needs 3 repeats). Approved rules apply from the next session.');
+  } else {
+    for (const c of cands) {
+      lines.push(`  R${c.id}  "${c.labelEn || c.label}" ×${c.count}  →  delegate to ${c.agent}`);
+    }
+    lines.push(`  Approve one:  ${b(`${CLI_NAME} harness promote R${cands[0].id} --global`)}      All candidates:  ${b(`${CLI_NAME} route-scan`)}`);
+  }
+  lines.push('');
+  return lines;
+}
+
+export function formatReport({ summary: sum, trend, ttl, anomalies, cost, options, spikeReport, contextWindow, caps, routing }, { color } = {}) {
   colorOk = color ?? !process.env.NO_COLOR;
   const lines = [];
 
   // Header
   lines.push('');
-  lines.push(`  Claude Token Saver — Last ${options.days} day${options.days === 1 ? '' : 's'}`);
+  lines.push(`  Sprag — Last ${options.days} day${options.days === 1 ? '' : 's'}`);
   lines.push(`  (${CLI_NAME} v${options.version || ''})`.trimEnd());
   lines.push(`  ${'═'.repeat(50)}`);
   lines.push('');
 
+  lines.push(...renderRoutingSection(routing));
+
   // Cap warning leads — it's the most time-sensitive signal we can show.
   if (caps) {
     lines.push(...renderCapWarnSection(caps));

package/src/harness-templates.js

@@ -52,6 +52,16 @@ export function presetRatchetImportLine() {
 }
 export const PRESET_RATCHET_IMPORT_RE = /^@~\/\.claude\/ratchet-preset\.md\s*$/m;
 
+/**
+ * The team ratchet: rules the user's team approved, cached by `sprag team sync`
+ * and rendered into a tool-owned file. Unlike the others its import is not in
+ * the rendered block; it is added only for members, when the file exists.
+ */
+export function teamRatchetImportLine() {
+  return '@~/.claude/ratchet-team.md';
+}
+export const TEAM_RATCHET_IMPORT_RE = /^@~\/\.claude\/ratchet-team\.md\s*$/m;
+
 /**
  * Render ratchet-preset.md. `rules` is [{ id, text }] in display order. The
  * file is loaded into every session, so the header stays short.

package/src/model-rules.js

@@ -72,7 +72,8 @@ export function wilsonLowerBound(errs, n) {
 // route-scan's pre-calibration defaults. Kept as local constants rather than
 // imported: route-scan imports this module, and a static back-import would
 // close the cycle.
-const DEFAULT_BUDGET = { T2: { calls: 8, out: 1500 }, T1: { calls: null, out: 8000 } };
+const DEFAULT_BUDGET = { T2: { calls: 8, out: 1500 }, T1: { calls: null, out: 8000 },
+  T1H: { calls: null, out: 30000 } };
 
 /** The budget a rule is held to: its calibrated one, or the default of its tier. */
 export function ruleBudget(rule) {
@@ -132,20 +133,27 @@ function shortExample(text) {
   return one.length <= EXAMPLE_MAX ? one : `${one.slice(0, EXAMPLE_MAX - 1)}…`;
 }
 
-// T1 is named through its delegation agent only when that file exists; without
-// it the literal `model: sonnet` stays so output on such machines is unchanged.
-function t1Target(root, ko) {
-  if (resolveAgentName('sonnet', root) === null) return null;
-  return (ko ? agentPhrase : agentPhraseEn)('sonnet', { root });
+// T1 (and T1H) is named through its delegation agent only when that file
+// exists; without it the literal `model: sonnet` / `model: opus` stays so
+// output on such machines is unchanged.
+function t1Target(root, ko, tier = 'sonnet') {
+  if (resolveAgentName(tier, root) === null) return null;
+  return (ko ? agentPhrase : agentPhraseEn)(tier, { root });
 }
 
 export function modelRuleBaseText(g, lang = userLanguage(), { root } = {}) {
   if (lang === 'ko') {
+    if (g.tier === 'T1H') {
+      return `"${g.label}" 고난도 구현 요청(예: "${shortExample(g.example)}")은 Fable·Mythos 세션에 한해 ${t1Target(root, true, 'opus') ?? 'model: opus'}에 위임`;
+    }
     return g.tier === 'T2'
       ? `"${g.label}" 단순 요청(예: "${shortExample(g.example)}")은 ${agentPhrase(g.agent, { root })}에 위임`
       : `"${g.label}" 중간 난도 요청(예: "${shortExample(g.example)}")은 ${t1Target(root, true) ?? 'model: sonnet'}에 위임`;
   }
   const example = g.exampleEn || g.example;
+  if (g.tier === 'T1H') {
+    return `Heavy "${g.labelEn}" implementation requests (e.g. "${shortExample(example)}") go to ${t1Target(root, false, 'opus') ?? 'a model: opus subagent'}, in Fable/Mythos sessions only`;
+  }
   return g.tier === 'T2'
     ? `Simple "${g.labelEn}" requests (e.g. "${shortExample(example)}") go to ${agentPhraseEn(g.agent, { root })}`
     : `Moderate "${g.labelEn}" requests (e.g. "${shortExample(example)}") go to ${t1Target(root, false) ?? 'a model: sonnet subagent'}`;
@@ -272,13 +280,27 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '  알려 주는 작업은 하위 티어가 안전하다. 검증 게이트가 품질 하한이 된다.',
     '  틀려도 조용한 작업(진단, 근본 원인 판정, 보안, 설계)은 티어를 내리지',
     '  않는다. 싼 모델은 결정을 옮겨 적을 뿐, 결정을 내리지 못한다.',
+    '- **effort**: 모델 티어와 다른 축이다. 설치된 서브에이전트는 검증 형태에 따라',
+    '  effort가 고정되어 있다. 명령 출력이나 파일 대조로 검증되는 위임(조회·명령',
+    '  실행·정형 변환을 맡는 haiku 에이전트)은 low, 확정된 설계를 테스트에 맞춰',
+    '  구현하는 위임(sonnet 워커)은 medium, 범위가 큰 구현·디버깅 위임(opus 워커)은',
+    '  high다. 메인 세션의 effort는 바꾸지 않고,',
+    '  CLAUDE_CODE_EFFORT_LEVEL은 서브에이전트의 effort를 덮어쓰므로 설정하지 않는다.',
+    '- **고난도 구현(T1H)**: 설계는 메인이 확정하고, 범위가 크거나 sonnet 이 틀린',
+    '  적 있는 구현·디버깅은 opus 에 위임한다. Fable·Mythos 세션에서만 적용되며,',
+    '  설계 판단과 되돌릴 수 없는 작업은 메인 모델에 남긴다.',
     '- **위임 배치**: 서브에이전트 비용의 지배 항은 생성이 아니라 컨텍스트',
     '  적재다. 같은 파일들을 읽어야 하는 작업 여러 개는 에이전트 하나에 묶어',
     '  보내고, 읽는 영역이 다른 작업만 나눈다.',
     implementationDelegationRule('claude', lang),
     '- **에스컬레이션**: 같은 에러 2회 반복, 답이 복수 후보로 갈림, 서브에이전트가',
-    '  질문을 멈추고 헛도는 징후가 보이면 즉시 인계한다. 대응 순서는',
-    '  ① 재지시 후 재시도 → ② 한 티어 상향 → ③ 메인 모델이 직접 수습.',
+    '  질문을 멈추고 헛도는 징후가 보이면 즉시 인계한다. 어느 축을 올릴지는 실패',
+    '  종류로 정한다. 파일을 읽지 않았거나 테스트를 돌리지 않았거나 상한에 걸려',
+    '  멈춘 누락형 실패는 같은 모델에서 effort를 한 단계 올려 한 번만 재시도하고,',
+    '  컨텍스트를 다 보고도 틀린 오판형 실패는 모델을 한 티어 올린다. 순서는',
+    '  ① 재지시 후 재시도(누락형이면 effort 한 단계 위) → ② 한 티어 상향(오판형)',
+    '  → ③ 메인 모델이 직접 수습. effort를 올릴 때는 에이전트 파일을 고치지 않고',
+    '  Agent 도구 호출의 effort 인자에 한 단계 위 값(low → medium → high)을 넘긴다.',
     '',
     '## Rules',
     '',
@@ -323,14 +345,30 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '  the verification gate is the quality floor. Never drop the tier on work',
     '  that fails silently (diagnosis, root-cause calls, security posture,',
     '  design). Cheap models transcribe decisions; they do not make them.',
+    '- **Effort**: a separate axis from the tier. The installed subagents pin it',
+    '  by how their work is verified: low where the check is command output or a',
+    '  file comparison (the haiku agents for lookups, command runs and mechanical',
+    '  conversion), medium where a fixed design is implemented against tests (the',
+    '  sonnet worker), high for large implementation or debugging (the opus',
+    '  worker). Leave the main session\'s effort alone, and never set',
+    '  CLAUDE_CODE_EFFORT_LEVEL: it overrides every subagent\'s own value.',
+    '- **Heavy implementation (T1H)**: the main model fixes the design; large-scope',
+    '  implementation or debugging, or work sonnet has already got wrong, goes to',
+    '  opus. Applies in Fable/Mythos sessions only; design judgement and',
+    '  irreversible work stay on the main model.',
     '- **Batching**: a subagent\'s dominant cost is context ingestion, not',
     '  generation. Bundle tasks that read the same files into one agent; split',
     '  only when the areas they read differ.',
     implementationDelegationRule('claude', lang),
     '- **Escalation**: hand off immediately on the same error twice, an answer',
     '  splitting into multiple candidates, or a subagent spinning without asking',
-    '  questions. Order: ① re-instruct and retry → ② move up one tier → ③ the',
-    '  main model takes over directly.',
+    '  questions. Which axis moves depends on the failure: an omission (a file',
+    '  not read, tests not run, a cap hit mid-task) retries once on the same',
+    '  model one effort step up; a wrong answer with the full context in hand',
+    '  moves up one tier. Order: ① re-instruct and retry (effort +1 on an',
+    '  omission) → ② move up one tier (on a wrong answer) → ③ the main model',
+    '  takes over directly. To raise effort, pass the next level (low → medium →',
+    '  high) in the Agent call\'s effort argument instead of editing the agent file.',
     '',
     '## Rules',
     '',
@@ -363,13 +401,13 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     const saved = r.savedUsd ? `, saved ~${signedUsd(r.savedUsd)}` : '';
     return `${base}, delegated ×${r.delegatedRuns} err ${pct(r.delegatedErrRate)}%${saved}`;
   };
-  // Merged T2+T1 rules carry two caps, so they state both once rather than
+  // Merged rules carry one cap per tier, so they state them 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 ${budgetCapPhrase(t2, 'en')} / sonnet ${budgetCapPhrase(t1, 'en')}`;
+  const TIER_MODEL = { T2: 'haiku', T1: 'sonnet', T1H: 'opus' };
+  const mergedBudget = (tiers) => (ko ? '상한 ' : 'cap ') + tiers
+    .map((r) => `${TIER_MODEL[r.tier]} ${budgetCapPhrase(r, ko ? 'ko' : 'en')}`).join(' / ');
 
-  // A category can carry both a T2 (haiku) and a T1 (sonnet) rule. Tier is
+  // A category can carry a T2 (haiku), a T1 (sonnet) and a T1H (opus) rule. Tier is
   // only known after an episode finishes, so two separate bullets give the
   // reading LLM no way to pick one at request time — merge such pairs into a
   // single conditional rule with explicit request-time criteria (default to
@@ -384,38 +422,50 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
   // text stored on the rule is whatever wording and language were current when
   // it was promoted, which is how an English line sat in a Korean file. A rule
   // missing what the template needs still falls back to its stored text.
-  const baseTextOf = (r) => ((r.tier === 'T2' || r.tier === 'T1') && r.label && (ko || r.labelEn)
+  const baseTextOf = (r) => ((r.tier === 'T2' || r.tier === 'T1' || r.tier === 'T1H') && r.label && (ko || r.labelEn)
     ? modelRuleBaseText(r, lang, { root }) : r.rule);
+  const DELEGATION_TIERS = ['T2', 'T1', 'T1H'];
   for (const group of byCategory.values()) {
-    const t2 = group.find((r) => r.tier === 'T2');
-    const t1 = group.find((r) => r.tier === 'T1');
+    const picked = DELEGATION_TIERS.map((t) => group.find((r) => r.tier === t)).filter(Boolean);
     // A second rule of a tier the line already covers (two global rules of one
     // category, promoted from different projects) says nothing the line does
     // not, so it adds no line of its own. Its review flag and its numbers stay
     // visible on the line that speaks for it.
-    const extras = t2 || t1 ? group.filter((r) => r !== t2 && r !== t1 && (r.tier === 'T2' || r.tier === 'T1')) : [];
-    const unknown = group.filter((r) => r !== t2 && r !== t1 && !extras.includes(r));
+    const extras = picked.length ? group.filter((r) => !picked.includes(r) && DELEGATION_TIERS.includes(r.tier)) : [];
+    const unknown = group.filter((r) => !picked.includes(r) && !extras.includes(r));
     const extraHealth = extras.map(healthOf).join('');
     const extraStats = extras.map((r) => ` / +${r.tier} ${statsOf(r)}`).join('');
-    if (t2 && t1) {
+    if (picked.length >= 2) {
       // 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) => shortExample(ko ? r.example : (r.exampleEn || r.example));
-      // One line per category, stating only what differs between the two tiers.
+      const target = (r) => {
+        if (r.tier === 'T2') return (ko ? agentPhrase : agentPhraseEn)(r.agent, { root });
+        const name = r.tier === 'T1H' ? 'opus' : 'sonnet';
+        return t1Target(root, ko, name) ?? `model: ${name}`;
+      };
+      // One line per category, stating only what differs between the 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 when = (r, first) => {
+        if (first) return ko ? '기본' : 'by default';
+        if (r.tier === 'T1H') return ko ? '범위가 크면(Fable·Mythos 세션 한정)' : 'for large scope (Fable/Mythos sessions only)';
+        return ko ? '여러 단계·여러 파일이 얽히면' : 'when it spans multiple steps or file edits';
+      };
+      const parts = picked.map((r, i) => (ko
+        ? `${when(r, i === 0)} ${target(r)}(예: "${ex(r)}")`
+        : `${i === 0 ? `${target(r)} ${when(r, true)}` : `${target(r)} ${when(r, false)}`} (e.g. "${ex(r)}")`));
+      const head = picked[0];
       const rule = ko
-        ? `"${t2.label}": 기본 ${agentPhrase(t2.agent, { root })}(예: "${ex(t2)}"), ` +
-          `여러 단계·여러 파일이 얽히면 ${t1Target(root, true) ?? 'model: sonnet'}(예: "${ex(t1)}"). ` +
-          mergedBudget(t2, t1)
-        : `"${t2.labelEn || t2.label}": ${agentPhraseEn(t2.agent, { root })} by default (e.g. "${ex(t2)}"), ` +
-          `${t1Target(root, false) ?? 'model: sonnet'} when it spans multiple steps or file edits (e.g. "${ex(t1)}"). ` +
-          mergedBudget(t2, t1);
-      lines.push(`- ${rule}${healthOf(t2)}${healthOf(t1)}${extraHealth} <!-- T2 ${statsOf(t2)} / T1 ${statsOf(t1)}${extraStats} -->`);
-    } else if (t2 || t1) {
-      const r = t2 || t1;
+        ? `"${head.label}": ${parts.join(', ')}. ${mergedBudget(picked)}`
+        : `"${head.labelEn || head.label}": ${parts.join(', ')}. ${mergedBudget(picked)}`;
+      const health = picked.map(healthOf).join('');
+      const stats = picked.map((r) => `${r.tier} ${statsOf(r)}`).join(' / ');
+      lines.push(`- ${rule}${health}${extraHealth} <!-- ${stats}${extraStats} -->`);
+    } else if (picked.length === 1) {
+      const r = picked[0];
       lines.push(`- ${composeRuleText(baseTextOf(r), r, lang)}${healthOf(r)}${extraHealth} <!-- ${statsOf(r)}${extraStats} -->`);
     }
     for (const r of unknown) lines.push(`- ${composeRuleText(r.rule, r, lang)}${healthOf(r)} <!-- ${statsOf(r)} -->`);

package/src/route-caps.js

@@ -13,7 +13,7 @@
  * rule clears it, so a cap never outlives the turn it was stated for.
  *
  * State: <stateDir>/route-caps.json
- *   { sessions: { [session_id]: { ts, T2?: { calls, out }, T1?: { calls, out } } } }
+ *   { sessions: { [session_id]: { ts, T2?: { calls, out }, T1?: { calls, out }, T1H?: { calls, out } } } }
  */
 
 import { readFileSync } from 'node:fs';
@@ -49,7 +49,7 @@ export function recordRouteCaps(sessionId, caps, now = Date.now()) {
   if (typeof sessionId !== 'string' || sessionId === '') return false;
   const state = load();
   const next = {};
-  for (const tier of ['T2', 'T1']) {
+  for (const tier of ['T2', 'T1', 'T1H']) {
     if (validBudget(caps?.[tier])) next[tier] = { calls: caps[tier].calls ?? null, out: caps[tier].out };
   }
   const has = Object.keys(next).length > 0;
@@ -69,6 +69,6 @@ export function routeCapsFor(sessionId, now = Date.now()) {
   const s = load().sessions[sessionId];
   if (!s || !Number.isFinite(s.ts) || now - s.ts > TTL_MS) return null;
   const out = {};
-  for (const tier of ['T2', 'T1']) if (validBudget(s[tier])) out[tier] = s[tier];
+  for (const tier of ['T2', 'T1', 'T1H']) if (validBudget(s[tier])) out[tier] = s[tier];
   return Object.keys(out).length ? out : null;
 }

package/src/route-inject.js

@@ -126,8 +126,8 @@ export function sessionModelRank({ env = process.env, transcriptPath = null, sna
  * and saves nothing. Outside such a host an unset variable selects Claude
  * Code's built-in default for the tier, so nothing is reported unreachable.
  */
-const TIER_ALIAS_ENV = { T2: 'ANTHROPIC_DEFAULT_HAIKU_MODEL', T1: 'ANTHROPIC_DEFAULT_SONNET_MODEL' };
-const TIER_ALIAS = { T2: 'haiku', T1: 'sonnet' };
+const TIER_ALIAS_ENV = { T2: 'ANTHROPIC_DEFAULT_HAIKU_MODEL', T1: 'ANTHROPIC_DEFAULT_SONNET_MODEL', T1H: 'ANTHROPIC_DEFAULT_OPUS_MODEL' };
+const TIER_ALIAS = { T2: 'haiku', T1: 'sonnet', T1H: 'opus' };
 
 export function unreachableTiers(env = process.env) {
   if (env.CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST !== '1') return [];
@@ -205,7 +205,8 @@ export function routeMatch(text, { rules, sessionRank = null, root, env = proces
   const nearest = [...reachable].sort((a, b) => scopeRank(b) - scopeRank(a));
   const t2 = nearest.find((r) => r.tier === 'T2');
   const t1 = nearest.find((r) => r.tier === 'T1');
-  return t2 || t1 ? { cat, t2, t1 } : null;
+  const t1h = nearest.find((r) => r.tier === 'T1H');
+  return t2 || t1 || t1h ? { cat, t2, t1, t1h } : null;
 }
 
 /** The budgets a match states, by tier: what the delegation guard repeats to the subagent. */
@@ -214,6 +215,7 @@ export function matchCaps(match) {
   const caps = {};
   if (match.t2) caps.T2 = ruleBudget(match.t2);
   if (match.t1) caps.T1 = ruleBudget(match.t1);
+  if (match.t1h) caps.T1H = ruleBudget(match.t1h);
   return caps;
 }
 
@@ -248,10 +250,10 @@ function unreachableNotice(label, tiers, ko) {
 export function routeHint(text, { rules, lang = userLanguage(), root, sessionRank = null, match, env } = {}) {
   const found = match === undefined ? routeMatch(text, { rules, sessionRank, root, env }) : match;
   if (!found) return null;
-  const { cat, t2, t1 } = found;
+  const { cat, t2, t1, t1h } = found;
   const ko = lang === 'ko';
   const label = ko ? (cat.label || cat.id) : (cat.labelEn || cat.label || cat.id);
-  if (!t2 && !t1 && found.unreachable?.length) return unreachableNotice(label, found.unreachable, ko);
+  if (!t2 && !t1 && !t1h && found.unreachable?.length) return unreachableNotice(label, found.unreachable, ko);
   // `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
@@ -262,21 +264,28 @@ export function routeHint(text, { rules, lang = userLanguage(), root, sessionRan
   // T1 is named through its delegation agent only when that file exists here;
   // otherwise the literal tier string stays, so output without agents is unchanged.
   const t1Root = root === undefined ? undefined : root;
-  const t1Named = resolveAgentName('sonnet', t1Root) !== null;
-  const t1Phrase = t1Named ? phrase('sonnet') : 'model: sonnet';
+  const tierPhrase = (name) => (resolveAgentName(name, t1Root) !== null ? phrase(name) : `model: ${name}`);
+  const picked = [t2, t1, t1h].filter(Boolean);
   let target;
-  if (t2 && t1) {
+  if (picked.length >= 2) {
+    const named = (r) => (r.tier === 'T2' ? phrase(r.agent) : tierPhrase(r.tier === 'T1H' ? 'opus' : 'sonnet'));
+    const when = (r, i) => {
+      if (i === 0) return null;
+      if (r.tier === 'T1H') return ko ? '범위가 크면(Fable·Mythos 세션 한정)' : 'for large scope (Fable/Mythos sessions only)';
+      return ko ? '여러 단계·여러 파일이 얽히면' : 'when it spans multiple steps or file edits';
+    };
     target = ko
-      ? `기본 ${phrase(t2.agent)}, 여러 단계·여러 파일이 얽히면 ${t1Phrase}`
-      : `${phrase(t2.agent)} by default, ${t1Phrase} when it spans multiple steps or file edits`;
+      ? picked.map((r, i) => `${when(r, i) ?? '기본'} ${named(r)}`).join(', ')
+      : picked.map((r, i) => (i === 0 ? `${named(r)} by default` : `${named(r)} ${when(r, i)}`)).join(', ');
   } else {
-    const only = t2 || t1;
-    target = ko ? phrase(only.agent) : phrase(only.agent);
+    const only = picked[0];
+    target = only.tier === 'T1H' ? tierPhrase('opus') : 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]}`)
+  const MODEL_OF = { T2: 'haiku', T1: 'sonnet', T1H: 'opus' };
+  const caps = picked.map((r) => budgetCapPhrase(r, lang));
+  const capText = picked.length >= 2
+    ? (ko ? '상한 ' : 'cap ') + picked.map((r, i) => `${MODEL_OF[r.tier]} ${caps[i]}`).join(' / ')
     : (ko ? `상한 ${caps[0]}` : `cap ${caps[0]}`);
 
   // The marker line is the one in ratchet-model.md, so the user sees the same

package/src/route-scan.js

@@ -44,6 +44,10 @@ export const T2_OUT_CLAMP = [1000, 3000];   // default 1500 pre-calibration
 export const T1_MAX_MUTATING = 6;
 export const T1_MAX_ERRORS = 1;
 export const T1_OUT_CLAMP = [5000, 15000];  // default 8000 pre-calibration
+// T1H (opus, Fable sessions only): too heavy for sonnet but still bounded.
+export const T1H_MAX_ERRORS = 3;
+export const T1H_MAX_MUTATING = 20;
+export const T1H_OUT_CLAMP = [15000, 60000]; // default 30000 pre-calibration
 export const T0_MIN_ERRORS = 2;             // repeated tool errors = hard, by outcome
 export const T0_MIN_MUTATING = 7;
 // Episodes below this output size carry no delegable work (conversational
@@ -65,7 +69,14 @@ export const MIN_DELEGABLE_OUT = 100;
 // questions that merely contained "statusline". None gained a hint. Bare
 // '리뷰' and '보안' are left out on purpose: they are product nouns in ordinary
 // status checks ("리뷰 허브 배치 확인"), so only the request-shaped forms count.
-export const ESCALATE_RE = /설계|아키텍처|리팩토링|원인\s*(?:분석|파악|확인|규명|조사)|원인을?\s*찾|버그|개선할|개선점|개선\s*(?:사항|방안)|검토해보|검수|코드\s*리뷰|리뷰\s*해|취약|보안\s*(?:점검|검토|감사|리뷰|이슈)|비교|왜(?=[\s?]|$)|이유|제출|배포|출시|퍼블리시|릴리[스즈](?!\s*노트)|(?<!나)머지|analyze|compare|evaluate|architect|refactor|submit|deploy|release|publish|merge|root cause|code review|security (?:review|audit)|vulnerabilit/i;
+//
+// 2026-10-18: production-database work and a user's go-ahead ("운영디비 승인할게
+// 너가 진행해줘", "승인할게 너가 직접 실행해줘") read as light run episodes and
+// became Opus (T1H) candidates. Measured on 6,473 local prompts over 90 days:
+// the two term groups catch 7 + 12 prompts, of which 4 were not already
+// escalated, all of them approvals or production-DB asks. Bare '승인' is left
+// out: "승인된 룰" is a product noun in sprag's own ratchet flow.
+export const ESCALATE_RE = /운영\s*(?:db|디비|데이터베이스|서버|환경)|프로덕션|\bprod(?:uction)?\s*(?:db|database|server|env)|승인\s*(?:할게|했어|했으니|했습니다|합니다|해줄게|완료)|\bapproved?\b|설계|아키텍처|리팩토링|원인\s*(?:분석|파악|확인|규명|조사)|원인을?\s*찾|버그|개선할|개선점|개선\s*(?:사항|방안)|검토해보|검수|코드\s*리뷰|리뷰\s*해|취약|보안\s*(?:점검|검토|감사|리뷰|이슈)|비교|왜(?=[\s?]|$)|이유|제출|배포|출시|퍼블리시|릴리[스즈](?!\s*노트)|(?<!나)머지|analyze|compare|evaluate|architect|refactor|submit|deploy|release|publish|merge|root cause|code review|security (?:review|audit)|vulnerabilit/i;
 
 // Implementation asks phrased around a run/check verb ("설치와 동시에 설정되도록
 // 하자", "피드백 확인해주고 아이콘도 만들자"). Editing is not delegable, and at
@@ -412,32 +423,30 @@ const percentile = (sorted, p) => sorted[Math.min(sorted.length - 1, Math.floor(
  * Falls back to mid-clamp defaults when the sample is too small to trust.
  */
 export function calibrateThresholds(episodeOuts) {
-  if (episodeOuts.length < 100) return { t2Out: 1500, t1Out: 8000, calibrated: false };
+  if (episodeOuts.length < 100) return { t2Out: 1500, t1Out: 8000, t1hOut: 30000, calibrated: false };
   const sorted = [...episodeOuts].sort((a, b) => a - b);
   return {
     t2Out: clamp(Math.max(percentile(sorted, 0.25), 1500), T2_OUT_CLAMP),
     t1Out: clamp(percentile(sorted, 0.75), T1_OUT_CLAMP),
+    t1hOut: clamp(percentile(sorted, 0.95), T1H_OUT_CLAMP),
     calibrated: true,
   };
 }
 
 /**
- * Tier classification (docs/TIER_CRITERIA.md §3). Returns 'T0'|'T1'|'T2',
+ * Tier classification (docs/TIER_CRITERIA.md §3). Returns 'T0'|'T1H'|'T1'|'T2',
  * or null when the episode carries nothing delegable. Order matters: hard
  * evidence (errors, heavy mutation, big output, judgement keywords) wins
  * before any cheap-band check.
  */
 export function tierOf(ep, category, th) {
   if (ep.out < MIN_DELEGABLE_OUT) return null;
-  if (
-    ep.errors >= T0_MIN_ERRORS ||
-    ep.mutating >= T0_MIN_MUTATING ||
-    ep.out > th.t1Out ||
-    ESCALATE_RE.test(ep.text)
-  ) return 'T0';
+  if (ESCALATE_RE.test(ep.text)) return 'T0';
   if (!category || ep.delegated > 0) return 'T0';
   if (ep.calls <= T2_MAX_CALLS && ep.out <= th.t2Out && ep.mutating <= T2_MAX_MUTATING && ep.errors === 0) return 'T2';
   if (ep.out <= th.t1Out && ep.mutating <= T1_MAX_MUTATING && ep.errors <= T1_MAX_ERRORS) return 'T1';
+  const t1hOut = th.t1hOut ?? 30000;
+  if (ep.errors <= T1H_MAX_ERRORS && ep.mutating <= T1H_MAX_MUTATING && ep.out <= t1hOut) return 'T1H';
   return 'T0';
 }
 
@@ -611,13 +620,13 @@ export async function runRouteScan({ days = 14 } = {}) {
       const shapeTier = tierOf({ ...ep, errors: 0 }, cat, thresholds);
       // Same rank gate as the candidate path below — a denominator counting
       // episodes that can't produce a rule would skew that rule's error rate.
-      if ((shapeTier === 'T1' || shapeTier === 'T2') && worthDelegating(shapeTier, epRank)) {
+      if ((shapeTier === 'T1' || shapeTier === 'T2' || shapeTier === 'T1H') && worthDelegating(shapeTier, epRank)) {
         bumpStats(`${shapeTier}|${cat.id}|${projectDir}`, ep);
         bumpStats(`${shapeTier}|${cat.id}|*`, ep);
       }
     }
     const tier = tierOf(ep, cat, thresholds);
-    if (tier !== 'T1' && tier !== 'T2') continue;
+    if (tier !== 'T1' && tier !== 'T2' && tier !== 'T1H') continue;
     if (!worthDelegating(tier, epRank)) continue;
     tieredEpisodes += 1;
     const key = `${tier}|${cat.id}|${projectDir}`;
@@ -626,7 +635,7 @@ export async function runRouteScan({ days = 14 } = {}) {
       category: cat.id,
       label: cat.label,
       labelEn: cat.labelEn,
-      agent: tier === 'T2' ? cat.agent : 'sonnet',
+      agent: tier === 'T2' ? cat.agent : tier === 'T1H' ? 'opus' : 'sonnet',
       project: projectDir,
       projectPath: '',
       count: 0,
@@ -653,7 +662,7 @@ export async function runRouteScan({ days = 14 } = {}) {
   // where a promoted rule's real success rate lives, so they get their own
   // pass: join each episode to the subagent transcripts it spawned, and file
   // the outcome under the tier that run's model represents — a haiku run is a
-  // T2 rule firing, a sonnet run a T1 one. Runs that were not a downgrade
+  // T2 rule firing, a sonnet run a T1 one, an opus run (Fable session) a T1H one. Runs that were not a downgrade
   // (same tier or higher) carry no delegation saving and are skipped.
   const delegatedStats = new Map(); // "tier|category|project" → outcome aggregate
   let unresolvedRuns = 0;           // delegated runs dropped for an unpriceable model id
@@ -774,7 +783,7 @@ export async function runRouteScan({ days = 14 } = {}) {
   // time rather than hardcoded downstream.
   const budgetOf = (g) => ({
     calls: g.tier === 'T2' ? T2_MAX_CALLS + 2 : null,
-    out: g.tier === 'T2' ? thresholds.t2Out : thresholds.t1Out,
+    out: g.tier === 'T2' ? thresholds.t2Out : g.tier === 'T1H' ? thresholds.t1hOut : thresholds.t1Out,
   });
   // Shared with the seed presets (src/seed-rules.js) through model-rules.js —
   // one template, so a reworded rule cannot mean two different things
@@ -945,7 +954,7 @@ export async function shouldRescan(cache, { days = 14, afterDelegation = false }
 }
 
 /**
- * Human-readable labels for the T0/T1/T2 codes and scope values — used by
+ * Human-readable labels for the T0/T1H/T1/T2 codes and scope values — used by
  * every user-facing listing so a bare code never appears without its meaning
  * (first-time users can't be expected to know the tier vocabulary).
  */
@@ -953,11 +962,13 @@ export function tierLabel(tier, lang = 'ko') {
   const ko = {
     T2: '단순 작업, haiku급이면 충분',
     T1: '중간 난도, sonnet급이면 충분',
+    T1H: '고난도 구현, opus급이면 충분 (Fable 세션 전용)',
     T0: '고난도, 지금 모델 유지',
   };
   const en = {
     T2: 'simple — haiku-class is enough',
     T1: 'moderate — sonnet-class is enough',
+    T1H: 'heavy, opus-class is enough (Fable sessions only)',
     T0: 'hard — stays on the session model',
   };
   return (lang === 'ko' ? ko : en)[tier] || tier;

package/src/shared-model-rules.js

@@ -3,7 +3,7 @@ import { isAbsolute, resolve } from 'node:path';
 import { loadModelRules, ruleBudget } from './model-rules.js';
 import { findProjectRoot } from './harness.js';
 
-export const SHARED_RULE_TIERS = ['T2', 'T1'];
+export const SHARED_RULE_TIERS = ['T2', 'T1', 'T1H'];
 const CATEGORIES = new Set(['paste', 'translate', 'explore', 'read', 'check', 'run']);
 
 /** A root as a real path, so a symlinked checkout or macOS /var names one directory once. */

package/src/star-note.js

@@ -0,0 +1,62 @@
+/**
+ * star-note — a one-time "star the repo" ask in the statusline.
+ *
+ * The package is downloaded thousands of times a month and starred a handful
+ * of times: all of the value lands in the statusline, so users never see the
+ * repository. This asks once, at the moment the value is visible — when the
+ * savings sprag itself produced (routing + doc2md) first reach $10.
+ *
+ * Once, because a chip that keeps asking is an advertisement. For 24 hours,
+ * which is long enough to be seen across a day of sessions and short enough
+ * not to linger. CTS_NO_NOTE=1 suppresses it, the same opt-out as every
+ * other one-time note.
+ */
+
+import { createRequire } from 'node:module';
+import { delegationSavedTotals } from './savings-ledger.js';
+import { noteShownAt, markNoteShown } from './first-run-note.js';
+import { userDataDir } from './paths.js';
+import { debug } from './debug.js';
+
+const require = createRequire(import.meta.url);
+
+export const STAR_THRESHOLD_USD = 10;
+export const STAR_WINDOW_MS = 24 * 60 * 60 * 1000;
+export const STAR_URL = 'github.com/rootstudioyaml/sprag';
+
+/** Lifetime dollars saved by routing and doc2md; an unreadable ledger counts as 0. */
+export function toolSavedUsd(now = Date.now(), dir = userDataDir()) {
+  let total = 0;
+  try {
+    total += Number(delegationSavedTotals(now, dir).total) || 0;
+  } catch (e) {
+    debug('star-note:routing', e);
+  }
+  try {
+    total += Number(require('./doc2md-ledger.cjs').doc2mdSavedTotals(dir).total) || 0;
+  } catch (e) {
+    debug('star-note:doc2md', e);
+  }
+  return total;
+}
+
+/** `{ usd, shownAt }` while the chip should show, else null. Never throws. */
+export function readStarChip({ now = Date.now(), dir = userDataDir(), savedUsd } = {}) {
+  try {
+    if (process.env.CTS_NO_NOTE === '1') return null;
+    const shownAt = noteShownAt('star');
+    if (shownAt === null) {
+      const usd = savedUsd ?? toolSavedUsd(now, dir);
+      if (!(usd >= STAR_THRESHOLD_USD)) return null;
+      markNoteShown('star', now);
+      return { usd, shownAt: now };
+    }
+    if (now - shownAt < STAR_WINDOW_MS) {
+      return { usd: savedUsd ?? toolSavedUsd(now, dir), shownAt };
+    }
+    return null;
+  } catch (e) {
+    debug('star-note', e);
+    return null;
+  }
+}