slash-tokens 1.7.0 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [1.8.0] — The Merge Gate Edition
+
+*2026-10-11*
+
+Know what a change will cost before it merges.
+
+New: `slash-tokens diff`, a quality floor per job, the output cap passed to your client, and no older-generation swaps by default. `/auto` routing is unchanged. No price change.
+
+### Added
+- **`slash-tokens diff <base> [head] [--json]`**: what a git change does to the scan's monthly LLM cost. It scans both refs of the repo in the current folder (head defaults to the working tree, so uncommitted edits count), and reports call sites and monthly cost at each, the change, and each file whose LLM calls or cost moved, largest first. Same assumptions as the scan (100 calls a site a day, output twice the input). `--json` is for CI. CLI only: it uses git, so it isn't in the library entry (which runs in browsers and Workers).
+- **`hire().run()` tells your client the job's output cap.** `call(model, input, { maxOutputTokens })`: send it as the provider's max-tokens so the bill can't pass the quote. Two-argument clients keep working.
+- **A quality floor per job.** `run({ …, floor })` overrides the agent's floor for that job, so one agent can plan on the flagship (floor 3) and edit on a mid-tier model (floor 2).
+- The diff's per-file line reads "0 → 1 site" (was "sites").
+- `estimateMonthly(sites)` in `report.ts`: the scan's monthly cost as one function, shared by the scan report and `diff`. The scan's numbers are unchanged.
+
+### Changed
+- **`decide()` won't swap in an older generation of the same line by default.** A tier is the vendor's product line, not its generation, so "same tier" alone didn't mean "as good": at the default floor Gemini 3.8 Flash was swapped for 2.5 Flash. Each catalog model now has a `gen` (Claude 4.5 < 5 < 5.5, Gemini 2.5 < 3.8, GPT-5.4 < 6, Grok 4.3 < 4.7, Nemotron 3 < 3.5; aliases take the generation they resolve to), and a substitute in the same tier must be the same generation or newer. A smaller current line is still fair game at a lower floor (Opus 5.5 → Haiku, Gemini 3.8 Flash → 3.1 Flash-Lite). `decide(task, { allowOlder: true })` brings back the old behaviour. Newer-generation swaps are unchanged: Opus 4.8 → 5.5, GPT-5.6 Sol → GPT-6 Luna, Nemotron Ultra → 3.5 Lightning. `preflightRoute()` and `/auto` are unchanged.
+- **OSS savings study re-run** (`bench/oss/RESULTS.md`): floor 1 is unchanged (pooled 71%); the default floor reads 29% pooled (was 34%) because Google's 34% was the 3.8 Flash → 2.5 Flash swap this release stops. The study now fails loudly without `rg` instead of writing zeros.
+
+## [1.7.1] — The Hired Agent Edition
+
+*2026-10-10*
+
+The scan counts each real LLM request once.
+
+No change to `quote()`, `decide()`, `reconcile()`, `hire()`, `/auto` or prices.
+
+### Fixed
+- **The scan (`npx slash-tokens`) counts each LLM request once.** It counted every import, client constructor and request line as its own call site, so one `client.messages.create(...)` behind `import Anthropic` and `new Anthropic()` was reported as two sites (and the request itself wasn't matched unless the client variable was named `anthropic`). The monthly estimate is per site, so it came out inflated: a two-request sample project read 4 sites and $35.77/mo in 1.7.0, and reads 2 sites and $17.89/mo now. A request is now one site; a file that only imports or builds a client counts once. Requests on any client variable are matched (`.messages.create(`, `.chat.completions.create(`, `.responses.create(`, `generateText(` …), in Python too.
+- **The scan no longer counts look-alike calls.** Matching any client variable made `.messages.create(` also catch Twilio's SMS API and `.invoke(` catch Tauri / Electron IPC. A request now counts only in a file that uses that SDK (an import or a client: `import anthropic`, `from openai import`, `new Anthropic()`, `AsyncOpenAI()` …), unless the call names the provider itself (`fetch` to an AI API URL, `x.ai/api`, `cohere.chat`). Python Gemini (`generate_content`) is matched too.
+- The scan's footnote reads "1 call site uses an assumed price" (was "use").
+
+### Docs
+- **Accuracy claims now say what was measured.** Request framing is measured on Nebius only; xAI comes from the Grok bench, OpenAI from its tiktoken cookbook, Anthropic and Google are allowances. The npm README's accuracy line, the root README's accuracy gate (GPT-5.x, not all GPT; GPT-6 takes the conservative default) and the `quote()` / `FRAMING` doc comments now say so. The 1.7.0 entry below called all framing "measured" and its live check didn't name Nebius; both are corrected in place.
+- **`TEST-NOTES.md` is current.** It was the v1.4.0 plan: retired models, and a "preflightRoute agrees with /auto" invariant that has been false by design since 1.6.6 (`/auto` is frozen at its 1.6.5 targets). It now maps each invariant to the test that holds it and lists what isn't tested yet. Two of its invariants had no test and now do: `preflightRoute()` never picks a model the prompt doesn't fit, and `intercept.ts` uses the shared `PROVIDER_MODELS`. The `preflightRoute()` tie-break comment now matches the code (lower list price, not list order).
+
 ## [1.7.0] — The Hired Agent Edition
 
 *2026-10-08*
@@ -14,7 +50,7 @@ New: `quote()`, `decide()`, `reconcile()`, `hire().run()`, `slash-tokens quote`,
 - **`reconcile(quote, usage, { baseline, feeRate, waived })`** writes the receipt after a call: estimated vs actual tokens and cost (from the provider's own `usage`, OpenAI-style or Anthropic-style), `underReported` (the estimate counted fewer input tokens than were billed — Slash should never do this), whether the cost stayed within the quote, what was saved against a baseline model, and the agent's fee (10% of measured savings by default, shown and waived by default, never charged on a loss). Cached input is priced at the full input rate, so a cached call's cost is an upper bound.
 - **`hire({ budget, baseline, floor, feeRate, waived }).run(job)`**: the agent you hire. Each job is quoted, booked on the cheapest model the policy allows (or blocked), run through your own `call(model, input)`, and reconciled into a receipt. The budget covers all jobs: each one may spend only what earlier jobs left. Blocked jobs never call the model. `agent.spent`, `agent.remaining`, `agent.receipts`.
 - **`slash-tokens quote --model M [--file F | --text T | stdin] [--max-output N] [--min-output N] [--budget USD] [--floor 1-4] [--json]`** prints the quote and the decision (`--json` for pipelines). Exit 0 for go, downgrade and block (read `action`); 1 for bad input.
-- **Quotes include each provider's request framing.** A provider bills the chat template and system preamble on top of your content. Content-only counting quoted 12 input tokens for a real Nebius call billed 23. `quote()` now adds measured framing: Nebius 16 per request + 7 per extra message (real Token Factory calls, recorded in `bench/results-nemotron-requests.json`), xAI's 193-token system preamble (the Grok bench baseline), OpenAI's 3-per-message rule, and a conservative allowance for Anthropic and Google. Live check after the fix: 4% and 8% over the bill, never under. `tests/request-framing.test.ts` holds every recorded bill. `preflight()` stays a content-only go/no-go.
+- **Quotes include each provider's request framing.** A provider bills the chat template and system preamble on top of your content. Content-only counting quoted 12 input tokens for a real Nebius call billed 23. `quote()` now adds framing: Nebius 16 per request + 7 per extra message, measured (real Token Factory calls, recorded in `bench/results-nemotron-requests.json`), xAI's 193-token system preamble (the Grok bench baseline), OpenAI's 3-per-message rule (its tiktoken cookbook), and a conservative allowance for Anthropic and Google. Two live Nebius calls after the fix: 4% and 8% over the bill, never under. `tests/request-framing.test.ts` holds every recorded bill. `preflight()` stays a content-only go/no-go.
 - **`reconcile()` reads Nebius cache hits** (`prompt_cache_hit_tokens`).
 - **npm metadata:** description now says what 1.7.0 does; keywords add nemotron, nvidia, nebius, agent, cost.
 - **The catalog** (`CATALOG`): one source for every model's prices, context, provider, capability tier (1 small · 2 mid · 3 flagship · 4 frontier — the vendor's own line position, compared within one provider only) and `asOf` date. `MODELS` is now derived from it, with the same keys, order and fields.

package/README.md

@@ -10,7 +10,22 @@
 **Know what an LLM call will cost before you make it, and prove what you saved after.**
 4.8 KB WASM · sub-millisecond · zero dependencies · Claude, GPT, Grok, Gemini, Nemotron.
 
-## v1.7.0 — The Hired Agent Edition
+## v1.8.0 — The Merge Gate Edition
+
+Know what a change will cost before it merges.
+
+```bash
+npx slash-tokens diff main
+# LLM cost of this change (scan estimate, 100 calls a site a day)
+#   main: 1 call site, $8.71/mo
+#   working tree: 2 call sites, $17.29/mo
+#   change: +$8.58/mo
+#   src/summarise.ts (OpenAI): 0 → 1 site, +$8.58/mo
+```
+
+Run it in CI on every merge request (`--json` for pipelines). Also new in 1.8.0: `decide()` never swaps in an older model generation unless you allow it, and `hire()` takes a quality floor per job and tells your client each job's output cap.
+
+## Hire the agent
 
 Quote the job, book the right model, prove it with a receipt.
 
@@ -23,7 +38,7 @@ const { decision, receipt } = await agent.run({
   input: prompt,
   model: 'nemotron-3-ultra',
   maxOutputTokens: 2000,
-  call: (model, input) => yourClient(model, input),  // returns { output, usage }
+  call: (model, input, { maxOutputTokens }) => yourClient(model, input, maxOutputTokens),  // returns { output, usage }
 })
 
 decision.action  // 'downgrade': nemotron-3-super does the job for less
@@ -35,7 +50,7 @@ receipt.saved    // dollars saved against the model you asked for
 - **Prove:** `reconcile()` checks the quote against what the provider billed.
 - **Hire:** `hire()` does all three for every job, inside one budget. Its cut, 10% of measured savings, is on every receipt, waived.
 
-Counts are calibrated against each provider's real tokenizer, quotes add what each provider bills on top of your text, and CI fails if either comes in under the real number.
+Counts are calibrated against each provider's real tokenizer; models not benchmarked yet (GPT-6) get a conservative default. Quotes add what the provider bills on top of your text, measured on Nebius and a conservative allowance elsewhere. CI fails if a count comes in under the real one, or a quote under a real Nebius bill.
 
 ## Install
 
@@ -48,6 +63,7 @@ npm install slash-tokens
 ```bash
 npx slash-tokens   # find the LLM calls in this project and what they cost a month
 echo "Fix the bug" | npx slash-tokens quote --model nemotron-3-ultra --floor 1
+npx slash-tokens diff main      # what this branch does to that monthly cost
 ```
 
 ## Check every call, automatically

package/dist/agent.d.ts

@@ -6,24 +6,31 @@ export interface HireOptions {
     budget?: number;
     /** Model the savings are measured against. Default: the model each job asks for. */
     baseline?: string;
-    /** Lowest tier a substitute may have. Default: each job's requested tier. */
+    /** Lowest tier a substitute may have. A job's own `floor` overrides it. Default: each job's requested tier. */
     floor?: Tier;
     /** The agent's cut of measured savings. Default 0.10. */
     feeRate?: number;
     /** Fee shown on the receipt but not charged. Default true. */
     waived?: boolean;
 }
+/** What hire().run() tells your client about the job, beyond the model and input. */
+export interface CallOptions {
+    /** The job's output ceiling, the quote's high end. Send it as the provider's max-tokens so the bill can't pass the quote. */
+    maxOutputTokens: number;
+}
 /**
  * What the agent calls to do the work: your provider client. `model` is the
  * booked catalog key (e.g. `nemotron-3.5-lightning`); map it to your
  * provider's API ID. Return the output and the provider's `usage` object.
  */
-export type CallModel = (model: string, input: string | Message[]) => Promise<{
+export type CallModel = (model: string, input: string | Message[], opts: CallOptions) => Promise<{
     output: string;
     usage: Usage;
 }>;
 export interface Job extends Task {
     call: CallModel;
+    /** Lowest tier a substitute may have for this job. Default: the agent's floor, else the job's requested tier. */
+    floor?: Tier;
 }
 export interface RunResult {
     decision: Decision;

package/dist/agent.js

@@ -15,14 +15,14 @@ export function hire(opts = {}) {
         get remaining() { return Math.max(budget - spent, 0); },
         get receipts() { return receipts; },
         async run(job) {
-            const { call, ...task } = job;
-            const policy = { floor: opts.floor };
+            const { call, floor, ...task } = job;
+            const policy = { floor: floor ?? opts.floor };
             if (budget !== Infinity)
                 policy.budget = Math.max(budget - spent, 0);
             const decision = decide(task, policy);
             if (decision.action === 'block' || !decision.chosen)
                 return { decision };
-            const { output, usage } = await call(decision.chosen.model, task.input);
+            const { output, usage } = await call(decision.chosen.model, task.input, { maxOutputTokens: decision.chosen.outputTokens.max });
             const receipt = reconcile(decision.chosen, usage, {
                 baseline: opts.baseline ?? decision.requested.model,
                 feeRate: opts.feeRate,

package/dist/catalog.d.ts

@@ -18,6 +18,13 @@ export declare const TIER_NAMES: Record<Tier, string>;
 export interface CatalogEntry {
     provider: string;
     tier: Tier;
+    /**
+     * Model generation within its provider (Claude 4.5 < 5 < 5.5, Gemini 2.5 <
+     * 3.8, GPT-5.4 < 6, Grok 4.3 < 4.7, Nemotron 3 < 3.5). Aliases take the
+     * generation they resolve to (grok-4.20 and grok-4-1-fast → 4.3). decide() won't swap in an older generation
+     * unless the policy allows it.
+     */
+    gen: number;
     /** Date the price was checked against the provider's own pricing page. */
     asOf: string;
     /** Last day this price holds, when the provider has announced a change. */

package/dist/catalog.js

@@ -70,65 +70,65 @@ const NEMOTRON_LIGHTNING = { input: 0.06, output: 0.24, context: 1048576 };
 const ASOF = '2026-10-07';
 // Nemotron: read from the Token Factory API (see above).
 const ASOF_NEBIUS = '2026-10-08';
-function e(provider, tier, price) {
-    return { provider, tier, asOf: provider === 'Nebius' ? ASOF_NEBIUS : ASOF, ...price };
+function e(provider, tier, price, gen) {
+    return { provider, tier, gen, asOf: provider === 'Nebius' ? ASOF_NEBIUS : ASOF, ...price };
 }
 // Order is kept from the 1.6.6 MODELS table (new entries appended), so
 // preflight()'s option ordering for equal costs doesn't move.
 export const CATALOG = {
     // Anthropic — live names + generic aliases (same rates)
-    'claude-fable-5.1': e('Anthropic', 4, FABLE),
-    'claude-fable-5': e('Anthropic', 4, FABLE),
-    'claude-mythos-5.1': e('Anthropic', 4, FABLE),
-    'claude-mythos-5': e('Anthropic', 4, FABLE),
-    'claude-opus-5.5': e('Anthropic', 3, OPUS_55),
-    'claude-opus-5': e('Anthropic', 3, OPUS),
-    'claude-opus-4.8': e('Anthropic', 3, OPUS),
-    'claude-opus': e('Anthropic', 3, OPUS),
-    'claude-opus-4.7': e('Anthropic', 3, OPUS),
-    'claude-opus-4.6': e('Anthropic', 3, OPUS),
-    'claude-opus-4.5': e('Anthropic', 3, OPUS),
-    'claude-sonnet-5.5': e('Anthropic', 2, SONNET),
-    'claude-sonnet-5': e('Anthropic', 2, SONNET),
-    'claude-sonnet': e('Anthropic', 2, SONNET),
-    'claude-sonnet-4.6': e('Anthropic', 2, SONNET_4X),
-    'claude-sonnet-4.5': e('Anthropic', 2, SONNET_4X),
-    'claude-haiku-4.5': e('Anthropic', 1, HAIKU),
-    'claude-haiku': e('Anthropic', 1, HAIKU),
+    'claude-fable-5.1': e('Anthropic', 4, FABLE, 5.1),
+    'claude-fable-5': e('Anthropic', 4, FABLE, 5),
+    'claude-mythos-5.1': e('Anthropic', 4, FABLE, 5.1),
+    'claude-mythos-5': e('Anthropic', 4, FABLE, 5),
+    'claude-opus-5.5': e('Anthropic', 3, OPUS_55, 5.5),
+    'claude-opus-5': e('Anthropic', 3, OPUS, 5),
+    'claude-opus-4.8': e('Anthropic', 3, OPUS, 4.8),
+    'claude-opus': e('Anthropic', 3, OPUS, 5),
+    'claude-opus-4.7': e('Anthropic', 3, OPUS, 4.7),
+    'claude-opus-4.6': e('Anthropic', 3, OPUS, 4.6),
+    'claude-opus-4.5': e('Anthropic', 3, OPUS, 4.5),
+    'claude-sonnet-5.5': e('Anthropic', 2, SONNET, 5.5),
+    'claude-sonnet-5': e('Anthropic', 2, SONNET, 5),
+    'claude-sonnet': e('Anthropic', 2, SONNET, 5),
+    'claude-sonnet-4.6': e('Anthropic', 2, SONNET_4X, 4.6),
+    'claude-sonnet-4.5': e('Anthropic', 2, SONNET_4X, 4.5),
+    'claude-haiku-4.5': e('Anthropic', 1, HAIKU, 4.5),
+    'claude-haiku': e('Anthropic', 1, HAIKU, 4.5),
     // xAI — flagship 4.6, cheap same-provider 4.3. 4.20 / fast are aliases.
-    'grok-4.7': e('xAI', 3, GROK_46),
-    'grok-4.6': e('xAI', 3, GROK_46),
-    'grok-4.5': e('xAI', 3, GROK_46),
-    'grok-build-0.1': e('xAI', 2, GROK_BUILD),
-    'grok-4.3': e('xAI', 2, GROK_43),
-    'grok-4.20': e('xAI', 2, GROK_43),
-    'grok-4-1-fast': e('xAI', 2, GROK_43),
+    'grok-4.7': e('xAI', 3, GROK_46, 4.7),
+    'grok-4.6': e('xAI', 3, GROK_46, 4.6),
+    'grok-4.5': e('xAI', 3, GROK_46, 4.5),
+    'grok-build-0.1': e('xAI', 2, GROK_BUILD, 4.7),
+    'grok-4.3': e('xAI', 2, GROK_43, 4.3),
+    'grok-4.20': e('xAI', 2, GROK_43, 4.3),
+    'grok-4-1-fast': e('xAI', 2, GROK_43, 4.3),
     // Google
-    'gemini-3.1-pro': e('Google', 3, GEMINI_PRO),
-    'gemini-3.1-pro-preview': e('Google', 3, GEMINI_PRO),
-    'gemini-3.8-flash': e('Google', 2, GEMINI_FLASH_3X),
-    'gemini-3.7-flash': e('Google', 2, GEMINI_FLASH_3X),
-    'gemini-3.6-flash': e('Google', 2, GEMINI_FLASH_3X),
-    'gemini-3.5-flash': e('Google', 2, GEMINI_35_FLASH),
-    'gemini-3.1-flash-lite': e('Google', 1, GEMINI_31_FLASH_LITE),
-    'gemini-3.5-flash-lite': e('Google', 1, GEMINI_FLASH),
-    'gemini-2.5-flash': e('Google', 2, GEMINI_FLASH),
+    'gemini-3.1-pro': e('Google', 3, GEMINI_PRO, 3.1),
+    'gemini-3.1-pro-preview': e('Google', 3, GEMINI_PRO, 3.1),
+    'gemini-3.8-flash': e('Google', 2, GEMINI_FLASH_3X, 3.8),
+    'gemini-3.7-flash': e('Google', 2, GEMINI_FLASH_3X, 3.7),
+    'gemini-3.6-flash': e('Google', 2, GEMINI_FLASH_3X, 3.6),
+    'gemini-3.5-flash': e('Google', 2, GEMINI_35_FLASH, 3.5),
+    'gemini-3.1-flash-lite': e('Google', 1, GEMINI_31_FLASH_LITE, 3.1),
+    'gemini-3.5-flash-lite': e('Google', 1, GEMINI_FLASH, 3.5),
+    'gemini-2.5-flash': e('Google', 2, GEMINI_FLASH, 2.5),
     // OpenAI — live 5.6 ladder + GPT-6. 5.4 family kept as aliases (old prices).
-    'gpt-6-astra': e('OpenAI', 4, GPT_6_ASTRA),
-    'gpt-6.1-sol': e('OpenAI', 3, GPT_6_SOL),
-    'gpt-6-sol': e('OpenAI', 3, GPT_6_SOL),
-    'gpt-6-luna': e('OpenAI', 1, GPT_6_LUNA),
-    'gpt-5.6-sol': e('OpenAI', 3, GPT_SOL),
-    'gpt-5.6-terra': e('OpenAI', 2, GPT_TERRA),
-    'gpt-5.6-luna': e('OpenAI', 1, GPT_LUNA),
-    'gpt-5.4': e('OpenAI', 3, GPT_54),
-    'gpt-5.4-mini': e('OpenAI', 2, GPT_54_MINI),
-    'gpt-5.4-nano': e('OpenAI', 1, GPT_54_NANO),
+    'gpt-6-astra': e('OpenAI', 4, GPT_6_ASTRA, 6),
+    'gpt-6.1-sol': e('OpenAI', 3, GPT_6_SOL, 6.1),
+    'gpt-6-sol': e('OpenAI', 3, GPT_6_SOL, 6),
+    'gpt-6-luna': e('OpenAI', 1, GPT_6_LUNA, 6),
+    'gpt-5.6-sol': e('OpenAI', 3, GPT_SOL, 5.6),
+    'gpt-5.6-terra': e('OpenAI', 2, GPT_TERRA, 5.6),
+    'gpt-5.6-luna': e('OpenAI', 1, GPT_LUNA, 5.6),
+    'gpt-5.4': e('OpenAI', 3, GPT_54, 5.4),
+    'gpt-5.4-mini': e('OpenAI', 2, GPT_54_MINI, 5.4),
+    'gpt-5.4-nano': e('OpenAI', 1, GPT_54_NANO, 5.4),
     // NVIDIA Nemotron, served and billed by Nebius Token Factory
-    'nemotron-3-ultra': e('Nebius', 3, NEMOTRON_ULTRA),
-    'nemotron-3-super': e('Nebius', 2, NEMOTRON_SUPER),
-    'nemotron-3-nano': e('Nebius', 1, NEMOTRON_NANO),
-    'nemotron-3.5-lightning': e('Nebius', 1, NEMOTRON_LIGHTNING),
+    'nemotron-3-ultra': e('Nebius', 3, NEMOTRON_ULTRA, 3),
+    'nemotron-3-super': e('Nebius', 2, NEMOTRON_SUPER, 3),
+    'nemotron-3-nano': e('Nebius', 1, NEMOTRON_NANO, 3),
+    'nemotron-3.5-lightning': e('Nebius', 1, NEMOTRON_LIGHTNING, 3.5),
 };
 /**
  * Real API IDs that don't follow the table's naming → table keys.

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { readFileSync as readFileSync2 } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { dirname, join as join3 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/scanner.ts
@@ -112,58 +112,58 @@ var NEMOTRON_NANO = { input: 0.06, output: 0.24, context: 262144 };
 var NEMOTRON_LIGHTNING = { input: 0.06, output: 0.24, context: 1048576 };
 var ASOF = "2026-10-07";
 var ASOF_NEBIUS = "2026-10-08";
-function e(provider, tier, price) {
-  return { provider, tier, asOf: provider === "Nebius" ? ASOF_NEBIUS : ASOF, ...price };
+function e(provider, tier, price, gen) {
+  return { provider, tier, gen, asOf: provider === "Nebius" ? ASOF_NEBIUS : ASOF, ...price };
 }
 var CATALOG = {
-  "claude-fable-5.1": e("Anthropic", 4, FABLE),
-  "claude-fable-5": e("Anthropic", 4, FABLE),
-  "claude-mythos-5.1": e("Anthropic", 4, FABLE),
-  "claude-mythos-5": e("Anthropic", 4, FABLE),
-  "claude-opus-5.5": e("Anthropic", 3, OPUS_55),
-  "claude-opus-5": e("Anthropic", 3, OPUS),
-  "claude-opus-4.8": e("Anthropic", 3, OPUS),
-  "claude-opus": e("Anthropic", 3, OPUS),
-  "claude-opus-4.7": e("Anthropic", 3, OPUS),
-  "claude-opus-4.6": e("Anthropic", 3, OPUS),
-  "claude-opus-4.5": e("Anthropic", 3, OPUS),
-  "claude-sonnet-5.5": e("Anthropic", 2, SONNET),
-  "claude-sonnet-5": e("Anthropic", 2, SONNET),
-  "claude-sonnet": e("Anthropic", 2, SONNET),
-  "claude-sonnet-4.6": e("Anthropic", 2, SONNET_4X),
-  "claude-sonnet-4.5": e("Anthropic", 2, SONNET_4X),
-  "claude-haiku-4.5": e("Anthropic", 1, HAIKU),
-  "claude-haiku": e("Anthropic", 1, HAIKU),
-  "grok-4.7": e("xAI", 3, GROK_46),
-  "grok-4.6": e("xAI", 3, GROK_46),
-  "grok-4.5": e("xAI", 3, GROK_46),
-  "grok-build-0.1": e("xAI", 2, GROK_BUILD),
-  "grok-4.3": e("xAI", 2, GROK_43),
-  "grok-4.20": e("xAI", 2, GROK_43),
-  "grok-4-1-fast": e("xAI", 2, GROK_43),
-  "gemini-3.1-pro": e("Google", 3, GEMINI_PRO),
-  "gemini-3.1-pro-preview": e("Google", 3, GEMINI_PRO),
-  "gemini-3.8-flash": e("Google", 2, GEMINI_FLASH_3X),
-  "gemini-3.7-flash": e("Google", 2, GEMINI_FLASH_3X),
-  "gemini-3.6-flash": e("Google", 2, GEMINI_FLASH_3X),
-  "gemini-3.5-flash": e("Google", 2, GEMINI_35_FLASH),
-  "gemini-3.1-flash-lite": e("Google", 1, GEMINI_31_FLASH_LITE),
-  "gemini-3.5-flash-lite": e("Google", 1, GEMINI_FLASH),
-  "gemini-2.5-flash": e("Google", 2, GEMINI_FLASH),
-  "gpt-6-astra": e("OpenAI", 4, GPT_6_ASTRA),
-  "gpt-6.1-sol": e("OpenAI", 3, GPT_6_SOL),
-  "gpt-6-sol": e("OpenAI", 3, GPT_6_SOL),
-  "gpt-6-luna": e("OpenAI", 1, GPT_6_LUNA),
-  "gpt-5.6-sol": e("OpenAI", 3, GPT_SOL),
-  "gpt-5.6-terra": e("OpenAI", 2, GPT_TERRA),
-  "gpt-5.6-luna": e("OpenAI", 1, GPT_LUNA),
-  "gpt-5.4": e("OpenAI", 3, GPT_54),
-  "gpt-5.4-mini": e("OpenAI", 2, GPT_54_MINI),
-  "gpt-5.4-nano": e("OpenAI", 1, GPT_54_NANO),
-  "nemotron-3-ultra": e("Nebius", 3, NEMOTRON_ULTRA),
-  "nemotron-3-super": e("Nebius", 2, NEMOTRON_SUPER),
-  "nemotron-3-nano": e("Nebius", 1, NEMOTRON_NANO),
-  "nemotron-3.5-lightning": e("Nebius", 1, NEMOTRON_LIGHTNING)
+  "claude-fable-5.1": e("Anthropic", 4, FABLE, 5.1),
+  "claude-fable-5": e("Anthropic", 4, FABLE, 5),
+  "claude-mythos-5.1": e("Anthropic", 4, FABLE, 5.1),
+  "claude-mythos-5": e("Anthropic", 4, FABLE, 5),
+  "claude-opus-5.5": e("Anthropic", 3, OPUS_55, 5.5),
+  "claude-opus-5": e("Anthropic", 3, OPUS, 5),
+  "claude-opus-4.8": e("Anthropic", 3, OPUS, 4.8),
+  "claude-opus": e("Anthropic", 3, OPUS, 5),
+  "claude-opus-4.7": e("Anthropic", 3, OPUS, 4.7),
+  "claude-opus-4.6": e("Anthropic", 3, OPUS, 4.6),
+  "claude-opus-4.5": e("Anthropic", 3, OPUS, 4.5),
+  "claude-sonnet-5.5": e("Anthropic", 2, SONNET, 5.5),
+  "claude-sonnet-5": e("Anthropic", 2, SONNET, 5),
+  "claude-sonnet": e("Anthropic", 2, SONNET, 5),
+  "claude-sonnet-4.6": e("Anthropic", 2, SONNET_4X, 4.6),
+  "claude-sonnet-4.5": e("Anthropic", 2, SONNET_4X, 4.5),
+  "claude-haiku-4.5": e("Anthropic", 1, HAIKU, 4.5),
+  "claude-haiku": e("Anthropic", 1, HAIKU, 4.5),
+  "grok-4.7": e("xAI", 3, GROK_46, 4.7),
+  "grok-4.6": e("xAI", 3, GROK_46, 4.6),
+  "grok-4.5": e("xAI", 3, GROK_46, 4.5),
+  "grok-build-0.1": e("xAI", 2, GROK_BUILD, 4.7),
+  "grok-4.3": e("xAI", 2, GROK_43, 4.3),
+  "grok-4.20": e("xAI", 2, GROK_43, 4.3),
+  "grok-4-1-fast": e("xAI", 2, GROK_43, 4.3),
+  "gemini-3.1-pro": e("Google", 3, GEMINI_PRO, 3.1),
+  "gemini-3.1-pro-preview": e("Google", 3, GEMINI_PRO, 3.1),
+  "gemini-3.8-flash": e("Google", 2, GEMINI_FLASH_3X, 3.8),
+  "gemini-3.7-flash": e("Google", 2, GEMINI_FLASH_3X, 3.7),
+  "gemini-3.6-flash": e("Google", 2, GEMINI_FLASH_3X, 3.6),
+  "gemini-3.5-flash": e("Google", 2, GEMINI_35_FLASH, 3.5),
+  "gemini-3.1-flash-lite": e("Google", 1, GEMINI_31_FLASH_LITE, 3.1),
+  "gemini-3.5-flash-lite": e("Google", 1, GEMINI_FLASH, 3.5),
+  "gemini-2.5-flash": e("Google", 2, GEMINI_FLASH, 2.5),
+  "gpt-6-astra": e("OpenAI", 4, GPT_6_ASTRA, 6),
+  "gpt-6.1-sol": e("OpenAI", 3, GPT_6_SOL, 6.1),
+  "gpt-6-sol": e("OpenAI", 3, GPT_6_SOL, 6),
+  "gpt-6-luna": e("OpenAI", 1, GPT_6_LUNA, 6),
+  "gpt-5.6-sol": e("OpenAI", 3, GPT_SOL, 5.6),
+  "gpt-5.6-terra": e("OpenAI", 2, GPT_TERRA, 5.6),
+  "gpt-5.6-luna": e("OpenAI", 1, GPT_LUNA, 5.6),
+  "gpt-5.4": e("OpenAI", 3, GPT_54, 5.4),
+  "gpt-5.4-mini": e("OpenAI", 2, GPT_54_MINI, 5.4),
+  "gpt-5.4-nano": e("OpenAI", 1, GPT_54_NANO, 5.4),
+  "nemotron-3-ultra": e("Nebius", 3, NEMOTRON_ULTRA, 3),
+  "nemotron-3-super": e("Nebius", 2, NEMOTRON_SUPER, 3),
+  "nemotron-3-nano": e("Nebius", 1, NEMOTRON_NANO, 3),
+  "nemotron-3.5-lightning": e("Nebius", 1, NEMOTRON_LIGHTNING, 3.5)
 };
 var API_ALIASES = {
   "nvidia/nemotron-3-ultra-550b-a55b": "nemotron-3-ultra",
@@ -173,7 +173,7 @@ var API_ALIASES = {
 };
 
 // src/models.ts
-var MODELS = Object.fromEntries(Object.entries(CATALOG).map(([name, { provider: _p, tier: _t, asOf: _a, priceUntil: _u, ...price }]) => [name, price]));
+var MODELS = Object.fromEntries(Object.entries(CATALOG).map(([name, { provider: _p, tier: _t, gen: _g, asOf: _a, priceUntil: _u, ...price }]) => [name, price]));
 function canonicalModel(name) {
   if (MODELS[name])
     return name;
@@ -265,16 +265,16 @@ function slash(content, model) {
 
 // src/patterns.ts
 var AI_PATTERNS = [
-  { name: "OpenAI", regex: /openai\.chat\.completions\.create|new OpenAI\(|from\s+['"]openai['"]/g },
-  { name: "Anthropic", regex: /anthropic\.messages\.create|new Anthropic\(|from\s+['"]@anthropic-ai/g },
-  { name: "Vercel AI", regex: /from\s+['"]ai['"]|generateText|streamText|generateObject/g },
-  { name: "LangChain", regex: /from\s+['"]langchain|ChatOpenAI|ChatAnthropic|\.invoke\(/g },
-  { name: "Gemini", regex: /GoogleGenerativeAI|generateContent|from\s+['"]@google\/generative/g },
-  { name: "Bedrock", regex: /BedrockRuntimeClient|InvokeModelCommand/g },
-  { name: "Grok", regex: /x\.ai\/api|xai\.chat|from\s+['"]grok/g },
-  { name: "fetch (AI)", regex: /fetch\(.*api\.openai\.com|fetch\(.*api\.anthropic\.com|fetch\(.*generativelanguage\.googleapis/g },
-  { name: "Cohere", regex: /from\s+['"]cohere|CohereClient|cohere\.chat/g },
-  { name: "Mistral", regex: /from\s+['"]@mistralai|MistralClient/g }
+  { name: "OpenAI", call: /\.(?:chat\.completions|responses)\.create\(/g, uses: /\b(?:Async|Azure)?OpenAI\(|from\s+['"]openai['"]|^\s*(?:from\s+openai\s+import|import\s+openai)\b/gm },
+  { name: "Anthropic", call: /\.messages\.(?:create|stream)\(/g, uses: /\b(?:Async)?Anthropic\(|from\s+['"]@anthropic-ai|^\s*(?:from\s+anthropic\s+import|import\s+anthropic)\b/gm },
+  { name: "Vercel AI", call: /\b(?:generateText|streamText|generateObject|streamObject)\(/g, uses: /from\s+['"]ai['"]/g },
+  { name: "LangChain", call: /\.invoke\(/g, uses: /from\s+['"]@?langchain|^\s*(?:from|import)\s+langchain|ChatOpenAI|ChatAnthropic/gm },
+  { name: "Gemini", call: /\.(?:generateContent(?:Stream)?|generate_content(?:_stream)?)\(/g, uses: /GoogleGenerativeAI|from\s+['"]@google\/gen|^\s*(?:import\s+google\.generativeai|from\s+google(?:\.genai|\s+import\s+genai))/gm },
+  { name: "Bedrock", call: /InvokeModelCommand\(/g, uses: /BedrockRuntimeClient/g },
+  { name: "Grok", call: /x\.ai\/api|xai\.chat/g, uses: /from\s+['"]grok/g, standalone: true },
+  { name: "fetch (AI)", call: /fetch\(.*api\.openai\.com|fetch\(.*api\.anthropic\.com|fetch\(.*generativelanguage\.googleapis/g, standalone: true },
+  { name: "Cohere", call: /cohere\.chat/g, uses: /from\s+['"]cohere|CohereClient/g, standalone: true },
+  { name: "Mistral", uses: /from\s+['"]@mistralai|MistralClient/g }
 ];
 var SDK_REPRESENTATIVE_MODEL = {
   Anthropic: "claude-sonnet-5",
@@ -337,32 +337,41 @@ function walkDir(dir, files) {
     }
   }
 }
+function matchLines(regex, content) {
+  if (!regex)
+    return [];
+  const found = [];
+  regex.lastIndex = 0;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const line = content.substring(0, match.index).split(`
+`).length;
+    if (!found.includes(line))
+      found.push(line);
+  }
+  return found;
+}
 function findCallSites(filePath, content) {
   const sites = [];
   const lines = content.split(`
 `);
   for (const pattern of AI_PATTERNS) {
-    pattern.regex.lastIndex = 0;
-    let match;
-    while ((match = pattern.regex.exec(content)) !== null) {
-      const beforeMatch = content.substring(0, match.index);
-      const lineNum = beforeMatch.split(`
-`).length;
+    const usesLines = matchLines(pattern.uses, content);
+    const callLines = pattern.standalone || !pattern.uses || usesLines.length > 0 ? matchLines(pattern.call, content) : [];
+    const siteLines = callLines.length > 0 ? callLines : usesLines.slice(0, 1);
+    const estimatedModel = SDK_REPRESENTATIVE_MODEL[pattern.name] ?? UNKNOWN_SDK_REPRESENTATIVE_MODEL;
+    for (const lineNum of siteLines) {
       const startLine = Math.max(0, lineNum - 5);
       const endLine = Math.min(lines.length, lineNum + 20);
       const context = lines.slice(startLine, endLine).join(`
 `);
-      const estimatedModel = SDK_REPRESENTATIVE_MODEL[pattern.name] ?? UNKNOWN_SDK_REPRESENTATIVE_MODEL;
-      const tokensPerCall = slash(context, estimatedModel);
-      if (!sites.some((s) => s.line === lineNum && s.sdk === pattern.name)) {
-        sites.push({
-          file: filePath,
-          line: lineNum,
-          sdk: pattern.name,
-          tokensPerCall,
-          estimatedModel
-        });
-      }
+      sites.push({
+        file: filePath,
+        line: lineNum,
+        sdk: pattern.name,
+        tokensPerCall: slash(context, estimatedModel),
+        estimatedModel
+      });
     }
   }
   return sites;
@@ -402,6 +411,30 @@ function pad(s, n) {
 function formatNum(n) {
   return n.toLocaleString("en-US");
 }
+var CALLS_PER_SITE_PER_DAY = 100;
+function estimateMonthly(sites) {
+  const callsPerDay = CALLS_PER_SITE_PER_DAY;
+  const dailyInput = sites.reduce((sum, s) => sum + s.tokensPerCall * callsPerDay, 0);
+  const dailyOutput = dailyInput * 2;
+  const dailyTotal = dailyInput + dailyOutput;
+  let monthlyCostInput = 0;
+  let monthlyCostOutput = 0;
+  let unknownProviderSites = 0;
+  for (const site of sites) {
+    const info = getModel(site.estimatedModel);
+    if (!info)
+      continue;
+    if (site.estimatedModel === UNKNOWN_SDK_REPRESENTATIVE_MODEL && !["Anthropic"].includes(site.sdk)) {
+      unknownProviderSites++;
+    }
+    const siteDailyInput = site.tokensPerCall * callsPerDay;
+    const siteDailyOutput = siteDailyInput * 2;
+    monthlyCostInput += siteDailyInput * 30 / 1e6 * info.input;
+    monthlyCostOutput += siteDailyOutput * 30 / 1e6 * info.output;
+  }
+  const monthlyCost = monthlyCostInput + monthlyCostOutput;
+  return { callsPerDay, dailyInput, dailyOutput, dailyTotal, monthlyCostInput, monthlyCostOutput, monthlyCost, unknownProviderSites };
+}
 function printReport(sites, filesScanned, timeMs, cwd) {
   console.log("");
   console.log(`${ORANGE}${B}  ⚡ /slash${R}`);
@@ -423,26 +456,7 @@ function printReport(sites, filesScanned, timeMs, cwd) {
     console.log(`${WHITE}  ${pad(loc, 40)} ${GOLD}${pad(site.sdk, 12)} ${ORANGE}~${formatNum(site.tokensPerCall)} tok/call${R}`);
   }
   console.log("");
-  const callsPerDay = 100;
-  const dailyInput = sites.reduce((sum, s) => sum + s.tokensPerCall * callsPerDay, 0);
-  const dailyOutput = dailyInput * 2;
-  const dailyTotal = dailyInput + dailyOutput;
-  let monthlyCostInput = 0;
-  let monthlyCostOutput = 0;
-  let unknownProviderSites = 0;
-  for (const site of sites) {
-    const info = getModel(site.estimatedModel);
-    if (!info)
-      continue;
-    if (site.estimatedModel === UNKNOWN_SDK_REPRESENTATIVE_MODEL && !["Anthropic"].includes(site.sdk)) {
-      unknownProviderSites++;
-    }
-    const siteDailyInput = site.tokensPerCall * callsPerDay;
-    const siteDailyOutput = siteDailyInput * 2;
-    monthlyCostInput += siteDailyInput * 30 / 1e6 * info.input;
-    monthlyCostOutput += siteDailyOutput * 30 / 1e6 * info.output;
-  }
-  const monthlyCost = monthlyCostInput + monthlyCostOutput;
+  const { callsPerDay, dailyInput, dailyOutput, dailyTotal, monthlyCostInput, monthlyCostOutput, monthlyCost, unknownProviderSites } = estimateMonthly(sites);
   console.log(`${ORANGE}  DAILY TOKEN VOLUME ${GRAY}(${callsPerDay} calls/site/day)${R}`);
   console.log(`${DIM}  ${"─".repeat(60)}${R}`);
   console.log(`${WHITE}  Input tokens:    ${B}${formatNum(dailyInput)}${R}`);
@@ -455,7 +469,7 @@ function printReport(sites, filesScanned, timeMs, cwd) {
   console.log(`${WHITE}  Output:          ${B}$${monthlyCostOutput.toFixed(2)}/mo${R}`);
   console.log(`${WHITE}  Total:           ${ORANGE}${B}$${monthlyCost.toFixed(2)}/mo${R}`);
   if (unknownProviderSites > 0) {
-    console.log(`${GRAY}  (${unknownProviderSites} call site${unknownProviderSites === 1 ? "" : "s"} use an assumed price — the detected SDK doesn't reveal the exact provider)${R}`);
+    console.log(`${GRAY}  (${unknownProviderSites} ${unknownProviderSites === 1 ? "call site uses" : "call sites use"} an assumed price — the detected SDK doesn't reveal the exact provider)${R}`);
   }
   console.log("");
   console.log(`${GRAY}  4.8 KB WASM · sub-ms · zero deps${R}`);
@@ -619,6 +633,8 @@ function decide(task, policy = {}) {
         continue;
       if (CATALOG[m].tier < floor)
         continue;
+      if (!policy.allowOlder && CATALOG[m].tier === CATALOG[requested.model].tier && CATALOG[m].gen < CATALOG[requested.model].gen)
+        continue;
       const q = quote({ ...task, model: m });
       if (!ok(q) || q.cost.high >= requested.cost.high)
         continue;
@@ -644,6 +660,79 @@ function decide(task, policy = {}) {
   };
 }
 
+// src/diff.ts
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2, relative } from "path";
+import { spawnSync } from "child_process";
+var round2 = (n) => Math.round(n * 100) / 100;
+function exportRef(dir, ref) {
+  const out = mkdtempSync(join2(tmpdir(), "slash-diff-"));
+  const archive = spawnSync("git", ["-C", dir, "archive", "--format=tar", ref], { maxBuffer: 512 * 1024 * 1024 });
+  if (archive.status !== 0) {
+    rmSync(out, { recursive: true, force: true });
+    throw new Error(`git archive ${ref} failed: ${archive.stderr?.toString().trim() || "unknown error"}`);
+  }
+  const untar = spawnSync("tar", ["-x", "-C", out], { input: archive.stdout });
+  if (untar.status !== 0) {
+    rmSync(out, { recursive: true, force: true });
+    throw new Error(`could not unpack ${ref}: ${untar.stderr?.toString().trim()}`);
+  }
+  return out;
+}
+function scanSide(root) {
+  const { sites } = scan(root);
+  return {
+    sites: sites.map((s) => ({ ...s, rel: relative(root, s.file) })),
+    monthly: estimateMonthly(sites).monthlyCost
+  };
+}
+function scanDiff(dir, base, head) {
+  const baseDir = exportRef(dir, base);
+  const headDir = head ? exportRef(dir, head) : dir;
+  try {
+    const b = scanSide(baseDir);
+    const h = scanSide(headDir);
+    const groups = new Map;
+    const add = (s, side) => {
+      const key = `${s.rel}\x00${s.sdk}`;
+      const g = groups.get(key) ?? { file: s.rel, sdk: s.sdk, before: [], after: [] };
+      g[side].push(s);
+      groups.set(key, g);
+    };
+    b.sites.forEach((s) => add(s, "before"));
+    h.sites.forEach((s) => add(s, "after"));
+    const files = [];
+    for (const g of groups.values()) {
+      const monthlyBefore = estimateMonthly(g.before).monthlyCost;
+      const monthlyAfter = estimateMonthly(g.after).monthlyCost;
+      if (g.before.length === g.after.length && round2(monthlyBefore) === round2(monthlyAfter))
+        continue;
+      files.push({
+        file: g.file,
+        sdk: g.sdk,
+        sitesBefore: g.before.length,
+        sitesAfter: g.after.length,
+        monthlyBefore: round2(monthlyBefore),
+        monthlyAfter: round2(monthlyAfter),
+        monthlyDelta: round2(monthlyAfter - monthlyBefore)
+      });
+    }
+    files.sort((x, y) => Math.abs(y.monthlyDelta) - Math.abs(x.monthlyDelta) || x.file.localeCompare(y.file));
+    return {
+      base: { ref: base, sites: b.sites.length, monthlyCost: round2(b.monthly) },
+      head: { ref: head ?? "working tree", sites: h.sites.length, monthlyCost: round2(h.monthly) },
+      monthlyDelta: round2(h.monthly - b.monthly),
+      files,
+      callsPerSitePerDay: CALLS_PER_SITE_PER_DAY
+    };
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+    if (head)
+      rmSync(headDir, { recursive: true, force: true });
+  }
+}
+
 // src/cli.ts
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-V")) {
@@ -656,6 +745,8 @@ if (args.includes("--help") || args.includes("-h")) {
 }
 if (args[0] === "quote") {
   runQuote(args.slice(1)).then((code) => process.exit(code));
+} else if (args[0] === "diff") {
+  process.exit(runDiff(args.slice(1)));
 } else {
   scanHere();
 }
@@ -682,6 +773,32 @@ function scanHere() {
     console.log("");
   }
 }
+function runDiff(argv) {
+  try {
+    const refs = argv.filter((a) => !a.startsWith("--"));
+    if (refs.length < 1 || refs.length > 2)
+      throw new Error("usage: slash-tokens diff <base> [head] [--json]");
+    const d = scanDiff(process.cwd(), refs[0], refs[1]);
+    if (argv.includes("--json")) {
+      console.log(JSON.stringify(d, null, 2));
+      return 0;
+    }
+    const usd = (n) => `${n < 0 ? "-" : ""}$${Math.abs(n).toFixed(2)}`;
+    const sign = (n) => n > 0 ? `+${usd(n)}` : usd(n);
+    console.log(`LLM cost of this change (scan estimate, ${d.callsPerSitePerDay} calls a site a day)`);
+    const sites = (n) => `${n} call site${n === 1 ? "" : "s"}`;
+    console.log(`  ${d.base.ref}: ${sites(d.base.sites)}, ${usd(d.base.monthlyCost)}/mo`);
+    console.log(`  ${d.head.ref}: ${sites(d.head.sites)}, ${usd(d.head.monthlyCost)}/mo`);
+    console.log(`  change: ${sign(d.monthlyDelta)}/mo`);
+    for (const f of d.files) {
+      console.log(`  ${f.file} (${f.sdk}): ${f.sitesBefore} → ${f.sitesAfter} site${f.sitesAfter === 1 ? "" : "s"}, ${sign(f.monthlyDelta)}/mo`);
+    }
+    return 0;
+  } catch (err) {
+    console.error(`slash-tokens diff: ${err.message}`);
+    return 1;
+  }
+}
 function flag(argv, name) {
   const eq = argv.find((a) => a.startsWith(`--${name}=`));
   if (eq)
@@ -739,7 +856,7 @@ async function runQuote(argv) {
 }
 function packageVersion() {
   const here = dirname(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync2(join2(here, "..", "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync2(join3(here, "..", "package.json"), "utf8"));
   return pkg.version;
 }
 function printHelp() {
@@ -752,6 +869,9 @@ function printHelp() {
       [--max-output N] [--min-output N] [--budget USD] [--floor 1-4] [--json]
                              price a job and decide: go, downgrade or block
 
+  slash-tokens diff <base> [head] [--json]
+                             what a git change does to the scan's monthly LLM cost
+
   --version, -V    print version and exit
   --help, -h       print this help and exit
   --key=KEY        optional; CLI scans never charge

package/dist/diff.d.ts

@@ -0,0 +1,31 @@
+export interface ScanSide {
+    /** The git ref scanned, or "working tree". */
+    ref: string;
+    sites: number;
+    monthlyCost: number;
+}
+export interface FileDelta {
+    file: string;
+    sdk: string;
+    sitesBefore: number;
+    sitesAfter: number;
+    monthlyBefore: number;
+    monthlyAfter: number;
+    monthlyDelta: number;
+}
+export interface ScanDiff {
+    base: ScanSide;
+    head: ScanSide;
+    /** head.monthlyCost − base.monthlyCost, USD a month, at the scan's assumed traffic. */
+    monthlyDelta: number;
+    /** Files whose LLM call sites or cost changed, largest change first. */
+    files: FileDelta[];
+    callsPerSitePerDay: number;
+}
+/**
+ * What a change does to the scan's monthly LLM cost: scan `base` and `head`
+ * (default: the working tree) of the git repo at `dir`, and compare. Same
+ * assumptions as the scan (100 calls a site a day, output twice the input,
+ * each site priced at its SDK's representative model).
+ */
+export declare function scanDiff(dir: string, base: string, head?: string): ScanDiff;

package/dist/diff.js

@@ -0,0 +1,78 @@
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, relative } from 'path';
+import { spawnSync } from 'child_process';
+import { scan } from './scanner.js';
+import { estimateMonthly, CALLS_PER_SITE_PER_DAY } from './report.js';
+const round2 = (n) => Math.round(n * 100) / 100;
+/** Unpack one git ref of the repo at `dir` into a temp folder (git archive). */
+function exportRef(dir, ref) {
+    const out = mkdtempSync(join(tmpdir(), 'slash-diff-'));
+    const archive = spawnSync('git', ['-C', dir, 'archive', '--format=tar', ref], { maxBuffer: 512 * 1024 * 1024 });
+    if (archive.status !== 0) {
+        rmSync(out, { recursive: true, force: true });
+        throw new Error(`git archive ${ref} failed: ${archive.stderr?.toString().trim() || 'unknown error'}`);
+    }
+    const untar = spawnSync('tar', ['-x', '-C', out], { input: archive.stdout });
+    if (untar.status !== 0) {
+        rmSync(out, { recursive: true, force: true });
+        throw new Error(`could not unpack ${ref}: ${untar.stderr?.toString().trim()}`);
+    }
+    return out;
+}
+function scanSide(root) {
+    const { sites } = scan(root);
+    return {
+        sites: sites.map(s => ({ ...s, rel: relative(root, s.file) })),
+        monthly: estimateMonthly(sites).monthlyCost,
+    };
+}
+/**
+ * What a change does to the scan's monthly LLM cost: scan `base` and `head`
+ * (default: the working tree) of the git repo at `dir`, and compare. Same
+ * assumptions as the scan (100 calls a site a day, output twice the input,
+ * each site priced at its SDK's representative model).
+ */
+export function scanDiff(dir, base, head) {
+    const baseDir = exportRef(dir, base);
+    const headDir = head ? exportRef(dir, head) : dir;
+    try {
+        const b = scanSide(baseDir);
+        const h = scanSide(headDir);
+        const groups = new Map();
+        const add = (s, side) => {
+            const key = `${s.rel}\u0000${s.sdk}`;
+            const g = groups.get(key) ?? { file: s.rel, sdk: s.sdk, before: [], after: [] };
+            g[side].push(s);
+            groups.set(key, g);
+        };
+        b.sites.forEach(s => add(s, 'before'));
+        h.sites.forEach(s => add(s, 'after'));
+        const files = [];
+        for (const g of groups.values()) {
+            const monthlyBefore = estimateMonthly(g.before).monthlyCost;
+            const monthlyAfter = estimateMonthly(g.after).monthlyCost;
+            if (g.before.length === g.after.length && round2(monthlyBefore) === round2(monthlyAfter))
+                continue;
+            files.push({
+                file: g.file, sdk: g.sdk,
+                sitesBefore: g.before.length, sitesAfter: g.after.length,
+                monthlyBefore: round2(monthlyBefore), monthlyAfter: round2(monthlyAfter),
+                monthlyDelta: round2(monthlyAfter - monthlyBefore),
+            });
+        }
+        files.sort((x, y) => Math.abs(y.monthlyDelta) - Math.abs(x.monthlyDelta) || x.file.localeCompare(y.file));
+        return {
+            base: { ref: base, sites: b.sites.length, monthlyCost: round2(b.monthly) },
+            head: { ref: head ?? 'working tree', sites: h.sites.length, monthlyCost: round2(h.monthly) },
+            monthlyDelta: round2(h.monthly - b.monthly),
+            files,
+            callsPerSitePerDay: CALLS_PER_SITE_PER_DAY,
+        };
+    }
+    finally {
+        rmSync(baseDir, { recursive: true, force: true });
+        if (head)
+            rmSync(headDir, { recursive: true, force: true });
+    }
+}

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export type { Task, Message, Quote, Policy, Decision, Action } from './quote.js'
 export { reconcile, normalizeUsage } from './receipt.js';
 export type { Usage, Receipt, ReconcileOptions } from './receipt.js';
 export { hire } from './agent.js';
-export type { HireOptions, Job, CallModel, RunResult, Agent } from './agent.js';
+export type { HireOptions, Job, CallModel, CallOptions, RunResult, Agent } from './agent.js';
 export { CATALOG, TIER_NAMES } from './catalog.js';
 export type { CatalogEntry, Tier } from './catalog.js';
 export { PROVIDER_MODELS, providerOf } from './providers.js';

package/dist/models.js

@@ -2,7 +2,7 @@ import { CATALOG, API_ALIASES } from './catalog.js';
 // The price table, derived from the catalog (catalog.ts): same keys, same
 // order, same fields as before 1.7.0. Old keys stay as aliases so existing
 // call sites don't throw.
-export const MODELS = Object.fromEntries(Object.entries(CATALOG).map(([name, { provider: _p, tier: _t, asOf: _a, priceUntil: _u, ...price }]) => [name, price]));
+export const MODELS = Object.fromEntries(Object.entries(CATALOG).map(([name, { provider: _p, tier: _t, gen: _g, asOf: _a, priceUntil: _u, ...price }]) => [name, price]));
 /**
  * Real API IDs → table keys, strictly: lowercase, drop a trailing date stamp
  * (`-20250514`), and write version numbers with dots (`claude-opus-4-7` →

package/dist/patterns.d.ts

@@ -1,6 +1,17 @@
 export interface Pattern {
     name: string;
-    regex: RegExp;
+    /** A request to the model. Each match is one call site. */
+    call?: RegExp;
+    /** The SDK is in use (an import, a client being built). Not a request:
+     * it counts as one call site only in a file with no matched call, e.g. a
+     * client built here and passed to a wrapper. An import plus a client plus
+     * one request is one call site, not three. */
+    uses?: RegExp;
+    /** The call names the provider by itself (an API URL, a provider-named
+     * client), so it counts without `uses` in the file. Otherwise a call counts
+     * only where the SDK is in use: `.messages.create(` is also Twilio's SMS
+     * API, and `.invoke(` is also Tauri / Electron IPC. */
+    standalone?: boolean;
 }
 export declare const AI_PATTERNS: Pattern[];
 export declare const SDK_REPRESENTATIVE_MODEL: Record<string, string>;

package/dist/patterns.js

@@ -1,24 +1,24 @@
 export const AI_PATTERNS = [
     // OpenAI
-    { name: 'OpenAI', regex: /openai\.chat\.completions\.create|new OpenAI\(|from\s+['"]openai['"]/g },
+    { name: 'OpenAI', call: /\.(?:chat\.completions|responses)\.create\(/g, uses: /\b(?:Async|Azure)?OpenAI\(|from\s+['"]openai['"]|^\s*(?:from\s+openai\s+import|import\s+openai)\b/gm },
     // Anthropic
-    { name: 'Anthropic', regex: /anthropic\.messages\.create|new Anthropic\(|from\s+['"]@anthropic-ai/g },
+    { name: 'Anthropic', call: /\.messages\.(?:create|stream)\(/g, uses: /\b(?:Async)?Anthropic\(|from\s+['"]@anthropic-ai|^\s*(?:from\s+anthropic\s+import|import\s+anthropic)\b/gm },
     // Vercel AI SDK
-    { name: 'Vercel AI', regex: /from\s+['"]ai['"]|generateText|streamText|generateObject/g },
+    { name: 'Vercel AI', call: /\b(?:generateText|streamText|generateObject|streamObject)\(/g, uses: /from\s+['"]ai['"]/g },
     // LangChain
-    { name: 'LangChain', regex: /from\s+['"]langchain|ChatOpenAI|ChatAnthropic|\.invoke\(/g },
+    { name: 'LangChain', call: /\.invoke\(/g, uses: /from\s+['"]@?langchain|^\s*(?:from|import)\s+langchain|ChatOpenAI|ChatAnthropic/gm },
     // Google Gemini
-    { name: 'Gemini', regex: /GoogleGenerativeAI|generateContent|from\s+['"]@google\/generative/g },
+    { name: 'Gemini', call: /\.(?:generateContent(?:Stream)?|generate_content(?:_stream)?)\(/g, uses: /GoogleGenerativeAI|from\s+['"]@google\/gen|^\s*(?:import\s+google\.generativeai|from\s+google(?:\.genai|\s+import\s+genai))/gm },
     // AWS Bedrock
-    { name: 'Bedrock', regex: /BedrockRuntimeClient|InvokeModelCommand/g },
+    { name: 'Bedrock', call: /InvokeModelCommand\(/g, uses: /BedrockRuntimeClient/g },
     // xAI Grok
-    { name: 'Grok', regex: /x\.ai\/api|xai\.chat|from\s+['"]grok/g },
+    { name: 'Grok', call: /x\.ai\/api|xai\.chat/g, uses: /from\s+['"]grok/g, standalone: true },
     // Raw fetch to AI endpoints
-    { name: 'fetch (AI)', regex: /fetch\(.*api\.openai\.com|fetch\(.*api\.anthropic\.com|fetch\(.*generativelanguage\.googleapis/g },
+    { name: 'fetch (AI)', call: /fetch\(.*api\.openai\.com|fetch\(.*api\.anthropic\.com|fetch\(.*generativelanguage\.googleapis/g, standalone: true },
     // Cohere
-    { name: 'Cohere', regex: /from\s+['"]cohere|CohereClient|cohere\.chat/g },
+    { name: 'Cohere', call: /cohere\.chat/g, uses: /from\s+['"]cohere|CohereClient/g, standalone: true },
     // Mistral
-    { name: 'Mistral', regex: /from\s+['"]@mistralai|MistralClient/g },
+    { name: 'Mistral', uses: /from\s+['"]@mistralai|MistralClient/g },
 ];
 // Representative model per detected SDK — the scanner only ever sees an
 // SDK name (a regex match on import/call syntax), never the actual model

package/dist/preflight.d.ts

@@ -46,9 +46,9 @@ export declare function preflight(content: string, model: string): PreflightResu
  *     canonical model in PROVIDER_MODELS.
  *   - Returns null when: model unknown, provider unknown, or no cheaper same-
  *     provider alternative exists. Null is a valid result ("PASS, no route").
- *   - Cheapest SAME-PROVIDER alternative by input price. If two alternatives
- *     tie on price (unlikely but possible), returns the first encountered in
- *     PROVIDER_MODELS order.
+ *   - Cheapest SAME-PROVIDER alternative that fits the prompt, by cost for
+ *     this prompt. When two costs round to the same value (tiny prompts),
+ *     the lower input list price wins.
  *   - Respects the same init() config gates as intercept.ts findCheapestRoute: shouldRoute()
  *     (init({route: false}) must make this always return null, matching
  *     patchFetch() never routing) and isModelAllowed() (init({models: [...]})

package/dist/preflight.js

@@ -71,9 +71,9 @@ export function preflight(content, model) {
  *     canonical model in PROVIDER_MODELS.
  *   - Returns null when: model unknown, provider unknown, or no cheaper same-
  *     provider alternative exists. Null is a valid result ("PASS, no route").
- *   - Cheapest SAME-PROVIDER alternative by input price. If two alternatives
- *     tie on price (unlikely but possible), returns the first encountered in
- *     PROVIDER_MODELS order.
+ *   - Cheapest SAME-PROVIDER alternative that fits the prompt, by cost for
+ *     this prompt. When two costs round to the same value (tiny prompts),
+ *     the lower input list price wins.
  *   - Respects the same init() config gates as intercept.ts findCheapestRoute: shouldRoute()
  *     (init({route: false}) must make this always return null, matching
  *     patchFetch() never routing) and isModelAllowed() (init({models: [...]})

package/dist/quote.d.ts

@@ -42,6 +42,13 @@ export interface Policy {
      * own tier, so nothing is swapped for a smaller line unless you allow it.
      */
     floor?: Tier;
+    /**
+     * Let a substitute be an older generation of the requested model's own
+     * line (same tier: Gemini 3.8 Flash → 2.5 Flash). Default false: a tier is a
+     * product line, not a generation, so "same tier" alone doesn't mean "as
+     * good". A smaller current line (floor 1: Opus 5.5 → Haiku) is unaffected.
+     */
+    allowOlder?: boolean;
 }
 export type Action = 'go' | 'downgrade' | 'block';
 export interface Decision {
@@ -68,10 +75,13 @@ export declare const DEFAULT_MAX_OUTPUT_TOKENS = 4096;
  *   xAI        a fixed system preamble of 185–193 tokens per request
  *              (baselines in bench/results-grok.json); 193 used.
  *   OpenAI     3 per message + 3 to prime the reply (OpenAI's tiktoken
- *              cookbook); 4 per message, the first one inside `request`.
+ *              cookbook, not measured here); 4 per message, the first one
+ *              inside `request`.
  *   Anthropic  the calibration ground truth (count_tokens) already includes
- *              one message's framing; 4 per extra message.
- *   Google     countTokens on content; 4 per message, not yet measured.
+ *              one message's framing; 4 per extra message, an allowance,
+ *              not yet measured.
+ *   Google     countTokens on content; 4 per message, an allowance, not yet
+ *              measured.
  */
 export declare const FRAMING: Record<string, {
     request: number;
@@ -81,14 +91,16 @@ export declare const FRAMING: Record<string, {
  * Price a job before it runs: input tokens, an output band, and a low–high
  * cost. Input is the content counted with the model's calibration factor
  * plus the provider's request framing (see FRAMING), so it doesn't come in
- * under the bill; the long-context rate applies when the prompt crosses it.
+ * under the bill (checked against real bills for Nebius; an allowance for
+ * the others); the long-context rate applies when the prompt crosses it.
  */
 export declare function quote(task: Task): Quote;
 /**
  * Choose what to run under a budget and a quality floor.
  *
  * Candidates are the requested model plus its same-provider siblings at or
- * above the floor (never a NOT_ROUTE_TARGETS model, never one excluded by
+ * above the floor, never an older generation of the requested line (unless allowOlder; never
+ * a NOT_ROUTE_TARGETS model, never one excluded by
  * init({ models }), none at all after init({ route: false })). Each is quoted
  * on its own token count. A substitute must cost less than the requested
  * model — decide() never raises the bill. The cheapest candidate that fits

package/dist/quote.js

@@ -17,10 +17,13 @@ export const DEFAULT_MAX_OUTPUT_TOKENS = 4096;
  *   xAI        a fixed system preamble of 185–193 tokens per request
  *              (baselines in bench/results-grok.json); 193 used.
  *   OpenAI     3 per message + 3 to prime the reply (OpenAI's tiktoken
- *              cookbook); 4 per message, the first one inside `request`.
+ *              cookbook, not measured here); 4 per message, the first one
+ *              inside `request`.
  *   Anthropic  the calibration ground truth (count_tokens) already includes
- *              one message's framing; 4 per extra message.
- *   Google     countTokens on content; 4 per message, not yet measured.
+ *              one message's framing; 4 per extra message, an allowance,
+ *              not yet measured.
+ *   Google     countTokens on content; 4 per message, an allowance, not yet
+ *              measured.
  */
 export const FRAMING = {
     Nebius: { request: 16, perMessage: 7 },
@@ -44,7 +47,8 @@ function inputTokens(input, model, provider) {
  * Price a job before it runs: input tokens, an output band, and a low–high
  * cost. Input is the content counted with the model's calibration factor
  * plus the provider's request framing (see FRAMING), so it doesn't come in
- * under the bill; the long-context rate applies when the prompt crosses it.
+ * under the bill (checked against real bills for Nebius; an allowance for
+ * the others); the long-context rate applies when the prompt crosses it.
  */
 export function quote(task) {
     const model = canonicalModel(task.model);
@@ -76,7 +80,8 @@ export function quote(task) {
  * Choose what to run under a budget and a quality floor.
  *
  * Candidates are the requested model plus its same-provider siblings at or
- * above the floor (never a NOT_ROUTE_TARGETS model, never one excluded by
+ * above the floor, never an older generation of the requested line (unless allowOlder; never
+ * a NOT_ROUTE_TARGETS model, never one excluded by
  * init({ models }), none at all after init({ route: false })). Each is quoted
  * on its own token count. A substitute must cost less than the requested
  * model — decide() never raises the bill. The cheapest candidate that fits
@@ -94,6 +99,9 @@ export function decide(task, policy = {}) {
                 continue;
             if (CATALOG[m].tier < floor)
                 continue;
+            // Older generation of the same line (tier) only: a smaller current line is fine.
+            if (!policy.allowOlder && CATALOG[m].tier === CATALOG[requested.model].tier && CATALOG[m].gen < CATALOG[requested.model].gen)
+                continue;
             const q = quote({ ...task, model: m });
             if (!ok(q) || q.cost.high >= requested.cost.high)
                 continue; // never raise the cost

package/dist/report.d.ts

@@ -1,2 +1,16 @@
 import { CallSite } from './scanner.js';
+/** Assumed traffic for the scan's estimate: 100 calls per site per day, output twice the input. */
+export declare const CALLS_PER_SITE_PER_DAY = 100;
+export interface MonthlyEstimate {
+    callsPerDay: number;
+    dailyInput: number;
+    dailyOutput: number;
+    dailyTotal: number;
+    monthlyCostInput: number;
+    monthlyCostOutput: number;
+    monthlyCost: number;
+    unknownProviderSites: number;
+}
+/** The scan's daily token volume and monthly cost for a set of call sites. */
+export declare function estimateMonthly(sites: CallSite[]): MonthlyEstimate;
 export declare function printReport(sites: CallSite[], filesScanned: number, timeMs: number, cwd: string): void;

package/dist/report.js

@@ -14,30 +14,11 @@ function pad(s, n) {
 function formatNum(n) {
     return n.toLocaleString('en-US');
 }
-export function printReport(sites, filesScanned, timeMs, cwd) {
-    console.log('');
-    console.log(`${ORANGE}${B}  ⚡ /slash${R}`);
-    console.log(`${GRAY}  Token optimization analysis${R}`);
-    console.log('');
-    console.log(`${DIM}  Evaluated ${filesScanned} files in ${timeMs}ms${R}`);
-    console.log('');
-    if (sites.length === 0) {
-        console.log(`${WHITE}  No AI API call sites detected.${R}`);
-        console.log(`${GRAY}  Supported: OpenAI, Anthropic, Vercel AI, LangChain, Gemini, Bedrock, Grok${R}`);
-        console.log(`${GRAY}  Run this in a project that already calls an LLM.${R}`);
-        console.log('');
-        return;
-    }
-    // Call sites
-    console.log(`${ORANGE}  CALL SITES${R}`);
-    console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
-    for (const site of sites) {
-        const loc = site.file.replace(cwd + '/', '') + ':' + site.line;
-        console.log(`${WHITE}  ${pad(loc, 40)} ${GOLD}${pad(site.sdk, 12)} ${ORANGE}~${formatNum(site.tokensPerCall)} tok/call${R}`);
-    }
-    console.log('');
-    // Daily estimates (100 calls/site/day)
-    const callsPerDay = 100;
+/** Assumed traffic for the scan's estimate: 100 calls per site per day, output twice the input. */
+export const CALLS_PER_SITE_PER_DAY = 100;
+/** The scan's daily token volume and monthly cost for a set of call sites. */
+export function estimateMonthly(sites) {
+    const callsPerDay = CALLS_PER_SITE_PER_DAY;
     const dailyInput = sites.reduce((sum, s) => sum + s.tokensPerCall * callsPerDay, 0);
     const dailyOutput = dailyInput * 2; // Estimate output at 2x input
     const dailyTotal = dailyInput + dailyOutput;
@@ -62,6 +43,31 @@ export function printReport(sites, filesScanned, timeMs, cwd) {
         monthlyCostOutput += (siteDailyOutput * 30 / 1000000) * info.output;
     }
     const monthlyCost = monthlyCostInput + monthlyCostOutput;
+    return { callsPerDay, dailyInput, dailyOutput, dailyTotal, monthlyCostInput, monthlyCostOutput, monthlyCost, unknownProviderSites };
+}
+export function printReport(sites, filesScanned, timeMs, cwd) {
+    console.log('');
+    console.log(`${ORANGE}${B}  ⚡ /slash${R}`);
+    console.log(`${GRAY}  Token optimization analysis${R}`);
+    console.log('');
+    console.log(`${DIM}  Evaluated ${filesScanned} files in ${timeMs}ms${R}`);
+    console.log('');
+    if (sites.length === 0) {
+        console.log(`${WHITE}  No AI API call sites detected.${R}`);
+        console.log(`${GRAY}  Supported: OpenAI, Anthropic, Vercel AI, LangChain, Gemini, Bedrock, Grok${R}`);
+        console.log(`${GRAY}  Run this in a project that already calls an LLM.${R}`);
+        console.log('');
+        return;
+    }
+    // Call sites
+    console.log(`${ORANGE}  CALL SITES${R}`);
+    console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
+    for (const site of sites) {
+        const loc = site.file.replace(cwd + '/', '') + ':' + site.line;
+        console.log(`${WHITE}  ${pad(loc, 40)} ${GOLD}${pad(site.sdk, 12)} ${ORANGE}~${formatNum(site.tokensPerCall)} tok/call${R}`);
+    }
+    console.log('');
+    const { callsPerDay, dailyInput, dailyOutput, dailyTotal, monthlyCostInput, monthlyCostOutput, monthlyCost, unknownProviderSites } = estimateMonthly(sites);
     console.log(`${ORANGE}  DAILY TOKEN VOLUME ${GRAY}(${callsPerDay} calls/site/day)${R}`);
     console.log(`${DIM}  ${'─'.repeat(60)}${R}`);
     console.log(`${WHITE}  Input tokens:    ${B}${formatNum(dailyInput)}${R}`);
@@ -74,7 +80,7 @@ export function printReport(sites, filesScanned, timeMs, cwd) {
     console.log(`${WHITE}  Output:          ${B}$${monthlyCostOutput.toFixed(2)}/mo${R}`);
     console.log(`${WHITE}  Total:           ${ORANGE}${B}$${monthlyCost.toFixed(2)}/mo${R}`);
     if (unknownProviderSites > 0) {
-        console.log(`${GRAY}  (${unknownProviderSites} call site${unknownProviderSites === 1 ? '' : 's'} use an assumed price — the detected SDK doesn't reveal the exact provider)${R}`);
+        console.log(`${GRAY}  (${unknownProviderSites} ${unknownProviderSites === 1 ? 'call site uses' : 'call sites use'} an assumed price — the detected SDK doesn't reveal the exact provider)${R}`);
     }
     console.log('');
     console.log(`${GRAY}  4.8 KB WASM · sub-ms · zero deps${R}`);

package/dist/scanner.js

@@ -29,33 +29,40 @@ function walkDir(dir, files) {
         }
     }
 }
+function matchLines(regex, content) {
+    if (!regex)
+        return [];
+    const found = [];
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const line = content.substring(0, match.index).split('\n').length;
+        if (!found.includes(line))
+            found.push(line);
+    }
+    return found;
+}
 function findCallSites(filePath, content) {
     const sites = [];
     const lines = content.split('\n');
     for (const pattern of AI_PATTERNS) {
-        // Reset regex
-        pattern.regex.lastIndex = 0;
-        let match;
-        while ((match = pattern.regex.exec(content)) !== null) {
-            // Find line number
-            const beforeMatch = content.substring(0, match.index);
-            const lineNum = beforeMatch.split('\n').length;
+        const usesLines = matchLines(pattern.uses, content);
+        // A call counts where it names the provider itself, or where the SDK is in use.
+        const callLines = pattern.standalone || !pattern.uses || usesLines.length > 0 ? matchLines(pattern.call, content) : [];
+        const siteLines = callLines.length > 0 ? callLines : usesLines.slice(0, 1);
+        const estimatedModel = SDK_REPRESENTATIVE_MODEL[pattern.name] ?? UNKNOWN_SDK_REPRESENTATIVE_MODEL;
+        for (const lineNum of siteLines) {
             // Estimate tokens from surrounding context (grab the function/block)
             const startLine = Math.max(0, lineNum - 5);
             const endLine = Math.min(lines.length, lineNum + 20);
             const context = lines.slice(startLine, endLine).join('\n');
-            const estimatedModel = SDK_REPRESENTATIVE_MODEL[pattern.name] ?? UNKNOWN_SDK_REPRESENTATIVE_MODEL;
-            const tokensPerCall = slash(context, estimatedModel);
-            // Avoid duplicates at same location
-            if (!sites.some(s => s.line === lineNum && s.sdk === pattern.name)) {
-                sites.push({
-                    file: filePath,
-                    line: lineNum,
-                    sdk: pattern.name,
-                    tokensPerCall,
-                    estimatedModel,
-                });
-            }
+            sites.push({
+                file: filePath,
+                line: lineNum,
+                sdk: pattern.name,
+                tokensPerCall: slash(context, estimatedModel),
+                estimatedModel,
+            });
         }
     }
     return sites;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slash-tokens",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Know what an LLM call will cost before you make it, and prove what you saved after. Quote, decide, receipt. 4.8 KB WASM, zero dependencies.",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -31,7 +31,8 @@
     "test": "bun test",
     "check:engines": "node scripts/check-engines.mjs",
     "check:freshness": "bun scripts/check-freshness.ts",
-    "bench:nemotron": "bun bench/calibrate-nemotron.ts"
+    "bench:nemotron": "bun bench/calibrate-nemotron.ts",
+    "bench:oss": "bun bench/oss/study.ts"
   },
   "author": "wolfejam",
   "license": "MIT",