sprag-cli 3.59.0 → 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;
@@ -823,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);
   }
@@ -840,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,
@@ -862,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.59.0",
+  "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,9 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync, realpathSync, statSync } 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');
@@ -22,8 +23,7 @@ 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. */ }
 }
 

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,7 +1,8 @@
-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';
@@ -52,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() } = {}) {
@@ -173,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 });
 }
 
 /**

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/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