sprag-cli 3.50.1 → 3.52.0

package/bin/cli.js

@@ -52,7 +52,7 @@ import {
   sessionMetrics,
   diagnoseSession,
 } from '../src/stats.js';
-import { estimateCost } from '../src/cost.js';
+import { estimateCostAcross } from '../src/cost.js';
 import { chipForIssues } from '../src/advice.js';
 import { debug } from '../src/debug.js';
 import { createArgs } from '../src/cli-args.js';
@@ -561,7 +561,7 @@ async function main() {
   const ttl = ttlBreakdown(sessions);
   const sum = summary(sessions);
   const anomalies = detectAnomalies(trend);
-  const cost = estimateCost(sum, sessions[0]?.model);
+  const cost = estimateCostAcross(sessions);
   const spikeReport = detectSpikes(sessions, { recentHours: 24, multiplier: 3 });
   const contextWindow = detectContextWindow(sessions, { recentHours: 24 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.50.1",
+  "version": "3.52.0",
   "description": "Sprag - a quality ratchet harness for AI coding agents: model-fitting delegation, ratchet rules, doc2md, Korean style gate. Same tool as claude-token-saver, under its new name.",
   "type": "module",
   "bin": {

package/src/caps-cache.js

@@ -9,7 +9,7 @@
  * than `maxAgeMs` the loader returns null and the table view stays quiet.
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
 import { userDataDir } from './paths.js';
 
@@ -38,7 +38,11 @@ export function persistSnapshot(snapshot) {
       caps: snapshot.caps || null,
       model: snapshot.model || null,
     };
-    writeFileSync(CACHE_PATH, JSON.stringify(payload) + '\n');
+    // 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);
   } catch {
     // best-effort cache, never blocks the statusline
   }

package/src/commands/brief.js

@@ -34,8 +34,12 @@ export async function run({ hasFlag }) {
     // the match here removes both steps. Silent unless it is sure — see
     // src/route-inject.js.
     try {
-      const { routeHint } = await import('../route-inject.js');
-      const hint = routeHint(ctx.prompt);
+      const { routeHint, sessionModelRank } = await import('../route-inject.js');
+      // The payload names the session but not its model, so the rank comes from
+      // the transcript: without it a Sonnet session is told to delegate to
+      // Sonnet, which saves nothing.
+      const sessionRank = sessionModelRank({ transcriptPath: ctx.transcript_path });
+      const hint = routeHint(ctx.prompt, { sessionRank });
       if (hint) parts.push(hint);
     } catch (e) { debug('brief:route-hint', e); }
     if (parts.length) console.log(parts.join('\n'));

package/src/commands/harness.js

@@ -161,7 +161,9 @@ export async function run({ args, hasFlag }) {
           }
           process.exit(1);
         }
-        rule = `반복 감지 ×${cand.count}: ${cand.pattern} — TODO: 원인·예방책 한 줄로`;
+        // No em dash here: this text lands in ratchet.md, where the Korean
+        // write-time lint would flag it on the user's next edit.
+        rule = `반복 감지 ×${cand.count}: ${cand.pattern} · TODO: 원인과 예방책을 한 줄로 적습니다`;
       }
       // R-prefixed arg → route-scan delegation candidate (statusline `route? R<N>`).
       // The rule text is pre-generated by the scan; promoting also resolves the

package/src/commands/install.js

@@ -257,8 +257,8 @@ export async function run({ hasFlag }) {
           ? '           내용: 조사·어미를 생략하지 않고, 명사구가 아니라 서술어로 문장을 끝맺으며,'
           : '           what it does: keeps particles and endings, ends sentences with a predicate,');
         console.log(lang === 'ko'
-          ? '                 번역체 대신 자연스러운 한국어를 쓰도록 지시합니다. 코드와 주석에는 적용되지 않습니다.'
-          : '                 and asks for idiomatic Korean over translationese. Code and comments are exempt.');
+          ? '                 번역체 대신 자연스러운 한국어를 쓰도록 지시합니다. 기본 범위는 코드 주석과 문자열까지 포함하며, `korean lint scope prose` 로 산문만 검사하도록 좁힐 수 있습니다.'
+          : '                 and asks for idiomatic Korean over translationese. The default scope includes code comments and strings; `korean lint scope prose` narrows it to prose.');
         console.log(lang === 'ko'
           ? '           비용: 세션당 약 1.5k 토큰(턴마다가 아니라 세션 시작 시 1회, 이후 프롬프트 캐시에 포함).'
           : '           cost: ~1.5k tokens per session (once at session start, cached from the second request on).');

package/src/commands/korean.js

@@ -181,8 +181,8 @@ export async function run({ args, hasFlag }) {
           : `  ⚠ Could not register the write-time hook: ${hook.reason}`);
       } else {
         console.log(lang === 'ko'
-          ? `  쓰기 시점 검사: ${koreanLintMode(loadConfig())}, 범위 ${koreanLintScope(loadConfig())} (Write·Edit 로 쓴 한국어를 검사합니다)`
-          : `  Write-time check: ${koreanLintMode(loadConfig())}, scope ${koreanLintScope(loadConfig())} (runs on Korean written via Write/Edit)`);
+          ? `  쓰기 시점 검사: ${koreanLintMode(loadConfig())}, 범위 ${koreanLintScope(loadConfig())} (Write·Edit·Bash 로 쓴 한국어를 검사합니다)`
+          : `  Write-time check: ${koreanLintMode(loadConfig())}, scope ${koreanLintScope(loadConfig())} (runs on Korean written via Write, Edit or Bash)`);
       }
     } else {
       console.log(lang === 'ko'

package/src/compact-window.js

@@ -73,7 +73,13 @@ function readJson(path) {
  * its /config parser documents. Returns null when unparseable.
  */
 export function parseWindow(raw) {
-  if (typeof raw === 'number') return Number.isFinite(raw) ? Math.round(raw) : null;
+  if (typeof raw === 'number') {
+    if (!Number.isFinite(raw)) return null;
+    // Same bare-hundreds rule as the string form: `200` and `"200"` are one
+    // intent and must audit the same way.
+    const n = Math.round(raw);
+    return n < MIN_WINDOW ? n * 1_000 : n;
+  }
   if (typeof raw !== 'string') return null;
   const s = raw.trim().toLowerCase();
   const m = s.match(/^(\d+(?:\.\d+)?)\s*([km]?)$/);

package/src/cost.js

@@ -248,6 +248,40 @@ export function estimateCost(totals, model) {
   };
 }
 
+/**
+ * Price a set of sessions each at its own model and sum. One estimateCost over
+ * the summed totals priced every token at whichever session came first in the
+ * list — sorted by mtime, so a haiku scratch session touched earliest set the
+ * rate for a day of Fable work and understated the saving about tenfold.
+ * Sessions whose model has no known rate are skipped, as month-spend does.
+ */
+export function estimateCostAcross(sessions) {
+  const acc = { actual: 0, noCacheCost: 0, scenario5mCost: 0, extraCostIf5mApplicable: false };
+  const tiers = new Map();
+  for (const s of sessions || []) {
+    if (!s?.totals) continue;
+    let c;
+    try { c = estimateCost(s.totals, s.model); } catch { continue; }
+    acc.actual += c.actual;
+    acc.noCacheCost += c.noCacheCost;
+    acc.scenario5mCost += c.scenario5mCost;
+    acc.extraCostIf5mApplicable = acc.extraCostIf5mApplicable || c.extraCostIf5mApplicable;
+    tiers.set(c.tier, (tiers.get(c.tier) || 0) + c.actual);
+  }
+  let tier = null;
+  for (const [t, usd] of tiers) if (tier === null || usd > tiers.get(tier)) tier = t;
+  return {
+    tier,
+    actual: round(acc.actual),
+    noCacheCost: round(acc.noCacheCost),
+    savings: round(acc.noCacheCost - acc.actual),
+    savingsRate: acc.noCacheCost > 0 ? (acc.noCacheCost - acc.actual) / acc.noCacheCost : 0,
+    scenario5mCost: round(acc.scenario5mCost),
+    extraCostIf5m: round(acc.scenario5mCost - acc.actual),
+    extraCostIf5mApplicable: acc.extraCostIf5mApplicable,
+  };
+}
+
 function round(n) {
   return Math.round(n * 100) / 100;
 }

package/src/doc2md-ledger.cjs

@@ -23,8 +23,8 @@
  * `claude --print --input-format stream-json` with and without the file as a
  * document block. The control turn cost 42,204 tokens, twice, to the token.
  *
- *   kohjuho_resume_kr.pdf   7 pages   +20,537 tokens   2,934 per page
- *   xeoyoung_resume.pdf     5 pages   +12,709 tokens   2,542 per page
+ *   report-a.pdf   7 pages   +20,537 tokens   2,934 per page
+ *   report-b.pdf   5 pages   +12,709 tokens   2,542 per page
  *
  * A PDF is read whole: the model answered from its contents. Converting one
  * to text is worth three to four times its own size.
@@ -38,7 +38,7 @@
  * outweigh the text many times over:
  *
  *   aws-summit-seoul.pptx   2.1MB of slide XML   ~540,429 tokens   23.8× the conversion
- *   우리은행이력서.docx      312KB of body XML    ~78,113 tokens    ~46× the conversion
+ *   사업계획서.docx         312KB of body XML    ~78,113 tokens    ~46× the conversion
  *
  * So the baseline for these formats is the body markup the converter read,
  * measured per file rather than assumed from a ratio. It is a real number for

package/src/formatters/statusline.js

@@ -458,7 +458,9 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     : (ttl.gatewayObserved ? YELLOW : GRAY);
   const ttlSeconds = is1h ? 3600 : 300;
 
-  const savings = cost?.savings ?? 0;
+  // noCache − actual goes negative in write-heavy sessions (cache writes bill
+  // 1.25×/2× with few reads yet); "$-0.42" is not a saving, so floor at zero.
+  const savings = Math.max(0, cost?.savings ?? 0);
 
   const c = (v) => (color ? v : '');
   // narrow shares the icon layout and swaps only the glyphs, so both modes take

package/src/harness-analyzer.cjs

@@ -218,7 +218,9 @@ function computePevSkip(entries) {
 
 function analyzeTranscript(transcriptPath, opts) {
   opts = opts || {};
-  const entries = readJsonl(transcriptPath);
+  // The hook has already parsed the transcript for its own totals; reading a
+  // 65MB session a second time per tool call is the one avoidable cost here.
+  const entries = Array.isArray(opts.entries) ? opts.entries : readJsonl(transcriptPath);
   if (entries.length === 0) return null;
   const evidenceRate = computeEvidenceRate(entries);
   const pevSkip = computePevSkip(entries);
@@ -240,7 +242,10 @@ function writeState(state) {
   if (!state) return;
   try {
     if (!fs.existsSync(STATE_DIR)) fs.mkdirSync(STATE_DIR, { recursive: true });
-    fs.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2) + '\n');
+    // 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);
   } catch {
     // best-effort
   }

package/src/hook-manager.js

@@ -26,6 +26,31 @@ function isCacheMonitorHook(nh) {
   return cmd.includes(HOOK_MARKER) || cmd.includes('--hook-run');
 }
 
+/**
+ * Drop our hook entries and keep everything else. Removal is per hook, not per
+ * matcher group: Claude Code merges hooks that share a matcher into one group,
+ * so filtering whole groups took another tool's hook with ours whenever that
+ * tool had been installed into the same `Bash|Edit|Write` group. A group goes
+ * only once nothing of anyone else's is left in it. Same rule as
+ * installer.js uninstallAll, which fixed this for the other hooks earlier.
+ */
+export function withoutCacheMonitorHooks(groups) {
+  const kept = [];
+  for (const m of groups) {
+    if (!Array.isArray(m?.hooks)) { kept.push(m); continue; }
+    const hooks = m.hooks.filter((h) => !isCacheMonitorHook(h));
+    if (hooks.length === m.hooks.length) { kept.push(m); continue; }
+    if (hooks.length) kept.push({ ...m, hooks });
+  }
+  return kept;
+}
+
+function countCacheMonitorHooks(groups) {
+  let n = 0;
+  for (const m of groups) for (const h of (Array.isArray(m?.hooks) ? m.hooks : [])) if (isCacheMonitorHook(h)) n += 1;
+  return n;
+}
+
 export async function installHook({ threshold = 0.7 } = {}) {
   let settings;
   try {
@@ -36,13 +61,17 @@ export async function installHook({ threshold = 0.7 } = {}) {
   }
 
   if (!settings.hooks) settings.hooks = {};
-  if (!Array.isArray(settings.hooks.PostToolUse)) settings.hooks.PostToolUse = [];
+  if (settings.hooks.PostToolUse !== undefined && !Array.isArray(settings.hooks.PostToolUse)) {
+    // Someone else's data in a shape we do not understand; overwriting it with
+    // [] would discard it. Leave the file alone and say so.
+    console.log(`⚠ hooks.PostToolUse in ${SETTINGS_PATH} is not an array — hook not installed.`);
+    return;
+  }
+  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = [];
 
-  // Remove existing cache-monitor hook if present — matches both the current
-  // subcommand form and the legacy copied-file form.
-  settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
-    (h) => !(h.hooks || []).some(isCacheMonitorHook),
-  );
+  // Remove an existing cache-monitor hook — matches both the current subcommand
+  // form and the legacy copied-file form.
+  settings.hooks.PostToolUse = withoutCacheMonitorHooks(settings.hooks.PostToolUse);
 
   settings.hooks.PostToolUse.push({
     matcher: 'Bash|Edit|Write',
@@ -76,12 +105,10 @@ export async function uninstallHook() {
     return;
   }
 
-  if (settings.hooks?.PostToolUse) {
-    const before = settings.hooks.PostToolUse.length;
-    settings.hooks.PostToolUse = settings.hooks.PostToolUse.filter(
-      (h) => !(h.hooks || []).some(isCacheMonitorHook),
-    );
-    const removed = before - settings.hooks.PostToolUse.length;
+  if (Array.isArray(settings.hooks?.PostToolUse)) {
+    const before = countCacheMonitorHooks(settings.hooks.PostToolUse);
+    settings.hooks.PostToolUse = withoutCacheMonitorHooks(settings.hooks.PostToolUse);
+    const removed = before;
 
     if (settings.hooks.PostToolUse.length === 0) delete settings.hooks.PostToolUse;
     if (Object.keys(settings.hooks).length === 0) delete settings.hooks;

package/src/hook.cjs

@@ -100,6 +100,9 @@ try {
 
 const lines = content.trim().split('\n');
 const requests = new Map();
+// Every parsed entry, handed to the harness analyzer below so it does not read
+// and parse the same transcript a second time per tool call.
+const entries = [];
 
 for (const line of lines) {
   let entry;
@@ -108,6 +111,7 @@ for (const line of lines) {
   } catch {
     continue;
   }
+  entries.push(entry);
 
   const msg = entry.message;
   if (!msg || !msg.usage || !msg.id) continue;
@@ -129,6 +133,22 @@ for (const line of lines) {
 
 if (requests.size === 0) process.exit(0);
 
+// The model most requests ran on, skipping the `<synthetic>` placeholder Claude
+// Code writes for local turns. Same rule as parser.js modelCounts; taking
+// reqs[0] here was the CJS twin drifting from it.
+function dominantModel(list) {
+  var counts = new Map();
+  for (var i = 0; i < list.length; i++) {
+    var m = list[i].model;
+    if (!m || m === 'unknown' || m.indexOf('<synthetic>') !== -1) continue;
+    counts.set(m, (counts.get(m) || 0) + 1);
+  }
+  var best = 'unknown';
+  var bestN = 0;
+  counts.forEach(function (n, m) { if (n > bestN) { best = m; bestN = n; } });
+  return best;
+}
+
 const reqs = Array.from(requests.values());
 const totals = reqs.reduce(
   function (a, r) {
@@ -160,11 +180,22 @@ const record = {
     ephemeral1h: totals.ephemeral1h,
     output: totals.output,
   },
-  model: reqs[0] ? reqs[0].model : 'unknown',
+  model: dominantModel(reqs),
 };
 
-// Append to stats file
+// Append to stats file. One record per tool call and nothing reads it back
+// yet, so keep it from growing without bound: past the cap, keep the tail.
+var STATS_MAX_BYTES = 5 * 1024 * 1024;
+var STATS_KEEP_LINES = 2000;
 try {
+  try {
+    if (fs.statSync(STATS_FILE).size > STATS_MAX_BYTES) {
+      var tail = fs.readFileSync(STATS_FILE, 'utf8').trim().split('\n').slice(-STATS_KEEP_LINES);
+      fs.writeFileSync(STATS_FILE, tail.join('\n') + '\n', 'utf8');
+    }
+  } catch (e) {
+    // no file yet, or unreadable — the append below creates or reports it
+  }
   fs.appendFileSync(STATS_FILE, JSON.stringify(record) + '\n', 'utf8');
 } catch (e) {
   dbg('hook:append-stats', e);
@@ -188,6 +219,7 @@ try {
   var state = harnessAnalyzer.analyzeTranscript(sessionFile, {
     sessionId: sessionId,
     cwd: cwd,
+    entries: entries,
   });
   if (state) harnessAnalyzer.writeState(state);
 } catch (e) {

package/src/parser.js

@@ -1,4 +1,4 @@
-import { createReadStream } from 'node:fs';
+import { createReadStream, openSync, readSync, closeSync, fstatSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
 import { createInterface } from 'node:readline';
 import { join, isAbsolute } from 'node:path';
@@ -141,8 +141,96 @@ export async function parseSessionFile(filePath) {
  * @param {string} filePath absolute path to the session JSONL
  * @returns {Promise<Date|null>}
  */
+// The statusline calls this every refresh for the live session, whose file
+// only grows. Streaming the whole transcript to find its last user entry made
+// a 65MB session cost a full re-read per tick, so the tail is read first in
+// bounded chunks; the full scan below is the fallback when the last user entry
+// sits further back than the cap (a long run of tool turns, or a corrupt tail).
+const TAIL_CHUNK = 64 * 1024;
+const TAIL_CAP = 4 * 1024 * 1024;
+
+/**
+ * Walk a session JSONL backwards in bounded chunks, newest line first, and
+ * return the first non-null value `visit` produces. `hint` is a cheap substring
+ * test that skips parsing lines that cannot match.
+ *
+ * `found: false` means the cap was reached before the answer or the start of
+ * the file: the caller decides whether to fall back to a full scan or give up.
+ */
+function scanTail(filePath, hint, visit) {
+  let fd = null;
+  try {
+    fd = openSync(filePath, 'r');
+    const size = fstatSync(fd).size;
+    if (size === 0) return { found: true, value: null };
+    let end = size;
+    let carry = '';
+    while (end > 0 && size - end < TAIL_CAP) {
+      const start = Math.max(0, end - TAIL_CHUNK);
+      const buf = Buffer.alloc(end - start);
+      readSync(fd, buf, 0, buf.length, start);
+      const text = buf.toString('utf8') + carry;
+      const lines = text.split('\n');
+      // The first piece may be a partial line; keep it for the next chunk
+      // unless this chunk reached the start of the file.
+      carry = start > 0 ? lines.shift() : '';
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line || !line.includes(hint)) continue;
+        try {
+          const value = visit(JSON.parse(line));
+          if (value != null) return { found: true, value };
+        } catch { /* partial or malformed line — keep walking back */ }
+      }
+      end = start;
+    }
+    // Reached the start of the file without a match: there is none.
+    if (end === 0) return { found: true, value: null };
+    return { found: false, value: null };
+  } catch {
+    return { found: false, value: null };
+  } finally {
+    if (fd !== null) try { closeSync(fd); } catch { /* already closed */ }
+  }
+}
+
+function lastUserTsFromTail(filePath) {
+  const { found, value } = scanTail(filePath, '"type":"user"', (entry) =>
+    (entry.type === 'user' && entry.timestamp) || null);
+  return { found, ts: value };
+}
+
+/**
+ * Model id of the most recent assistant turn in a session JSONL.
+ *
+ * The UserPromptSubmit payload names the session but not its model, and the
+ * statusline snapshot is a single file shared by every session on the machine —
+ * with two sessions open, the last one to tick decides what it says. The
+ * transcript is the only per-session answer, so a caller that must not confuse
+ * two concurrent sessions reads it here first.
+ *
+ * Tail-only by design: this runs inside a prompt hook, so a session whose last
+ * 4MB carries no assistant turn returns null rather than re-reading the file.
+ * `<synthetic>` is skipped for the same reason session-records.js skips it —
+ * it marks a locally generated stub, not a model that answered.
+ *
+ * @param {string} filePath absolute path to the session JSONL
+ * @returns {string|null}
+ */
+export function getSessionModel(filePath) {
+  if (!filePath) return null;
+  const { value } = scanTail(filePath, '"model"', (entry) => {
+    if (entry.type !== 'assistant') return null;
+    const model = entry.message && entry.message.model;
+    return typeof model === 'string' && model && model !== '<synthetic>' ? model : null;
+  });
+  return value;
+}
+
 export async function getLastUserMessageTime(filePath) {
   let lastUserTs = null;
+  const tail = lastUserTsFromTail(filePath);
+  if (tail.found) return tail.ts ? new Date(tail.ts) : null;
   try {
     const rl = createInterface({
       input: createReadStream(filePath, { encoding: 'utf8' }),

package/src/route-inject.js

@@ -25,14 +25,57 @@
  * A hint that fires on the wrong request costs more than one that stays quiet.
  */
 
-import { categorize, ESCALATE_RE, EDIT_RE } from './route-scan.js';
+import { categorize, ESCALATE_RE, EDIT_RE, worthDelegating } from './route-scan.js';
 import { loadModelRules, budgetCapPhrase } from './model-rules.js';
 import { agentPhrase, agentPhraseEn } from './agents.js';
 import { userLanguage } from './config.js';
+import { aliasForRole, resolveModelAlias } from './model-alias.js';
+import { isRecognizedModelId, modelRank } from './cost.js';
+import { loadRecentSnapshot } from './caps-cache.js';
+import { getSessionModel } from './parser.js';
+
+const PASTE_MIN_LINES = 8;
+const LOG_SHAPE_RE = /^\s+at\s|\b(error|exception|traceback|warn(ing)?|fatal)\b|^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/im;
+export function looksPasted(text) {
+  const lines = (String(text).match(/\n/g) || []).length;
+  return lines >= PASTE_MIN_LINES || LOG_SHAPE_RE.test(text);
+}
 
 /** Shortest text worth classifying; below this a prompt is an ack, not a task. */
 const MIN_LEN = 8;
 
+/**
+ * Price rank of whatever model is answering this session, or null when it
+ * cannot be established.
+ *
+ * Only a recognized id counts. `modelRank()` prices an unknown string as Sonnet
+ * so a cost estimate always has an answer, but here that guess would silence
+ * every T1 hint behind a gateway whose house alias (`prod-large`) names no
+ * Claude family — so an unrecognized id returns null and the hint keeps its
+ * previous behaviour instead.
+ *
+ * Sources, most trustworthy first: the session's own transcript, the gateway
+ * model environment, and finally the statusline snapshot, which is shared by
+ * every session on the machine and therefore only consulted last.
+ *
+ * @returns {number|null}
+ */
+export function sessionModelRank({ env = process.env, transcriptPath = null, snapshot } = {}) {
+  const rankOf = (raw) => {
+    if (!raw) return null;
+    if (isRecognizedModelId(raw)) return modelRank(raw);
+    // An opaque gateway id can still be priced through profile-map.json.
+    const mapped = resolveModelAlias(raw, { env });
+    return isRecognizedModelId(mapped) ? modelRank(mapped) : null;
+  };
+  const fromTranscript = rankOf(getSessionModel(transcriptPath));
+  if (fromTranscript !== null) return fromTranscript;
+  const fromEnv = rankOf(aliasForRole('main', env));
+  if (fromEnv !== null) return fromEnv;
+  const snap = snapshot === undefined ? loadRecentSnapshot() : snapshot;
+  return rankOf(snap && snap.model);
+}
+
 /**
  * @param {string} text the prompt just submitted
  * @param {object} [opts]
@@ -41,9 +84,12 @@ const MIN_LEN = 8;
  * @param {string} [opts.root] project root used to look for a subagent's .md.
  *   The hint names the agent when that file exists and only its model tier when
  *   it does not, so a caller that needs a predictable phrase pins this.
+ * @param {number|null} [opts.sessionRank] price rank of the model reading the
+ *   hint (see sessionModelRank). null means unknown, and an unknown session
+ *   model filters nothing.
  * @returns {string|null} the line to inject, or null to stay quiet
  */
-export function routeHint(text, { rules, lang = userLanguage(), root } = {}) {
+export function routeHint(text, { rules, lang = userLanguage(), root, sessionRank = null } = {}) {
   const t = String(text || '').trim();
   if (t.length < MIN_LEN) return null;
   // Judgement and irreversible work stay on the top tier. This check comes
@@ -56,13 +102,29 @@ export function routeHint(text, { rules, lang = userLanguage(), root } = {}) {
 
   const cat = categorize(t, null);
   if (!cat) return null;
+  // Length alone makes a paste offline, where the tool mix confirms it. At
+  // prompt time a long text is as often a written spec as a pasted log, and a
+  // spec is not haiku work — so it must also look pasted: many lines, or the
+  // shape of a log or stack trace. Otherwise stay quiet rather than fall
+  // through to keyword scoring, which a long request trips by accident.
+  if (cat.id === 'paste' && !looksPasted(t)) return null;
 
   const all = rules || loadModelRules().rules || [];
   const matched = all.filter((r) => r && r.category === cat.id);
   if (!matched.length) return null;
+  // A rule only saves anything when its target tier is cheaper than the model
+  // reading the hint. A T1 rule states "delegate to model: sonnet", which in a
+  // Sonnet session instructs a delegation worth nothing — and contradicts the
+  // registry's own clause that a session already at the target tier does not
+  // delegate. So drop the tiers this session cannot profit from; if that leaves
+  // nothing (a haiku session), stay quiet.
+  const usable = sessionRank === null
+    ? matched
+    : matched.filter((r) => worthDelegating(r.tier, sessionRank));
+  if (!usable.length) return null;
 
-  const t2 = matched.find((r) => r.tier === 'T2');
-  const t1 = matched.find((r) => r.tier === 'T1');
+  const t2 = usable.find((r) => r.tier === 'T2');
+  const t1 = usable.find((r) => r.tier === 'T1');
   const ko = lang === 'ko';
   const label = ko ? (cat.label || cat.id) : (cat.labelEn || cat.label || cat.id);
   // `root` is threaded through to agentPhrase, which names the subagent only

package/src/route-scan.js

@@ -53,8 +53,8 @@ export const MIN_DELEGABLE_OUT = 100;
 // delegating them defeats the harness's default-safe-path rule.
 // Measured 2026-09-20 on 1,276 local prompts: '퍼블리시' (npm publish, 15 hits)
 // and '이유' (root-cause asks) were slipping through as run/translate, and a
-// bare '머지' matched inside '나머지' ("나머지 진행하자" ×7) — hence the lookbehind.
-export const ESCALATE_RE = /설계|아키텍처|리팩토링|원인 분석|개선할|검토해보|비교|왜 |이유|제출|배포|출시|퍼블리시|릴리스|릴리즈|(?<!나)머지|analyze|compare|evaluate|architect|refactor|submit|deploy|release|publish|merge/i;
+// bare '머지' matched inside '나머지' ("나머지 진행하자" ×7), hence the lookbehind.
+export const ESCALATE_RE = /설계|아키텍처|리팩토링|원인 분석|개선할|검토해보|비교|왜(?=[\s?]|$)|이유|제출|배포|출시|퍼블리시|릴리[스즈](?!\s*노트)|(?<!나)머지|analyze|compare|evaluate|architect|refactor|submit|deploy|release|publish|merge/i;
 
 // Implementation asks phrased around a run/check verb ("설치와 동시에 설정되도록
 // 하자", "피드백 확인해주고 아이콘도 만들자"). Editing is not delegable, and at
@@ -62,7 +62,9 @@ export const ESCALATE_RE = /설계|아키텍처|리팩토링|원인 분석|개
 // classification does not use this: a write-dominant tool mix already excludes
 // such episodes in behaviorPool(). Same corpus: 21 of 1,276 prompts gated, all
 // but two of them implementation requests that had been read as run/check.
-export const EDIT_RE = /구현|추가하자|만들자|넣자|넣어줘|수정해|고쳐|바꿔|되도록|되게|리팩/;
+// `되게` alone is also the colloquial intensifier ("되게 느린데") and `되도록`
+// the adverb ("되도록 빨리"); only the causative shape means "make it so".
+export const EDIT_RE = /구현|추가하자|만들자|넣자|넣어줘|수정해|고쳐|바꿔|(?:되도록|되게)\s*(?:하|해|만들)|리팩/;
 // A pattern must recur this often before we nag about it.
 export const MIN_RECURRENCE = 3;
 
@@ -185,7 +187,11 @@ function keywordScore(cat, text) {
 
 // Episodes that are not user-delegable requests: bare continuations, injected
 // notifications, image pastes. These are easy but there is nothing to route.
-const SKIP_RE = /^(계속|이어서|continue|다음|proceed|진행|응|네|넵|ok|okay|yes|ㄱ+|고고)\b/i;
+// `\b` is ASCII-only in JS, so after a Hangul syllable it never matches and
+// every Korean ack in this list was silently ignored (measured 2026-09-21:
+// "계속 진행", "응 다 정리해도돼" both entered tiering as episodes). The
+// lookahead does what `\b` was meant to: the ack ends the word.
+const SKIP_RE = /^(계속|이어서|continue|다음|proceed|진행|응|네|넵|ok|okay|yes|ㄱ+|고고)(?=\s|$|[.!?,~])/i;
 const SKIP_PREFIX = ['<task-notification', '<system', '[Image:', '<local-command'];
 
 // Single source of truth for the state dir (paths.js). A local copy used to
@@ -226,7 +232,7 @@ export function categorize(text, toolCounts) {
   return null;
 }
 
-function isSkippable(text) {
+export function isSkippable(text) {
   if (!text) return true;
   if (SKIP_RE.test(text.trim())) return true;
   return SKIP_PREFIX.some((p) => text.startsWith(p));
@@ -384,6 +390,20 @@ export function tierOf(ep, category, th) {
  * Scan transcripts and build delegation candidates.
  * Returns the cache object (also written to disk).
  */
+/**
+ * Whether a rule was already registered when a subagent run started. The
+ * ledger credits a rule with every matching run in the scan window, and a rule
+ * promoted today would otherwise claim two weeks of runs that happened before
+ * it existed — and keep claiming them, since the ledger is keyed by run path.
+ * A rule with no promotion date (older registries) is trusted as before.
+ */
+export function ruleCouldHaveRouted(rule, run) {
+  if (!rule?.promotedAt || !Number.isFinite(run?.startedAt)) return true;
+  const promoted = Date.parse(rule.promotedAt);
+  if (!Number.isFinite(promoted)) return true;
+  return run.startedAt >= promoted;
+}
+
 export async function runRouteScan({ days = 14 } = {}) {
   const files = await discoverSessionFiles({ days });
 
@@ -502,8 +522,13 @@ export async function runRouteScan({ days = 14 } = {}) {
     g.count += 1;
     for (const m of ep.models) g.models.add(m);
     if (!g.projectPath && ep.cwd) g.projectPath = ep.cwd;
-    if (!g.example || (ep.text.length < g.example.length && ep.text.length > 10)) {
+    // Shortest text longer than 10 chars wins; a 3-char first episode used to
+    // be accepted unconditionally and then never replaced.
+    const usable = ep.text.length > 10;
+    if ((!g.example && (usable || !g.exampleUsable))
+      || (usable && (!g.exampleUsable || ep.text.length < g.example.length))) {
       g.example = ep.text.slice(0, 80).replace(/\s+/g, ' ');
+      g.exampleUsable = usable;
     }
     groups.set(key, g);
   }
@@ -600,6 +625,7 @@ export async function runRouteScan({ days = 14 } = {}) {
         // not against whatever the session's priciest model happened to be.
         const rule = ruleForRun(runTier, cat.id, projectDir);
         if (!rule) continue; // no rule routed this run — not our saving to claim
+        if (!ruleCouldHaveRouted(rule, run)) continue; // it did not exist yet
         // Priced below, after this scan's baselines have been written back to
         // the registry — see the note at the ledger write.
         if (!isRecognizedModelId(run.model)) continue;
@@ -808,9 +834,9 @@ export async function shouldRescan(cache, { days = 14, afterDelegation = false }
  */
 export function tierLabel(tier, lang = 'ko') {
   const ko = {
-    T2: '단순 작업 — haiku급이면 충분',
-    T1: '중간 난도 — sonnet급이면 충분',
-    T0: '고난도 — 지금 모델 유지',
+    T2: '단순 작업, haiku급이면 충분',
+    T1: '중간 난도, sonnet급이면 충분',
+    T0: '고난도, 지금 모델 유지',
   };
   const en = {
     T2: 'simple — haiku-class is enough',

package/src/statusline-mode.js

@@ -52,6 +52,12 @@ export function iconForceRequested({ cfg = {}, env = process.env } = {}) {
  * `icon` instead, so that is read as a fallback: absent means icons, since icons
  * are the default for a fresh install.
  */
+/** Whether the config carries an explicit label choice (new or legacy key). */
+export function hasStoredPreference(cfg = {}) {
+  if (cfg.labels === 'icon' || cfg.labels === 'narrow' || cfg.labels === 'text') return true;
+  return typeof cfg.icon === 'boolean';
+}
+
 export function labelPreference(cfg = {}) {
   if (cfg.labels === 'icon' || cfg.labels === 'narrow' || cfg.labels === 'text') return cfg.labels;
   return cfg.icon === false ? 'text' : 'icon';
@@ -71,7 +77,8 @@ export function labelPreference(cfg = {}) {
  *   `flag:--icon`, `config`.
  *
  * Precedence: explicit opt-out, then the IntelliJ guard (and the escape hatch
- * out of it, which applies only there), then `--icon`, then persisted config.
+ * out of it, which applies only there), then persisted config, then `--icon`
+ * (the installed command's default when nothing is stored).
  */
 export function resolveLabelMode({ hasFlag = () => false, cfg = {}, env = process.env } = {}) {
   // An explicit opt-out wins everywhere. Nothing below should talk a user out
@@ -90,6 +97,10 @@ export function resolveLabelMode({ hasFlag = () => false, cfg = {}, env = proces
     // is a character the IDE font actually has, so the line does not garble.
     return { mode: 'narrow', reason: 'intellij-narrow' };
   }
-  if (hasFlag('--icon')) return { mode: 'icon', reason: 'flag:--icon' };
+  // The installed statusline command carries `--icon`, so the flag is present
+  // on every refresh. If it beat the config, `sprag mode text` and `narrow`
+  // could never take effect there — the mode command promises they apply on
+  // the next refresh. So the flag decides only when nothing is stored.
+  if (hasFlag('--icon') && !hasStoredPreference(cfg)) return { mode: 'icon', reason: 'flag:--icon' };
   return { mode: pref, reason: 'config' };
 }

package/src/update-check.js

@@ -27,7 +27,7 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { spawn } from 'node:child_process';
-import { join, dirname } from 'node:path';
+import { join, dirname, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { userDataDir } from './paths.js';
 import { debug } from './debug.js';
@@ -375,7 +375,9 @@ export function dismissUpdate(version) {
  * overwhelming majority of copies got here.
  */
 export function upgradeCommand() {
-  const here = dirname(fileURLToPath(import.meta.url));
+  // Forward slashes on every platform, so the manager checks below hold on
+  // Windows too instead of reporting every install as npm.
+  const here = dirname(fileURLToPath(import.meta.url)).split(sep).join('/');
   // A legacy copy upgrades by moving to the canonical name. Installing the new
   // name alone would leave two copies fighting over the same `sprag` binary,
   // so the old one comes off first.

package/src/window-labels.js

@@ -39,7 +39,8 @@ const KNOWN = {
 };
 
 function deriveShort(key) {
-  // "five_hour" → "5H"; "seven_day_sonnet" → "7DS"; arbitrary key → uppercase initials
+  // "5_hour" → "5H"; "7_day_sonnet" → "7DS"; a key with no leading digit
+  // ("five_hour") falls through to uppercase initials ("FH")
   const m = key.match(/^(\d+)_?([a-z]+)/);
   if (m) {
     const num = m[1];