sprag-cli 3.66.0 → 3.68.0

package/src/commands/saved.js

@@ -26,18 +26,19 @@ const SCOPE_SETS = {
 async function currentTotals(scope, dir) {
   if (scope === 'routing') {
     const { delegationSavedTotals } = await import('../savings-ledger.js');
-    return { usd: delegationSavedTotals(Date.now(), dir).total };
+    const t = delegationSavedTotals(Date.now(), dir);
+    return { usd: t.total, spent: t.spent, spentMissing: t.spentMissing };
   }
   if (scope === 'doc2md') {
     const { doc2mdSavedTotals } = await import('../doc2md-ledger.cjs');
     return { usd: doc2mdSavedTotals(dir).total };
   }
   if (scope === 'codex-routing') {
-    const { codexRoutingSavedTotals } = await import('../codex-ledger.js');
+    const { codexRoutingSavedTotals } = await import('../codex/ledger.js');
     const totals = codexRoutingSavedTotals({ dir });
     return { usd: totals.priced ? totals.total : null, unpriced: totals.runs - totals.priced };
   }
-  const { codexDocumentTotals } = await import('../codex-doc2md-ledger.js');
+  const { codexDocumentTotals } = await import('../codex/doc2md-ledger.js');
   const totals = codexDocumentTotals({ dir });
   return { docs: totals.docs, usd: totals.savings.priced ? totals.savings.total : null, unpriced: totals.savings.unpriced };
 }
@@ -67,6 +68,54 @@ async function refreshRuleSavings(ko, rescan) {
   }
 }
 
+const FAMILY_NAMES = { opus: 'Opus', sonnet: 'Sonnet', haiku: 'Haiku', fable: 'Fable', mythos: 'Mythos' };
+
+/**
+ * The model-share table for the routing counter's period. Best-effort like the
+ * statusline: a failure to read transcripts must not break the totals above it.
+ */
+async function printModelShare({ ko, dir, money }) {
+  const { loadModelShare, roundShares } = await import('../model-share.js');
+  let share;
+  try {
+    share = await loadModelShare({ dir, env: process.env });
+  } catch (e) {
+    debug('saved:model-share', e);
+    return;
+  }
+  let title = ko ? '모델별 사용 비중 (같은 기간, 비용 기준)' : 'Model share (same period, by cost)';
+  if (share.sinceKind === 'month') title += ko ? ' · 초기화 기록이 없어 이번 달 기준' : ' · no reset on record, this month';
+  else if (share.sinceKind === 'capped') title += ko ? ' · 최근 90일' : ' · last 90 days';
+  console.log('');
+  console.log(title);
+  if (!(share.totalUsd > 0)) {
+    console.log(ko ? '이 기간에 집계할 사용 기록이 없습니다.' : 'No usage to count in this period.');
+  } else {
+    const names = share.families.map((f) => FAMILY_NAMES[f.family] || f.family);
+    const nameW = Math.max(...names.map((n) => n.length));
+    const pcts = share.families.map((f) => f.pct.toFixed(1));
+    const pctW = Math.max(...pcts.map((p) => p.length));
+    share.families.forEach((f, i) => {
+      const filled = roundShares([f.usd, share.totalUsd - f.usd], 20)[0];
+      const bar = '█'.repeat(filled) + '░'.repeat(20 - filled);
+      console.log(`  ${names[i].padEnd(nameW)}  ${bar}  ${pcts[i].padStart(pctW)}%  ${money(f.usd)}`);
+    });
+    if (share.subagent.usd > 0) {
+      const subs = share.subagent.families;
+      const subPct = Math.round(share.subagent.pct);
+      // A share that rounds to 0 still spent money; "0%" would read as unused.
+      const pctText = (p) => (p > 0 && Math.round(p) === 0 ? '<1' : String(Math.round(p)));
+      const detail = subs
+        .map((f) => `${f.family} ${pctText(f.pct)}%`)
+        .join(', ');
+      console.log(`  ${ko ? '서브에이전트 몫' : 'Subagents'}: ${subPct}% (${detail})`);
+    }
+  }
+  if (share.unpriced > 0) {
+    console.log(ko ? `단가가 없어 제외한 부분 ${share.unpriced}건` : `${share.unpriced} part(s) left out: no price`);
+  }
+}
+
 export async function run({ args, hasFlag, agent = 'claude', dir: dirArg, rescan }) {
   const { userLanguage } = await import('../config.js');
   const { userDataDir } = await import('../paths.js');
@@ -79,8 +128,13 @@ export async function run({ args, hasFlag, agent = 'claude', dir: dirArg, rescan
   const money = (v) => (v < 0 ? `-$${(-v).toFixed(2)}` : `$${v.toFixed(2)}`);
   const fmtTotal = (t) => {
     const value = Number.isFinite(t.usd) ? money(t.usd) : 'n/a';
-    return t.docs !== undefined ? `${ko ? `${t.docs}건` : `${t.docs} doc(s)`}, ${value} (${ko ? 'XML 대비 추정' : 'XML estimate'}; ${t.unpriced} unpriced)`
-      : `${value}${t.unpriced ? ` +${t.unpriced} unpriced` : ''}`;
+    if (t.docs !== undefined) return `${ko ? `${t.docs}건` : `${t.docs} doc(s)`}, ${value} (${ko ? 'XML 대비 추정' : 'XML estimate'}; ${t.unpriced} unpriced)`;
+    // What the delegated runs cost on the models they ran on. The statusline
+    // no longer draws it beside the saving, so this is where it is read.
+    const spent = Number(t.spent) > 0
+      ? ` · ${ko ? '위임 실행 비용' : 'spent on delegated runs'} ${money(t.spent)}${t.spentMissing > 0 ? ` +${t.spentMissing} unpriced` : ''}`
+      : '';
+    return `${value}${t.unpriced ? ` +${t.unpriced} unpriced` : ''}${spent}`;
   };
   const fmtTime = (ms) => new Date(ms).toLocaleString(ko ? 'ko-KR' : 'en-US');
   const label = (scope) => ({
@@ -101,6 +155,7 @@ export async function run({ args, hasFlag, agent = 'claude', dir: dirArg, rescan
         : (ko ? `${fmtTime(marks[s])} 이후` : `since ${fmtTime(marks[s])}`);
       console.log(`${label(s)}: ${fmtTotal(t)} (${since})`);
     }
+    if (agent !== 'codex') await printModelShare({ ko, dir, money });
     return;
   }
 

package/src/commands/uninstall.js

@@ -26,6 +26,10 @@ export async function run({ hasFlag, args = [] }) {
     return;
   }
 
+  // The Cowork copies and the settings.json exclude entry are ours too.
+  try { (await import('../cowork-sync.js')).removeCoworkRatchets(); } catch { /* uninstall goes on */ }
+  try { (await import('../delegation-agents.js')).removeDelegationAgents(); } catch { /* uninstall goes on */ }
+
   if (r.removed.length === 0) {
     console.log(lang === 'ko' ? '설치된 항목이 없습니다.' : 'Nothing was installed.');
   } else {
@@ -39,8 +43,8 @@ export async function run({ hasFlag, args = [] }) {
   // undo that as well; otherwise Codex keeps calling a command that may no
   // longer exist. Only our own entries go, exactly as `uninstall --agent codex`.
   try {
-    const { codexHookStatus, configureCodexHooks } = await import('../codex-installer.js');
-    const { codexHarnessStatus, uninitCodexHarness } = await import('../codex-harness.js');
+    const { codexHookStatus, configureCodexHooks } = await import('../codex/installer.js');
+    const { codexHarnessStatus, uninitCodexHarness } = await import('../codex/harness.js');
     const hooked = codexHookStatus().some((h) => h.registered);
     let harness = false;
     try { harness = codexHarnessStatus({ scope: 'global' }).configured > 0; } catch { /* no AGENTS.md */ }
@@ -52,7 +56,7 @@ export async function run({ hasFlag, args = [] }) {
         : `  Codex: hooks ${hook.action} (${hook.file}), harness ${h.removed ? 'removed' : 'absent'}`);
       if (process.platform === 'darwin') {
         try {
-          const { installPanelShell } = await import('../codex-panel-shell.js');
+          const { installPanelShell } = await import('../codex/panel-shell.js');
           installPanelShell({ remove: true });
         } catch (e) { /* a malformed or foreign block stays for the user to repair */ }
       }

package/src/config.js

@@ -56,6 +56,9 @@ const KEYWORDS = {
   'no-timer': { key: 'timer',   value: false },
   color:      { key: 'color',   value: true  },
   'no-color': { key: 'color',   value: false },
+  // Model-share bar and letters beside the routing chip; on unless switched off.
+  share:      { key: 'modelShare', value: true  },
+  'no-share': { key: 'modelShare', value: false },
 };
 
 // Output language for `last`/`history`/advice. Stored at top level
@@ -195,6 +198,7 @@ export function statuslineDefaults() {
     verbose:     s.verbose !== false,
     timer:       s.timer   !== false,
     color:       s.color   !== false,
+    modelShare:  s.modelShare !== false,
     windowHours,
     windowLabel: formatWindow(windowHours),
     // 'auto' | '5m' | '1h'. Auto lets the measured split decide and falls back

package/src/cowork-sync.js

@@ -0,0 +1,361 @@
+/**
+ * cowork-sync: copy the global ratchet files into the folders connected to the
+ * Claude desktop app's Cowork tab.
+ *
+ * Cowork does not read ~/.claude (no hooks, no `@` imports), but it does read
+ * `<folder>/.claude/rules/*.md`. So the three global ratchet files are pasted
+ * into one tool-owned rules file per connected folder. Claude Code reads the
+ * same rules directory, so ~/.claude/settings.json gets a `claudeMdExcludes`
+ * entry that keeps Claude Code from loading the copy a second time (Cowork does
+ * not read that settings file).
+ *
+ * Where Cowork keeps its session metadata (macOS verified):
+ *   ~/Library/Application Support/Claude-3p/local-agent-mode-sessions/<org>/<user>/local_<id>.json
+ * The 1p app is assumed to use ".../Claude/local-agent-mode-sessions" (not
+ * verified). Windows is assumed to use %APPDATA%\Claude and %APPDATA%\Claude-3p
+ * (not verified). Linux is out of scope.
+ *
+ * Nothing here throws to the caller: a folder that cannot be written is
+ * reported in `skipped`, and the SessionStart hook ignores the whole call on
+ * failure.
+ */
+
+import {
+  existsSync, readFileSync, readdirSync, statSync, realpathSync, mkdirSync, writeFileSync, rmSync,
+  appendFileSync,
+} from 'node:fs';
+import { join, resolve, sep, isAbsolute } from 'node:path';
+import { homedir } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { userDataDir, claudeUserDir } from './paths.js';
+import { loadConfig, saveConfig, userLanguage } from './config.js';
+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 { globalRatchetMdPath } from './harness.js';
+import { debug } from './debug.js';
+
+export const COWORK_MARKER = '<!-- sprag:cowork-ratchet -->';
+export const COWORK_EXCLUDE_PATTERN = '**/.claude/rules/sprag-cowork-ratchet.md';
+const COPY_REL = join('.claude', 'rules', 'sprag-cowork-ratchet.md');
+const MAX_PARSE_PER_CALL = 200;
+
+export const coworkStatePath = () => join(userDataDir(), 'cowork-sync.json');
+
+// ---------- config ----------
+
+export function coworkConfig() {
+  const c = loadConfig().cowork;
+  return {
+    sync: !(c && c.sync === false),
+    exclude: Array.isArray(c?.exclude) ? c.exclude.filter((x) => typeof x === 'string') : [],
+  };
+}
+
+export function saveCoworkConfig(patch) {
+  const cfg = loadConfig();
+  saveConfig({ ...cfg, cowork: { ...coworkConfig(), ...patch } });
+}
+
+// ---------- state ----------
+
+export function loadCoworkState() {
+  try {
+    const s = JSON.parse(readFileSync(coworkStatePath(), 'utf8'));
+    if (s && typeof s === 'object' && !Array.isArray(s)) {
+      return {
+        version: 1,
+        scanned: s.scanned && typeof s.scanned === 'object' ? s.scanned : {},
+        folders: s.folders && typeof s.folders === 'object' ? s.folders : {},
+        written: s.written && typeof s.written === 'object' ? s.written : {},
+        ...(typeof s.lastSync === 'string' ? { lastSync: s.lastSync } : {}),
+      };
+    }
+  } catch { /* first run or unreadable: start empty */ }
+  return { version: 1, scanned: {}, folders: {}, written: {} };
+}
+
+export function saveCoworkState(state) {
+  try { writeStateFile(coworkStatePath(), JSON.stringify(state, null, 2) + '\n'); } catch (e) { debug('cowork-sync:save-state', e); }
+}
+
+// ---------- discovery ----------
+
+export function coworkSessionRoots() {
+  const bases = [];
+  if (process.platform === 'darwin') {
+    const support = join(homedir(), 'Library', 'Application Support');
+    bases.push(join(support, 'Claude'), join(support, 'Claude-3p'));
+  } else if (process.platform === 'win32' && process.env.APPDATA) {
+    bases.push(join(process.env.APPDATA, 'Claude'), join(process.env.APPDATA, 'Claude-3p'));
+  }
+  return bases.map((b) => join(b, 'local-agent-mode-sessions')).filter((p) => existsSync(p));
+}
+
+function subdirs(dir) {
+  try {
+    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => join(dir, e.name));
+  } catch { return []; }
+}
+
+/** local_*.json exactly three levels under a root: <org>/<user>/local_*.json */
+function sessionMetaFiles(root) {
+  const out = [];
+  for (const org of subdirs(root)) {
+    for (const user of subdirs(org)) {
+      let names;
+      try { names = readdirSync(user); } catch { continue; }
+      for (const n of names) {
+        if (n.startsWith('local_') && n.endsWith('.json')) out.push(join(user, n));
+      }
+    }
+  }
+  return out;
+}
+
+/**
+ * Parse only the metadata files whose mtime changed since the last call (at
+ * most 200 per call, newest first; the rest wait for the next call) and add
+ * the folders they name to `state.folders`. Folders are never forgotten.
+ */
+export function discoverCoworkFolders({ state = loadCoworkState() } = {}) {
+  const now = new Date().toISOString();
+  const seen = {};
+  const changed = [];
+  for (const root of coworkSessionRoots()) {
+    for (const file of sessionMetaFiles(root)) {
+      let mtime;
+      try { mtime = statSync(file).mtimeMs; } catch { continue; }
+      seen[file] = mtime;
+      if (state.scanned[file] !== mtime) changed.push({ file, mtime });
+    }
+  }
+  changed.sort((a, b) => b.mtime - a.mtime);
+  const nextScanned = {};
+  // Unchanged files keep their mark; changed ones are marked only once handled,
+  // so the ones beyond the cap are picked up by the next call.
+  for (const [file, mtime] of Object.entries(seen)) {
+    if (state.scanned[file] === mtime) nextScanned[file] = mtime;
+  }
+  for (const { file, mtime } of changed.slice(0, MAX_PARSE_PER_CALL)) {
+    nextScanned[file] = mtime;
+    let meta;
+    try { meta = JSON.parse(readFileSync(file, 'utf8')); } catch { continue; }
+    const list = Array.isArray(meta?.userSelectedFolders) ? meta.userSelectedFolders : [];
+    for (const f of list) {
+      if (typeof f !== 'string' || !f) continue;
+      const rec = state.folders[f];
+      state.folders[f] = { firstSeen: rec?.firstSeen || now, lastSeen: now };
+    }
+  }
+  state.scanned = nextScanned;
+  return Object.keys(state.folders);
+}
+
+// ---------- eligibility ----------
+
+function real(p) {
+  try { return realpathSync(p); } catch { return resolve(p); }
+}
+
+const isInside = (child, parent) => child === parent || child.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+
+/** @returns {{ ok: boolean, reason?: string, dir?: string }} `dir` is the real path when ok */
+export function eligibleFolder(dir) {
+  if (typeof dir !== 'string' || !isAbsolute(dir)) return { ok: false, reason: 'not-absolute' };
+  let st;
+  try { st = statSync(dir); } catch { return { ok: false, reason: 'missing' }; }
+  if (!st.isDirectory()) return { ok: false, reason: 'not-a-directory' };
+  const rd = real(dir);
+  const home = real(homedir());
+  if (rd === home || isInside(home, rd)) return { ok: false, reason: 'home-or-ancestor' };
+  if (isInside(rd, real(claudeUserDir()))) return { ok: false, reason: 'inside-claude-dir' };
+  if (process.platform === 'darwin' && isInside(rd, real(join(homedir(), 'Library')))) return { ok: false, reason: 'inside-library' };
+  if (isInside(rd, real(userDataDir()))) return { ok: false, reason: 'inside-sprag-data' };
+  for (const ex of coworkConfig().exclude) {
+    if (isInside(rd, real(ex))) return { ok: false, reason: 'excluded' };
+  }
+  return { ok: true, dir: rd };
+}
+
+export const coworkCopyPath = (dir) => join(dir, COPY_REL);
+
+// ---------- content ----------
+
+/** @returns {string|null} null when none of the three source files exists */
+export function renderCoworkRatchet(lang = userLanguage()) {
+  const ko = lang === 'ko';
+  const parts = [];
+  for (const file of [modelRatchetPathFor('global'), presetRatchetPath(), globalRatchetMdPath()]) {
+    let body;
+    try { body = readFileSync(file, 'utf8'); } catch { continue; }
+    const name = file.split(/[\\/]/).pop();
+    parts.push(`## ${ko ? '원본' : 'Source'}: ~/.claude/${name}\n\n${body.trim()}\n`);
+  }
+  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.';
+  return `${COWORK_MARKER}\n${intro}\n\n${parts.join('\n')}`;
+}
+
+function firstLine(file) {
+  const raw = readFileSync(file, 'utf8');
+  const i = raw.indexOf('\n');
+  return (i === -1 ? raw : raw.slice(0, i)).replace(/\r$/, '').trim();
+}
+
+const isOwned = (file) => { try { return firstLine(file) === COWORK_MARKER; } catch { return false; } };
+
+// ---------- git exclude ----------
+
+const git = (dir, args) => execFileSync('git', ['-C', dir, ...args], {
+  timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf8',
+}).trim();
+
+function addGitExclude(dir) {
+  try {
+    if (git(dir, ['rev-parse', '--is-inside-work-tree']) !== 'true') return;
+    const rel = COPY_REL.split(sep).join('/');
+    try { git(dir, ['check-ignore', '-q', rel]); return; } catch { /* exit 1: not ignored yet */ }
+    const excludeFile = resolve(dir, git(dir, ['rev-parse', '--git-path', 'info/exclude']));
+    const prefix = git(dir, ['rev-parse', '--show-prefix']);
+    const line = `/${prefix}${rel}`;
+    let existing = '';
+    try { existing = readFileSync(excludeFile, 'utf8'); } catch { /* new file */ }
+    if (existing.split(/\r?\n/).includes(line)) return;
+    mkdirSync(resolve(excludeFile, '..'), { recursive: true });
+    appendFileSync(excludeFile, `${existing && !existing.endsWith('\n') ? '\n' : ''}${line}\n`);
+  } catch (e) {
+    debug('cowork-sync:git-exclude', e);
+  }
+}
+
+// ---------- settings.json (Code tab de-dup) ----------
+
+const settingsFile = () => join(claudeUserDir(), 'settings.json');
+
+function ensureClaudeMdExclude() {
+  const file = settingsFile();
+  const read = readSettings(file);
+  if (read.state !== 'ok' && read.state !== 'absent') return;
+  const cur = read.settings.claudeMdExcludes;
+  if (cur !== undefined && !Array.isArray(cur)) return; // not ours to reshape
+  if (cur && cur.includes(COWORK_EXCLUDE_PATTERN)) return;
+  read.settings.claudeMdExcludes = [...(cur || []), COWORK_EXCLUDE_PATTERN];
+  const problem = writeSettings(file, read.settings);
+  if (problem) debug('cowork-sync:settings-write', problem);
+}
+
+function dropClaudeMdExclude() {
+  const file = settingsFile();
+  const read = readSettings(file);
+  if (read.state !== 'ok') return;
+  const cur = read.settings.claudeMdExcludes;
+  if (!Array.isArray(cur) || !cur.includes(COWORK_EXCLUDE_PATTERN)) return;
+  const next = cur.filter((x) => x !== COWORK_EXCLUDE_PATTERN);
+  if (next.length) read.settings.claudeMdExcludes = next;
+  else delete read.settings.claudeMdExcludes;
+  const problem = writeSettings(file, read.settings);
+  if (problem) debug('cowork-sync:settings-write', problem);
+}
+
+// ---------- sync / remove ----------
+
+export function syncCoworkRatchets({ discover = true, agent = 'claude' } = {}) {
+  const result = { written: [], unchanged: [], skipped: [], removed: [] };
+  if (agent === 'codex') return result;
+  try {
+    if (!coworkConfig().sync) return removeCoworkRatchets();
+    const state = loadCoworkState();
+    if (discover) {
+      try { discoverCoworkFolders({ state }); } catch (e) { debug('cowork-sync:discover', e); }
+    }
+    const content = renderCoworkRatchet();
+    for (const folder of Object.keys(state.folders)) {
+      try {
+        const el = eligibleFolder(folder);
+        if (!el.ok) { result.skipped.push({ dir: folder, reason: el.reason }); continue; }
+        if (content === null) { result.skipped.push({ dir: folder, reason: 'no-source' }); continue; }
+        const target = coworkCopyPath(el.dir);
+        if (existsSync(target)) {
+          if (!isOwned(target)) { result.skipped.push({ dir: folder, reason: 'not-owned' }); continue; }
+          if (readFileSync(target, 'utf8') === content) {
+            result.unchanged.push(folder);
+            state.written[target] = state.written[target] || { at: new Date().toISOString() };
+            continue;
+          }
+        }
+        mkdirSync(join(el.dir, '.claude', 'rules'), { recursive: true });
+        writeFileSync(target, content);
+        state.written[target] = { at: new Date().toISOString() };
+        result.written.push(folder);
+        addGitExclude(el.dir);
+      } catch (e) {
+        result.skipped.push({ dir: folder, reason: `error: ${e?.message || e}` });
+      }
+    }
+    if (result.written.length || result.unchanged.length) {
+      try { ensureClaudeMdExclude(); } catch (e) { debug('cowork-sync:settings', e); }
+    }
+    state.lastSync = new Date().toISOString();
+    saveCoworkState(state);
+  } catch (e) {
+    debug('cowork-sync:sync', e);
+  }
+  return result;
+}
+
+/** Remove the copy in one folder (only when it carries our marker). */
+export function removeCoworkRatchetIn(dir) {
+  const candidates = new Set([coworkCopyPath(dir), coworkCopyPath(real(dir))]);
+  let removed = false;
+  const state = loadCoworkState();
+  for (const target of candidates) {
+    try {
+      if (existsSync(target) && isOwned(target)) { rmSync(target, { force: true }); removed = true; }
+    } catch (e) { debug('cowork-sync:remove-one', e); }
+    delete state.written[target];
+  }
+  saveCoworkState(state);
+  return removed;
+}
+
+export function removeCoworkRatchets() {
+  const result = { written: [], unchanged: [], skipped: [], removed: [] };
+  try {
+    const state = loadCoworkState();
+    const targets = new Set(Object.keys(state.written));
+    for (const folder of Object.keys(state.folders)) targets.add(coworkCopyPath(folder));
+    for (const target of targets) {
+      try {
+        if (existsSync(target) && isOwned(target)) {
+          rmSync(target, { force: true });
+          result.removed.push(resolve(target, '..', '..', '..'));
+        }
+      } catch (e) {
+        result.skipped.push({ dir: target, reason: `error: ${e?.message || e}` });
+      }
+    }
+    state.written = {};
+    saveCoworkState(state);
+    try { dropClaudeMdExclude(); } catch (e) { debug('cowork-sync:settings', e); }
+  } catch (e) {
+    debug('cowork-sync:remove', e);
+  }
+  return result;
+}
+
+/** Per-folder view for `sprag cowork`. */
+export function coworkStatus() {
+  const state = loadCoworkState();
+  const cfg = coworkConfig();
+  const folders = Object.keys(state.folders).map((dir) => {
+    const el = eligibleFolder(dir);
+    const copy = coworkCopyPath(el.ok ? el.dir : dir);
+    const there = existsSync(copy);
+    return { dir, eligible: el.ok, reason: el.reason, hasCopy: there && isOwned(copy), foreign: there && !isOwned(copy) };
+  });
+  return { enabled: cfg.sync, exclude: cfg.exclude, lastSync: state.lastSync || null, folders };
+}

package/src/delegation-agents.js

@@ -0,0 +1,133 @@
+/**
+ * Delegation-only subagents: Claude Code agents with a `tools` allowlist.
+ *
+ * Behind a gateway (ANTHROPIC_BASE_URL) Claude Code turns MCP tool search off,
+ * so every MCP tool definition rides along on each subagent request. A
+ * `general-purpose` haiku measured 46,618 tokens on its first request; a haiku
+ * agent limited to Read/Grep/Glob/Bash measured 20,141. A `tools` allowlist
+ * excludes MCP tools by definition, which is the whole saving.
+ *
+ * The files live in ~/.claude/agents and carry an ownership marker inside the
+ * frontmatter (a YAML comment, so it never reaches the prompt). Only files with
+ * that marker are ever overwritten or deleted; a same-named user file is left.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { claudeUserDir } from './paths.js';
+import { loadConfig } from './config.js';
+
+export const OWNER_MARK = 'sprag:delegation-agent';
+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.
+export const DEFINITIONS = [
+  {
+    name: 'haiku-explore',
+    model: 'haiku',
+    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',
+    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',
+    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',
+    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.',
+  },
+];
+
+function render(def) {
+  return [
+    '---',
+    `name: ${def.name}`,
+    `description: ${def.description}`,
+    `tools: ${def.tools}`,
+    `model: ${def.model}`,
+    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.',
+    '',
+  ].join('\n');
+}
+
+const agentsDir = () => join(claudeUserDir(), 'agents');
+const fileOf = (name) => join(agentsDir(), `${name}.md`);
+
+/** True when the marker sits inside the leading frontmatter block. */
+function isOwned(text) {
+  if (!text.startsWith('---')) return false;
+  const end = text.indexOf('\n---', 3);
+  return (end === -1 ? text : text.slice(0, end)).includes(OWNER_MARK);
+}
+
+function readOwned(path) {
+  try { return { text: readFileSync(path, 'utf8') }; } catch { return null; }
+}
+
+export function removeDelegationAgents() {
+  const removed = [];
+  for (const def of DEFINITIONS) {
+    const p = fileOf(def.name);
+    try {
+      const f = readOwned(p);
+      if (f && isOwned(f.text)) { unlinkSync(p); removed.push(def.name); }
+    } catch { /* one file failing does not stop the rest */ }
+  }
+  return { written: [], unchanged: [], skipped: [], removed };
+}
+
+export function syncDelegationAgents({ agent = 'claude' } = {}) {
+  const res = { written: [], unchanged: [], skipped: [], removed: [] };
+  if (agent === 'codex') return res;
+  try {
+    if (loadConfig().delegationAgents === false) return removeDelegationAgents();
+  } catch { /* an unreadable config means the default, on */ }
+  for (const def of DEFINITIONS) {
+    try {
+      const p = fileOf(def.name);
+      const want = render(def);
+      const cur = existsSync(p) ? readOwned(p) : null;
+      if (existsSync(p) && !cur) { res.skipped.push({ name: def.name, reason: 'unreadable' }); continue; }
+      if (cur && !isOwned(cur.text)) { res.skipped.push({ name: def.name, reason: 'not-owned' }); continue; }
+      if (cur && cur.text === want) { res.unchanged.push(def.name); continue; }
+      mkdirSync(agentsDir(), { recursive: true });
+      writeFileSync(p, want);
+      res.written.push(def.name);
+    } catch (e) {
+      res.skipped.push({ name: def.name, reason: `error: ${e.message}` });
+    }
+  }
+  return res;
+}
+
+export function delegationAgentStatus() {
+  let enabled = true;
+  try { enabled = loadConfig().delegationAgents !== false; } catch { /* default on */ }
+  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 };
+  });
+  return { enabled, agents };
+}