sprag-cli 3.69.0 → 3.70.0

package/src/commands/team.js

@@ -0,0 +1,278 @@
+/**
+ * team — `sprag team <create|join|leave|status|sync|rules|propose>`.
+ *
+ * The opt-in team layer. `join` shows exactly what will be uploaded (daily
+ * aggregates only) and asks before enrolling. `sync --background` is what the
+ * SessionStart hook's detached child runs: auto-join from SPRAG_TEAM_TOKEN,
+ * then upload and pull, printing nothing. All network access goes through
+ * rpc() in src/team-sync.js. Exit codes: 0 ok, 1 error, 2 usage.
+ */
+
+import { createInterface } from 'node:readline';
+import { readFileSync } from 'node:fs';
+import { userInfo } from 'node:os';
+import { userLanguage } from '../config.js';
+import {
+  loadTeamState, isJoined, joinTeam, leaveTeam, syncTeam, autoJoin, aggregateDaily, rpc,
+  teamRulesCachePath, teamSyncDisabled, requestSignInCode, verifySignInCode, createTeam,
+} from '../team-sync.js';
+
+const T = {
+  en: {
+    usage: [
+      'Usage: sprag team <command>',
+      '  create [--email <e>] [--name <n>] [--code <6 digits>] [--no-join]   create a team (you become the owner)',
+      '  join [token] [--name <n>] [--yes]   join a team (token or SPRAG_TEAM_TOKEN)',
+      '  leave                                leave the team and stop uploading',
+      '  status [--show-payload]              membership, last sync, what is sent',
+      '  sync [--force]                       upload aggregates and pull team rules now',
+      '  rules                                show cached team rules',
+      '  propose <text> [--scope ratchet|model]   propose a rule to the team',
+    ].join('\n'),
+    willSend: 'Joining uploads daily aggregates only, per local day:\n  - spend (USD)\n  - savings (USD)\n  - delegation run counts\n  - model-family share\nNo prompts, file paths or transcripts are sent.',
+    asName: (n) => `Display name: ${n}`,
+    ask: 'Join? [y/N] ',
+    needYes: 'Not a terminal. Re-run with --yes to confirm: sprag team join <token> --yes',
+    noToken: 'Missing invite token. Pass it as an argument or set SPRAG_TEAM_TOKEN.',
+    aborted: 'Not joined.',
+    joined: (n) => `Joined team "${n}". Check it with: sprag team status`,
+    left: 'Left the team. Nothing is uploaded any more.',
+    notJoined: 'Not in a team. Join with: sprag team join <token>',
+    team: 'Team', plan: 'Plan', capture: 'Prompt capture', name: 'Display name',
+    lastSync: (t, n) => `Last sync: ${t} (${n} rows)`,
+    neverSynced: 'Last sync: never',
+    lastError: 'Last error',
+    on: 'on', off: 'off',
+    disabled: 'Team sync is disabled (CTS_NO_TEAM_SYNC=1).',
+    skipped: (s) => `Skipped: ${s}`,
+    synced: (u, r) => `Synced: ${u} day rows uploaded, ${r} team rules.`,
+    noRules: 'No team rules yet.',
+    proposed: (id) => `Proposed. Id: ${id}`,
+    needText: 'Missing rule text. Usage: sprag team propose <text> [--scope ratchet|model]',
+    badScope: 'Scope must be ratchet or model.',
+    needJoin: 'Join a team first: sprag team join <token>',
+    createUsage: 'Usage: sprag team create --email <e> --name "<team name>" [--code <6 digits>] [--no-join]',
+    badEmail: 'That does not look like an email address.',
+    badCode: 'The code is 6 digits, like 123456.',
+    needEmail: 'Missing --email. Usage: sprag team create --email <e> --name "<team name>"',
+    needName: 'Missing --name. Usage: sprag team create --email <e> --name "<team name>" --code <6 digits>',
+    alreadyJoined: (n) => `This machine is already in team "${n}". Run \`sprag team leave\` first, or pass --no-join.`,
+    askEmail: 'Your email: ',
+    askCode: 'Code from the email (6 digits): ',
+    askTeamName: (d) => `Team name [${d}]: `,
+    codeSent: (e) => `A 6-digit code was sent to ${e} (valid 15 minutes).`,
+    rerun: (e, n) => `Then run: sprag team create --email ${e} --name "${n}" --code <code>`,
+    created: (n) => `Created team "${n}".`,
+    inviteToken: 'Invite token',
+    memberCmd: 'Member command',
+    orgLine: 'Organization env',
+    dashboard: (e) => `Dashboard: https://sprag.io/team/ (sign in with ${e})`,
+    noJoinNote: 'This machine did not join (--no-join).',
+    syncFailed: (e) => `Team created, but the first sync failed: ${e}`,
+  },
+  ko: {
+    usage: [
+      '사용법: sprag team <명령>',
+      '  create [--email <e>] [--name <이름>] [--code <6자리>] [--no-join]   팀 만들기 (만든 사람이 소유자)',
+      '  join [토큰] [--name <이름>] [--yes]   팀에 참여 (토큰 또는 SPRAG_TEAM_TOKEN)',
+      '  leave                                  팀에서 나가고 업로드 중단',
+      '  status [--show-payload]                참여 상태, 마지막 동기화, 보내는 내용',
+      '  sync [--force]                         지금 집계를 올리고 팀 규칙을 받기',
+      '  rules                                  받아 둔 팀 규칙 보기',
+      '  propose <내용> [--scope ratchet|model]   팀에 규칙 제안',
+    ].join('\n'),
+    willSend: '참여하면 로컬 날짜별 하루 단위 집계만 올라갑니다.\n  - 지출(USD)\n  - 절감(USD)\n  - 위임 실행 횟수\n  - 모델 계열 비중\n프롬프트, 파일 경로, 대화 기록은 보내지 않습니다.',
+    asName: (n) => `표시 이름: ${n}`,
+    ask: '참여할까요? [y/N] ',
+    needYes: '터미널이 아닙니다. 확인하려면 --yes 를 붙여 다시 실행하세요: sprag team join <토큰> --yes',
+    noToken: '초대 토큰이 없습니다. 인자로 넘기거나 SPRAG_TEAM_TOKEN 을 설정하세요.',
+    aborted: '참여하지 않았습니다.',
+    joined: (n) => `팀 "${n}" 에 참여했습니다. 확인: sprag team status`,
+    left: '팀에서 나왔습니다. 이제 아무것도 업로드하지 않습니다.',
+    notJoined: '참여한 팀이 없습니다. 참여하려면: sprag team join <토큰>',
+    team: '팀', plan: '플랜', capture: '프롬프트 수집', name: '표시 이름',
+    lastSync: (t, n) => `마지막 동기화: ${t} (${n}행)`,
+    neverSynced: '마지막 동기화: 아직 없음',
+    lastError: '마지막 오류',
+    on: '켜짐', off: '꺼짐',
+    disabled: '팀 동기화가 꺼져 있습니다 (CTS_NO_TEAM_SYNC=1).',
+    skipped: (s) => `건너뜀: ${s}`,
+    synced: (u, r) => `동기화 완료: ${u}일치 집계 업로드, 팀 규칙 ${r}개.`,
+    noRules: '아직 팀 규칙이 없습니다.',
+    proposed: (id) => `제안했습니다. ID: ${id}`,
+    needText: '규칙 내용이 없습니다. 사용법: sprag team propose <내용> [--scope ratchet|model]',
+    badScope: '범위는 ratchet 또는 model 이어야 합니다.',
+    needJoin: '먼저 팀에 참여하세요: sprag team join <토큰>',
+    createUsage: '사용법: sprag team create --email <e> --name "<팀 이름>" [--code <6자리>] [--no-join]',
+    badEmail: '이메일 주소 형식이 아닙니다',
+    badCode: '코드는 123456 같은 6자리 숫자입니다',
+    needEmail: '--email 이 없습니다. 사용법: sprag team create --email <e> --name "<팀 이름>"',
+    needName: '--name 이 없습니다. 사용법: sprag team create --email <e> --name "<팀 이름>" --code <6자리>',
+    alreadyJoined: (n) => `이 PC는 이미 팀 "${n}" 에 참여 중입니다. 먼저 \`sprag team leave\` 를 실행하거나 --no-join 을 붙이세요`,
+    askEmail: '이메일: ',
+    askCode: '메일로 받은 코드 (6자리): ',
+    askTeamName: (d) => `팀 이름 [${d}]: `,
+    codeSent: (e) => `${e} 로 6자리 코드를 보냈습니다 (15분간 유효)`,
+    rerun: (e, n) => `받은 코드로 다시 실행하세요: sprag team create --email ${e} --name "${n}" --code <코드>`,
+    created: (n) => `팀 "${n}" 을 만들었습니다`,
+    inviteToken: '초대 토큰',
+    memberCmd: '멤버용 명령',
+    orgLine: '조직 환경 변수',
+    dashboard: (e) => `대시보드: https://sprag.io/team/ (${e} 로 로그인)`,
+    noJoinNote: '이 PC는 참여하지 않았습니다 (--no-join)',
+    syncFailed: (e) => `팀은 만들어졌지만 첫 동기화에 실패했습니다: ${e}`,
+  },
+};
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (a) => { rl.close(); resolve(a.trim()); });
+  });
+}
+
+async function confirm(question) {
+  return /^y(es)?$/i.test(await prompt(question));
+}
+
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const CODE_RE = /^\d{6}$/;
+
+/** `sprag team create`: sign in by emailed code, insert the team, join as first member. */
+async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive, ask }) {
+  const noJoin = hasFlag('--no-join');
+  const st0 = loadTeamState();
+  if (isJoined(st0) && !noJoin) { console.error(m.alreadyJoined(st0.teamName || '')); return process.exit(1); }
+
+  let email = getArg('--email');
+  let name = getArg('--name');
+  const code = getArg('--code');
+  if (code !== undefined && code !== null && !CODE_RE.test(String(code))) { console.error(m.badCode); return process.exit(2); }
+  if (!email && interactive) email = await ask(m.askEmail);
+  if (!email) { console.error(m.needEmail); return process.exit(2); }
+  if (!EMAIL_RE.test(email)) { console.error(m.badEmail); return process.exit(2); }
+
+  let osName = 'my';
+  try { osName = userInfo().username || 'my'; } catch { /* no passwd entry */ }
+  const defaultName = `${osName}'s team`;
+
+  let useCode = code;
+  if (!useCode) {
+    if (!interactive) {
+      await requestSignInCode({ email, fetch });
+      out(m.codeSent(email));
+      out(m.rerun(email, name || defaultName));
+      return undefined;
+    }
+    await requestSignInCode({ email, fetch });
+    out(m.codeSent(email));
+    useCode = await ask(m.askCode);
+    if (!CODE_RE.test(useCode)) { console.error(m.badCode); return process.exit(2); }
+  }
+  if (!name && interactive) name = (await ask(m.askTeamName(defaultName))) || defaultName;
+  if (!name) { console.error(m.needName); return process.exit(2); }
+
+  const { accessToken, userId } = await verifySignInCode({ email, code: useCode, fetch });
+  const team = await createTeam({ name, accessToken, userId, fetch });
+  out(m.created(team.name || name));
+  out(`${m.inviteToken}: ${team.inviteToken}`);
+  out(`${m.memberCmd}: npm i -g sprag-cli@latest && sprag team join ${team.inviteToken}`);
+  out(`${m.orgLine}: export SPRAG_TEAM_TOKEN=${team.inviteToken}`);
+  out(m.dashboard(email));
+
+  if (noJoin) { out(m.noJoinNote); return undefined; }
+  let display = 'member';
+  try { display = userInfo().username || 'member'; } catch { /* no passwd entry */ }
+  await joinTeam({ token: team.inviteToken, displayName: display, fetch, version });
+  if (!teamSyncDisabled()) {
+    const r = await syncTeam({ force: true, fetch, version });
+    if (r.error) console.error(m.syncFailed(r.error));
+    else if (!r.skipped) out(m.synced(r.uploaded, r.rules));
+  }
+  return undefined;
+}
+
+export async function run({ args, hasFlag, getArg, version, fetch, interactive, ask }) {
+  const m = T[userLanguage()] || T.en;
+  const verb = args[1];
+  const out = (s) => console.log(s);
+
+  try {
+    switch (verb) {
+      case 'create': {
+        const tty = interactive !== undefined ? interactive : !!(process.stdin.isTTY && process.stdout.isTTY);
+        return await createFlow({ m, out, hasFlag, getArg, version, fetch, interactive: tty, ask: ask || prompt });
+      }
+      case 'join': {
+        const token = (args[2] && !args[2].startsWith('--') ? args[2] : null) || process.env.SPRAG_TEAM_TOKEN;
+        if (!token) { console.error(m.noToken); return process.exit(2); }
+        let name = getArg('--name');
+        if (!name) { try { name = userInfo().username; } catch { name = 'member'; } }
+        out(m.willSend);
+        out(m.asName(name));
+        if (!hasFlag('--yes')) {
+          if (!process.stdin.isTTY || !process.stdout.isTTY) { console.error(m.needYes); return process.exit(2); }
+          if (!(await confirm(m.ask))) { out(m.aborted); return undefined; }
+        }
+        const st = await joinTeam({ token, displayName: name, version });
+        out(m.joined(st.teamName));
+        return undefined;
+      }
+      case 'leave':
+        await leaveTeam();
+        out(m.left);
+        return undefined;
+      case 'status': {
+        const st = loadTeamState();
+        if (!isJoined(st)) { out(m.notJoined); return undefined; }
+        out(`${m.team}: ${st.teamName}`);
+        out(`${m.plan}: ${st.plan}`);
+        out(`${m.capture}: ${st.promptCapture ? m.on : m.off}`);
+        out(`${m.name}: ${st.displayName}`);
+        out(st.lastSyncAt ? m.lastSync(new Date(st.lastSyncAt).toLocaleString(), st.lastSyncRows || 0) : m.neverSynced);
+        if (st.lastError) out(`${m.lastError}: ${st.lastError}`);
+        if (hasFlag('--show-payload')) out(JSON.stringify(await aggregateDaily(), null, 2));
+        return undefined;
+      }
+      case 'sync': {
+        if (hasFlag('--background')) {
+          await autoJoin({ version });
+          await syncTeam({ version });
+          return undefined;
+        }
+        const r = await syncTeam({ force: hasFlag('--force'), version });
+        if (hasFlag('--quiet')) return undefined;
+        if (r.error) { console.error(r.error); return process.exit(1); }
+        if (r.skipped) out(r.skipped === 'disabled' ? m.disabled : m.skipped(r.skipped));
+        else out(m.synced(r.uploaded, r.rules));
+        return undefined;
+      }
+      case 'rules': {
+        let cache = null;
+        try { cache = JSON.parse(readFileSync(teamRulesCachePath(), 'utf8')); } catch { /* none cached */ }
+        const rules = cache && Array.isArray(cache.rules) ? cache.rules : [];
+        if (rules.length === 0) { out(m.noRules); return undefined; }
+        for (const r of rules) out(`- [${r.scope}] ${r.text}`);
+        return undefined;
+      }
+      case 'propose': {
+        const text = args.slice(2).filter((a, i, arr) => !a.startsWith('--') && arr[i - 1] !== '--scope').join(' ').trim();
+        if (!text) { console.error(m.needText); return process.exit(2); }
+        const scope = getArg('--scope') || 'ratchet';
+        if (scope !== 'ratchet' && scope !== 'model') { console.error(m.badScope); return process.exit(2); }
+        const st = loadTeamState();
+        if (!isJoined(st)) { console.error(m.needJoin); return process.exit(2); }
+        if (teamSyncDisabled()) { out(m.disabled); return undefined; }
+        const id = await rpc('team_rule_propose', { member_key: st.memberKey, rule_text: text, scope });
+        out(m.proposed(id));
+        return undefined;
+      }
+      default:
+        out(m.usage);
+        return verb && verb !== 'help' ? process.exit(2) : undefined;
+    }
+  } catch (e) {
+    console.error(e.message);
+    return process.exit(1);
+  }
+}

package/src/cost.js

@@ -249,8 +249,11 @@ export function modelRank(model) {
   return rank ?? 1;
 }
 
-/** Price rank each delegation tier targets: T2 → haiku, T1 → sonnet. */
-export const TIER_TARGET_RANK = { T2: 0, T1: 1 };
+/**
+ * Price rank each delegation tier targets: T2 → haiku, T1 → sonnet, T1H → opus.
+ * T1H is worth it only from a rank-3 (Fable/Mythos) session.
+ */
+export const TIER_TARGET_RANK = { T2: 0, T1: 1, T1H: 2 };
 
 /**
  * Which delegation tier a subagent run at this price rank represents.
@@ -260,6 +263,7 @@ export const TIER_TARGET_RANK = { T2: 0, T1: 1 };
 export function tierForRank(rank) {
   if (rank === 0) return 'T2';
   if (rank === 1) return 'T1';
+  if (rank === 2) return 'T1H';
   return null;
 }
 

package/src/cowork-sync.js

@@ -33,6 +33,7 @@ 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 { teamRatchetPath } from './team-ratchet.js';
 import { globalRatchetMdPath } from './harness.js';
 import { debug } from './debug.js';
 
@@ -183,11 +184,11 @@ export const coworkCopyPath = (dir) => join(dir, COPY_REL);
 
 // ---------- content ----------
 
-/** @returns {string|null} null when none of the three source files exists */
+/** @returns {string|null} null when none of the source files exists */
 export function renderCoworkRatchet(lang = userLanguage()) {
   const ko = lang === 'ko';
   const parts = [];
-  for (const file of [modelRatchetPathFor('global'), presetRatchetPath(), globalRatchetMdPath()]) {
+  for (const file of [modelRatchetPathFor('global'), presetRatchetPath(), teamRatchetPath(), globalRatchetMdPath()]) {
     let body;
     try { body = readFileSync(file, 'utf8'); } catch { continue; }
     const name = file.split(/[\\/]/).pop();
@@ -195,8 +196,8 @@ export function renderCoworkRatchet(lang = userLanguage()) {
   }
   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.';
+    ? '이 파일은 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 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')}`;
 }
 

package/src/delegation-agents.js

@@ -28,7 +28,7 @@ const MARK_LINE = `# managed by sprag (${OWNER_MARK}); edits are overwritten`;
 // comparison (lookups, test runs, mechanical conversion) extra thinking buys
 // nothing, so those agents run at low. The worker implements a design the
 // caller already fixed, against tests, so it takes the default for well-specified
-// work, medium. The main session's effort is never touched here, and
+// work, medium; the opus worker takes the larger, harder share of that work at high. The main session's effort is never touched here, and
 // CLAUDE_CODE_EFFORT_LEVEL must stay unset: it overrides every agent's own value.
 export const DEFINITIONS = [
   {
@@ -63,6 +63,18 @@ export const DEFINITIONS = [
     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.',
   },
+  {
+    // The full model id, not the `opus` alias: Claude Code resolves a bare
+    // alias to an older model than the one the tier means (haiku was observed
+    // resolving to Haiku 4.5). A host that remaps ANTHROPIC_DEFAULT_OPUS_MODEL
+    // is better served by the rule's `model: opus` fallback phrase.
+    name: 'opus-worker',
+    model: 'claude-opus-5-5',
+    effort: 'high',
+    tools: 'Read, Grep, Glob, Bash, Edit, Write, NotebookEdit',
+    role: 'Your role: large implementation and debugging work whose design the caller already fixed. Hand design judgement and irreversible actions back to the caller.',
+    description: 'Heavy worker for Fable sessions: large implementation, debugging and refactoring handed over with a fixed design. It has no MCP tools.',
+  },
 ];
 
 function render(def) {

package/src/delegation-guard.js

@@ -123,6 +123,7 @@ export async function buildAppendix(payload, { cfg = loadConfig(), home = homedi
   // because the Korean section below weighs the same answer.
   const modelHint = String(payload?.tool_input?.model || payload?.tool_input?.subagent_type || '');
   const isHaiku = /haiku/i.test(modelHint);
+  const isOpus = /opus/i.test(modelHint);
 
   const bounds = boundsText();
   if (bounds) {
@@ -132,8 +133,8 @@ export async function buildAppendix(payload, { cfg = loadConfig(), home = homedi
     // own calibrated budget for the tier replaces them, so the subagent is told
     // the same limit the main model was (see route-caps.js). A T1 rule sets no
     // call count, and the default one stays in that case.
-    const fallback = isHaiku ? { calls: 8, out: 1500 } : { calls: 20, out: 8000 };
-    const matched = routeCaps?.[isHaiku ? 'T2' : 'T1'];
+    const fallback = isHaiku ? { calls: 8, out: 1500 } : isOpus ? { calls: 20, out: 30000 } : { calls: 20, out: 8000 };
+    const matched = routeCaps?.[isHaiku ? 'T2' : isOpus ? 'T1H' : 'T1'];
     const calls = Number.isFinite(matched?.calls) && matched.calls > 0 ? matched.calls : fallback.calls;
     const out = Number.isFinite(matched?.out) && matched.out > 0 ? matched.out : fallback.out;
     const capLine = `Cap for this delegation: ${calls} tool calls, ${out.toLocaleString('en-US')} output tokens.`;

package/src/harness-templates.js

@@ -52,6 +52,16 @@ export function presetRatchetImportLine() {
 }
 export const PRESET_RATCHET_IMPORT_RE = /^@~\/\.claude\/ratchet-preset\.md\s*$/m;
 
+/**
+ * The team ratchet: rules the user's team approved, cached by `sprag team sync`
+ * and rendered into a tool-owned file. Unlike the others its import is not in
+ * the rendered block; it is added only for members, when the file exists.
+ */
+export function teamRatchetImportLine() {
+  return '@~/.claude/ratchet-team.md';
+}
+export const TEAM_RATCHET_IMPORT_RE = /^@~\/\.claude\/ratchet-team\.md\s*$/m;
+
 /**
  * Render ratchet-preset.md. `rules` is [{ id, text }] in display order. The
  * file is loaded into every session, so the header stays short.

package/src/model-rules.js

@@ -72,7 +72,8 @@ export function wilsonLowerBound(errs, n) {
 // route-scan's pre-calibration defaults. Kept as local constants rather than
 // imported: route-scan imports this module, and a static back-import would
 // close the cycle.
-const DEFAULT_BUDGET = { T2: { calls: 8, out: 1500 }, T1: { calls: null, out: 8000 } };
+const DEFAULT_BUDGET = { T2: { calls: 8, out: 1500 }, T1: { calls: null, out: 8000 },
+  T1H: { calls: null, out: 30000 } };
 
 /** The budget a rule is held to: its calibrated one, or the default of its tier. */
 export function ruleBudget(rule) {
@@ -132,20 +133,27 @@ 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 });
+// 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 });
 }
 
 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.tier === 'T2'
       ? `"${g.label}" 단순 요청(예: "${shortExample(g.example)}")은 ${agentPhrase(g.agent, { root })}에 위임`
       : `"${g.label}" 중간 난도 요청(예: "${shortExample(g.example)}")은 ${t1Target(root, true) ?? 'model: sonnet'}에 위임`;
   }
   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 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'}`;
@@ -275,8 +283,12 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '- **effort**: 모델 티어와 다른 축이다. 설치된 서브에이전트는 검증 형태에 따라',
     '  effort가 고정되어 있다. 명령 출력이나 파일 대조로 검증되는 위임(조회·명령',
     '  실행·정형 변환을 맡는 haiku 에이전트)은 low, 확정된 설계를 테스트에 맞춰',
-    '  구현하는 위임(sonnet 워커)은 medium이다. 메인 세션의 effort는 바꾸지 않고,',
+    '  구현하는 위임(sonnet 워커)은 medium, 범위가 큰 구현·디버깅 위임(opus 워커)은',
+    '  high다. 메인 세션의 effort는 바꾸지 않고,',
     '  CLAUDE_CODE_EFFORT_LEVEL은 서브에이전트의 effort를 덮어쓰므로 설정하지 않는다.',
+    '- **고난도 구현(T1H)**: 설계는 메인이 확정하고, 범위가 크거나 sonnet 이 틀린',
+    '  적 있는 구현·디버깅은 opus 에 위임한다. Fable·Mythos 세션에서만 적용되며,',
+    '  설계 판단과 되돌릴 수 없는 작업은 메인 모델에 남긴다.',
     '- **위임 배치**: 서브에이전트 비용의 지배 항은 생성이 아니라 컨텍스트',
     '  적재다. 같은 파일들을 읽어야 하는 작업 여러 개는 에이전트 하나에 묶어',
     '  보내고, 읽는 영역이 다른 작업만 나눈다.',
@@ -337,8 +349,13 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     '  by how their work is verified: low where the check is command output or a',
     '  file comparison (the haiku agents for lookups, command runs and mechanical',
     '  conversion), medium where a fixed design is implemented against tests (the',
-    '  sonnet worker). Leave the main session\'s effort alone, and never set',
+    '  sonnet worker), high for large implementation or debugging (the opus',
+    '  worker). Leave the main session\'s effort alone, and never set',
     '  CLAUDE_CODE_EFFORT_LEVEL: it overrides every subagent\'s own value.',
+    '- **Heavy implementation (T1H)**: the main model fixes the design; large-scope',
+    '  implementation or debugging, or work sonnet has already got wrong, goes to',
+    '  opus. Applies in Fable/Mythos sessions only; design judgement and',
+    '  irreversible work stay on the main model.',
     '- **Batching**: a subagent\'s dominant cost is context ingestion, not',
     '  generation. Bundle tasks that read the same files into one agent; split',
     '  only when the areas they read differ.',
@@ -384,13 +401,13 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
     const saved = r.savedUsd ? `, saved ~${signedUsd(r.savedUsd)}` : '';
     return `${base}, delegated ×${r.delegatedRuns} err ${pct(r.delegatedErrRate)}%${saved}`;
   };
-  // Merged T2+T1 rules carry two caps, so they state both once rather than
+  // Merged rules carry one cap per tier, so they state them once rather than
   // repeating the whole stop-condition per tier.
-  const mergedBudget = (t2, t1) => ko
-    ? `상한 haiku ${budgetCapPhrase(t2, 'ko')} / sonnet ${budgetCapPhrase(t1, 'ko')}`
-    : `cap haiku ${budgetCapPhrase(t2, 'en')} / sonnet ${budgetCapPhrase(t1, 'en')}`;
+  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(' / ');
 
-  // A category can carry both a T2 (haiku) and a T1 (sonnet) rule. Tier is
+  // A category can carry a T2 (haiku), a T1 (sonnet) and a T1H (opus) rule. Tier is
   // only known after an episode finishes, so two separate bullets give the
   // reading LLM no way to pick one at request time — merge such pairs into a
   // single conditional rule with explicit request-time criteria (default to
@@ -405,38 +422,50 @@ export function renderModelRatchet(rules, lang = userLanguage(), { root } = {})
   // text stored on the rule is whatever wording and language were current when
   // it was promoted, which is how an English line sat in a Korean file. A rule
   // missing what the template needs still falls back to its stored text.
-  const baseTextOf = (r) => ((r.tier === 'T2' || r.tier === 'T1') && r.label && (ko || r.labelEn)
+  const baseTextOf = (r) => ((r.tier === 'T2' || r.tier === 'T1' || r.tier === 'T1H') && r.label && (ko || r.labelEn)
     ? modelRuleBaseText(r, lang, { root }) : r.rule);
+  const DELEGATION_TIERS = ['T2', 'T1', 'T1H'];
   for (const group of byCategory.values()) {
-    const t2 = group.find((r) => r.tier === 'T2');
-    const t1 = group.find((r) => r.tier === 'T1');
+    const picked = DELEGATION_TIERS.map((t) => group.find((r) => r.tier === t)).filter(Boolean);
     // A second rule of a tier the line already covers (two global rules of one
     // category, promoted from different projects) says nothing the line does
     // not, so it adds no line of its own. Its review flag and its numbers stay
     // visible on the line that speaks for it.
-    const extras = t2 || t1 ? group.filter((r) => r !== t2 && r !== t1 && (r.tier === 'T2' || r.tier === 'T1')) : [];
-    const unknown = group.filter((r) => r !== t2 && r !== t1 && !extras.includes(r));
+    const extras = picked.length ? group.filter((r) => !picked.includes(r) && DELEGATION_TIERS.includes(r.tier)) : [];
+    const unknown = group.filter((r) => !picked.includes(r) && !extras.includes(r));
     const extraHealth = extras.map(healthOf).join('');
     const extraStats = extras.map((r) => ` / +${r.tier} ${statsOf(r)}`).join('');
-    if (t2 && t1) {
+    if (picked.length >= 2) {
       // Seeded rules carry a localized example; scan-produced ones only have the
       // user's own prompt, so exampleEn is a preference, not a requirement.
       const ex = (r) => shortExample(ko ? r.example : (r.exampleEn || r.example));
-      // One line per category, stating only what differs between the two tiers.
+      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}`;
+      };
+      // One line per category, stating only what differs between the tiers.
       // The exceptions this used to spell out (design judgement, irreversible
       // work) are identical in every rule and now sit in the header's shared
       // clauses, so a rule the model re-reads on every request is short enough to
       // match at a glance.
+      const when = (r, first) => {
+        if (first) return ko ? '기본' : 'by default';
+        if (r.tier === 'T1H') return ko ? '범위가 크면(Fable·Mythos 세션 한정)' : 'for large scope (Fable/Mythos sessions only)';
+        return ko ? '여러 단계·여러 파일이 얽히면' : 'when it spans multiple steps or file edits';
+      };
+      const parts = picked.map((r, i) => (ko
+        ? `${when(r, i === 0)} ${target(r)}(예: "${ex(r)}")`
+        : `${i === 0 ? `${target(r)} ${when(r, true)}` : `${target(r)} ${when(r, false)}`} (e.g. "${ex(r)}")`));
+      const head = picked[0];
       const rule = ko
-        ? `"${t2.label}": 기본 ${agentPhrase(t2.agent, { root })}(예: "${ex(t2)}"), ` +
-          `여러 단계·여러 파일이 얽히면 ${t1Target(root, true) ?? 'model: sonnet'}(예: "${ex(t1)}"). ` +
-          mergedBudget(t2, t1)
-        : `"${t2.labelEn || t2.label}": ${agentPhraseEn(t2.agent, { root })} by default (e.g. "${ex(t2)}"), ` +
-          `${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) {
-      const r = t2 || t1;
+        ? `"${head.label}": ${parts.join(', ')}. ${mergedBudget(picked)}`
+        : `"${head.labelEn || head.label}": ${parts.join(', ')}. ${mergedBudget(picked)}`;
+      const health = picked.map(healthOf).join('');
+      const stats = picked.map((r) => `${r.tier} ${statsOf(r)}`).join(' / ');
+      lines.push(`- ${rule}${health}${extraHealth} <!-- ${stats}${extraStats} -->`);
+    } else if (picked.length === 1) {
+      const r = picked[0];
       lines.push(`- ${composeRuleText(baseTextOf(r), r, lang)}${healthOf(r)}${extraHealth} <!-- ${statsOf(r)}${extraStats} -->`);
     }
     for (const r of unknown) lines.push(`- ${composeRuleText(r.rule, r, lang)}${healthOf(r)} <!-- ${statsOf(r)} -->`);

package/src/route-caps.js

@@ -13,7 +13,7 @@
  * rule clears it, so a cap never outlives the turn it was stated for.
  *
  * State: <stateDir>/route-caps.json
- *   { sessions: { [session_id]: { ts, T2?: { calls, out }, T1?: { calls, out } } } }
+ *   { sessions: { [session_id]: { ts, T2?: { calls, out }, T1?: { calls, out }, T1H?: { calls, out } } } }
  */
 
 import { readFileSync } from 'node:fs';
@@ -49,7 +49,7 @@ export function recordRouteCaps(sessionId, caps, now = Date.now()) {
   if (typeof sessionId !== 'string' || sessionId === '') return false;
   const state = load();
   const next = {};
-  for (const tier of ['T2', 'T1']) {
+  for (const tier of ['T2', 'T1', 'T1H']) {
     if (validBudget(caps?.[tier])) next[tier] = { calls: caps[tier].calls ?? null, out: caps[tier].out };
   }
   const has = Object.keys(next).length > 0;
@@ -69,6 +69,6 @@ export function routeCapsFor(sessionId, now = Date.now()) {
   const s = load().sessions[sessionId];
   if (!s || !Number.isFinite(s.ts) || now - s.ts > TTL_MS) return null;
   const out = {};
-  for (const tier of ['T2', 'T1']) if (validBudget(s[tier])) out[tier] = s[tier];
+  for (const tier of ['T2', 'T1', 'T1H']) if (validBudget(s[tier])) out[tier] = s[tier];
   return Object.keys(out).length ? out : null;
 }