sprag-cli 3.51.0 → 3.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sprag-cli",
-  "version": "3.51.0",
+  "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/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/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/parser.js

@@ -149,12 +149,20 @@ export async function parseSessionFile(filePath) {
 const TAIL_CHUNK = 64 * 1024;
 const TAIL_CAP = 4 * 1024 * 1024;
 
-function lastUserTsFromTail(filePath) {
+/**
+ * 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, ts: null };
+    if (size === 0) return { found: true, value: null };
     let end = size;
     let carry = '';
     while (end > 0 && size - end < TAIL_CAP) {
@@ -168,24 +176,57 @@ function lastUserTsFromTail(filePath) {
       carry = start > 0 ? lines.shift() : '';
       for (let i = lines.length - 1; i >= 0; i--) {
         const line = lines[i];
-        if (!line || !line.includes('"type":"user"')) continue;
+        if (!line || !line.includes(hint)) continue;
         try {
-          const entry = JSON.parse(line);
-          if (entry.type === 'user' && entry.timestamp) return { found: true, ts: entry.timestamp };
+          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 user entry: there is none.
-    if (end === 0) return { found: true, ts: null };
-    return { found: false, ts: null };
+    // 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, ts: null };
+    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);

package/src/route-inject.js

@@ -25,10 +25,14 @@
  * 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;
@@ -40,6 +44,38 @@ export function looksPasted(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]
@@ -48,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
@@ -73,9 +112,19 @@ export function routeHint(text, { rules, lang = userLanguage(), root } = {}) {
   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