sprag-cli 3.69.0 → 3.71.0

package/src/commands/team.js

@@ -0,0 +1,334 @@
+/**
+ * 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 { pendingPrompts } from '../team-prompts.js';
+import {
+  loadTeamState, deviceInfo, isJoined, joinTeam, leaveTeam, syncTeam, autoJoin, aggregateDaily, rpc,
+  teamRulesCachePath, teamSyncDisabled, requestSignInCode, verifySignInCode, createTeam, isSeatLimitError,
+} from '../team-sync.js';
+
+const T = {
+  en: {
+    usage: [
+      'Usage: sprag team <command>',
+      '  create [--email <e>] [--name <n>] [--code <6 digits>] [--org <org-id>] [--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] [--rules-only]        upload aggregates, prompts (Enterprise capture) and pull rules now',
+      '                                       (--rules-only: pull organization and team rules only, upload nothing)',
+      '  rules                                show cached organization and 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`,
+    seatLimit: 'This organization has no free seat. Ask your organization owner or admin to add seats, then join again.',
+    org: 'Organization',
+    seats: (u, l) => `${u}/${l} seats used`,
+    orgCreated: (n, u, l) => `Organization: ${n}${u != null && l != null ? ` (${u}/${l} seats used)` : ''}`,
+    badOrg: '--org needs an organization id.',
+    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',
+    lastPrompts: (t, n) => `Last prompt upload: ${t} (${n} prompts)`,
+    noPrompts: 'Last prompt upload: never',
+    pendingPrompts: (n) => `Prompts waiting to upload: ${n}`,
+    pendingExample: (e) => `Example (redacted): ${e.at} · ${e.project || '-'} · ${e.text}`,
+    disabled: 'Team sync is disabled (SPRAG_NO_TEAM_SYNC=1).',
+    skipped: (s) => `Skipped: ${s}`,
+    synced: (u, r, p) => `Synced: ${u} day rows uploaded, ${r} rules${p ? `, ${p} prompts` : ''}.`,
+    rulesPulled: (r) => `Rules updated: ${r} organization and team rules. A new session applies them.`,
+    noRules: 'No organization or 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자리>] [--org <조직 ID>] [--no-join]   팀 만들기 (만든 사람이 조직 오너)',
+      '  join [토큰] [--name <이름>] [--yes]   팀에 참여 (토큰 또는 SPRAG_TEAM_TOKEN)',
+      '  leave                                  팀에서 나가고 업로드 중단',
+      '  status [--show-payload]                참여 상태, 마지막 동기화, 보내는 내용',
+      '  sync [--force] [--rules-only]          지금 집계를 올리고 규칙을 받기',
+      '                                         (--rules-only: 조직·팀 규칙만 받고 아무것도 올리지 않음)',
+      '  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`,
+    seatLimit: '이 조직에 남은 좌석이 없습니다. 조직 오너나 어드민에게 좌석 추가를 요청한 뒤 다시 참여하세요',
+    org: '조직',
+    seats: (u, l) => `좌석 ${u}/${l} 사용 중`,
+    orgCreated: (n, u, l) => `조직: ${n}${u != null && l != null ? ` (좌석 ${u}/${l} 사용 중)` : ''}`,
+    badOrg: '--org 에는 조직 ID 가 필요합니다',
+    left: '팀에서 나왔습니다. 이제 아무것도 업로드하지 않습니다.',
+    notJoined: '참여한 팀이 없습니다. 참여하려면: sprag team join <토큰>',
+    team: '팀', plan: '플랜', capture: '프롬프트 수집', name: '표시 이름',
+    lastSync: (t, n) => `마지막 동기화: ${t} (${n}행)`,
+    neverSynced: '마지막 동기화: 아직 없음',
+    lastError: '마지막 오류',
+    on: '켜짐', off: '꺼짐',
+    lastPrompts: (t, n) => `마지막 프롬프트 업로드: ${t} (${n}건)`,
+    noPrompts: '마지막 프롬프트 업로드: 아직 없음',
+    pendingPrompts: (n) => `업로드 대기 중인 프롬프트: ${n}건`,
+    pendingExample: (e) => `예시 (비밀값 가림): ${e.at} · ${e.project || '-'} · ${e.text}`,
+    disabled: '팀 동기화가 꺼져 있습니다 (SPRAG_NO_TEAM_SYNC=1).',
+    skipped: (s) => `건너뜀: ${s}`,
+    synced: (u, r, p) => `동기화 완료: ${u}일치 집계 업로드, 규칙 ${r}개${p ? `, 프롬프트 ${p}건` : ''}.`,
+    rulesPulled: (r) => `규칙을 받았습니다: 조직·팀 규칙 ${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}`,
+  },
+};
+
+/**
+ * `sprag team rules` lines: `- [org · model] text`, organization rules first.
+ * Rows without a level (older servers) are team rules. Removed ids are skipped.
+ */
+export function formatRuleLines(cache) {
+  const removed = new Set(Array.isArray(cache?.removed) ? cache.removed : []);
+  const rules = (Array.isArray(cache?.rules) ? cache.rules : [])
+    .filter((r) => r && typeof r.text === 'string' && r.text.trim() && !removed.has(r.id));
+  const org = rules.filter((r) => r.level === 'org');
+  const team = rules.filter((r) => r.level !== 'org');
+  return [...org, ...team].map((r) =>
+    `- [${r.level === 'org' ? 'org' : 'team'} · ${r.scope === 'model' ? 'model' : 'ratchet'}] ${r.text.trim().replace(/\s*\n\s*/g, ' ')}`);
+}
+
+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); }
+
+  const org = getArg('--org');
+  if (hasFlag('--org') && (!org || org.startsWith('--'))) { console.error(m.badOrg); return process.exit(2); }
+  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, orgId: org || null, fetch });
+  out(m.created(team.name || name));
+  if (team.orgName && noJoin) out(m.orgCreated(team.orgName, null, null));
+  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 */ }
+  const joined = await joinTeam({ token: team.inviteToken, displayName: display, fetch, version });
+  if (joined.orgName && joined.seatsUsed != null && joined.seatLimit != null) out(m.orgCreated(joined.orgName, joined.seatsUsed, joined.seatLimit));
+  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, r.prompts));
+  }
+  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));
+        if (st.orgName && st.seatsUsed != null && st.seatLimit != null) out(m.orgCreated(st.orgName, st.seatsUsed, st.seatLimit));
+        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}`);
+        if (st.orgName) out(`${m.org}: ${st.orgName}`);
+        out(`${m.plan}: ${st.plan}`);
+        out(`${m.capture}: ${st.promptCapture ? m.on : m.off}`);
+        if (st.promptCapture) {
+          out(st.lastPromptUploadAt ? m.lastPrompts(new Date(st.lastPromptUploadAt).toLocaleString(), st.lastPromptCount || 0) : m.noPrompts);
+        }
+        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(`device: ${JSON.stringify(st.deviceInfo || deviceInfo())}`);
+          out(JSON.stringify(await aggregateDaily(), null, 2));
+          if (st.promptCapture) {
+            const pend = await pendingPrompts();
+            out(m.pendingPrompts(pend.count));
+            if (pend.example) out(m.pendingExample(pend.example));
+          }
+        }
+        return undefined;
+      }
+      case 'sync': {
+        const rulesOnly = hasFlag('--rules-only');
+        if (hasFlag('--background')) {
+          if (!hasFlag('--prompts-only') && !rulesOnly) await autoJoin({ version });
+          await syncTeam({ version, promptsOnly: hasFlag('--prompts-only'), rulesOnly });
+          return undefined;
+        }
+        // Run by hand, --rules-only always pulls (no hourly gate).
+        const r = await syncTeam({ force: hasFlag('--force') || rulesOnly, rulesOnly, 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 if (r.rulesOnly) out(m.rulesPulled(r.rules));
+        else out(m.synced(r.uploaded, r.rules, r.prompts));
+        return undefined;
+      }
+      case 'rules': {
+        let cache = null;
+        try { cache = JSON.parse(readFileSync(teamRulesCachePath(), 'utf8')); } catch { /* none cached */ }
+        if (formatRuleLines(cache).length === 0) { out(m.noRules); return undefined; }
+        for (const line of formatRuleLines(cache)) out(line);
+        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(isSeatLimitError(e) ? m.seatLimit : e.message);
+    return process.exit(1);
+  }
+}

package/src/commands/update-check.js

@@ -46,8 +46,8 @@ export async function run({ hasFlag, version, agent = 'claude' }) {
 
   if (updateCheckDisabled()) {
     console.log(lang === 'ko'
-      ? `현재 버전 v${version} — 업데이트 확인이 환경 변수로 꺼져 있습니다 (CTS_NO_UPDATE_CHECK / NO_UPDATE_NOTIFIER).`
-      : `v${version} — update checks are disabled by env var (CTS_NO_UPDATE_CHECK / NO_UPDATE_NOTIFIER).`);
+      ? `현재 버전 v${version} — 업데이트 확인이 환경 변수로 꺼져 있습니다 (SPRAG_NO_UPDATE_CHECK / NO_UPDATE_NOTIFIER).`
+      : `v${version} — update checks are disabled by env var (SPRAG_NO_UPDATE_CHECK / NO_UPDATE_NOTIFIER).`);
     return;
   }
 

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/debug.js

@@ -7,12 +7,13 @@
  * a genuinely broken path (bad permissions on the state dir, a corrupt hook
  * payload) is indistinguishable from "nothing to do".
  *
- * `CTS_DEBUG=1` makes those swallowed failures visible on stderr — which the
+ * `SPRAG_DEBUG=1` makes those swallowed failures visible on stderr — which the
  * statusline contract discards and hooks surface in Claude Code's debug
  * output — without changing behavior in any way.
  */
 
-const ENABLED = !!process.env.CTS_DEBUG;
+import { envVar } from './env.js';
+const ENABLED = !!envVar('DEBUG');
 
 /**
  * @param {string} scope short label for where the failure happened

package/src/delegation-agents.js

@@ -12,74 +12,50 @@
  * that marker are ever overwritten or deleted; a same-named user file is left.
  */
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { claudeUserDir } from './paths.js';
 import { loadConfig } from './config.js';
+import { agentDefinitions } from './presets-source.js';
 
 export const OWNER_MARK = 'sprag:delegation-agent';
 const MARK_LINE = `# managed by sprag (${OWNER_MARK}); edits are overwritten`;
 
+// The definitions come from presets-source.js: the centrally published bundle
+// when it verifies, else presets/agents.json. Both have one shape:
+//   { name, model, effort, tools: [..], description: { ko, en }, body: { ko, en } }
+//
 // Models are aliases on purpose: behind a gateway they resolve through
-// ANTHROPIC_DEFAULT_*_MODEL, and a full model id would bypass that mapping.
+// ANTHROPIC_DEFAULT_*_MODEL, and a full model id would bypass that mapping. The
+// exception is opus-worker, which names the full id: Claude Code resolves a bare
+// alias to an older model than the one the tier means.
 //
 // Effort is a separate axis from the tier and is set by how the work gets
 // 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 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 = [
-  {
-    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.',
-  },
-  {
-    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.',
-  },
-  {
-    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.',
-  },
-  {
-    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 files are rendered from the English copy. They are prompts the model
+// reads, and the Korean copy is what the /ops console shows beside it.
+export function definitions() {
+  return agentDefinitions();
+}
 
 function render(def) {
+  const body = String((def.body && def.body.en) || '').replace(/\s+$/, '');
   return [
     '---',
     `name: ${def.name}`,
-    `description: ${def.description}`,
-    `tools: ${def.tools}`,
+    `description: ${(def.description && def.description.en) || ''}`,
+    `tools: ${(Array.isArray(def.tools) ? def.tools : [def.tools]).join(', ')}`,
     `model: ${def.model}`,
     `effort: ${def.effort}`,
     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.',
+    body,
     '',
   ].join('\n');
 }
@@ -98,13 +74,27 @@ function readOwned(path) {
   try { return { text: readFileSync(path, 'utf8') }; } catch { return null; }
 }
 
+/** Names of the files in the agents dir that carry our marker. */
+function ownedNames() {
+  let entries = [];
+  try { entries = readdirSync(agentsDir()); } catch { return []; }
+  const out = [];
+  for (const e of entries) {
+    if (!e.endsWith('.md')) continue;
+    const f = readOwned(join(agentsDir(), e));
+    if (f && isOwned(f.text)) out.push(e.slice(0, -3));
+  }
+  return out;
+}
+
 export function removeDelegationAgents() {
   const removed = [];
-  for (const def of DEFINITIONS) {
-    const p = fileOf(def.name);
+  const names = new Set([...definitions().map((d) => d.name), ...ownedNames()]);
+  for (const name of names) {
+    const p = fileOf(name);
     try {
       const f = readOwned(p);
-      if (f && isOwned(f.text)) { unlinkSync(p); removed.push(def.name); }
+      if (f && isOwned(f.text)) { unlinkSync(p); removed.push(name); }
     } catch { /* one file failing does not stop the rest */ }
   }
   return { written: [], unchanged: [], skipped: [], removed };
@@ -116,7 +106,8 @@ export function syncDelegationAgents({ agent = 'claude' } = {}) {
   try {
     if (loadConfig().delegationAgents === false) return removeDelegationAgents();
   } catch { /* an unreadable config means the default, on */ }
-  for (const def of DEFINITIONS) {
+  const defs = definitions();
+  for (const def of defs) {
     try {
       const p = fileOf(def.name);
       const want = render(def);
@@ -131,13 +122,22 @@ export function syncDelegationAgents({ agent = 'claude' } = {}) {
       res.skipped.push({ name: def.name, reason: `error: ${e.message}` });
     }
   }
+  // An agent the published presets dropped or renamed: its old file is ours
+  // (the marker says so) and nothing names it any more.
+  if (defs.length > 0) {
+    const keep = new Set(defs.map((d) => d.name));
+    for (const name of ownedNames()) {
+      if (keep.has(name)) continue;
+      try { unlinkSync(fileOf(name)); res.removed.push(name); } catch { /* left for the next sync */ }
+    }
+  }
   return res;
 }
 
 export function delegationAgentStatus() {
   let enabled = true;
   try { enabled = loadConfig().delegationAgents !== false; } catch { /* default on */ }
-  const agents = DEFINITIONS.map((def) => {
+  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 };

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/doc2md.cjs

@@ -28,6 +28,7 @@ const path = require('node:path');
 const crypto = require('node:crypto');
 const { spawn, spawnSync } = require('node:child_process');
 const ledger = require('./doc2md-ledger.cjs');
+const { envVar } = require('./env.cjs');
 
 // Formats where the original is of no use to the model. Images are absent
 // deliberately: markitdown returns nothing for them, and OCR misread resource
@@ -247,7 +248,7 @@ const IS_WINDOWS = process.platform === 'win32';
  */
 function interpreterCandidates() {
   const out = [];
-  if (process.env.CTS_DOC2MD_PYTHON) out.push({ bin: process.env.CTS_DOC2MD_PYTHON, args: [] });
+  if (envVar('DOC2MD_PYTHON')) out.push({ bin: envVar('DOC2MD_PYTHON'), args: [] });
   // The tool's own venv, created by `doc2md install-converter`. First because
   // it is the only one this tool controls: telling people to `pip install`
   // into the system interpreter is how a token-saving CLI ends up owning a
@@ -477,7 +478,7 @@ function convert(filePath, { converter = CONVERTER, python: pythonOverride = nul
     // The .fig parser is an npm install of a few hundred KB, fast enough to
     // wait for inline the first time a Figma file turns up.
     if (!result.ok && result.reason === 'no-figparser'
-        && process.env.CTS_DOC2MD_NO_AUTOINSTALL !== '1') {
+        && envVar('DOC2MD_NO_AUTOINSTALL') !== '1') {
       fig2md.installFigParser(userDataDir());
       result = spawnFigConvert(fig2md, filePath);
     }
@@ -565,7 +566,7 @@ function convert(filePath, { converter = CONVERTER, python: pythonOverride = nul
  * Returns true when a converter is ready to use right now.
  */
 function ensureConverterInstalled({ waitMs = 15_000 } = {}) {
-  if (process.env.CTS_DOC2MD_NO_AUTOINSTALL === '1') return false;
+  if (envVar('DOC2MD_NO_AUTOINSTALL') === '1') return false;
   if (findInterpreter()) return true;
 
   const lock = path.join(userDataDir(), 'doc2md-install.lock');

package/src/env.cjs

@@ -0,0 +1,7 @@
+'use strict';
+// CommonJS twin of src/env.js. Keep the two identical in behaviour;
+// test/env.test.js pins them together.
+function envVar(name, env = process.env) {
+  return env['SPRAG_' + name] ?? env['CTS_' + name];
+}
+module.exports = { envVar };