claude-token-saver 3.9.2 → 3.11.0

package/README.en.md

@@ -77,6 +77,7 @@ The statusline appears at the bottom of Claude Code right away. If auto-registra
 | `✦ current` / `📅 weekly` | 5-hour / 7-day rate-limit window usage + reset time |
 | `📦` | Context usage (e.g. `Ctx 68% of 1M`) — colored by fill. Current models default to 1M with no premium, but token volume itself drives per-turn cost and 5H/7D burn |
 | `💰` | Cumulative savings from prompt caching |
+| `🔀` | Cumulative savings from delegation — what running work on a cheaper tier saved, a different number from `💰`. Hidden until a delegation has actually been measured |
 
 When something is wrong, a **warning chip leads the line**:
 
@@ -202,6 +203,24 @@ claude-token-saver route-scan rules              # list model-fitting rules (rm
 
 Dig deeper: **tier criteria & research evidence** → [docs/TIER_CRITERIA.md](./docs/TIER_CRITERIA.md) (Korean) · **rule-file mechanics, scan triggers, subagent setup** → [docs/ROUTE_SCAN.md](./docs/ROUTE_SCAN.md) (Korean + English)
 
+### Behind a gateway (Bedrock / LiteLLM)
+
+Through a corporate gateway the transcript records an inference-profile ARN where the model id belongs. That string says nothing about `opus` or `haiku`, so older versions read every session as Sonnet — which made **T1 (→sonnet) rules unreachable and zeroed the savings figures**.
+
+Since v3.10.0 the profile id is mapped back to a role (main, opus, sonnet, haiku) and then to the alias your `ANTHROPIC_DEFAULT_*_MODEL` variables declare. The mapping is learned by joining each parent `Task` call to the subagent run it spawned via `toolUseId`. Below three observations, or when the role votes agree less than 80% of the time, the id stays `unknown` and drops out of the delegation aggregate rather than being guessed at.
+
+For environments the learner cannot reach, write the mapping yourself in `<userDataDir>/profile-map.json`. Account id and region may be wildcarded:
+
+```jsonc
+{
+  "modelAliases": {
+    "arn:aws:bedrock:*:*:application-inference-profile/<PROFILE_ID>": "claude-opus-5"
+  }
+}
+```
+
+That file holds internal identifiers in plain text — do not commit it. On a direct-API machine it is never created and behaviour is unchanged.
+
 ## Spike issue codes
 
 | Code | Meaning |
@@ -282,6 +301,16 @@ Also update `statusLine.command` in `~/.claude/settings.json` to `claude-token-s
 
 ## Release notes
 
+### v3.11.0 (2026-08-21)
+- **Delegation savings chip in the statusline** — `🔀 Delegated $3.2`. The existing `💰 Cache saved` covers the prompt cache; this one is what running work on a cheaper tier saved. Zero or missing data hides the chip entirely, so nothing changes for direct-API users. The statusline only reads `model-rules.json` — it never triggers a scan (it re-renders every few seconds). Segment name: `delegated`.
+- **Role-learning mis-classification fixed** — subagent records sometimes land in the parent transcript without an `isSidechain` flag, and that circumstantial evidence could outvote stated evidence, confirming a haiku profile as the session model (measured: 16 against 1, agreement exactly at the 80% line). Stated evidence (`Task(model:)` parameters, agent-definition frontmatter) and inferred evidence are now tallied separately, and an inference is not adopted when stated evidence contradicts it. Undecided ids stay `unknown` and leave the aggregate.
+
+### v3.10.0 (2026-08-20)
+- **Model tiers are detected again behind a Bedrock / LiteLLM gateway** — when the transcript's model id is an inference-profile ARN there is no `opus` or `haiku` in the string, so it fell back to Sonnet. Since `worthDelegating()` requires `rank > target`, **every T1 rule was rejected**, savings aggregated to zero, and cost was under-counted by roughly 1.67x. The profile id is now learned as a role (parent `Task` call joined to the subagent run by `toolUseId`) and mapped back to the alias your environment declares. The pricing table, the ranks, and the tiering logic are untouched.
+- **No confident mapping means no guess** — under three observations, or below 80% agreement, the id stays `unknown` and leaves the delegation aggregate. Quietly calling it Sonnet was the worse failure.
+- **Manual override** — `modelAliases` in `<userDataDir>/profile-map.json`, wildcards allowed. No profile id or AWS account id is ever hardcoded in this package.
+- Direct-API machines behave **exactly as before** and no new file is written.
+
 ### v3.9.2 (2026-08-01)
 - **Added a LICENSE file (MIT)** — the field existed in `package.json` but the file did not, which blocked license review for company adoption. It ships in the npm tarball now via `files`.
 - **Package description and keywords rewritten for what this actually does** — leftover cache-monitoring copy meant it never surfaced for `model-routing` / `delegation` / `subagent`.

package/README.md

@@ -76,6 +76,7 @@ npm i -g claude-token-saver
 | `✦ current` / `📅 weekly` | 5시간 / 7일 rate-limit 윈도 사용률 + 리셋 시각 |
 | `📦` | 컨텍스트 사용률 (예: `Ctx 68% of 1M`) — 사용률 기준 녹/황/적. 현재 모델은 1M이 기본·프리미엄 없음이지만, 토큰량 자체가 턴당 비용과 5H/7D 한도를 태웁니다 |
 | `💰` | 캐시가 절약해준 누적 금액 |
+| `🔀` | 위임이 절약해준 누적 금액 — 더 싼 티어로 내려서 아낀 몫이며 `💰`와는 다른 수치입니다. 실측 위임이 없으면 표시되지 않습니다 |
 
 문제가 감지되면 **경고 칩이 맨 앞에** 붙습니다:
 
@@ -182,6 +183,24 @@ claude-token-saver route-scan rules              # 등록된 모델 피팅 룰
 
 더 알아보기: **티어 기준·리서치 근거** → [docs/TIER_CRITERIA.md](./docs/TIER_CRITERIA.md) · **룰 파일 구조·스캔 트리거·서브에이전트 준비** → [docs/ROUTE_SCAN.md](./docs/ROUTE_SCAN.md)
 
+### 게이트웨이(Bedrock·LiteLLM) 경유 환경
+
+사내 게이트웨이를 거치면 로그의 모델명 자리에 추론 프로파일 ARN이 기록됩니다. 그 문자열에는 `opus`·`haiku` 같은 단서가 없어서 예전 버전은 이것을 전부 Sonnet으로 읽었고, 그 결과 **T1(→sonnet) 위임 룰이 하나도 제안되지 않았으며 절감 집계가 0**이었습니다.
+
+v3.10.0부터는 프로파일 ID를 역할(main·opus·sonnet·haiku)로 되돌린 뒤 `ANTHROPIC_DEFAULT_*_MODEL` 환경변수가 선언한 별칭으로 치환합니다. 매핑은 부모 세션의 `Task` 호출과 서브에이전트 기록을 `toolUseId`로 조인해 스스로 학습하며, 관측이 3건 미만이거나 역할 판정이 80% 미만으로 갈리면 **추측하지 않고 `unknown`으로 두고 위임 집계에서 제외**합니다.
+
+자동 학습이 닿지 않는 환경을 위한 수동 경로도 있습니다. `<userDataDir>/profile-map.json`에 아래처럼 적으면 되고, 계정 ID와 리전은 `*`로 가려도 매칭됩니다.
+
+```jsonc
+{
+  "modelAliases": {
+    "arn:aws:bedrock:*:*:application-inference-profile/<PROFILE_ID>": "claude-opus-5"
+  }
+}
+```
+
+이 파일에는 사내 식별자가 평문으로 남으므로 저장소에 커밋하지 마십시오. 게이트웨이를 쓰지 않는 환경에서는 파일이 아예 만들어지지 않고 기존 동작이 그대로 유지됩니다.
+
 ## 토큰 급증 원인 코드
 
 | 코드 | 의미 |
@@ -238,6 +257,16 @@ npm uninstall -g claude-cache-monitor && npm i -g claude-token-saver
 
 ## 릴리스 노트
 
+### v3.11.0 (2026-08-21)
+- **statusline에 위임 절감 칩 추가** — `🔀 Delegated $3.2`. 기존 `💰 Cache saved`는 프롬프트 캐시 절감이고, 새 칩은 **더 싼 티어로 내려서 아낀 금액**입니다. 값이 0이거나 데이터가 없으면 칩을 아예 그리지 않아 직접 API 사용자에게는 아무것도 늘지 않습니다. statusline은 `model-rules.json`을 읽기만 하며 스캔을 돌리지 않습니다(5초마다 호출되는 자리입니다). 세그먼트 이름은 `delegated`입니다.
+- **역할 학습의 오분류 수정** — 서브에이전트 레코드가 부모 트랜스크립트에 `isSidechain` 없이 섞여 들어오는 경우가 있어, 그 정황 증거가 명시 증거를 이겨 haiku 프로파일이 세션 모델로 확정되곤 했습니다(실측 16건 대 1건, 합의율 정확히 80%). 이제 **명시 증거(`Task(model:)` 파라미터·에이전트 정의 frontmatter)와 정황 증거(sidechain 플래그 부재)를 분리해 집계**하고, 명시 증거가 이를 반박하면 정황 추론을 채택하지 않습니다. 확정이 안 되면 `unknown`으로 남아 집계에서 빠집니다.
+
+### v3.10.0 (2026-08-20)
+- **게이트웨이(Bedrock·LiteLLM) 환경에서 모델 티어를 다시 인식합니다** — 로그의 모델명이 추론 프로파일 ARN이면 `opus`·`haiku` 단서가 없어 Sonnet으로 폴백했고, `worthDelegating()`이 `rank > target`을 요구하므로 **T1 위임이 전부 기각**됐습니다. 절감 집계는 0, 비용은 약 1.67배 과소 계상이었습니다. 이제 프로파일 ID를 역할로 학습해(부모 `Task` 호출 ↔ 서브에이전트 `toolUseId` 정확 조인) 환경변수가 선언한 별칭으로 되돌립니다. 가격표·랭크·판정 로직은 그대로입니다.
+- **확신이 없으면 숨기지 않고 드러냅니다** — 관측 3건 미만이거나 역할 동의율 80% 미만이면 `unknown`으로 두고 위임 집계에서 제외합니다. Sonnet으로 조용히 틀리던 기존 동작이 더 나빴습니다.
+- **수동 오버라이드** — `<userDataDir>/profile-map.json`의 `modelAliases`에 와일드카드 패턴으로 직접 지정할 수 있습니다. 프로파일 ID·AWS 계정 ID는 소스에 전혀 넣지 않습니다.
+- 게이트웨이를 쓰지 않는 환경은 **동작이 완전히 동일**합니다(파일도 만들지 않습니다).
+
 ### v3.9.2 (2026-08-01)
 - **LICENSE 파일 추가 (MIT)** — `package.json`에만 있고 파일이 없어서, 사내 도입 검토 시 라이선스 확인이 막히던 문제. npm 패키지에도 포함되도록 `files`에 넣었습니다.
 - **패키지 설명·키워드를 현재 기능에 맞게 교체** — 캐시 모니터링 시절 문구가 남아 있어 모델 위임(`model-routing`·`delegation`·`subagent`)으로 검색되지 않았습니다.

package/bin/cli.js

@@ -433,6 +433,17 @@ async function main() {
   }
   const lastActivity = Math.max(otherLastActivity, currentSessionLastUser);
 
+  // What delegation has measurably saved, read straight from the registry
+  // route-scan maintains. A lookup, never a scan: the statusline re-renders
+  // every few seconds and a scan parses tens of MB of transcripts.
+  let delegationSaved = 0;
+  try {
+    const { delegationSavedUsd } = await import('../src/model-rules.js');
+    delegationSaved = delegationSavedUsd();
+  } catch (e) {
+    debug('model-rules:saved', e); // an unreadable registry just hides the chip
+  }
+
   const data = {
     summary: sum,
     trend,
@@ -447,6 +458,7 @@ async function main() {
     spikeChip,
     caps,
     model,
+    delegationSaved,
   };
 
   let output;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-token-saver",
-  "version": "3.9.2",
+  "version": "3.11.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/cost.js

@@ -117,7 +117,22 @@ const TIER_RANK = {
   'claude-haiku-3': 0,
 };
 
+/**
+ * True for the explicit 'unknown' marker — an id that could not be resolved
+ * at all (see model-alias.js), as opposed to an id this table simply has no
+ * entry for. The two must not share a fate: an unresolved gateway id counted
+ * as Sonnet silently corrupts every delegation statistic, so it is dropped
+ * from the ranking instead of guessed at.
+ */
+export function isUnknownModel(model) {
+  return !model || String(model).toLowerCase() === 'unknown';
+}
+
 export function modelRank(model) {
+  // -1 sits below every real tier, so worthDelegating() rejects it and
+  // tierForRank() attributes no saving to it: the run leaves the aggregate
+  // rather than distorting it.
+  if (isUnknownModel(model)) return -1;
   const rank = TIER_RANK[detectPricingTier(model)];
   // Unknown ids fall through detectPricingTier to the Sonnet tier; ranking
   // them 1 keeps the conservative reading (cheap enough that a Sonnet-target

package/src/formatters/statusline.js

@@ -211,7 +211,7 @@ export function formatNoSession({ caps = null, model = null, windowLabel = '' }
  * @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] - whitelist of segments to render. Names: cap-warn, spike, harness, model, hit, ttl, saved, ctx, period, plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. Null/undefined = all.
+ * @param {string[]|null} [opts.segments] - whitelist of segments to render. Names: cap-warn, spike, harness, model, hit, ttl, saved, delegated, ctx, period, plus per-window keys (`five_hour`, `seven_day`, …). `5h`/`7d` are kept as aliases for back-compat. Null/undefined = all.
  */
 export function formatReport(data, { color = true, verbose = false, timer = true, mode = 'text', segments = null } = {}) {
   const { summary, ttl, cost, options, lastActivity, contextWindow, ctxLive, spikeChip, caps, model } = data;
@@ -255,6 +255,21 @@ export function formatReport(data, { color = true, verbose = false, timer = true
     : 'Cache saved';
   const saveSeg = `${c(CYAN)}${saveLabel}${c(RESET)} ${formatMoney(savings)}`;
 
+  // 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, summed from the rule registry route-scan maintains. Hidden
+  // when zero or absent: a permanent "$0" is noise for direct-API users and
+  // for anyone who has not delegated yet.
+  //   text:       "Delegated $3.2"                   |  same in verbose
+  //   icon:       "🔀 $3.2"                           |  verbose: "🔀 Delegated $3.2"
+  const delegationSaved = Number(data.delegationSaved) || 0;
+  const delegateLabel = isIcon
+    ? (verbose ? '🔀 Delegated' : '🔀')
+    : 'Delegated';
+  const delegateSeg = delegationSaved > 0
+    ? `${c(GREEN)}${delegateLabel}${c(RESET)} ${formatMoney(delegationSaved)}`
+    : null;
+
   // Period label honors hour-precision configs (`mode 6h` → "6h", `mode 1d` → "1d").
   // Fall back to legacy `${days}d` when callers haven't supplied a label.
   const periodLabel = options.windowLabel || `${options.days}d`;
@@ -482,6 +497,8 @@ export function formatReport(data, { color = true, verbose = false, timer = true
   // it sits near the tail. The period label closes the line as a quiet
   // timeframe footer.
   if (want('saved')) segs.push(saveSeg);
+  // Both savings numbers sit side by side, then the period label closes the line.
+  if (delegateSeg && want('delegated')) segs.push(delegateSeg);
   if (want('period')) segs.push(periodSeg);
   // Trailing erase-to-end-of-line so any leftover characters from a previous
   // (longer) statusline render don't bleed into ours. \x1b[K is the standard

package/src/model-alias.js

@@ -0,0 +1,437 @@
+/**
+ * model-alias — restore a usable model name when the transcript records a
+ * gateway identifier instead of a Claude model id.
+ *
+ * Why this exists: behind a Bedrock / LiteLLM gateway, `message.model` in the
+ * transcript is an inference-profile ARN:
+ *
+ *   converse/arn:aws:bedrock:<region>:<account>:application-inference-profile/<id>
+ *
+ * Nothing in that string says "opus" or "haiku", so `detectPricingTier()`
+ * falls through to its Sonnet default. Everything downstream then reads the
+ * session as Sonnet: `worthDelegating('T1', 1)` is false, so every T1 rule is
+ * rejected, delegation savings aggregate to zero, and cost is under-counted.
+ *
+ * The fix is a single normalization point rather than a change to the pricing
+ * table — plain aliases (`ap-northeast-2.anthropic.claude-opus-5[1m]`) are
+ * already classified correctly, region prefix and `[1m]` suffix included. So
+ * all that is missing is ARN → alias.
+ *
+ * Resolution order, cheapest first:
+ *   1. not an ARN            → return the input unchanged (direct-API users
+ *                              must keep their existing behaviour)
+ *   2. user override         → `modelAliases` in profile-map.json
+ *   3. learned mapping       → profile id → role, learned from transcripts
+ *   4. otherwise             → 'unknown' (never a silent Sonnet guess)
+ *
+ * A profile id is never hardcoded here. Ids differ per account and change
+ * with gateway config, and the ARN embeds a 12-digit AWS account id — this
+ * package is published to npm, so neither may live in the source.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, createReadStream } 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';
+
+/** Marker returned when a gateway id could not be resolved to a model. */
+export const UNKNOWN_MODEL = 'unknown';
+
+/** File holding user overrides plus the learned profile→role votes. */
+export function profileMapPath() {
+  return join(userDataDir(), 'profile-map.json');
+}
+
+// `converse/` (LiteLLM) or a bare ARN, foundation- or application-scoped.
+const ARN_RE =
+  /arn:aws:bedrock:[^:]*:[^:]*:(?:application-)?inference-profile\/([A-Za-z0-9._:-]+)/;
+
+/** True when the id came from a Bedrock gateway rather than the Claude API. */
+export function isGatewayModelId(model) {
+  return typeof model === 'string' && model.includes('arn:aws:bedrock:');
+}
+
+/** The inference-profile id inside an ARN, or null when there is none. */
+export function profileIdFrom(model) {
+  if (typeof model !== 'string') return null;
+  const m = ARN_RE.exec(model);
+  return m ? m[1] : null;
+}
+
+/**
+ * Roles a profile id can carry. 'main' is the session's own model, which the
+ * env declares separately from the per-tier subagent overrides.
+ */
+const ROLES = ['main', 'opus', 'sonnet', 'haiku', 'fable'];
+
+/**
+ * Alias for a role, taken from the environment Claude Code itself uses to
+ * pick subagent models. Returns null when the variable is absent or is itself
+ * an ARN (resolving an ARN to another ARN would loop).
+ */
+export function aliasForRole(role, env = process.env) {
+  const candidates = {
+    main: [env.ANTHROPIC_MODEL, env.ANTHROPIC_DEFAULT_MODEL, env.ANTHROPIC_DEFAULT_OPUS_MODEL],
+    opus: [env.ANTHROPIC_DEFAULT_OPUS_MODEL, env.ANTHROPIC_MODEL],
+    sonnet: [env.ANTHROPIC_DEFAULT_SONNET_MODEL],
+    haiku: [env.ANTHROPIC_DEFAULT_HAIKU_MODEL],
+    fable: [env.ANTHROPIC_DEFAULT_FABLE_MODEL],
+  }[role] || [];
+  for (const v of candidates) {
+    if (typeof v === 'string' && v && !isGatewayModelId(v)) return v;
+  }
+  return null;
+}
+
+// ── override / learned map storage ───────────────────────────────────────
+
+let cached = null;
+
+/** Read profile-map.json (memoized). Missing or corrupt file → empty map. */
+export function loadProfileMap() {
+  if (cached) return cached;
+  let data = {};
+  try {
+    data = JSON.parse(readFileSync(profileMapPath(), 'utf8'));
+  } catch { /* absent on first run, and unreadable is not fatal */ }
+  cached = {
+    version: 1,
+    modelAliases: data.modelAliases && typeof data.modelAliases === 'object' ? data.modelAliases : {},
+    learned: data.learned && typeof data.learned === 'object' ? data.learned : {},
+    learnedAt: data.learnedAt || null,
+    scannedSessions: data.scannedSessions || 0,
+  };
+  return cached;
+}
+
+export function saveProfileMap(map) {
+  const dir = userDataDir();
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(profileMapPath(), JSON.stringify(map, null, 2));
+  cached = map;
+}
+
+/** Drop the memoized map. Tests use this after pointing paths elsewhere. */
+export function resetModelAliasCache() {
+  cached = null;
+}
+
+/**
+ * Glob match for override keys, so a user can write one entry that hides the
+ * account id and region: `arn:aws:bedrock:*:*:application-inference-profile/x`.
+ */
+function globMatch(pattern, value) {
+  const rx = new RegExp(
+    '^' + pattern.split('*').map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*') + '$',
+  );
+  return rx.test(value);
+}
+
+function overrideAlias(model, map) {
+  for (const [pattern, alias] of Object.entries(map.modelAliases || {})) {
+    if (globMatch(pattern, model)) return alias;
+    // Overrides are usually written without the LiteLLM `converse/` prefix.
+    const bare = model.slice(model.indexOf('arn:aws:bedrock:'));
+    if (globMatch(pattern, bare)) return alias;
+  }
+  return null;
+}
+
+// ── resolution ───────────────────────────────────────────────────────────
+
+/**
+ * Normalize one transcript model id.
+ * Non-gateway ids pass through untouched; gateway ids resolve to an alias, or
+ * to 'unknown' when the mapping is not confident yet.
+ */
+export function resolveModelAlias(rawModel, { env = process.env } = {}) {
+  if (!rawModel) return UNKNOWN_MODEL;
+  const model = String(rawModel);
+  if (!isGatewayModelId(model)) return model;
+
+  const map = loadProfileMap();
+
+  const override = overrideAlias(model, map);
+  if (override) return override;
+
+  const pid = profileIdFrom(model);
+  if (!pid) return UNKNOWN_MODEL;
+
+  const entry = map.learned?.[pid];
+  if (entry?.role) {
+    const alias = aliasForRole(entry.role, env);
+    if (alias) return alias;
+  }
+  return UNKNOWN_MODEL;
+}
+
+// ── learning ─────────────────────────────────────────────────────────────
+
+// A single observation can be wrong: the time-adjacent parent records leak
+// into a naive join, and a mis-set agent definition mislabels one run. Require
+// a few observations that mostly agree before trusting a mapping.
+export const MIN_VOTES = 3;
+export const MIN_AGREEMENT = 0.8;
+
+/** Role named directly by a Task call's `model` parameter. */
+function roleFromModelParam(value) {
+  if (typeof value !== 'string') return null;
+  const v = value.toLowerCase();
+  return ROLES.find((r) => r !== 'main' && v.includes(r)) || null;
+}
+
+/** Role declared in a subagent definition's frontmatter (`model: haiku`). */
+function roleFromAgentType(agentType, cache) {
+  if (!agentType) return null;
+  if (cache.has(agentType)) return cache.get(agentType);
+  let role = null;
+  for (const dir of [join(claudeUserDir(), 'agents'), join(process.cwd(), '.claude', 'agents')]) {
+    const file = join(dir, `${agentType}.md`);
+    if (!existsSync(file)) continue;
+    try {
+      const head = readFileSync(file, 'utf8').slice(0, 2000);
+      const m = /^model:\s*([A-Za-z0-9._-]+)/m.exec(head);
+      if (m) role = roleFromModelParam(m[1]);
+    } catch { /* unreadable definition just yields no vote */ }
+    if (role) break;
+  }
+  cache.set(agentType, role);
+  return role;
+}
+
+/**
+ * Record one observation.
+ *
+ * `kind` matters more than the count. An 'explicit' vote comes from a stated
+ * model — a `Task(model: "haiku")` parameter or an agent definition's
+ * frontmatter. An 'inferred' vote is circumstantial: the record carried no
+ * sidechain flag, so it is *probably* the parent session's own model. Mixing
+ * the two by volume let 4 inferred votes outrank 1 explicit one and stamped a
+ * haiku profile as 'main' — see tallyVotes.
+ */
+function addVote(votes, pid, role, kind) {
+  if (!pid || !role) return;
+  const v = (votes[pid] ||= { explicit: {}, inferred: {} });
+  const bucket = v[kind] || (v[kind] = {});
+  bucket[role] = (bucket[role] || 0) + 1;
+}
+
+/**
+ * Read one main transcript: which profile id the session itself ran on, and
+ * which role each Task/Agent tool_use asked for (joined later by tool_use id).
+ */
+async function scanMainTranscript(path, votes, requestedByToolUse, agentTypeCache) {
+  let sawGateway = false;
+  const rl = createInterface({
+    input: createReadStream(path, { encoding: 'utf8' }),
+    crlfDelay: Infinity,
+  });
+  try {
+    for await (const line of rl) {
+      if (!line.includes('arn:aws:bedrock:') && !line.includes('"Task"') && !line.includes('"Agent"')) {
+        continue;
+      }
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const msg = entry.message;
+      if (!msg) continue;
+
+      // The session's own model: the parent side of the transcript.
+      if (msg.model && entry.isSidechain !== true) {
+        const pid = profileIdFrom(msg.model);
+        if (pid) {
+          sawGateway = true;
+          // Circumstantial: a subagent's records also land in the parent file
+          // without the flag often enough to outvote real evidence.
+          addVote(votes, pid, 'main', 'inferred');
+        }
+      }
+
+      if (!Array.isArray(msg.content)) continue;
+      for (const block of msg.content) {
+        if (!block || block.type !== 'tool_use') continue;
+        if (block.name !== 'Task' && block.name !== 'Agent') continue;
+        const input = block.input || {};
+        const role = roleFromModelParam(input.model)
+          || roleFromAgentType(input.subagent_type, agentTypeCache);
+        if (block.id && role) requestedByToolUse.set(block.id, role);
+      }
+    }
+  } finally {
+    rl.close();
+  }
+  return sawGateway;
+}
+
+/** First profile id used by a subagent transcript (a run uses exactly one). */
+async function subagentProfileId(path) {
+  const rl = createInterface({
+    input: createReadStream(path, { encoding: 'utf8' }),
+    crlfDelay: Infinity,
+  });
+  try {
+    for await (const line of rl) {
+      if (!line.includes('arn:aws:bedrock:')) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const pid = profileIdFrom(entry.message?.model);
+      if (pid) return pid;
+    }
+  } finally {
+    rl.close();
+  }
+  return null;
+}
+
+/** Subagent transcripts a session spawned (mirrors subagent-records layout). */
+async function subagentFiles(sessionPath) {
+  const dir = join(dirname(sessionPath), basename(sessionPath, '.jsonl'), 'subagents');
+  try {
+    return (await readdir(dir)).filter((f) => f.endsWith('.jsonl')).map((f) => join(dir, f));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Whether two roles describe the same model. 'main' and 'opus' routinely do:
+ * the session model is the opus alias on a default setup, so a Task that asked
+ * for opus does not contradict "this is the parent's own profile".
+ */
+function rolesAgree(a, b) {
+  if (!a || !b) return false;
+  if (a === b) return true;
+  const pair = new Set([a, b]);
+  return pair.has('main') && pair.has('opus');
+}
+
+/** Winner of one bucket, with the counts needed to judge confidence. */
+function topRole(tally) {
+  let role = null;
+  let top = 0;
+  let total = 0;
+  for (const [r, n] of Object.entries(tally || {})) {
+    total += n;
+    if (n > top) { top = n; role = r; }
+  }
+  return { role, top, total };
+}
+
+/**
+ * Decide a role per profile id.
+ *
+ * Explicit evidence decides alone whenever there is enough of it; inferred
+ * evidence is only consulted when the explicit bucket is too thin. Counting
+ * both together is what produced the original mis-classification: a haiku
+ * profile appeared 16 times in parent transcripts without a sidechain flag
+ * 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.
+ */
+export function tallyVotes(votes, { minVotes = MIN_VOTES, minAgreement = MIN_AGREEMENT } = {}) {
+  const learned = {};
+  for (const [pid, buckets] of Object.entries(votes)) {
+    // Legacy flat shape (`{ haiku: 3 }`) is read as explicit evidence.
+    const split = buckets && (buckets.explicit || buckets.inferred)
+      ? { explicit: buckets.explicit || {}, inferred: buckets.inferred || {} }
+      : { explicit: buckets || {}, inferred: {} };
+
+    const explicit = topRole(split.explicit);
+    const inferred = topRole(split.inferred);
+
+    let role = null;
+    let source = null;
+    if (explicit.total >= minVotes && explicit.top / explicit.total >= minAgreement) {
+      role = explicit.role;
+      source = 'explicit';
+    } else if (inferred.total >= minVotes
+      && inferred.top / inferred.total >= minAgreement
+      && (explicit.total === 0 || rolesAgree(explicit.role, inferred.role))) {
+      // Thin explicit evidence still vetoes a contradicting inference: one
+      // stated `Task(model: "haiku")` outweighs any number of "no sidechain
+      // flag, so probably the session model" observations.
+      role = inferred.role;
+      source = 'inferred';
+    }
+
+    learned[pid] = {
+      role,
+      source,
+      votes: split,
+      total: explicit.total + inferred.total,
+    };
+  }
+  return learned;
+}
+
+/**
+ * Learn profile id → role from transcripts and persist the result.
+ *
+ * The join is exact rather than time-windowed: `.meta.json` carries the
+ * `toolUseId` of the Task block that spawned the run, and that block names the
+ * model tier. A subagent transcript uses exactly one profile id, so the run's
+ * id and the requested role identify each other.
+ *
+ * @param {object}   opts
+ * @param {string[]} opts.sessionPaths transcripts to read, newest first
+ * @param {number}   opts.maxSessions  cap on files read (learning is a scan)
+ * @returns {Promise<{learned: object, scannedSessions: number, gateway: boolean}>}
+ */
+export async function learnProfileMapping({ sessionPaths = [], maxSessions = 40 } = {}) {
+  const votes = {};
+  const agentTypeCache = new Map();
+  let scanned = 0;
+  let gateway = false;
+
+  for (const sessionPath of sessionPaths.slice(0, maxSessions)) {
+    const requestedByToolUse = new Map();
+    let sawGateway = false;
+    try {
+      sawGateway = await scanMainTranscript(sessionPath, votes, requestedByToolUse, agentTypeCache);
+    } catch {
+      continue;
+    }
+    scanned += 1;
+
+    for (const jsonl of await subagentFiles(sessionPath)) {
+      let meta = null;
+      try {
+        meta = JSON.parse(await readFile(jsonl.replace(/\.jsonl$/, '.meta.json'), 'utf8'));
+      } catch { /* pre-toolUseId runs simply cast no vote */ }
+      const role = (meta?.toolUseId && requestedByToolUse.get(meta.toolUseId))
+        || roleFromAgentType(meta?.agentType, agentTypeCache);
+      if (!role) continue;
+      const pid = await subagentProfileId(jsonl);
+      if (!pid) continue;
+      sawGateway = true;
+      // Stated evidence: the Task call named this tier, or the agent
+      // definition it used did.
+      addVote(votes, pid, role, 'explicit');
+    }
+    if (sawGateway) gateway = true;
+  }
+
+  const learned = tallyVotes(votes);
+  const map = loadProfileMap();
+  const next = {
+    ...map,
+    learned,
+    learnedAt: new Date().toISOString(),
+    scannedSessions: scanned,
+  };
+  // Nothing to record on a non-gateway machine — do not create the file there.
+  if (gateway || Object.keys(map.learned || {}).length) saveProfileMap(next);
+  return { learned, scannedSessions: scanned, gateway };
+}

package/src/model-rules.js

@@ -100,6 +100,27 @@ export function loadModelRules() {
   }
 }
 
+/**
+ * USD that measured delegations have saved, summed across registered rules.
+ * Reads the file route-scan already wrote — the statusline refreshes every few
+ * seconds and must never start a scan of its own (a scan parses tens of MB of
+ * transcripts).
+ *
+ * Rules with no measured delegation contribute nothing, and an unreadable
+ * registry returns 0 rather than throwing: the statusline reads 0 as "draw no
+ * chip", which is the right outcome for anyone who never delegates.
+ */
+export function delegationSavedUsd() {
+  try {
+    return loadModelRules().rules.reduce(
+      (sum, r) => sum + (r.delegatedRuns ? (Number(r.savedUsd) || 0) : 0),
+      0,
+    );
+  } catch {
+    return 0;
+  }
+}
+
 export function saveModelRules(data) {
   const dir = stateDir();
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });

package/src/parser.js

@@ -4,6 +4,7 @@ import { createInterface } from 'node:readline';
 import { join, isAbsolute } from 'node:path';
 import { homedir } from 'node:os';
 import { loadCache, getCached, putCached, saveCache } from './session-cache.js';
+import { resolveModelAlias } from './model-alias.js';
 
 const CLAUDE_DIR = join(homedir(), '.claude', 'projects');
 
@@ -49,7 +50,7 @@ export async function parseSessionFile(filePath) {
 
     requests.set(reqId, {
       requestId: reqId,
-      model: msg.model || 'unknown',
+      model: resolveModelAlias(msg.model),
       inputTokens: usage.input_tokens || 0,
       cacheCreationTokens: usage.cache_creation_input_tokens || 0,
       cacheReadTokens: usage.cache_read_input_tokens || 0,

package/src/route-scan.js

@@ -24,6 +24,7 @@ import { discoverSessionFiles } from './parser.js';
 import { collectSessionRecords } from './session-records.js';
 import { collectSubagentRuns, indexRuns, runsForEpisode } from './subagent-records.js';
 import { estimateCost, modelRank, TIER_TARGET_RANK, tierForRank } from './cost.js';
+import { learnProfileMapping, resetModelAliasCache } from './model-alias.js';
 import { agentPhrase, agentPhraseEn } from './agents.js';
 
 // ── Tier bands (docs/TIER_CRITERIA.md §3) ────────────────────────────────
@@ -331,6 +332,16 @@ export function tierOf(ep, category, th) {
 export async function runRouteScan({ days = 14 } = {}) {
   const files = await discoverSessionFiles({ days });
 
+  // Behind a Bedrock/LiteLLM gateway the transcripts carry an inference-profile
+  // ARN where the model id belongs, which reads as Sonnet and rejects every T1
+  // rule. Refresh the profile→role mapping before parsing so this scan resolves
+  // those ids; on a direct-API machine it finds nothing and writes nothing.
+  resetModelAliasCache();
+  try {
+    await learnProfileMapping({ sessionPaths: files.map((f) => f.path) });
+  } catch { /* learning is an optimization — the scan still runs without it */ }
+  resetModelAliasCache();
+
   // Pass 1 — collect episodes (needed up front: thresholds are calibrated
   // from the full window's output distribution before any tiering).
   const all = []; // { ep, projectDir, sessionPath }

package/src/session-records.js

@@ -9,10 +9,16 @@
 
 import { createReadStream } from 'node:fs';
 import { createInterface } from 'node:readline';
+import { resolveModelAlias } from './model-alias.js';
 
-/** Strip context-window suffixes like "[1m]" so model ids compare cleanly. */
+/**
+ * Strip context-window suffixes like "[1m]" so model ids compare cleanly, and
+ * turn a gateway inference-profile ARN back into a Claude alias. Ids that are
+ * already Claude aliases pass through untouched.
+ */
 export function normalizeModelId(model) {
-  return String(model || 'unknown').replace(/\[[^\]]*\]$/, '');
+  const resolved = resolveModelAlias(model || 'unknown');
+  return String(resolved).replace(/\[[^\]]*\]$/, '');
 }
 
 /** Extract plain text from a Claude transcript message content field. */