sprag-cli 3.70.0 → 3.72.0

package/src/commands/presets.js

@@ -0,0 +1,158 @@
+/**
+ * Subcommand: presets — which presets this machine uses, and fetching them.
+ *
+ *   sprag presets [status]        source, version, fetch times, signing key, next check
+ *   sprag presets sync [--force]  fetch the published bundle now (read-only)
+ *   sprag presets show [--json]   the effective ratchet, model-routing and agent presets
+ *
+ * The published bundle comes from the /ops console and applies only when its
+ * signature verifies; otherwise the presets bundled with this version are used.
+ */
+
+const REASONS = {
+  en: {
+    'no-cache': 'no published bundle has been fetched yet',
+    disabled: 'remote presets are off (SPRAG_NO_PRESET_SYNC=1 or SPRAG_NO_UPDATE_CHECK=1)',
+    'no-keys': 'no signing keys yet: this version ships no public key, so a published bundle is not applied',
+    unsigned: 'the published bundle is not signed',
+    'unknown-kid': 'the bundle is signed with a key this version does not know',
+    'bad-sig': 'the signature does not match the bundle',
+    'min-cli': 'the bundle needs a newer sprag (min_cli)',
+    format: 'the bundle format is newer than this version understands',
+    shape: 'the bundle is malformed',
+    'too-large': 'the bundle is larger than 200 KB',
+    older: 'the bundle is older than the one already in use',
+  },
+  ko: {
+    'no-cache': '아직 받아 온 게시 번들이 없습니다',
+    disabled: '원격 프리셋이 꺼져 있습니다 (SPRAG_NO_PRESET_SYNC=1 또는 SPRAG_NO_UPDATE_CHECK=1)',
+    'no-keys': '아직 서명 키가 없습니다. 이 버전에 공개 키가 들어 있지 않아 게시 번들을 적용하지 않습니다',
+    unsigned: '게시 번들에 서명이 없습니다',
+    'unknown-kid': '이 버전이 모르는 키로 서명된 번들입니다',
+    'bad-sig': '서명이 번들 내용과 맞지 않습니다',
+    'min-cli': '더 새 버전의 sprag 가 필요한 번들입니다 (min_cli)',
+    format: '이 버전이 읽지 못하는 새 번들 형식입니다',
+    shape: '번들 형식이 잘못됐습니다',
+    'too-large': '번들이 200 KB 를 넘습니다',
+    older: '이미 쓰고 있는 번들보다 오래된 번들입니다',
+  },
+};
+
+function when(ms) {
+  if (!ms) return null;
+  const d = new Date(ms);
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+export async function run({ args, hasFlag }) {
+  const sub = args[1] || 'status';
+  const { userLanguage } = await import('../config.js');
+  const ko = userLanguage() === 'ko';
+  const R = REASONS[ko ? 'ko' : 'en'];
+  const why = (r) => R[r] || r;
+  const src = await import('../presets-source.js');
+  const sync = await import('../preset-sync.js');
+  const { PRESET_SIGNING_KEYS } = await import('../preset-sign.js');
+
+  if (sub === 'sync') {
+    const res = await sync.syncPresets({ force: hasFlag('--force') });
+    if (hasFlag('--background')) return;
+    const v = res.version ? `v${res.version}` : '';
+    const lines = {
+      disabled: ko ? `받지 않았습니다. ${R.disabled}` : `Not fetched: ${R.disabled}`,
+      none: ko ? '서버에 게시된 프리셋 번들이 없습니다. 패키지에 들어 있는 프리셋을 씁니다' : 'Nothing is published on the server. The bundled presets stay in use.',
+      current: ko ? `이미 최신입니다 (${v})` : `Already current (${v}).`,
+      updated: ko ? `${v} 을 받았습니다. 다음 세션부터 적용됩니다` : `Fetched ${v}. It applies from the next session start.`,
+      rejected: ko ? `${v} 을 받았지만 적용하지 않습니다. ${why(res.reason)}` : `Fetched ${v} but did not apply it: ${why(res.reason)}.`,
+      error: ko ? `가져오지 못했습니다 (${res.reason}). 패키지에 들어 있는 프리셋을 계속 씁니다` : `Could not fetch (${res.reason}). The presets in use stay as they are.`,
+    };
+    console.log(lines[res.status] || res.status);
+    if (res.status === 'error') process.exitCode = 1;
+    return;
+  }
+
+  if (sub === 'show') {
+    const out = {
+      source: src.presetSource(),
+      ratchet_rules: src.ratchetPresetEntries(),
+      model_rules: src.modelPresets(),
+      agents: src.agentDefinitions(),
+    };
+    if (hasFlag('--json')) { console.log(JSON.stringify(out, null, 2)); return; }
+    const s = out.source;
+    console.log(s.kind === 'remote'
+      ? (ko ? `출처: 게시 번들 v${s.version}` : `Source: published bundle v${s.version}`)
+      : (ko ? `출처: sprag ${src.cliVersion()} 동봉 프리셋` : `Source: bundled with sprag ${src.cliVersion()}`));
+    console.log('');
+    console.log(ko ? `래칫 프리셋 ${out.ratchet_rules.length}건` : `Ratchet presets (${out.ratchet_rules.length})`);
+    for (const r of out.ratchet_rules) {
+      const text = (ko ? r.ko : r.en).replace(/\s+/g, ' ');
+      console.log(`  [${r.id}]${r.agents ? ` (${r.agents.join(', ')})` : ''} ${text.length > 110 ? text.slice(0, 109) + '…' : text}`);
+    }
+    console.log('');
+    console.log(ko ? `모델 라우팅 프리셋 ${out.model_rules.length}건` : `Model-routing presets (${out.model_rules.length})`);
+    for (const m of out.model_rules) {
+      console.log(`  [${m.id}] ${m.tier} · ${ko ? m.label : m.labelEn} → ${m.agent}`);
+    }
+    console.log('');
+    console.log(ko ? `위임 에이전트 ${out.agents.length}개` : `Delegation agents (${out.agents.length})`);
+    for (const a of out.agents) {
+      console.log(`  ${a.name}  model=${a.model} effort=${a.effort} tools=${a.tools.join(', ')}`);
+    }
+    return;
+  }
+
+  if (sub !== 'status') {
+    console.error(ko ? '사용법: sprag presets [status|sync [--force]|show [--json]]' : 'Usage: sprag presets [status|sync [--force]|show [--json]]');
+    process.exitCode = 2;
+    return;
+  }
+
+  const cache = src.readRemoteCache();
+  const s = src.presetSource();
+  const disabled = src.presetSyncDisabled();
+  const lines = [];
+  if (s.kind === 'remote') {
+    lines.push(ko ? `프리셋 출처: 게시 번들 v${s.version} (받은 시각 ${when(s.fetchedAt)})`
+      : `Presets source: published bundle v${s.version} (fetched ${when(s.fetchedAt)})`);
+  } else {
+    lines.push(ko ? `프리셋 출처: sprag ${src.cliVersion()} 동봉 프리셋 (대체 경로)`
+      : `Presets source: bundled with sprag ${src.cliVersion()} (fallback)`);
+    // Nothing applied but something was fetched: the rejection is the answer.
+    const reason = s.reason === 'no-cache' && cache.rejected && cache.rejected.reason ? cache.rejected.reason : s.reason;
+    lines.push(ko ? `  이유: ${why(reason)}` : `  Why: ${why(reason)}`);
+  }
+  // Signing key status, independent of whether anything has been fetched.
+  const seenKid = (cache.bundle && cache.bundle.sig && cache.bundle.sig.kid) || null;
+  let keyLine;
+  if (PRESET_SIGNING_KEYS.length === 0) {
+    keyLine = ko ? '서명 키: 아직 없음. 공개 키가 들어간 버전이 나오기 전까지 게시 번들을 적용하지 않습니다'
+      : 'Signing keys: none yet. Published bundles are not applied until a release ships the public key.';
+  } else if (s.kind === 'remote') {
+    keyLine = ko ? `서명 키: 정상 (${s.kid})` : `Signing key: ok (${s.kid})`;
+  } else if (seenKid && !PRESET_SIGNING_KEYS.some((k) => k.kid === seenKid)) {
+    keyLine = ko ? `서명 키: 모르는 키 (${seenKid})` : `Signing key: unknown kid (${seenKid})`;
+  } else {
+    keyLine = ko ? `서명 키: ${PRESET_SIGNING_KEYS.map((k) => k.kid).join(', ')}` : `Signing keys: ${PRESET_SIGNING_KEYS.map((k) => k.kid).join(', ')}`;
+  }
+  lines.push(keyLine);
+  if (cache.rejected && cache.rejected.version != null) {
+    lines.push(ko ? `마지막으로 거절한 번들: v${cache.rejected.version} (${why(cache.rejected.reason)})`
+      : `Last rejected: v${cache.rejected.version} (${why(cache.rejected.reason)})`);
+  }
+  if (cache.lastError && cache.lastError.message) {
+    lines.push(ko ? `마지막 오류: ${cache.lastError.message} (${when(cache.lastError.at)})`
+      : `Last error: ${cache.lastError.message} (${when(cache.lastError.at)})`);
+  }
+  lines.push(ko ? `마지막 확인: ${when(cache.checkedAt) || '없음'}` : `Last check: ${when(cache.checkedAt) || 'never'}`);
+  if (disabled) {
+    lines.push(ko ? '다음 확인: 꺼져 있음' : 'Next check: off');
+  } else {
+    const next = sync.nextPresetCheckAt(cache);
+    lines.push(!next || next <= Date.now()
+      ? (ko ? '다음 확인: 다음 세션 시작 때' : 'Next check: at the next session start')
+      : (ko ? `다음 확인: ${when(next)} 이후 세션 시작 때` : `Next check: at the first session start after ${when(next)}`));
+  }
+  console.log(lines.join('\n'));
+}

package/src/commands/profile-map.js

@@ -56,8 +56,8 @@ export async function run({ args, hasFlag }) {
     const result = await refreshGatewayModelMap({ base, key });
     if (!result) {
       say(ko
-        ? `LiteLLM 에서 모델 정보를 가져오지 못했습니다 (GET ${base}/model/info). CTS_DEBUG=1 로 다시 실행하면 원인이 보입니다.`
-        : `Could not fetch model info from LiteLLM (GET ${base}/model/info). Re-run with CTS_DEBUG=1 to see why.`);
+        ? `LiteLLM 에서 모델 정보를 가져오지 못했습니다 (GET ${base}/model/info). SPRAG_DEBUG=1 로 다시 실행하면 원인이 보입니다.`
+        : `Could not fetch model info from LiteLLM (GET ${base}/model/info). Re-run with SPRAG_DEBUG=1 to see why.`);
       process.exitCode = 1;
       return;
     }

package/src/commands/route-scan.js

@@ -259,9 +259,8 @@ export async function run({ args, hasFlag, numArg }) {
       try {
         const cache = rs.readRouteScan();
         if (!(await rs.shouldRescan(cache, { afterDelegation: true }))) return;
-        const { spawn } = await import('node:child_process');
-        spawn(process.execPath, [process.argv[1], 'route-scan', '--refresh', '--quiet'],
-          { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+        const { spawnDetachedCli } = await import('../cli-entry.js');
+        spawnDetachedCli(['route-scan', '--refresh', '--quiet']);
       } catch (e) {
         // A missed refresh only means the figure lags, which is what happened
         // before this hook existed. Never fail the tool call over it.
@@ -278,9 +277,8 @@ export async function run({ args, hasFlag, numArg }) {
       let cache = rs.readRouteScan();
       if (await rs.shouldRescan(cache)) {
         try {
-          const { spawn } = await import('node:child_process');
-          spawn(process.execPath, [process.argv[1], 'route-scan', '--refresh', '--quiet'],
-            { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+          const { spawnDetachedCli } = await import('../cli-entry.js');
+          spawnDetachedCli(['route-scan', '--refresh', '--quiet']);
         } catch (e) { debug('route-scan:spawn-refresh', e); /* stale cache is still usable below */ }
       }
       const open = rs.openCandidates(cache);
@@ -296,6 +294,10 @@ export async function run({ args, hasFlag, numArg }) {
       // would keep reading the old wording indefinitely. The call writes only
       // when the rendering differs, so the common case is a read and a string
       // compare.
+      // Central presets: kick the detached, read-only fetch when a day has
+      // passed. What it fetches is applied by the renders below at the NEXT
+      // session start; this one uses whatever was already cached.
+      try { (await import('../preset-sync.js')).spawnPresetSyncIfDue(); } catch (e) { debug('route-scan:preset-sync', e); }
       // Agent files come first so the ratchet-model.md rendered next names them.
       try { (await import('../delegation-agents.js')).syncDelegationAgents(); } catch (e) { debug('route-scan:delegation-agents', e); }
       try { mrHook.syncAllFiles(); } catch (e) { debug('route-scan:sync-ratchet', e); }
@@ -522,7 +524,7 @@ export async function run({ args, hasFlag, numArg }) {
     console.log(lang === 'ko' ? '등록 / 무시:' : 'Promote / dismiss:');
     console.log('  sprag harness promote R<N> --global|--project');
     console.log('  sprag route-scan dismiss <N>');
-    // 최초 1회만 — 매번 찍으면 도구가 광고판이 된다 (CTS_NO_NOTE=1 로 끔)
+    // 최초 1회만 — 매번 찍으면 도구가 광고판이 된다 (SPRAG_NO_NOTE=1 로 끔)
     (await import('../first-run-note.js')).printOnce('route-scan', lang);
     return;
 }

package/src/commands/team.js

@@ -12,21 +12,23 @@ 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, isJoined, joinTeam, leaveTeam, syncTeam, autoJoin, aggregateDaily, rpc,
-  teamRulesCachePath, teamSyncDisabled, requestSignInCode, verifySignInCode, createTeam,
+  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>] [--no-join]   create a team (you become the owner)',
+      '  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]                       upload aggregates and pull team rules now',
-      '  rules                                show cached team rules',
+      '  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.',
@@ -36,6 +38,11 @@ const T = {
     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',
@@ -43,10 +50,15 @@ const T = {
     neverSynced: 'Last sync: never',
     lastError: 'Last error',
     on: 'on', off: 'off',
-    disabled: 'Team sync is disabled (CTS_NO_TEAM_SYNC=1).',
+    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) => `Synced: ${u} day rows uploaded, ${r} team rules.`,
-    noRules: 'No team rules yet.',
+    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.',
@@ -73,12 +85,13 @@ const T = {
   ko: {
     usage: [
       '사용법: sprag team <명령>',
-      '  create [--email <e>] [--name <이름>] [--code <6자리>] [--no-join]   팀 만들기 (만든 사람이 소유자)',
+      '  create [--email <e>] [--name <이름>] [--code <6자리>] [--org <조직 ID>] [--no-join]   팀 만들기 (만든 사람이 조직 오너)',
       '  join [토큰] [--name <이름>] [--yes]   팀에 참여 (토큰 또는 SPRAG_TEAM_TOKEN)',
       '  leave                                  팀에서 나가고 업로드 중단',
       '  status [--show-payload]                참여 상태, 마지막 동기화, 보내는 내용',
-      '  sync [--force]                         지금 집계를 올리고 팀 규칙을 받기',
-      '  rules                                  받아 둔 팀 규칙 보기',
+      '  sync [--force] [--rules-only]          지금 집계를 올리고 규칙을 받기',
+      '                                         (--rules-only: 조직·팀 규칙만 받고 아무것도 올리지 않음)',
+      '  rules                                  받아 둔 조직·팀 규칙 보기',
       '  propose <내용> [--scope ratchet|model]   팀에 규칙 제안',
     ].join('\n'),
     willSend: '참여하면 로컬 날짜별 하루 단위 집계만 올라갑니다.\n  - 지출(USD)\n  - 절감(USD)\n  - 위임 실행 횟수\n  - 모델 계열 비중\n프롬프트, 파일 경로, 대화 기록은 보내지 않습니다.',
@@ -88,6 +101,11 @@ const T = {
     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: '표시 이름',
@@ -95,10 +113,15 @@ const T = {
     neverSynced: '마지막 동기화: 아직 없음',
     lastError: '마지막 오류',
     on: '켜짐', off: '꺼짐',
-    disabled: '팀 동기화가 꺼져 있습니다 (CTS_NO_TEAM_SYNC=1).',
+    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) => `동기화 완료: ${u}일치 집계 업로드, 팀 규칙 ${r}개.`,
-    noRules: '아직 팀 규칙이 없습니다.',
+    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 이어야 합니다.',
@@ -124,6 +147,20 @@ const T = {
   },
 };
 
+/**
+ * `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 });
@@ -144,6 +181,8 @@ async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive
   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');
@@ -173,8 +212,9 @@ async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive
   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 });
+  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}`);
@@ -183,11 +223,12 @@ async function createFlow({ m, out, hasFlag, getArg, version, fetch, interactive
   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 });
+  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));
+    else if (!r.skipped) out(m.synced(r.uploaded, r.rules, r.prompts));
   }
   return undefined;
 }
@@ -216,6 +257,7 @@ export async function run({ args, hasFlag, getArg, version, fetch, interactive,
         }
         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':
@@ -226,33 +268,47 @@ export async function run({ args, hasFlag, getArg, version, fetch, interactive,
         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(JSON.stringify(await aggregateDaily(), null, 2));
+        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')) {
-          await autoJoin({ version });
-          await syncTeam({ version });
+          if (!hasFlag('--prompts-only') && !rulesOnly) await autoJoin({ version });
+          await syncTeam({ version, promptsOnly: hasFlag('--prompts-only'), rulesOnly });
           return undefined;
         }
-        const r = await syncTeam({ force: hasFlag('--force'), version });
+        // 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 out(m.synced(r.uploaded, r.rules));
+        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 */ }
-        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}`);
+        if (formatRuleLines(cache).length === 0) { out(m.noRules); return undefined; }
+        for (const line of formatRuleLines(cache)) out(line);
         return undefined;
       }
       case 'propose': {
@@ -272,7 +328,7 @@ export async function run({ args, hasFlag, getArg, version, fetch, interactive,
         return verb && verb !== 'help' ? process.exit(2) : undefined;
     }
   } catch (e) {
-    console.error(e.message);
+    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/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,16 +12,23 @@
  * 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
@@ -30,68 +37,25 @@ const MARK_LINE = `# managed by sprag (${OWNER_MARK}); edits are overwritten`;
 // 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.',
-  },
-  {
-    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 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.',
-  },
-];
+//
+// 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');
 }
@@ -110,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 };
@@ -128,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);
@@ -143,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 };