sprag-cli 3.59.0 → 3.61.0

package/src/formatters/statusline.js

@@ -74,6 +74,50 @@ function formatPct(v) {
   return `${(v * 100).toFixed(1)}%`;
 }
 
+/**
+ * Elapsed time as one short unit: `<1m`, `45m`, `6h`, `3d`. Floors rather than
+ * rounds, so a figure never claims more age than it has. Null for an input that
+ * is not a usable duration (a future timestamp reads as clock skew, not as
+ * "negative age").
+ */
+function formatAge(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return null;
+  const min = Math.floor(ms / 60000);
+  if (min < 1) return '<1m';
+  if (min < 60) return `${min}m`;
+  const h = Math.floor(min / 60);
+  if (h < 24) return `${h}h`;
+  return `${Math.floor(h / 24)}d`;
+}
+
+/**
+ * The reset mark a savings counter counts from, as a short local date: `10/9`,
+ * with the year prepended only when it is not the current one. Null when the
+ * counter was never reset (or the mark is unusable), which is also how the
+ * callers decide whether a zero total is worth showing.
+ */
+function formatSince(ms, now = Date.now()) {
+  const t = Number(ms);
+  if (ms == null || !Number.isFinite(t) || t <= 0) return null;
+  const d = new Date(t);
+  if (Number.isNaN(d.getTime())) return null;
+  const md = `${d.getMonth() + 1}/${d.getDate()}`;
+  return d.getFullYear() === new Date(now).getFullYear() ? md : `${d.getFullYear()}/${md}`;
+}
+
+/** A route-scan older than this makes the savings figures worth a caveat. */
+const SCAN_STALE_MS = 3 * 24 * 3600 * 1000;
+
+/** Epoch ms from a number or an ISO string; null for anything else. */
+function toEpochMs(v) {
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null;
+  if (typeof v === 'string') {
+    const t = Date.parse(v);
+    return Number.isFinite(t) ? t : null;
+  }
+  return null;
+}
+
 /**
  * Render the gauge for `pct` (0..100) as a row of separate ticks.
  *
@@ -296,7 +340,14 @@ function buildVersionSeg(version, update, c, isIcon, verbose, g) {
       : `v${version} → ${update.latest}`;
     return `${c(YELLOW)}${isIcon ? `${g.upgrade} ` : ''}${body}${c(RESET)}`;
   }
-  return `${c(GRAY)}v${version}${c(RESET)}`;
+  // Verbose mode only: how long ago the registry was last asked. A bare version
+  // cannot tell "up to date as of this morning" from "never checked since the
+  // network went away", and the second is the one worth noticing. Needs a
+  // `latest` on record, since a check that never answered confirmed nothing.
+  const age = verbose && update && update.latest && !update.available
+    ? formatAge(Date.now() - (toEpochMs(update.checkedAt) ?? NaN))
+    : null;
+  return `${c(GRAY)}v${version}${age ? ` ✓${age}` : ''}${c(RESET)}`;
 }
 
 /**
@@ -313,7 +364,11 @@ function buildHarnessSeg(c, isIcon, g, liveWindow = null) {
       // Warning state outranks the N/5 count — a runtime issue (repeated
       // error / no-evidence / racing edits) is more actionable than a
       // missing ratchet section. Always red so it stands out.
-      return `${c(RED)}${icon}${g.spike} ${harnessInfo.warning}${c(RESET)}`;
+      // Only the first warning in precedence order is named; the count of the
+      // rest rides along so a lower-priority problem is not invisible for as
+      // long as a higher one is showing.
+      const more = Number(harnessInfo.moreWarnings) || 0;
+      return `${c(RED)}${icon}${g.spike} ${harnessInfo.warning}${more > 0 ? ` +${more}` : ''}${c(RESET)}`;
     }
     if (harnessInfo.custom) return `${c(CYAN)}${icon} custom${c(RESET)}`;
     const tone = harnessInfo.configured >= harnessInfo.total ? GREEN : YELLOW;
@@ -323,6 +378,42 @@ function buildHarnessSeg(c, isIcon, g, liveWindow = null) {
   }
 }
 
+/**
+ * Delegation-rule registry chip: `rules 10 · ⚠1`. Rendered only when
+ * `--segments` names `rules`, since it describes configuration rather than
+ * anything the user can act on in the next minute; the 🅷 chip already raises
+ * `rule-health` when one needs attention.
+ * `⚠N` is the number of rules flagged for review, and is left off at zero so a
+ * healthy registry reads as a plain count.
+ */
+function buildRulesSeg(stats, c, g) {
+  if (!stats) return null;
+  const total = Number(stats.total) || 0;
+  if (total <= 0) return null;
+  const review = Number(stats.review) || 0;
+  const flagged = review > 0 ? ` ${c(GRAY)}·${c(RESET)} ${c(YELLOW)}${g.spike}${review}${c(RESET)}` : '';
+  return `${c(GRAY)}rules ${total}${c(RESET)}${flagged}`;
+}
+
+/**
+ * This session's subagent runs: `3 (haiku 2 · sonnet 1)`. Counts every
+ * subagent the session started, not only the ones a routing rule sent, so it
+ * answers "how much did this session fan out" rather than "how many rules
+ * fired". Null when the session ran none, which is the common case.
+ */
+function buildSessionDelegationSeg(sd, c, isIcon, verbose, g) {
+  const total = Number(sd && sd.total) || 0;
+  if (total <= 0) return null;
+  const families = Array.isArray(sd.families)
+    ? sd.families.filter((f) => f && Number(f.runs) > 0).map((f) => `${f.family} ${f.runs}`)
+    : [];
+  const label = isIcon
+    ? `${g.routing} ${verbose ? 'Subagents this session' : 'this session'}`
+    : 'Subagents this session';
+  const split = families.length ? ` ${c(GRAY)}(${families.join(' · ')})${c(RESET)}` : '';
+  return `${c(CYAN)}${label} ${total}${c(RESET)}${split}`;
+}
+
 /**
  * Cap-warn chip builder — shared by the full report and the no-session
  * fallback line. At 90%+ the user wants to know "when can I send again", so
@@ -386,7 +477,7 @@ export function formatNoSession({ caps = null, model = null, effort = null, wind
  * @param {boolean} [opts.verbose=false] - longer layout with labels
  * @param {boolean} [opts.timer=true] - show TTL countdown segment
  * @param {'text'|'icon'} [opts.mode='text'] - label style. 'icon' uses 🧠 ⏳ 💰 instead of word labels.
- * @param {string[]|null} [opts.segments] - segments to render, in the order given. Names: cap-warn, spike, version, harness, korean, model, effort, hit, ttl, month, saved, delegated, doc2md, ctx, period, `usage` (every rate-limit window), plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. cap-warn and spike keep the lead regardless of where they appear. Null/undefined = all, in the default order.
+ * @param {string[]|null} [opts.segments] - segments to render, in the order given. Names: cap-warn, spike, version, harness, korean, model, effort, hit, ttl, month, saved, delegated, doc2md, ctx, period, `subagents` (this session's subagent runs; also rides with `delegated`), `rules` (only when named here), `usage` (every rate-limit window), plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. cap-warn and spike keep the lead regardless of where they appear. Null/undefined = all, in the default order.
  * @param {boolean} [opts.singleLine=false] - force the legacy one-line layout. By default, when the delegation ledger has lifetime savings, the routing totals lead on their own first line and everything else moves to line 2 (Claude Code renders multi-line statuslines; `--single-line` is the escape hatch for terminals that only show the first line).
  */
 /**
@@ -491,9 +582,10 @@ export function formatReport(data, { color = true, verbose = false, timer = true
 
   // Delegation savings — a DIFFERENT number from "Cache saved" above, which
   // covers the prompt cache only. This one is what running work on a cheaper
-  // tier saved, the lifetime total of the delegation ledger. Hidden
-  // when zero or absent: a permanent "$0" is noise for direct-API users and
-  // for anyone who has not delegated yet.
+  // tier saved, the lifetime total of the delegation ledger (counted from the
+  // last `sprag saved reset`, when there was one). Hidden when zero or absent
+  // and never reset: a permanent "$0" is noise for direct-API users and for
+  // anyone who has not delegated yet.
   // "Routing saved" says what earned the money — work that ran on a cheaper
   // model instead of this one. It leads the line rather than trailing it
   // because it is the headline number of the whole tool, not a footnote.
@@ -518,11 +610,38 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // Tied to MIN_VOTES rather than a literal so the two cannot drift: the chip
   // appears exactly when learning has had its chance and still came up short.
   const unresolvedRuns = Number(data.unresolvedRuns) || 0;
-  const delegateSeg = delegationSaved !== 0
-    ? `${c(delegationSaved < 0 ? RED : GREEN)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}`
-    : (unresolvedRuns >= MIN_VOTES
-      ? `${c(YELLOW)}${g.routing} ${unresolvedRuns} unresolved${c(RESET)}`
-      : null);
+  const unresolvedSeg = unresolvedRuns >= MIN_VOTES
+    ? `${c(YELLOW)}${g.routing} ${unresolvedRuns} unresolved${c(RESET)}`
+    : null;
+
+  // The counter's reset mark ("since 10/9"), when `sprag saved reset` was run.
+  // After a reset the total is legitimately zero, and a chip that vanished at
+  // zero made "just reset" look the same as "feature off". With a mark on
+  // record a zero is shown, dated; with none it stays hidden as before.
+  // Compact icon mode has no room for a sentence, so it gets `(10/9~)`.
+  const totals = data.delegationTotals;
+  const routingSince = formatSince(totals && totals.since);
+  const sinceWord = (since) => (since ? ` ${c(GRAY)}since ${since}${c(RESET)}` : '');
+  const sinceCompact = (since) => (since ? ` ${c(GRAY)}(${since}~)${c(RESET)}` : '');
+  const sinceInline = isIcon && !verbose ? sinceCompact : sinceWord;
+
+  // Savings come from the ledger route-scan fills, so they are only as fresh as
+  // the last scan. Said only once that has gone stale: a recent scan is the
+  // normal case and needs no caveat.
+  const scanAt = toEpochMs(data.routeScanAt);
+  const scanAge = scanAt !== null && Date.now() - scanAt > SCAN_STALE_MS ? formatAge(Date.now() - scanAt) : null;
+  const scanTag = scanAge
+    ? ` ${c(GRAY)}${verbose ? `last scan ${scanAge} ago` : `scan ${scanAge}`}${c(RESET)}`
+    : '';
+
+  const savedTone = delegationSaved < 0 ? RED : delegationSaved > 0 ? GREEN : GRAY;
+  const savingsChip = delegationSaved !== 0 || routingSince
+    ? `${c(savedTone)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}${sinceInline(routingSince)}${scanTag}`
+    : null;
+  // The unresolved count stands in only while there are no savings to show, so
+  // a dated zero keeps both: the reset and the dropped runs are separate facts.
+  const delegateSeg = savingsChip || (delegationSaved === 0 ? unresolvedSeg : null);
+  const delegateExtra = savingsChip && delegationSaved === 0 ? unresolvedSeg : null;
 
   // Document conversions — the same kind of number as "Routing saved", earned
   // a different way: a document read as Markdown instead of attached whole.
@@ -538,16 +657,22 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   const doc2md = data.doc2mdTotals;
   const doc2mdUsd = Number(doc2md && doc2md.total) || 0;
   const doc2mdDocs = Number(doc2md && doc2md.docs) || 0;
+  // Same reset mark as the routing counter, and the same reason to show a dated
+  // zero: after `sprag saved reset` an empty counter and a disabled feature
+  // would otherwise look alike.
+  const doc2mdSince = formatSince(doc2md && doc2md.since);
   const doc2mdLabel = isIcon
     ? (verbose ? `${g.doc} Doc2md saved` : g.doc)
     : 'Doc2md saved';
   let doc2mdSeg = null;
   if (doc2mdUsd > 0) {
-    doc2mdSeg = `${c(GREEN)}${doc2mdLabel}${c(RESET)} ${formatMoney(doc2mdUsd)}`
+    doc2mdSeg = `${c(GREEN)}${doc2mdLabel}${c(RESET)} ${formatMoney(doc2mdUsd)}${sinceInline(doc2mdSince)}`
       + (verbose ? ` ${c(GRAY)}· ${doc2mdDocs} docs${c(RESET)}` : '');
   } else if (doc2mdDocs > 0) {
     const label = isIcon ? g.doc : 'Doc2md';
-    doc2mdSeg = `${c(GRAY)}${label} ${doc2mdDocs} docs${c(RESET)}`;
+    doc2mdSeg = `${c(GRAY)}${label} ${doc2mdDocs} docs${doc2mdSince ? ` ${isIcon && !verbose ? `(${doc2mdSince}~)` : `since ${doc2mdSince}`}` : ''}${c(RESET)}`;
+  } else if (doc2mdSince) {
+    doc2mdSeg = `${c(GRAY)}${doc2mdLabel} ${formatMoney(0)}${isIcon && !verbose ? ` (${doc2mdSince}~)` : ` since ${doc2mdSince}`}${c(RESET)}`;
   }
 
   // 이번 달 지출 세그먼트. 달력 월(1일 00시 기준) 지출 추정치라서 cap 이 없는
@@ -584,9 +709,11 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // nothing to mismatch.
   //   icon:  "🔀 Routing saved $9.8 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
   //   text:  "Routing saved $9.8 | opus→haiku 2× $6.4 · fable→sonnet 1× $3.4"
-  const totals = data.delegationTotals;
   let totalsLine = null;
-  if (!singleLine && totals && Number(totals.total) !== 0 && Number.isFinite(Number(totals.total))) {
+  const totalsNum = Number(totals && totals.total);
+  // A zero total gets its line only when a reset mark explains it; see the
+  // note above `routingSince`.
+  if (!singleLine && totals && Number.isFinite(totalsNum) && (totalsNum !== 0 || routingSince)) {
     const head = isIcon ? `${g.routing} Routing saved` : 'Routing saved';
     // Model changes behind the total, family-level and version-free: `opus →
     // haiku 2× $0.6`. Versions bump constantly and add nothing here — the
@@ -605,10 +732,12 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     const pairText = pairs
       .map((p) => `${c(GRAY)}${p.from}→${p.to} ${p.runs}× ${formatMoney(p.usd)}${c(RESET)}`)
       .join(` ${c(GRAY)}·${c(RESET)} `);
-    const tone = Number(totals.total) < 0 ? RED : GREEN; // a net loss must not read as a win
+    // A net loss must not read as a win, and a zero is neither.
+    const tone = totalsNum < 0 ? RED : totalsNum > 0 ? GREEN : GRAY;
     totalsLine =
       `${c(tone)}${c(BOLD)}${head}${c(RESET)} ` +
-      `${c(tone)}${formatMoney(Number(totals.total) || 0)}${c(RESET)}` +
+      `${c(tone)}${formatMoney(totalsNum)}${c(RESET)}` +
+      sinceWord(routingSince) + scanTag +
       (pairText ? `  ${c(GRAY)}|${c(RESET)}  ${pairText}` : '');
   }
 
@@ -637,6 +766,7 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     doc2mdLine =
       `${c(GREEN)}${c(BOLD)}${head}${c(RESET)} ` +
       `${c(GREEN)}${formatMoney(doc2mdUsd)}${c(RESET)}` +
+      sinceWord(doc2mdSince) +
       (extText ? `  ${c(GRAY)}|${c(RESET)}  ${extText}` : '');
   }
 
@@ -770,6 +900,13 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // Korean-style chip — rendered only when the session-start injection is on.
   const koreanSeg = buildKoreanSeg(c, isIcon, verbose, g);
 
+  // Delegation-rule registry (`rules 10 · ⚠1`), opt-in through `--segments`.
+  const rulesSeg = buildRulesSeg(data.ruleStats, c, g);
+
+  // This session's subagent runs by model family. It is a session figure, so it
+  // sits with the routing chips rather than with the lifetime totals above it.
+  const sessionDelegationSeg = buildSessionDelegationSeg(data.sessionDelegation, c, isIcon, verbose, g);
+
   // Model chip — pulled from Claude Code's stdin payload (`model.display_name`).
   // Cheap identity context: useful when the user toggles between Sonnet/Opus
   // mid-session and wants to confirm at a glance which one is answering.
@@ -896,13 +1033,25 @@ export function formatReport(data, { color = true, verbose = false, timer = true
       case 'cap-warn':  return [capWarnSeg];
       case 'spike':     return [spikeSeg];
       case 'version':   return [versionSeg];
+      // `rules` renders only when asked for by name. Verbose is the shipped
+      // default, so riding with the harness chip would put it on everyone's
+      // line, and its ⚠ count repeats what `rule-health` already raises there.
       case 'harness':   return [harnessSeg];
+      case 'rules':     return [rulesSeg];
+      case 'subagents': return [sessionDelegationSeg];
       case 'korean':    return [koreanSeg];
       case 'model':     return [modelSeg];
       case 'effort':    return [effortSeg];
       // Dropped when the same story already owns a headline line above, which
       // would otherwise repeat it on line 2.
-      case 'delegated': return totalsLine ? [] : [delegateSeg];
+      // The unresolved-runs chip survives the headline when that headline is a
+      // dated zero, since a zero is exactly when the dropped runs matter.
+      case 'delegated': {
+        const base = totalsLine
+          ? (totalsNum === 0 ? [unresolvedSeg] : [])
+          : [delegateSeg, delegateExtra];
+        return [...base, sessionDelegationSeg];
+      }
       case 'doc2md':    return doc2mdLine ? [] : [doc2mdSeg];
       case 'hit':       return [hitSeg];
       case 'ttl':       return [ttlSeg];

package/src/harness-analyzer.cjs

@@ -244,8 +244,14 @@ function writeState(state) {
     if (!fs.existsSync(STATE_DIR)) fs.mkdirSync(STATE_DIR, { recursive: true });
     // tmp + rename so the statusline never reads a half-written state file.
     const tmp = STATE_PATH + '.' + process.pid + '.tmp';
-    fs.writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n');
-    fs.renameSync(tmp, STATE_PATH);
+    try {
+      fs.writeFileSync(tmp, JSON.stringify(state, null, 2) + '\n');
+      fs.renameSync(tmp, STATE_PATH);
+    } catch (e) {
+      // A failed write or rename must not leave the temp file behind.
+      try { fs.rmSync(tmp, { force: true }); } catch { /* nothing to clean */ }
+      throw e;
+    }
   } catch {
     // best-effort
   }

package/src/harness.js

@@ -614,8 +614,14 @@ export function harnessStatusForStatusline(cfg, { root, liveWindow = null } = {}
   // user hasn't opted in, no point nagging.
   if (!status.hasFile && !existsSync(join(projectRoot, '.claude'))) return null;
   if (status.optOut) return null;
-  // Attach a warning derived from the analyzer state file (if any). Precedence:
-  //   ratchet? > no-evidence > PEV-skip. Guards, in order:
+  // Warnings derived from the analyzer state file (if any), then the config
+  // and registry checks below. Every check runs and collects, in precedence
+  // order, so the chip can name the first and count the rest: stopping at the
+  // first hid everything behind it (a `PEV-skip` on screen meant a failing
+  // `rule-health` was invisible until the PEV one cleared).
+  //
+  // Precedence: ratchet? > no-evidence > PEV-skip > ratchet-unloaded >
+  // compact-window? > rule-health > route?. Guards on the state file, in order:
   //   - freshness: the hook rewrites the state on every tool use, so anything
   //     older than WARNING_TTL_MS is a dead session's leftovers — a red 🅷⚠
   //     must never linger for days after the triggering session ended.
@@ -627,7 +633,7 @@ export function harnessStatusForStatusline(cfg, { root, liveWindow = null } = {}
   //     every project.
   const WARNING_TTL_MS = 30 * 60 * 1000;
   const state = readHarnessState();
-  let warning = null;
+  const warnings = [];
   if (state) {
     const ts = state.timestamp ? Date.parse(state.timestamp) : NaN;
     const fresh = Number.isFinite(ts) && Date.now() - ts <= WARNING_TTL_MS;
@@ -635,42 +641,45 @@ export function harnessStatusForStatusline(cfg, { root, liveWindow = null } = {}
     if (fresh && matches) {
       if (state.ratchetCandidate && state.ratchetCandidate.count >= 2) {
         const id = state.ratchetCandidate.id || 1;
-        warning = `ratchet? #${id}`;
+        warnings.push(`ratchet? #${id}`);
       }
-      else if (state.evidenceLow) warning = 'no-evidence';
-      else if (state.pevSkip) warning = 'PEV-skip';
+      if (state.evidenceLow) warnings.push('no-evidence');
+      if (state.pevSkip) warnings.push('PEV-skip');
     }
   }
   // Config defect, above the optimization nudges: the harness block is there
   // but carries no `@` import, so every promoted ratchet rule is dead weight.
   // One `harness init` re-run fixes it and the warning goes away for good.
-  if (!warning && status.hasBlock && !(status.hasRatchetImport && status.hasModelRatchetImport)) warning = 'ratchet-unloaded';
+  if (status.hasBlock && !(status.hasRatchetImport && status.hasModelRatchetImport)) warnings.push('ratchet-unloaded');
   // Same class of defect, one notch lower: the session runs on a 1M-context
   // model with no `autoCompactWindow` cap, so compaction only fires past 800k
   // and every request until then re-bills the whole context. 200k sessions are
   // exempt — the setting cannot change anything for them.
-  if (!warning) {
-    try {
-      warning = compactWindowWarningForStatusline(projectRoot, cfg, { liveWindow });
-    } catch { /* settings unreadable — stay silent */ }
-  }
+  try {
+    const w = compactWindowWarningForStatusline(projectRoot, cfg, { liveWindow });
+    if (w) warnings.push(w);
+  } catch { /* settings unreadable — stay silent */ }
   // Below session-quality warnings: a promoted delegation rule whose
   // category started failing (`rule-health R<N>`) — the user approved that
   // rule, so its degradation outranks a mere new-candidate nudge.
-  if (!warning) {
-    try {
-      warning = ruleHealthWarningForStatusline(projectRoot);
-    } catch { /* registry unreadable — stay silent */ }
-  }
+  try {
+    const w = ruleHealthWarningForStatusline(projectRoot);
+    if (w) warnings.push(w);
+  } catch { /* registry unreadable — stay silent */ }
   // Lowest precedence: route-scan delegation candidate (`route? R<N>`).
   // Session-quality warnings above always win — routing is an optimization
   // nudge, not a correctness signal. Cheap: one small cached-JSON read.
-  if (!warning) {
-    try {
-      warning = routeWarningForStatusline(projectRoot);
-    } catch { /* scan cache unreadable — stay silent */ }
-  }
-  return { ...status, warning };
+  try {
+    const w = routeWarningForStatusline(projectRoot);
+    if (w) warnings.push(w);
+  } catch { /* scan cache unreadable — stay silent */ }
+  // `warning` is the one shown; `moreWarnings` counts the ones it outranks.
+  // The checks after the state file are a few small JSON reads (settings,
+  // model-rules.json ~11KB, route-scan.json ~1KB). A render with no warning
+  // already ran all of them; the change is that they now also run while an
+  // earlier warning is up, so no render does more than the clean one did.
+  return { ...status, warning: warnings[0] || null, moreWarnings: Math.max(0, warnings.length - 1), warnings };
+
 }
 
 function escapeRe(s) {

package/src/installer.js

@@ -640,6 +640,58 @@ export function removeKoreanLintHook() {
   return { path: file, action: 'removed' };
 }
 
+// Registers the Stop hook that catches an English reply to a Korean prompt.
+// The lint hook above watches files the model writes; this slip writes no
+// file, so it needs its own checkpoint at the end of the turn. Installed and
+// removed together with the lint hook by `korean on|off`. Idempotent.
+const REPLY_LANGUAGE_HOOK_COMMAND = `${CLI} korean --reply-hook`;
+
+export function installReplyLanguageHook() {
+  const dir = claudeUserDir();
+  const file = join(dir, 'settings.json');
+  mkdirSync(dir, { recursive: true });
+
+  const read = readSettings(file);
+  if (read.state === 'unusable') return { path: file, action: 'skipped', reason: read.reason };
+  const settings = read.settings;
+
+  const hooksProblem = ensureHooksObject(settings);
+  if (hooksProblem) return { path: file, action: 'skipped', reason: hooksProblem };
+  if (settings.hooks.Stop !== undefined && !Array.isArray(settings.hooks.Stop)) {
+    return { path: file, action: 'skipped', reason: 'hooks.Stop is not an array — fix settings.json manually' };
+  }
+  const list = Array.isArray(settings.hooks.Stop) ? settings.hooks.Stop : [];
+  const existing = list.find((m) =>
+    Array.isArray(m?.hooks) && m.hooks.some((h) => isOurSubcommand(h?.command, 'korean', '--reply-hook')),
+  );
+  if (existing) return { path: file, action: 'exists' };
+
+  list.push({
+    hooks: [{ type: 'command', command: REPLY_LANGUAGE_HOOK_COMMAND, timeout: 10 }],
+  });
+  settings.hooks.Stop = list;
+  const writeProblem = writeSettings(file, settings);
+  if (writeProblem) return { path: file, action: 'skipped', reason: writeProblem };
+  return { path: file, action: 'created' };
+}
+
+export function removeReplyLanguageHook() {
+  const file = join(claudeUserDir(), 'settings.json');
+  if (!existsSync(file)) return { path: file, action: 'absent' };
+  const read = readSettings(file);
+  if (read.state === 'unusable') return { path: file, action: 'skipped', reason: read.reason };
+  const settings = read.settings;
+  const list = settings?.hooks?.Stop;
+  if (!Array.isArray(list)) return { path: file, action: 'absent' };
+  const { kept, touched } = removeHooksWhere(list, (h) => isOurSubcommand(h?.command, 'korean', '--reply-hook'));
+  if (!touched) return { path: file, action: 'absent' };
+  if (kept.length === 0) delete settings.hooks.Stop;
+  else settings.hooks.Stop = kept;
+  const writeProblem = writeSettings(file, settings);
+  if (writeProblem) return { path: file, action: 'skipped', reason: writeProblem };
+  return { path: file, action: 'removed' };
+}
+
 // Registers the PreToolUse hook that converts attached documents to Markdown
 // before the model reads them. PreToolUse rather than PostToolUse because the
 // point is to intervene before a pptx lands in the context window; afterwards

package/src/model-alias.js

@@ -36,12 +36,13 @@
  * package is published to npm, so neither may live in the source.
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync, createReadStream, statSync, renameSync } from 'node:fs';
+import { readFileSync, mkdirSync, existsSync, createReadStream, statSync } from 'node:fs';
 import { readFile, readdir } from 'node:fs/promises';
 import { createInterface } from 'node:readline';
 import { join, dirname, basename } from 'node:path';
 import { userDataDir, claudeUserDir } from './paths.js';
 import { gatewayBase } from './gateway-auth.js';
+import { writeViaTmp } from './state-file.js';
 
 /** Marker returned when a gateway id could not be resolved to a model. */
 export const UNKNOWN_MODEL = 'unknown';
@@ -154,8 +155,7 @@ function writeProfileMapFile(map) {
   mkdirSync(dir, { recursive: true });
   const target = profileMapPath();
   const tmp = `${target}.tmp-${process.pid}`;
-  writeFileSync(tmp, JSON.stringify(map, null, 2));
-  renameSync(tmp, target);
+  writeViaTmp(tmp, target, JSON.stringify(map, null, 2));
 }
 
 /**

package/src/model-rules.js

@@ -147,15 +147,17 @@ export function modelRuleBaseText(g, lang = userLanguage(), { root } = {}) {
 // this, so an XDG_CONFIG_HOME override moves every state file together.
 const stateDir = userDataDir;
 
-export function modelRulesPath() {
-  return join(stateDir(), 'model-rules.json');
+export function modelRulesPath({ dir = stateDir() } = {}) {
+  return join(dir, 'model-rules.json');
 }
 
-export function loadModelRules() {
+export function loadModelRules({ dir = stateDir(), strict = false } = {}) {
   try {
-    const data = JSON.parse(readFileSync(modelRulesPath(), 'utf8'));
-    return Array.isArray(data.rules) ? data : { rules: [] };
-  } catch {
+    const data = JSON.parse(readFileSync(modelRulesPath({ dir }), 'utf8'));
+    if (!Array.isArray(data?.rules)) throw new Error('Invalid registry');
+    return data;
+  } catch (error) {
+    if (strict && error.code !== 'ENOENT') throw new Error('Cannot parse model rules; file left unchanged.');
     return { rules: [] };
   }
 }
@@ -189,8 +191,9 @@ export function saveModelRules(data) {
 
 /** Add (or re-activate) a promoted rule; returns the stored entry. */
 export function addModelRule(entry) {
-  const data = loadModelRules();
-  const existing = data.rules.find((r) => r.signature === entry.signature && r.scope === entry.scope);
+  const data = loadModelRules({ strict: true });
+  const existing = data.rules.find((r) => r.signature === entry.signature && r.scope === entry.scope &&
+    (r.scope === 'global' || r.targetRoot === entry.targetRoot));
   if (existing) {
     Object.assign(existing, entry, { status: 'active' });
     saveModelRules(data);
@@ -581,7 +584,9 @@ export function refreshModelRules(episodeStats, delegatedStats = new Map(), { no
     }
     // Window snapshot, not a running total: these describe the current scan
     // window so a rule that stopped firing decays to zero instead of coasting
-    // on old credit.
+    // on old credit. savedUsd is the one figure `sprag saved reset` narrows: the
+    // scan only adds runs that started after the routing mark (see
+    // tallyDelegatedRun), while runs and the error rate keep the whole window.
     r.delegatedRuns = d ? d.runs : 0;
     r.delegatedErrRate = d && d.runs > 0 ? d.errRuns / d.runs : 0;
     r.savedUsd = d ? Math.round(d.savedUsd * 100) / 100 : 0;

package/src/preset-ratchet.js

@@ -17,7 +17,7 @@
  * a project rule is the user's placement decision, not a tool-wide default.
  */
 
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { codexUserDir } from './agent.js';
@@ -30,6 +30,7 @@ import {
   renderPresetRatchet,
 } from './harness-templates.js';
 import { loadSeedState, ratchetPresets, saveSeedState } from './seed-rules.js';
+import { writeViaTmp } from './state-file.js';
 
 export function presetRatchetPath({ agent = 'claude' } = {}) {
   return agent === 'codex'
@@ -47,8 +48,7 @@ function writeIfChanged(file, text) {
   if (before === text) return false;
   mkdirSync(dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}`;
-  writeFileSync(tmp, text);
-  renameSync(tmp, file);
+  writeViaTmp(tmp, file, text);
   return true;
 }