sprag-cli 3.67.0 → 3.68.0

package/src/{codex-route-scan.js → codex/route-scan.js}

@@ -1,17 +1,17 @@
 import { readFileSync, mkdirSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { userDataDir } from './paths.js';
-import { writeViaTmp } from './state-file.js';
-import { loadConfig } from './config.js';
-import { findProjectRoot } from './harness.js';
-import { discoverCodexSessionFiles, parseCodexTurns } from './codex-parser.js';
+import { userDataDir } from '../paths.js';
+import { writeViaTmp } from '../state-file.js';
+import { loadConfig } from '../config.js';
+import { findProjectRoot } from '../harness.js';
+import { discoverCodexSessionFiles, parseCodexTurns } from './parser.js';
 import { categorize, isSkippable, tierOf, calibrateThresholds, MIN_RECURRENCE,
-  RESCAN_MIN_INTERVAL_MS, RESCAN_BIG_DELTA_BYTES, RESCAN_MAX_AGE_MS } from './route-scan.js';
-import { codexPromptCategory, loadCodexModelRules, sharedCodexModelRules, codexSharedTargets } from './codex-delegation.js';
-import { codexRunCost, codexPriceBook, isDirectOpenAI, readCodexPrices } from './codex-cache-policy.js';
-import { OPENAI_PRICES_CHECKED_AT } from './openai-prices.js';
-import { refreshCodexLedger } from './codex-ledger.js';
+  RESCAN_MIN_INTERVAL_MS, RESCAN_BIG_DELTA_BYTES, RESCAN_MAX_AGE_MS } from '../route-scan.js';
+import { codexPromptCategory, loadCodexModelRules, sharedCodexModelRules, codexSharedTargets } from './delegation.js';
+import { codexRunCost, codexPriceBook, isDirectOpenAI, readCodexPrices } from './cache-policy.js';
+import { OPENAI_PRICES_CHECKED_AT } from '../openai-prices.js';
+import { refreshCodexLedger } from './ledger.js';
 
 /*
  * Codex route-scan: recurring easy turns become delegation-rule candidates.

package/src/{codex-rule-health.js → codex/rule-health.js}

@@ -1,8 +1,8 @@
 import { resolve } from 'node:path';
-import { loadCodexLedger } from './codex-ledger.js';
-import { isFailedRun } from './route-scan.js';
-import { wilsonLowerBound, HEALTH_ERR_RATE, HEALTH_MIN_SAMPLE_DELEGATED } from './model-rules.js';
-import { loadSharedModelRules, sharedModelRulesForProject, realProjectRoot } from './shared-model-rules.js';
+import { loadCodexLedger } from './ledger.js';
+import { isFailedRun } from '../route-scan.js';
+import { wilsonLowerBound, HEALTH_ERR_RATE, HEALTH_MIN_SAMPLE_DELEGATED } from '../model-rules.js';
+import { loadSharedModelRules, sharedModelRulesForProject, realProjectRoot } from '../shared-model-rules.js';
 
 /**
  * Measured outcome of one Codex rule, judged as Claude's rule health judges

package/src/commands/codex-delegate.js

@@ -1,15 +1,15 @@
 import { loadConfig, saveConfig } from '../config.js';
-import { configureCodexHooks } from '../codex-installer.js';
+import { configureCodexHooks } from '../codex/installer.js';
 import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule,
   validateCodexSharedTarget, codexSharedTargets, codexDelegateMinContext, DEFAULT_DELEGATE_MIN_CONTEXT,
-  autoCodexSharedTargets, codexDelegateEnabled, codexImplementationHint } from '../codex-delegation.js';
-import { findCodexCandidate, resolveCodexCandidate } from '../codex-route-scan.js';
-import { codexRoutingSavedTotals, loadCodexLedger } from '../codex-ledger.js';
-import { codexRuleHealth, codexRulesInReview, codexSharedRuleHealth } from '../codex-rule-health.js';
+  autoCodexSharedTargets, codexDelegateEnabled, codexImplementationHint } from '../codex/delegation.js';
+import { findCodexCandidate, resolveCodexCandidate } from '../codex/route-scan.js';
+import { codexRoutingSavedTotals, loadCodexLedger } from '../codex/ledger.js';
+import { codexRuleHealth, codexRulesInReview, codexSharedRuleHealth } from '../codex/rule-health.js';
 import { signedUsd } from '../money.js';
 import { codexProviderName, codexModelName } from '../agent.js';
 import { loadSharedModelRules, sharedModelRulesForProject, SHARED_RULE_TIERS } from '../shared-model-rules.js';
-import { codexDelegationDiagnostics } from '../codex-delegation-diagnostics.js';
+import { codexDelegationDiagnostics } from '../codex/delegation-diagnostics.js';
 
 // Starts from the working directory, as the hooks do, so a project policy
 // stored under either agent's project root is counted.

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/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');
@@ -436,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 })) {
@@ -466,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/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

@@ -43,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 */ }
@@ -56,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