sprag-cli 3.58.1 → 3.60.0

package/README.ko.md

@@ -109,6 +109,23 @@ LLMRouterBench(Findings of ACL 2026)에서 오프라인으로 측정했습니다
 
 위임된 실행은 한 건마다 단가 차액을 기록하므로, `sprag route-scan savings` 가 어떤 금액이든 그 원인이 된 규칙까지 역추적해 보여 줍니다. 집계에서 무엇을 빼는지는 [명령 문서](https://github.com/rootstudioyaml/sprag/blob/main/docs/COMMANDS.ko.md)에 적어 두었습니다.
 
+## 티어 기준의 근거가 된 연구
+
+티어 기준은 감으로 정한 값이 아닙니다. 기준마다 공개된 라우팅 연구를 근거로 삼았고, 룰 문구에 나오는 수치(지식 회상 28% 대 54%, 도구 체인 작업의 +63%p 격차)는 아래 데이터셋으로 sprag가 직접 오프라인 실측한 값입니다.
+
+| 기준 | 논문이 밝힌 내용 | 논문 |
+|---|---|---|
+| 보수적으로 내려보낸다 | 학습형 라우터는 예산이 커질수록 더 싼 모델로 충분한 경우에도 가장 비싼 모델을 고르는 쪽으로 수렴합니다. | Lai & Ye, [When Routing Collapses: On the Degenerate Convergence of LLM Routers](https://arxiv.org/abs/2602.03478) (2026) |
+| 난이도는 결과로 판정한다 | 기존 라우터는 모두 오라클에 못 미치며, 주된 원인은 작은 모델로 충분한 경우를 알아보지 못하는 데 있습니다. 문항 난이도는 42개 모델 중 실제로 맞힌 모델 수로 정의합니다. | Lu et al., [RouterArena: An Open Platform for Comprehensive Comparison of LLM Routers](https://arxiv.org/abs/2510.00202) (2025) |
+| 임계값은 내 로그에서 정한다 | 예측한 승률을 비용 임계값과 비교해 라우팅하고, 결과는 강한 모델로 보낸 호출 비율로 읽습니다. sprag는 스캔할 때마다 최근 14일 분포에서 이 임계값을 다시 계산합니다. | Ong et al., [RouteLLM: Learning to Route LLMs with Preference Data](https://arxiv.org/abs/2406.18665) (2024) |
+| 실패하면 위로 올린다 | 캐스케이드는 싼 모델부터 시도하고, 답을 검사한 결과로 상위 모델로 올릴지 정합니다. GPT-4와 같은 성능을 최대 98% 낮은 비용으로 냈습니다. | Chen, Zaharia & Zou, [FrugalGPT](https://arxiv.org/abs/2305.05176) (2023) |
+| 답이 어디에 있나 | 짧은 사실 회상 능력만 따로 측정합니다. 지식 회상 28% 대 54% 격차는 이 계열의 데이터셋에서 나왔습니다. | Wei et al., [Measuring short-form factuality in large language models (SimpleQA)](https://arxiv.org/abs/2411.04368) (2024) |
+| 도구 오케스트레이션은 내리지 않는다 | 에이전트가 공유 환경에서 사용자와 함께 도구 호출을 조율해야 하는 벤치마크입니다. +63%p 격차를 여기서 측정했습니다. | Barres et al., [τ²-Bench](https://arxiv.org/abs/2506.07982) (2025) |
+| 공개 벤치마크 실측 | 40만 문항, 21개 데이터셋, 33개 모델 규모이며, 상용 제품을 포함한 여러 라우터가 단순한 기준선을 안정적으로 넘지 못했습니다. | Li et al., [LLMRouterBench](https://arxiv.org/abs/2601.07206) (Findings of ACL 2026) |
+| 라우팅과 캐스케이드 | 라우팅 결정을 언제 내리는지, 무엇을 읽는지, 어떻게 계산하는지로 기존 방식을 분류합니다. | Moslem & Kelleher, [Dynamic Model Routing and Cascading for Efficient LLM Inference: A Survey](https://arxiv.org/abs/2603.04445) (2026) |
+
+논문 근거가 없는 기준도 두 개 있습니다. 같은 파일을 읽는 작업을 한 에이전트에 묶는 기준과, 설계와 코드 작성을 나누는 기준은 sprag의 비용 집계에서 나왔습니다. 서브에이전트에서는 생성보다 컨텍스트 적재 비용이 더 크기 때문입니다. 자세한 근거는 [티어 기준 문서](https://github.com/rootstudioyaml/sprag/blob/main/docs/TIER_CRITERIA.md)에 있습니다.
+
 ## 설치 한 번에 전부 들어 있고, 첫날부터 동작합니다
 
 | | 하는 일 | 더 보기 |

package/README.md

@@ -140,6 +140,29 @@ ledger. Nothing here is a projection.
 
 Every delegated run records its own price difference, so `sprag route-scan savings` traces any amount back to the rule that caused it. What the ledger deliberately leaves out is written down in [the command reference](https://github.com/rootstudioyaml/sprag/blob/main/docs/COMMANDS.md).
 
+## Research behind the tier rules
+
+The tier criteria are not a hunch. Each one traces back to published routing
+research, and the percentages quoted in the rules (28% vs 54% recall, a +63pp
+gap on chained tool work) are sprag's own offline measurement on the datasets
+below.
+
+| Criterion | What the paper found | Paper |
+|---|---|---|
+| Delegate down, conservatively | As budgets grow, learned routers default to the most expensive model even when a cheaper one already suffices. | Lai & Ye, [When Routing Collapses: On the Degenerate Convergence of LLM Routers](https://arxiv.org/abs/2602.03478) (2026) |
+| Judge difficulty by outcome | Every router on the board falls short of the oracle, mainly because it cannot tell when a smaller model is enough. Query difficulty is defined by how many of 42 models actually answered it. | Lu et al., [RouterArena: An Open Platform for Comprehensive Comparison of LLM Routers](https://arxiv.org/abs/2510.00202) (2025) |
+| Thresholds from your own logs | Routing compares a predicted win rate against a cost threshold, and results are read by the share of calls sent to the strong model. sprag sets that threshold from your last 14 days at every scan. | Ong et al., [RouteLLM: Learning to Route LLMs with Preference Data](https://arxiv.org/abs/2406.18665) (2024) |
+| Escalate on failure | A cascade tries the cheap model first and lets a check on the answer decide whether to go up. It matched GPT-4 with up to 98% lower cost. | Chen, Zaharia & Zou, [FrugalGPT](https://arxiv.org/abs/2305.05176) (2023) |
+| Where the answer lives | Short-form factual recall measured on its own. The 28% vs 54% recall gap comes from this class of set. | Wei et al., [Measuring short-form factuality in large language models (SimpleQA)](https://arxiv.org/abs/2411.04368) (2024) |
+| Tool orchestration stays up | Agents must coordinate tool calls with a user in a shared environment. The +63pp gap was measured here. | Barres et al., [τ²-Bench](https://arxiv.org/abs/2506.07982) (2025) |
+| The public benchmark run | 400K instances, 21 datasets, 33 models. Several routers, commercial ones included, fail to beat a simple baseline. | Li et al., [LLMRouterBench](https://arxiv.org/abs/2601.07206) (Findings of ACL 2026) |
+| Routing vs cascading | A taxonomy of when a routing decision is made, what it reads, and how it is computed. | Moslem & Kelleher, [Dynamic Model Routing and Cascading for Efficient LLM Inference: A Survey](https://arxiv.org/abs/2603.04445) (2026) |
+
+Two criteria have no paper behind them. Batching tasks that read the same files
+and splitting design from code writing come from sprag's own cost accounting:
+on a sub-agent, loading context costs more than generating. The full reasoning,
+in Korean, is in [Tier criteria](https://github.com/rootstudioyaml/sprag/blob/main/docs/TIER_CRITERIA.md).
+
 ## Everything ships in one install, working from day one
 
 | | What it does | More |

package/bin/cli.js

@@ -57,7 +57,7 @@ import { sessionCostAcross } from '../src/claude-price.js';
 import { chipForIssues } from '../src/advice.js';
 import { debug } from '../src/debug.js';
 import { createArgs } from '../src/cli-args.js';
-import { updateStatus, maybeSpawnUpdateCheck } from '../src/update-check.js';
+import { updateStatus, maybeSpawnUpdateCheck, readUpdateState, updateCheckDisabled } from '../src/update-check.js';
 import { selectAgent } from '../src/agent.js';
 
 const selection = (() => {
@@ -86,7 +86,13 @@ const { getArg, hasFlag, numArg } = createArgs(args);
 function readUpdateChip() {
   try {
     maybeSpawnUpdateCheck(PKG_VERSION);
-    return updateStatus(PKG_VERSION);
+    const status = updateStatus(PKG_VERSION);
+    // When the registry was last asked, for the verbose "✓6h" on an up-to-date
+    // version. updateStatus() does not carry it, and a second read of the
+    // 200-byte state file is cheaper than a second status computation. With
+    // checks switched off the file is a leftover, so it says nothing.
+    const checkedAt = updateCheckDisabled() ? null : (Number(readUpdateState().checkedAt) || null);
+    return { ...status, checkedAt };
   } catch (e) {
     debug('update-check:chip', e);
     return null;
@@ -106,7 +112,7 @@ function tableColor() {
 const KNOWN_SUBCOMMANDS = new Set([
   'last', 'brief', 'history', 'handoff', 'install', 'uninstall', 'mode', 'korean', 'cohesion',
   'doc2md', 'delegate', 'harness', 'route-scan', 'compact-window', 'update-check', 'upgrade',
-  'seed', 'litellm-budget', 'profile-map', 'feedback',
+  'seed', 'litellm-budget', 'profile-map', 'feedback', 'saved',
 ]);
 
 const USAGE = `sprag — Claude Code and Codex agent harness
@@ -148,6 +154,7 @@ Usage:
   sprag doc2md on|off|<file>     convert documents to Markdown before the model reads them
   sprag delegate on|off|status   add bounds and context to Task/Agent delegation prompts
   sprag compact-window     audit or pin autoCompactWindow for 1M sessions
+  sprag saved [reset|undo] show, reset or restore the saved-money counters (--agent codex for Codex)
   sprag litellm-budget     LiteLLM gateway key budget and spend
   sprag update-check       is a newer version out?
   sprag brief --hook       internal: the UserPromptSubmit hook entry point
@@ -305,6 +312,12 @@ async function main() {
     return (await import('../src/commands/seed.js')).run({ args, hasFlag });
   }
 
+  // Subcommand: saved — stopwatch reset for the lifetime "saved" counters.
+  //   sprag saved | saved reset [routing|doc2md|all] | saved undo
+  if (args[0] === 'saved') {
+    return (await import('../src/commands/saved.js')).run({ args, hasFlag });
+  }
+
   // Subcommand: harness — manage the project's CLAUDE.md harness rules.
   //   sprag harness init       # write CLAUDE.md (5 sections) + ratchet.md
   //   sprag harness uninit     # remove harness block from CLAUDE.md (backup kept)
@@ -816,9 +829,15 @@ async function main() {
   // the statusline shows the same blank for "no delegation happened" and for
   // "delegation happened and was silently discarded".
   let unresolvedRuns = 0;
+  // The same cached scan says how old the savings figures are: the ledger is
+  // filled by route-scan, so a stale scan means a stale total.
+  let routeScanAt = null;
   try {
     const { readRouteScan } = await import('../src/route-scan.js');
-    unresolvedRuns = Number(readRouteScan()?.unresolvedRuns) || 0;
+    const scan = readRouteScan();
+    unresolvedRuns = Number(scan?.unresolvedRuns) || 0;
+    const scannedAt = Date.parse(scan?.scannedAt);
+    routeScanAt = Number.isFinite(scannedAt) ? scannedAt : null;
   } catch (e) {
     debug('route-scan:unresolved', e);
   }
@@ -833,6 +852,38 @@ async function main() {
     debug('config:ttlBucket', e);
   }
 
+  // Statusline-only additions. Each reuses data already in hand: the sessions
+  // parsed above (subagent runs ride on them) and the small model-rules.json
+  // the harness chip reads anyway.
+  //
+  // This session's subagent runs, matched to the session Claude Code is
+  // drawing for by the transcript path / session id in its payload.
+  let sessionDelegation;
+  // Delegation-rule counts, read only when `--segments` names `rules`: the
+  // chip is opt-in, so nothing else would look at them.
+  let ruleStats;
+  const rulesRequested = String(getArg('--segments') || '').split(',').some((s) => s.trim() === 'rules');
+  if (isStatusline) {
+    try {
+      const { sessionSubagentSummary } = await import('../src/statusline-data.js');
+      sessionDelegation = sessionSubagentSummary(sessions, {
+        transcriptPath: extractTranscriptPath(stdinJson),
+        sessionId: extractSessionId(stdinJson),
+      });
+    } catch (e) {
+      debug('statusline-data:session-delegation', e);
+    }
+    if (rulesRequested) {
+      try {
+        const { delegationRuleStats } = await import('../src/statusline-data.js');
+        const { findProjectRoot } = await import('../src/harness.js');
+        ruleStats = delegationRuleStats(findProjectRoot());
+      } catch (e) {
+        debug('statusline-data:rule-stats', e);
+      }
+    }
+  }
+
   const data = {
     summary: sum,
     trend,
@@ -855,6 +906,10 @@ async function main() {
     delegationTotals,
     doc2mdTotals,
     unresolvedRuns,
+    // Statusline-only; left undefined elsewhere so --format json keeps its shape.
+    routeScanAt: isStatusline ? routeScanAt : undefined,
+    sessionDelegation,
+    ruleStats,
     ttlBucket,
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.58.1",
+  "version": "3.60.0",
   "description": "Lower your Claude Code bill without changing how you work: simple tasks go to cheaper models, documents go in as compact Markdown, and the statusline shows spend and savings live. Works with Codex too.",
   "type": "module",
   "bin": {

package/src/caps-cache.js

@@ -9,9 +9,10 @@
  * than `maxAgeMs` the loader returns null and the table view stays quiet.
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs';
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 
 const CACHE_PATH = join(userDataDir(), 'last-caps.json');
 
@@ -41,8 +42,7 @@ export function persistSnapshot(snapshot) {
     // tmp + rename: the statusline reads this every tick and must never see a
     // half-written file.
     const tmp = `${CACHE_PATH}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(payload) + '\n');
-    renameSync(tmp, CACHE_PATH);
+    writeViaTmp(tmp, CACHE_PATH, JSON.stringify(payload) + '\n');
   } catch {
     // best-effort cache, never blocks the statusline
   }

package/src/codex-brief.js

@@ -1,8 +1,9 @@
 import { createHash } from 'node:crypto';
-import { readFileSync, writeFileSync, mkdirSync, renameSync, readdirSync } from 'node:fs';
+import { readFileSync, mkdirSync, readdirSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { codexUserDir } from './agent.js';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 import { readCodexSnapshot } from './codex-parser.js';
 import { loadCodexModelRules } from './codex-delegation.js';
 import { loadCodexLedger } from './codex-ledger.js';
@@ -105,8 +106,7 @@ export function runCodexBrief({ sessionId, transcriptPath, cwd, root: projectRoo
   const events = [...state.events, ...next.map((issue) => ({ ...issue, at, sessionId, project: cwd || snapshot.projectDir || '' }))].slice(-200);
   mkdirSync(directory, { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify({ active: nextActive, events }) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify({ active: nextActive, events }) + '\n', { mode: 0o600 });
   return next.length ? ['[Sprag Codex briefing]', ...next.map((issue) => `${issue.message} ${issue.advice}`)].join('\n') : null;
 }
 
@@ -125,8 +125,7 @@ export function recordCodexHistoryEvent({ sessionId, project = '', key, level =
     at: new Date(now).toISOString(), sessionId: owner, project }].slice(-200);
   mkdirSync(directory, { recursive: true });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, JSON.stringify({ ...state, events }) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify({ ...state, events }) + '\n', { mode: 0o600 });
   return true;
 }
 

package/src/codex-cache-policy.js

@@ -1,9 +1,10 @@
-import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { readFileSync, mkdirSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { parse } from 'smol-toml';
 import { codexUserDir } from './agent.js';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 import { codexBudgetProvider, codexProviderKey } from './codex-budget.js';
 import { codexCachePolicy } from './codex-cache.js';
 import { PRICE_MAX_AGE_MS, gatewayPrices } from './gateway-prices.js';
@@ -153,8 +154,7 @@ async function writeGatewaySnapshot(provider, { fetchImpl = fetch, execute, ...o
   // Persist only policy and price fields, never raw model/info (which can contain secrets).
   mkdirSync(join(opts.dir || userDataDir(), 'codex-cache-policy'), { recursive: true, mode: 0o700 });
   const tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, JSON.stringify(snapshot) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify(snapshot) + '\n', { mode: 0o600 });
   return snapshot;
 }
 

package/src/codex-delegation.js

@@ -1,8 +1,9 @@
-import { readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { readFileSync, readdirSync, mkdirSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parse } from 'smol-toml';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 import { codexUserDir, codexProviderName } from './agent.js';
 import { categorize, ESCALATE_RE, EDIT_RE } from './route-scan.js';
 import { looksPasted } from './route-inject.js';
@@ -41,8 +42,7 @@ export function loadCodexModelRules({ dir = userDataDir() } = {}) {
 function saveRules(rules, dir) {
   mkdirSync(dir, { recursive: true });
   const file = rulesFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, JSON.stringify({ version: 1, rules }, null, 2) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify({ version: 1, rules }, null, 2) + '\n', { mode: 0o600 });
 }
 
 export function addCodexModelRule({ category, model, effort, from, scope, root, provider }, { dir = userDataDir() } = {}) {

package/src/codex-doc2md-ledger.js

@@ -1,8 +1,10 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync, realpathSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { extname, join, resolve } from 'node:path';
 import { codexUserDir } from './agent.js';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
+import { readResetMarks, isBeforeReset } from './saved-reset.cjs';
 
 const hash = (value) => createHash('sha256').update(value).digest('hex');
 const ledgerDir = ({ home = codexUserDir(), dir = userDataDir() } = {}) => join(dir, 'codex-doc2md', hash(resolve(home)));
@@ -21,18 +23,21 @@ export function recordCodexDocument(source, result, opts) {
       clipped: !!(meta.clipped || meta.truncated) };
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     const tmp = `${file}.${randomUUID()}.tmp`;
-    writeFileSync(tmp, JSON.stringify(event) + '\n', { mode: 0o600 });
-    renameSync(tmp, file);
+    writeViaTmp(tmp, file, JSON.stringify(event) + '\n', { mode: 0o600 });
   } catch { /* Accounting must not prevent document conversion. */ }
 }
 
+// Records carry no timestamp field, so the reset mark is compared with the
+// file's mtime. A source converted again rewrites its record and counts as new.
 export function codexDocumentTotals(opts) {
-  const total = { docs: 0, byExt: [], scope: 'codex-total' };
+  const since = readResetMarks(opts?.dir ?? userDataDir())['codex-docs'];
+  const total = { docs: 0, byExt: [], scope: 'codex-total', since };
   const byExt = new Map();
   try {
     const dir = ledgerDir(opts);
     for (const file of readdirSync(dir).filter((name) => /^[a-f0-9]{64}\.json$/.test(name))) {
       try {
+        if (since !== null && isBeforeReset(statSync(join(dir, file)).mtimeMs, since)) continue;
         const event = JSON.parse(readFileSync(join(dir, file), 'utf8'));
         if (event?.version !== 1 || !['pdf', 'pptx', 'xlsx', 'xls', 'docx', 'fig'].includes(event.ext)) continue;
         total.docs++;

package/src/codex-hooks.js

@@ -1,12 +1,13 @@
 import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
-import { mkdirSync, openSync, readFileSync, readSync, closeSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { mkdirSync, openSync, readFileSync, readSync, closeSync, statSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { loadConfig, userLanguage } from './config.js';
 import { koreanStyleInjection, koreanStyleEnabled } from './korean-style.js';
 import { cohesionInjection } from './cohesion.js';
 import { codexHarnessPaths } from './codex-harness.js';
+import { writeViaTmp } from './state-file.js';
 import { findProjectRoot } from './harness.js';
 import { runCodexBrief } from './codex-brief.js';
 import { codexDocumentTool, codexDocumentNote, convertCodexDocument } from './codex-doc2md.js';
@@ -69,8 +70,7 @@ export function fitCodexContext(parts, { budget = CODEX_CONTEXT_TOKEN_BUDGET, ov
 function writeOverflow(file, text) {
   mkdirSync(join(file, '..'), { recursive: true, mode: 0o700 });
   const tmp = `${file}.${process.pid}.tmp`;
-  writeFileSync(tmp, text, { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, text, { mode: 0o600 });
 }
 
 function overflowFileFor(root) {

package/src/codex-installer.js

@@ -1,6 +1,7 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { codexUserDir } from './agent.js';
+import { writeViaTmp } from './state-file.js';
 
 export const CODEX_HANDLERS = {
   SessionStart: { matcher: 'startup|resume|clear|compact', command: 'sprag codex-hook --agent codex --event session-start', timeout: 15 },
@@ -72,8 +73,7 @@ export function configureCodexHooks({ remove = false, panelAuto } = {}) {
     mkdirSync(dirname(file), { recursive: true });
     if (existsSync(file)) writeFileSync(`${file}.bak-${Date.now()}`, readFileSync(file));
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n');
-    renameSync(tmp, file);
+    writeViaTmp(tmp, file, JSON.stringify(data, null, 2) + '\n');
   }
   return { file, action: remove ? 'removed' : 'configured' };
 }

package/src/codex-ledger.js

@@ -1,8 +1,10 @@
-import { appendFileSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomBytes, randomUUID } from 'node:crypto';
 import { userDataDir } from './paths.js';
+import { writeViaTmp } from './state-file.js';
 import { roundUsd } from './savings-ledger.js';
+import { readResetMarks, isBeforeReset } from './saved-reset.cjs';
 import { discoverCodexSessionFiles, parseCodexTurns } from './codex-parser.js';
 import { codexRunCost, codexPriceBook, readCodexPrices } from './codex-cache-policy.js';
 
@@ -51,8 +53,7 @@ export function pruneCodexDelegations({ dir = userDataDir(), now = Date.now() }
   try { all = readFileSync(pendingFile(dir), 'utf8').split('\n').filter(Boolean).length; } catch { return; }
   if (keep.length === all) return;
   const file = pendingFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, keep.map((r) => JSON.stringify(r) + '\n').join(''), { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, keep.map((r) => JSON.stringify(r) + '\n').join(''), { mode: 0o600 });
 }
 
 export function readCodexDelegations({ dir = userDataDir() } = {}) {
@@ -172,8 +173,7 @@ export function loadCodexLedger({ dir = userDataDir() } = {}) {
 function saveLedger(data, dir) {
   mkdirSync(dir, { recursive: true });
   const file = ledgerFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
 }
 
 /**
@@ -262,10 +262,15 @@ export async function refreshCodexLedger({ dir = userDataDir(), home, now = Date
   return ledger;
 }
 
-/** Signed totals over priced runs; unpriced runs are counted, never summed as zero. */
+/**
+ * Signed totals over priced runs; unpriced runs are counted, never summed as zero.
+ * Runs before the `codex-routing` reset mark are left out of every figure,
+ * `runs` and `priced` included; `since` reports the mark.
+ */
 export function codexRoutingSavedTotals({ dir = userDataDir(), now = Date.now() } = {}) {
-  const events = Object.values(loadCodexLedger({ dir }).events);
-  const totals = { week: 0, month: 0, total: 0, runs: events.length, priced: 0 };
+  const since = readResetMarks(dir)['codex-routing'];
+  const events = Object.values(loadCodexLedger({ dir }).events).filter((e) => !isBeforeReset(e.ts, since));
+  const totals = { week: 0, month: 0, total: 0, runs: events.length, priced: 0, since };
   for (const e of events) {
     if (!Number.isFinite(e.usd)) continue;
     totals.priced++;

package/src/codex-panel-session.js

@@ -1,5 +1,6 @@
-import { readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute } from 'node:path';
+import { writeViaTmp } from './state-file.js';
 
 export function createPanelBinding(file) {
   writeFileSync(file, JSON.stringify({ version: 1, sessionId: null, transcriptPath: null }), { mode: 0o600 });
@@ -27,9 +28,8 @@ export function bindPanelSession(event, payload, { file = process.env.SPRAG_CODE
     if (current.version !== 1) return false;
     if (payload.source === 'compact' && current.sessionId && current.sessionId !== payload.session_id) return false;
     const tmp = `${file}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify({ version: 1, sessionId: payload.session_id,
+    writeViaTmp(tmp, file, JSON.stringify({ version: 1, sessionId: payload.session_id,
       transcriptPath: typeof payload.transcript_path === 'string' && isAbsolute(payload.transcript_path) ? payload.transcript_path : null }), { mode: 0o600 });
-    renameSync(tmp, file);
     return true;
   } catch { return false; }
 }

package/src/codex-panel-state.js

@@ -1,8 +1,15 @@
 import { createHash } from 'node:crypto';
-import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { readFileSync, mkdirSync, readdirSync, lstatSync, unlinkSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { userDataDir } from './paths.js';
 import { codexUserDir } from './agent.js';
+import { writeViaTmp, runHousekeeping, sweepStaleTmp } from './state-file.js';
+
+// Every panel session leaves a `-frame` and a `-hook` file behind, keyed by a
+// hash that is not reused once the session is gone. They are diagnostics for a
+// live session, so a file untouched for a week describes one that is over.
+const PANEL_STATE_FILE = /^codex-panel-[0-9a-f]{64}-(?:frame|hook)\.json$/;
+export const PANEL_STATE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
 export function panelStatePath(root, kind, dir = userDataDir(), sessionId) {
   const key = createHash('sha256').update(codexUserDir() + '\0' + resolve(root) + (sessionId ? `\0${sessionId}` : '')).digest('hex');
@@ -15,17 +22,56 @@ export function recordPanelState(root, kind, value, dir = userDataDir()) {
     const file = panelStatePath(root, kind, dir);
     const tmp = `${file}.${process.pid}.tmp`;
     const text = JSON.stringify({ ...value, at: new Date().toISOString() });
-    writeFileSync(tmp, text);
-    renameSync(tmp, file);
+    writeViaTmp(tmp, file, text);
     if (value.sessionId) {
       const sessionFile = panelStatePath(root, kind, dir, value.sessionId);
       const sessionTmp = `${sessionFile}.${process.pid}.tmp`;
-      writeFileSync(sessionTmp, text);
-      renameSync(sessionTmp, sessionFile);
+      writeViaTmp(sessionTmp, sessionFile, text);
     }
+    // A live panel records a frame every couple of seconds, so the clean-up is
+    // rate-limited to once a day (see runHousekeeping) rather than listing the
+    // directory on every write. This session's own files, of both kinds, are
+    // never candidates: a session that has run for over a week keeps writing
+    // frames while its hook record is just as old.
+    runHousekeeping(dir, {
+      'stale-tmp': () => sweepStaleTmp(dir),
+      'codex-panel': () => sweepPanelState({
+        dir,
+        keep: ['frame', 'hook'].flatMap((k) => [
+          panelStatePath(root, k, dir),
+          ...(value.sessionId ? [panelStatePath(root, k, dir, value.sessionId)] : []),
+        ]),
+      }),
+    });
   } catch { /* Diagnostics must not stop a session or panel. */ }
 }
 
+/**
+ * Remove panel state files untouched for `maxAgeMs`. Only the exact
+ * `codex-panel-<64 hex>-(frame|hook).json` shape is considered, and anything
+ * in `keep` (full paths) is left alone whatever its mtime.
+ *
+ * @returns {number} how many files were removed
+ */
+export function sweepPanelState({ dir = userDataDir(), now = Date.now(), maxAgeMs = PANEL_STATE_MAX_AGE_MS, keep = [] } = {}) {
+  let names;
+  try { names = readdirSync(dir); } catch { return 0; }
+  const protectedPaths = new Set(keep);
+  let removed = 0;
+  for (const name of names) {
+    if (!PANEL_STATE_FILE.test(name)) continue;
+    const path = join(dir, name);
+    if (protectedPaths.has(path)) continue;
+    try {
+      const st = lstatSync(path);
+      if (!st.isFile() || now - st.mtimeMs <= maxAgeMs) continue;
+      unlinkSync(path);
+      removed += 1;
+    } catch { /* already gone, or not ours to remove */ }
+  }
+  return removed;
+}
+
 export function readPanelState(root, kind, dir = userDataDir(), sessionId) {
   try { return JSON.parse(readFileSync(panelStatePath(root, kind, dir, sessionId), 'utf8')); }
   catch { return null; }

package/src/codex-route-scan.js

@@ -1,7 +1,8 @@
-import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+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';
@@ -32,8 +33,7 @@ export function readCodexRouteScan({ dir = userDataDir() } = {}) {
 function writeCache(data, dir) {
   mkdirSync(dir, { recursive: true });
   const file = cacheFile(dir), tmp = `${file}.${randomUUID()}.tmp`;
-  writeFileSync(tmp, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
 }
 
 /** Candidates not yet approved or dismissed; with `root`, only that project's. */

package/src/commands/codex.js

@@ -23,6 +23,7 @@ Usage: sprag <command> --agent codex [options]
   brief [on|off|status]          Current warnings or prompt-briefing preference
   last / history                Context/rate-limit warnings and handoffs; --days, --session, --project
   handoff [--cwd path]           Write Git state and Codex usage to HANDOFF-*.md
+  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
@@ -144,6 +145,7 @@ export async function run({ args, version }) {
     return;
   }
   if (cmd === 'delegate') return (await import('./codex-delegate.js')).run({ args, getArg, hasFlag, root });
+  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');

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 로 쓴 파일도 이제 확인합니다'