sprag-cli 3.72.0 → 3.73.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.72.0",
+  "version": "3.73.0",
   "description": "Model-delegation router for Claude Code and Codex: lookups, checks and test runs go to cheaper models, documents go in as compact Markdown, and a live statusline shows spend and savings.",
   "type": "module",
   "bin": {

package/presets/agents.json

@@ -9,13 +9,23 @@
     "Effort follows how the work is verified: low for lookups and command runs, medium for",
     "implementation against tests, high for the larger opus share.",
     "The files are rendered in English (description.en, body.en): they are model-facing",
-    "prompts, and the Korean copy is what the /ops console shows next to it."
+    "prompts, and the Korean copy is what the /ops console shows next to it.",
+    "tier and categories say which model-routing rules an agent serves (agentForRule in",
+    "src/agents.js): a rule names only its category and tier, and \"*\" covers every category.",
+    "They are not written into the rendered files; Claude Code does not know those keys."
   ],
   "agents": [
     {
       "name": "haiku-explore",
       "model": "haiku",
       "effort": "low",
+      "tier": "T2",
+      "categories": [
+        "explore",
+        "read",
+        "check",
+        "paste"
+      ],
       "tools": [
         "Read",
         "Grep",
@@ -35,6 +45,10 @@
       "name": "haiku-runner",
       "model": "haiku",
       "effort": "low",
+      "tier": "T2",
+      "categories": [
+        "run"
+      ],
       "tools": [
         "Bash",
         "Read",
@@ -54,6 +68,10 @@
       "name": "haiku-translate",
       "model": "haiku",
       "effort": "low",
+      "tier": "T2",
+      "categories": [
+        "translate"
+      ],
       "tools": [
         "Read",
         "Grep",
@@ -74,6 +92,10 @@
       "name": "sonnet-worker",
       "model": "sonnet",
       "effort": "medium",
+      "tier": "T1",
+      "categories": [
+        "*"
+      ],
       "tools": [
         "Read",
         "Grep",
@@ -96,6 +118,10 @@
       "name": "opus-worker",
       "model": "claude-opus-5-5",
       "effort": "high",
+      "tier": "T1H",
+      "categories": [
+        "*"
+      ],
       "tools": [
         "Read",
         "Grep",

package/presets/model-rules.json

@@ -4,7 +4,8 @@
     "counterpart to presets/ratchet-rules.md. These were promoted from the author's",
     "own route-scan candidates over months of real sessions, then stripped of the",
     "originating examples, project paths and recurrence counts: what carries over is",
-    "the shape of the work (category, tier, agent, cap), not the author's transcripts.",
+    "the shape of the work (category, tier, cap), not the author's transcripts. Which",
+    "agent serves a tier is said by presets/agents.json (tier, categories).",
     "Each entry is offered one at a time at session start; nothing is registered",
     "without the user saying yes. Caps are the defaults a scan would calibrate to;",
     "later scans refresh the stats on whatever the user accepts.",
@@ -18,7 +19,6 @@
       "category": "run",
       "label": "명령 실행 (빌드·테스트·git)",
       "labelEn": "running commands (build/test/git)",
-      "agent": "haiku-runner",
       "example": "npm test 돌려봐",
       "exampleEn": "run npm test",
       "budget": {
@@ -32,7 +32,6 @@
       "category": "run",
       "label": "명령 실행 (빌드·테스트·git)",
       "labelEn": "running commands (build/test/git)",
-      "agent": "sonnet",
       "example": "빌드하고 실패한 테스트만 보여줘",
       "exampleEn": "build it and show only the failing tests",
       "budget": {
@@ -46,7 +45,6 @@
       "category": "explore",
       "label": "탐색·조회 (파일/값 찾기)",
       "labelEn": "lookup (finding files/values)",
-      "agent": "haiku-explore",
       "example": "이 설정값 어느 파일에 있어?",
       "exampleEn": "which file holds this config value?",
       "budget": {
@@ -60,7 +58,6 @@
       "category": "explore",
       "label": "탐색·조회 (파일/값 찾기)",
       "labelEn": "lookup (finding files/values)",
-      "agent": "sonnet",
       "example": "이 함수를 호출하는 곳 전부 찾아줘",
       "exampleEn": "find every caller of this function",
       "budget": {
@@ -74,7 +71,6 @@
       "category": "check",
       "label": "상태 확인·검증",
       "labelEn": "status checks / verification",
-      "agent": "haiku-explore",
       "example": "지금 배포된 버전이 뭔지 확인해줘",
       "exampleEn": "check which version is deployed right now",
       "budget": {
@@ -88,7 +84,6 @@
       "category": "check",
       "label": "상태 확인·검증",
       "labelEn": "status checks / verification",
-      "agent": "sonnet",
       "example": "마이그레이션이 실제로 적용됐는지 확인해줘",
       "exampleEn": "verify the migration actually applied",
       "budget": {
@@ -102,7 +97,6 @@
       "category": "paste",
       "label": "붙여넣은 화면·로그 질문",
       "labelEn": "questions about pasted screens/logs",
-      "agent": "haiku-explore",
       "example": "이 에러 로그는 무슨 뜻이야?",
       "exampleEn": "what does this error log mean?",
       "budget": {
@@ -116,7 +110,6 @@
       "category": "paste",
       "label": "붙여넣은 화면·로그 질문",
       "labelEn": "questions about pasted screens/logs",
-      "agent": "sonnet",
       "example": "이 스택트레이스에서 어느 모듈이 죽은 건지 짚어줘",
       "exampleEn": "point out which module failed in this stack trace",
       "budget": {
@@ -130,7 +123,6 @@
       "category": "read",
       "label": "읽기·요약·설명",
       "labelEn": "reading / summarizing / explaining",
-      "agent": "haiku-explore",
       "example": "이 README 요약해줘",
       "exampleEn": "summarize this README",
       "budget": {
@@ -144,7 +136,6 @@
       "category": "read",
       "label": "읽기·요약·설명",
       "labelEn": "reading / summarizing / explaining",
-      "agent": "sonnet",
       "example": "이 함수가 하는 일을 단계별로 정리해줘",
       "exampleEn": "walk through what this function does, step by step",
       "budget": {

package/presets/ratchet-rules.json

@@ -39,11 +39,8 @@
     },
     {
       "id": "fix-f558f9",
-      "ko": "탐색·조회·상태 확인·명령 실행 같은 단순 요청은 `model: haiku` 서브에이전트로 위임해 상위 모델 토큰을 아낀다 (읽기 전용 preset 에이전트가 이미 있으면 그걸 쓰고, 없으면 티어만 내려서 위임)",
-      "en": "Delegate simple requests — lookup, status checks, running commands — to a `model: haiku` subagent to keep the expensive model's tokens for real work (use an existing read-only preset agent when there is one; otherwise delegate with the tier lowered)",
-      "agents": [
-        "claude"
-      ]
+      "ko": "탐색·조회·상태 확인·명령 실행 같은 단순 요청은 T2 티어에 위임해 상위 모델 토큰을 아낀다. 티어는 도구가 해석한다. Claude는 그 카테고리의 T2 에이전트 파일을, 없으면 `model: haiku`를 쓰고 Codex는 T2에 매핑된 모델을 쓴다",
+      "en": "Delegate simple requests — lookup, status checks, running commands — to the T2 tier to keep the expensive model's tokens for real work. Each tool resolves the tier: Claude uses that category's T2 agent file or `model: haiku`, Codex the model mapped to T2"
     },
     {
       "id": "fix-aa18bc",
@@ -52,11 +49,8 @@
     },
     {
       "id": "fix-777a15",
-      "ko": "여러 파일에 걸친 구현을 맡으면 → 설계와 스펙 확정은 메인 모델이 하고 코드 작성은 서브에이전트에 위임한다(Claude는 `model: sonnet`, Codex는 명시적 매핑을 우선해 해석한 T1을 쓰며 haiku나 T2에는 구현을 맡기지 않는다). 위임 프롬프트에는 설계, 수정할 파일, 제약, 완료 기준, 테스트 명령, 예산, 권장 모델과 그 이유를 적어 다른 문맥 없이 실행할 수 있게 한다. 이미 읽은 파일의 약 50줄 이하 변경이나 의존 단계가 하나뿐인 짧은 구현, 그리고 위임 도구나 하위 모델을 쓸 수 없는 경우는 메인 모델이 직접 처리한다. 위임한 구현은 끝날 때까지 기다리고 같은 구현을 중복 실행하지 않으며, 돌아온 diff와 테스트 결과를 메인 모델이 직접 검증한 뒤에 완료로 보고한다",
-      "en": "When an implementation spans several files → the main model settles the design and specification, then delegates the code writing to a subagent (Claude: `model: sonnet`; Codex: its resolved T1, explicit mapping first; never haiku or T2 for implementation). Write the delegation prompt so it runs without other context: design, files to change, constraints, completion criteria, test commands, budget, and the recommended model with a one-line reason. Keep changes of roughly 50 lines or less in files already read, a single short dependency chain, or cases where the subagent tools or the lower model are unavailable on the main model. Wait for the delegated work instead of duplicating it, and verify the returned diff and the actual test results before reporting completion",
-      "agents": [
-        "claude"
-      ]
+      "ko": "여러 파일에 걸친 구현을 맡으면 → 설계와 스펙 확정은 메인 모델이 하고 코드 작성은 T1 티어에 위임하며, T2에는 구현을 맡기지 않는다. 티어는 도구가 해석한다. Claude는 그 카테고리의 T1 에이전트 파일을, 없으면 `model: sonnet`을 쓰고 Codex는 T1에 매핑된 모델을 쓴다. 위임 프롬프트에는 설계, 수정할 파일, 제약, 완료 기준, 테스트 명령, 예산, 권장 모델과 그 이유를 적어 다른 문맥 없이 실행할 수 있게 한다. 이미 읽은 파일의 약 50줄 이하 변경이나 의존 단계가 하나뿐인 짧은 구현, 그리고 위임 도구나 하위 모델을 쓸 수 없는 경우는 메인 모델이 직접 처리한다. 위임한 구현은 끝날 때까지 기다리고 같은 구현을 중복 실행하지 않으며, 돌아온 diff와 테스트 결과를 메인 모델이 직접 검증한 뒤에 완료로 보고한다",
+      "en": "When an implementation spans several files → the main model settles the design and specification and delegates the code writing to the T1 tier, never T2. Each tool resolves the tier: Claude uses that category's T1 agent file or `model: sonnet`, Codex the model mapped to T1. Write the delegation prompt so it runs without other context: design, files to change, constraints, completion criteria, test commands, budget, and the recommended model with a one-line reason. Keep changes of roughly 50 lines or less in files already read, a single short dependency chain, or cases where the subagent tools or the lower model are unavailable on the main model. Wait for the delegated work instead of duplicating it, and verify the returned diff and the actual test results before reporting completion"
     },
     {
       "id": "fix-bec8e9",

package/src/agents.js

@@ -19,6 +19,13 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { claudeUserDir } from './paths.js';
+import { agentDefinitions } from './presets-source.js';
+
+/**
+ * Bare model alias each routing tier stands for. A rule says only its tier;
+ * where no agent serves that tier, this alias is what the text names.
+ */
+export const TIER_MODEL = { T2: 'haiku', T1: 'sonnet', T1H: 'opus' };
 
 /** Tier each preset agent is pinned to, for the `model:` half of the phrase. */
 const AGENT_MODEL = {
@@ -51,6 +58,28 @@ export function agentExists(name, root = process.cwd()) {
     existsSync(join(claudeUserDir(), 'agents', `${name}.md`));
 }
 
+/**
+ * The agent a model-routing rule delegates to, or null when no agent serves its
+ * tier. A rule carries only `category` and `tier`; the agents preset says which
+ * tier and categories each agent serves, so Claude and Codex read one key.
+ *
+ *   (a) `rule.agent` when it is a non-empty string: legacy registries and the
+ *       published v1 bundle still carry it, and it stays an explicit override,
+ *   (b) else the first agent of that tier whose categories name the category,
+ *   (c) else the first agent of that tier whose categories hold "*",
+ *   (d) else null.
+ */
+export function agentForRule(rule, { agents = agentDefinitions() } = {}) {
+  if (!rule) return null;
+  if (typeof rule.agent === 'string' && rule.agent.trim()) return rule.agent;
+  const list = (Array.isArray(agents) ? agents : []).filter((a) => a && a.tier === rule.tier);
+  const cats = (a) => (Array.isArray(a.categories) ? a.categories : []);
+  const exact = list.find((a) => cats(a).includes(rule.category));
+  if (exact) return exact.name;
+  const any = list.find((a) => cats(a).includes('*'));
+  return any ? any.name : null;
+}
+
 /** Agent a bare tier name stands for when that agent's file exists. */
 const TIER_AGENT = { sonnet: 'sonnet-worker', opus: 'opus-worker', haiku: 'haiku-explore' };
 

package/src/commands/presets.js

@@ -92,8 +92,9 @@ export async function run({ args, hasFlag }) {
     }
     console.log('');
     console.log(ko ? `모델 라우팅 프리셋 ${out.model_rules.length}건` : `Model-routing presets (${out.model_rules.length})`);
+    const { agentForRule, TIER_MODEL } = await import('../agents.js');
     for (const m of out.model_rules) {
-      console.log(`  [${m.id}] ${m.tier} · ${ko ? m.label : m.labelEn} → ${m.agent}`);
+      console.log(`  [${m.id}] ${m.tier} · ${ko ? m.label : m.labelEn} → ${agentForRule(m, { agents: out.agents }) ?? TIER_MODEL[m.tier]}`);
     }
     console.log('');
     console.log(ko ? `위임 에이전트 ${out.agents.length}개` : `Delegation agents (${out.agents.length})`);

package/src/commands/route-scan.js

@@ -11,6 +11,7 @@ const require = createRequire(import.meta.url);
 import { readStdinJson } from '../stdin-payload.js';
 import { debug } from '../debug.js';
 import { signedUsd } from '../money.js';
+import { agentForRule, TIER_MODEL } from '../agents.js';
 
 /**
  * Whether the user turned doc2md on.
@@ -418,12 +419,12 @@ export async function run({ args, hasFlag, numArg }) {
           const rule = composed(lang === 'ko' ? c.rule : (c.ruleEn || c.rule), c);
           if (lang === 'ko') {
             lines.push(`  후보 R${c.id} — "${label}" 유형, ${c.count}회 반복 (프로젝트: ${c.project})`);
-            lines.push(`      판정: ${tier} (${rs.tierLabel(tier)}) → ${c.agent} 서브에이전트 위임 권장 · 적용 범위 제안: ${rs.scopeLabel(c.suggestedScope)}`);
+            lines.push(`      판정: ${tier} (${rs.tierLabel(tier)}) → ${agentForRule(c) ?? TIER_MODEL[tier]} 서브에이전트 위임 권장 · 적용 범위 제안: ${rs.scopeLabel(c.suggestedScope)}`);
             lines.push(`      예시 요청: "${c.example}"`);
             lines.push(`      등록 시 ratchet-model.md에 기록될 룰: "${rule}"`);
           } else {
             lines.push(`  Candidate R${c.id} — "${label}", seen ×${c.count} (project: ${c.project})`);
-            lines.push(`      verdict: ${tier} (${rs.tierLabel(tier, 'en')}) → delegate to the ${c.agent} subagent · suggested scope: ${rs.scopeLabel(c.suggestedScope, 'en')}`);
+            lines.push(`      verdict: ${tier} (${rs.tierLabel(tier, 'en')}) → delegate to the ${agentForRule(c) ?? TIER_MODEL[tier]} subagent · suggested scope: ${rs.scopeLabel(c.suggestedScope, 'en')}`);
             lines.push(`      example request: "${c.example}"`);
             lines.push(`      rule that would be written to ratchet-model.md: "${rule}"`);
           }
@@ -510,10 +511,10 @@ export async function run({ args, hasFlag, numArg }) {
       const tier = c.tier || 'T2';
       if (lang === 'ko') {
         console.log(`  R${c.id}  "${c.label}" ×${c.count}회 [${c.project}]`);
-        console.log(`       판정: ${tier} (${rs.tierLabel(tier)}) → ${c.agent} 위임 권장 · 적용 범위 제안: ${rs.scopeLabel(c.suggestedScope)}`);
+        console.log(`       판정: ${tier} (${rs.tierLabel(tier)}) → ${agentForRule(c) ?? TIER_MODEL[tier]} 위임 권장 · 적용 범위 제안: ${rs.scopeLabel(c.suggestedScope)}`);
       } else {
         console.log(`  R${c.id}  "${c.labelEn || c.label}" ×${c.count} [${c.project}]`);
-        console.log(`       verdict: ${tier} (${rs.tierLabel(tier, 'en')}) → delegate to ${c.agent} · suggested scope: ${rs.scopeLabel(c.suggestedScope, 'en')}`);
+        console.log(`       verdict: ${tier} (${rs.tierLabel(tier, 'en')}) → delegate to ${agentForRule(c) ?? TIER_MODEL[tier]} · suggested scope: ${rs.scopeLabel(c.suggestedScope, 'en')}`);
       }
       console.log(`       ${lang === 'ko' ? '예시' : 'example'}: "${c.example}"`);
       const mrList = await import('../model-rules.js');

package/src/formatters/table.js

@@ -5,6 +5,7 @@ import { ISSUE_MESSAGES } from '../advice.js';
 import { CLI_NAME } from '../cli-name.js';
 import { formatResetIn, formatResetClock } from '../format-time.js';
 import { labelForKey } from '../window-labels.js';
+import { agentForRule, TIER_MODEL } from '../agents.js';
 
 const C = {
   reset:  '\x1b[0m',
@@ -202,7 +203,7 @@ function renderRoutingSection(routing) {
     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(`  R${c.id}  "${c.labelEn || c.label}" ×${c.count}  →  delegate to ${agentForRule(c) ?? TIER_MODEL[c.tier || 'T2']}`);
     }
     lines.push(`  Approve one:  ${b(`${CLI_NAME} harness promote R${cands[0].id} --global`)}      All candidates:  ${b(`${CLI_NAME} route-scan`)}`);
   }

package/src/model-rules.js

@@ -16,7 +16,8 @@
  *      (rule-health, per docs/TIER_CRITERIA.md).
  *
  * Registry file (source of truth): <stateDir>/model-rules.json
- *   { rules: [ { signature, tier, category, label, labelEn, agent, scope,  // 'project'|'global'
+ *   { rules: [ { signature, tier, category, label, labelEn, scope,  // 'project'|'global'
+ *                agent,                // legacy only: honoured when present, never written
  *                targetRoot,           // project root path (project scope)
  *                rule, example, count, errRate, promotedAt, lastSeen,
  *                status } ] }          // 'active' | 'review'
@@ -33,7 +34,7 @@ import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { userDataDir } from './paths.js';
 import { userLanguage } from './config.js';
-import { agentPhrase, agentPhraseEn, resolveAgentName } from './agents.js';
+import { agentPhrase, agentPhraseEn, resolveAgentName, agentForRule, TIER_MODEL } from './agents.js';
 import { writeStateFile } from './state-file.js';
 import { signedUsd } from './money.js';
 import { implementationDelegationRule } from './implementation-delegation.js';
@@ -120,7 +121,8 @@ export function composeRuleText(baseText, rule, lang = userLanguage()) {
  * wording — two copies of this template would drift the moment one is reworded,
  * and the drift only shows up in a file the model reads as instructions.
  *
- * `g` carries { tier, label, labelEn, example, exampleEn, agent }.
+ * `g` carries { tier, category, label, labelEn, example, exampleEn } and, on a
+ * legacy rule, `agent`; agentForRule turns tier and category into the agent.
  */
 /**
  * Trim an example to something a reader takes in at a glance. Scan-derived
@@ -133,30 +135,34 @@ function shortExample(text) {
   return one.length <= EXAMPLE_MAX ? one : `${one.slice(0, EXAMPLE_MAX - 1)}…`;
 }
 
+/** The agent (or bare alias) a rule's text names, before the file check. */
+const targetName = (g) => agentForRule(g) ?? TIER_MODEL[g.tier];
+
 // 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 });
+function t1Target(root, ko, g) {
+  const name = targetName(g);
+  if (resolveAgentName(name, root) === null) return null;
+  return (ko ? agentPhrase : agentPhraseEn)(name, { 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.label}" 고난도 구현 요청(예: "${shortExample(g.example)}")은 Fable·Mythos 세션에 한해 ${t1Target(root, true, g) ?? `model: ${TIER_MODEL.T1H}`}에 위임`;
     }
     return g.tier === 'T2'
-      ? `"${g.label}" 단순 요청(예: "${shortExample(g.example)}")은 ${agentPhrase(g.agent, { root })}에 위임`
-      : `"${g.label}" 중간 난도 요청(예: "${shortExample(g.example)}")은 ${t1Target(root, true) ?? 'model: sonnet'}에 위임`;
+      ? `"${g.label}" 단순 요청(예: "${shortExample(g.example)}")은 ${agentPhrase(targetName(g), { root })}에 위임`
+      : `"${g.label}" 중간 난도 요청(예: "${shortExample(g.example)}")은 ${t1Target(root, true, g) ?? `model: ${TIER_MODEL.T1}`}에 위임`;
   }
   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 `Heavy "${g.labelEn}" implementation requests (e.g. "${shortExample(example)}") go to ${t1Target(root, false, g) ?? `a model: ${TIER_MODEL.T1H} 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'}`;
+    ? `Simple "${g.labelEn}" requests (e.g. "${shortExample(example)}") go to ${agentPhraseEn(targetName(g), { root })}`
+    : `Moderate "${g.labelEn}" requests (e.g. "${shortExample(example)}") go to ${t1Target(root, false, g) ?? `a model: ${TIER_MODEL.T1} subagent`}`;
 }
 
 // See the note in route-scan.js — paths.js is the only place that resolves
@@ -403,7 +409,6 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
   };
   // Merged rules carry one cap per tier, so they state them once rather than
   // repeating the whole stop-condition per tier.
-  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(' / ');
 
@@ -440,9 +445,8 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
       // user's own prompt, so exampleEn is a preference, not a requirement.
       const ex = (r) => shortExample(ko ? r.example : (r.exampleEn || r.example));
       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}`;
+        if (r.tier === 'T2') return (ko ? agentPhrase : agentPhraseEn)(targetName(r), { root });
+        return t1Target(root, ko, r) ?? `model: ${TIER_MODEL[r.tier]}`;
       };
       // One line per category, stating only what differs between the tiers.
       // The exceptions this used to spell out (design judgement, irreversible

package/src/preset-sign.js

@@ -37,7 +37,10 @@ import { createHash, createPublicKey, verify as cryptoVerify } from 'node:crypto
  * adding the new entry, releasing, then publishing with the new key; remove the
  * old entry one release later.
  */
-export const PRESET_SIGNING_KEYS = [];
+export const PRESET_SIGNING_KEYS = [
+  // Created 2026-10-20 for sprag.io/ops; the private half lives in the superuser's browser and its backup file.
+  { kid: '8bc624f874f5620a', jwk: { kty: 'EC', crv: 'P-256', x: 'Lx3x--sWgDZ2_7jWxO3_ks86MtihDNRRbckITpR5bLc', y: 'L2D7puHKmZhQRh7mWjGYsmIX_UrPBYjKt3nH8B51Bhg' } },
+];
 
 export const PRESET_BUNDLE_FORMAT = 1;
 export const PRESET_MAX_BYTES = 200 * 1024;

package/src/presets-source.js

@@ -90,7 +90,10 @@ export function bundleShapeError(b) {
   }
   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 (!str(m.label) || !str(m.labelEn)) return 'shape';
+    // `agent` is optional: a rule names its tier, and the agents say which tier
+    // and categories they serve. A legacy rule that still names one is checked.
+    if (m.agent != null && (!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) {
@@ -98,6 +101,10 @@ export function bundleShapeError(b) {
     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';
+    // tier and categories are optional (a legacy bundle lacks them), checked when present.
+    if (a.tier != null && !TIERS.includes(a.tier)) return 'shape';
+    if (a.categories != null && (!Array.isArray(a.categories) || a.categories.length === 0 ||
+      a.categories.some((c) => c !== '*' && (typeof c !== 'string' || !ID_RE.test(c))))) return 'shape';
   }
   if (!uniq(rr, 'id') || !uniq(mr, 'id') || !uniq(ag, 'name')) return 'shape';
   return null;
@@ -188,12 +195,21 @@ export function modelPresets(opts = {}) {
   return Array.isArray(data?.presets) ? data.presets : [];
 }
 
-/** Delegation agents: [{ name, model, effort, tools[], description{ko,en}, body{ko,en} }] */
+// A legacy bundle has no tier or categories on its agents. Readers get one
+// shape either way: categories always an array, tier a string or null.
+function normaliseAgents(list) {
+  return (Array.isArray(list) ? list : []).filter(Boolean).map((a) => ({
+    ...a,
+    tier: typeof a.tier === 'string' && a.tier ? a.tier : null,
+    categories: Array.isArray(a.categories) ? a.categories.filter((c) => typeof c === 'string') : [],
+  }));
+}
+
+/** Delegation agents: [{ name, model, effort, tier, categories[], 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 : [];
+  if (r.bundle) return normaliseAgents(r.bundle.agents);
+  return normaliseAgents(readBundled('agents.json')?.agents);
 }
 
 /** The bundle the bundled files make: the shape the server seeds as version 1. */

package/src/route-inject.js

@@ -34,7 +34,7 @@
 import { categorizeScored, ESCALATE_RE, EDIT_RE, worthDelegating } from './route-scan.js';
 import { loadModelRules, budgetCapPhrase, ruleBudget } from './model-rules.js';
 import { sharedProjectRoots, realProjectRoot, scopeRank } from './shared-model-rules.js';
-import { agentPhrase, agentPhraseEn, resolveAgentName } from './agents.js';
+import { agentPhrase, agentPhraseEn, resolveAgentName, agentForRule, TIER_MODEL } from './agents.js';
 import { userLanguage } from './config.js';
 import { aliasForRole, resolveModelAlias } from './model-alias.js';
 import { isRecognizedModelId, modelRank } from './cost.js';
@@ -263,12 +263,17 @@ 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.
+  // A rule names its tier; agentForRule picks the agent that serves it.
   const t1Root = root === undefined ? undefined : root;
-  const tierPhrase = (name) => (resolveAgentName(name, t1Root) !== null ? phrase(name) : `model: ${name}`);
+  const nameOf = (r) => agentForRule(r) ?? TIER_MODEL[r.tier];
+  const tierPhrase = (r) => {
+    const name = nameOf(r);
+    return resolveAgentName(name, t1Root) !== null ? phrase(name) : `model: ${TIER_MODEL[r.tier]}`;
+  };
   const picked = [t2, t1, t1h].filter(Boolean);
   let target;
   if (picked.length >= 2) {
-    const named = (r) => (r.tier === 'T2' ? phrase(r.agent) : tierPhrase(r.tier === 'T1H' ? 'opus' : 'sonnet'));
+    const named = (r) => (r.tier === 'T2' ? phrase(nameOf(r)) : tierPhrase(r));
     const when = (r, i) => {
       if (i === 0) return null;
       if (r.tier === 'T1H') return ko ? '범위가 크면(Fable·Mythos 세션 한정)' : 'for large scope (Fable/Mythos sessions only)';
@@ -279,13 +284,12 @@ export function routeHint(text, { rules, lang = userLanguage(), root, sessionRan
       : picked.map((r, i) => (i === 0 ? `${named(r)} by default` : `${named(r)} ${when(r, i)}`)).join(', ');
   } else {
     const only = picked[0];
-    target = only.tier === 'T1H' ? tierPhrase('opus') : phrase(only.agent);
+    target = only.tier === 'T1H' ? tierPhrase(only) : phrase(nameOf(only));
   }
 
-  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 ? '상한 ' : 'cap ') + picked.map((r, i) => `${TIER_MODEL[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,7 +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';
+import { agentForRule } from './agents.js';
 
 // ── Tier bands (docs/TIER_CRITERIA.md §3) ────────────────────────────────
 // T2 (haiku): finished in few calls, tiny output, near-zero mutation, no
@@ -115,7 +115,7 @@ export const RESCAN_MAX_AGE_MS = 24 * 60 * 60 * 1000;      // any new data + a d
 // 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
+// Categories a request is filed under. Classification is behavior-first with
 // weighted keyword scoring as fallback — see categorize().
 const PASTE_MIN_LEN = 400;
 const CATEGORIES = [
@@ -123,21 +123,18 @@ const CATEGORIES = [
     id: 'paste',
     label: '붙여넣은 화면·로그 질문',
     labelEn: 'questions about pasted screens/logs',
-    agent: 'haiku-explore',
     kw: null, // matched by length, see categorize()
   },
   {
     id: 'translate',
     label: '배치 번역·정형 텍스트 변환',
     labelEn: 'batch translation / mechanical text transforms',
-    agent: 'haiku-translate',
     kw: [[/번역|translate/i, 2], [/변환해|표로 정리|포맷팅/i, 1]],
   },
   {
     id: 'explore',
     label: '탐색·조회 (파일/값 찾기)',
     labelEn: 'lookup (finding files/values)',
-    agent: 'haiku-explore',
     kw: [[/\bgrep\b|검색|\bsearch|\bfind\b/i, 2], [/찾아|어디|위치|목록|살펴/i, 1],
       [/정의(?:돼|되어)\s*있|어느\s*파일|어떤\s*파일에|\bwhich\s+file\b|\bwhere\s+(?:is|are)\b[^?\n]*\bdefined\b/i, 1]],
   },
@@ -145,34 +142,28 @@ const CATEGORIES = [
     id: 'read',
     label: '읽기·요약·설명',
     labelEn: 'reading / summarizing / explaining',
-    agent: 'haiku-explore',
     kw: [[/요약|summar|explain/i, 2], [/읽어|설명|정리해|보여줘|알려줘|뭐야|\bwhat\b/i, 1]],
   },
   {
     id: 'check',
     label: '상태 확인·검증',
     labelEn: 'status checks / verification',
-    agent: 'haiku-explore',
     kw: [[/확인|검증|\bverif|점검/i, 2], [/맞아\?|되나|됐나|됐어|되는지|괜찮|체크|\bcheck\b|\bstatus\b/i, 1]],
   },
   {
     id: 'run',
     label: '명령 실행 (빌드·테스트·git)',
     labelEn: 'running commands (build/test/git)',
-    agent: 'haiku-runner',
     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.
+// The T2 agent a category's candidates name comes from the agents preset (the
+// agent whose tier and categories cover it, see agentForRule), so renaming or
+// re-scoping an agent in the /ops console carries over to new candidates.
 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;
+    return agentForRule({ tier: 'T2', category: cat.id }) ?? 'haiku';
+  } catch { return 'haiku'; }
 }
 
 // English keywords are matched as whole words. As bare substrings, `pip`
@@ -815,7 +806,6 @@ export async function runRouteScan({ days = 14 } = {}) {
       category: g.category,
       label: g.label,
       labelEn: g.labelEn,
-      agent: g.agent,
       project: g.project,
       // Real session cwd for the project (munged `project` is lossy) — lets
       // `harness promote R<N> --project` write the rule into the project the

package/src/seed-rules.js

@@ -31,6 +31,7 @@ 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 { agentForRule, TIER_MODEL } from './agents.js';
 import { userLanguage } from './config.js';
 import { writeStateFile } from './state-file.js';
 import {
@@ -130,7 +131,7 @@ export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot(),
       id: p.id,
       tier: p.tier,
       label: lang === 'ko' ? p.label : p.labelEn,
-      agent: agent === 'codex' ? `Codex ${p.tier} mapping` : p.agent,
+      agent: agent === 'codex' ? `Codex ${p.tier} mapping` : (agentForRule(p) ?? TIER_MODEL[p.tier]),
       ruleText: agent === 'codex' ? codexSeedText(p, lang)
         : composeRuleText(modelRuleBaseText(p, lang), { budget: p.budget }, lang),
       preset: p,
@@ -212,7 +213,9 @@ export async function acceptSeed(id, { scope, root = findProjectRoot(), lang = u
     category: p.category,
     label: p.label,
     labelEn: p.labelEn,
-    agent: p.agent,
+    // A preset names its tier; only a legacy (v1) bundle preset still names an
+    // agent, and that override is kept rather than lost on accept.
+    ...(typeof p.agent === 'string' && p.agent ? { agent: p.agent } : {}),
     scope,
     targetRoot: scope === 'project' ? root : null,
     project,
@@ -276,6 +279,26 @@ export async function resetSeeds({ agent = 'claude' } = {}) {
  * asked for, and because a single "register all of these?" question invites a
  * yes to rules the user never read.
  */
+/**
+ * The first sentence of a rule, for the Codex seed offer. Codex keeps about
+ * 2,000 tokens of a hook's context and drops a part that does not fit whole,
+ * so listing every ratchet rule in full pushed the whole offer out. The offer
+ * only has to say what each rule is about; accepting writes the full text.
+ * A sentence ends at "다." or a full stop followed by whitespace (not an
+ * ellipsis), or at "다" before a newline. Without one, a text over 140
+ * characters is cut at the last space before 140 and marked with "…".
+ */
+export const OFFER_CUT = 140;
+export function firstSentence(text) {
+  const t = String(text ?? '').trim();
+  const m = /(?<!\.)\.(?=\s)|다(?=\n)/.exec(t);
+  if (m && m.index + 1 < t.length) return t.slice(0, m.index + m[0].length).trim();
+  if (t.length <= OFFER_CUT) return t;
+  const head = t.slice(0, OFFER_CUT);
+  const sp = head.lastIndexOf(' ');
+  return `${(sp > 0 ? head.slice(0, sp) : head).trimEnd()}…`;
+}
+
 export function seedOfferBlock({ lang = userLanguage(), root = findProjectRoot(), agent = 'claude' } = {}) {
   const pending = pendingSeeds({ lang, root, agent });
   if (pending.length === 0) return null;
@@ -291,7 +314,7 @@ export function seedOfferBlock({ lang = userLanguage(), root = findProjectRoot()
       `  4. Register none: ${cmd('skip all')} (never offered again)`,
       'Always confirm the scope with the user before running an accept command.',
       'Delegation policies are shared across Claude and Codex; approval retains the chosen scope. Codex execution also requires delegate on; tier models resolve from cheaper priced models already run in Codex, or from mappings: sprag delegate shared status --agent codex. Never assume Claude model names are Codex models.',
-      ...pending.map((s) => `  [${s.id}] ${s.ruleText}`),
+      ...pending.map((s) => `  [${s.id}] ${s.kind === 'ratchet' ? firstSentence(s.ruleText) : s.ruleText}`),
     ].join('\n');
   }
   const models = pending.filter((s) => s.kind === 'model');