sprag-cli 3.73.0 → 3.75.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.73.0",
+  "version": "3.75.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,7 +5,7 @@
     "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",
@@ -16,7 +16,7 @@
   ],
   "agents": [
     {
-      "name": "haiku-explore",
+      "name": "t2-explore",
       "model": "haiku",
       "effort": "low",
       "tier": "T2",
@@ -37,12 +37,12 @@
         "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",
@@ -60,12 +60,12 @@
         "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",
@@ -84,12 +84,12 @@
         "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",
@@ -110,12 +110,12 @@
         "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",
@@ -136,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/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,8 +39,8 @@
     },
     {
       "id": "fix-f558f9",
-      "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"
+      "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",
@@ -49,8 +49,8 @@
     },
     {
       "id": "fix-777a15",
-      "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"
+      "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,17 +10,31 @@
  * 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.
  */
 
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } 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.
@@ -29,11 +43,11 @@ 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.
@@ -48,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.
  */
@@ -71,7 +85,9 @@ export function agentExists(name, root = process.cwd()) {
  */
 export function agentForRule(rule, { agents = agentDefinitions() } = {}) {
   if (!rule) return null;
-  if (typeof rule.agent === 'string' && rule.agent.trim()) return rule.agent;
+  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));
@@ -80,47 +96,103 @@ export function agentForRule(rule, { agents = agentDefinitions() } = {}) {
   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';
-  return `${resolved}(model 인자 생략. 이 에이전트가 없거나 MCP 도구가 필요하면 general-purpose에 model: ${tier})`;
+  if (!resolved) return `model: ${model || modelOf(name) || 'haiku'}`;
+  const tier = modelOf(resolved) || model || 'haiku';
+  const spec = agentSpecLabel(resolved, root);
+  return `${resolved}(${spec ? `${spec}. ` : ''}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';
-  return `the ${resolved} subagent (omit the model argument; if it is unavailable or MCP tools are needed, use general-purpose with model: ${tier})`;
+  if (!resolved) return `a model: ${model || modelOf(name) || 'haiku'} subagent`;
+  const tier = modelOf(resolved) || model || 'haiku';
+  const spec = agentSpecLabel(resolved, root, ', ');
+  return `the ${resolved} subagent (${spec ? `${spec}; ` : ''}omit the model argument; if it is unavailable or MCP tools are needed, use general-purpose with model: ${tier})`;
+}
+
+/**
+ * The model and effort an installed agent file really pins, read from its
+ * frontmatter, or null when the file has none.
+ *
+ * The agent name says only the tier (`t1-worker`), and Claude Code draws a
+ * delegated run as `t1-worker(…)` with no model beside it. The phrase carries
+ * what the file says so the session can show it. The file is read rather
+ * than the preset because a user's own copy is never overwritten, and it may
+ * pin something else. A file without `model:` inherits the session model,
+ * which Claude Code writes as `inherit`.
+ */
+export function agentSpec(name, root = process.cwd()) {
+  const paths = [];
+  if (root !== null) paths.push(join(root, '.claude', 'agents', `${name}.md`));
+  paths.push(join(claudeUserDir(), 'agents', `${name}.md`));
+  for (const p of paths) {
+    let text;
+    try { text = readFileSync(p, 'utf8'); } catch { continue; }
+    const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+    if (!m) return null;
+    const field = (key) => {
+      const hit = new RegExp(`^${key}:[ \\t]*(.*?)[ \\t]*$`, 'm').exec(m[1]);
+      return hit && hit[1] ? hit[1] : null;
+    };
+    return { model: field('model') || 'inherit', effort: field('effort') };
+  }
+  return null;
+}
+
+/**
+ * Display name for a model value: `claude-sonnet-5-5` → `Sonnet 5.5`, a dated
+ * id loses its date. An alias or a gateway id stays as written, since an alias
+ * can resolve to an older model and that is worth seeing.
+ */
+export function modelLabel(model) {
+  const m = /^claude-([a-z]+)-(\d+)-(\d+)(?:-\d{8})?$/.exec(String(model || ''));
+  return m ? `${m[1][0].toUpperCase()}${m[1].slice(1)} ${m[2]}.${m[3]}` : String(model || '');
+}
+
+/** `Sonnet 5.5 · effort medium` for an installed agent, or '' when unknown. */
+function agentSpecLabel(name, root, sep = ' · ') {
+  const spec = agentSpec(name, root);
+  if (!spec) return '';
+  return spec.effort ? `${modelLabel(spec.model)}${sep}effort ${spec.effort}` : modelLabel(spec.model);
 }

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/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/model-rules.js

@@ -263,7 +263,11 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '',
     '위임을 실행할 때는 사용자에게 다음 한 줄을 먼저 표시할 것',
     '(어떤 도구가 토큰을 아끼고 있는지 가시화):',
-    '`🔀 [sprag] 모델 피팅: "<유형>" → <agent> 위임`',
+    '`🔀 [sprag] 모델 피팅: "<유형>" → <agent> (<모델> · effort <effort>) 위임`',
+    '',
+    '<모델>과 <effort>에는 룰의 에이전트 표기 괄호 안에 적힌 값(예: Sonnet 5.5 · effort medium)을',
+    '그대로 옮기고, 값이 적혀 있지 않으면 그 부분을 뺍니다. Claude Code 호출 행에는 에이전트',
+    '이름만 보이므로, Agent 도구의 description 맨 앞에도 `[<모델> · <effort>]` 를 붙이십시오.',
     '',
     '## 공통 조항 (룰마다 반복하지 않으므로 여기서 한 번만 읽으십시오)',
     '',
@@ -326,7 +330,12 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '',
     'When delegating under a rule below, show the user this line first so it is',
     'visible which tool is saving tokens:',
-    '`🔀 [sprag] model fitting: "<category>" → delegated to <agent>`',
+    '`🔀 [sprag] model fitting: "<category>" → delegated to <agent> (<model> · effort <effort>)`',
+    '',
+    'Fill <model> and <effort> from the parentheses after the agent in the rule',
+    '(e.g. Sonnet 5.5, effort medium), and leave out whichever the rule does not',
+    'give. Claude Code shows only the agent name on the call row, so also start',
+    'the Agent tool\'s description with `[<model> · <effort>]`.',
     '',
     '## Shared clauses (stated once here, not repeated per rule)',
     '',

package/src/route-inject.js

@@ -296,9 +296,11 @@ export function routeHint(text, { rules, lang = userLanguage(), root, sessionRan
   // string whichever path decided to delegate.
   return ko
     ? `[sprag] 이 요청은 사용자가 이미 승인한 위임 룰 "${label}" 에 해당합니다: ${target} 로 위임하십시오 (${capText}). `
-      + `되묻지 말고 위임하고, 위임할 때 \`🔀 [sprag] 모델 피팅: "${label}" → <agent> 위임\` 을 먼저 표시하십시오. `
+      + `되묻지 말고 위임하고, 위임할 때 \`🔀 [sprag] 모델 피팅: "${label}" → <agent> (<모델> · effort <effort>) 위임\` 을 먼저 표시하십시오. `
+      + `모델과 effort 값은 위 에이전트 표기에 적힌 그대로 쓰고, Agent 도구의 description 맨 앞에도 \`[<모델> · <effort>]\` 를 붙이십시오. `
       + `상한을 넘길 것 같거나 에러가 나면 그 자리에서 멈추고 메인 모델이 이어받습니다.`
     : `[sprag] This request matches a delegation rule the user already approved — "${label}": delegate to ${target} (${capText}). `
-      + `Do not ask again; print \`🔀 [sprag] model fit: "${label}" → <agent>\` first. `
+      + `Do not ask again; print \`🔀 [sprag] model fit: "${label}" → <agent> (<model> · effort <effort>)\` first, `
+      + `with the model and effort the agent's phrase above gives, and start the Agent tool's description with \`[<model> · <effort>]\`. `
       + `If the run is likely to exceed its cap or hits an error, stop there and the main model takes over.`;
 }

package/src/seed-rules.js

@@ -32,6 +32,11 @@ 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 {
@@ -148,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);
 }
 
@@ -279,26 +292,6 @@ 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;