claude-token-saver 3.21.1 → 3.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-token-saver",
-  "version": "3.21.1",
+  "version": "3.22.1",
   "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

@@ -22,7 +22,9 @@ import { join } from 'node:path';
 import { userDataDir } from './paths.js';
 import { discoverSessionFiles } from './parser.js';
 import { collectSessionRecords } from './session-records.js';
-import { collectSubagentRuns, indexRuns, runsForEpisode } from './subagent-records.js';
+import {
+  collectSubagentRuns, indexRuns, exactRunsForEpisode, fallbackRunsForEpisode,
+} from './subagent-records.js';
 import { estimateCost, modelRank, isRecognizedModelId, TIER_TARGET_RANK, tierForRank } from './cost.js';
 import { learnProfileMapping, resetModelAliasCache } from './model-alias.js';
 import { agentPhrase, agentPhraseEn } from './agents.js';
@@ -280,6 +282,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 +494,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);
@@ -520,10 +536,18 @@ export async function runRouteScan({ days = 14 } = {}) {
     (r.scope === 'global' || r.project === projectDir));
   for (const [sessionPath, index] of runIndexBySession) {
     const used = new Set();
-    for (const { ep, projectDir, sessionPath: epSession } of all) {
-      if (epSession !== sessionPath) continue;
-      if (!ep.delegationToolUseIds.length && index.unjoined.length === 0) continue;
-      const runs = runsForEpisode(index, ep, used);
+    const eps = all.filter((x) => x.sessionPath === sessionPath);
+    // Two passes over the session, not one per episode: every exact tool_use
+    // join is settled first, so the timestamp fallback can only ever claim a
+    // run that no episode was able to prove was its own.
+    const runsByEp = new Map();
+    for (const item of eps) runsByEp.set(item, exactRunsForEpisode(index, item.ep, used));
+    for (const item of eps) {
+      runsByEp.get(item).push(...fallbackRunsForEpisode(index, item.ep, used));
+    }
+    for (const item of eps) {
+      const { ep, projectDir } = item;
+      const runs = runsByEp.get(item);
       if (runs.length === 0) continue;
       const cat = categorize(ep.text, ep.tools);
       if (!cat) continue;
@@ -537,6 +561,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 +673,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 } = {}) {

package/src/subagent-records.js

@@ -150,6 +150,10 @@ export async function collectSubagentRuns(sessionPath) {
  * with the un-joinable ones kept aside for the timestamp fallback (a run
  * whose .meta.json is missing or predates toolUseId still happened, and
  * dropping it would silently under-count a rule's real error rate).
+ *
+ * `unjoined` is kept for callers that want only the no-id runs; the fallback
+ * itself works off `all` minus whatever the exact pass claimed, because a run
+ * CAN carry an id that no parent episode holds (see fallbackRunsForEpisode).
  */
 export function indexRuns(runs) {
   const byToolUse = new Map();
@@ -168,13 +172,38 @@ export function indexRuns(runs) {
  * (an episode's span can overlap a neighbouring episode's runs).
  */
 export function runsForEpisode(index, ep, used) {
+  return [...exactRunsForEpisode(index, ep, used), ...fallbackRunsForEpisode(index, ep, used)];
+}
+
+/** Runs this episode's own Task calls spawned. No guessing. */
+export function exactRunsForEpisode(index, ep, used) {
   const out = [];
   for (const id of ep.delegationToolUseIds || []) {
     const r = index.byToolUse.get(id);
     if (r && !used.has(r.path)) { used.add(r.path); out.push(r); }
   }
+  return out;
+}
+
+/**
+ * Runs that no episode's tool_use ids claimed, matched by start time falling
+ * inside this episode's span.
+ *
+ * The pool is every unclaimed run, not just the ones without a toolUseId. A
+ * nested delegation — a subagent spawning its own subagent — records the
+ * SIBLING's tool_use id, which appears in no parent transcript and therefore
+ * matches nothing. Gating the fallback on "has no toolUseId" made having one
+ * disqualify the run from the only path that could still attribute it, so
+ * every spawnDepth >= 2 run was dropped forever (measured: 3 of 3 over 14
+ * days, ~$3.42 of savings and three runs of rule-health evidence).
+ *
+ * Run session-wide AFTER every episode's exact join, so a timestamp guess
+ * cannot take a run that another episode can prove is its own.
+ */
+export function fallbackRunsForEpisode(index, ep, used) {
+  const out = [];
   if (ep.startedAt === null || ep.endedAt === null) return out;
-  for (const r of index.unjoined) {
+  for (const r of index.all) {
     if (used.has(r.path) || r.startedAt === null) continue;
     if (r.startedAt >= ep.startedAt && r.startedAt <= ep.endedAt) {
       used.add(r.path);