claude-token-saver 3.21.1 → 3.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-token-saver",
-  "version": "3.21.1",
+  "version": "3.22.0",
   "description": "Route the easy work your expensive Claude model keeps repeating down to haiku/sonnet — post-hoc session analysis, no realtime router, no extra LLM calls.",
   "type": "module",
   "bin": {

package/src/commands/route-scan.js

@@ -107,6 +107,18 @@ export async function run({ args, hasFlag, numArg }) {
         // what the model reads.
         console.log(`      ${mr.composeRuleText(r.rule, r, lang)}`);
       });
+      // Runs on a model id we cannot price never reach the aggregate, so a
+      // rule whose tier runs entirely on such an id reads as "never fired".
+      // Say so here rather than leaving the zero unexplained.
+      const scan = rs.readRouteScan();
+      if (scan?.unresolvedRuns > 0) {
+        const ids = (scan.unresolvedModels || []).join(', ');
+        console.log(lang === 'ko'
+          ? `\n⚠ 해석되지 않은 모델 ID 때문에 위임 ${scan.unresolvedRuns}건이 집계에서 제외됐습니다${ids ? ` (${ids})` : ''}.`
+            + '\n  profile-map.json 의 modelAliases 에 해당 ID 를 매핑한 뒤 route-scan --refresh 를 실행하십시오.'
+          : `\n⚠ ${scan.unresolvedRuns} delegated run(s) were excluded — unpriceable model id${ids ? ` (${ids})` : ''}.`
+            + '\n  Map it under modelAliases in profile-map.json, then run route-scan --refresh.');
+      }
       console.log(lang === 'ko'
         ? '\n제거: claude-token-saver route-scan rules rm <N>'
         : '\nRemove with: claude-token-saver route-scan rules rm <N>');

package/src/korean-style.js

@@ -123,7 +123,9 @@ export function koreanStyleInjection({ cfg = loadConfig() } = {}) {
   if (!text) return null;
   return [
     '[claude-token-saver korean-style] 이 세션에서 한국어를 출력할 때는 아래 지침을 따르십시오.',
-    '이 지침은 사용자가 claude-token-saver에 설정한 것이며, 답변·문서·주석이 아닌 산문 전반에 적용됩니다.',
+    '이 지침은 사용자가 claude-token-saver에 설정한 것입니다.',
+    '적용 대상: 대화 답변, 그리고 새로 작성하거나 수정하는 마크다운·문서·보고서의 한국어 산문을 모두 포함합니다.',
+    '적용 예외: 원문을 그대로 옮기는 인용, 코드, 코드 주석, 그리고 프로젝트의 기존 표기 관례를 따라야 하는 커밋 메시지와 로그 문자열입니다.',
     `(출처: ${KOREAN_STYLE_SOURCE})`,
     '',
     text,

package/src/model-alias.js

@@ -357,9 +357,13 @@ function topRole(tally) {
  * against 1,702 times as a subagent, and those 16 inferred 'main' votes beat
  * the single explicit 'haiku' one at exactly the 80% line.
  *
- * When neither bucket is decisive the id stays unresolved. An 'unknown' that
- * drops out of the aggregate beats a confident wrong answer that silently
- * re-tiers every run on that profile.
+ * When a thin explicit bucket vetoes a decisive inference, the explicit role
+ * is adopted ('explicit-veto'): a stated `Task(model: ...)` is the stronger
+ * evidence, and it is the only evidence left once the inference is rejected.
+ *
+ * When neither bucket says anything usable the id stays unresolved. An
+ * 'unknown' that drops out of the aggregate beats a confident wrong answer
+ * that silently re-tiers every run on that profile.
  */
 export function tallyVotes(votes, { minVotes = MIN_VOTES, minAgreement = MIN_AGREEMENT } = {}) {
   const learned = {};
@@ -385,6 +389,16 @@ export function tallyVotes(votes, { minVotes = MIN_VOTES, minAgreement = MIN_AGR
       // flag, so probably the session model" observations.
       role = inferred.role;
       source = 'inferred';
+    } else if (explicit.total > 0
+      && explicit.top / explicit.total >= minAgreement
+      && inferred.role
+      && !rolesAgree(explicit.role, inferred.role)) {
+      // The veto above is only coherent if we then believe what did the
+      // vetoing. Leaving the id unresolved instead drops every delegated run
+      // on that profile out of the aggregate, which is how a haiku profile
+      // that doubles as somebody's session model reported zero delegations.
+      role = explicit.role;
+      source = 'explicit-veto';
     }
 
     learned[pid] = {

package/src/route-scan.js

@@ -280,6 +280,18 @@ export function dominantModel(counts) {
   return best;
 }
 
+// A delegated run counts as failed on error DENSITY, not on the presence of a
+// single is_error. Binary counting scored a 218-call run that finished its task
+// identically to one that died on its first call. The floor keeps very short
+// runs honest: 1 error in 3 calls is still a failure.
+export const DELEGATED_ERR_DENSITY = 0.1;
+
+export function isFailedRun(run) {
+  if (!run || !(run.toolErrors > 0)) return false;
+  const calls = run.calls > 0 ? run.calls : 1;
+  return run.toolErrors / calls > DELEGATED_ERR_DENSITY;
+}
+
 export function worthDelegating(tier, rank) {
   const target = TIER_TARGET_RANK[tier];
   return target !== undefined && rank > target;
@@ -480,10 +492,12 @@ export async function runRouteScan({ days = 14 } = {}) {
   // T2 rule firing, a sonnet run a T1 one. Runs that were not a downgrade
   // (same tier or higher) carry no delegation saving and are skipped.
   const delegatedStats = new Map(); // "tier|category|project" → outcome aggregate
+  let unresolvedRuns = 0;           // delegated runs dropped for an unpriceable model id
+  const unresolvedModels = new Set();
   const bumpDelegated = (key, run, saved) => {
     const d = delegatedStats.get(key) || { runs: 0, errRuns: 0, outTokens: 0, savedUsd: 0 };
     d.runs += 1;
-    if (run.toolErrors > 0) d.errRuns += 1;
+    if (isFailedRun(run)) d.errRuns += 1;
     d.outTokens += run.out || 0;
     d.savedUsd += saved;
     delegatedStats.set(key, d);
@@ -537,6 +551,14 @@ export async function runRouteScan({ days = 14 } = {}) {
       }
       for (const run of runs) {
         const runTier = tierForRank(modelRank(run.model));
+        // Dropping unresolved model ids is deliberate (see cost.js) — pricing
+        // a gateway id as Sonnet would poison every number here. But dropping
+        // them SILENTLY is what made a whole tier of rules report zero
+        // delegations with no way to tell why, so keep a count to surface.
+        if (!isRecognizedModelId(run.model)) {
+          unresolvedRuns += 1;
+          if (run.model) unresolvedModels.add(run.model);
+        }
         if (!runTier || !worthDelegating(runTier, mainRank)) continue;
         const saved = runSaving(run, mainModel);
         bumpDelegated(`${runTier}|${cat.id}|${projectDir}`, run, saved);
@@ -641,6 +663,8 @@ export async function runRouteScan({ days = 14 } = {}) {
     thresholds,
     candidates,
     resolved: [...resolved],
+    unresolvedRuns,
+    unresolvedModels: [...unresolvedModels].slice(0, 5),
   };
   try {
     const dir = stateDir();

package/src/session-records.js

@@ -55,6 +55,14 @@ const REJECTION_RE = /doesn't want to proceed|tool use was rejected|doesn't want
 // does not exist" on a Read) stay counted — those are genuine difficulty signal.
 const SELF_CORRECTED_RE = /File has not been read yet|has been modified since read|String to replace not found|is not running \(status:|<tool_use_error>Blocked:/i;
 
+// Environment constraints — a sandbox without `curl`/`wc`, a corporate proxy
+// timing a fetch out — are not task difficulty either. The agent routinely
+// routes around them and finishes: one 218-turn run that produced a 9,870-char
+// sourced report was scored a failure on two `command not found` results.
+// NARROW on purpose: only the shell's own "this binary is absent" wording and
+// curl's transport-timeout exit, never a generic non-zero exit.
+const ENVIRONMENT_RE = /command not found|curl: \(28\)|Operation timed out after|ETIMEDOUT|ENOTFOUND|getaddrinfo/i;
+
 function toolResultText(content) {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';
@@ -64,7 +72,7 @@ function toolResultText(content) {
 function isRealToolError(block) {
   if (!block || block.type !== 'tool_result' || !block.is_error) return false;
   const txt = toolResultText(block.content);
-  return !REJECTION_RE.test(txt) && !SELF_CORRECTED_RE.test(txt);
+  return !REJECTION_RE.test(txt) && !SELF_CORRECTED_RE.test(txt) && !ENVIRONMENT_RE.test(txt);
 }
 
 export async function collectSessionRecords(filePath, { includeContent = true } = {}) {