sprag-cli 3.72.0 → 3.74.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.72.0",
+  "version": "3.74.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

@@ -5,17 +5,27 @@
     "and a remote bundle render through one path. A remote bundle replaces this list",
     "when its signature verifies; otherwise this file is used.",
     "Models are aliases on purpose (a gateway resolves them through ANTHROPIC_DEFAULT_*_MODEL),",
-    "except opus-worker, which names the full id: a bare alias resolves to an older model.",
+    "except t1h-worker, which names the full id: a bare alias resolves to an older model.",
     "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",
+      "name": "t2-explore",
       "model": "haiku",
       "effort": "low",
+      "tier": "T2",
+      "categories": [
+        "explore",
+        "read",
+        "check",
+        "paste"
+      ],
       "tools": [
         "Read",
         "Grep",
@@ -27,14 +37,18 @@
         "en": "Cheap read-only exploration, lookup, status checks and summaries for delegated tasks. It has no MCP tools."
       },
       "body": {
-        "ko": "맡은 역할: 읽기 전용 탐색, 조회, 상태 확인, 붙여넣은 로그나 텍스트를 두고 묻는 질문에 답합니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.",
-        "en": "Your role: read-only exploration, lookups, status checks, and questions about pasted logs or text.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it."
+        "ko": "맡은 역할: 읽기 전용 탐색, 조회, 상태 확인, 붙여넣은 로그나 텍스트를 두고 묻는 질문에 답합니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs tools: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.",
+        "en": "Your role: read-only exploration, lookups, status checks, and questions about pasted logs or text.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs tools: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it."
       }
     },
     {
-      "name": "haiku-runner",
+      "name": "t2-runner",
       "model": "haiku",
       "effort": "low",
+      "tier": "T2",
+      "categories": [
+        "run"
+      ],
       "tools": [
         "Bash",
         "Read",
@@ -46,14 +60,18 @@
         "en": "Cheap runner for build, test and git commands in delegated tasks. It has no MCP tools."
       },
       "body": {
-        "ko": "맡은 역할: 전달받은 빌드·테스트·git 명령을 실행하고 결과를 보고합니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
-        "en": "Your role: run the build, test, or git commands you are given and report the result.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
+        "ko": "맡은 역할: 전달받은 빌드·테스트·git 명령을 실행하고 결과를 보고합니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs tools: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
+        "en": "Your role: run the build, test, or git commands you are given and report the result.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs tools: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
       }
     },
     {
-      "name": "haiku-translate",
+      "name": "t2-translate",
       "model": "haiku",
       "effort": "low",
+      "tier": "T2",
+      "categories": [
+        "translate"
+      ],
       "tools": [
         "Read",
         "Grep",
@@ -66,14 +84,18 @@
         "en": "Cheap batch translation and structured text conversion for delegated tasks. It has no MCP tools."
       },
       "body": {
-        "ko": "맡은 역할: 전달받은 파일이나 텍스트의 일괄 번역과 정형 텍스트 변환입니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.",
-        "en": "Your role: batch translation and mechanical text conversion of the files or text you are given.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it."
+        "ko": "맡은 역할: 전달받은 파일이나 텍스트의 일괄 번역과 정형 텍스트 변환입니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs tools: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.",
+        "en": "Your role: batch translation and mechanical text conversion of the files or text you are given.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs tools: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it."
       }
     },
     {
-      "name": "sonnet-worker",
+      "name": "t1-worker",
       "model": "sonnet",
       "effort": "medium",
+      "tier": "T1",
+      "categories": [
+        "*"
+      ],
       "tools": [
         "Read",
         "Grep",
@@ -88,14 +110,18 @@
         "en": "Mid-tier worker for multi-step tasks and implementation handed over with a fixed design. It has no MCP tools."
       },
       "body": {
-        "ko": "맡은 역할: 여러 단계로 이어지는 작업과, 호출자가 설계를 확정한 구현을 맡습니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
-        "en": "Your role: multi-step work and the implementation half of a design the caller already fixed.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
+        "ko": "맡은 역할: 여러 단계로 이어지는 작업과, 호출자가 설계를 확정한 구현을 맡습니다.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs tools: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
+        "en": "Your role: multi-step work and the implementation half of a design the caller already fixed.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs tools: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
       }
     },
     {
-      "name": "opus-worker",
+      "name": "t1h-worker",
       "model": "claude-opus-5-5",
       "effort": "high",
+      "tier": "T1H",
+      "categories": [
+        "*"
+      ],
       "tools": [
         "Read",
         "Grep",
@@ -110,8 +136,8 @@
         "en": "Heavy worker for Fable sessions: large implementation, debugging and refactoring handed over with a fixed design. It has no MCP tools."
       },
       "body": {
-        "ko": "맡은 역할: 호출자가 설계를 확정한 대규모 구현과 디버깅입니다. 설계 판단과 되돌릴 수 없는 작업은 호출자에게 넘기십시오.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs general-purpose: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
-        "en": "Your role: large implementation and debugging work whose design the caller already fixed. Hand design judgement and irreversible actions back to the caller.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs general-purpose: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
+        "ko": "맡은 역할: 호출자가 설계를 확정한 대규모 구현과 디버깅입니다. 설계 판단과 되돌릴 수 없는 작업은 호출자에게 넘기십시오.\n위임받은 작업만 하고, 호출자가 프롬프트에 적은 상한(도구 호출 횟수, 출력 토큰)을 넘기지 마십시오.\n호출자 프롬프트의 언어로 간결하게 보고하십시오.\nMCP 도구나 목록에 없는 도구가 필요하면 즉시 멈추고 \"needs tools: <필요한 도구>\" 한 줄로 보고하십시오. 부모가 다시 위임합니다.\n확인하지 못한 내용은 추측하지 말고 확인하지 못했다고 말하십시오.\n전체 테스트, 빌드, 렌더처럼 프로세스를 여럿 띄우는 명령은 프로세스 상한을 걸고 실행하십시오. macOS 와 Linux 에서는 `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <명령>)` 으로 감싸고, Windows 에서는 그대로 실행합니다. 출력에 `spawn ... EAGAIN` 이나 `Resource temporarily unavailable` 이 보이면 테스트 실패가 아니라 프로세스 폭주이므로, 명령을 다시 돌리지 말고 그 줄을 인용해 보고하십시오.",
+        "en": "Your role: large implementation and debugging work whose design the caller already fixed. Hand design judgement and irreversible actions back to the caller.\nDo only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.\nReport concisely, in the language of the caller's prompt.\nIf you need an MCP tool or any tool not on your list, stop at once and report one line: \"needs tools: <tools needed>\". The parent will delegate again.\nDo not guess at anything you could not verify; say that you could not verify it.\nRun a command that starts many processes (a full test suite, a build, a render) under a process cap: on macOS and Linux wrap it as `(ulimit -u $(( $(ps -u $(id -u) -o pid= | wc -l) + 150 )); <command>)`, on Windows run it as is. If the output shows `spawn ... EAGAIN` or `Resource temporarily unavailable`, that is a process runaway, not a test failure: do not rerun the command; quote that line and report."
       }
     }
   ]

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

@@ -29,8 +29,8 @@
     },
     {
       "id": "fix-b1da7a",
-      "ko": "자동화 설계에서 vision/screenshot 루프가 보이면 → 호출 가능한 함수·API·MCP tool부터 찾는다. 통제 가능한 내부 도구는 무조건 API, 통제 불가 외부 SaaS만 vision 차선책. 인터페이스를 바꾼 뒤에 모델을 내린다 — 거꾸로 가면 토큰 폭발",
-      "en": "When an automation design calls for a vision/screenshot loop → look for a callable function, API or MCP tool first. Anything you control gets an API; vision is the fallback only for external SaaS you cannot change. Fix the interface before lowering the model — doing it the other way round explodes the token cost"
+      "ko": "자동화 설계에서 vision/screenshot 루프가 보이면 → 호출 가능한 함수·API·MCP tool부터 찾는다. 통제 가능한 내부 도구는 무조건 API, 통제 불가 외부 SaaS만 vision 차선책. 인터페이스를 바꾼 뒤에 티어를 내린다(T1 → T2) — 거꾸로 가면 토큰 폭발",
+      "en": "When an automation design calls for a vision/screenshot loop → look for a callable function, API or MCP tool first. Anything you control gets an API; vision is the fallback only for external SaaS you cannot change. Change the interface first, then lower the tier (T1 → T2) — doing it the other way round explodes the token cost"
     },
     {
       "id": "fix-1dee5f",
@@ -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 에이전트(t2-explore, t2-runner)에 위임해 상위 모델 토큰을 아낀다. 티어를 실제 모델로 바꾸는 일은 도구가 맡는다",
+      "en": "Delegate simple requests (lookup, status checks, running commands) to a T2 agent (t2-explore, t2-runner) to keep the expensive model's tokens for real work. The tool turns the tier into a model"
     },
     {
       "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 에이전트(t1-worker)에 위임하며, T2에는 구현을 맡기지 않는다. 위임 프롬프트에는 설계, 수정할 파일, 제약, 완료 기준, 테스트 명령, 예산, 권장 티어와 그 이유를 적어 다른 문맥 없이 실행할 수 있게 한다. 이미 읽은 파일의 약 50줄 이하 변경이나 의존 단계가 하나뿐인 짧은 구현, 그리고 위임 도구나 하위 티어를 쓸 수 없는 경우는 메인 모델이 직접 처리한다. 위임한 구현은 끝날 때까지 기다리고 같은 구현을 중복 실행하지 않으며, 돌아온 diff와 테스트 결과를 메인 모델이 직접 검증한 뒤에 완료로 보고한다",
+      "en": "When an implementation spans several files → the main model settles the design and specification and delegates the code writing to a T1 agent (t1-worker), never T2. Write the delegation prompt so it runs without other context: design, files to change, constraints, completion criteria, test commands, budget, and the recommended tier 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 tier 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

@@ -1,7 +1,7 @@
 /**
  * How a delegation target is phrased in generated rules.
  *
- * Rules used to name concrete subagents (`haiku-explore`, `haiku-runner`, …).
+ * Rules used to name concrete subagents (`t2-explore`, `t2-runner`, …).
  * Those live in the user's own `~/.claude/agents/` and are NOT shipped by this
  * package, so on any machine that never created them the generated rule told
  * the model to delegate to an agent that does not exist. The model tier is the
@@ -10,7 +10,7 @@
  * there, which keeps the tool-restricted preset in play for users who have it.
  *
  * A rule that names a tier alone (`sonnet`, `haiku`) resolves to that tier's
- * delegation-only agent (`sonnet-worker`, `haiku-explore`, installed by
+ * delegation-only agent (`t1-worker`, `t2-explore`, installed by
  * delegation-agents.js) when its file exists. A phrase that names an agent
  * always carries a general-purpose fallback, because Cowork reads no agents
  * directory and a copied rule would otherwise name an agent that is not there.
@@ -19,14 +19,35 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { claudeUserDir } from './paths.js';
+import { agentDefinitions } from './presets-source.js';
+
+/**
+ * Agents used to be named after their model. They are named by tier now, since
+ * the model behind a tier changes and a stale model name inside an agent name
+ * misleads. A registry, a hand-written rule or a user's own file may still carry
+ * the old name, so it keeps resolving to the new one.
+ */
+export const LEGACY_AGENT_NAMES = {
+  'haiku-explore': 't2-explore',
+  'haiku-runner': 't2-runner',
+  'haiku-translate': 't2-translate',
+  'sonnet-worker': 't1-worker',
+  'opus-worker': 't1h-worker',
+};
+
+/**
+ * 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 = {
-  'haiku-explore': 'haiku',
-  'haiku-runner': 'haiku',
-  'haiku-translate': 'haiku',
-  'sonnet-worker': 'sonnet',
-  'opus-worker': 'opus',
+  't2-explore': 'haiku',
+  't2-runner': 'haiku',
+  't2-translate': 'haiku',
+  't1-worker': 'sonnet',
+  't1h-worker': 'opus',
   // A T1 rule names its target by tier alone (`agent: 'sonnet'`). Without these
   // the phrase fell through to the haiku default, and a sonnet rule told the
   // session to delegate to haiku. resolveAgentName maps them to an agent file.
@@ -41,7 +62,7 @@ const AGENT_MODEL = {
  * `root: null` asks about the user directory alone. Text that every project
  * reads (the global ratchet-model.md) has to be worded from what every project
  * can see: checked against the current directory, the same rule read
- * `haiku-explore(model: haiku)` when the scan ran in a project that defines
+ * `t2-explore(model: haiku)` when the scan ran in a project that defines
  * the agent and `model: haiku` when it ran anywhere else, and each flip
  * rewrote a file sitting in the prompt-cache prefix of every session.
  */
@@ -51,47 +72,79 @@ 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 Object.hasOwn(LEGACY_AGENT_NAMES, rule.agent) ? LEGACY_AGENT_NAMES[rule.agent] : 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;
+}
+
+/** Model alias an agent (or a legacy agent name) is pinned to, or undefined. */
+const modelOf = (name) => AGENT_MODEL[Object.hasOwn(LEGACY_AGENT_NAMES, name) ? LEGACY_AGENT_NAMES[name] : name];
+
 /** 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' };
+const TIER_AGENT = { sonnet: 't1-worker', opus: 't1h-worker', haiku: 't2-explore' };
 
 /**
  * The agent a rule target really names on this machine, or null when none is
  * installed. A name wins when its own file exists; a bare tier name falls back
- * to its delegation-only agent.
+ * to its delegation-only agent. A legacy name maps to its tier-named successor
+ * first; when only the legacy file is installed (a user-edited file sprag does
+ * not own, so it was never removed) the legacy name is returned, because that is
+ * the file the phrase has to point at.
  */
 export function resolveAgentName(name, root = process.cwd()) {
-  if (agentExists(name, root)) return name;
-  const alt = TIER_AGENT[name];
+  const current = Object.hasOwn(LEGACY_AGENT_NAMES, name) ? LEGACY_AGENT_NAMES[name] : name;
+  if (agentExists(current, root)) return current;
+  if (current !== name && agentExists(name, root)) return name;
+  const alt = TIER_AGENT[current];
   return alt && agentExists(alt, root) ? alt : null;
 }
 
 /**
  * Korean phrase for a delegation target, e.g.
- *   agent present → `haiku-explore(model 인자 생략. …general-purpose에 model: haiku)`
+ *   agent present → `t2-explore(model 인자 생략. …general-purpose에 model: haiku)`
  *   agent absent  → `model: haiku`
  *
  * A named agent carries its model in its own definition, and the Agent tool's
  * `model` argument overrides that definition. The old phrase
- * `haiku-explore(model: haiku)` read as "pass model: haiku", and Claude Code
+ * `t2-explore(model: haiku)` read as "pass model: haiku", and Claude Code
  * resolves the bare `haiku` alias to an older Haiku than a definition pinned to
  * a full id (claude-haiku-5-5), so following the rule undid the pin. The phrase
  * now says to leave the argument out.
  */
 export function agentPhrase(name, { model, root } = {}) {
   const resolved = resolveAgentName(name, root);
-  if (!resolved) return `model: ${model || AGENT_MODEL[name] || 'haiku'}`;
-  const tier = AGENT_MODEL[resolved] || model || 'haiku';
+  if (!resolved) return `model: ${model || modelOf(name) || 'haiku'}`;
+  const tier = modelOf(resolved) || model || 'haiku';
   return `${resolved}(model 인자 생략. 이 에이전트가 없거나 MCP 도구가 필요하면 general-purpose에 model: ${tier})`;
 }
 
 /**
  * English phrase, including the article, e.g.
- *   agent present → `the haiku-explore subagent (omit the model argument; …)`
+ *   agent present → `the t2-explore subagent (omit the model argument; …)`
  *   agent absent  → `a model: haiku subagent`
  */
 export function agentPhraseEn(name, { model, root } = {}) {
   const resolved = resolveAgentName(name, root);
-  if (!resolved) return `a model: ${model || AGENT_MODEL[name] || 'haiku'} subagent`;
-  const tier = AGENT_MODEL[resolved] || model || 'haiku';
+  if (!resolved) return `a model: ${model || modelOf(name) || 'haiku'} subagent`;
+  const tier = modelOf(resolved) || model || 'haiku';
   return `the ${resolved} subagent (omit the model argument; if it is unavailable or MCP tools are needed, use general-purpose with model: ${tier})`;
 }

package/src/codex/delegation.js

@@ -13,6 +13,9 @@ import { loadConfig } from '../config.js';
 import { loadSharedModelRules, sharedModelRulesForProject, sharedRuleBounds, SHARED_RULE_TIERS } from '../shared-model-rules.js';
 import { codexPriceBook, readCodexPrices } from './cache-policy.js';
 import { codexRunCost } from '../gateway-prices.js';
+import { agentForRule } from '../agents.js';
+import { agentDefinitions } from '../presets-source.js';
+import { firstSentence } from '../first-sentence.js';
 
 export const CODEX_ROUTE_CATEGORIES = ['paste', 'translate', 'explore', 'read', 'check', 'run'];
 const MARKER = '<!-- sprag:codex:delegation -->';
@@ -124,13 +127,30 @@ export function codexTierTargets({ cfg = loadConfig(), dir = userDataDir(), home
   return [...explicit, ...auto];
 }
 
+/**
+ * The delegation role a rule runs as: the agent agentForRule() picks for its
+ * tier and category, the same one Claude delegates to, and the first sentence
+ * of that agent's English body. Codex runs the role on the model mapped to the
+ * tier, so both tools show one value for one rule. Null when no agent serves it.
+ */
+export function codexRoleFor(rule, { agents = agentDefinitions() } = {}) {
+  const role = agentForRule(rule, { agents });
+  if (!role) return { role: null, roleLine: null };
+  const def = agents.find((a) => a && a.name === role);
+  // The body opens with "Your role: …"; the hint already says "Role <name>:", so the prefix is dropped.
+  return { role, roleLine: def?.body?.en ? firstSentence(def.body.en.replace(/^\s*Your role:\s*/i, '')) : null };
+}
+
 export function sharedCodexModelRules({ cfg = loadConfig(), dir = userDataDir(), home = codexUserDir(), root, start = root,
   model, provider = codexProviderName() } = {}) {
   if (cfg.codex?.sharedRules?.enabled === false) return [];
   const targets = codexTierTargets({ cfg, dir, home, model, provider });
+  let agents = null;
   return sharedModelRulesForProject(loadSharedModelRules({ dir }), start).flatMap((rule) => {
     const target = targets.find((t) => t.tier === rule.tier);
-    return target ? [{ ...rule, ...target, source: 'shared', status: 'active' }] : [];
+    if (!target) return [];
+    agents ??= agentDefinitions();
+    return [{ ...rule, ...target, ...codexRoleFor(rule, { agents }), source: 'shared', status: 'active' }];
   });
 }
 
@@ -254,18 +274,21 @@ export function codexImplementationHint({ model, provider, sessionId, cfg = load
   if (!codexDelegateEnabled(cfg) || cfg.codex?.sharedRules?.enabled === false) return 'Implementation delegation is off. Keep the implementation on the main agent.';
   const target = codexTierTargets({ cfg, dir, home, model, provider }).find((t) => t.tier === 'T1');
   if (!target) return 'T1 is unresolved for this parent/provider. Keep the implementation on the main agent; do not fall back to T2.';
+  const { role, roleLine } = codexRoleFor({ tier: 'T1', category: 'implement' });
+  const asRole = role ? ` Run it as role ${role}${roleLine ? `: ${roleLine}` : '.'}` : '';
   const id = newRouteId();
   record({ id, parentSessionId: sessionId, via: 'prompt', source: 'implementation', tier: 'T1',
     from: model, to: target.model, provider, effort: target.effort ?? null }, { dir });
   return `[Sprag implementation delegation] The user-approved implementation-split policy keeps design and specification on the main agent. `
-    + `Delegate only the implementation of that completed design to model ${target.model}${target.effort ? `, reasoning_effort ${target.effort}` : ''}, with fork_turns "none". `
+    + `Delegate only the implementation of that completed design to model ${target.model}${target.effort ? `, reasoning_effort ${target.effort}` : ''}, with fork_turns "none".${asRole} `
     + 'Never delegate design judgement or irreversible actions. Give one child a self-contained specification, owned files, constraints, test commands, completion criteria and the reason for this model choice. '
     + 'Cap: 8000 output tokens. Stop and report partial work before exceeding it. Do not recursively delegate. '
     + WAIT_TEXT + `\nEnd the child task message with this route line only:\n<!-- sprag:codex:route id=${id} -->`;
 }
 
 function sharedTargetText(rule) {
-  return `${rule.tier}: model ${rule.model}${rule.effort ? `, reasoning_effort ${rule.effort}` : ''}. ${sharedRuleBounds(rule)}`.trim();
+  const role = rule.role ? ` Role ${rule.role}:${rule.roleLine ? ` ${rule.roleLine}` : ''}` : '';
+  return `${rule.tier}: model ${rule.model}${rule.effort ? `, reasoning_effort ${rule.effort}` : ''}.${role} ${sharedRuleBounds(rule)}`.trim();
 }
 
 function sharedDenyReason(routes) {

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/delegation-agents.js

@@ -27,7 +27,7 @@ const MARK_LINE = `# managed by sprag (${OWNER_MARK}); edits are overwritten`;
 //
 // Models are aliases on purpose: behind a gateway they resolve through
 // ANTHROPIC_DEFAULT_*_MODEL, and a full model id would bypass that mapping. The
-// exception is opus-worker, which names the full id: Claude Code resolves a bare
+// exception is t1h-worker, which names the full id: Claude Code resolves a bare
 // alias to an older model than the one the tier means.
 //
 // Effort is a separate axis from the tier and is set by how the work gets

package/src/first-sentence.js

@@ -0,0 +1,22 @@
+/**
+ * The first sentence of a text, shared by the Codex seed offer (seed-rules.js)
+ * and the Codex delegation hints (codex/delegation.js). It has no imports so
+ * the per-prompt Codex hook can use it without loading the seed module.
+ *
+ * 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()}…`;
+}

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,12 @@ 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 { firstSentence, OFFER_CUT } from './first-sentence.js';
+
+// Re-exported: the Codex delegation hints use the same cut through first-sentence.js,
+// which stays dependency-free so the per-prompt hook does not load this module.
+export { firstSentence, OFFER_CUT };
 import { userLanguage } from './config.js';
 import { writeStateFile } from './state-file.js';
 import {
@@ -130,7 +136,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,
@@ -147,9 +153,17 @@ export function pendingSeeds({ lang = userLanguage(), root = findProjectRoot(),
 }
 
 function codexSeedText(p, lang) {
-  const text = lang === 'ko'
-    ? `"${p.label}" 유형의 ${p.tier === 'T2' ? '단순' : '중간 난도'} 작업은 ${p.tier}에 위임합니다. 실행 모델은 Codex가 자동으로 정하거나 매핑으로 지정합니다.`
-    : `${p.tier === 'T2' ? 'Simple' : 'Moderate'} "${p.labelEn}" tasks use ${p.tier}. Codex resolves the execution model automatically or from a mapping.`;
+  // The role is the agent Claude delegates the same rule to; Codex runs that
+  // role on the model its tier mapping names, so both tools offer one value.
+  const role = agentForRule(p);
+  const level = lang === 'ko' ? (p.tier === 'T2' ? '단순' : '중간 난도') : (p.tier === 'T2' ? 'Simple' : 'Moderate');
+  const text = role
+    ? (lang === 'ko'
+      ? `"${p.label}" 유형의 ${level} 작업은 ${p.tier}에 위임합니다. 역할은 ${role}이고 실행 모델은 Codex가 티어 매핑으로 정합니다.`
+      : `${level} "${p.labelEn}" tasks use ${p.tier} as role ${role}; Codex resolves the model from the tier mapping.`)
+    : (lang === 'ko'
+      ? `"${p.label}" 유형의 ${level} 작업은 ${p.tier}에 위임합니다. 실행 모델은 Codex가 자동으로 정하거나 매핑으로 지정합니다.`
+      : `${level} "${p.labelEn}" tasks use ${p.tier}. Codex resolves the execution model automatically or from a mapping.`);
   return composeRuleText(text, p, lang);
 }
 
@@ -212,7 +226,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,
@@ -291,7 +307,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');