sprag-cli 3.66.0 → 3.68.0

package/src/commands/codex.js

@@ -1,6 +1,6 @@
 import { createArgs } from '../cli-args.js';
-import { configureCodexHooks } from '../codex-installer.js';
-import { initCodexHarness, uninitCodexHarness, codexHarnessStatus, syncCodexKoreanBlock } from '../codex-harness.js';
+import { configureCodexHooks } from '../codex/installer.js';
+import { initCodexHarness, uninitCodexHarness, codexHarnessStatus, syncCodexKoreanBlock } from '../codex/harness.js';
 import { findProjectRoot, harnessPromote, harnessListRules, harnessRmRule, harnessPrune } from '../harness.js';
 import { loadConfig, saveConfig } from '../config.js';
 import { resolve } from 'node:path';
@@ -103,7 +103,7 @@ export async function run({ args, version }) {
   const selectedRoot = !['harness', 'delegate', 'seed'].includes(cmd) && getArg('--project') ? resolve(getArg('--project')) : root;
   const format = getArg('--format') || getArg('-f') || 'table';
   if (cmd === 'cache') {
-    const { parseCodexCacheTtl } = await import('../codex-cache.js');
+    const { parseCodexCacheTtl } = await import('../codex/cache.js');
     const mode = args[1] || 'status';
     const cfg = loadConfig();
     if (mode !== 'status') {
@@ -113,13 +113,13 @@ export async function run({ args, version }) {
     }
     const ttl = cfg.codex?.cacheTtl ?? 'auto';
     console.log(`Codex cache timer: ${typeof ttl === 'number' ? `${ttl / 60}m (configured estimate)` : ttl}`);
-    const { createPanelReader } = await import('../codex-panel.js');
-    const { refreshCodexCachePolicy } = await import('../codex-cache-policy.js');
-    const { codexCacheTimer } = await import('../codex-cache.js');
+    const { createPanelReader } = await import('../codex/panel.js');
+    const { refreshCodexCachePolicy } = await import('../codex/cache-policy.js');
+    const { codexCacheTimer } = await import('../codex/cache.js');
     const data = await createPanelReader({ root: selectedRoot, sessionId: getArg('--session'),
       ...(hasFlag('--refresh') ? { readCachePolicy: refreshCodexCachePolicy } : {}) })();
     if (data.session) {
-      const { terminalText } = await import('../codex-panel.js');
+      const { terminalText } = await import('../codex/panel.js');
       console.log(`Session: ${terminalText(data.session.sessionId)} | ${terminalText(data.session.provider)} / ${terminalText(data.session.model)}`);
       if (data.cachePolicy) {
         const p = data.cachePolicy;
@@ -133,11 +133,11 @@ export async function run({ args, version }) {
   }
   if (cmd === 'capabilities' || cmd === 'doctor') {
     if (!['table', 'json'].includes(format)) throw new Error('Diagnostics format must be table or json.');
-    const { codexDoctor, CODEX_CAPABILITIES } = await import('../codex-doctor.js');
+    const { codexDoctor, CODEX_CAPABILITIES } = await import('../codex/doctor.js');
     const report = cmd === 'capabilities' ? { agent: 'codex', capabilities: CODEX_CAPABILITIES }
       : await codexDoctor({ root: selectedRoot, sessionId: getArg('--session'), days: numArg('--days', { dflt: 7, min: 0 }) });
     if (format === 'json') { console.log(JSON.stringify(report, null, 2)); return; }
-    const { terminalText } = await import('../codex-panel.js');
+    const { terminalText } = await import('../codex/panel.js');
     if (cmd === 'doctor') {
       console.log(`Codex home: ${terminalText(report.home)}`);
       console.log(`Config: ${report.config.error || (report.config.present ? 'readable' : 'absent (defaults)')}`);
@@ -161,10 +161,10 @@ export async function run({ args, version }) {
   if (cmd === 'saved') return (await import('./saved.js')).run({ args, hasFlag, agent: 'codex' });
   if (cmd === 'seed') return (await import('./seed.js')).run({ args, hasFlag, agent: 'codex', root });
   if (cmd === 'route-scan') {
-    const rs = await import('../codex-route-scan.js');
+    const rs = await import('../codex/route-scan.js');
     const days = numArg('--days', { dflt: 14, min: 1 });
     if (args[1] === 'savings') {
-      const { refreshCodexLedger, loadCodexLedger, codexRoutingSavedTotals } = await import('../codex-ledger.js');
+      const { refreshCodexLedger, loadCodexLedger, codexRoutingSavedTotals } = await import('../codex/ledger.js');
       if (hasFlag('--refresh')) await refreshCodexLedger();
       // The prompt hook runs this detached to price finished delegations.
       if (hasFlag('--quiet')) return;
@@ -190,7 +190,7 @@ export async function run({ args, version }) {
     let cache = rs.readCodexRouteScan();
     if (hasFlag('--refresh') || !cache) {
       // Prices live in the gateway snapshot; refresh it when stale so candidates can name a target.
-      const { readCodexPrices, refreshCodexPrices } = await import('../codex-cache-policy.js');
+      const { readCodexPrices, refreshCodexPrices } = await import('../codex/cache-policy.js');
       if (!readCodexPrices()) { try { await refreshCodexPrices(); } catch (e) { debug('codex:prices', e); } }
       cache = await rs.runCodexRouteScan({ days });
     }
@@ -225,8 +225,8 @@ export async function run({ args, version }) {
       console.log('Run sprag install --agent codex and review/trust hooks in Codex /hooks.');
       return;
     }
-    const { createPanelReader, terminalText } = await import('../codex-panel.js');
-    const { codexIssues } = await import('../codex-brief.js');
+    const { createPanelReader, terminalText } = await import('../codex/panel.js');
+    const { codexIssues } = await import('../codex/brief.js');
     const data = await createPanelReader({ root: selectedRoot, sessionId: getArg('--session'), days: numArg('--days', { dflt: 7, min: 0 }) })();
     const issues = codexIssues(data.session);
     if (!issues.length) console.log('No fresh Codex context or rate-limit warnings. Missing/stale logs do not prove healthy usage.');
@@ -238,8 +238,8 @@ export async function run({ args, version }) {
   }
   if (cmd === 'history' || cmd === 'last') {
     if (!['table', 'json'].includes(format)) throw new Error('History format must be table or json.');
-    const { readCodexHistory } = await import('../codex-brief.js');
-    const { terminalText } = await import('../codex-panel.js');
+    const { readCodexHistory } = await import('../codex/brief.js');
+    const { terminalText } = await import('../codex/panel.js');
     let events = readCodexHistory({ days: numArg('--days', { dflt: cmd === 'last' ? 1 : 7, min: 0 }),
       sessionId: getArg('--session'), project: getArg('--project') || getArg('-p') });
     if (cmd === 'last') events = events.slice(-1);
@@ -253,13 +253,13 @@ export async function run({ args, version }) {
     return;
   }
   if (cmd === 'handoff') {
-    const { createPanelReader } = await import('../codex-panel.js');
+    const { createPanelReader } = await import('../codex/panel.js');
     const { writeHandoff } = await import('../handoff.js');
     const cwd = getArg('--cwd') || process.cwd();
     const data = await createPanelReader({ root: findProjectRoot(resolve(cwd), { agent: 'codex' }), sessionId: getArg('--session'), days: numArg('--days', { dflt: 7, min: 0 }) })();
     const result = writeHandoff({ cwd, agent: 'codex', session: data.session });
     try {
-      const { recordCodexHistoryEvent } = await import('../codex-brief.js');
+      const { recordCodexHistoryEvent } = await import('../codex/brief.js');
       recordCodexHistoryEvent({ sessionId: data.session?.sessionId, project: cwd, key: 'handoff',
         message: `Handoff written: ${result.path}` });
     } catch (e) { debug('codex:handoff-record', e); }
@@ -269,7 +269,7 @@ export async function run({ args, version }) {
   }
   const statusline = hasFlag('--statusline') || format === 'statusline';
   if (statusline && (!cmd || cmd.startsWith('-'))) {
-    const { createPanelReader, formatCodexPanel } = await import('../codex-panel.js');
+    const { createPanelReader, formatCodexPanel } = await import('../codex/panel.js');
     const data = await createPanelReader({ root: selectedRoot, sessionId: getArg('--session'), days: numArg('--days', { dflt: 7, min: 0 }), hasFlag, version })();
     const columns = numArg('--columns', { dflt: process.stdout.columns || 100, min: 1, max: 10000 });
     const text = formatCodexPanel(data, { compact: true, columns: hasFlag('--single-line') ? 100000 : columns,
@@ -281,7 +281,7 @@ export async function run({ args, version }) {
     if (args[1] === 'run') {
       const separator = args.indexOf('--');
       const forwarded = separator < 0 ? [] : args.slice(separator + 1);
-      const { runCodexWithPanel } = await import('../codex-panel-runner.js');
+      const { runCodexWithPanel } = await import('../codex/panel-runner.js');
       let project = process.cwd();
       for (let i = 0; i < forwarded.length; i++) {
         if (forwarded[i] === '--') break;
@@ -294,7 +294,7 @@ export async function run({ args, version }) {
     if (args[1] === 'shell') {
       if (process.platform !== 'darwin') throw new Error('Immediate panel launch currently supports macOS zsh.');
       if (!['install', 'remove'].includes(args[2])) throw new Error('Usage: sprag panel shell install|remove --agent codex');
-      const { installPanelShell } = await import('../codex-panel-shell.js');
+      const { installPanelShell } = await import('../codex/panel-shell.js');
       const file = installPanelShell({ remove: args[2] === 'remove' });
       // install adds the integration by default, so a removal must be
       // remembered or the next upgrade puts it back.
@@ -304,10 +304,10 @@ export async function run({ args, version }) {
       console.log(`Shell integration ${args[2]}: ${file}. Open a new terminal to apply it.`);
       return;
     }
-    const { recordPanelState, panelHealth } = await import('../codex-panel-state.js');
+    const { recordPanelState, panelHealth } = await import('../codex/panel-state.js');
     const panelRoot = getArg('--project') ? resolve(getArg('--project')) : root;
     if (args[1] === 'doctor') {
-      const { codexPanelAutoEnabled } = await import('../codex-installer.js');
+      const { codexPanelAutoEnabled } = await import('../codex/installer.js');
       const health = panelHealth(panelRoot, { sessionId: getArg('--session') });
       console.log(`Panel hook registered: ${codexPanelAutoEnabled() ? 'yes' : 'no'}`);
       console.log(`Project: ${panelRoot}`);
@@ -320,7 +320,7 @@ export async function run({ args, version }) {
       return;
     }
     if (args[1] === 'auto') {
-      const { codexPanelAutoEnabled } = await import('../codex-installer.js');
+      const { codexPanelAutoEnabled } = await import('../codex/installer.js');
       const mode = args[2] || 'status';
       if (!['on', 'off', 'status'].includes(mode)) throw new Error('Usage: sprag panel auto on|off|status --agent codex');
       if (mode === 'on' && process.platform !== 'darwin') throw new Error('Automatic panel windows currently require macOS Terminal.');
@@ -335,13 +335,13 @@ export async function run({ args, version }) {
       return;
     }
     if (hasFlag('--open')) {
-      const { openCodexPanel } = await import('../codex-panel-launcher.js');
+      const { openCodexPanel } = await import('../codex/panel-launcher.js');
       console.log(`Codex panel: ${openCodexPanel(getArg('--project') || root, { sessionId: getArg('--session') })}`);
       return;
     }
-    const { createPanelReader, runCodexPanel } = await import('../codex-panel.js');
-    const { createCodexCachePolicyReader, refreshCodexCachePolicy } = await import('../codex-cache-policy.js');
-    const { createCodexBudgetReader, codexBudgetProvider, fetchCodexBudget } = await import('../codex-budget.js');
+    const { createPanelReader, runCodexPanel } = await import('../codex/panel.js');
+    const { createCodexCachePolicyReader, refreshCodexCachePolicy } = await import('../codex/cache-policy.js');
+    const { createCodexBudgetReader, codexBudgetProvider, fetchCodexBudget } = await import('../codex/budget.js');
     const readBudget = hasFlag('--once') ? (() => {
       let snapshot = null;
       return { read: () => snapshot, set: (value) => { snapshot = value; } };
@@ -350,7 +350,7 @@ export async function run({ args, version }) {
       const provider = codexBudgetProvider();
       if (provider) { try { readBudget.set(await fetchCodexBudget(provider)); } catch (e) { debug('codex:budget', e); } }
     }
-    const { createInlinePanelResizer } = await import('../codex-panel-runner.js');
+    const { createInlinePanelResizer } = await import('../codex/panel-runner.js');
     const rawInterval = getArg('--interval');
     const interval = rawInterval === undefined ? 2 : Number(rawInterval);
     if (!Number.isFinite(interval) || interval < 0.5 || interval > 60) throw new Error('--interval must be between 0.5 and 60 seconds');
@@ -362,7 +362,7 @@ export async function run({ args, version }) {
       read: createPanelReader({ root: getArg('--project') ? resolve(getArg('--project')) : root,
         sessionId: getArg('--session'), sessionFile: getArg('--session-file'), days: numArg('--days', { dflt: 7, min: 0 }), readBudget: readBudget.read,
         version, refreshUpdate: !hasFlag('--once'), readCachePolicy: hasFlag('--once') ? async (session) => {
-          const { readCodexCachePolicy } = await import('../codex-cache-policy.js');
+          const { readCodexCachePolicy } = await import('../codex/cache-policy.js');
           try { return readCodexCachePolicy(session) || await refreshCodexCachePolicy(session); }
           catch (e) { debug('codex:cache-policy', e); return null; }
         } : createCodexCachePolicyReader(), hasFlag }),
@@ -378,16 +378,16 @@ export async function run({ args, version }) {
   }
   if (cmd === 'codex-hook') {
     const { readStdinJson } = await import('../stdin-payload.js');
-    const { codexHookOutput } = await import('../codex-hooks.js');
+    const { codexHookOutput } = await import('../codex/hooks.js');
     try {
       const payload = readStdinJson();
-      const { bindPanelSession } = await import('../codex-panel-session.js');
+      const { bindPanelSession } = await import('../codex/panel-session.js');
       bindPanelSession(getArg('--event'), payload);
       if (getArg('--event') === 'panel-start') {
         if (process.env.SPRAG_CODEX_PANEL === '1') return;
         if (!payload?.cwd || typeof payload.session_id !== 'string' || !payload.session_id.trim() || !['startup', 'resume'].includes(payload.source)) return;
-        const { openCodexPanel } = await import('../codex-panel-launcher.js');
-        const { recordPanelState } = await import('../codex-panel-state.js');
+        const { openCodexPanel } = await import('../codex/panel-launcher.js');
+        const { recordPanelState } = await import('../codex/panel-state.js');
         const panelRoot = findProjectRoot(payload.cwd, { agent: 'codex' });
         recordPanelState(panelRoot, 'hook', { status: 'started', sessionId: payload.session_id });
         try {
@@ -406,7 +406,7 @@ export async function run({ args, version }) {
   }
   if (cmd === 'install') {
     const cfg = loadConfig();
-    const { setupCodexPanel, describePanelSetup } = await import('../codex-panel-setup.js');
+    const { setupCodexPanel, describePanelSetup } = await import('../codex/panel-setup.js');
     const panel = setupCodexPanel({ config: cfg || {}, noPanel: hasFlag('--no-panel') });
     const panelAuto = panel.panelAuto;
     const hook = configureCodexHooks({ panelAuto });
@@ -432,7 +432,7 @@ export async function run({ args, version }) {
     console.log('Existing config.toml, Claude Code settings, and ratchet rules are preserved.');
     try {
       const { codexModelName, codexProviderName } = await import('../agent.js');
-      const { autoCodexSharedTargets } = await import('../codex-delegation.js');
+      const { autoCodexSharedTargets } = await import('../codex/delegation.js');
       const parent = codexModelName(), provider = codexProviderName();
       const auto = parent ? autoCodexSharedTargets({ model: parent, provider }) : { targets: [], reason: 'Codex config names no default model' };
       console.log(auto.targets.length
@@ -447,7 +447,7 @@ export async function run({ args, version }) {
     if (hasFlag('--purge')) throw new Error('Codex uninstall keeps shared Sprag state; --purge is not supported.');
     const hook = configureCodexHooks({ remove: true });
     const h = uninitCodexHarness({ root, scope: 'global' });
-    const { installPanelShell } = await import('../codex-panel-shell.js');
+    const { installPanelShell } = await import('../codex/panel-shell.js');
     const shellFile = installPanelShell({ remove: true });
     console.log(`Codex hooks: ${hook.file} (${hook.action})`);
     console.log(`Codex harness: ${h.file} (${h.removed ? 'removed' : 'absent'})`);
@@ -481,8 +481,8 @@ export async function run({ args, version }) {
       if (!rule) throw new Error('Provide rule text or a ratchet candidate number (see ratchet? in sprag --statusline --agent codex).');
       if (/^R\d+$/i.test(rule)) throw new Error(`Approve route candidates with: sprag delegate rules add ${rule.toUpperCase()} --global|--project --agent codex`);
       if (/^\d+$/.test(rule)) {
-        const { createPanelReader } = await import('../codex-panel.js');
-        const { codexCandidateRule } = await import('../codex-harness.js');
+        const { createPanelReader } = await import('../codex/panel.js');
+        const { codexCandidateRule } = await import('../codex/harness.js');
         const { userLanguage } = await import('../config.js');
         const data = await createPanelReader({ root, sessionId: getArg('--session') })();
         const cand = (data.ratchet || []).find((c) => c.id === Number(rule));
@@ -543,7 +543,7 @@ export async function run({ args, version }) {
   if (cmd === 'doc2md' && (!args[1] || args[1] === 'status')) {
     const { createRequire } = await import('node:module');
     const doc2md = createRequire(import.meta.url)('../doc2md.cjs');
-    const { codexHookStatus } = await import('../codex-installer.js');
+    const { codexHookStatus } = await import('../codex/installer.js');
     console.log(`Codex document conversion: ${loadConfig()?.codex?.doc2md === false || process.env.CTS_NO_DOC2MD === '1' ? 'off' : 'on'}`);
     console.log(`Formats: ${doc2md.TARGET_EXTENSIONS.join(' ')}`);
     console.log(`Converter: ${doc2md.findInterpreter() || 'missing; run sprag doc2md install-converter --agent codex'}`);
@@ -558,7 +558,7 @@ export async function run({ args, version }) {
     return;
   }
   if (cmd === 'doc2md' && args[1] === 'savings') {
-    const { codexDocumentTotals } = await import('../codex-doc2md-ledger.js');
+    const { codexDocumentTotals } = await import('../codex/doc2md-ledger.js');
     const totals = codexDocumentTotals();
     if (format === 'json') console.log(JSON.stringify({ agent: 'codex', ...totals }, null, 2));
     else {
@@ -569,11 +569,11 @@ export async function run({ args, version }) {
     return;
   }
   if (cmd === 'doc2md' && args[1] && !args[1].startsWith('-') && args[1] !== 'install-converter') {
-    const { convertCodexDocument } = await import('../codex-doc2md.js');
+    const { convertCodexDocument } = await import('../codex/doc2md.js');
     const sessionId = getArg('--session') || process.env.CODEX_THREAD_ID;
     let identity = {};
     if (sessionId) {
-      const { createPanelReader } = await import('../codex-panel.js');
+      const { createPanelReader } = await import('../codex/panel.js');
       const { session } = await createPanelReader({ root, sessionId })();
       if (session) identity = { model: session.model, provider: session.provider };
     }
@@ -617,7 +617,7 @@ export async function run({ args, version }) {
   const days = numArg('--hours', { min: 0 }) !== undefined ? numArg('--hours', { min: 0 }) / 24
     : (numArg('--days', { min: 0 }) ?? numArg('-d', { min: 0 }) ?? 30);
   if (!['table', 'json', 'csv'].includes(format)) throw new Error('Codex report format must be table, json, or csv.');
-  const { parseAllCodexSessions } = await import('../codex-parser.js');
+  const { parseAllCodexSessions } = await import('../codex/parser.js');
   const { summary, dailyTrend } = await import('../stats.js');
   const sessions = (await parseAllCodexSessions({ days, projectFilter: getArg('--project') || getArg('-p') }))
     .filter((session) => !getArg('--session') || session.sessionId === getArg('--session'));

package/src/commands/cowork.js

@@ -0,0 +1,107 @@
+/**
+ * Subcommand: cowork : keep the Claude app's Cowork tab on the same ratchet rules.
+ *
+ *   sprag cowork                  status
+ *   sprag cowork sync             discover connected folders and write the copies now
+ *   sprag cowork on | off         turn the sync on (and sync) or off (and remove the copies)
+ *   sprag cowork exclude <dir>    never write into <dir> (removes its copy)
+ *   sprag cowork include <dir>    undo exclude (and sync)
+ */
+
+import { resolve } from 'node:path';
+import { realpathSync } from 'node:fs';
+
+const REASONS = {
+  ko: {
+    'not-absolute': '절대 경로가 아님', missing: '폴더가 없음', 'not-a-directory': '디렉터리가 아님',
+    'home-or-ancestor': '홈 디렉터리 또는 그 상위 경로', 'inside-claude-dir': '~/.claude 안',
+    'inside-library': '~/Library 안', 'inside-sprag-data': 'sprag 데이터 폴더 안', excluded: '제외 목록에 있음',
+    'not-owned': '같은 이름의 사용자 파일이 있어 덮어쓰지 않음', 'no-source': '복사할 원본 래칫 파일이 없음',
+  },
+  en: {
+    'not-absolute': 'not an absolute path', missing: 'folder does not exist', 'not-a-directory': 'not a directory',
+    'home-or-ancestor': 'the home directory or one of its parents', 'inside-claude-dir': 'inside ~/.claude',
+    'inside-library': 'inside ~/Library', 'inside-sprag-data': 'inside the sprag data folder', excluded: 'on the exclude list',
+    'not-owned': 'a user file of the same name exists, not overwritten', 'no-source': 'no source ratchet file to copy',
+  },
+};
+
+const norm = (p) => {
+  const abs = resolve(p);
+  try { return realpathSync(abs); } catch { return abs; }
+};
+
+export async function run({ args }) {
+  const cw = await import('../cowork-sync.js');
+  const { userLanguage } = await import('../config.js');
+  const ko = userLanguage() === 'ko';
+  const why = (r) => (REASONS[ko ? 'ko' : 'en'][r] || r);
+  const sub = args[1];
+
+  const summarize = (r) => {
+    console.log(ko
+      ? `Cowork 래칫 동기화: 새로 씀 ${r.written.length}, 변경 없음 ${r.unchanged.length}, 건너뜀 ${r.skipped.length}, 제거 ${r.removed.length}`
+      : `Cowork ratchet sync: written ${r.written.length}, unchanged ${r.unchanged.length}, skipped ${r.skipped.length}, removed ${r.removed.length}`);
+    for (const d of r.written) console.log(`  + ${d}`);
+    for (const d of r.removed) console.log(`  - ${d}`);
+    for (const s of r.skipped) console.log(`  ! ${s.dir} (${why(s.reason)})`);
+  };
+
+  if (sub === 'sync') return summarize(cw.syncCoworkRatchets({ discover: true }));
+
+  if (sub === 'off') {
+    cw.saveCoworkConfig({ sync: false });
+    console.log(ko ? 'Cowork 래칫 동기화를 껐습니다. 만들어 둔 사본을 지웁니다.' : 'Cowork ratchet sync is off. Removing the copies it made.');
+    return summarize(cw.removeCoworkRatchets());
+  }
+
+  if (sub === 'on') {
+    cw.saveCoworkConfig({ sync: true });
+    console.log(ko ? 'Cowork 래칫 동기화를 켰습니다.' : 'Cowork ratchet sync is on.');
+    return summarize(cw.syncCoworkRatchets({ discover: true }));
+  }
+
+  if (sub === 'exclude' || sub === 'include') {
+    const target = args.slice(2).find((a) => !a.startsWith('-'));
+    if (!target) {
+      console.error(ko ? '폴더 경로를 지정하십시오.' : 'Pass a folder path.');
+      process.exitCode = 1;
+      return;
+    }
+    const dir = norm(target);
+    const list = cw.coworkConfig().exclude;
+    if (sub === 'exclude') {
+      if (!list.includes(dir)) cw.saveCoworkConfig({ exclude: [...list, dir] });
+      const removed = cw.removeCoworkRatchetIn(dir);
+      console.log(ko
+        ? `제외 목록에 추가했습니다: ${dir}${removed ? ' (사본을 지웠습니다)' : ''}`
+        : `Added to the exclude list: ${dir}${removed ? ' (copy removed)' : ''}`);
+      return;
+    }
+    cw.saveCoworkConfig({ exclude: list.filter((x) => x !== dir && norm(x) !== dir) });
+    console.log(ko ? `제외 목록에서 뺐습니다: ${dir}` : `Removed from the exclude list: ${dir}`);
+    return summarize(cw.syncCoworkRatchets({ discover: true }));
+  }
+
+  if (sub !== undefined) {
+    console.error(ko ? `알 수 없는 하위 명령입니다: ${sub}` : `Unknown subcommand: ${sub}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const st = cw.coworkStatus();
+  console.log(ko ? `Cowork 래칫 동기화: ${st.enabled ? '켜짐' : '꺼짐'}` : `Cowork ratchet sync: ${st.enabled ? 'on' : 'off'}`);
+  console.log(ko ? `마지막 동기화: ${st.lastSync || '없음'}` : `Last sync: ${st.lastSync || 'never'}`);
+  if (st.folders.length === 0) {
+    console.log(ko ? '발견한 Cowork 연결 폴더가 없습니다.' : 'No Cowork folders discovered.');
+    return;
+  }
+  console.log(ko ? '연결 폴더:' : 'Connected folders:');
+  for (const f of st.folders) {
+    const state = f.hasCopy ? (ko ? '사본 있음' : 'copy present')
+      : f.foreign ? why('not-owned')
+      : f.eligible ? (ko ? '사본 없음' : 'no copy yet')
+      : (ko ? `제외: ${why(f.reason)}` : `skipped: ${why(f.reason)}`);
+    console.log(`  ${f.dir}  [${state}]`);
+  }
+}

package/src/commands/delegate.js

@@ -59,6 +59,13 @@ export async function run({ args, hasFlag }) {
   const { userLanguage } = await import('../config.js');
   const lang = userLanguage();
 
+  // `delegate agents` manages the tool-restricted subagent files. It is split
+  // off by the second word so it never mixes with the on/off PreToolUse guard.
+  if (sub === 'agents') {
+    await agentsCommand(args[2], lang);
+    return;
+  }
+
   if (sub === 'on') {
     // Install first, and only record the feature as on once that worked.
     // Saving the flag first left `delegate: on, hook not registered` behind
@@ -131,3 +138,39 @@ export async function run({ args, hasFlag }) {
     console.log('Enable with: sprag delegate on');
   }
 }
+
+async function agentsCommand(action, lang) {
+  const ko = lang === 'ko';
+  const da = await import('../delegation-agents.js');
+  const report = (r) => {
+    for (const n of r.written) console.log(ko ? `✓ ${n} 에이전트를 설치했습니다.` : `✓ installed agent ${n}`);
+    for (const n of r.unchanged) console.log(ko ? `  ${n} 에이전트는 이미 최신입니다.` : `  agent ${n} is already current`);
+    for (const k of r.skipped) {
+      console.log(ko
+        ? `✗ ${k.name} 에이전트는 건너뛰었습니다 (${k.reason === 'not-owned' ? '직접 만든 같은 이름의 파일이 있습니다' : k.reason}).`
+        : `✗ skipped agent ${k.name} (${k.reason})`);
+    }
+    for (const n of r.removed) console.log(ko ? `✓ ${n} 에이전트를 제거했습니다.` : `✓ removed agent ${n}`);
+  };
+  const rerender = async () => {
+    try { (await import('../model-rules.js')).syncAllFiles(); } catch { /* the next session start re-renders */ }
+  };
+
+  if (action === 'on' || action === 'off') {
+    const { loadConfig, saveConfig } = await import('../config.js');
+    saveConfig({ ...loadConfig(), delegationAgents: action === 'on' });
+    const r = action === 'on' ? da.syncDelegationAgents() : da.removeDelegationAgents();
+    await rerender();
+    report(r);
+    console.log(action === 'on'
+      ? (ko ? '위임 전용 에이전트를 켰습니다. 래칫 문구가 에이전트 이름으로 다시 만들어졌습니다.' : 'Delegation agents are on. The ratchet wording was re-rendered with the agent names.')
+      : (ko ? '위임 전용 에이전트를 껐습니다. 래칫 문구가 model 지정 방식으로 다시 만들어졌습니다.' : 'Delegation agents are off. The ratchet wording was re-rendered with plain model tiers.'));
+    return;
+  }
+
+  const st = da.delegationAgentStatus();
+  console.log(ko ? `delegate agents: ${st.enabled ? 'on' : 'off'}` : `delegate agents: ${st.enabled ? 'on' : 'off'}`);
+  const label = { 'installed-by-sprag': ko ? 'sprag 가 설치함' : 'installed by sprag', 'user-file': ko ? '직접 만든 파일' : 'user file', absent: ko ? '없음' : 'absent' };
+  for (const a of st.agents) console.log(`  ${a.name}: ${a.state} (${label[a.state]})`);
+  console.log(ko ? '켜기 또는 끄기: sprag delegate agents on|off' : 'Toggle with: sprag delegate agents on|off');
+}

package/src/commands/install.js

@@ -102,6 +102,9 @@ export async function run({ hasFlag }) {
         console.log(lang === 'ko'
           ? `  statusline: 기존 statusline이 이미 설정되어 있습니다: ${s.existingCommand}`
           : `  statusline: an existing statusline is already configured: ${s.existingCommand}`);
+        // A wrapper around our own CLI is worth naming here too: the non-tty line
+        // below prints the same sentence, so both paths say what the entry is.
+        if (s.wrapper) console.log(`              ${s.reason}`);
         const pick = await choose(lang === 'ko'
           ? '              statusline을 어떻게 표시할까요?'
           : '              How should the statusline be shown?', [
@@ -212,8 +215,8 @@ export async function run({ hasFlag }) {
           console.log(lang === 'ko' ? `  harness: 작성 ${p}` : `  harness: wrote ${p}`);
         }
         console.log(lang === 'ko'
-          ? '  harness: 5원칙을 ~/.claude/CLAUDE.md 에 설정했습니다 — statusline에 🅷 5/5 가 표시됩니다.'
-          : '  harness: 5 principles installed in ~/.claude/CLAUDE.md — the statusline now shows 🅷 5/5.');
+          ? '  harness: 5원칙을 ~/.claude/CLAUDE.md 에 설정했습니다. 점수가 5/5에 못 미치거나 경고가 있을 때 statusline에 🅷 가 표시됩니다.'
+          : '  harness: 5 principles installed in ~/.claude/CLAUDE.md. The statusline shows 🅷 when the score drops below 5/5 or a warning is due.');
         console.log(lang === 'ko'
           ? '           되돌리려면: sprag harness uninit --global'
           : '           to undo: sprag harness uninit --global');
@@ -368,6 +371,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();
@@ -425,15 +439,15 @@ export async function run({ hasFlag }) {
             : '  codex: Codex is installed here. Set up its hooks and harness too?', { defaultValue: true });
         }
         if (proceed) {
-          const { configureCodexHooks } = await import('../codex-installer.js');
-          const { initCodexHarness } = await import('../codex-harness.js');
+          const { configureCodexHooks } = await import('../codex/installer.js');
+          const { initCodexHarness } = await import('../codex/harness.js');
           const { loadConfig } = await import('../config.js');
-          const { setupCodexPanel, describePanelSetup } = await import('../codex-panel-setup.js');
+          const { setupCodexPanel, describePanelSetup } = await import('../codex/panel-setup.js');
           const config = loadConfig() || {};
           // A manual install asks before touching the system package manager.
           let env = process.env;
           if (interactive && process.platform === 'darwin') {
-            const { tmuxAvailable } = await import('../codex-panel-setup.js');
+            const { tmuxAvailable } = await import('../codex/panel-setup.js');
             if (!tmuxAvailable() && !await confirm(lang === 'ko'
               ? '  codex: tmux 가 없습니다. Homebrew 로 설치해 같은 창에 패널을 붙일까요?'
               : '  codex: tmux is missing. Install it with Homebrew so the panel shares the Codex window?', { defaultValue: true })) {
@@ -455,7 +469,7 @@ export async function run({ hasFlag }) {
             const h = initCodexHarness({ scope: 'global' });
             console.log(`  codex: harness ${h.file}`);
             try {
-              const { syncCodexKoreanBlock } = await import('../codex-harness.js');
+              const { syncCodexKoreanBlock } = await import('../codex/harness.js');
               const k = syncCodexKoreanBlock({ cfg: config });
               console.log(`  codex: korean-style ${k.action} (${k.file})`);
             } catch (e) { debug('install:codex-korean', e); }

package/src/commands/korean.js

@@ -224,7 +224,7 @@ export async function run({ args, hasFlag }) {
     const enabled = sub === 'on';
     ks.setKoreanStyleEnabled(enabled);
     // Codex reads the guide from its global AGENTS.md; keep that block in step.
-    try { (await import('../codex-harness.js')).syncCodexKoreanBlock({ cfg: loadConfig() }); } catch (e) { debug('korean:codex-sync', e); }
+    try { (await import('../codex/harness.js')).syncCodexKoreanBlock({ cfg: loadConfig() }); } catch (e) { debug('korean:codex-sync', e); }
     const {
       installKoreanLintHook, removeKoreanLintHook,
       installReplyLanguageHook, removeReplyLanguageHook,

package/src/commands/litellm-budget.js

@@ -0,0 +1,56 @@
+/**
+ * Subcommand: litellm-budget · LiteLLM 게이트웨이 키의 max_budget/spend 조회.
+ *   sprag litellm-budget            # 캐시된 예산을 게이지·금액으로 출력
+ *   sprag litellm-budget --json     # 캐시 원본 JSON 출력
+ *   sprag litellm-budget --refresh  # 지금 프록시에 물어봄 (detached 자식이 사용)
+ */
+
+import { debug } from '../debug.js';
+
+export async function run({ hasFlag }) {
+  const { gatewayBase, readBudgetState, refreshBudgetState, formatBudgetReport, resolveKey } =
+    await import('../litellm-budget.js');
+  const quiet = hasFlag('--quiet');
+  if (hasFlag('--refresh')) {
+    try {
+      // apiKeyHelper 가 토큰 수명(TTL)을 소유합니다. 헬퍼를 한 번만 불러 그
+      // 키를 예산 갱신과 게이트웨이 모델맵 갱신 양쪽에 재사용합니다. 갱신
+      // 경로마다 resolveKey() 를 다시 부르면 사본을 만드는 셈이 되고, 헬퍼
+      // 호출 횟수도 그만큼 늘어납니다.
+      const key = resolveKey();
+      let next = null;
+      if (key) {
+        next = await refreshBudgetState(process.env, fetch, key);
+        const { maybeRefreshGatewayModelMap } = await import('../litellm-models.js');
+        await maybeRefreshGatewayModelMap({ base: gatewayBase(), key });
+      }
+      if (!quiet) console.log(JSON.stringify(next, null, 2));
+    } catch (e) {
+      debug('litellm-budget:refresh', e);
+      if (!quiet) console.error(`litellm-budget refresh failed: ${e.message}`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+  // 읽기 경로는 캐시만 보므로 키를 요구하지 않습니다 (apiKeyHelper 환경 배려).
+  const base = gatewayBase();
+  if (!base) {
+    console.log('게이트웨이가 감지되지 않았습니다 (ANTHROPIC_BASE_URL 필요).');
+    return;
+  }
+  const state = readBudgetState();
+  if (hasFlag('--json')) {
+    console.log(JSON.stringify(state, null, 2));
+    return;
+  }
+  if (state.base !== base || state.maxBudget === undefined) {
+    console.log('예산 캐시가 비어 있습니다. `sprag litellm-budget --refresh` 로 먼저 조회하십시오.');
+    return;
+  }
+  // Same resolver the statusline uses: this report draws a gauge too, and a
+  // glyph the terminal's font lacks garbles here exactly as it does there.
+  const { resolveLabelMode } = await import('../statusline-mode.js');
+  const { statuslineDefaults } = await import('../config.js');
+  const { mode: labelMode } = resolveLabelMode({ hasFlag, cfg: statuslineDefaults() });
+  for (const line of formatBudgetReport(state, new Date(), labelMode)) console.log(line);
+}

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')) {