sprag-cli 3.59.0 → 3.61.0

package/src/commands/codex-delegate.js

@@ -1,20 +1,94 @@
 import { loadConfig, saveConfig } from '../config.js';
 import { configureCodexHooks } from '../codex-installer.js';
-import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule } from '../codex-delegation.js';
+import { validateCodexTarget, loadCodexModelRules, addCodexModelRule, removeCodexModelRule,
+  validateCodexSharedTarget, codexSharedTargets, codexDelegateMinContext, DEFAULT_DELEGATE_MIN_CONTEXT } from '../codex-delegation.js';
 import { findCodexCandidate, resolveCodexCandidate } from '../codex-route-scan.js';
 import { codexRoutingSavedTotals, loadCodexLedger } from '../codex-ledger.js';
 import { codexRuleHealth, codexRulesInReview } from '../codex-rule-health.js';
 import { signedUsd } from '../money.js';
-import { codexProviderName } from '../agent.js';
+import { codexProviderName, codexModelName } from '../agent.js';
+import { loadSharedModelRules, sharedModelRulesForProject, SHARED_RULE_TIERS } from '../shared-model-rules.js';
+
+// Starts from the working directory, as the hooks do, so a project policy
+// stored under either agent's project root is counted.
+function printShared(cfg, { details = false } = {}) {
+  const policies = sharedModelRulesForProject(loadSharedModelRules(), process.cwd());
+  const targets = codexSharedTargets(cfg);
+  const provider = codexProviderName();
+  const parent = codexModelName();
+  console.log(`Shared delegation policies: ${policies.length} in this project (${cfg.codex?.sharedRules?.enabled === false ? 'off' : 'on'}); Codex tier mappings: ${targets.length}`);
+  if (!policies.length) console.log('First use: sprag seed --agent codex. Approve policies with seed accept <id>|all --global|--project; no Claude installation or history is required.');
+  if (details) {
+    for (const r of policies) console.log(`shared ${r.tier} ${r.category} | ${r.scope}${r.targetRoot ? ` ${r.targetRoot}` : ''}`);
+    for (const t of targets) console.log(`${t.provider} | ${t.from} | ${t.tier} -> ${t.model}${t.effort ? ` (${t.effort})` : ''}`);
+  }
+  // A mapping routes only sessions on the parent model it names, so a tier
+  // mapped for another model still leaves the configured model unrouted.
+  const mapped = (tier) => targets.some((t) => t.provider === provider && t.tier === tier && (!parent || t.from === parent));
+  const missing = [...new Set(policies.map((r) => r.tier))].filter((tier) => !mapped(tier));
+  if (missing.length) {
+    console.log(`Unmapped tiers for ${parent || 'any parent model'} on ${provider || 'unknown provider'}: ${missing.join(', ')}. `
+      + `Set: sprag delegate shared map <T1|T2> --from ${parent || '<parent-model>'} --model <target-model> --agent codex`);
+  }
+  if (!parent && targets.length) console.log('Codex config names no default model; each mapping routes only sessions on its --from model.');
+  const minimum = codexDelegateMinContext(cfg);
+  console.log(`Shared prompt guidance starts at ${minimum} parent input tokens${cfg.codex?.delegateMinContext === minimum ? '' : ' (default)'}. `
+    + 'Change: sprag delegate shared min-context <tokens|default> --agent codex');
+  console.log('Shared policies keep their original scope and bounds. Models require an exact parent/provider mapping; agent-specific roles and usage totals are not imported.');
+}
 
 export function run({ args, getArg, hasFlag, root }) {
   const sub = args[1] || 'status';
   if (args.some((arg) => arg.startsWith('--hook'))) throw new Error('Use codex-hook for Codex hook payloads.');
-  for (const flag of ['--model', '--effort', '--from']) {
+  for (const flag of ['--model', '--effort', '--from', '--provider']) {
     if (args.some((arg) => arg === flag || arg.startsWith(`${flag}=`)) && (!getArg(flag) || getArg(flag).startsWith('-'))) {
       throw new Error(`${flag} requires a value.`);
     }
   }
+  const cfg = loadConfig();
+  if (sub === 'shared') {
+    const action = args[2] || 'status';
+    if (!['status', 'on', 'off', 'map', 'unmap', 'min-context'].includes(action)) {
+      throw new Error('Usage: delegate shared status|on|off|map <T1|T2>|unmap <T1|T2>|min-context <tokens|default> --agent codex');
+    }
+    if (hasFlag('--global') || hasFlag('--project')) throw new Error('Shared policies retain their approved scope; mappings do not change it.');
+    const provided = (flag) => args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+    if (!['map', 'unmap'].includes(action) && ['--model', '--effort', '--from', '--provider'].some(provided)) {
+      throw new Error('Model options require delegate shared map or unmap.');
+    }
+    const targets = codexSharedTargets(cfg);
+    if (action === 'map' || action === 'unmap') {
+      const tier = args[3];
+      const from = getArg('--from');
+      const provider = getArg('--provider') ?? codexProviderName();
+      if (!SHARED_RULE_TIERS.includes(tier)) throw new Error('Shared rule tier must be T1 or T2.');
+      const same = (t) => t.tier === tier && t.from === from && t.provider === provider;
+      if (action === 'map') {
+        const target = validateCodexSharedTarget({ tier, from, provider, model: getArg('--model'), effort: getArg('--effort') });
+        cfg.codex = { ...cfg.codex, sharedRules: { ...cfg.codex?.sharedRules, targets: [...targets.filter((t) => !same(t)), target] } };
+      } else {
+        if (provided('--model') || provided('--effort')) throw new Error('unmap accepts only tier, --from and --provider.');
+        if (!targets.some(same)) throw new Error('No matching shared tier mapping; specify --from and the correct provider.');
+        cfg.codex = { ...cfg.codex, sharedRules: { ...cfg.codex?.sharedRules, targets: targets.filter((t) => !same(t)) } };
+      }
+    } else if (action === 'min-context') {
+      const value = args[3];
+      if (value === 'default') {
+        cfg.codex = { ...cfg.codex };
+        delete cfg.codex.delegateMinContext;
+      } else if (/^\d+$/.test(value ?? '') && Number.isSafeInteger(Number(value))) {
+        cfg.codex = { ...cfg.codex, delegateMinContext: Number(value) };
+      } else {
+        throw new Error(`min-context takes a whole number of parent input tokens, or default (${DEFAULT_DELEGATE_MIN_CONTEXT}).`);
+      }
+    } else if (action !== 'status') {
+      cfg.codex = { ...cfg.codex, sharedRules: { ...cfg.codex?.sharedRules, enabled: action === 'on' } };
+    }
+    if (action !== 'status') saveConfig(cfg);
+    printShared(cfg, { details: true });
+    console.log(`Codex delegation is ${cfg.codex?.delegate === true ? 'on' : 'off; enable with sprag delegate on --agent codex'}. Target availability and lower cost must be verified with your provider.`);
+    return;
+  }
   if (sub === 'rules') {
     if (args[2] === 'add') {
       if (hasFlag('--global') === hasFlag('--project')) throw new Error('Choose --global or --project for the rule.');
@@ -31,7 +105,7 @@ export function run({ args, getArg, hasFlag, root }) {
     } else if (args[2] === 'rm') removeCodexModelRule(Number(args[3]));
     else if (args[2]) throw new Error('Usage: delegate rules [add <category|R<N>> --from <model> --model <model> --global|--project | rm <N>]');
     const rules = loadCodexModelRules();
-    if (!rules.length) console.log('No Codex model rules. Claude rules are not imported.');
+    if (!rules.length) console.log('No Codex-only model rules.');
     let events = [];
     try { events = Object.values(loadCodexLedger().events); } catch { /* No ledger yet: rules list without outcomes. */ }
     const inReview = new Set(codexRulesInReview({ rules, events, root: null }).map((x) => x.index));
@@ -41,10 +115,10 @@ export function run({ args, getArg, hasFlag, root }) {
       const warn = inReview.has(i + 1) ? ` | rule-health: ${h.errs}/${h.runs} runs failed, narrow the condition or remove (delegate rules rm ${i + 1} --agent codex)` : '';
       console.log(`#${i + 1} ${r.category} | ${r.from} -> ${r.model} | ${r.scope}${r.targetRoot ? ` ${r.targetRoot}` : ''}${outcome}${warn}`);
     });
+    printShared(cfg, { details: true });
     return;
   }
-  if (!['on', 'off', 'status', 'model'].includes(sub)) throw new Error('Usage: delegate on|off|status|model <model>|rules --agent codex');
-  const cfg = loadConfig();
+  if (!['on', 'off', 'status', 'model'].includes(sub)) throw new Error('Usage: delegate on|off|status|model <model>|rules|shared --agent codex');
   let target;
   if (sub === 'model') target = args[2] === 'off' ? null : validateCodexTarget(args[2], getArg('--effort'));
   else if (getArg('--model') !== undefined) target = validateCodexTarget(getArg('--model'), getArg('--effort'));
@@ -63,6 +137,7 @@ export function run({ args, getArg, hasFlag, root }) {
   let ruleCount;
   try { ruleCount = String(loadCodexModelRules().length); } catch (e) { ruleCount = `unreadable (${e.message})`; }
   console.log(`Codex rules: ${ruleCount}`);
+  printShared(cfg);
   console.log('Explicit spawn models and custom roles are preserved. Targets must be available from your Codex provider.');
   const saved = codexRoutingSavedTotals();
   console.log(saved.priced

package/src/commands/codex.js

@@ -26,11 +26,16 @@ Usage: sprag <command> --agent codex [options]
   saved [reset|undo]             Show, reset or restore the saved-money counters
   delegate on|off|status         Native model routing and SubagentStart guidance
   delegate model <model>         Default target for spawns without an explicit model
-  delegate rules                Codex-only category rules; add/rm with explicit scope
+  delegate rules                Codex rules and shared delegation policies
+  delegate shared on|off|status  Reuse approved policies; keep original scopes
+  delegate shared map T1|T2     Map a tier: --from <parent> --model <target>
+                                Optional --provider <id> and --effort <level>
+  delegate shared unmap T1|T2   Remove a mapping: --from <parent> [--provider <id>]
+  delegate shared min-context N Parent input tokens before shared guidance; default resets
   route-scan [--refresh]         Discover recurring simple turns in local logs
   route-scan dismiss R<N>       Dismiss a candidate without registering a rule
   route-scan savings            Attributed routing estimates; --refresh or --format json
-  seed [accept|skip|reset]       Bundled Codex ratchet presets; acceptance needs a scope
+  seed [accept|skip|reset]       Shared delegation and Codex ratchet presets; explicit scope
   cache [auto|off|<duration>]    Display timer policy (e.g. 30m); never changes retention
   cache status --refresh        Resolve the session's gateway deployment and cache policy
   harness init|uninit|check|promote|list|rm|prune
@@ -413,6 +418,7 @@ export async function run({ args, version }) {
     console.log('After approval, start or resume Codex and run: sprag panel doctor --agent codex');
     if (panel.mode === 'window') console.log('Some Codex versions defer SessionStart until the first prompt. For immediate opening on typing codex: sprag panel shell install --agent codex (optional zsh integration).');
     console.log('Existing config.toml, Claude Code settings, and ratchet rules are preserved.');
+    console.log('First-use delegation: sprag seed --agent codex, then sprag delegate shared status --agent codex. Approve a scope and map the tiers before enabling delegation. No Claude installation is required.');
     console.log('Korean guidance is opt-in: sprag korean on --agent codex');
     return;
   }

package/src/commands/compact-window.js

@@ -58,9 +58,13 @@ export async function run({ args, hasFlag }) {
   }
 
   if (!sub || sub === 'status' || sub === 'check') {
-    const s = cw.compactWindowStatus({ root });
+    // The statusline knows the real window; the settings model id often does
+    // not (a bare `opus` carries no `[1m]`), so the last reported size decides.
+    let liveWindow = null;
+    try { liveWindow = (await import('../ctx-window-cache.js')).latestLiveWindow(); } catch { /* id-only fallback */ }
+    const s = cw.compactWindowStatus({ root, liveWindow });
     console.log(`model:  ${s.model || '(not set — Claude Code default)'}${s.modelSource ? ` [${s.modelSource}]` : ''}`);
-    console.log(`window: ${s.is1m ? '1M context' : '200k context'}`);
+    console.log(`window: ${s.is1m ? '1M context' : '200k context'}${liveWindow ? ` [statusline: ${liveWindow >= 1e6 ? `${liveWindow / 1e6}M` : fmt(liveWindow)}]` : ''}`);
     console.log(`autoCompactWindow: ${s.window === null ? '(unset)' : `${s.window} (${fmt(s.window)})`}${s.windowSource ? ` [${s.windowSource}${s.windowPath ? ` → ${s.windowPath}` : ''}]` : ''}`);
     if (s.ok && s.reason === 'not-1m') {
       console.log(ko

package/src/commands/install.js

@@ -251,8 +251,11 @@ export async function run({ hasFlag }) {
         // good, and upgrading would silently leave shell-written files
         // unchecked. installKoreanLintHook widens in place and is idempotent.
         if (ks.koreanStyleEnabled()) {
-          const { installKoreanLintHook } = await import('../installer.js');
+          const { installKoreanLintHook, installReplyLanguageHook } = await import('../installer.js');
           const migrated = installKoreanLintHook();
+          // Older installs have the lint hook but no Stop hook; add it here so
+          // an upgrade closes the English-reply gap without a manual `korean on`.
+          installReplyLanguageHook();
           if (migrated.action === 'updated') {
             console.log(lang === 'ko'
               ? '          검사 범위 갱신: Bash 로 쓴 파일도 이제 확인합니다'

package/src/commands/korean.js

@@ -20,6 +20,10 @@
  * wrote:
  *   sprag korean lint block|warn|off   # how findings are handled
  *   sprag korean lint <file...>        # check files on disk
+ *
+ * The third half is a Stop hook for the one slip a write-time check cannot
+ * see: an English reply to a Korean prompt, which writes no file at all.
+ *   sprag korean reply on|off          # toggle it (default on)
  */
 
 // Enforcement is only useful if it is on by default — a check the user has to
@@ -39,6 +43,12 @@ function koreanLintScope(cfg) {
   return cfg?.koreanStyle?.lintScope === 'prose' ? 'prose' : 'all';
 }
 
+// Default on, like the lint: a check the user has to discover is the same
+// hole in a different shape. Only an explicit false turns it off.
+function koreanReplyCheckOn(cfg) {
+  return cfg?.koreanReplyCheck !== false;
+}
+
 export async function run({ args, hasFlag }) {
   const sub = args[1] || 'status';
   const ks = await import('../korean-style.js');
@@ -72,6 +82,55 @@ export async function run({ args, hasFlag }) {
     return;
   }
 
+  // Stop hook. Fires when the model finishes a turn; if the reply is English
+  // to a Korean prompt, block the stop so the model answers again in Korean.
+  // Imports stay minimal on purpose: this runs after every turn.
+  if (hasFlag?.('--reply-hook') || sub === '--reply-hook') {
+    const { readStdinJson } = await import('../stdin-payload.js');
+    const payload = readStdinJson();
+    if (!payload) return;
+    // Claude Code sets stop_hook_active while the model is already continuing
+    // because of a Stop hook. Blocking again would loop forever.
+    if (payload.stop_hook_active) return;
+    if (!ks.koreanStyleEnabled()) return;
+    if (!koreanReplyCheckOn(loadConfig())) return;
+    const { createRequire } = await import('node:module');
+    const found = createRequire(import.meta.url)('../reply-language.cjs').checkReplyLanguage(payload.transcript_path);
+    if (!found) return;
+    console.log(JSON.stringify({
+      decision: 'block',
+      reason: '사용자는 한국어로 질문했는데 마지막 답변이 영어로 작성됐습니다. 같은 내용을 한국어로 다시 답하십시오. 코드, 명령어, 오류 원문, 커밋 메시지처럼 원문을 유지해야 하는 부분은 그대로 둡니다.',
+    }));
+    return;
+  }
+
+  // Toggle: `korean reply on|off`. Off keeps the hook installed and makes it
+  // a no-op, the same way lint mode `off` works; `korean off` removes it.
+  if (sub === 'reply') {
+    const cfg = loadConfig();
+    const next = args[2];
+    if (!next) {
+      console.log(lang === 'ko'
+        ? `답변 언어 검사: ${koreanReplyCheckOn(cfg) ? '켜짐' : '꺼짐'}`
+        : `Reply-language check: ${koreanReplyCheckOn(cfg) ? 'on' : 'off'}`);
+      return;
+    }
+    if (!['on', 'off'].includes(next)) {
+      console.error('Usage: sprag korean reply [on|off]');
+      process.exit(1);
+    }
+    cfg.koreanReplyCheck = next === 'on';
+    saveConfig(cfg);
+    console.log(next === 'on'
+      ? (lang === 'ko'
+        ? '답변 언어 검사를 켰습니다. 한국어 질문에 영어로 답하면 모델에게 되돌려 보내 다시 답하게 합니다.'
+        : 'Reply-language check is on. An English reply to a Korean prompt is sent back for a Korean answer.')
+      : (lang === 'ko'
+        ? '답변 언어 검사를 껐습니다. 훅은 남아 있지만 아무 일도 하지 않습니다.'
+        : 'Reply-language check is off. The hook stays installed and does nothing.'));
+    return;
+  }
+
   // Manual run over files already on disk: `korean lint docs/*.md`.
   if (sub === 'lint' && args.length > 2 && !['on', 'off', 'warn', 'block', 'scope'].includes(args[2])) {
     const { readFileSync } = await import('node:fs');
@@ -116,8 +175,8 @@ export async function run({ args, hasFlag }) {
     saveConfig(cfg);
     console.log(lang === 'ko'
       ? (next === 'all'
-        ? '검사 범위: all — 문서와 코드 주석, UI 문자열까지 세션이 쓴 모든 텍스트 파일을 검사합니다.'
-        : '검사 범위: prose — 마크다운과 텍스트 문서만 검사합니다.')
+        ? '검사 범위를 all 로 바꿨습니다. 문서와 코드 주석, UI 문자열까지 세션이 쓴 모든 텍스트 파일을 검사합니다.'
+        : '검사 범위를 prose 로 좁혔습니다. 마크다운과 텍스트 문서만 검사합니다.')
       : (next === 'all'
         ? 'Check scope: all — every text file the session writes, comments and UI strings included.'
         : 'Check scope: prose — documents only.'));
@@ -163,8 +222,13 @@ export async function run({ args, hasFlag }) {
   if (sub === 'on' || sub === 'off') {
     const enabled = sub === 'on';
     ks.setKoreanStyleEnabled(enabled);
-    const { installKoreanLintHook, removeKoreanLintHook } = await import('../installer.js');
+    const {
+      installKoreanLintHook, removeKoreanLintHook,
+      installReplyLanguageHook, removeReplyLanguageHook,
+    } = await import('../installer.js');
     const hook = enabled ? installKoreanLintHook() : removeKoreanLintHook();
+    if (enabled) installReplyLanguageHook();
+    else removeReplyLanguageHook();
     if (enabled) {
       console.log(lang === 'ko'
         ? '한국어 문체 지침을 켰습니다. 다음 세션부터 모든 프로젝트에 적용됩니다.'
@@ -202,6 +266,7 @@ export async function run({ args, hasFlag }) {
     console.log(`한국어 문체 지침: ${on ? '켜짐' : '꺼짐'}`);
     console.log(`  비용: 세션당 약 ${tokens} 토큰 (세션 시작 1회 주입)`);
     console.log(`  쓰기 시점 검사: ${koreanLintMode(loadConfig())}, 범위 ${koreanLintScope(loadConfig())} (바꾸려면 sprag korean lint block|warn|off, korean lint scope all|prose)`);
+    console.log(`  답변 언어 검사: ${koreanReplyCheckOn(loadConfig()) ? '켜짐' : '꺼짐'} (바꾸려면 sprag korean reply on|off)`);
     console.log(`  출처: ${ks.KOREAN_STYLE_SOURCE}`);
     console.log(`  라이선스 전문: ${ks.KOREAN_STYLE_LICENSE_PATH}`);
     console.log(on
@@ -211,6 +276,7 @@ export async function run({ args, hasFlag }) {
     console.log(`Korean writing guidance: ${on ? 'on' : 'off'}`);
     console.log(`  Cost: ~${tokens} tokens per session (injected once at session start)`);
     console.log(`  Write-time check: ${koreanLintMode(loadConfig())}, scope ${koreanLintScope(loadConfig())} (change with: sprag korean lint block|warn|off, korean lint scope all|prose)`);
+    console.log(`  Reply-language check: ${koreanReplyCheckOn(loadConfig()) ? 'on' : 'off'} (change with: sprag korean reply on|off)`);
     console.log(`  Source: ${ks.KOREAN_STYLE_SOURCE}`);
     console.log(`  License text: ${ks.KOREAN_STYLE_LICENSE_PATH}`);
     console.log(on

package/src/commands/route-scan.js

@@ -360,12 +360,14 @@ export async function run({ args, hasFlag, numArg }) {
       // — the refresh runs detached off the statusline path, never here.
       let updateBlock = null;
       try {
-        const { updateStatus, maybeSpawnUpdateCheck } = await import('../update-check.js');
+        const { updateStatus, maybeSpawnUpdateCheck, SESSION_START_CHECK_INTERVAL_MS } = await import('../update-check.js');
         const pkgVersion = readPackageVersion();
         // Session start is the one moment where a stale cache matters most, so
-        // kick the detached refresh here too. It lands in time for the
-        // statusline and for the next session, not for this line.
-        if (pkgVersion) maybeSpawnUpdateCheck(pkgVersion);
+        // kick the detached refresh here too, on a shorter interval than the
+        // statusline's 24h: releases can land several times a day, and a
+        // session opened that afternoon should hear about them. It lands in
+        // time for the statusline and for the next session, not for this line.
+        if (pkgVersion) maybeSpawnUpdateCheck(pkgVersion, { intervalMs: SESSION_START_CHECK_INTERVAL_MS });
         const u = pkgVersion ? updateStatus(pkgVersion) : null;
         // `dismissed` is the whole point of asking once: a user who said no to
         // this version must not be asked again every `/clear`.

package/src/commands/saved.js

@@ -8,8 +8,15 @@
  *
  * Nothing is deleted. A reset only records a timestamp, and the totals count
  * events from that moment on; see src/saved-reset.cjs.
+ *
+ * The routing mark also bounds the per-rule `saved ~$` figures in
+ * model-rules.json and ratchet-model.md, which are rebuilt by a scan rather than
+ * summed from the ledger. So a reset or undo that touches `routing` finishes by
+ * running that scan; see refreshRuleSavings.
  */
 
+import { debug } from '../debug.js';
+
 const SCOPE_SETS = {
   claude: ['routing', 'doc2md'],
   codex: ['codex-routing', 'codex-docs'],
@@ -33,7 +40,32 @@ async function currentTotals(scope, dir) {
   return { docs: codexDocumentTotals({ dir }).docs };
 }
 
-export async function run({ args, hasFlag, agent = 'claude', dir: dirArg }) {
+/**
+ * Rebuild each rule's savedUsd and re-render ratchet-model.md after the routing
+ * mark moved. The 14-day scan does both (it reads the mark, refreshes the
+ * registry, writes the managed files) in about half a second, so it is reused
+ * rather than duplicated here.
+ *
+ * Best-effort by design: the mark is already saved, and a failed rescan must not
+ * turn a successful reset into an error. It says so in one line instead, since
+ * the figures then stay stale until the next scan.
+ *
+ * @param {boolean} ko
+ * @param {Function} [rescan] injected by tests; defaults to runRouteScan
+ */
+async function refreshRuleSavings(ko, rescan) {
+  try {
+    const scan = rescan || (await import('../route-scan.js')).runRouteScan;
+    await scan({ days: 14 });
+  } catch (e) {
+    debug('saved:rule-savings', e);
+    console.log(ko
+      ? '룰별 절감액은 다음 route-scan 때 다시 계산됩니다.'
+      : 'Per-rule savings will be recalculated at the next route-scan.');
+  }
+}
+
+export async function run({ args, hasFlag, agent = 'claude', dir: dirArg, rescan }) {
   const { userLanguage } = await import('../config.js');
   const { userDataDir } = await import('../paths.js');
   const { readResetMarks, resetSaved, undoReset } = await import('../saved-reset.cjs');
@@ -90,6 +122,9 @@ export async function run({ args, hasFlag, agent = 'claude', dir: dirArg }) {
     console.log(ko
       ? `원장 기록은 지우지 않았습니다. \`sprag saved undo${suffix}\`로 되돌릴 수 있습니다.`
       : `No ledger data was deleted. Run \`sprag saved undo${suffix}\` to restore the previous counters.`);
+    // Codex keeps no per-rule figure (its rules are a separate store with no
+    // savedUsd), so only the Claude `routing` scope has anything to recompute.
+    if (targets.includes('routing')) await refreshRuleSavings(ko, rescan);
     return;
   }
 
@@ -105,6 +140,10 @@ export async function run({ args, hasFlag, agent = 'claude', dir: dirArg }) {
         ? `${label(s)} 카운터를 되돌렸습니다. 현재 합계는 ${fmtTotal(t)}입니다.`
         : `Restored the ${label(s)} counter. The total is now ${fmtTotal(t)}.`);
     }
+    // Keyed on what was undone, not on --agent: undo pops the latest reset
+    // whichever agent made it, so a bare `undo --agent codex` can restore
+    // the Claude routing mark and the rule figures must follow it.
+    if (undone.scopes.includes('routing')) await refreshRuleSavings(ko, rescan);
     return;
   }
 

package/src/ctx-window-cache.js

@@ -59,3 +59,17 @@ export function liveWindowFor(sessionId) {
   const s = load().sessions[sessionId];
   return s && validSize(s.size) ? s.size : null;
 }
+
+/**
+ * The window most recently reported by any session's statusline, or null.
+ * `sprag compact-window` runs outside a session and has no payload of its own;
+ * judged by the settings model id alone, a bare `opus` (1M by default on Opus
+ * 5.5, with no `[1m]` suffix) read as 200k while the statusline said 1M.
+ */
+export function latestLiveWindow() {
+  let best = null;
+  for (const s of Object.values(load().sessions)) {
+    if (s && validSize(s.size) && Number.isFinite(s.ts) && (!best || s.ts > best.ts)) best = s;
+  }
+  return best ? best.size : null;
+}