sprag-cli 3.68.0 → 3.70.0

package/src/codex/route-scan.js

@@ -92,7 +92,9 @@ function pickTarget(group, { prices, known, home }) {
     .sort((a, b) => a.usd - b.usd);
   const eligible = cheaper.filter((x) => known.has(`${group.provider}|${x.model}`));
   // Simple work goes to the cheapest model; moderate work steps down one notch.
-  const pick = group.tiers.T2 >= group.tiers.T1 ? eligible[0] : eligible.at(-1);
+  // The heaviest band goes to the most expensive cheaper model (the T1H target).
+  const { T2, T1, T1H } = group.tiers;
+  const pick = T2 >= T1 && T2 >= T1H ? eligible[0] : eligible.at(-1);
   return {
     suggestedModel: pick?.model ?? null,
     alternatives: pick ? [] : cheaper.slice(0, 3).map((x) => x.model),
@@ -135,10 +137,10 @@ export async function runCodexRouteScan({ days = 14, now = Date.now(), home, dir
     const runtime = codexPromptCategory(ep.text);
     if (!runtime || !categorize(ep.text, ep.tools)) continue;
     const tier = tierOf(ep, runtime, thresholds);
-    if (tier !== 'T1' && tier !== 'T2') continue;
+    if (tier !== 'T1' && tier !== 'T2' && tier !== 'T1H') continue;
     const key = `${runtime.id}|${ep.provider}|${ep.model}|${ep.projectRoot}`;
     const g = groups.get(key) || { signature: key, category: runtime.id, label: runtime.label, labelEn: runtime.labelEn,
-      from: ep.model, provider: ep.provider, projectRoot: ep.projectRoot, count: 0, tiers: { T1: 0, T2: 0 }, example: ep.text,
+      from: ep.model, provider: ep.provider, projectRoot: ep.projectRoot, count: 0, tiers: { T1: 0, T2: 0, T1H: 0 }, example: ep.text,
       tokens: { input: 0, cached: 0, cacheWrite: 0, output: 0 }, lastSeen: 0 };
     g.count++;
     g.tiers[tier]++;
@@ -154,7 +156,7 @@ export async function runCodexRouteScan({ days = 14, now = Date.now(), home, dir
         (!r.provider || r.provider === g.provider) &&
         (r.scope === 'global' || r.targetRoot === g.projectRoot))) return true;
     const shared = sharedCodexModelRules({ cfg, dir, root: g.projectRoot, model: g.from, provider: g.provider });
-    return ['T1', 'T2'].every((tier) => !g.tiers[tier] || shared.some((r) => r.category === g.category && r.tier === tier));
+    return ['T1', 'T2', 'T1H'].every((tier) => !g.tiers[tier] || shared.some((r) => r.category === g.category && r.tier === tier));
   };
   const known = new Set([...observed, ...rules.filter((r) => r.provider).map((r) => `${r.provider}|${r.model}`)]);
   const target = cfg?.codex?.delegateTarget?.model;

package/src/commands/codex-delegate.js

@@ -43,7 +43,7 @@ function printShared(cfg, { details = false } = {}) {
   if (missing.length) {
     console.log(`Unmapped tiers for ${parent || 'any parent model'} on ${provider || 'unknown provider'}: ${missing.join(', ')}`
       + `${autoOn && auto.reason ? ` (auto: ${auto.reason})` : ''}. `
-      + `Set: sprag delegate shared map <T1|T2> --from ${parent || '<parent-model>'} --model <target-model> --agent codex`);
+      + `Set: sprag delegate shared map <T1|T1H|T2> --from ${parent || '<parent-model>'} --model <target-model> --agent codex`);
   }
   console.log(`Automatic tier models: ${autoOn ? 'on' : 'off'} (turn ${autoOn ? 'off' : 'on'}: sprag delegate shared auto ${autoOn ? 'off' : 'on'} --agent codex)`);
   if (!parent && targets.length) console.log('Codex config names no default model; each mapping routes only sessions on its --from model.');
@@ -74,7 +74,7 @@ export function run({ args, getArg, hasFlag, root }) {
   if (sub === 'shared') {
     const action = args[2] || 'status';
     if (!['status', 'on', 'off', 'map', 'unmap', 'min-context', 'auto'].includes(action)) {
-      throw new Error('Usage: delegate shared status|on|off|map <T1|T2>|unmap <T1|T2>|min-context <tokens|default>|auto on|off --agent codex');
+      throw new Error('Usage: delegate shared status|on|off|map <T1|T1H|T2>|unmap <T1|T1H|T2>|min-context <tokens|default>|auto on|off --agent codex');
     }
     if (hasFlag('--global') || hasFlag('--project')) throw new Error('Shared policies retain their approved scope; mappings do not change it.');
     const provided = (flag) => args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
@@ -86,7 +86,7 @@ export function run({ args, getArg, hasFlag, root }) {
       const tier = args[3];
       const from = getArg('--from');
       const provider = getArg('--provider') ?? codexProviderName();
-      if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1 or T2.');
+      if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1, T1H or T2.');
       const same = (t) => t.tier === tier && t.from === from && t.provider === provider;
       if (action === 'map') {
         const target = validateCodexSharedTarget({ tier, from, provider, model: getArg('--model'), effort: getArg('--effort') });

package/src/commands/codex.js

@@ -30,9 +30,9 @@ Usage: sprag <command> --agent codex [options]
   delegate implementation       After design: resolve T1 with --from, --provider, --session
   delegate rules                Codex rules and shared delegation policies
   delegate shared on|off|status  Reuse approved policies; keep original scopes
-  delegate shared map T1|T2     Map a tier: --from <parent> --model <target>
+  delegate shared map T1|T1H|T2 Map a tier: --from <parent> --model <target>
                                 Optional --provider <id> and --effort <level>
-  delegate shared unmap T1|T2   Remove a mapping: --from <parent> [--provider <id>]
+  delegate shared unmap T1|T1H|T2 Remove a mapping: --from <parent> [--provider <id>]
   delegate shared min-context N Parent input tokens before shared guidance; default resets
   delegate shared auto on|off   Resolve unmapped tiers from priced models already run in Codex
   route-scan [--refresh]         Discover recurring simple turns in local logs
@@ -202,7 +202,7 @@ export async function run({ args, version }) {
     for (const c of open) {
       const target = c.suggestedModel ? `-> ${c.suggestedModel}${Number.isFinite(c.estSavedUsd) ? ` (~${signedUsd(c.estSavedUsd, 4)} over ${c.count} turns)` : ''}`
         : `-> choose --model${c.alternatives.length ? ` (priced cheaper: ${c.alternatives.join(', ')})` : ''}`;
-      console.log(`R${c.id} ${c.category} x${c.count} [T2 ${c.tiers.T2} / T1 ${c.tiers.T1}] ${c.provider || 'unknown provider'} / ${c.from} ${target}`);
+      console.log(`R${c.id} ${c.category} x${c.count} [T2 ${c.tiers.T2} / T1 ${c.tiers.T1} / T1H ${c.tiers.T1H ?? 0}] ${c.provider || 'unknown provider'} / ${c.from} ${target}`);
       console.log(`   ${c.projectRoot}`);
       console.log(`   e.g. ${JSON.stringify(c.example)}`);
     }

package/src/commands/harness.js

@@ -255,7 +255,7 @@ export async function run({ args, hasFlag }) {
           example: routeCandidate.example,
           count: routeCandidate.count,
           // Calibrated budget snapshot — ratchet-model.md restates it when it
-          // merges a category's T2 and T1 rules into one conditional rule.
+          // merges a category's T2, T1 and T1H rules into one conditional rule.
           budget: routeCandidate.budget || null,
           promotedAt: new Date().toISOString().slice(0, 10),
           lastSeen: new Date().toISOString().slice(0, 10),

package/src/commands/route-scan.js

@@ -303,6 +303,17 @@ export async function run({ args, hasFlag, numArg }) {
       // 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); }
+      // Team layer (opt-in): re-render the team ratchet file from the cached rules,
+      // keep the CLAUDE.md import in step with the file, and kick the detached sync
+      // when it is due. Nothing here touches the network.
+      let teamBlock = null;
+      try {
+        const tr = await import('../team-ratchet.js');
+        tr.syncTeamRatchet({ lang });
+        tr.ensureTeamImport();
+        tr.spawnTeamSyncIfDue();
+        teamBlock = tr.autoJoinNoticeBlock(undefined, lang);
+      } catch (e) { debug('route-scan:team', 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
@@ -375,6 +386,7 @@ export async function run({ args, hasFlag, numArg }) {
       } catch (e) { debug('route-scan:update-check', e); /* the offer is optional */ }
 
       if (open.length === 0 && reviewRules.length === 0) {
+        if (teamBlock) console.log(teamBlock);
         if (updateBlock) console.log(updateBlock);
         if (seedBlock) console.log(seedBlock);
         if (doc2mdBlock) console.log(doc2mdBlock);
@@ -382,6 +394,7 @@ export async function run({ args, hasFlag, numArg }) {
         if (cohesionBlock) console.log(cohesionBlock);
         return; // nothing else to inject
       }
+      if (teamBlock) console.log(teamBlock);
       if (updateBlock) console.log(updateBlock);
       if (seedBlock) console.log(seedBlock);
       if (doc2mdBlock) console.log(doc2mdBlock);
@@ -392,10 +405,10 @@ export async function run({ args, hasFlag, numArg }) {
       if (open.length > 0) {
         if (lang === 'ko') {
           lines.push(`[sprag route-scan] 최근 ${cache.days}일 세션에서 비싼 모델(opus/fable)이 반복 처리해 온, 더 싼 모델로 넘겨도 되는 작업이 감지되었습니다.`);
-          lines.push('(R<N>은 후보 번호, T2/T1은 난이도 등급입니다 — 사용자에게 전달할 때는 코드가 아니라 아래 풀어쓴 설명으로 브리핑하세요)');
+          lines.push('(R<N>은 후보 번호, T2/T1/T1H는 난이도 등급입니다 — 사용자에게 전달할 때는 코드가 아니라 아래 풀어쓴 설명으로 브리핑하세요)');
         } else {
           lines.push(`[sprag route-scan] Over the last ${cache.days} days, expensive models (opus/fable) repeatedly handled work that a cheaper model could take.`);
-          lines.push('(R<N> is the candidate id, T2/T1 the difficulty tier — brief the user with the spelled-out wording below, not the codes.)');
+          lines.push('(R<N> is the candidate id, T2/T1/T1H the difficulty tier — brief the user with the spelled-out wording below, not the codes.)');
         }
         for (const c of open) {
           const tier = c.tier || 'T2';
@@ -490,7 +503,7 @@ export async function run({ args, hasFlag, numArg }) {
       (await import('../first-run-note.js')).printOnce('route-scan', lang);
       return;
     }
-    console.log(lang === 'ko' ? '\n위임 후보 (R<N>=후보 번호, T2/T1=난이도 등급):' : '\nDelegation candidates (R<N> = candidate id, T2/T1 = difficulty tier):');
+    console.log(lang === 'ko' ? '\n위임 후보 (R<N>=후보 번호, T2/T1/T1H=난이도 등급):' : '\nDelegation candidates (R<N> = candidate id, T2/T1/T1H = difficulty tier):');
     for (const c of open) {
       const tier = c.tier || 'T2';
       if (lang === 'ko') {

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

@@ -22,10 +22,19 @@ 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.
+//
+// Effort is a separate axis from the tier and is set by how the work gets
+// verified, not by how hard it is. Where the check is command output or a file
+// 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 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 = [
   {
     name: 'haiku-explore',
     model: 'haiku',
+    effort: 'low',
     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.',
@@ -33,6 +42,7 @@ export const DEFINITIONS = [
   {
     name: 'haiku-runner',
     model: 'haiku',
+    effort: 'low',
     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.',
@@ -40,6 +50,7 @@ export const DEFINITIONS = [
   {
     name: 'haiku-translate',
     model: 'haiku',
+    effort: 'low',
     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.',
@@ -47,10 +58,23 @@ export const DEFINITIONS = [
   {
     name: 'sonnet-worker',
     model: 'sonnet',
+    effort: 'medium',
     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.',
   },
+  {
+    // 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) {
@@ -60,6 +84,7 @@ function render(def) {
     `description: ${def.description}`,
     `tools: ${def.tools}`,
     `model: ${def.model}`,
+    `effort: ${def.effort}`,
     MARK_LINE,
     '---',
     def.role,

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/first-run-note.js

@@ -34,6 +34,22 @@ function markShown(key, now) {
   writeFileSync(firstRunStatePath(), JSON.stringify(state) + '\n');
 }
 
+/** When `key` was marked shown (epoch ms), or null. For notes that stay
+ *  visible for a window after the first time instead of printing once. */
+export function noteShownAt(key) {
+  const at = Number(load()[key]);
+  return Number.isFinite(at) && at > 0 ? at : null;
+}
+
+/** Persist `key` as shown at `now`. Best-effort, like `shouldShowOnce`. */
+export function markNoteShown(key, now = Date.now()) {
+  try {
+    markShown(key, now);
+  } catch {
+    /* state dir unwritable — the note may show again, never a failure */
+  }
+}
+
 /** True only the first time this key is asked about. Best-effort — a
  *  read-only state dir just means the note repeats, never that we crash. */
 export function shouldShowOnce(key, { now = Date.now() } = {}) {