sprag-cli 3.58.1 → 3.60.0

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

@@ -56,9 +56,22 @@ export async function run({ args, hasFlag, numArg }) {
     // which model actually ran it.
     if (args[1] === 'savings') {
       const { loadLedger, delegationSavedTotals } = await import('../savings-ledger.js');
+      // Runs from before `sprag saved reset` are kept in the ledger but not listed.
+      const { readResetMarks, isBeforeReset } = await import('../saved-reset.cjs');
+      const { userDataDir } = await import('../paths.js');
+      const since = readResetMarks(userDataDir()).routing;
       const events = Object.entries(loadLedger().events)
         .map(([key, e]) => ({ key, ...e }))
+        .filter((e) => !isBeforeReset(e.ts, since))
         .sort((a, b) => b.ts - a.ts);
+      if (events.length === 0 && since !== null) {
+        // After a reset an empty list is the expected state, not a setup gap.
+        const at = new Date(since).toLocaleString(lang === 'ko' ? 'ko-KR' : 'en-US');
+        console.log(lang === 'ko'
+          ? `${at}에 카운터를 초기화한 뒤로 기록된 라우팅 절감이 아직 없습니다. 되돌리려면 \`sprag saved undo\` 를 실행하십시오.`
+          : `No routing savings recorded since the counter was reset at ${at}. Run \`sprag saved undo\` to restore it.`);
+        return;
+      }
       if (events.length === 0) {
         console.log(lang === 'ko'
           ? '기록된 라우팅 절감 없음. 승격된 룰이 실제로 위임을 일으킨 뒤 `route-scan --refresh` 를 돌리면 채워집니다.'
@@ -72,6 +85,12 @@ export async function run({ args, hasFlag, numArg }) {
       console.log(lang === 'ko'
         ? `🔀 라우팅 절감 누적 ${money(t.total)}  (최근 7일 ${money(t.week)} · 30일 ${money(t.month)})`
         : `🔀 Routing saved, lifetime ${money(t.total)}  (last 7d ${money(t.week)} · 30d ${money(t.month)})`);
+      if (since !== null) {
+        const at = new Date(since).toLocaleString(lang === 'ko' ? 'ko-KR' : 'en-US');
+        console.log(lang === 'ko'
+          ? `  ${at}에 카운터를 초기화했습니다. 이후 기록만 집계합니다.`
+          : `  Counter reset at ${at}; only later runs are counted.`);
+      }
 
       // Per model-pair rollup first: the "what moved where" question is what
       // this view exists to answer, and it is easier to read than the log.
@@ -341,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

@@ -0,0 +1,154 @@
+/**
+ * Subcommand: saved — a stopwatch reset for the lifetime "saved" counters.
+ *
+ *   sprag saved                              # totals since the last reset
+ *   sprag saved reset [routing|doc2md|all]   # start counting from now
+ *   sprag saved undo                         # put the previous counters back
+ *   (add --agent codex for the Codex counters: codex-routing, codex-docs)
+ *
+ * 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'],
+};
+
+/** Totals since each scope's mark: { usd } for money counters, { docs } for the Codex document counter. */
+async function currentTotals(scope, dir) {
+  if (scope === 'routing') {
+    const { delegationSavedTotals } = await import('../savings-ledger.js');
+    return { usd: delegationSavedTotals(Date.now(), dir).total };
+  }
+  if (scope === 'doc2md') {
+    const { doc2mdSavedTotals } = await import('../doc2md-ledger.cjs');
+    return { usd: doc2mdSavedTotals(dir).total };
+  }
+  if (scope === 'codex-routing') {
+    const { codexRoutingSavedTotals } = await import('../codex-ledger.js');
+    return { usd: codexRoutingSavedTotals({ dir }).total };
+  }
+  const { codexDocumentTotals } = await import('../codex-doc2md-ledger.js');
+  return { docs: codexDocumentTotals({ dir }).docs };
+}
+
+/**
+ * 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');
+  const ko = userLanguage() === 'ko';
+  const dir = dirArg || userDataDir();
+  const scopes = SCOPE_SETS[agent === 'codex' ? 'codex' : 'claude'];
+  const suffix = agent === 'codex' ? ' --agent codex' : '';
+
+  const money = (v) => (v < 0 ? `-$${(-v).toFixed(2)}` : `$${v.toFixed(2)}`);
+  const fmtTotal = (t) => (t.docs !== undefined ? (ko ? `${t.docs}건` : `${t.docs} doc(s)`) : money(t.usd));
+  const fmtTime = (ms) => new Date(ms).toLocaleString(ko ? 'ko-KR' : 'en-US');
+  const label = (scope) => ({
+    routing: ko ? '라우팅 절감' : 'Routing saved',
+    doc2md: ko ? '문서 변환 절감' : 'Document conversion saved',
+    'codex-routing': ko ? 'Codex 라우팅 절감' : 'Codex routing saved',
+    'codex-docs': ko ? 'Codex 문서 변환' : 'Codex documents converted',
+  })[scope];
+
+  const sub = args[1];
+
+  if (sub === undefined) {
+    const marks = readResetMarks(dir);
+    for (const s of scopes) {
+      const t = await currentTotals(s, dir);
+      const since = marks[s] === null
+        ? (ko ? '초기화한 적 없음' : 'not reset')
+        : (ko ? `${fmtTime(marks[s])} 이후` : `since ${fmtTime(marks[s])}`);
+      console.log(`${label(s)}: ${fmtTotal(t)} (${since})`);
+    }
+    return;
+  }
+
+  if (sub === 'reset') {
+    const arg = args[2] || 'all';
+    const base = agent === 'codex' ? { routing: 'codex-routing', doc2md: 'codex-docs' } : { routing: 'routing', doc2md: 'doc2md' };
+    let targets;
+    if (arg === 'all') targets = scopes;
+    else if (scopes.includes(arg)) targets = [arg];
+    else if (base[arg]) targets = [base[arg]];
+    else {
+      console.error(ko
+        ? `알 수 없는 범위입니다: ${arg}. 사용할 수 있는 범위는 ${scopes.join(', ')}, all 입니다.`
+        : `Unknown scope: ${arg}. Valid scopes are ${scopes.join(', ')}, all.`);
+      process.exit(1);
+    }
+    const before = {};
+    for (const s of targets) before[s] = await currentTotals(s, dir);
+    resetSaved(targets, { dir });
+    for (const s of targets) {
+      console.log(ko
+        ? `${label(s)} 카운터를 0으로 초기화했습니다. 이전 합계는 ${fmtTotal(before[s])}입니다.`
+        : `Reset the ${label(s)} counter to zero. The previous total was ${fmtTotal(before[s])}.`);
+    }
+    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;
+  }
+
+  if (sub === 'undo') {
+    const undone = undoReset({ dir });
+    if (!undone) {
+      console.log(ko ? '되돌릴 초기화 기록이 없습니다.' : 'There is no reset to undo.');
+      return;
+    }
+    for (const s of undone.scopes) {
+      const t = await currentTotals(s, dir);
+      console.log(ko
+        ? `${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;
+  }
+
+  console.error(ko
+    ? `알 수 없는 하위 명령입니다: ${sub}. 사용법은 sprag saved [reset|undo] 입니다.`
+    : `Unknown subcommand: ${sub}. Usage: sprag saved [reset|undo].`);
+  process.exit(1);
+}

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;
+}

package/src/doc2md-ledger.cjs

@@ -69,6 +69,7 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
+const { readResetMarks, isBeforeReset } = require('./saved-reset.cjs');
 
 const WEEK_MS = 7 * 24 * 3600 * 1000;
 const MONTH_MS = 30 * 24 * 3600 * 1000;
@@ -185,13 +186,18 @@ function recordConversion(userDataDir, event) {
  * the lifetime rollup per format, priciest first, then most-converted. Never
  * throws; an unreadable ledger yields zeros, and the statusline hides the
  * chip on a zero.
+ *
+ * Events before the `doc2md` reset mark (`sprag saved reset`) are skipped in
+ * every figure, and `since` reports the mark (null when never reset).
  */
 function doc2mdSavedTotals(userDataDir, now = Date.now()) {
-  const empty = () => ({ week: 0, month: 0, total: 0, docs: 0, tokens: 0, byExt: [] });
+  const since = readResetMarks(userDataDir).doc2md;
+  const empty = () => ({ week: 0, month: 0, total: 0, docs: 0, tokens: 0, byExt: [], since });
   const totals = empty();
   const byExt = new Map();
   try {
     for (const e of Object.values(loadLedger(userDataDir).events)) {
+      if (isBeforeReset(e.ts, since)) continue;
       const usd = Number(e.usd) || 0;
       totals.total += usd;
       totals.docs += 1;