sprag-cli 3.66.0 → 3.67.0

package/bin/cli.js

@@ -90,7 +90,7 @@ function tableColor() {
 const KNOWN_SUBCOMMANDS = new Set([
   'last', 'brief', 'history', 'handoff', 'install', 'uninstall', 'mode', 'korean', 'cohesion',
   'doc2md', 'delegate', 'harness', 'route-scan', 'compact-window', 'update-check', 'upgrade',
-  'seed', 'litellm-budget', 'profile-map', 'feedback', 'saved',
+  'seed', 'litellm-budget', 'profile-map', 'feedback', 'saved', 'cowork',
 ]);
 
 const USAGE = `sprag — Claude Code and Codex agent harness
@@ -116,6 +116,7 @@ Usage:
   sprag uninstall --agent codex   remove the global Codex integration
       --agent claude|codex (default: claude; accepted before or after subcommands)
   sprag route-scan         detect recurring easy work → delegation candidates
+  sprag delegate agents [on|off]   tool-restricted delegation agents (no MCP tools)
   sprag profile-map        show/refresh the gateway model map (LiteLLM /model/info)
   sprag install            set up everything (presets, and Codex when present) without asking
   sprag install --manual   confirm each optional step
@@ -127,6 +128,7 @@ Usage:
   sprag handoff            write a session handoff file
   sprag mode [keywords]    statusline preferences (icon/text, en/ko, window, ttl)
   sprag seed               register the bundled starter rules, one answer at a time
+  sprag cowork [sync|on|off|exclude <dir>|include <dir>]   copy the ratchet rules into Cowork tab folders
   sprag korean on|off|status     Korean writing guidance + write-time check
   sprag cohesion on|off|status   English sentence-connection guidance
   sprag doc2md on|off|<file>     convert documents to Markdown before the model reads them
@@ -290,6 +292,11 @@ async function main() {
     return (await import('../src/commands/seed.js')).run({ args, hasFlag });
   }
 
+  // Subcommand: cowork — ratchet copies for the Claude app's Cowork tab.
+  if (args[0] === 'cowork') {
+    return (await import('../src/commands/cowork.js')).run({ args, hasFlag });
+  }
+
   // Subcommand: saved — stopwatch reset for the lifetime "saved" counters.
   //   sprag saved | saved reset [routing|doc2md|all] | saved undo
   if (args[0] === 'saved') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.66.0",
+  "version": "3.67.0",
   "description": "Lower your Claude Code bill without changing how you work: simple tasks go to cheaper models, documents go in as compact Markdown, and the statusline shows spend and savings live. Works with Codex too.",
   "type": "module",
   "bin": {

package/presets/ratchet-rules.json

@@ -40,6 +40,13 @@
     {
       "ko": "지침이나 룰이 지켜지지 않아 같은 품질 문제가 재발하면 문구를 다시 쓰지 말 것 → 그 조항이 기계로 판정 가능한지부터 따지고(문자열 비교나 정규식으로 결정되면 판정 가능), 가능하면 쓰기 시점 훅이나 테스트 같은 차단 지점을 추가한다. 판단이 필요한 잔여 부분만 지침에 남기고 그 경계를 지침에 적는다. 실제 코퍼스에 돌려 오탐 건수를 센 뒤 좁히고, 회귀 테스트를 같은 커밋에 넣는다",
       "en": "When a guideline keeps being violated and the same quality defect recurs, do NOT reword the instruction → first ask whether the clause is machine-decidable (a string comparison or regex settles it), and if so add an enforcement point such as a write-time hook or a test. Leave only the judgement remainder in the prose and state that boundary there. Measure the false-positive count on a real corpus, narrow until it is acceptable, and land a regression test in the same commit"
+    },
+    {
+      "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"
+      ]
     }
   ]
 }

package/src/agents.js

@@ -8,6 +8,12 @@
  * part that actually saves tokens and it is universal, so `model: haiku` is the
  * default phrasing — the agent name is only added when the file is really
  * 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-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';
@@ -20,9 +26,9 @@ const AGENT_MODEL = {
   'haiku-runner': 'haiku',
   'haiku-translate': 'haiku',
   'sonnet-worker': 'sonnet',
-  // A T1 rule names its target by tier alone (`agent: 'sonnet'`), with no
-  // preset agent behind it. Without these the phrase fell through to the
-  // haiku default, and a sonnet rule told the session to delegate to haiku.
+  // 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.
   sonnet: 'sonnet',
   haiku: 'haiku',
 };
@@ -43,9 +49,23 @@ export function agentExists(name, root = process.cwd()) {
     existsSync(join(claudeUserDir(), 'agents', `${name}.md`));
 }
 
+/** Agent a bare tier name stands for when that agent's file exists. */
+const TIER_AGENT = { sonnet: 'sonnet-worker', haiku: 'haiku-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.
+ */
+export function resolveAgentName(name, root = process.cwd()) {
+  if (agentExists(name, root)) return name;
+  const alt = TIER_AGENT[name];
+  return alt && agentExists(alt, root) ? alt : null;
+}
+
 /**
  * Korean phrase for a delegation target, e.g.
- *   agent present → `haiku-explore(model 인자 생략)`
+ *   agent present → `haiku-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
@@ -56,18 +76,20 @@ export function agentExists(name, root = process.cwd()) {
  * now says to leave the argument out.
  */
 export function agentPhrase(name, { model, root } = {}) {
-  const tier = model || AGENT_MODEL[name] || 'haiku';
-  return agentExists(name, root) ? `${name}(model 인자 생략)` : `model: ${tier}`;
+  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})`;
 }
 
 /**
  * English phrase, including the article, e.g.
- *   agent present → `the haiku-explore subagent (omit the model argument)`
+ *   agent present → `the haiku-explore subagent (omit the model argument; …)`
  *   agent absent  → `a model: haiku subagent`
  */
 export function agentPhraseEn(name, { model, root } = {}) {
-  const tier = model || AGENT_MODEL[name] || 'haiku';
-  return agentExists(name, root)
-    ? `the ${name} subagent (omit the model argument)`
-    : `a model: ${tier} subagent`;
+  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})`;
 }

package/src/commands/cowork.js

@@ -0,0 +1,107 @@
+/**
+ * Subcommand: cowork : keep the Claude app's Cowork tab on the same ratchet rules.
+ *
+ *   sprag cowork                  status
+ *   sprag cowork sync             discover connected folders and write the copies now
+ *   sprag cowork on | off         turn the sync on (and sync) or off (and remove the copies)
+ *   sprag cowork exclude <dir>    never write into <dir> (removes its copy)
+ *   sprag cowork include <dir>    undo exclude (and sync)
+ */
+
+import { resolve } from 'node:path';
+import { realpathSync } from 'node:fs';
+
+const REASONS = {
+  ko: {
+    'not-absolute': '절대 경로가 아님', missing: '폴더가 없음', 'not-a-directory': '디렉터리가 아님',
+    'home-or-ancestor': '홈 디렉터리 또는 그 상위 경로', 'inside-claude-dir': '~/.claude 안',
+    'inside-library': '~/Library 안', 'inside-sprag-data': 'sprag 데이터 폴더 안', excluded: '제외 목록에 있음',
+    'not-owned': '같은 이름의 사용자 파일이 있어 덮어쓰지 않음', 'no-source': '복사할 원본 래칫 파일이 없음',
+  },
+  en: {
+    'not-absolute': 'not an absolute path', missing: 'folder does not exist', 'not-a-directory': 'not a directory',
+    'home-or-ancestor': 'the home directory or one of its parents', 'inside-claude-dir': 'inside ~/.claude',
+    'inside-library': 'inside ~/Library', 'inside-sprag-data': 'inside the sprag data folder', excluded: 'on the exclude list',
+    'not-owned': 'a user file of the same name exists, not overwritten', 'no-source': 'no source ratchet file to copy',
+  },
+};
+
+const norm = (p) => {
+  const abs = resolve(p);
+  try { return realpathSync(abs); } catch { return abs; }
+};
+
+export async function run({ args }) {
+  const cw = await import('../cowork-sync.js');
+  const { userLanguage } = await import('../config.js');
+  const ko = userLanguage() === 'ko';
+  const why = (r) => (REASONS[ko ? 'ko' : 'en'][r] || r);
+  const sub = args[1];
+
+  const summarize = (r) => {
+    console.log(ko
+      ? `Cowork 래칫 동기화: 새로 씀 ${r.written.length}, 변경 없음 ${r.unchanged.length}, 건너뜀 ${r.skipped.length}, 제거 ${r.removed.length}`
+      : `Cowork ratchet sync: written ${r.written.length}, unchanged ${r.unchanged.length}, skipped ${r.skipped.length}, removed ${r.removed.length}`);
+    for (const d of r.written) console.log(`  + ${d}`);
+    for (const d of r.removed) console.log(`  - ${d}`);
+    for (const s of r.skipped) console.log(`  ! ${s.dir} (${why(s.reason)})`);
+  };
+
+  if (sub === 'sync') return summarize(cw.syncCoworkRatchets({ discover: true }));
+
+  if (sub === 'off') {
+    cw.saveCoworkConfig({ sync: false });
+    console.log(ko ? 'Cowork 래칫 동기화를 껐습니다. 만들어 둔 사본을 지웁니다.' : 'Cowork ratchet sync is off. Removing the copies it made.');
+    return summarize(cw.removeCoworkRatchets());
+  }
+
+  if (sub === 'on') {
+    cw.saveCoworkConfig({ sync: true });
+    console.log(ko ? 'Cowork 래칫 동기화를 켰습니다.' : 'Cowork ratchet sync is on.');
+    return summarize(cw.syncCoworkRatchets({ discover: true }));
+  }
+
+  if (sub === 'exclude' || sub === 'include') {
+    const target = args.slice(2).find((a) => !a.startsWith('-'));
+    if (!target) {
+      console.error(ko ? '폴더 경로를 지정하십시오.' : 'Pass a folder path.');
+      process.exitCode = 1;
+      return;
+    }
+    const dir = norm(target);
+    const list = cw.coworkConfig().exclude;
+    if (sub === 'exclude') {
+      if (!list.includes(dir)) cw.saveCoworkConfig({ exclude: [...list, dir] });
+      const removed = cw.removeCoworkRatchetIn(dir);
+      console.log(ko
+        ? `제외 목록에 추가했습니다: ${dir}${removed ? ' (사본을 지웠습니다)' : ''}`
+        : `Added to the exclude list: ${dir}${removed ? ' (copy removed)' : ''}`);
+      return;
+    }
+    cw.saveCoworkConfig({ exclude: list.filter((x) => x !== dir && norm(x) !== dir) });
+    console.log(ko ? `제외 목록에서 뺐습니다: ${dir}` : `Removed from the exclude list: ${dir}`);
+    return summarize(cw.syncCoworkRatchets({ discover: true }));
+  }
+
+  if (sub !== undefined) {
+    console.error(ko ? `알 수 없는 하위 명령입니다: ${sub}` : `Unknown subcommand: ${sub}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const st = cw.coworkStatus();
+  console.log(ko ? `Cowork 래칫 동기화: ${st.enabled ? '켜짐' : '꺼짐'}` : `Cowork ratchet sync: ${st.enabled ? 'on' : 'off'}`);
+  console.log(ko ? `마지막 동기화: ${st.lastSync || '없음'}` : `Last sync: ${st.lastSync || 'never'}`);
+  if (st.folders.length === 0) {
+    console.log(ko ? '발견한 Cowork 연결 폴더가 없습니다.' : 'No Cowork folders discovered.');
+    return;
+  }
+  console.log(ko ? '연결 폴더:' : 'Connected folders:');
+  for (const f of st.folders) {
+    const state = f.hasCopy ? (ko ? '사본 있음' : 'copy present')
+      : f.foreign ? why('not-owned')
+      : f.eligible ? (ko ? '사본 없음' : 'no copy yet')
+      : (ko ? `제외: ${why(f.reason)}` : `skipped: ${why(f.reason)}`);
+    console.log(`  ${f.dir}  [${state}]`);
+  }
+}

package/src/commands/delegate.js

@@ -59,6 +59,13 @@ export async function run({ args, hasFlag }) {
   const { userLanguage } = await import('../config.js');
   const lang = userLanguage();
 
+  // `delegate agents` manages the tool-restricted subagent files. It is split
+  // off by the second word so it never mixes with the on/off PreToolUse guard.
+  if (sub === 'agents') {
+    await agentsCommand(args[2], lang);
+    return;
+  }
+
   if (sub === 'on') {
     // Install first, and only record the feature as on once that worked.
     // Saving the flag first left `delegate: on, hook not registered` behind
@@ -131,3 +138,39 @@ export async function run({ args, hasFlag }) {
     console.log('Enable with: sprag delegate on');
   }
 }
+
+async function agentsCommand(action, lang) {
+  const ko = lang === 'ko';
+  const da = await import('../delegation-agents.js');
+  const report = (r) => {
+    for (const n of r.written) console.log(ko ? `✓ ${n} 에이전트를 설치했습니다.` : `✓ installed agent ${n}`);
+    for (const n of r.unchanged) console.log(ko ? `  ${n} 에이전트는 이미 최신입니다.` : `  agent ${n} is already current`);
+    for (const k of r.skipped) {
+      console.log(ko
+        ? `✗ ${k.name} 에이전트는 건너뛰었습니다 (${k.reason === 'not-owned' ? '직접 만든 같은 이름의 파일이 있습니다' : k.reason}).`
+        : `✗ skipped agent ${k.name} (${k.reason})`);
+    }
+    for (const n of r.removed) console.log(ko ? `✓ ${n} 에이전트를 제거했습니다.` : `✓ removed agent ${n}`);
+  };
+  const rerender = async () => {
+    try { (await import('../model-rules.js')).syncAllFiles(); } catch { /* the next session start re-renders */ }
+  };
+
+  if (action === 'on' || action === 'off') {
+    const { loadConfig, saveConfig } = await import('../config.js');
+    saveConfig({ ...loadConfig(), delegationAgents: action === 'on' });
+    const r = action === 'on' ? da.syncDelegationAgents() : da.removeDelegationAgents();
+    await rerender();
+    report(r);
+    console.log(action === 'on'
+      ? (ko ? '위임 전용 에이전트를 켰습니다. 래칫 문구가 에이전트 이름으로 다시 만들어졌습니다.' : 'Delegation agents are on. The ratchet wording was re-rendered with the agent names.')
+      : (ko ? '위임 전용 에이전트를 껐습니다. 래칫 문구가 model 지정 방식으로 다시 만들어졌습니다.' : 'Delegation agents are off. The ratchet wording was re-rendered with plain model tiers.'));
+    return;
+  }
+
+  const st = da.delegationAgentStatus();
+  console.log(ko ? `delegate agents: ${st.enabled ? 'on' : 'off'}` : `delegate agents: ${st.enabled ? 'on' : 'off'}`);
+  const label = { 'installed-by-sprag': ko ? 'sprag 가 설치함' : 'installed by sprag', 'user-file': ko ? '직접 만든 파일' : 'user file', absent: ko ? '없음' : 'absent' };
+  for (const a of st.agents) console.log(`  ${a.name}: ${a.state} (${label[a.state]})`);
+  console.log(ko ? '켜기 또는 끄기: sprag delegate agents on|off' : 'Toggle with: sprag delegate agents on|off');
+}

package/src/commands/install.js

@@ -368,6 +368,17 @@ export async function run({ hasFlag }) {
     // they have not read. All the install does is say what is waiting.
     // Presets now live in ratchet-preset.md. Moving the ones older versions
     // appended to ratchet.md comes first, so they are not offered again below.
+    try {
+      const d = (await import('../delegation-agents.js')).syncDelegationAgents();
+      if (d.written.length) {
+        console.log(lang === 'ko'
+          ? `  agents: 위임 전용 에이전트 ${d.written.length}개를 ~/.claude/agents 에 설치했습니다 (MCP 도구 없음).`
+          : `  agents: installed ${d.written.length} delegation-only agent(s) in ~/.claude/agents (no MCP tools).`);
+      }
+    } catch (e) {
+      debug('install:delegation-agents', e);
+    }
+
     try {
       const { preparePresetRatchet } = await import('../preset-ratchet.js');
       const p = preparePresetRatchet();

package/src/commands/route-scan.js

@@ -296,11 +296,15 @@ export async function run({ args, hasFlag, numArg }) {
       // would keep reading the old wording indefinitely. The call writes only
       // when the rendering differs, so the common case is a read and a string
       // compare.
+      // Agent files come first so the ratchet-model.md rendered next names them.
+      try { (await import('../delegation-agents.js')).syncDelegationAgents(); } catch (e) { debug('route-scan:delegation-agents', e); }
       try { mrHook.syncAllFiles(); } catch (e) { debug('route-scan:sync-ratchet', e); }
       // Same reason for the preset ratchet: an upgrade that rewords or drops a
       // bundled rule reaches ratchet-preset.md here, without a reinstall. It
       // also moves presets older versions appended to ratchet.md.
       try { (await import('../preset-ratchet.js')).preparePresetRatchet(); } catch (e) { debug('route-scan:sync-preset', e); }
+      // Cowork cannot follow the ~/.claude imports, so it gets a pasted copy.
+      try { (await import('../cowork-sync.js')).syncCoworkRatchets({ discover: true }); } catch (e) { debug('route-scan:cowork-sync', e); }
       // Registered rules whose delegated-category error rate crossed the
       // health threshold since promotion — the user approved these, so a
       // status change must be briefed, not just written into the md file.
@@ -466,6 +470,8 @@ export async function run({ args, hasFlag, numArg }) {
     let cache = rs.readRouteScan();
     if (hasFlag('--refresh') || (cache && cache.days !== days) || await rs.shouldRescan(cache, { days })) {
       cache = await rs.runRouteScan({ days });
+      // model-rules were rewritten by the scan; carry them to the Cowork copies.
+      try { (await import('../cowork-sync.js')).syncCoworkRatchets({ discover: true }); } catch (e) { debug('route-scan:cowork-sync', e); }
     }
     if (hasFlag('--quiet')) return;
     if (hasFlag('--json')) {

package/src/commands/uninstall.js

@@ -26,6 +26,10 @@ export async function run({ hasFlag, args = [] }) {
     return;
   }
 
+  // The Cowork copies and the settings.json exclude entry are ours too.
+  try { (await import('../cowork-sync.js')).removeCoworkRatchets(); } catch { /* uninstall goes on */ }
+  try { (await import('../delegation-agents.js')).removeDelegationAgents(); } catch { /* uninstall goes on */ }
+
   if (r.removed.length === 0) {
     console.log(lang === 'ko' ? '설치된 항목이 없습니다.' : 'Nothing was installed.');
   } else {

package/src/cowork-sync.js

@@ -0,0 +1,361 @@
+/**
+ * cowork-sync: copy the global ratchet files into the folders connected to the
+ * Claude desktop app's Cowork tab.
+ *
+ * Cowork does not read ~/.claude (no hooks, no `@` imports), but it does read
+ * `<folder>/.claude/rules/*.md`. So the three global ratchet files are pasted
+ * into one tool-owned rules file per connected folder. Claude Code reads the
+ * same rules directory, so ~/.claude/settings.json gets a `claudeMdExcludes`
+ * entry that keeps Claude Code from loading the copy a second time (Cowork does
+ * not read that settings file).
+ *
+ * Where Cowork keeps its session metadata (macOS verified):
+ *   ~/Library/Application Support/Claude-3p/local-agent-mode-sessions/<org>/<user>/local_<id>.json
+ * The 1p app is assumed to use ".../Claude/local-agent-mode-sessions" (not
+ * verified). Windows is assumed to use %APPDATA%\Claude and %APPDATA%\Claude-3p
+ * (not verified). Linux is out of scope.
+ *
+ * Nothing here throws to the caller: a folder that cannot be written is
+ * reported in `skipped`, and the SessionStart hook ignores the whole call on
+ * failure.
+ */
+
+import {
+  existsSync, readFileSync, readdirSync, statSync, realpathSync, mkdirSync, writeFileSync, rmSync,
+  appendFileSync,
+} from 'node:fs';
+import { join, resolve, sep, isAbsolute } from 'node:path';
+import { homedir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { userDataDir, claudeUserDir } from './paths.js';
+import { loadConfig, saveConfig, userLanguage } from './config.js';
+import { writeStateFile } from './state-file.js';
+import { readSettings, writeSettings } from './installer.js';
+import { modelRatchetPathFor } from './model-rules.js';
+import { presetRatchetPath } from './preset-ratchet.js';
+import { globalRatchetMdPath } from './harness.js';
+import { debug } from './debug.js';
+
+export const COWORK_MARKER = '<!-- sprag:cowork-ratchet -->';
+export const COWORK_EXCLUDE_PATTERN = '**/.claude/rules/sprag-cowork-ratchet.md';
+const COPY_REL = join('.claude', 'rules', 'sprag-cowork-ratchet.md');
+const MAX_PARSE_PER_CALL = 200;
+
+export const coworkStatePath = () => join(userDataDir(), 'cowork-sync.json');
+
+// ---------- config ----------
+
+export function coworkConfig() {
+  const c = loadConfig().cowork;
+  return {
+    sync: !(c && c.sync === false),
+    exclude: Array.isArray(c?.exclude) ? c.exclude.filter((x) => typeof x === 'string') : [],
+  };
+}
+
+export function saveCoworkConfig(patch) {
+  const cfg = loadConfig();
+  saveConfig({ ...cfg, cowork: { ...coworkConfig(), ...patch } });
+}
+
+// ---------- state ----------
+
+export function loadCoworkState() {
+  try {
+    const s = JSON.parse(readFileSync(coworkStatePath(), 'utf8'));
+    if (s && typeof s === 'object' && !Array.isArray(s)) {
+      return {
+        version: 1,
+        scanned: s.scanned && typeof s.scanned === 'object' ? s.scanned : {},
+        folders: s.folders && typeof s.folders === 'object' ? s.folders : {},
+        written: s.written && typeof s.written === 'object' ? s.written : {},
+        ...(typeof s.lastSync === 'string' ? { lastSync: s.lastSync } : {}),
+      };
+    }
+  } catch { /* first run or unreadable: start empty */ }
+  return { version: 1, scanned: {}, folders: {}, written: {} };
+}
+
+export function saveCoworkState(state) {
+  try { writeStateFile(coworkStatePath(), JSON.stringify(state, null, 2) + '\n'); } catch (e) { debug('cowork-sync:save-state', e); }
+}
+
+// ---------- discovery ----------
+
+export function coworkSessionRoots() {
+  const bases = [];
+  if (process.platform === 'darwin') {
+    const support = join(homedir(), 'Library', 'Application Support');
+    bases.push(join(support, 'Claude'), join(support, 'Claude-3p'));
+  } else if (process.platform === 'win32' && process.env.APPDATA) {
+    bases.push(join(process.env.APPDATA, 'Claude'), join(process.env.APPDATA, 'Claude-3p'));
+  }
+  return bases.map((b) => join(b, 'local-agent-mode-sessions')).filter((p) => existsSync(p));
+}
+
+function subdirs(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join(dir, e.name));
+  } catch { return []; }
+}
+
+/** local_*.json exactly three levels under a root: <org>/<user>/local_*.json */
+function sessionMetaFiles(root) {
+  const out = [];
+  for (const org of subdirs(root)) {
+    for (const user of subdirs(org)) {
+      let names;
+      try { names = readdirSync(user); } catch { continue; }
+      for (const n of names) {
+        if (n.startsWith('local_') && n.endsWith('.json')) out.push(join(user, n));
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * Parse only the metadata files whose mtime changed since the last call (at
+ * most 200 per call, newest first; the rest wait for the next call) and add
+ * the folders they name to `state.folders`. Folders are never forgotten.
+ */
+export function discoverCoworkFolders({ state = loadCoworkState() } = {}) {
+  const now = new Date().toISOString();
+  const seen = {};
+  const changed = [];
+  for (const root of coworkSessionRoots()) {
+    for (const file of sessionMetaFiles(root)) {
+      let mtime;
+      try { mtime = statSync(file).mtimeMs; } catch { continue; }
+      seen[file] = mtime;
+      if (state.scanned[file] !== mtime) changed.push({ file, mtime });
+    }
+  }
+  changed.sort((a, b) => b.mtime - a.mtime);
+  const nextScanned = {};
+  // Unchanged files keep their mark; changed ones are marked only once handled,
+  // so the ones beyond the cap are picked up by the next call.
+  for (const [file, mtime] of Object.entries(seen)) {
+    if (state.scanned[file] === mtime) nextScanned[file] = mtime;
+  }
+  for (const { file, mtime } of changed.slice(0, MAX_PARSE_PER_CALL)) {
+    nextScanned[file] = mtime;
+    let meta;
+    try { meta = JSON.parse(readFileSync(file, 'utf8')); } catch { continue; }
+    const list = Array.isArray(meta?.userSelectedFolders) ? meta.userSelectedFolders : [];
+    for (const f of list) {
+      if (typeof f !== 'string' || !f) continue;
+      const rec = state.folders[f];
+      state.folders[f] = { firstSeen: rec?.firstSeen || now, lastSeen: now };
+    }
+  }
+  state.scanned = nextScanned;
+  return Object.keys(state.folders);
+}
+
+// ---------- eligibility ----------
+
+function real(p) {
+  try { return realpathSync(p); } catch { return resolve(p); }
+}
+
+const isInside = (child, parent) => child === parent || child.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+
+/** @returns {{ ok: boolean, reason?: string, dir?: string }} `dir` is the real path when ok */
+export function eligibleFolder(dir) {
+  if (typeof dir !== 'string' || !isAbsolute(dir)) return { ok: false, reason: 'not-absolute' };
+  let st;
+  try { st = statSync(dir); } catch { return { ok: false, reason: 'missing' }; }
+  if (!st.isDirectory()) return { ok: false, reason: 'not-a-directory' };
+  const rd = real(dir);
+  const home = real(homedir());
+  if (rd === home || isInside(home, rd)) return { ok: false, reason: 'home-or-ancestor' };
+  if (isInside(rd, real(claudeUserDir()))) return { ok: false, reason: 'inside-claude-dir' };
+  if (process.platform === 'darwin' && isInside(rd, real(join(homedir(), 'Library')))) return { ok: false, reason: 'inside-library' };
+  if (isInside(rd, real(userDataDir()))) return { ok: false, reason: 'inside-sprag-data' };
+  for (const ex of coworkConfig().exclude) {
+    if (isInside(rd, real(ex))) return { ok: false, reason: 'excluded' };
+  }
+  return { ok: true, dir: rd };
+}
+
+export const coworkCopyPath = (dir) => join(dir, COPY_REL);
+
+// ---------- content ----------
+
+/** @returns {string|null} null when none of the three source files exists */
+export function renderCoworkRatchet(lang = userLanguage()) {
+  const ko = lang === 'ko';
+  const parts = [];
+  for (const file of [modelRatchetPathFor('global'), presetRatchetPath(), globalRatchetMdPath()]) {
+    let body;
+    try { body = readFileSync(file, 'utf8'); } catch { continue; }
+    const name = file.split(/[\\/]/).pop();
+    parts.push(`## ${ko ? '원본' : 'Source'}: ~/.claude/${name}\n\n${body.trim()}\n`);
+  }
+  if (parts.length === 0) return null;
+  const intro = ko
+    ? '이 파일은 sprag가 Claude 앱 Cowork 탭용으로 생성한 래칫 사본입니다. Cowork는 ~/.claude 의 설정과 import를 읽지 않으므로, 원본 래칫 세 파일의 본문을 여기에 옮겨 둡니다. sprag가 원본이 바뀔 때마다 이 파일을 통째로 다시 쓰므로 직접 고치지 마십시오. Claude Code(Code 탭)는 settings.json 의 claudeMdExcludes 로 이 파일을 읽지 않습니다.'
+    : 'This file is a copy of the ratchet rules that sprag generates for the Cowork tab of the Claude app. Cowork does not read the settings or imports under ~/.claude, so the bodies of the three source ratchet files are copied here. sprag rewrites this whole file whenever a source changes, so do not edit it by hand. Claude Code (the Code tab) skips this file through claudeMdExcludes in settings.json.';
+  return `${COWORK_MARKER}\n${intro}\n\n${parts.join('\n')}`;
+}
+
+function firstLine(file) {
+  const raw = readFileSync(file, 'utf8');
+  const i = raw.indexOf('\n');
+  return (i === -1 ? raw : raw.slice(0, i)).replace(/\r$/, '').trim();
+}
+
+const isOwned = (file) => { try { return firstLine(file) === COWORK_MARKER; } catch { return false; } };
+
+// ---------- git exclude ----------
+
+const git = (dir, args) => execFileSync('git', ['-C', dir, ...args], {
+  timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8',
+}).trim();
+
+function addGitExclude(dir) {
+  try {
+    if (git(dir, ['rev-parse', '--is-inside-work-tree']) !== 'true') return;
+    const rel = COPY_REL.split(sep).join('/');
+    try { git(dir, ['check-ignore', '-q', rel]); return; } catch { /* exit 1: not ignored yet */ }
+    const excludeFile = resolve(dir, git(dir, ['rev-parse', '--git-path', 'info/exclude']));
+    const prefix = git(dir, ['rev-parse', '--show-prefix']);
+    const line = `/${prefix}${rel}`;
+    let existing = '';
+    try { existing = readFileSync(excludeFile, 'utf8'); } catch { /* new file */ }
+    if (existing.split(/\r?\n/).includes(line)) return;
+    mkdirSync(resolve(excludeFile, '..'), { recursive: true });
+    appendFileSync(excludeFile, `${existing && !existing.endsWith('\n') ? '\n' : ''}${line}\n`);
+  } catch (e) {
+    debug('cowork-sync:git-exclude', e);
+  }
+}
+
+// ---------- settings.json (Code tab de-dup) ----------
+
+const settingsFile = () => join(claudeUserDir(), 'settings.json');
+
+function ensureClaudeMdExclude() {
+  const file = settingsFile();
+  const read = readSettings(file);
+  if (read.state !== 'ok' && read.state !== 'absent') return;
+  const cur = read.settings.claudeMdExcludes;
+  if (cur !== undefined && !Array.isArray(cur)) return; // not ours to reshape
+  if (cur && cur.includes(COWORK_EXCLUDE_PATTERN)) return;
+  read.settings.claudeMdExcludes = [...(cur || []), COWORK_EXCLUDE_PATTERN];
+  const problem = writeSettings(file, read.settings);
+  if (problem) debug('cowork-sync:settings-write', problem);
+}
+
+function dropClaudeMdExclude() {
+  const file = settingsFile();
+  const read = readSettings(file);
+  if (read.state !== 'ok') return;
+  const cur = read.settings.claudeMdExcludes;
+  if (!Array.isArray(cur) || !cur.includes(COWORK_EXCLUDE_PATTERN)) return;
+  const next = cur.filter((x) => x !== COWORK_EXCLUDE_PATTERN);
+  if (next.length) read.settings.claudeMdExcludes = next;
+  else delete read.settings.claudeMdExcludes;
+  const problem = writeSettings(file, read.settings);
+  if (problem) debug('cowork-sync:settings-write', problem);
+}
+
+// ---------- sync / remove ----------
+
+export function syncCoworkRatchets({ discover = true, agent = 'claude' } = {}) {
+  const result = { written: [], unchanged: [], skipped: [], removed: [] };
+  if (agent === 'codex') return result;
+  try {
+    if (!coworkConfig().sync) return removeCoworkRatchets();
+    const state = loadCoworkState();
+    if (discover) {
+      try { discoverCoworkFolders({ state }); } catch (e) { debug('cowork-sync:discover', e); }
+    }
+    const content = renderCoworkRatchet();
+    for (const folder of Object.keys(state.folders)) {
+      try {
+        const el = eligibleFolder(folder);
+        if (!el.ok) { result.skipped.push({ dir: folder, reason: el.reason }); continue; }
+        if (content === null) { result.skipped.push({ dir: folder, reason: 'no-source' }); continue; }
+        const target = coworkCopyPath(el.dir);
+        if (existsSync(target)) {
+          if (!isOwned(target)) { result.skipped.push({ dir: folder, reason: 'not-owned' }); continue; }
+          if (readFileSync(target, 'utf8') === content) {
+            result.unchanged.push(folder);
+            state.written[target] = state.written[target] || { at: new Date().toISOString() };
+            continue;
+          }
+        }
+        mkdirSync(join(el.dir, '.claude', 'rules'), { recursive: true });
+        writeFileSync(target, content);
+        state.written[target] = { at: new Date().toISOString() };
+        result.written.push(folder);
+        addGitExclude(el.dir);
+      } catch (e) {
+        result.skipped.push({ dir: folder, reason: `error: ${e?.message || e}` });
+      }
+    }
+    if (result.written.length || result.unchanged.length) {
+      try { ensureClaudeMdExclude(); } catch (e) { debug('cowork-sync:settings', e); }
+    }
+    state.lastSync = new Date().toISOString();
+    saveCoworkState(state);
+  } catch (e) {
+    debug('cowork-sync:sync', e);
+  }
+  return result;
+}
+
+/** Remove the copy in one folder (only when it carries our marker). */
+export function removeCoworkRatchetIn(dir) {
+  const candidates = new Set([coworkCopyPath(dir), coworkCopyPath(real(dir))]);
+  let removed = false;
+  const state = loadCoworkState();
+  for (const target of candidates) {
+    try {
+      if (existsSync(target) && isOwned(target)) { rmSync(target, { force: true }); removed = true; }
+    } catch (e) { debug('cowork-sync:remove-one', e); }
+    delete state.written[target];
+  }
+  saveCoworkState(state);
+  return removed;
+}
+
+export function removeCoworkRatchets() {
+  const result = { written: [], unchanged: [], skipped: [], removed: [] };
+  try {
+    const state = loadCoworkState();
+    const targets = new Set(Object.keys(state.written));
+    for (const folder of Object.keys(state.folders)) targets.add(coworkCopyPath(folder));
+    for (const target of targets) {
+      try {
+        if (existsSync(target) && isOwned(target)) {
+          rmSync(target, { force: true });
+          result.removed.push(resolve(target, '..', '..', '..'));
+        }
+      } catch (e) {
+        result.skipped.push({ dir: target, reason: `error: ${e?.message || e}` });
+      }
+    }
+    state.written = {};
+    saveCoworkState(state);
+    try { dropClaudeMdExclude(); } catch (e) { debug('cowork-sync:settings', e); }
+  } catch (e) {
+    debug('cowork-sync:remove', e);
+  }
+  return result;
+}
+
+/** Per-folder view for `sprag cowork`. */
+export function coworkStatus() {
+  const state = loadCoworkState();
+  const cfg = coworkConfig();
+  const folders = Object.keys(state.folders).map((dir) => {
+    const el = eligibleFolder(dir);
+    const copy = coworkCopyPath(el.ok ? el.dir : dir);
+    const there = existsSync(copy);
+    return { dir, eligible: el.ok, reason: el.reason, hasCopy: there && isOwned(copy), foreign: there && !isOwned(copy) };
+  });
+  return { enabled: cfg.sync, exclude: cfg.exclude, lastSync: state.lastSync || null, folders };
+}

package/src/delegation-agents.js

@@ -0,0 +1,133 @@
+/**
+ * Delegation-only subagents: Claude Code agents with a `tools` allowlist.
+ *
+ * Behind a gateway (ANTHROPIC_BASE_URL) Claude Code turns MCP tool search off,
+ * so every MCP tool definition rides along on each subagent request. A
+ * `general-purpose` haiku measured 46,618 tokens on its first request; a haiku
+ * agent limited to Read/Grep/Glob/Bash measured 20,141. A `tools` allowlist
+ * excludes MCP tools by definition, which is the whole saving.
+ *
+ * The files live in ~/.claude/agents and carry an ownership marker inside the
+ * frontmatter (a YAML comment, so it never reaches the prompt). Only files with
+ * that marker are ever overwritten or deleted; a same-named user file is left.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { claudeUserDir } from './paths.js';
+import { loadConfig } from './config.js';
+
+export const OWNER_MARK = 'sprag:delegation-agent';
+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.
+export const DEFINITIONS = [
+  {
+    name: 'haiku-explore',
+    model: 'haiku',
+    tools: 'Read, Grep, Glob, Bash',
+    role: 'Your role: read-only exploration, lookups, status checks, and questions about pasted logs or text.',
+    description: 'Cheap read-only exploration, lookup, status checks and summaries for delegated tasks. It has no MCP tools.',
+  },
+  {
+    name: 'haiku-runner',
+    model: 'haiku',
+    tools: 'Bash, Read, Grep, Glob',
+    role: 'Your role: run the build, test, or git commands you are given and report the result.',
+    description: 'Cheap runner for build, test and git commands in delegated tasks. It has no MCP tools.',
+  },
+  {
+    name: 'haiku-translate',
+    model: 'haiku',
+    tools: 'Read, Grep, Glob, Edit, Write',
+    role: 'Your role: batch translation and mechanical text conversion of the files or text you are given.',
+    description: 'Cheap batch translation and structured text conversion for delegated tasks. It has no MCP tools.',
+  },
+  {
+    name: 'sonnet-worker',
+    model: 'sonnet',
+    tools: 'Read, Grep, Glob, Bash, Edit, Write, NotebookEdit',
+    role: 'Your role: multi-step work and the implementation half of a design the caller already fixed.',
+    description: 'Mid-tier worker for multi-step tasks and implementation handed over with a fixed design. It has no MCP tools.',
+  },
+];
+
+function render(def) {
+  return [
+    '---',
+    `name: ${def.name}`,
+    `description: ${def.description}`,
+    `tools: ${def.tools}`,
+    `model: ${def.model}`,
+    MARK_LINE,
+    '---',
+    def.role,
+    'Do only the delegated task, and stay within the caps (tool calls, output tokens) the caller wrote in the prompt.',
+    "Report concisely, in the language of the caller's prompt.",
+    'If 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.',
+    'Do not guess at anything you could not verify; say that you could not verify it.',
+    '',
+  ].join('\n');
+}
+
+const agentsDir = () => join(claudeUserDir(), 'agents');
+const fileOf = (name) => join(agentsDir(), `${name}.md`);
+
+/** True when the marker sits inside the leading frontmatter block. */
+function isOwned(text) {
+  if (!text.startsWith('---')) return false;
+  const end = text.indexOf('\n---', 3);
+  return (end === -1 ? text : text.slice(0, end)).includes(OWNER_MARK);
+}
+
+function readOwned(path) {
+  try { return { text: readFileSync(path, 'utf8') }; } catch { return null; }
+}
+
+export function removeDelegationAgents() {
+  const removed = [];
+  for (const def of DEFINITIONS) {
+    const p = fileOf(def.name);
+    try {
+      const f = readOwned(p);
+      if (f && isOwned(f.text)) { unlinkSync(p); removed.push(def.name); }
+    } catch { /* one file failing does not stop the rest */ }
+  }
+  return { written: [], unchanged: [], skipped: [], removed };
+}
+
+export function syncDelegationAgents({ agent = 'claude' } = {}) {
+  const res = { written: [], unchanged: [], skipped: [], removed: [] };
+  if (agent === 'codex') return res;
+  try {
+    if (loadConfig().delegationAgents === false) return removeDelegationAgents();
+  } catch { /* an unreadable config means the default, on */ }
+  for (const def of DEFINITIONS) {
+    try {
+      const p = fileOf(def.name);
+      const want = render(def);
+      const cur = existsSync(p) ? readOwned(p) : null;
+      if (existsSync(p) && !cur) { res.skipped.push({ name: def.name, reason: 'unreadable' }); continue; }
+      if (cur && !isOwned(cur.text)) { res.skipped.push({ name: def.name, reason: 'not-owned' }); continue; }
+      if (cur && cur.text === want) { res.unchanged.push(def.name); continue; }
+      mkdirSync(agentsDir(), { recursive: true });
+      writeFileSync(p, want);
+      res.written.push(def.name);
+    } catch (e) {
+      res.skipped.push({ name: def.name, reason: `error: ${e.message}` });
+    }
+  }
+  return res;
+}
+
+export function delegationAgentStatus() {
+  let enabled = true;
+  try { enabled = loadConfig().delegationAgents !== false; } catch { /* default on */ }
+  const agents = DEFINITIONS.map((def) => {
+    const f = existsSync(fileOf(def.name)) ? readOwned(fileOf(def.name)) : null;
+    const state = !f ? 'absent' : isOwned(f.text) ? 'installed-by-sprag' : 'user-file';
+    return { name: def.name, state };
+  });
+  return { enabled, agents };
+}

package/src/harness.js

@@ -70,7 +70,7 @@ function ratchetMdPath(root) {
   return join(root, '.claude', 'ratchet.md');
 }
 
-function globalRatchetMdPath() {
+export function globalRatchetMdPath() {
   return join(homedir(), '.claude', 'ratchet.md');
 }
 

package/src/implementation-delegation.js

@@ -1,11 +1,14 @@
+import { agentPhrase, agentPhraseEn, resolveAgentName } from './agents.js';
+
 /** Shared policy, rendered with each client's native model selector. */
 export function implementationDelegationRule(agent = 'claude', lang = 'en') {
   const target = agent === 'codex'
     ? 'the resolved T1 model for the current parent model and provider (explicit mapping first, automatic resolution otherwise)'
-    : 'a model: sonnet subagent';
+    : (resolveAgentName('sonnet', null) ? agentPhraseEn('sonnet', { root: null }) : 'a model: sonnet subagent');
+  const targetKo = resolveAgentName('sonnet', null) ? agentPhrase('sonnet', { root: null }) : 'model: sonnet 서브에이전트';
   if (lang === 'ko') return [
     '- **구현 분업**: 여러 파일을 고칠 때 설계와 스펙 확정은 메인 모델이 맡습니다.',
-    `  구현은 ${agent === 'codex' ? '현재 부모 모델과 프로바이더의 T1 모델' : 'model: sonnet 서브에이전트'}에 위임합니다.`,
+    `  구현은 ${agent === 'codex' ? '현재 부모 모델과 프로바이더의 T1 모델' : targetKo}에 위임합니다.`,
     '  Claude는 sonnet을 쓰고, Codex는 명시적 T1 매핑을 우선하며 없으면 자동 해석한 T1을 씁니다.',
     '  두 모델의 성능이 같다고 가정하지 않으며 haiku나 T2에 구현을 맡기지 않습니다.',
     '  위임 프롬프트에는 설계, 수정할 파일, 제약, 완료 기준, 테스트 명령, 예산과',

package/src/model-rules.js

@@ -33,7 +33,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 } from './agents.js';
+import { agentPhrase, agentPhraseEn, resolveAgentName } from './agents.js';
 import { writeStateFile } from './state-file.js';
 import { signedUsd } from './money.js';
 import { implementationDelegationRule } from './implementation-delegation.js';
@@ -132,16 +132,23 @@ function shortExample(text) {
   return one.length <= EXAMPLE_MAX ? one : `${one.slice(0, EXAMPLE_MAX - 1)}…`;
 }
 
+// T1 is named through its delegation agent only when that file exists; without
+// it the literal `model: sonnet` stays so output on such machines is unchanged.
+function t1Target(root, ko) {
+  if (resolveAgentName('sonnet', root) === null) return null;
+  return (ko ? agentPhrase : agentPhraseEn)('sonnet', { root });
+}
+
 export function modelRuleBaseText(g, lang = userLanguage(), { root } = {}) {
   if (lang === 'ko') {
     return g.tier === 'T2'
       ? `"${g.label}" 단순 요청(예: "${shortExample(g.example)}")은 ${agentPhrase(g.agent, { root })}에 위임`
-      : `"${g.label}" 중간 난도 요청(예: "${shortExample(g.example)}")은 model: sonnet에 위임`;
+      : `"${g.label}" 중간 난도 요청(예: "${shortExample(g.example)}")은 ${t1Target(root, true) ?? 'model: sonnet'}에 위임`;
   }
   const example = g.exampleEn || g.example;
   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 a model: sonnet subagent`;
+    : `Moderate "${g.labelEn}" requests (e.g. "${shortExample(example)}") go to ${t1Target(root, false) ?? 'a model: sonnet subagent'}`;
 }
 
 // See the note in route-scan.js — paths.js is the only place that resolves
@@ -401,10 +408,10 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
       // match at a glance.
       const rule = ko
         ? `"${t2.label}": 기본 ${agentPhrase(t2.agent, { root })}(예: "${ex(t2)}"), ` +
-          `여러 단계·여러 파일이 얽히면 model: sonnet(예: "${ex(t1)}"). ` +
+          `여러 단계·여러 파일이 얽히면 ${t1Target(root, true) ?? 'model: sonnet'}(예: "${ex(t1)}"). ` +
           mergedBudget(t2, t1)
         : `"${t2.labelEn || t2.label}": ${agentPhraseEn(t2.agent, { root })} by default (e.g. "${ex(t2)}"), ` +
-          `model: sonnet when it spans multiple steps or file edits (e.g. "${ex(t1)}"). ` +
+          `${t1Target(root, false) ?? 'model: sonnet'} when it spans multiple steps or file edits (e.g. "${ex(t1)}"). ` +
           mergedBudget(t2, t1);
       lines.push(`- ${rule}${healthOf(t2)}${healthOf(t1)}${extraHealth} <!-- T2 ${statsOf(t2)} / T1 ${statsOf(t1)}${extraStats} -->`);
     } else if (t2 || t1) {

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 } from './agents.js';
+import { agentPhrase, agentPhraseEn, resolveAgentName } from './agents.js';
 import { userLanguage } from './config.js';
 import { aliasForRole, resolveModelAlias } from './model-alias.js';
 import { isRecognizedModelId, modelRank } from './cost.js';
@@ -259,11 +259,16 @@ export function routeHint(text, { rules, lang = userLanguage(), root, sessionRan
   const raw = ko ? agentPhrase : agentPhraseEn;
   const phrase = (name) => raw(name, root === undefined ? undefined : { root });
 
+  // T1 is named through its delegation agent only when that file exists here;
+  // otherwise the literal tier string stays, so output without agents is unchanged.
+  const t1Root = root === undefined ? undefined : root;
+  const t1Named = resolveAgentName('sonnet', t1Root) !== null;
+  const t1Phrase = t1Named ? phrase('sonnet') : 'model: sonnet';
   let target;
   if (t2 && t1) {
     target = ko
-      ? `기본 ${phrase(t2.agent)}, 여러 단계·여러 파일이 얽히면 model: sonnet`
-      : `${phrase(t2.agent)} by default, model: sonnet when it spans multiple steps or file edits`;
+      ? `기본 ${phrase(t2.agent)}, 여러 단계·여러 파일이 얽히면 ${t1Phrase}`
+      : `${phrase(t2.agent)} by default, ${t1Phrase} when it spans multiple steps or file edits`;
   } else {
     const only = t2 || t1;
     target = ko ? phrase(only.agent) : phrase(only.agent);