@alexeiled/claude-router 1.11.0 → 1.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "router",
3
3
  "displayName": "Router",
4
- "version": "1.11.0",
4
+ "version": "1.12.0",
5
5
  "description": "Model and effort routing for the main conversation by task difficulty and activity, advised by a prompt classifier (Jev, Clef, Clef Flash, OpenAI or local Ollama). Subagents get one model at spawn: every agent that does not pin one.",
6
6
  "author": {
7
7
  "name": "Alexei Ledenev",
package/CHANGELOG.md CHANGED
@@ -1,5 +1,23 @@
1
1
  # Changelog
2
2
 
3
+ ## 1.12.0 (2026-10-13)
4
+
5
+ The Usage tab now shows any period, not only this session and the time since the last reset. See [Compare routing with your model](docs/user-guide.md#compare-routing-with-your-model).
6
+
7
+ ### Added
8
+
9
+ - Periods on the Usage tab: Session, Today, 7d, 30d, Month and All. Press `p` for the next one; the choice is kept across sessions. Each session now keeps its routed usage by local calendar day in `usage:v1:<session id>`, for 400 days.
10
+ - A ledger that adds up in whole cents: your model, minus cheaper models, plus stronger models, plus switch cache writes, equals routed. A line under it gives replies, turns, input, cache hit and output.
11
+ - The period's cost by activity, model or tier (`g`), with each row opening to its routes or activities.
12
+ - The cost per hour, day or week, and **What if** (`c`): the period's tokens on each model alone.
13
+ - **Worth a look**, from 20 replies: the cell that carried most of the cost, switch writes that ate the saving, the cell that ran above your model. Each links to Routes or Policy. It never names a model to use.
14
+
15
+ ### Changed
16
+
17
+ - **Delete history** replaces **Reset stats**. It asks once more, then deletes the usage, activity and subagent records of every session. To look at a shorter span, pick a period.
18
+ - The plan quota leaves the pane: Claude Code shows it in `/usage`. Claude's readings and **details** move to the Now tab. The session's tool **Agreement** moves to the Classifier tab.
19
+ - All adds the totals earlier versions kept without dates, with a note; the other periods start from the first dated day.
20
+
3
21
  ## 1.11.0 (2026-10-13)
4
22
 
5
23
  Clef Omni joins Clef and Clef Flash as a third Cloudflare classifier. It costs less than Clef, and in Cloudflare's benchmarks it leads the Clef family on intent classification.
package/README.md CHANGED
@@ -26,7 +26,7 @@ Jev is the default. [Configuration](docs/configuration.md#classifiers) gives the
26
26
 
27
27
  The band above the prompt shows the tier, activity, model, and reason for each turn. `/router` opens a pane to pin a tier, edit the model and effort of each tier, and tune the policy. See the [user guide](docs/user-guide.md#read-the-status-band).
28
28
 
29
- The router needs Claude Code 2.1.289 or newer. Savings are not measured. The pane's Usage tab estimates what routing cost against your own model for the same tokens at configured list prices; it is not a bill and does not judge answer quality. See the [evaluation](docs/evaluation.md).
29
+ The router needs Claude Code 2.1.289 or newer. Savings are not measured. The pane's Usage tab estimates what routing cost against your own model for the same tokens at configured list prices, for this session, today, 7 or 30 days, this month or all; it is not a bill and does not judge answer quality. See the [evaluation](docs/evaluation.md).
30
30
 
31
31
  ## How it works
32
32
 
@@ -223,7 +223,7 @@ label was right, not the classifier's probabilities.
223
223
 
224
224
  ## What the estimates mean
225
225
 
226
- **In the pane.** The band, the Now tab and the Usage tab report Claude's own readings: cost, context, and cache. The
226
+ **In the pane.** The band and the Now tab report Claude's own readings: cost, context, and cache. The
227
227
  dollar figures next to them, such as the switch cost, and the payback, are estimates
228
228
  at the list prices in `router.json`. They are not your bill: a plan does not charge list prices. They are not measured
229
229
  savings: the router does not know what another model would have answered, or how many requests it would have needed.
@@ -246,8 +246,8 @@ Limits:
246
246
 
247
247
  - The answer quality of routed sessions.
248
248
  - How well the classifier labels real turns. On 70 synthetic prompts, Jev and OpenAI labelled all 70 right; see
249
- [Evaluation](evaluation.md#activity-probe-set). The **Agreement** lines, on the Usage tab for this session and on the
250
- Classifier tab across sessions, check your own turns against the tools they used.
249
+ [Evaluation](evaluation.md#activity-probe-set). The **Agreement** lines, on the
250
+ Classifier tab for this session and across sessions, check your own turns against the tools they used.
251
251
  - Whether an effort change on the same model keeps the cache. We found only 6 cases. Claude Code's prompt-caching
252
252
  docs say it does on the 5.5 models and Fable 5.1 with an API key or a subscription, and the router now prices it so.
253
253
  - How many requests a turn needs on each model.
@@ -113,13 +113,13 @@ When a turn completes, the Mod labels it from the tool calls the assistant made
113
113
  Two stores hold counts:
114
114
 
115
115
  - **Session**: `activityStats` in the view, reset when the session ends. It has turns, requests, tokens, the list price of priced replies with their count, and routed replies by `model@effort` per activity, switches by tier and by activity, lateral moves taken and refused, and tool agreement. The label counted per activity is the applied activity in `on`. Tool agreement compares the answer that cleared `activityMass`, so it measures the classifier in both modes. The view also keeps an `activities` array aligned with the last 30 replies.
116
- - **Across sessions**: two `$.store` records per session. Each session's `activity:stats:v1:<session id>` holds a confusion matrix of the classifier's raw answer (including `uncertain` and `none`) against the observed bucket, run lengths per activity in five buckets, lateral switches taken and refused (from the decision's `lateral` field, so a hold or the cash gate counts), and `since`, its first count. A value with an unknown key or shape reads as empty; the `shadow` key that versions before 1.10.1 wrote is dropped on read and the rest is kept. Before 1.10.3 every session shared one `activity:stats:v1` key, read-modified-written each turn, so two sessions finishing turns together could lose a count and a stale write could undo a reset; that key now counts as one more record in the sum until **Reset stats** deletes it, and 1.10.2 and earlier read only it. Each session's `activity:metrics:v1:<session id>` holds a classifier latency histogram per classifier id (22 buckets, at most 8 ids), the cheaper activity moves taken in `on` with the escalations that followed one, and `since`, its first reading; each part reads as empty on its own when its shape is wrong, as after a change of buckets. Both follow the savings records below: one writer per key, so sessions that finish turns at the same moment do not overwrite each other; this session's record held in memory and written after each turn that adds a count; the readout the sum of all records, latency kept to the first 8 classifier ids; and the same reset marker. Each record is bounded, and the records grow by one per session that recorded a count until **Reset stats**, as the savings records do. The view keeps the last sums read or written as `activityStore` and `activityMetrics`: read at session start and when the pane opens, replaced after each turn's write and after a reset. The open run is written when the session ends. **Reset stats** clears the session counts, every stats and metrics record, and the routing-vs-your-model totals below.
116
+ - **Across sessions**: two `$.store` records per session. Each session's `activity:stats:v1:<session id>` holds a confusion matrix of the classifier's raw answer (including `uncertain` and `none`) against the observed bucket, run lengths per activity in five buckets, lateral switches taken and refused (from the decision's `lateral` field, so a hold or the cash gate counts), and `since`, its first count. A value with an unknown key or shape reads as empty; the `shadow` key that versions before 1.10.1 wrote is dropped on read and the rest is kept. Before 1.10.3 every session shared one `activity:stats:v1` key, read-modified-written each turn, so two sessions finishing turns together could lose a count and a stale write could undo a reset; that key now counts as one more record in the sum until **Delete history** deletes it, and 1.10.2 and earlier read only it. Each session's `activity:metrics:v1:<session id>` holds a classifier latency histogram per classifier id (22 buckets, at most 8 ids), the cheaper activity moves taken in `on` with the escalations that followed one, and `since`, its first reading; each part reads as empty on its own when its shape is wrong, as after a change of buckets. Both follow the usage records below: one writer per key, so sessions that finish turns at the same moment do not overwrite each other; this session's record held in memory and written after each turn that adds a count; the readout the sum of all records, latency kept to the first 8 classifier ids; and the same reset marker. Each record is bounded, and the records grow by one per session that recorded a count until **Delete history**. The view keeps the last sums read or written as `activityStore` and `activityMetrics`: read at session start and when the pane opens, replaced after each turn's write and after a reset. The open run is written when the session ends. **Delete history** clears the session counts, every stats and metrics record, and the usage records below.
117
117
 
118
118
  Nothing is recorded with `activityRouting: off`. Stats run inside a guard: a failed transcript read or store access loses that turn's counts and never fails the turn. Readings already in the session's metrics record stay in memory after a failed write and go out with the next turn that adds a reading. A turn from a session that has since changed is dropped.
119
119
 
120
120
  ### Routing vs your model
121
121
 
122
- After each main reply, where the response is observed, `savings.mjs` prices the reply on the model that served it and the same tokens on "your model": the session's model and the effort Claude Code sent on the turn's first request. `compareModels` prices each reply against every model in `router.json` as "your model", at the session effort. Each keeps a simulated single cache in the loop under its models key in `yoursBy` (`{ total, at, onYours, model, effort }`), which a history reset clears; after an effort change the next reply finds it cold. The session's totals per model are `savingsBy` in the view, and `updateView` sets `savings` to the entry for the model `/model` selects whenever the model or the totals change, so a `/model` change re-prices the whole session without a replay. At turn completion the turn's totals against the model selected then are added to the session's own `$.store` key `savings:v1:<session id>` (replies, five sums and `since`), under the same reset guard as the activity stats. Each key has one writer, and Claude Code 2.1.296 writes one key under a file lock (observed in its code; the `$.store` types do not promise it), so sessions that finish turns at the same moment do not overwrite each other. The view's `savingsStore` adds up two parts: every other session's key, read at session start and when the pane opens, and this session's record, which the router reads once, holds in memory, adds each finished turn to and then writes, so a pane opened during that write counts the turn once. **Reset stats** first writes the time in `savings:reset:v1`, then deletes every such key and every activity metrics record. A record whose first reply is older than that time reads as empty, and each session reads the time before it adds a turn, so a session that still holds its record from before a Reset in another session drops it instead of writing it back. The comparison is by milliseconds: a record whose first reply has the reset's millisecond, or one written while the clock had moved back, still counts. A stored value of any other shape reads as empty. A reply with routing off or after an engine fallback is not counted, but it still moves your model's cache. A reply whose cache lifetime cannot be read loses its prices only, and your model's cache still follows it; a usage without rate limits prices writes at five minutes. No failure here fails the turn. [Evaluation](evaluation.md#routing-vs-your-model) gives the method and its limits.
122
+ After each main reply, where the response is observed, `savings.mjs` prices the reply on the model that served it and the same tokens on "your model": the session's model and the effort Claude Code sent on the turn's first request. `compareModels` prices each reply against every model in `router.json` as "your model", at the session effort. Each keeps a simulated single cache in the loop under its models key in `yoursBy` (`{ total, at, onYours, model, effort }`), which a history reset clears; after an effort change the next reply finds it cold. The session's totals per model are `savingsBy` in the view, and `updateView` sets `savings` to the entry for the model `/model` selects whenever the model or the totals change, so a `/model` change re-prices the whole session without a replay. Each reply also becomes a `replyEntry` in `usage.mjs`: its time, its cell `activity|tier|modelId@effort` with the model that served it, its prices against the model selected then, its input, cache-read and output tokens, and what the same tokens cost on each model as yours. Models are kept by id, not by models key, because a key can later name another model. At turn completion `recordUsage` adds the turn's entries to the session's own `$.store` key `usage:v1:<session id>`, by local calendar day: per day the cells' nine sums, the what-if sums, the replies per your model, the routed cost per hour, the turns, and the route switches by tier and by activity, with `since`, the record's first write. Days older than 400 days leave the record when it is written. Each key has one writer, and Claude Code 2.1.296 writes one key under a file lock (observed in its code; the `$.store` types do not promise it), so sessions that finish turns at the same moment do not overwrite each other. The view's `usageStore` adds up two parts: every other session's key, read at session start and when the pane opens, and this session's record (`usageSession`), which the router reads once, holds in memory, adds each finished turn to and then writes, so a pane opened during that write counts the turn once. On that read, `prunedUsage` names other sessions' records with no day in the last 400 days and, past 1,000 records, those whose last day is oldest; a record that does not read whole, such as one a later version wrote, is never named. Each named record is read again and deleted only if it has not changed, so a session that wrote its record since keeps it; with no conditional delete in `$.store`, a write between that read and the delete is still lost. A day that does not read is dropped, and the others stay. The Usage tab sums the days of the chosen period (`summarize`); the period is kept across sessions in `usage:period`. Before these records each session kept undated totals in `savings:v1:<session id>`; they are no longer written, and the view's `savingsStore`, their sum, is added to the All period. **Delete history** first writes the time in `savings:reset:v1`, then deletes every usage, savings, activity stats, metrics and subagent record. A record whose first reply is older than that time reads as empty, and each session reads the time before it adds a turn, so a session that still holds its record from before a Reset in another session drops it instead of writing it back. The comparison is by milliseconds: a record whose first reply has the reset's millisecond, or one written while the clock had moved back, still counts. A stored value of any other shape reads as empty. A reply with routing off or after an engine fallback is not counted, but it still moves your model's cache. A reply whose cache lifetime cannot be read loses its prices only, and your model's cache still follows it; a usage without rate limits prices writes at five minutes. No failure here fails the turn. [Evaluation](evaluation.md#routing-vs-your-model) gives the method and its limits.
123
123
 
124
124
  ### Subagents
125
125
 
@@ -131,7 +131,7 @@ A subagent's model is chosen once, in the `agent.spawn` hook, before its cache e
131
131
 
132
132
  `spawnAgent` in `hooks/native-router.mjs` passes the spawn through unchanged for a fork, a workflow agent (before the explicit check, since a workflow `agent({ model })` has `e.model` set), an explicit `e.model`, or a teammate (`passReason` in `lib/subagents.mjs`). Then `typeRoute` decides. A `subagents.types` entry wins; a key without a colon matches only the engine's built-in of that name. An unlisted built-in passes (`unlisted`), since its definition is not on disk. Any other agent is routed by its definition. `agentDefinition` finds the file once per provider and type in a session; a read that fails is tried again at the next spawn of the type. A plugin agent's `provider.plugin` is `plugin@marketplace`, the key of `<profile>/plugins/installed_plugins.json`, whose `installPath` entries hold `agents/*.md`. Other agents are looked up under the session's `.claude/agents`, then `<profile>/agents`. `agentFrontmatter` reads `name`, `model` and `modelRouting` from YAML or a one-line JSON object. No model, `inherit`, or `modelRouting: auto` is routed; any other model passes (`pinned`); a file not found, unreadable, or matches that disagree pass (`unknown`). A routed agent's type uses its models key, or for `classify` the active classifier is asked with the description and prompt alone, clipped to `context.maxTextChars`, with no history and no tool results. The answer maps to `subagents.heavy` when `P(high) ≥ heavyMass`, to `light` for an `explore` activity above `activityMass` or tier `micro`, else to `standard`. The spawn path has its own classifier client per classifier: its own failure count and pause, and no in-flight slot, so parallel spawns each get an answer and spawn failures never pause main-turn routing. Its deadline is the classifier's, capped at 3 seconds. That bounds how long a subagent waits to start. No advice, a missing key, a model `availableModels` blocks, or settings that cannot be read keep core's model. The router sends the configured full id, never an alias, because a family alias resolves to the parent's exact model when the families match. A `.catch` runs `next(e)`, so a failing hook spawns the agent as Claude Code would. Routing off (`/router off`, `/model`) or unavailable passes every spawn through and records nothing.
133
133
 
134
- Every spawn in `on` gets a record keyed by `agentId`, from `next(e)`'s answer. Its replies are priced in `turn.step` (`addAgentReply`), on the model they ran on and on core's model as `coreModelOf` estimates it (the definition's own model, else `CLAUDE_CODE_SUBAGENT_MODEL` except for Explore and Plan without `CLAUDE_CODE_SUBAGENT_MODEL_FORCE`, else `parentModel`). Cache writes are priced at the subagent lifetime (`subagentCacheTtl`). The record's counts go to this session's `$.store` key `subagents:v1:<session id>` at each of the agent's `turn.complete`s, and at session end for agents still running. They are counted per type and per pass-through reason, with respawns: a spawn of the type its parent loop finished one of in the last 10 minutes. The records follow the savings records: one writer per key, the readout `subagentStore` in the view is the sum, and the same reset marker applies. **Reset stats** clears them too.
134
+ Every spawn in `on` gets a record keyed by `agentId`, from `next(e)`'s answer. Its replies are priced in `turn.step` (`addAgentReply`), on the model they ran on and on core's model as `coreModelOf` estimates it (the definition's own model, else `CLAUDE_CODE_SUBAGENT_MODEL` except for Explore and Plan without `CLAUDE_CODE_SUBAGENT_MODEL_FORCE`, else `parentModel`). Cache writes are priced at the subagent lifetime (`subagentCacheTtl`). The record's counts go to this session's `$.store` key `subagents:v1:<session id>` at each of the agent's `turn.complete`s, and at session end for agents still running. They are counted per type and per pass-through reason, with respawns: a spawn of the type its parent loop finished one of in the last 10 minutes. The records follow the usage records: one writer per key, the readout `subagentStore` in the view is the sum, and the same reset marker applies. **Delete history** clears them too.
135
135
 
136
136
  ## Classifier deadline and failure handling
137
137
 
@@ -56,7 +56,7 @@ The script writes aggregate counts, reason histograms, route transitions, and sh
56
56
 
57
57
  Activity routing has no measured result. The replay above predates it and covers tiers only. It is `on` by default since 1.7, with defaults chosen from Anthropic's published benchmarks and a list-price replay of one developer's sessions; [Activity routing](activity-routing.md#what-the-estimates-mean) gives that replay and its limits. The pane counts turns, requests, switches, and the turns `on` would route differently, with a configured list-price estimate of those turns' next requests, not a measured saving. Two checks look at the classifier's activity label.
58
58
 
59
- The figures plan §11 tracks (tool agreement of at least 80% on `code` against `ops` and `explore`, Jev p95 latency of at most 450 ms, at most 1 tool-error escalation in 10 cheaper activity moves, the number of activity switches) are read from the Usage tab's **ACROSS SESSIONS** block, which shows the counts kept since the last reset: **Code/ops/explore** for the tool agreement on turns the classifier answered `code`, `ops` or `explore`, **Agreement** and **Mismatch** for all of them, **Activity moves** for moves inside a tier taken and refused (a refusal by a hold or the credits cap included), **Escalations** for the tool-error escalations that followed a cheaper activity move in `on` while the turns stayed on its route in `on` (turning routing off, a turn with routing off, or a turn in `off` ends the watch, a pin in between does not, and an escalation the credits cap held counts), **Latency** for the active classifier's p95 wait. Latency is kept in fixed buckets, so the p95 reads as a bound (`≤ 350 ms`); it is the wait for the classifier's answer, transient retries included, without the routing after it, so it compares with the probe's p95 below, and is not recorded with activity routing `off`. `/router` without a UI surface prints both agreements. The underlying counts are the per-session `activity:stats:v1:<session id>` and `activity:metrics:v1:<session id>` records described in [Architecture](architecture.md).
59
+ The figures plan §11 tracks (tool agreement of at least 80% on `code` against `ops` and `explore`, Jev p95 latency of at most 450 ms, at most 1 tool-error escalation in 10 cheaper activity moves, the number of activity switches) are read from the Classifier tab's **ACROSS SESSIONS** block, which shows the counts kept since the last reset: **Code/ops/explore** for the tool agreement on turns the classifier answered `code`, `ops` or `explore`, **Agreement** and **Mismatch** for all of them, **Activity moves** for moves inside a tier taken and refused (a refusal by a hold or the credits cap included), **Escalations** for the tool-error escalations that followed a cheaper activity move in `on` while the turns stayed on its route in `on` (turning routing off, a turn with routing off, or a turn in `off` ends the watch, a pin in between does not, and an escalation the credits cap held counts). The active classifier's p95 wait is on its **Deadline** line on the same tab, above that block. Latency is kept in fixed buckets, so the p95 reads as a bound (`≤ 350 ms`); it is the wait for the classifier's answer, transient retries included, without the routing after it, so it compares with the probe's p95 below, and is not recorded with activity routing `off`. `/router` without a UI surface prints both agreements. The underlying counts are the per-session `activity:stats:v1:<session id>` and `activity:metrics:v1:<session id>` records described in [Architecture](architecture.md).
60
60
 
61
61
  ### Tool agreement
62
62
 
@@ -84,7 +84,7 @@ The classifier's activity agrees with the turn when the bucket is one it allows:
84
84
  | `ops` | `ops`, `read` |
85
85
  | `docs` | `docs` |
86
86
 
87
- Agreement is a weak check. It tells `code` from `ops` and `explore` well, but not `ops` from `explore` when the commands only read. It cannot tell `plan` from `review`, and it says nothing about whether the route was good enough. It does catch the costly mistake, a cheap route on a coding turn. The Usage tab shows the session's count as `Agreement`, over the turns where the classifier gave an activity at or above `activityMass`, in `on` too when the route kept another activity. The counts kept across sessions hold the classifier's raw answer, `uncertain` and no answer included, against the bucket. The pane's **ACROSS SESSIONS** block counts agreement over the answers that name an activity; `uncertain` and no answer appear only in **Labelled**.
87
+ Agreement is a weak check. It tells `code` from `ops` and `explore` well, but not `ops` from `explore` when the commands only read. It cannot tell `plan` from `review`, and it says nothing about whether the route was good enough. It does catch the costly mistake, a cheap route on a coding turn. The Classifier tab shows the session's count as `Agreement` under **THIS SESSION**, over the turns where the classifier gave an activity at or above `activityMass`, in `on` too when the route kept another activity. The counts kept across sessions hold the classifier's raw answer, `uncertain` and no answer included, against the bucket. The pane's **ACROSS SESSIONS** block counts agreement over the answers that name an activity; `uncertain` and no answer appear only in **Labelled**.
88
88
 
89
89
  ### Activity probe set
90
90
 
@@ -110,18 +110,18 @@ Ollama's latency covers both requests and stays inside its 5000 ms deadline; on
110
110
 
111
111
  ## Routing vs your model
112
112
 
113
- The Usage tab compares what routed replies cost with what the same tokens would cost on your model, the model `/model` selects now at the session effort. It answers "at list prices, did routing spend more or less than my own model for this work". It does not answer whether the answers were as good.
113
+ The Usage tab compares what routed replies cost with what the same tokens would cost on your model, the model `/model` selected at the session effort when each reply ran. It answers "at list prices, did routing spend more or less than my own model for this work". It does not answer whether the answers were as good.
114
114
 
115
115
  Method, per main reply that routing chose:
116
116
 
117
117
  - **Routed** prices the usage Claude reported (uncached input, cache read, cache write, output) on the model that served it.
118
- - **Yours** prices the same tokens on each model in `router.json` at the session effort, and the readout shows the one `/model` selects now, so a `/model` change shows the whole session against the new model. While this reply and the one before it ran on that model's route, it is the reply's own usage, so a session on your model differs by exactly $0.00. Otherwise each model keeps one cache that never switched: it reads the previous prompt, up to this one less its uncached input, inside the cache lifetime, unless a compaction shrank the history or, on a model that keeps one cache per effort, the effort changed since, and never less than the API actually read; it writes the rest. Output tokens are the same. The totals kept across sessions price each reply against the model selected when it ran.
118
+ - **Yours** prices the same tokens on each model in `router.json` at the session effort. The Usage tab keeps each reply against the model selected when it ran, and **What if** shows the period against each model alone; the two-row band and `/router` show the session against the model `/model` selects now, so a `/model` change shows the whole session against the new model there. While this reply and the one before it ran on that model's route, it is the reply's own usage, so a session on your model differs by exactly $0.00. Otherwise each model keeps one cache that never switched: it reads the previous prompt, up to this one less its uncached input, inside the cache lifetime, unless a compaction shrank the history or, on a model that keeps one cache per effort, the effort changed since, and never less than the API actually read; it writes the rest. Output tokens are the same.
119
119
  - **Parts**: the served model on your cache against yours is the model price, under cheaper models when negative and stronger than yours when positive; routed against the served model on your cache is the cache the switches cost, never negative. They sum to the difference. The pane rounds to cents and gives the remainder only to a part that is not zero: a surplus to the switch part, else the stronger part, else the cheaper part toward $0.00; a shortfall comes off the stronger part, down to $0.00, then the cheaper part. The shown parts add up, none changes sign, and none appears from rounding alone.
120
120
  - **Prices**: `router.json` list prices through `ratesAt`, so Haiku 5.5 above 100,000 prompt tokens is priced at 5x. Claude Code reports no 5m/1h split to a Mod, so cache writes use the lifetime Claude Code 2.1.296 gives the main conversation by its own rule: one hour on a Claude plan unless an environment variable or the `promptCacheTtl` setting says otherwise, five minutes with an API key.
121
121
 
122
122
  Checks:
123
123
 
124
- - Unit tests (`test/savings.test.mjs`) cover a session that saves, one that costs more with Haiku as your model, equal routes at exactly 0, cache expiry at 5m and 1h, a compaction, a change of your model or effort, the 100K surcharge, an unpriced model, and a corrupted store. `test/hook-routing.test.mjs` covers two sessions finishing turns at the same moment, and a `/model` change mid-session that shows the whole session against the new model.
124
+ - Unit tests (`test/savings.test.mjs`) cover a session that saves, one that costs more with Haiku as your model, equal routes at exactly 0, cache expiry at 5m and 1h, a compaction, a change of your model or effort, the 100K surcharge, an unpriced model, and a corrupted store. `test/hook-routing.test.mjs` covers two sessions finishing turns at the same moment, and a `/model` change mid-session that shows the whole session against the new model. `test/usage.test.mjs` covers calendar days across month ends and daylight saving changes, the periods, the record cap and expiry, the trend buckets and what is worth a look; `test/usage-view.test.mjs` covers the Usage tab.
125
125
  - A one-off replay, not checked in, of this machine's main-conversation transcripts from 2026-10-01 to 2026-10-10 (nine sessions with 10 or more replies) gave $0.00 for every session that ran only on the model it was compared with: three on Opus 5.5, one on Haiku 5.5. Every main-conversation cache write in them was a one-hour write, which is what the lifetime rule gives on this Max plan.
126
126
  - A live Claude Code 2.1.296 session on 2026-10-10, Opus 5.5 at `high` with turns pinned to Haiku 5.5, showed **Routed replies $0.48** beside **Cost $0.480 reported by Claude** for the same 16 replies; its last Haiku reply had a 114K-token prompt, which agrees only at the 5x rate. A Haiku 5.5 session with a pinned Opus turn showed $0.45 routed against $0.446 reported.
127
127
 
@@ -132,7 +132,7 @@ Limits:
132
132
  - Your model's cache is simulated, and a five-minute session that the lifetime rule takes for one hour (a plan subscriber billed as overage) would read too much cache on your side.
133
133
  - A route that changes only the effort costs the same per token. On Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 it shares your cache and reads $0.00; on a provider that caches each effort apart, it shows its cache writes.
134
134
  - Subagents (see [Subagent routing](#subagent-routing)), classifier charges and replies with routing off are not counted. On a Claude plan the dollars stand for quota, not cash.
135
- - The saved column keeps one record per session, so sessions finishing turns at the same moment both count. Claude Code's store has no atomic update, which leaves these gaps: the same session open in two Claude Code processes at once can lose one's turn; a turn finishing in another process during **Reset stats** can be lost; a session's total from before a reset comes back if its first saved reply has the same millisecond as the reset, or if the system clock moved back across the reset; and the activity counts across sessions are still one shared record, where two sessions finishing turns at the same moment can lose one turn's counts. The router reads every session's record at session start and when the pane opens, so that read grows with the number of sessions since the last reset.
135
+ - The usage records keep one record per session, by local calendar day, so sessions finishing turns at the same moment both count. A turn's switch counts on the day it ended, its replies on the days they arrived. Claude Code's store has no atomic update, which leaves these gaps: the same session open in two Claude Code processes at once can lose one's turn; a turn finishing in another process during **Delete history** can be lost; and a session's total from before a reset comes back if its first saved reply has the same millisecond as the reset, or if the system clock moved back across the reset. The router reads every session's record at session start and when the pane opens, so that read grows with the number of sessions kept. A session drops its days older than 400 days when it writes its record; on that read, another session's record with no day in the last 400 days is deleted, and past 1,000 records of other sessions those with the oldest last day go too. A record that does not read whole, such as one a later version wrote, counts toward the 1,000 but is never deleted. Totals kept before the dated usage records have no dates: All adds them, and the other periods leave them out.
136
136
 
137
137
  ## Subagent routing
138
138
 
@@ -149,7 +149,7 @@ Method:
149
149
 
150
150
  Checks:
151
151
 
152
- - `test/subagents.test.mjs` covers each pass reason, the pin rule, the classify mapping, core's model estimate, the subagent lifetime, Haiku's long-context price, and the store's merge, reset and bad values. `test/hook-subagents.test.mjs` covers `on` (the routed model), a fork, an explicit model, a teammate, a workflow agent and a pinned project agent (each passes), a classifier failure (core's model), parallel spawns, a spawn-path pause that leaves main routing alone, respawns, session end, Reset stats and the Usage tab.
152
+ - `test/subagents.test.mjs` covers each pass reason, the pin rule, the classify mapping, core's model estimate, the subagent lifetime, Haiku's long-context price, and the store's merge, reset and bad values. `test/hook-subagents.test.mjs` covers `on` (the routed model), a fork, an explicit model, a teammate, a workflow agent and a pinned project agent (each passes), a classifier failure (core's model), parallel spawns, a spawn-path pause that leaves main routing alone, respawns, session end, Delete history and the Usage tab.
153
153
  - `experiments/mod-router/results/agent-spawn-probe.json` records what Claude Code 2.1.296 does with a spawn's model, frontmatter and workflow agents.
154
154
  - `experiments/mod-router/results/subagent-routing-live.json` is a live `on` run on 2026-10-10 with Sonnet as the parent. Explore was sent Haiku and ran on it. general-purpose was classified `standard`. A pinned project agent and an explicit `opus` call passed through. The store counted each one.
155
155
 
@@ -37,15 +37,15 @@ The status band is one line above the prompt: a tier meter, the activity, the ro
37
37
  | Classifier support | Per-tier probabilities from the last classification; under **Why**, the support for the switch against the bar the policy required, and the switch cost. Pins and skipped calls leave it empty. |
38
38
  | Activity | The classifier's activity choice as a verb with its share, the two next-best answers, and the threshold at which an activity applies; `uncertain` shown dim. Empty with routing off, a pin, or no answer. |
39
39
  | Last replies | The tier that served each of the last 30 main-conversation replies, a dot where the router did not choose, the model switches between them, and the replies per tier and per activity. |
40
- | Routing vs your model (Usage) | Routed replies at configured list prices against the same tokens on your model (the model `/model` selects now, at the session effort; after a `/model` change, the whole session against the new one), this session and since the last reset (each reply against the model selected when it ran); the session against the other configured models; the difference split into cheaper models, stronger than yours, and cache writes from switches. `too early` below 10 replies. Output length is held the same; answer quality is not measured. |
41
- | By activity (Usage) | Counts for this session: turns, requests and share per activity, its `est. cost` at configured list prices (`—` unless every reply had a price) and the route it was `mostly on`; switches by tier and by activity, and activity moves refused in `on`; tool agreement. |
40
+ | Routing vs your model (Usage) | For a period (this session, today, 7 or 30 days, this month, or all), routed replies at configured list prices against the same tokens on your model, the model `/model` selected at the session effort when each reply ran: a ledger from your model through cheaper models, stronger models and switch cache writes to routed; tokens and cache hit. `early sample` below 10 replies. Output length is held the same; answer quality is not measured. |
41
+ | Breakdown (Usage) | The period's replies, cost and difference against your model by activity, model or tier, each row opening to its routes or activities; the cost per hour, day or week, or **What if**, the same tokens on each model alone; from 20 replies, the cells worth a look, linked to Routes or Policy. |
42
42
  | Across sessions (Classifier) | The counts kept since the last reset: labelled turns, tool agreement on the classifier's raw answer, overall and for `code`, `ops` and `explore`, the two largest mismatches, activity moves inside a tier taken and refused, and escalations after a cheaper activity move. The active classifier's p95 latency shows on its **Deadline** line. `/router` text shows the agreement. |
43
43
  | Cost | Claude Code's native usage value. A plan's list-price estimates are not subscription cash charges. |
44
44
  | Context bar | Maximum available observed and local estimated context, compared with the routed model's window. The fit rule reserves 20%. |
45
- | Observed / estimated input | Under **details** on Usage: Claude's local context reading and the router's best current context estimate. `unknown` blocks a move to a smaller window. |
45
+ | Observed / estimated input | Under **details** on Now: Claude's local context reading and the router's best current context estimate. `unknown` blocks a move to a smaller window. |
46
46
  | Cache reuse | Last response's cache-read tokens divided by its reported input counters. |
47
47
  | Cache read / written; Output | Response usage counters. Cache warmth does not prove a particular TTL. |
48
- | Input per reply | Under **details** on Usage: up to 30 observed main-conversation input sizes, scaled from the lowest to the highest reading. |
48
+ | Input per reply | Under **details** on Now: up to 30 observed main-conversation input sizes, scaled from the lowest to the highest reading. |
49
49
  | Classifier header | Active classifier state and elapsed time. Missing-key, missing-account, busy, and paused skips have no network latency reading. |
50
50
  | Next-turn difference | Configured-price range for the suggested tier versus the incumbent on the next request. Negative means estimated lower cost. |
51
51
  | Conservative payback | Conditional later-turn estimate based on configured cache prices, future reads, and the last output size. It is not measured savings. |
@@ -65,7 +65,7 @@ The Routes tab edits each tier's model alias and effort, the activity overrides
65
65
  | Credits cap | $0.50, $1, $2, $5 | Largest estimated cold write on a `credits` model. |
66
66
  | Activity threshold | 50%, 60%, 70%, 80% | `policy.activityMass`: the least probability at which an activity applies. |
67
67
 
68
- The Routes tab starts with the **Activity routing** selector, `off · on`, and a hint for the mode, and a yellow line when the overrides do not run: activity routing is `off`, routing is off, or routing is unavailable. Below it is one grid of the draft: a column per tier, the **every turn** row with each tier's own route, and a row per activity whose cells show the route it runs (`models key·effort`, such as `sonnet·high`), `·` for the tier's route, `°` for a built-in default, and **●** for an unsaved edit. Each cell is a plain Button; selecting one opens its editor under the grid: a model and an effort Select, the cell's state, **Use tier model** to drop an override, and **Restore default** for a changed or dropped built-in one. A dropped built-in override is saved as the tier's own route, because a file that only omitted it would get the built-in back. Yellow notes flag a cell stronger than the tier above, and the only cell on its cache, which adds one; a cell equal to its tier's route but saved in the file says `no effect`. A line counts the prompt caches the routes use, one per model where efforts share a cache and one per (model, effort) pair where they do not, counting only tier routes until the mode is `on`, and another flags two neighbouring tiers with the same route. **Reset routes to defaults** resets the tier routes and the baseline tier; pending override and mode edits stay in the draft. The Policy tab writes each control inside its sentence and names the default beside a changed value, and ends with the `subagentRouting` mode, which is set in `router.json`. The Usage tab's **BY ACTIVITY** table adds each activity's `est. cost`, its replies at list prices, and the route it was `mostly on`; the Classifier tab's **ACROSS SESSIONS** adds the escalations after a cheaper activity move. The Usage tab's **Reset stats** clears the activity counts and routing vs your model, for this session and across sessions.
68
+ The Routes tab starts with the **Activity routing** selector, `off · on`, and a hint for the mode, and a yellow line when the overrides do not run: activity routing is `off`, routing is off, or routing is unavailable. Below it is one grid of the draft: a column per tier, the **every turn** row with each tier's own route, and a row per activity whose cells show the route it runs (`models key·effort`, such as `sonnet·high`), `·` for the tier's route, `°` for a built-in default, and **●** for an unsaved edit. Each cell is a plain Button; selecting one opens its editor under the grid: a model and an effort Select, the cell's state, **Use tier model** to drop an override, and **Restore default** for a changed or dropped built-in one. A dropped built-in override is saved as the tier's own route, because a file that only omitted it would get the built-in back. Yellow notes flag a cell stronger than the tier above, and the only cell on its cache, which adds one; a cell equal to its tier's route but saved in the file says `no effect`. A line counts the prompt caches the routes use, one per model where efforts share a cache and one per (model, effort) pair where they do not, counting only tier routes until the mode is `on`, and another flags two neighbouring tiers with the same route. **Reset routes to defaults** resets the tier routes and the baseline tier; pending override and mode edits stay in the draft. The Policy tab writes each control inside its sentence and names the default beside a changed value, and ends with the `subagentRouting` mode, which is set in `router.json`. The Usage tab's breakdown by activity gives each activity's cost at list prices and the route it was `mostly on`; the Classifier tab's **ACROSS SESSIONS** adds the escalations after a cheaper activity move. The Usage tab's **Delete history** deletes the activity counts, the usage and the subagent records, for this session and across sessions.
69
69
 
70
70
  The Classifier tab lists every configured classifier as a row with its service host (`this machine` for a local one), its activity probe and p95 wait, and whether its key and endpoint settings are complete. Selecting a row writes `classifier` to `router.json` at once, or removes it for the default, through the same validation, and resets the new classifier's failure count. A turn already being classified finishes with its own classifier; its readings stay off the pane. **Undo** returns to the previous classifier. The deadline saves at once too, and a built-in classifier's default deadline is written as no override. **Sends** names the host that receives prompt text. The **Deadline** line shows the active classifier's p95 wait across sessions, or its probe's before any turn, in yellow when it is slower than the deadline.
71
71
 
@@ -1,12 +1,12 @@
1
- <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 594 458" role="img" aria-labelledby="title desc">
1
+ <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 657 458" role="img" aria-labelledby="title desc">
2
2
  <title id="title">Router pane, Now tab</title>
3
3
  <desc id="desc">What runs next turn: tier, model and activity, with the reason and the classifier support it weighed; classifier support per tier with pin buttons; the last 20 replies colored by tier with the switch count and the replies per tier and per activity; and context, cache and cost.</desc>
4
4
  <style>
5
5
  text { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, 'Liberation Mono', monospace; font-size: 13px; }
6
6
  .cap { font-family: system-ui, -apple-system, 'Segoe UI', sans-serif; font-size: 12px; fill: #9a988f; }
7
7
  </style>
8
- <rect width="594" height="458" rx="8" fill="#1c1c1c"/>
9
- <rect x="10" y="10" width="574" height="438" rx="6" fill="none" stroke="#3f5f8f"/>
8
+ <rect width="657" height="458" rx="8" fill="#1c1c1c"/>
9
+ <rect x="10" y="10" width="637" height="438" rx="6" fill="none" stroke="#3f5f8f"/>
10
10
  <text x="24.0" y="34" fill="#5fafd7" font-weight="700" xml:space="preserve">ROUTING</text>
11
11
  <rect x="94.2" y="20" width="62.4" height="18" rx="4" fill="#87afff"/>
12
12
  <text x="94.2" y="34" fill="#0d1016" font-weight="700" xml:space="preserve">[ ◉ on ]</text>
@@ -104,7 +104,9 @@
104
104
  <text x="94.2" y="414" fill="#87d787" xml:space="preserve">100% reused on the last reply</text>
105
105
  <text x="320.4" y="414" fill="#7c7c7c" xml:space="preserve"> · </text>
106
106
  <text x="359.4" y="414" fill="#d0d0d0" xml:space="preserve">cost $18.003 </text>
107
- <text x="460.8" y="414" fill="#7c7c7c" xml:space="preserve">by Claude</text>
107
+ <text x="460.8" y="414" fill="#7c7c7c" xml:space="preserve">by Claude </text>
108
+ <rect x="546.6" y="400" width="85.8" height="18" rx="4" fill="#2e3340"/>
109
+ <text x="546.6" y="414" fill="#d0d0d0" xml:space="preserve">[ details ]</text>
108
110
  <rect x="24.0" y="419" width="70.2" height="18" rx="4" fill="#2e3340"/>
109
111
  <text x="24.0" y="433" fill="#d0d0d0" xml:space="preserve">[ Close ]</text>
110
112
  </svg>
@@ -0,0 +1,133 @@
1
+ <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 672 819" role="img" aria-labelledby="title desc">
2
+ <title id="title">Router pane, Usage tab, What if</title>
3
+ <desc id="desc">This session by tier, with What if: the same tokens on Haiku 5.5, Sonnet 5.5 and Opus 5.5 alone against what routing spent.</desc>
4
+ <style>
5
+ text { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, 'Liberation Mono', monospace; font-size: 13px; }
6
+ .cap { font-family: system-ui, -apple-system, 'Segoe UI', sans-serif; font-size: 12px; fill: #9a988f; }
7
+ </style>
8
+ <rect width="672" height="819" rx="8" fill="#1c1c1c"/>
9
+ <rect x="10" y="10" width="652" height="799" rx="6" fill="none" stroke="#3f5f8f"/>
10
+ <text x="24.0" y="34" fill="#5fafd7" font-weight="700" xml:space="preserve">ROUTING</text>
11
+ <rect x="94.2" y="20" width="62.4" height="18" rx="4" fill="#87afff"/>
12
+ <text x="94.2" y="34" fill="#0d1016" font-weight="700" xml:space="preserve">[ ◉ on ]</text>
13
+ <rect x="164.4" y="20" width="70.2" height="18" rx="4" fill="#2e3340"/>
14
+ <text x="164.4" y="34" fill="#d0d0d0" xml:space="preserve">[ ○ off ]</text>
15
+ <text x="250.2" y="34" fill="#87d787" xml:space="preserve">Jev ready · 347 ms</text>
16
+ <rect x="24.0" y="39" width="54.6" height="18" rx="4" fill="#2e3340"/>
17
+ <text x="24.0" y="53" fill="#d0d0d0" xml:space="preserve">[ Now ]</text>
18
+ <rect x="86.4" y="39" width="78.0" height="18" rx="4" fill="#2e3340"/>
19
+ <text x="86.4" y="53" fill="#d0d0d0" xml:space="preserve">[ Routes ]</text>
20
+ <rect x="172.2" y="39" width="78.0" height="18" rx="4" fill="#2e3340"/>
21
+ <text x="172.2" y="53" fill="#d0d0d0" xml:space="preserve">[ Policy ]</text>
22
+ <rect x="258.0" y="39" width="109.2" height="18" rx="4" fill="#2e3340"/>
23
+ <text x="258.0" y="53" fill="#d0d0d0" xml:space="preserve">[ Classifier ]</text>
24
+ <rect x="375.0" y="39" width="70.2" height="18" rx="4" fill="#87afff"/>
25
+ <text x="375.0" y="53" fill="#0d1016" font-weight="700" xml:space="preserve">[ Usage ]</text>
26
+ <rect x="453.0" y="39" width="39.0" height="18" rx="4" fill="#2e3340"/>
27
+ <text x="453.0" y="53" fill="#d0d0d0" xml:space="preserve">[ ? ]</text>
28
+ <rect x="24.0" y="77" width="85.8" height="18" rx="4" fill="#87afff"/>
29
+ <text x="24.0" y="91" fill="#0d1016" font-weight="700" xml:space="preserve">[ Session ]</text>
30
+ <rect x="117.6" y="77" width="70.2" height="18" rx="4" fill="#2e3340"/>
31
+ <text x="117.6" y="91" fill="#d0d0d0" xml:space="preserve">[ Today ]</text>
32
+ <rect x="195.6" y="77" width="46.8" height="18" rx="4" fill="#2e3340"/>
33
+ <text x="195.6" y="91" fill="#d0d0d0" xml:space="preserve">[ 7d ]</text>
34
+ <rect x="250.2" y="77" width="54.6" height="18" rx="4" fill="#2e3340"/>
35
+ <text x="250.2" y="91" fill="#d0d0d0" xml:space="preserve">[ 30d ]</text>
36
+ <rect x="312.6" y="77" width="70.2" height="18" rx="4" fill="#2e3340"/>
37
+ <text x="312.6" y="91" fill="#d0d0d0" xml:space="preserve">[ Month ]</text>
38
+ <rect x="390.6" y="77" width="54.6" height="18" rx="4" fill="#2e3340"/>
39
+ <text x="390.6" y="91" fill="#d0d0d0" xml:space="preserve">[ All ]</text>
40
+ <text x="453.0" y="91" fill="#7c7c7c" xml:space="preserve"> p next</text>
41
+ <text x="24.0" y="110" fill="#7c7c7c" xml:space="preserve">this session · your model </text>
42
+ <text x="226.8" y="110" fill="#e0708a" font-weight="700" xml:space="preserve">Opus 5.5 · xhigh</text>
43
+ <text x="24.0" y="148" fill="#d0d0d0" xml:space="preserve">Routing saved </text>
44
+ <text x="133.2" y="148" fill="#6fcf97" font-weight="700" xml:space="preserve">$1.34 (46%)</text>
45
+ <text x="219.0" y="148" fill="#d0d0d0" xml:space="preserve"> vs your model</text>
46
+ <text x="55.2" y="186" fill="#d0d0d0" xml:space="preserve">Your model</text>
47
+ <text x="211.2" y="186" fill="#d0d0d0" xml:space="preserve"> $2.92</text>
48
+ <text x="304.8" y="186" fill="#e0708a" font-weight="700" xml:space="preserve">Opus 5.5 · xhigh</text>
49
+ <text x="24.0" y="205" fill="#7c7c7c" xml:space="preserve"> − </text>
50
+ <text x="55.2" y="205" fill="#d0d0d0" xml:space="preserve">Cheaper models</text>
51
+ <text x="211.2" y="205" fill="#6fcf97" xml:space="preserve"> $1.40</text>
52
+ <text x="24.0" y="224" fill="#7c7c7c" xml:space="preserve"> + </text>
53
+ <text x="55.2" y="224" fill="#d0d0d0" xml:space="preserve">Stronger models</text>
54
+ <text x="211.2" y="224" fill="#d0d0d0" xml:space="preserve"> $0.00</text>
55
+ <text x="24.0" y="243" fill="#7c7c7c" xml:space="preserve"> + </text>
56
+ <text x="55.2" y="243" fill="#d0d0d0" xml:space="preserve">Switch cache writes</text>
57
+ <text x="211.2" y="243" fill="#f0b429" xml:space="preserve"> $0.06</text>
58
+ <text x="304.8" y="243" fill="#7c7c7c" xml:space="preserve">3 route switches · 4% of the saving</text>
59
+ <text x="24.0" y="262" fill="#7c7c7c" xml:space="preserve"> = </text>
60
+ <text x="55.2" y="262" fill="#d0d0d0" font-weight="700" xml:space="preserve">Routed</text>
61
+ <text x="211.2" y="262" fill="#d0d0d0" font-weight="700" xml:space="preserve"> $1.58</text>
62
+ <text x="304.8" y="262" fill="#5fafd7" xml:space="preserve">████████████</text>
63
+ <text x="398.4" y="262" fill="#7c7c7c" xml:space="preserve">░░░░░░░░░░</text>
64
+ <text x="476.4" y="262" fill="#7c7c7c" xml:space="preserve"> 54% of your model</text>
65
+ <text x="24.0" y="300" fill="#7c7c7c" xml:space="preserve"> 24 replies · 8 turns · input 1.66M · cache hit 90% · output 21.6K</text>
66
+ <text x="24.0" y="338" fill="#5fafd7" font-weight="700" xml:space="preserve">BY </text>
67
+ <rect x="55.2" y="324" width="93.6" height="18" rx="4" fill="#2e3340"/>
68
+ <text x="55.2" y="338" fill="#d0d0d0" xml:space="preserve">[ Activity ]</text>
69
+ <rect x="156.6" y="324" width="70.2" height="18" rx="4" fill="#2e3340"/>
70
+ <text x="156.6" y="338" fill="#d0d0d0" xml:space="preserve">[ Model ]</text>
71
+ <rect x="234.6" y="324" width="62.4" height="18" rx="4" fill="#87afff"/>
72
+ <text x="234.6" y="338" fill="#0d1016" font-weight="700" xml:space="preserve">[ Tier ]</text>
73
+ <text x="304.8" y="338" fill="#7c7c7c" xml:space="preserve"> g next</text>
74
+ <text x="24.0" y="357" fill="#7c7c7c" xml:space="preserve"> replies cost vs yours mostly on</text>
75
+ <text x="39.6" y="376" fill="#d0d0d0" xml:space="preserve">▸</text>
76
+ <text x="55.2" y="376" fill="#d7af5f" font-weight="700" xml:space="preserve">medium</text>
77
+ <text x="211.2" y="376" fill="#d0d0d0" xml:space="preserve"> 10 $0.80</text>
78
+ <text x="351.6" y="376" fill="#6fcf97" xml:space="preserve"> −$0.50</text>
79
+ <text x="437.4" y="376" fill="#7c7c7c" xml:space="preserve"> Sonnet 5.5 · high</text>
80
+ <text x="39.6" y="395" fill="#d0d0d0" xml:space="preserve">▸</text>
81
+ <text x="55.2" y="395" fill="#e0708a" font-weight="700" xml:space="preserve">high</text>
82
+ <text x="211.2" y="395" fill="#d0d0d0" xml:space="preserve"> 4 $0.52</text>
83
+ <text x="351.6" y="395" fill="#d0d0d0" xml:space="preserve"> $0.00</text>
84
+ <text x="437.4" y="395" fill="#7c7c7c" xml:space="preserve"> Opus 5.5 · xhigh</text>
85
+ <text x="39.6" y="414" fill="#d0d0d0" xml:space="preserve">▸</text>
86
+ <text x="55.2" y="414" fill="#5f9fe0" font-weight="700" xml:space="preserve">low</text>
87
+ <text x="211.2" y="414" fill="#d0d0d0" xml:space="preserve"> 8 $0.23</text>
88
+ <text x="351.6" y="414" fill="#6fcf97" xml:space="preserve"> −$0.69</text>
89
+ <text x="437.4" y="414" fill="#7c7c7c" xml:space="preserve"> Haiku 5.5 · high</text>
90
+ <text x="39.6" y="433" fill="#d0d0d0" xml:space="preserve">▸</text>
91
+ <text x="55.2" y="433" fill="#5fd7af" font-weight="700" xml:space="preserve">micro</text>
92
+ <text x="211.2" y="433" fill="#d0d0d0" xml:space="preserve"> 2 $0.02</text>
93
+ <text x="351.6" y="433" fill="#6fcf97" xml:space="preserve"> −$0.16</text>
94
+ <text x="437.4" y="433" fill="#7c7c7c" xml:space="preserve"> Haiku 5.5 · low</text>
95
+ <text x="24.0" y="471" fill="#5fafd7" font-weight="700" xml:space="preserve">WHAT IF</text>
96
+ <text x="78.6" y="471" fill="#7c7c7c" xml:space="preserve"> · the same tokens on one model </text>
97
+ <rect x="343.8" y="457" width="70.2" height="18" rx="4" fill="#2e3340"/>
98
+ <text x="343.8" y="471" fill="#d0d0d0" xml:space="preserve">[ Trend ]</text>
99
+ <text x="39.6" y="490" fill="#d0d0d0" xml:space="preserve">Haiku 5.5</text>
100
+ <text x="211.2" y="490" fill="#7c7c7c" xml:space="preserve">████</text>
101
+ <text x="382.8" y="490" fill="#d0d0d0" xml:space="preserve"> $0.58</text>
102
+ <text x="453.0" y="490" fill="#6fcf97" xml:space="preserve"> −$2.34</text>
103
+ <text x="39.6" y="509" fill="#d0d0d0" font-weight="700" xml:space="preserve">Routed</text>
104
+ <text x="211.2" y="509" fill="#5fafd7" xml:space="preserve">████████████</text>
105
+ <text x="382.8" y="509" fill="#d0d0d0" xml:space="preserve"> $1.58</text>
106
+ <text x="39.6" y="528" fill="#d0d0d0" xml:space="preserve">Sonnet 5.5</text>
107
+ <text x="211.2" y="528" fill="#7c7c7c" xml:space="preserve">█████████████</text>
108
+ <text x="382.8" y="528" fill="#d0d0d0" xml:space="preserve"> $1.75</text>
109
+ <text x="453.0" y="528" fill="#6fcf97" xml:space="preserve"> −$1.17</text>
110
+ <text x="39.6" y="547" fill="#d0d0d0" xml:space="preserve">Opus 5.5 · yours</text>
111
+ <text x="211.2" y="547" fill="#7c7c7c" xml:space="preserve">██████████████████████</text>
112
+ <text x="382.8" y="547" fill="#d0d0d0" xml:space="preserve"> $2.92</text>
113
+ <text x="453.0" y="547" fill="#7c7c7c" xml:space="preserve"> —</text>
114
+ <text x="24.0" y="566" fill="#7c7c7c" xml:space="preserve"> same tokens and output on each model alone · answer quality not measured</text>
115
+ <text x="24.0" y="604" fill="#5fafd7" font-weight="700" xml:space="preserve">WORTH A LOOK</text>
116
+ <text x="117.6" y="604" fill="#7c7c7c" xml:space="preserve"> · from the numbers; answer quality is not measured</text>
117
+ <text x="39.6" y="623" fill="#d7875f" font-style="italic" xml:space="preserve">coding</text>
118
+ <text x="86.4" y="623" fill="#7c7c7c" xml:space="preserve"> · </text>
119
+ <text x="109.8" y="623" fill="#d7af5f" font-weight="700" xml:space="preserve">medium</text>
120
+ <text x="156.6" y="623" fill="#d0d0d0" xml:space="preserve"> carried 51% of the cost</text>
121
+ <text x="343.8" y="623" fill="#7c7c7c" xml:space="preserve"> · mostly Sonnet 5.5 · high</text>
122
+ <rect x="570.0" y="609" width="78.0" height="18" rx="4" fill="#2e3340"/>
123
+ <text x="570.0" y="623" fill="#d0d0d0" xml:space="preserve">[ Routes ]</text>
124
+ <text x="24.0" y="661" fill="#5fafd7" font-weight="700" xml:space="preserve">SUBAGENTS · across sessions</text>
125
+ <text x="234.6" y="661" fill="#7c7c7c" xml:space="preserve"> subagent routing on</text>
126
+ <text x="24.0" y="680" fill="#7c7c7c" xml:space="preserve"> no subagents yet</text>
127
+ <text x="24.0" y="718" fill="#7c7c7c" xml:space="preserve"> API list prices · same tokens and output length · not a bill;</text>
128
+ <text x="24.0" y="737" fill="#7c7c7c" xml:space="preserve"> on a Claude plan it stands for quota · answer quality not measured</text>
129
+ <rect x="24.0" y="761" width="140.4" height="18" rx="4" fill="#2e3340"/>
130
+ <text x="24.0" y="775" fill="#7c7c7c" xml:space="preserve">[ Delete history ]</text>
131
+ <rect x="24.0" y="780" width="70.2" height="18" rx="4" fill="#2e3340"/>
132
+ <text x="24.0" y="794" fill="#d0d0d0" xml:space="preserve">[ Close ]</text>
133
+ </svg>