feat: Wave 3 v1.0.0 rollout — VS Code, Claude Code skill, Mistral+Cohere, latency, playground showcase

Adds the headline differentiation features for v1.0.0. No breaking changes
to existing flags or output paths.

VS Code / Cursor extension (`packages/vscode/`, new package):
- Status bar shows live token count + USD cost for the active editor file
  across Claude, GPT-4o, and Gemini.
- Settings: model, format, warnOnCostAbove threshold (turns the bar
  background warning-yellow when exceeded).
- Commands: Tokenometer: switch model, Tokenometer: show info.
- Debounced 200ms recompute on document changes; 1MB file-size gate.
- Reuses @tokenometer/core via esbuild bundle. Marketplace publish in
  Wave 4 Phase I.

Claude Code skill (`packages/claude-code-skill/`, new package):
- SKILL.md with `name: tokenometer-cost-check` + multi-trigger description.
- 13-section body teaching Claude Code agents when and how to invoke
  `npx tokenometer` for prompt cost analysis: offline + empirical mode,
  --output json/sarif, --by-file, --image, auto provider detection,
  .tokenometer.yml config, CI guardrail via `tokenometer init`.
- One-line install via `~/.claude/skills/tokenometer/SKILL.md`.

Mistral + Cohere providers (`@tokenometer/core`):
- Mistral: `mistral-tokenizer-js` for SentencePiece family (Mistral 7B,
  Mixtral 8x7B/8x22B, Mistral Large 2407, Codestral 22B); chars/4
  heuristic for Tekken-tokenizer models (NeMo, Pixtral, Mistral Small
  2409+, Devstral, Mistral Medium 2505+, Magistral, Ministral). All
  marked `approximate: true`. Empirical mode unsupported — Mistral has
  no public token-count API.
- Cohere: chars/4 heuristic offline; empirical via POST /v1/tokenize
  using bare fetch (Cohere SDK ships only a REST wrapper, no offline
  tokenizer).
- Pricing: Mistral auto-sourced from @tokenlens/models; Cohere via
  LOCAL_OVERRIDES until tokenlens adds upstream. Total KNOWN_MODELS:
  42 → 63.

Latency mode (`--latency` flag):
- Measures real generation latency: TTFT (time to first token) + total
  wall-clock + tokens/sec. Reports p50/p95/mean over n trials (default
  3, configurable 1-10 via --latency-trials).
- Implies --empirical. Bumps default --max-spend ceiling to $0.25 to
  cover ~200-token generations.
- Streamed via SDK for Anthropic/Google; bare fetch SSE/NDJSON for
  OpenAI/Mistral/Cohere (no extra SDK install footprint).
- New table columns + JSON/SARIF carry the latency block.
- Differentiation pitch: only LLM cost CLI that also reports latency.

Playground showcase (`packages/web/`):
- 11 new routes: /diff, /by-file, /sarif, /vision, /config-builder,
  /init, /models (Cost Atlas with sort/search/filter), /models/<id>
  (per-model SEO pages), /editor, /claude-code, plus / and /calculator
  for the existing landing.
- react-router-dom 7, top nav with Tools dropdown, footer linking repo +
  npm + marketplace placeholders.
- Cross-page provider robustness: Map<Provider, ...> instead of static
  Records so playground gracefully extends as new providers land.
- Static robots.txt + sitemap.xml; per-page document.title via
  usePageTitle hook (no react-helmet dependency).

Test count: 150 → 227 (across 20 files). Lint, typecheck, root + web
builds all clean.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: faraa2m

.changeset/wave-3-claude-code-skill.md

@@ -0,0 +1,9 @@
+---
+"tokenometer": minor
+"@tokenometer/core": minor
+---
+
+Add `@tokenometer/claude-code-skill` — a Claude Code skill that teaches
+Claude Code agents to invoke `npx tokenometer` for prompt-cost analysis.
+Install via `~/.claude/skills/tokenometer/SKILL.md`. Submission to
+community skill registry tracked separately.

.changeset/wave-3-latency.md

@@ -0,0 +1,11 @@
+---
+"tokenometer": minor
+"@tokenometer/core": minor
+---
+
+Add `--latency` flag — measures real generation latency (TTFT + total ms +
+tokens/sec, p50/p95/mean over n trials) alongside token cost. Implies
+`--empirical`. Default trials = 3, configurable via `--latency-trials <n>`
+(1-10). Bumps default `--max-spend` to $0.25 to cover the n × 200-token
+generations. Supported providers: Anthropic, OpenAI, Google, Cohere,
+Mistral (latter two are metered).

.changeset/wave-3-mistral-cohere.md

@@ -0,0 +1,19 @@
+---
+"tokenometer": minor
+"@tokenometer/core": minor
+---
+
+Add Mistral and Cohere providers.
+
+- Mistral: `mistral-tokenizer-js` for SentencePiece family (Mistral 7B,
+  Mixtral, Mistral Large 2407, Codestral); `chars/4` heuristic for Tekken
+  models (NeMo, Pixtral, Mistral Small 2409+, Devstral, Mistral Medium
+  2505+, Magistral, Ministral). All marked `approximate: true`. Empirical
+  mode unsupported (Mistral has no public token-count API).
+- Cohere: offline heuristic `chars/4` (Cohere SDK is REST-only; no offline
+  tokenizer ships in JS). Empirical via `POST /v1/tokenize` when
+  `COHERE_API_KEY` is set.
+
+Pricing for Mistral auto-sourced from `@tokenlens/models/mistral`. Cohere
+pricing comes from `LOCAL_OVERRIDES` (`command-r`, `command-r-plus`)
+because `@tokenlens/models` does not yet ship a Cohere catalog at v1.3.0.

.changeset/wave-3-playground-showcase.md

@@ -0,0 +1,11 @@
+---
+"tokenometer": minor
+"@tokenometer/core": minor
+---
+
+Playground (`https://tokenometer.vercel.app`) gains showcase pages for
+every Wave 2 feature: `/diff`, `/by-file`, `/sarif`, `/vision`,
+`/config-builder`, `/init`, `/models` (Cost Atlas + per-model SEO pages),
+plus placeholder pages for the VS Code extension and Claude Code skill.
+</content>
+</invoke>

.changeset/wave-3-vscode-extension.md

@@ -0,0 +1,9 @@
+---
+"tokenometer": minor
+"@tokenometer/core": minor
+---
+
+Add VS Code / Cursor extension (`@tokenometer/vscode`). Status bar shows
+live token count + USD cost for the active editor file across Claude,
+GPT-4o, and Gemini. Reuses `@tokenometer/core`. Marketplace publish
+follows in Phase I.

README.md

@@ -58,14 +58,15 @@ The `Approx` column shows `✓` when the count is a proxy (Anthropic / Google of
 
 ## Why this exists
 
-`tiktoken` and `@anthropic-ai/tokenizer` give you a token count for one provider. They don't tell you:
+**Cost AND latency in one CLI — the only tool that does both.** `tiktoken` and `@anthropic-ai/tokenizer` give you a token count for one provider. They don't tell you:
 
 - What the same prompt costs across **multiple providers and models**
+- How **fast** each provider actually responds (TTFT + tokens/sec) — a real generation, not a synthetic benchmark
 - Whether **format conversion** (YAML ↔ JSON ↔ XML ↔ MD) actually moves the needle
 - The **empirical** cost — what your provider actually charged on a real call, after prompt caching
 - Whether a PR introduced a **prompt-cost regression**
 
-Tokenometer is dev-time, multi-provider, multi-format, optionally empirical, and CI-native.
+Tokenometer is dev-time, multi-provider, multi-format, optionally empirical, latency-aware, and CI-native.
 
 ## Install
 
@@ -135,11 +136,13 @@ The CLI also supports `--output json|sarif` for machine-readable output, `--by-f
 
 Tokenometer picks a tokenizer per provider and flags the count as approximate (`approximate: true` in the API result) when the offline path is a proxy:
 
-| Provider  | Offline tokenizer            | Exactness   | Empirical (`--empirical`)        |
-|-----------|------------------------------|-------------|----------------------------------|
-| OpenAI    | `gpt-tokenizer` `o200k_base` | exact       | same `o200k_base` (matches OpenAI production count) |
-| Anthropic | `gpt-tokenizer` `cl100k_base`| approximate | `messages.countTokens` (exact, free) |
-| Google    | `chars / 4` heuristic        | approximate | `model.countTokens` (exact, free) |
+| Provider  | Offline tokenizer                              | Exactness   | Empirical (`--empirical`)        |
+|-----------|------------------------------------------------|-------------|----------------------------------|
+| OpenAI    | `gpt-tokenizer` `o200k_base`                   | exact       | same `o200k_base` (matches OpenAI production count) |
+| Anthropic | `gpt-tokenizer` `cl100k_base`                  | approximate | `messages.countTokens` (exact, free) |
+| Google    | `chars / 4` heuristic                          | approximate | `model.countTokens` (exact, free) |
+| Mistral   | `mistral-tokenizer-js` (V1/V2/V3) · `chars/4` for Tekken | approximate | unsupported (no public token-count endpoint) |
+| Cohere    | `chars / 4` heuristic                          | approximate | `POST /v1/tokenize` (exact, free, requires `COHERE_API_KEY`) |
 
 Cost = `tokens / 1000 × per-1k input rate`. Pricing and context windows are sourced from the [`tokenlens`](https://www.npmjs.com/package/tokenlens) registry, with a small set of local overrides for bleeding-edge models the registry hasn't picked up yet — see [`packages/core/src/rates.ts`](packages/core/src/rates.ts) (`RATES_VERSION`).
 
@@ -153,7 +156,7 @@ Cost = `tokens / 1000 × per-1k input rate`. Pricing and context windows are sou
 
 ## Status
 
-Early. v0.0.x — see [milestones](https://github.com/faraa2m/tokenometer/milestones). Roadmap to v1.0.0 in progress: VS Code extension, Claude Code skill, vision-token cost, Mistral + Cohere providers.
+Early. v0.0.x — see [milestones](https://github.com/faraa2m/tokenometer/milestones). Roadmap to v1.0.0 in progress: VS Code extension, Claude Code skill, vision-token cost.
 
 ## License
 

benchmarks/run.mjs

@@ -1,11 +1,24 @@
 #!/usr/bin/env node
+//
+// Benchmark sweep modes:
+//
+//   node benchmarks/run.mjs                # offline drift check vs results.json
+//   node benchmarks/run.mjs --regenerate   # rewrite results.json from current code
+//   node benchmarks/run.mjs --empirical    # countTokens sweep (Anthropic / Google free), writes empirical.json
+//   node benchmarks/run.mjs --latency      # real generation sweep (METERED), writes latency-empirical.json
+//
+// `--latency` runs `--latency-trials` (default 3) streaming generations per
+// (model, format) cell with max_tokens=200. Cost scales linearly with the
+// number of cells; respect your `MAX_SPEND_USD` env or use `--filter`.
+
 import { readFile, readdir, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
   KNOWN_MODELS,
   RATES_VERSION,
   allFormats,
+  measureLatency,
   tokenize,
   tokenizeEmpirical,
 } from '@tokenometer/core';
@@ -14,6 +27,7 @@ const HERE = dirname(fileURLToPath(import.meta.url));
 const PROMPTS_DIR = join(HERE, 'prompts');
 const RESULTS_PATH = join(HERE, 'results.json');
 const EMPIRICAL_PATH = join(HERE, 'empirical.json');
+const LATENCY_PATH = join(HERE, 'latency-empirical.json');
 
 const loadPrompts = async () => {
   const files = (await readdir(PROMPTS_DIR)).filter((f) => !f.startsWith('.')).sort();
@@ -136,8 +150,11 @@ const compareResults = async (results) => {
 const readEnv = () => {
   const env = {};
   if (process.env.ANTHROPIC_API_KEY) env.anthropicApiKey = process.env.ANTHROPIC_API_KEY;
+  if (process.env.COHERE_API_KEY) env.cohereApiKey = process.env.COHERE_API_KEY;
   const googleKey = process.env.GOOGLE_API_KEY ?? process.env.GEMINI_API_KEY;
   if (googleKey) env.googleApiKey = googleKey;
+  if (process.env.MISTRAL_API_KEY) env.mistralApiKey = process.env.MISTRAL_API_KEY;
+  if (process.env.OPENAI_API_KEY) env.openaiApiKey = process.env.OPENAI_API_KEY;
   return env;
 };
 
@@ -225,17 +242,96 @@ const summarizeByProvider = (rows) => {
   return summary;
 };
 
+const parseLatencyTrials = (args) => {
+  const idx = args.indexOf('--latency-trials');
+  if (idx === -1 || !args[idx + 1]) return 3;
+  const n = Number.parseInt(args[idx + 1], 10);
+  if (!Number.isFinite(n) || n < 1 || n > 10) {
+    throw new Error(`--latency-trials must be 1..10, got "${args[idx + 1]}"`);
+  }
+  return n;
+};
+
+const runLatencySweep = async (prompts, env, models, trials) => {
+  const formats = [...allFormats()];
+  const out = {};
+  let totalTrials = 0;
+  for (const [name, prompt] of Object.entries(prompts).sort()) {
+    process.stderr.write(`${name} ... `);
+    const byModel = {};
+    for (const modelId of models) {
+      const byFormat = {};
+      for (const format of formats) {
+        try {
+          const result = await measureLatency({
+            env,
+            modelId,
+            prompt,
+            trials,
+          });
+          byFormat[format] = {
+            mean: result.mean,
+            p50: result.p50,
+            p95: result.p95,
+            trials: result.trials,
+          };
+          totalTrials += trials;
+        } catch (err) {
+          byFormat[format] = { error: err.message };
+        }
+      }
+      byModel[modelId] = byFormat;
+    }
+    out[name] = byModel;
+    process.stderr.write('done\n');
+  }
+  return {
+    formats,
+    generatedAt: new Date().toISOString(),
+    latency: out,
+    models,
+    schemaVersion: 1,
+    totalTrials,
+    trialsPerCell: trials,
+  };
+};
+
 const main = async () => {
   const args = process.argv.slice(2);
   const isRegenerate = args.includes('--regenerate');
   const isEmpirical = args.includes('--empirical');
+  const isLatency = args.includes('--latency');
   const filter = parseModelFilter(args);
   const models = selectModels(filter);
   if (filter) {
     console.error(`Filter active — sweeping ${models.length}/${KNOWN_MODELS.length} models.`);
   }
   const prompts = await loadPrompts();
 
+  if (isLatency) {
+    const env = readEnv();
+    const trials = parseLatencyTrials(args);
+    if (
+      !env.anthropicApiKey &&
+      !env.googleApiKey &&
+      !env.openaiApiKey &&
+      !env.cohereApiKey &&
+      !env.mistralApiKey
+    ) {
+      console.error(
+        'Latency sweep needs at least one of ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY (or GEMINI_API_KEY) / COHERE_API_KEY / MISTRAL_API_KEY.',
+      );
+      console.error(
+        'Each trial is a metered ~200-token chat completion — use --filter to narrow scope.',
+      );
+      return 1;
+    }
+    const result = await runLatencySweep(prompts, env, models, trials);
+    await writeFile(LATENCY_PATH, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+    console.log(`\nWrote ${LATENCY_PATH} (${result.totalTrials} trials, ${trials} per cell).`);
+    return 0;
+  }
+
   if (isEmpirical) {
     const env = readEnv();
     if (!env.anthropicApiKey && !env.googleApiKey) {