sprag-cli 3.69.0 → 3.70.0

package/src/route-inject.js

@@ -126,8 +126,8 @@ export function sessionModelRank({ env = process.env, transcriptPath = null, sna
  * and saves nothing. Outside such a host an unset variable selects Claude
  * Code's built-in default for the tier, so nothing is reported unreachable.
  */
-const TIER_ALIAS_ENV = { T2: 'ANTHROPIC_DEFAULT_HAIKU_MODEL', T1: 'ANTHROPIC_DEFAULT_SONNET_MODEL' };
-const TIER_ALIAS = { T2: 'haiku', T1: 'sonnet' };
+const TIER_ALIAS_ENV = { T2: 'ANTHROPIC_DEFAULT_HAIKU_MODEL', T1: 'ANTHROPIC_DEFAULT_SONNET_MODEL', T1H: 'ANTHROPIC_DEFAULT_OPUS_MODEL' };
+const TIER_ALIAS = { T2: 'haiku', T1: 'sonnet', T1H: 'opus' };
 
 export function unreachableTiers(env = process.env) {
   if (env.CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST !== '1') return [];
@@ -205,7 +205,8 @@ export function routeMatch(text, { rules, sessionRank = null, root, env = proces
   const nearest = [...reachable].sort((a, b) => scopeRank(b) - scopeRank(a));
   const t2 = nearest.find((r) => r.tier === 'T2');
   const t1 = nearest.find((r) => r.tier === 'T1');
-  return t2 || t1 ? { cat, t2, t1 } : null;
+  const t1h = nearest.find((r) => r.tier === 'T1H');
+  return t2 || t1 || t1h ? { cat, t2, t1, t1h } : null;
 }
 
 /** The budgets a match states, by tier: what the delegation guard repeats to the subagent. */
@@ -214,6 +215,7 @@ export function matchCaps(match) {
   const caps = {};
   if (match.t2) caps.T2 = ruleBudget(match.t2);
   if (match.t1) caps.T1 = ruleBudget(match.t1);
+  if (match.t1h) caps.T1H = ruleBudget(match.t1h);
   return caps;
 }
 
@@ -248,10 +250,10 @@ function unreachableNotice(label, tiers, ko) {
 export function routeHint(text, { rules, lang = userLanguage(), root, sessionRank = null, match, env } = {}) {
   const found = match === undefined ? routeMatch(text, { rules, sessionRank, root, env }) : match;
   if (!found) return null;
-  const { cat, t2, t1 } = found;
+  const { cat, t2, t1, t1h } = found;
   const ko = lang === 'ko';
   const label = ko ? (cat.label || cat.id) : (cat.labelEn || cat.label || cat.id);
-  if (!t2 && !t1 && found.unreachable?.length) return unreachableNotice(label, found.unreachable, ko);
+  if (!t2 && !t1 && !t1h && found.unreachable?.length) return unreachableNotice(label, found.unreachable, ko);
   // `root` is threaded through to agentPhrase, which names the subagent only
   // when its .md actually exists on this machine. A caller that pins it can
   // therefore get a deterministic phrase; a test that does not pin it reads
@@ -262,21 +264,28 @@ export function routeHint(text, { rules, lang = userLanguage(), root, sessionRan
   // T1 is named through its delegation agent only when that file exists here;
   // otherwise the literal tier string stays, so output without agents is unchanged.
   const t1Root = root === undefined ? undefined : root;
-  const t1Named = resolveAgentName('sonnet', t1Root) !== null;
-  const t1Phrase = t1Named ? phrase('sonnet') : 'model: sonnet';
+  const tierPhrase = (name) => (resolveAgentName(name, t1Root) !== null ? phrase(name) : `model: ${name}`);
+  const picked = [t2, t1, t1h].filter(Boolean);
   let target;
-  if (t2 && t1) {
+  if (picked.length >= 2) {
+    const named = (r) => (r.tier === 'T2' ? phrase(r.agent) : tierPhrase(r.tier === 'T1H' ? 'opus' : 'sonnet'));
+    const when = (r, i) => {
+      if (i === 0) return null;
+      if (r.tier === 'T1H') return ko ? '범위가 크면(Fable·Mythos 세션 한정)' : 'for large scope (Fable/Mythos sessions only)';
+      return ko ? '여러 단계·여러 파일이 얽히면' : 'when it spans multiple steps or file edits';
+    };
     target = ko
-      ? `기본 ${phrase(t2.agent)}, 여러 단계·여러 파일이 얽히면 ${t1Phrase}`
-      : `${phrase(t2.agent)} by default, ${t1Phrase} when it spans multiple steps or file edits`;
+      ? picked.map((r, i) => `${when(r, i) ?? '기본'} ${named(r)}`).join(', ')
+      : picked.map((r, i) => (i === 0 ? `${named(r)} by default` : `${named(r)} ${when(r, i)}`)).join(', ');
   } else {
-    const only = t2 || t1;
-    target = ko ? phrase(only.agent) : phrase(only.agent);
+    const only = picked[0];
+    target = only.tier === 'T1H' ? tierPhrase('opus') : phrase(only.agent);
   }
 
-  const caps = [t2, t1].filter(Boolean).map((r) => budgetCapPhrase(r, lang));
-  const capText = caps.length === 2
-    ? (ko ? `상한 haiku ${caps[0]} / sonnet ${caps[1]}` : `cap haiku ${caps[0]} / sonnet ${caps[1]}`)
+  const MODEL_OF = { T2: 'haiku', T1: 'sonnet', T1H: 'opus' };
+  const caps = picked.map((r) => budgetCapPhrase(r, lang));
+  const capText = picked.length >= 2
+    ? (ko ? '상한 ' : 'cap ') + picked.map((r, i) => `${MODEL_OF[r.tier]} ${caps[i]}`).join(' / ')
     : (ko ? `상한 ${caps[0]}` : `cap ${caps[0]}`);
 
   // The marker line is the one in ratchet-model.md, so the user sees the same

package/src/route-scan.js

@@ -44,6 +44,10 @@ export const T2_OUT_CLAMP = [1000, 3000];   // default 1500 pre-calibration
 export const T1_MAX_MUTATING = 6;
 export const T1_MAX_ERRORS = 1;
 export const T1_OUT_CLAMP = [5000, 15000];  // default 8000 pre-calibration
+// T1H (opus, Fable sessions only): too heavy for sonnet but still bounded.
+export const T1H_MAX_ERRORS = 3;
+export const T1H_MAX_MUTATING = 20;
+export const T1H_OUT_CLAMP = [15000, 60000]; // default 30000 pre-calibration
 export const T0_MIN_ERRORS = 2;             // repeated tool errors = hard, by outcome
 export const T0_MIN_MUTATING = 7;
 // Episodes below this output size carry no delegable work (conversational
@@ -65,7 +69,14 @@ export const MIN_DELEGABLE_OUT = 100;
 // questions that merely contained "statusline". None gained a hint. Bare
 // '리뷰' and '보안' are left out on purpose: they are product nouns in ordinary
 // status checks ("리뷰 허브 배치 확인"), so only the request-shaped forms count.
-export const ESCALATE_RE = /설계|아키텍처|리팩토링|원인\s*(?:분석|파악|확인|규명|조사)|원인을?\s*찾|버그|개선할|개선점|개선\s*(?:사항|방안)|검토해보|검수|코드\s*리뷰|리뷰\s*해|취약|보안\s*(?:점검|검토|감사|리뷰|이슈)|비교|왜(?=[\s?]|$)|이유|제출|배포|출시|퍼블리시|릴리[스즈](?!\s*노트)|(?<!나)머지|analyze|compare|evaluate|architect|refactor|submit|deploy|release|publish|merge|root cause|code review|security (?:review|audit)|vulnerabilit/i;
+//
+// 2026-10-18: production-database work and a user's go-ahead ("운영디비 승인할게
+// 너가 진행해줘", "승인할게 너가 직접 실행해줘") read as light run episodes and
+// became Opus (T1H) candidates. Measured on 6,473 local prompts over 90 days:
+// the two term groups catch 7 + 12 prompts, of which 4 were not already
+// escalated, all of them approvals or production-DB asks. Bare '승인' is left
+// out: "승인된 룰" is a product noun in sprag's own ratchet flow.
+export const ESCALATE_RE = /운영\s*(?:db|디비|데이터베이스|서버|환경)|프로덕션|\bprod(?:uction)?\s*(?:db|database|server|env)|승인\s*(?:할게|했어|했으니|했습니다|합니다|해줄게|완료)|\bapproved?\b|설계|아키텍처|리팩토링|원인\s*(?:분석|파악|확인|규명|조사)|원인을?\s*찾|버그|개선할|개선점|개선\s*(?:사항|방안)|검토해보|검수|코드\s*리뷰|리뷰\s*해|취약|보안\s*(?:점검|검토|감사|리뷰|이슈)|비교|왜(?=[\s?]|$)|이유|제출|배포|출시|퍼블리시|릴리[스즈](?!\s*노트)|(?<!나)머지|analyze|compare|evaluate|architect|refactor|submit|deploy|release|publish|merge|root cause|code review|security (?:review|audit)|vulnerabilit/i;
 
 // Implementation asks phrased around a run/check verb ("설치와 동시에 설정되도록
 // 하자", "피드백 확인해주고 아이콘도 만들자"). Editing is not delegable, and at
@@ -412,32 +423,30 @@ const percentile = (sorted, p) => sorted[Math.min(sorted.length - 1, Math.floor(
  * Falls back to mid-clamp defaults when the sample is too small to trust.
  */
 export function calibrateThresholds(episodeOuts) {
-  if (episodeOuts.length < 100) return { t2Out: 1500, t1Out: 8000, calibrated: false };
+  if (episodeOuts.length < 100) return { t2Out: 1500, t1Out: 8000, t1hOut: 30000, calibrated: false };
   const sorted = [...episodeOuts].sort((a, b) => a - b);
   return {
     t2Out: clamp(Math.max(percentile(sorted, 0.25), 1500), T2_OUT_CLAMP),
     t1Out: clamp(percentile(sorted, 0.75), T1_OUT_CLAMP),
+    t1hOut: clamp(percentile(sorted, 0.95), T1H_OUT_CLAMP),
     calibrated: true,
   };
 }
 
 /**
- * Tier classification (docs/TIER_CRITERIA.md §3). Returns 'T0'|'T1'|'T2',
+ * Tier classification (docs/TIER_CRITERIA.md §3). Returns 'T0'|'T1H'|'T1'|'T2',
  * or null when the episode carries nothing delegable. Order matters: hard
  * evidence (errors, heavy mutation, big output, judgement keywords) wins
  * before any cheap-band check.
  */
 export function tierOf(ep, category, th) {
   if (ep.out < MIN_DELEGABLE_OUT) return null;
-  if (
-    ep.errors >= T0_MIN_ERRORS ||
-    ep.mutating >= T0_MIN_MUTATING ||
-    ep.out > th.t1Out ||
-    ESCALATE_RE.test(ep.text)
-  ) return 'T0';
+  if (ESCALATE_RE.test(ep.text)) return 'T0';
   if (!category || ep.delegated > 0) return 'T0';
   if (ep.calls <= T2_MAX_CALLS && ep.out <= th.t2Out && ep.mutating <= T2_MAX_MUTATING && ep.errors === 0) return 'T2';
   if (ep.out <= th.t1Out && ep.mutating <= T1_MAX_MUTATING && ep.errors <= T1_MAX_ERRORS) return 'T1';
+  const t1hOut = th.t1hOut ?? 30000;
+  if (ep.errors <= T1H_MAX_ERRORS && ep.mutating <= T1H_MAX_MUTATING && ep.out <= t1hOut) return 'T1H';
   return 'T0';
 }
 
@@ -611,13 +620,13 @@ export async function runRouteScan({ days = 14 } = {}) {
       const shapeTier = tierOf({ ...ep, errors: 0 }, cat, thresholds);
       // Same rank gate as the candidate path below — a denominator counting
       // episodes that can't produce a rule would skew that rule's error rate.
-      if ((shapeTier === 'T1' || shapeTier === 'T2') && worthDelegating(shapeTier, epRank)) {
+      if ((shapeTier === 'T1' || shapeTier === 'T2' || shapeTier === 'T1H') && worthDelegating(shapeTier, epRank)) {
         bumpStats(`${shapeTier}|${cat.id}|${projectDir}`, ep);
         bumpStats(`${shapeTier}|${cat.id}|*`, ep);
       }
     }
     const tier = tierOf(ep, cat, thresholds);
-    if (tier !== 'T1' && tier !== 'T2') continue;
+    if (tier !== 'T1' && tier !== 'T2' && tier !== 'T1H') continue;
     if (!worthDelegating(tier, epRank)) continue;
     tieredEpisodes += 1;
     const key = `${tier}|${cat.id}|${projectDir}`;
@@ -626,7 +635,7 @@ export async function runRouteScan({ days = 14 } = {}) {
       category: cat.id,
       label: cat.label,
       labelEn: cat.labelEn,
-      agent: tier === 'T2' ? cat.agent : 'sonnet',
+      agent: tier === 'T2' ? cat.agent : tier === 'T1H' ? 'opus' : 'sonnet',
       project: projectDir,
       projectPath: '',
       count: 0,
@@ -653,7 +662,7 @@ export async function runRouteScan({ days = 14 } = {}) {
   // where a promoted rule's real success rate lives, so they get their own
   // pass: join each episode to the subagent transcripts it spawned, and file
   // the outcome under the tier that run's model represents — a haiku run is a
-  // T2 rule firing, a sonnet run a T1 one. Runs that were not a downgrade
+  // T2 rule firing, a sonnet run a T1 one, an opus run (Fable session) a T1H one. Runs that were not a downgrade
   // (same tier or higher) carry no delegation saving and are skipped.
   const delegatedStats = new Map(); // "tier|category|project" → outcome aggregate
   let unresolvedRuns = 0;           // delegated runs dropped for an unpriceable model id
@@ -774,7 +783,7 @@ export async function runRouteScan({ days = 14 } = {}) {
   // time rather than hardcoded downstream.
   const budgetOf = (g) => ({
     calls: g.tier === 'T2' ? T2_MAX_CALLS + 2 : null,
-    out: g.tier === 'T2' ? thresholds.t2Out : thresholds.t1Out,
+    out: g.tier === 'T2' ? thresholds.t2Out : g.tier === 'T1H' ? thresholds.t1hOut : thresholds.t1Out,
   });
   // Shared with the seed presets (src/seed-rules.js) through model-rules.js —
   // one template, so a reworded rule cannot mean two different things
@@ -945,7 +954,7 @@ export async function shouldRescan(cache, { days = 14, afterDelegation = false }
 }
 
 /**
- * Human-readable labels for the T0/T1/T2 codes and scope values — used by
+ * Human-readable labels for the T0/T1H/T1/T2 codes and scope values — used by
  * every user-facing listing so a bare code never appears without its meaning
  * (first-time users can't be expected to know the tier vocabulary).
  */
@@ -953,11 +962,13 @@ export function tierLabel(tier, lang = 'ko') {
   const ko = {
     T2: '단순 작업, haiku급이면 충분',
     T1: '중간 난도, sonnet급이면 충분',
+    T1H: '고난도 구현, opus급이면 충분 (Fable 세션 전용)',
     T0: '고난도, 지금 모델 유지',
   };
   const en = {
     T2: 'simple — haiku-class is enough',
     T1: 'moderate — sonnet-class is enough',
+    T1H: 'heavy, opus-class is enough (Fable sessions only)',
     T0: 'hard — stays on the session model',
   };
   return (lang === 'ko' ? ko : en)[tier] || tier;

package/src/shared-model-rules.js

@@ -3,7 +3,7 @@ import { isAbsolute, resolve } from 'node:path';
 import { loadModelRules, ruleBudget } from './model-rules.js';
 import { findProjectRoot } from './harness.js';
 
-export const SHARED_RULE_TIERS = ['T2', 'T1'];
+export const SHARED_RULE_TIERS = ['T2', 'T1', 'T1H'];
 const CATEGORIES = new Set(['paste', 'translate', 'explore', 'read', 'check', 'run']);
 
 /** A root as a real path, so a symlinked checkout or macOS /var names one directory once. */

package/src/team-ratchet.js

@@ -0,0 +1,176 @@
+/**
+ * team-ratchet — rules the user's team approved, kept in a tool-owned file.
+ *
+ * `sprag team sync` caches the approved rules in team-rules.json. This module
+ * only turns that cache into a ratchet file (no network), keeps the CLAUDE.md
+ * import in step with the file, and starts the detached sync when it is due.
+ * Every function degrades to a no-op for a machine that never joined a team.
+ *
+ *   Claude Code  ~/.claude/ratchet-team.md
+ *   Codex        <CODEX_HOME>/ratchet-team.md
+ */
+
+import * as childProcess from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { codexUserDir } from './agent.js';
+import { userLanguage } from './config.js';
+import { debug } from './debug.js';
+import {
+  HARNESS_BLOCK_BEGIN,
+  HARNESS_BLOCK_END,
+  TEAM_RATCHET_IMPORT_RE,
+  teamRatchetImportLine,
+} from './harness-templates.js';
+import { userDataDir } from './paths.js';
+import { writeStateFile, writeViaTmp } from './state-file.js';
+
+export { TEAM_RATCHET_IMPORT_RE, teamRatchetImportLine };
+
+export const TEAM_RATCHET_MARKER = '<!-- sprag:team-ratchet -->';
+const SYNC_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const TOKEN_RE = /^spt_[0-9a-f]{32}$/;
+
+export const teamStatePathFor = (dir = userDataDir()) => join(dir, 'team.json');
+export const teamRulesCachePathFor = (dir = userDataDir()) => join(dir, 'team-rules.json');
+
+function readJson(file) {
+  try {
+    const v = JSON.parse(readFileSync(file, 'utf8'));
+    return v && typeof v === 'object' ? v : null;
+  } catch { return null; }
+}
+
+export function readTeamState(dir = userDataDir()) {
+  return readJson(teamStatePathFor(dir)) || {};
+}
+
+export function readTeamRulesCache(dir = userDataDir()) {
+  return readJson(teamRulesCachePathFor(dir));
+}
+
+export function isJoined(state) {
+  return !!(state && state.memberKey && state.left !== true);
+}
+
+export function teamSyncDue(state, now = Date.now()) {
+  if (!isJoined(state)) return false;
+  const at = Number(state.lastSyncAt);
+  return !Number.isFinite(at) || at <= 0 || now - at > SYNC_INTERVAL_MS;
+}
+
+export function autoJoinPending(state, env = process.env) {
+  return TOKEN_RE.test(env.SPRAG_TEAM_TOKEN || '') && !isJoined(state) && state?.left !== true;
+}
+
+export function teamSyncDisabled(env = process.env) {
+  return env.CTS_NO_TEAM_SYNC === '1';
+}
+
+export function teamRatchetPath({ agent = 'claude' } = {}) {
+  return agent === 'codex'
+    ? join(codexUserDir(), 'ratchet-team.md')
+    : join(homedir(), '.claude', 'ratchet-team.md');
+}
+
+export function renderTeamRatchet(cache, { lang = 'en', agent = 'claude' } = {}) {
+  if (!cache || !Array.isArray(cache.rules)) return null;
+  const removed = new Set(Array.isArray(cache.removed) ? cache.removed : []);
+  const live = cache.rules.filter((r) => r && typeof r.text === 'string' && r.text.trim() && !removed.has(r.id));
+  const ratchet = live.filter((r) => (r.scope || 'ratchet') !== 'model');
+  const model = live.filter((r) => r.scope === 'model');
+  if (!ratchet.length && !model.length) return null;
+  const ko = lang === 'ko' && agent !== 'codex';
+  const name = cache.teamName || '';
+  const head = ko
+    ? `# 팀 래칫 룰 (sprag 관리)\n\n팀 "${name}" 이 승인한 룰입니다. sprag 가 세션 시작 때 통째로 다시 쓰므로 직접 고치지 마십시오. 목록: \`sprag team rules\``
+    : `# Team Ratchet Rules (managed by sprag)\n\nRules approved by team "${name}". sprag rewrites this file at session start, so do not edit it by hand. List: \`sprag team rules\``;
+  const line = (r) => `- ${r.text.trim().replace(/\s*\n\s*/g, ' ')}`;
+  let out = `${TEAM_RATCHET_MARKER}\n${head}\n`;
+  if (ratchet.length) out += `\n## Rules\n\n${ratchet.map(line).join('\n')}\n`;
+  if (model.length) out += `\n## Model rules\n\n${model.map(line).join('\n')}\n`;
+  return out;
+}
+
+function writeIfChanged(file, text) {
+  let before = null;
+  try { before = readFileSync(file, 'utf8'); } catch { /* first write */ }
+  if (before === text) return false;
+  mkdirSync(dirname(file), { recursive: true });
+  writeViaTmp(`${file}.tmp-${process.pid}`, file, text);
+  return true;
+}
+
+function ownedFile(file) {
+  try { return readFileSync(file, 'utf8').split('\n', 1)[0].trim() === TEAM_RATCHET_MARKER; } catch { return false; }
+}
+
+export function syncTeamRatchet({ agent = 'claude', lang = userLanguage(), dir = userDataDir() } = {}) {
+  const file = teamRatchetPath({ agent });
+  const state = readTeamState(dir);
+  const text = isJoined(state) ? renderTeamRatchet(readTeamRulesCache(dir), { lang, agent }) : null;
+  if (text === null) {
+    if (existsSync(file) && ownedFile(file)) {
+      rmSync(file, { force: true });
+      return { file, rules: 0, changed: true, removed: true };
+    }
+    return { file, rules: 0, changed: false, removed: false };
+  }
+  const changed = writeIfChanged(file, text);
+  return { file, rules: (text.match(/^- /gm) || []).length, changed, removed: false };
+}
+
+/**
+ * Keep the team import in the global harness block in step with the file.
+ * Only the tool's own marked block is edited; a CLAUDE.md without it is left alone.
+ */
+export function ensureTeamImport() {
+  const file = join(homedir(), '.claude', 'CLAUDE.md');
+  let text;
+  try { text = readFileSync(file, 'utf8'); } catch { return { file, added: false, removed: false }; }
+  const begin = text.indexOf(HARNESS_BLOCK_BEGIN);
+  const end = text.indexOf(HARNESS_BLOCK_END);
+  if (begin < 0 || end < begin) return { file, added: false, removed: false };
+  const block = text.slice(begin, end);
+  const has = TEAM_RATCHET_IMPORT_RE.test(block);
+  const exists = existsSync(teamRatchetPath());
+  if (exists && !has) {
+    writeFileSync(file, `${text.slice(0, end)}${teamRatchetImportLine()}\n${text.slice(end)}`);
+    return { file, added: true, removed: false };
+  }
+  if (!exists && has) {
+    const cleaned = block.replace(/^@~\/\.claude\/ratchet-team\.md[ \t]*\r?\n?/m, '');
+    writeFileSync(file, `${text.slice(0, begin)}${cleaned}${text.slice(end)}`);
+    return { file, added: false, removed: true };
+  }
+  return { file, added: false, removed: false };
+}
+
+export function spawnTeamSyncIfDue({
+  state = readTeamState(), now = Date.now(), env = process.env,
+  spawn = childProcess.spawn, argv = process.argv, execPath = process.execPath,
+} = {}) {
+  if (teamSyncDisabled(env)) return false;
+  if (!autoJoinPending(state, env) && !teamSyncDue(state, now)) return false;
+  try {
+    spawn(execPath, [argv[1], 'team', 'sync', '--background'],
+      { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+    return true;
+  } catch (e) {
+    debug('team-ratchet:spawn', e);
+    return false;
+  }
+}
+
+export function autoJoinNoticeBlock(dir = userDataDir(), lang = userLanguage()) {
+  const file = teamStatePathFor(dir);
+  const state = readJson(file);
+  if (!state || state.autoJoinNoticePending !== true) return null;
+  const name = state.teamName || '';
+  try { writeStateFile(file, `${JSON.stringify({ ...state, autoJoinNoticePending: false }, null, 2)}\n`); }
+  catch (e) { debug('team-ratchet:notice-clear', e); }
+  return lang === 'ko'
+    ? `Sprag: 이 PC는 SPRAG_TEAM_TOKEN 으로 팀 "${name}" 에 자동 참여됐습니다. 보내는 것은 하루 단위 집계(지출·절감·위임 횟수)뿐입니다. \`sprag team status --show-payload\` 로 내용을 확인하고 \`sprag team leave\` 로 멈출 수 있습니다.`
+    : `Sprag: this machine was enrolled in team "${name}" through SPRAG_TEAM_TOKEN. It sends daily aggregates only (spend, savings, delegation counts). See what is sent with \`sprag team status --show-payload\`; stop with \`sprag team leave\`.`;
+}