sprag-cli 3.65.0 → 3.67.0

package/src/commands/install.js

@@ -87,6 +87,8 @@ export async function run({ hasFlag }) {
     print('PostToolUse hook (delegation rescan)', r.delegationHook);
     print('mod (delegation meter, Claude Code 2.1.287+)', r.delegationMeterMod);
     if (r.delegationMeterMod.reason) console.log(`    ${r.delegationMeterMod.reason}`);
+    print('mod (desktop statusline, Claude Code 2.1.287+)', r.statuslineMod);
+    if (r.statuslineMod.reason) console.log(`    ${r.statuslineMod.reason}`);
     print('UserPromptSubmit hook (brief)', r.briefHook);
     {
       let s = r.statusline;
@@ -366,6 +368,17 @@ export async function run({ hasFlag }) {
     // they have not read. All the install does is say what is waiting.
     // Presets now live in ratchet-preset.md. Moving the ones older versions
     // appended to ratchet.md comes first, so they are not offered again below.
+    try {
+      const d = (await import('../delegation-agents.js')).syncDelegationAgents();
+      if (d.written.length) {
+        console.log(lang === 'ko'
+          ? `  agents: 위임 전용 에이전트 ${d.written.length}개를 ~/.claude/agents 에 설치했습니다 (MCP 도구 없음).`
+          : `  agents: installed ${d.written.length} delegation-only agent(s) in ~/.claude/agents (no MCP tools).`);
+      }
+    } catch (e) {
+      debug('install:delegation-agents', e);
+    }
+
     try {
       const { preparePresetRatchet } = await import('../preset-ratchet.js');
       const p = preparePresetRatchet();

package/src/commands/route-scan.js

@@ -296,11 +296,15 @@ 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.
+      // 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); }
       // Same reason for the preset ratchet: an upgrade that rewords or drops a
       // bundled rule reaches ratchet-preset.md here, without a reinstall. It
       // also moves presets older versions appended to ratchet.md.
       try { (await import('../preset-ratchet.js')).preparePresetRatchet(); } catch (e) { debug('route-scan:sync-preset', e); }
+      // Cowork cannot follow the ~/.claude imports, so it gets a pasted copy.
+      try { (await import('../cowork-sync.js')).syncCoworkRatchets({ discover: true }); } catch (e) { debug('route-scan:cowork-sync', e); }
       // Registered rules whose delegated-category error rate crossed the
       // health threshold since promotion — the user approved these, so a
       // status change must be briefed, not just written into the md file.
@@ -466,6 +470,8 @@ export async function run({ args, hasFlag, numArg }) {
     let cache = rs.readRouteScan();
     if (hasFlag('--refresh') || (cache && cache.days !== days) || await rs.shouldRescan(cache, { days })) {
       cache = await rs.runRouteScan({ days });
+      // model-rules were rewritten by the scan; carry them to the Cowork copies.
+      try { (await import('../cowork-sync.js')).syncCoworkRatchets({ discover: true }); } catch (e) { debug('route-scan:cowork-sync', e); }
     }
     if (hasFlag('--quiet')) return;
     if (hasFlag('--json')) {

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 {

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 };
+}