sprag-cli 3.69.0 → 3.71.0

package/src/presets-source.js

@@ -0,0 +1,209 @@
+/**
+ * presets-source — which presets this machine uses: the centrally published
+ * bundle or the copy shipped in the npm package.
+ *
+ * The superuser publishes ratchet presets, model-routing presets and the
+ * delegation agent definitions from the /ops console as one signed bundle.
+ * preset-sync.js fetches it (read-only, at most daily, in a detached child) into
+ * <userDataDir>/presets-remote.json. Everything that reads presets comes through
+ * here, so a newer bundle takes effect at the next session start after a fetch.
+ *
+ * The remote bundle wins only while it is valid, checked again on every read:
+ * its signature verifies against a key in PRESET_SIGNING_KEYS, its format is
+ * one this CLI understands, its min_cli is not newer than this CLI, its shape is
+ * right and it is at most 200 KB. Anything else falls back to the bundled
+ * presets in presets/*.json, which have the same shape. So a blocked network, a
+ * server outage or a tampered response leaves the machine exactly where a fresh
+ * install of this version would be.
+ *
+ * SPRAG_NO_PRESET_SYNC=1 (or SPRAG_NO_UPDATE_CHECK=1) turns the remote source
+ * off entirely: no fetch, and a cached bundle is ignored.
+ */
+
+import { readFileSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { envVar } from './env.js';
+import { userDataDir } from './paths.js';
+import {
+  PRESET_BUNDLE_FORMAT, PRESET_MAX_BYTES, PRESET_SIGNING_KEYS, verifyBundleSignature,
+} from './preset-sign.js';
+
+const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+const require = createRequire(import.meta.url);
+
+export function cliVersion() {
+  try { return require('../package.json').version; } catch { return '0.0.0'; }
+}
+
+export function presetSyncDisabled(env = process.env) {
+  return envVar('NO_PRESET_SYNC', env) === '1' || envVar('NO_UPDATE_CHECK', env) === '1';
+}
+
+export function remoteCachePath(dir = userDataDir()) { return join(dir, 'presets-remote.json'); }
+
+/** -1, 0 or 1. Pre-release suffixes are ignored; unparsable versions compare as 0.0.0. */
+export function compareVersions(a, b) {
+  const p = (v) => (String(v || '').trim().match(/^v?(\d+)\.(\d+)\.(\d+)/) || [0, 0, 0, 0]).slice(1, 4).map(Number);
+  const x = p(a), y = p(b);
+  for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return x[i] > y[i] ? 1 : -1;
+  return 0;
+}
+
+const ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+const NAME_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+const MODEL_RE = /^[A-Za-z0-9._-]{1,80}$/;
+const LINE_RE = /^[^\r\n]{1,600}$/;
+const TOOL_RE = /^[A-Za-z0-9_*().: -]{1,80}$/;
+const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const TIERS = ['T1', 'T2', 'T1H'];
+const str = (v) => typeof v === 'string' && v.trim() !== '';
+
+function uniq(list, key) {
+  const seen = new Set();
+  for (const x of list) { if (seen.has(x[key])) return false; seen.add(x[key]); }
+  return true;
+}
+
+/**
+ * Shape check for a bundle. Returns null when valid, else a short reason code.
+ * Rejected here rather than when rendering: an agent name with a slash would be
+ * a path outside ~/.claude/agents, and a newline in a frontmatter field would
+ * let the description write its own `tools:` line.
+ */
+export function bundleShapeError(b) {
+  if (!b || typeof b !== 'object' || Array.isArray(b)) return 'shape';
+  let bytes;
+  try { bytes = Buffer.byteLength(JSON.stringify(b), 'utf8'); } catch { return 'shape'; }
+  if (bytes > PRESET_MAX_BYTES) return 'too-large';
+  if (!Number.isInteger(b.format) || b.format < 1) return 'shape';
+  if (b.format > PRESET_BUNDLE_FORMAT) return 'format';
+  if (!Number.isInteger(b.version) || b.version < 1) return 'shape';
+  if (b.min_cli != null && typeof b.min_cli !== 'string') return 'shape';
+  const { ratchet_rules: rr, model_rules: mr, agents: ag } = b;
+  if (!Array.isArray(rr) || !Array.isArray(mr) || !Array.isArray(ag)) return 'shape';
+  for (const r of rr) {
+    if (!r || !ID_RE.test(r.id) || !str(r.ko) || !str(r.en)) return 'shape';
+    if (r.agents != null && (!Array.isArray(r.agents) || r.agents.some((a) => a !== 'claude' && a !== 'codex'))) return 'shape';
+  }
+  for (const m of mr) {
+    if (!m || !ID_RE.test(m.id) || !TIERS.includes(m.tier) || !ID_RE.test(m.category)) return 'shape';
+    if (!str(m.label) || !str(m.labelEn) || !str(m.agent) || !LINE_RE.test(m.agent)) return 'shape';
+    if (m.budget != null && (typeof m.budget !== 'object' || Array.isArray(m.budget))) return 'shape';
+  }
+  for (const a of ag) {
+    if (!a || !NAME_RE.test(a.name) || !MODEL_RE.test(a.model) || !EFFORTS.includes(a.effort)) return 'shape';
+    if (!Array.isArray(a.tools) || a.tools.length === 0 || a.tools.some((t) => typeof t !== 'string' || !TOOL_RE.test(t))) return 'shape';
+    if (!a.description || !LINE_RE.test(a.description.en || '') || (a.description.ko != null && !LINE_RE.test(a.description.ko))) return 'shape';
+    if (!a.body || !str(a.body.en)) return 'shape';
+  }
+  if (!uniq(rr, 'id') || !uniq(mr, 'id') || !uniq(ag, 'name')) return 'shape';
+  return null;
+}
+
+/**
+ * Whether this CLI may apply a bundle. { ok, reason?, kid? } with reason one of
+ * shape, too-large, format, min-cli, no-keys, unsigned, unknown-kid, bad-sig.
+ * No keys is checked before the signature: it is the more basic answer.
+ */
+export function evaluateBundle(b, { version = cliVersion(), keys = PRESET_SIGNING_KEYS } = {}) {
+  const shape = bundleShapeError(b);
+  if (shape) return { ok: false, reason: shape };
+  if (!Array.isArray(keys) || keys.length === 0) return { ok: false, reason: 'no-keys' };
+  if (b.min_cli && compareVersions(b.min_cli, version) > 0) return { ok: false, reason: 'min-cli' };
+  const sig = verifyBundleSignature(b, keys);
+  return sig.ok ? { ok: true, kid: sig.kid } : { ok: false, reason: sig.reason };
+}
+
+export function readRemoteCache(dir = userDataDir()) {
+  try {
+    const c = JSON.parse(readFileSync(remoteCachePath(dir), 'utf8'));
+    return c && typeof c === 'object' && !Array.isArray(c) ? c : {};
+  } catch {
+    return {};
+  }
+}
+
+// One evaluation per cache-file revision: the session-start path reads the
+// presets several times (seed offer, preset file, agents, route-scan).
+let memo = null;
+export function resetPresetSourceMemo() { memo = null; }
+
+function activeRemote({ env = process.env, dir = userDataDir(), keys = PRESET_SIGNING_KEYS, version = cliVersion() } = {}) {
+  if (presetSyncDisabled(env)) return { bundle: null, reason: 'disabled', cache: {} };
+  const file = remoteCachePath(dir);
+  let sig;
+  try { const s = statSync(file); sig = `${file}|${s.mtimeMs}|${s.size}|${keys.length}|${version}`; } catch { return { bundle: null, reason: 'no-cache', cache: {} }; }
+  if (memo && memo.sig === sig && memo.keys === keys) return memo.value;
+  const cache = readRemoteCache(dir);
+  let value;
+  if (!cache.bundle) value = { bundle: null, reason: 'no-cache', cache };
+  else {
+    const ev = evaluateBundle(cache.bundle, { version, keys });
+    value = ev.ok ? { bundle: cache.bundle, kid: ev.kid, cache } : { bundle: null, reason: ev.reason, cache };
+  }
+  memo = { sig, keys, value };
+  return value;
+}
+
+/** { kind: 'remote'|'bundled', version, fetchedAt, kid?, reason? } */
+export function presetSource(opts = {}) {
+  const r = activeRemote(opts);
+  if (r.bundle) return { kind: 'remote', version: r.bundle.version, fetchedAt: r.cache.fetchedAt || null, kid: r.kid };
+  return { kind: 'bundled', version: null, fetchedAt: r.cache.fetchedAt || null, reason: r.reason };
+}
+
+function readBundled(name) {
+  try { return JSON.parse(readFileSync(join(packageRoot, 'presets', name), 'utf8')); } catch { return null; }
+}
+
+const derivedId = (ko) => `fix-${createHash('sha1').update(ko).digest('hex').slice(0, 6)}`;
+
+function normaliseRatchet(list) {
+  return (Array.isArray(list) ? list : [])
+    .filter((r) => r && typeof r.ko === 'string' && r.ko.trim())
+    .map((r) => ({
+      // Explicit ids are stable across rewording. A rule without one (an older
+      // file) gets the id the Korean text always produced.
+      id: typeof r.id === 'string' && r.id ? r.id : derivedId(r.ko.trim()),
+      ko: r.ko.trim(), en: (r.en || r.ko).trim(),
+      ...(Array.isArray(r.agents) ? { agents: r.agents.filter((a) => typeof a === 'string') } : {}),
+    }));
+}
+
+/** Ratchet presets: [{ id, ko, en, agents? }] */
+export function ratchetPresetEntries(opts = {}) {
+  const r = activeRemote(opts);
+  if (r.bundle) return normaliseRatchet(r.bundle.ratchet_rules);
+  return normaliseRatchet(readBundled('ratchet-rules.json')?.rules);
+}
+
+/** Model-routing presets, the objects of presets/model-rules.json `presets`. */
+export function modelPresets(opts = {}) {
+  const r = activeRemote(opts);
+  if (r.bundle) return r.bundle.model_rules.map((p) => ({ ...p }));
+  const data = readBundled('model-rules.json');
+  return Array.isArray(data?.presets) ? data.presets : [];
+}
+
+/** Delegation agents: [{ name, model, effort, tools[], description{ko,en}, body{ko,en} }] */
+export function agentDefinitions(opts = {}) {
+  const r = activeRemote(opts);
+  if (r.bundle) return r.bundle.agents.map((a) => ({ ...a }));
+  const data = readBundled('agents.json');
+  return Array.isArray(data?.agents) ? data.agents : [];
+}
+
+/** The bundle the bundled files make: the shape the server seeds as version 1. */
+export function bundledBundle({ version = 1, minCli = null } = {}) {
+  return {
+    format: PRESET_BUNDLE_FORMAT,
+    version,
+    min_cli: minCli,
+    ratchet_rules: normaliseRatchet(readBundled('ratchet-rules.json')?.rules),
+    model_rules: readBundled('model-rules.json')?.presets || [],
+    agents: readBundled('agents.json')?.agents || [],
+  };
+}

package/src/prompt.js

@@ -9,6 +9,7 @@
  * decide-it-for-them behavior untouched.
  */
 
+import { envVar } from './env.js';
 import { createInterface } from 'node:readline';
 
 /**
@@ -19,7 +20,7 @@ import { createInterface } from 'node:readline';
  * checked because build agents deadlock rather than answer.
  */
 export function canPrompt({ env = process.env, stdin = process.stdin, stdout = process.stdout } = {}) {
-  if (env.CTS_NO_INPUT === '1') return false;
+  if (envVar('NO_INPUT', env) === '1') return false;
   if (env.CI && env.CI !== 'false') return false;
   if (env.npm_lifecycle_event === 'postinstall') return false;
   return Boolean(stdin.isTTY && stdout.isTTY);

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

@@ -30,6 +30,7 @@ import { sessionCost } from './claude-price.js';
 import { learnProfileMapping, resetModelAliasCache } from './model-alias.js';
 import { modelRuleBaseText } from './model-rules.js';
 import { readResetMarks, isBeforeReset } from './saved-reset.cjs';
+import { modelPresets as sourceModelPresets } from './presets-source.js';
 
 // ── Tier bands (docs/TIER_CRITERIA.md §3) ────────────────────────────────
 // T2 (haiku): finished in few calls, tiny output, near-zero mutation, no
@@ -44,6 +45,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 +70,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
@@ -151,6 +163,18 @@ const CATEGORIES = [
     kw: [[/\bgit |\bcommit(?:s|ted)?\b|\bpush(?:ed|es)?\b|\bnpm |\bpip3? |빌드해|빌드 돌/i, 2], [/실행|돌려|\brun\b|\bbuild\b|빌드|테스트|설치/i, 1]],
   },
 ];
+// The T2 agent a category's candidates name follows the published model presets
+// when one covers that category (presets-source.js), so renaming an agent in the
+// /ops console renames it in new candidates too. Categories without a preset
+// (translate) keep the name above.
+function t2AgentFor(cat) {
+  try {
+    const p = sourceModelPresets().find((x) => x.tier === 'T2' && x.category === cat.id);
+    if (p && typeof p.agent === 'string' && p.agent) return p.agent;
+  } catch { /* the built-in name below */ }
+  return cat.agent;
+}
+
 // English keywords are matched as whole words. As bare substrings, `pip`
 // claimed "pipeline", `commit` "commitment", `find` "findings" and `status`
 // "statusline", which filed questions about those under run, explore or check.
@@ -412,32 +436,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 +633,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 +648,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' ? t2AgentFor(cat) : tier === 'T1H' ? 'opus' : 'sonnet',
       project: projectDir,
       projectPath: '',
       count: 0,
@@ -653,7 +675,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 +796,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 +967,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 +975,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/seed-rules.js

@@ -12,6 +12,8 @@
  * This module closes that gap with presets bundled in the package:
  *   presets/model-rules.json   → tier-delegation rules (the model ratchet)
  *   presets/ratchet-rules.json → field-tested mistake rules (the global ratchet)
+ * or, when one has been fetched and verifies, the centrally published bundle
+ * with the same shape (presets-source.js).
  *
  * Nothing is written without the user agreeing to that specific rule. The
  * SessionStart hook lists what is pending and tells the model to ask one rule at
@@ -25,9 +27,8 @@
 
 import { readFileSync } from 'node:fs';
 import { CLI_NAME } from './cli-name.js';
-import { join, dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createHash } from 'node:crypto';
+import { join, resolve } from 'node:path';
+import { modelPresets as sourceModelPresets } from './presets-source.js';
 import { sharedModelRulesForProject, loadSharedModelRules, sharedProjectRoots, realProjectRoot } from './shared-model-rules.js';
 import { userDataDir } from './paths.js';
 import { userLanguage } from './config.js';
@@ -45,8 +46,6 @@ import {
   presetRuleEntries,
 } from './harness.js';
 
-const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
-
 // Codex answers are kept apart: saying no in one agent must not consume the
 // other agent's offer, and the two agents write to different ratchet files.
 export function seedStatePath({ agent = 'claude' } = {}) {
@@ -66,14 +65,12 @@ export function saveSeedState(state, opts = {}) {
   writeStateFile(seedStatePath(opts), JSON.stringify(state, null, 2) + '\n');
 }
 
-/** Bundled tier-delegation presets (empty array when the file is unreadable). */
+/**
+ * Tier-delegation presets: the published bundle when it verifies, else the
+ * bundled presets/model-rules.json (empty array when that is unreadable).
+ */
 export function modelPresets() {
-  try {
-    const data = JSON.parse(readFileSync(join(packageRoot, 'presets', 'model-rules.json'), 'utf8'));
-    return Array.isArray(data.presets) ? data.presets : [];
-  } catch {
-    return [];
-  }
+  return sourceModelPresets();
 }
 
 /**
@@ -87,10 +84,11 @@ export function ratchetPresets(lang = userLanguage(), { agent = 'claude' } = {})
     // tiers would only mislead a Codex session.
     .filter((r) => !r.agents || r.agents.includes(agent))
     .map((r) => ({
-      // Hashed from the Korean text in both languages: the id has to survive a
-      // reworded translation, or a user who declined a rule would be asked again
-      // the next time its English copy changes.
-      id: `fix-${createHash('sha1').update(r.ko).digest('hex').slice(0, 6)}`,
+      // The id is carried by the preset itself: first derived from the Korean
+      // text, then kept when a published bundle rewords the rule, so a user who
+      // accepted or declined it keeps that answer. presets-source.js fills it in
+      // for an entry that has none, from the Korean text as before.
+      id: r.id,
       text: lang === 'ko' ? r.ko : r.en,
       ko: r.ko,
     }));

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

@@ -8,10 +8,11 @@
  *
  * 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
+ * not to linger. SPRAG_NO_NOTE=1 suppresses it, the same opt-out as every
  * other one-time note.
  */
 
+import { envVar } from './env.js';
 import { createRequire } from 'node:module';
 import { delegationSavedTotals } from './savings-ledger.js';
 import { noteShownAt, markNoteShown } from './first-run-note.js';
@@ -43,7 +44,7 @@ export function toolSavedUsd(now = Date.now(), dir = userDataDir()) {
 /** `{ 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;
+    if (envVar('NO_NOTE') === '1') return null;
     const shownAt = noteShownAt('star');
     if (shownAt === null) {
       const usd = savedUsd ?? toolSavedUsd(now, dir);