mcp-context-cost 0.11.1 → 0.11.2

package/README.md

@@ -278,7 +278,7 @@ now measured against a pinned model and published beside the badge, and they do
 
 | server | badge (o200k) | Claude (`claude-opus-5`) | |
 |---|---:|---:|---|
-| github | 54,422 | **18,406** | 81% of the capture is `annotations`/`outputSchema` metadata Claude never sees |
+| github | 54,622 | **—** | most of the capture is `annotations`/`outputSchema` metadata Claude never sees |
 | notion | 17,500 | **33,560** | almost no metadata to drop, so the tokenizer difference dominates |
 
 So the heaviest server on the badge is not the heaviest server on Claude. Per-server

package/dist/audit/audit.d.ts

@@ -151,6 +151,13 @@ export interface AuditReport {
         worstTotal: number;
         worstSource: string;
         over: boolean;
+        /**
+         * Servers in the audited configs with no number, when there are any. Their
+         * cost is missing from `worstTotal`, so the budget could not be checked
+         * against the whole stack and the verdict fails rather than passing on a
+         * total that understates by an unknown amount.
+         */
+        unestablished?: string[];
         /** Present only when over budget: the arithmetic of getting back under it. */
         fit?: BudgetFit;
     };

package/dist/audit/audit.js

@@ -319,12 +319,21 @@ export function buildReport(configs, measured, opts = {}) {
         // The worst config is the gate: passing because your *lightest* client fits
         // would be a green check on a session you don't run.
         const worst = results[0];
+        // A total is only a ceiling to compare against if it is the whole cost. A
+        // server that failed to start contributes 0, so the stack reads lighter
+        // than it is and the budget passes on a number that is missing a server —
+        // exactly the PR the README says this gate catches. The server-level gate
+        // (core/server-diff.ts) already refuses this; so does this one now.
+        const unestablished = results.flatMap((c) => c.skipped.filter((s) => s.status !== 'remote-not-measurable').map((s) => `${c.source}: ${s.name} (${s.status})`));
         const over = (worst?.totalTokens ?? 0) > opts.budget;
         report.budget = {
             limit: opts.budget,
             worstTotal: worst?.totalTokens ?? 0,
             worstSource: worst?.source ?? '(none)',
-            over,
+            over: over || unestablished.length > 0,
+            // Named so the reader knows which way the number is wrong: the total
+            // understates by however much these cost, which nobody knows.
+            unestablished: unestablished.length ? unestablished : undefined,
             fit: over && worst ? planBudgetFit(worst, opts.budget) : undefined,
         };
     }
@@ -739,6 +748,15 @@ export function formatReport(report) {
             const headroom = b.limit - b.worstTotal;
             lines.push(`budget ok: ${n(b.worstTotal)} ≤ ${n(b.limit)} — ${n(headroom)} to spare`);
         }
+        else if (b.unestablished && b.worstTotal <= b.limit) {
+            // Under the line on what was measured, but not everything was: say which
+            // way the number is wrong rather than passing on it.
+            lines.push(`BUDGET FAIL: ${n(b.worstTotal)} ≤ ${n(b.limit)}, but the budget could not be checked against the ` +
+                `whole stack — ${b.unestablished.length} server(s) produced no number, so this total understates ` +
+                `by however much they cost:`);
+            for (const u of b.unestablished)
+                lines.push(`  ${u}`);
+        }
         else {
             lines.push(`BUDGET FAIL: ${n(b.worstTotal)} > ${n(b.limit)} (${b.worstSource})`);
             const fit = b.fit;

package/dist/audit/diff.js

@@ -21,6 +21,17 @@ export function parseBaselineReport(text) {
         if (!c || typeof c !== 'object' || typeof c.source !== 'string') {
             return { report: null, problem: 'baseline has a config entry without a source path' };
         }
+        // The number the diff subtracts from. Unchecked, a hand-trimmed or
+        // jq-filtered baseline yields `after - undefined === NaN`, and `typeof NaN`
+        // is 'number' — so the gate reported an increase of 0 and passed. A
+        // baseline that cannot be read is never "no change".
+        const total = c.totalTokens;
+        if (typeof total !== 'number' || !Number.isFinite(total)) {
+            return {
+                report: null,
+                problem: `baseline config ${c.source} has no usable totalTokens — is it the output of \`audit --json\`?`,
+            };
+        }
     }
     return { report: doc };
 }
@@ -69,9 +80,25 @@ export function diffConfig(before, after, matchedBy) {
             continue;
         }
         if (!bs && as) {
-            servers.push(as.tokens === null
-                ? { name, kind: 'added', before: null, after: null, delta: null, note: 'added but not measurable — its cost is unknown, not zero' }
-                : { name, kind: 'added', before: null, after: as.tokens, delta: as.tokens });
+            if (as.tokens === null) {
+                // Unknown, not zero — so the total this diff subtracts from does not
+                // contain it and the increase understates. Marking the config inexact
+                // is what stops `--max-increase` from passing: a server added in a PR
+                // and unmeasurable in CI (no credential — the ordinary case) otherwise
+                // reads as +0 and clears even a zero-token allowance.
+                exact = false;
+                servers.push({
+                    name,
+                    kind: 'added',
+                    before: null,
+                    after: null,
+                    delta: null,
+                    note: 'added but not measurable — its cost is unknown, not zero',
+                });
+            }
+            else {
+                servers.push({ name, kind: 'added', before: null, after: as.tokens, delta: as.tokens });
+            }
             continue;
         }
         if (!bs || !as)
@@ -298,13 +325,17 @@ export function evaluateIncreaseGate(diff, limit) {
             reasons.push(`${c.source}: no baseline to check its ${n(c.afterTotal)} tokens against`);
         }
         else if (!c.exact) {
-            reasons.push(`${c.source}: a server changed measured-ness, so the change could not be established exactly`);
+            reasons.push(`${c.source}: a server's cost is not established on both sides, so the change could not be established exactly`);
         }
     }
     for (const d of diff.droppedConfigs) {
         reasons.push(`${d.source}: covered by the baseline and not found in this run`);
     }
-    const increase = diff.worstIncrease?.delta ?? (diff.configs.some((c) => typeof c.delta === 'number') ? 0 : null);
+    // `Number.isFinite`, not `typeof === 'number'`: NaN passes the latter and
+    // then compares false against every limit, which is a silent pass.
+    const anyDelta = diff.configs.some((c) => Number.isFinite(c.delta));
+    const worst = diff.worstIncrease?.delta;
+    const increase = Number.isFinite(worst) ? worst : anyDelta ? 0 : null;
     if (reasons.length === 0 && increase !== null && increase > limit) {
         reasons.push(`${diff.worstIncrease.source}: +${n(increase)} tokens per request, over the ${n(limit)} allowed`);
     }

package/dist/cli.d.ts

@@ -27,6 +27,11 @@ export declare function unknownFlags(argv: string[], spec: {
     value: string[];
     boolean: string[];
 }): string[];
+/** Every flag name a command accepts — what tells a value apart from the next flag. */
+export declare const knownFlagNames: (spec: {
+    value: string[];
+    boolean: string[];
+}) => Set<string>;
 /**
  * Every value a value-taking flag was given, in either accepted spelling:
  * `--flag value` and `--flag=value`.
@@ -37,9 +42,9 @@ export declare function unknownFlags(argv: string[], spec: {
  * matched the bare token, so the gate it asked for silently did not run and the
  * command exited 0 — a green check on a check that never happened.
  */
-export declare function flagValues(argv: string[], name: string): string[];
+export declare function flagValues(argv: string[], name: string, known?: Set<string>): string[];
 /** The last value given for a flag, or undefined when the flag is absent. */
-export declare function flagValue(argv: string[], name: string): string | undefined;
+export declare function flagValue(argv: string[], name: string, known?: Set<string>): string | undefined;
 /**
  * Value-taking flags that appear with no usable value.
  *

package/dist/cli.js

@@ -85,6 +85,21 @@ export function unknownFlags(argv, spec) {
     }
     return unknown;
 }
+/**
+ * Whether a token is another flag of *this* command, rather than a value that
+ * merely looks like one.
+ *
+ * The distinction is load-bearing: `--command "--weird"` is a legitimate launch
+ * command this CLI has always accepted, while `--max-increase --json` is a
+ * value slot swallowed by the next flag. Deciding on the `--` prefix alone
+ * cannot tell them apart; deciding against the command's own flag list can, and
+ * the list is already declared at every call site.
+ */
+function isKnownFlagToken(tok, known) {
+    return tok.startsWith('--') && known.has(tok.slice(2).split('=')[0]);
+}
+/** Every flag name a command accepts — what tells a value apart from the next flag. */
+export const knownFlagNames = (spec) => new Set([...spec.value, ...spec.boolean]);
 /**
  * Every value a value-taking flag was given, in either accepted spelling:
  * `--flag value` and `--flag=value`.
@@ -95,15 +110,15 @@ export function unknownFlags(argv, spec) {
  * matched the bare token, so the gate it asked for silently did not run and the
  * command exited 0 — a green check on a check that never happened.
  */
-export function flagValues(argv, name) {
+export function flagValues(argv, name, known = new Set()) {
     const out = [];
     for (let i = 0; i < argv.length; i++) {
         const tok = argv[i];
         if (tok === `--${name}`) {
             const next = argv[i + 1];
-            // A following flag is not this flag's value; that case is a usage error,
-            // caught by `valuelessFlags`, and must not be read as a value here.
-            if (next !== undefined && !next.startsWith('--'))
+            // Another flag of this command is not this flag's value; that case is a
+            // usage error, caught by `valuelessFlags`, and never read as a value.
+            if (next !== undefined && !isKnownFlagToken(next, known))
                 out.push(next);
             continue;
         }
@@ -113,8 +128,8 @@ export function flagValues(argv, name) {
     return out;
 }
 /** The last value given for a flag, or undefined when the flag is absent. */
-export function flagValue(argv, name) {
-    const values = flagValues(argv, name);
+export function flagValue(argv, name, known = new Set()) {
+    const values = flagValues(argv, name, known);
     return values.length ? values[values.length - 1] : undefined;
 }
 /**
@@ -128,6 +143,7 @@ export function flagValue(argv, name) {
  * so it is refused in the same place and with the same severity.
  */
 export function valuelessFlags(argv, spec) {
+    const known = knownFlagNames(spec);
     const bad = [];
     for (let i = 0; i < argv.length; i++) {
         const tok = argv[i];
@@ -142,7 +158,7 @@ export function valuelessFlags(argv, spec) {
             continue;
         }
         const next = argv[i + 1];
-        if (next === undefined || next.startsWith('--'))
+        if (next === undefined || isKnownFlagToken(next, known))
             bad.push(`--${name}`);
         else
             i++; // consume the value, so `--command "--weird"` is not re-read as a flag
@@ -169,7 +185,7 @@ function rejectUnknownFlags(cmd, argv, spec) {
 }
 const [, , cmd, ...rest] = process.argv;
 if (cmd === 'audit') {
-    rejectUnknownFlags('audit', rest, {
+    const spec = {
         value: [
             'config',
             'budget',
@@ -183,9 +199,14 @@ if (cmd === 'audit') {
             'capture-index-url',
         ],
         boolean: ['json', 'docker', 'claude', 'suggest', 'changed'],
-    });
-    const argOf = (name) => flagValue(rest, name);
-    const all = (name) => flagValues(rest, name);
+    };
+    rejectUnknownFlags('audit', rest, spec);
+    // The same flag list the rejection used, so a value that merely looks like a
+    // flag (`--command "--weird"`) is told apart from a value slot swallowed by
+    // the next flag.
+    const known = knownFlagNames(spec);
+    const argOf = (name) => flagValue(rest, name, known);
+    const all = (name) => flagValues(rest, name, known);
     const json = rest.includes('--json');
     const numeric = (name) => {
         const raw = argOf(name);
@@ -315,9 +336,10 @@ if (cmd === 'audit') {
     process.exit(report.budget?.over || report.increaseGate?.pass === false ? 1 : 0);
 }
 else if (cmd === 'verify') {
-    rejectUnknownFlags('verify', rest, { value: ['remote'], boolean: ['json'] });
+    const spec = { value: ['remote'], boolean: ['json'] };
+    rejectUnknownFlags('verify', rest, spec);
     const json = rest.includes('--json');
-    const remoteUrl = flagValue(rest, 'remote');
+    const remoteUrl = flagValue(rest, 'remote', knownFlagNames(spec));
     const path = rest.find((a) => !a.startsWith('--') && a !== remoteUrl);
     if (!remoteUrl && !path) {
         console.error('usage: mcp-context-cost verify <measurement.json> [--json]');
@@ -361,11 +383,13 @@ else if (cmd === 'verify') {
     process.exit(1);
 }
 else if (cmd === 'measure') {
-    rejectUnknownFlags('measure', rest, {
+    const spec = {
         value: ['name', 'command', 'remote', 'timeout', 'docker-image', 'baseline', 'max-increase', 'budget'],
         boolean: ['docker'],
-    });
-    const argOf = (name) => flagValue(rest, name);
+    };
+    rejectUnknownFlags('measure', rest, spec);
+    const known = knownFlagNames(spec);
+    const argOf = (name) => flagValue(rest, name, known);
     const command = argOf('command');
     const remoteUrl = argOf('remote');
     if (remoteUrl && !/^https?:\/\//i.test(remoteUrl)) {

package/dist/core/regression.js

@@ -162,13 +162,36 @@ export function latestChange(server, rows, vectors) {
     if (deltaTokens === 0 && deltaTools === 0)
         return null;
     const deltaPct = from.tokens > 0 ? (deltaTokens / from.tokens) * 100 : 0;
-    // Attribution needs both sides on record, matched by date. A vector file that
-    // only holds the newer capture explains nothing about how the server got there.
+    // Attribution needs both sides on record. Matched by *cost as of that date*,
+    // not by date equality: vectors are deduped by capture and keep the first
+    // date a capture was seen, while `from` is the last row of the previous
+    // plateau — so the two dates coincide only when the previous cost was
+    // measured exactly once. With weekly sweeps and less frequent releases they
+    // almost never do, and a date-equality join therefore reported "only one of
+    // the two captures is on record" while holding both. The vector in force on a
+    // given day is the newest one recorded on or before it.
     let attribution = null;
-    const fromVec = vectors?.entries.find((e) => e.date === from.date);
-    const toVec = vectors?.entries.find((e) => e.date === to.date);
-    if (fromVec && toVec)
+    const inForceOn = (date, tokensThatDay) => {
+        const upto = (vectors?.entries ?? []).filter((e) => e.date <= date);
+        // A same-day re-sweep replaces that day's history row but *appends* a
+        // capture, so one date can carry two. Only one of them is the one the row
+        // describes: prefer the capture whose total is the number history recorded.
+        const agreeing = upto.filter((e) => e.totalTokens === tokensThatDay);
+        const pool = agreeing.length > 0 ? agreeing : upto;
+        return pool.reduce((best, e) => (!best || e.date >= best.date ? e : best), undefined);
+    };
+    const fromVec = inForceOn(from.date, from.tokens);
+    const toVec = inForceOn(to.date, to.tokens);
+    // A vector only explains the row it agrees with. If the totals disagree the
+    // file does not cover this change — say so rather than attributing a delta
+    // to the wrong capture and publishing the mismatch as framing bytes.
+    if (fromVec &&
+        toVec &&
+        fromVec.canonicalSha256 !== toVec.canonicalSha256 &&
+        fromVec.totalTokens === from.tokens &&
+        toVec.totalTokens === to.tokens) {
         attribution = attribute(fromVec, toVec, deltaTokens);
+    }
     return {
         server,
         fromDate: from.date,

package/dist/sweep/dashboard.js

@@ -6,6 +6,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { parse } from 'yaml';
+import { isCurrent } from '../core/divergence.js';
 import { bandColor, BAND_META } from '../core/bands.js';
 import { parseHistory, plottableSeries } from './history.js';
 /** Longest series a sparkline plots — a stat-tile trend, not a full chart. */
@@ -74,7 +75,12 @@ export function generateDashboard(root = process.cwd()) {
         const meta = BAND_META[band];
         const largest = [...m.tools].sort((a, b) => b.tokens - a.tokens)[0];
         const pct = Math.max(1.2, (t / max) * 100);
-        const div = dSrv[r.entry.name];
+        // Gated on the capture it was computed from, exactly as the leaderboard
+        // gates it: four rows here were publishing a Claude cost derived from
+        // bytes that no longer exist, while leaderboard.md printed `—` for the
+        // same four.
+        const dRaw = dSrv[r.entry.name];
+        const div = isCurrent(dRaw, m.canonicalSha256 ?? null) ? dRaw : undefined;
         const claudeTip = div ? ` · in a Claude request: ${fmt(div.claudeDelta)} tok` : '';
         const series = seriesFor(r.entry.name);
         const tokens = series.rows.map((h) => h.tokens);
@@ -107,10 +113,15 @@ export function generateDashboard(root = process.cwd()) {
     const tableRows = measured
         .map((r, i) => {
         const m = r.m;
-        const div = dSrv[r.entry.name];
+        // Gated on the capture it was computed from, exactly as the leaderboard
+        // gates it: four rows here were publishing a Claude cost derived from
+        // bytes that no longer exist, while leaderboard.md printed `—` for the
+        // same four.
+        const dRaw = dSrv[r.entry.name];
+        const div = isCurrent(dRaw, m.canonicalSha256 ?? null) ? dRaw : undefined;
         const tokens = seriesFor(r.entry.name).rows.map((h) => h.tokens);
         const trend = tokens.length > 1
-            ? `${tokens[tokens.length - 1] - tokens[0] >= 0 ? '+' : ''}${fmt(tokens[tokens.length - 1] - tokens[0])} / ${tokens.length}d`
+            ? `${tokens[tokens.length - 1] - tokens[0] >= 0 ? '+' : ''}${fmt(tokens[tokens.length - 1] - tokens[0])} over ${tokens.length} sweeps`
             : '—';
         return `<tr><td>${i + 1}</td><td>${esc(r.entry.name)}</td><td class="num">${fmt(m.totalTokens)}</td><td class="num">${div ? fmt(div.claudeDelta) : '—'}</td><td class="num">${esc(m.toolCount)}</td><td>${esc(BAND_META[bandColor(m.totalTokens)].label)}</td><td>${esc(r.entry.category)}</td><td class="num">${trend}</td></tr>`;
     })
@@ -227,7 +238,7 @@ export function generateDashboard(root = process.cwd()) {
   </div>
 
   <h2>Leaderboard</h2>
-  <p class="h2sub">Tokens = o200k_base count of the canonical <code>tools/list</code> bytes — the wire payload. What a <em>Claude request</em> actually carries can differ sharply (github: 54,422 on the wire, ${dSrv['github'] ? fmt(dSrv['github'].claudeDelta) : '…'} in a request — 80% of its schema bytes are fields no Anthropic request sends). The trend line plots tokens across every sweep date on record (oldest→newest, dot = current); servers with one sweep so far show no line yet, and a sweep taken under different isolation than the current one is left out rather than drawn as a change in the server. Hover a row for exact numbers; <a href="METHODOLOGY.html#claude-divergence">method</a>.</p>
+  <p class="h2sub">Tokens = o200k_base count of the canonical <code>tools/list</code> bytes — the wire payload. What a <em>Claude request</em> actually carries can differ sharply (a server can spend most of its schema bytes on fields no Anthropic request sends, and the denser tokenizer can push the rest back up). The trend line plots tokens across every sweep date on record (oldest→newest, dot = current); servers with one sweep so far show no line yet, and a sweep taken under different isolation than the current one is left out rather than drawn as a change in the server. Hover a row for exact numbers; <a href="METHODOLOGY.html#claude-divergence">method</a>.</p>
   <div class="board">
 ${barRows || '<p class="h2sub">Sweep in progress — first results land shortly.</p>'}
   </div>

package/dist/sweep/published-stats.d.ts

@@ -28,17 +28,22 @@ export interface PublishedStats {
         /** Rows the leaderboard prints a claude number for: measured AND capture-current. */
         currentCount: number;
         heaviestClaudeName: string | null;
+        /** `claudeTokens` is null when the published row no longer matches the capture on disk. */
         github: {
             badgeTokens: number;
-            mappedTokens: number;
-            claudeTokens: number;
-            droppedPct: number;
+            claudeTokens: number | null;
         };
         notion: {
             badgeTokens: number;
-            claudeTokens: number;
+            claudeTokens: number | null;
         };
-        /** Field-selection share across the run's rows, as fractions of the payload. */
+        /** The current row showing the largest field-selection effect, and its two counts. */
+        widest: {
+            server: string;
+            full: number;
+            mapped: number;
+        };
+        /** Field-selection share across the run's *current* rows, as fractions of the payload. */
         shareMin: number;
         shareMax: number;
         /** claudeDelta / o200kFull across the run's rows that carry a number. */

package/dist/sweep/published-stats.js

@@ -75,25 +75,48 @@ export function computePublishedStats(entries, root = process.cwd()) {
     }
     if (!div)
         throw new Error('results/divergence.json is missing — README states its numbers');
-    const divRow = (name) => {
+    /**
+     * A divergence row only where it still describes the capture on disk.
+     *
+     * The staleness gate is the whole discipline of this column, and skipping it
+     * here is how README came to print two different costs for github on one
+     * page: 54,422 from a row computed against bytes that no longer existed,
+     * beside 54,622 from the measurement. `withClaude` below already applied
+     * `isCurrent` to the very same run — the rule guarded one number and not its
+     * neighbour.
+     */
+    const currentDivRow = (name) => {
         const d = div.servers[name];
         if (!d)
             throw new Error(`README's Claude table names ${name}, which is not in the divergence run`);
-        return d;
+        const onDisk = rows.find((r) => r.entry.name === name)?.m?.canonicalSha256 ?? null;
+        return isCurrent(d, onDisk) ? d : null;
     };
-    const github = divRow('github');
-    const notion = divRow('notion');
-    const githubShare = fieldSelectionShare(github);
-    if (githubShare === null)
-        throw new Error('divergence run carries no o200k counts for github');
-    const runRows = Object.values(div.servers);
-    const shares = runRows.map((r) => fieldSelectionShare(r)).filter((s) => s !== null);
-    const ratios = runRows
-        .filter((r) => typeof r.claudeDelta === 'number' && r.claudeDelta > 0 && r.o200kFull > 0)
-        .map((r) => r.claudeDelta / r.o200kFull);
+    /** The badge number comes from the measurement, never from a divergence row's copy of it. */
+    const badgeTokensOf = (name) => {
+        const r = measured.find((x) => x.entry.name === name);
+        if (!r)
+            throw new Error(`README's Claude table names ${name}, which has no current measurement`);
+        return r.m.totalTokens;
+    };
+    // Ranges are stated over the rows that are still current, for the same
+    // reason: a range whose endpoint comes from a superseded capture describes a
+    // set that no longer exists.
+    const currentRows = Object.entries(div.servers).filter(([name, r]) => isCurrent(r, rows.find((x) => x.entry.name === name)?.m?.canonicalSha256 ?? null));
+    const shares = currentRows
+        .map(([, r]) => fieldSelectionShare(r))
+        .filter((s) => s !== null && s >= 0);
+    const ratios = currentRows
+        .filter(([, r]) => typeof r.claudeDelta === 'number' && r.claudeDelta > 0 && r.o200kFull > 0)
+        .map(([, r]) => r.claudeDelta / r.o200kFull);
     if (shares.length === 0 || ratios.length === 0) {
-        throw new Error('divergence run carries no usable rows — METHODOLOGY states its ranges');
+        throw new Error('no current divergence row — METHODOLOGY states ranges over them; run `npm run divergence`');
     }
+    // The exemplar METHODOLOGY names for the field-selection effect is whichever
+    // current row shows it most, rather than a server hardcoded into the prose.
+    const widest = currentRows
+        .filter(([, r]) => (fieldSelectionShare(r) ?? -1) >= 0)
+        .sort((a, b) => (fieldSelectionShare(b[1]) ?? 0) - (fieldSelectionShare(a[1]) ?? 0))[0];
     const withClaude = measured.filter((r) => isCurrent(div.servers[r.entry.name], r.m.canonicalSha256));
     const heaviest = [...withClaude].sort((a, b) => div.servers[b.entry.name].claudeDelta - div.servers[a.entry.name].claudeDelta)[0];
     const costlier = measured.filter((r) => {
@@ -118,13 +141,9 @@ export function computePublishedStats(entries, root = process.cwd()) {
             runSize: Object.keys(div.servers).length,
             currentCount: withClaude.length,
             heaviestClaudeName: heaviest?.entry.name ?? null,
-            github: {
-                badgeTokens: github.o200kFull,
-                mappedTokens: github.o200kMapped,
-                claudeTokens: github.claudeDelta,
-                droppedPct: Math.round(githubShare * 100),
-            },
-            notion: { badgeTokens: notion.o200kFull, claudeTokens: notion.claudeDelta },
+            github: { badgeTokens: badgeTokensOf('github'), claudeTokens: currentDivRow('github')?.claudeDelta ?? null },
+            notion: { badgeTokens: badgeTokensOf('notion'), claudeTokens: currentDivRow('notion')?.claudeDelta ?? null },
+            widest: { server: widest[0], full: widest[1].o200kFull, mapped: widest[1].o200kMapped },
             shareMin: Math.min(...shares),
             shareMax: Math.max(...shares),
             ratioMin: Math.min(...ratios),
@@ -140,6 +159,8 @@ export function computePublishedStats(entries, root = process.cwd()) {
 }
 export const PAGE_FILES = ['README.md', 'docs/index.md', 'docs/METHODOLOGY.md'];
 const fmt = (n) => n.toLocaleString('en-US');
+/** A number, or the em-dash that means "no current measurement" everywhere else here. */
+const q = (n) => (n === null ? '—' : fmt(n));
 export const PAGE_CLAIMS = [
     {
         file: 'README.md',
@@ -210,14 +231,14 @@ export const PAGE_CLAIMS = [
     {
         file: 'README.md',
         id: 'claude-table:github',
-        template: '| github | {n} | **{n}** | {d}% of the capture is `annotations`/`outputSchema` metadata Claude never sees |',
-        values: (s) => [fmt(s.claude.github.badgeTokens), fmt(s.claude.github.claudeTokens), String(s.claude.github.droppedPct)],
+        template: '| github | {n} | **{q}** | most of the capture is `annotations`/`outputSchema` metadata Claude never sees |',
+        values: (s) => [fmt(s.claude.github.badgeTokens), q(s.claude.github.claudeTokens)],
     },
     {
         file: 'README.md',
         id: 'claude-table:notion',
-        template: '| notion | {n} | **{n}** | almost no metadata to drop, so the tokenizer difference dominates |',
-        values: (s) => [fmt(s.claude.notion.badgeTokens), fmt(s.claude.notion.claudeTokens)],
+        template: '| notion | {n} | **{q}** | almost no metadata to drop, so the tokenizer difference dominates |',
+        values: (s) => [fmt(s.claude.notion.badgeTokens), q(s.claude.notion.claudeTokens)],
     },
     {
         file: 'README.md',
@@ -252,12 +273,15 @@ export const PAGE_CLAIMS = [
     {
         file: 'docs/METHODOLOGY.md',
         id: 'divergence:share-range',
-        template: 'this removes between {f}% and **{f}%** of the payload (github: {n} → {n} tokens).',
+        template: 'this removes between {f}% and **{f}%** of the payload ({w}: {n} → {n} tokens).',
+        // The exemplar is whichever current row shows the effect most, not a server
+        // named in the prose — a hardcoded name goes stale the week it is re-swept.
         values: (s) => [
             (s.claude.shareMin * 100).toFixed(1),
             (s.claude.shareMax * 100).toFixed(1),
-            fmt(s.claude.github.badgeTokens),
-            fmt(s.claude.github.mappedTokens),
+            s.claude.widest.server,
+            fmt(s.claude.widest.full),
+            fmt(s.claude.widest.mapped),
         ],
     },
     {
@@ -303,7 +327,7 @@ const escapeLiteral = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\
 export function compileTemplate(template) {
     let source = '';
     let last = 0;
-    for (const slot of template.matchAll(/\{[ndwf]\}/g)) {
+    for (const slot of template.matchAll(/\{[ndwfq]\}/g)) {
         source += escapeLiteral(template.slice(last, slot.index));
         source +=
             slot[0] === '{n}'
@@ -312,7 +336,11 @@ export function compileTemplate(template) {
                     ? '(\\d+)'
                     : slot[0] === '{f}'
                         ? '(\\d+\\.\\d+)'
-                        : '([A-Za-z0-9._-]+)';
+                        : // `{q}` is a number that may not exist: the em-dash the leaderboard
+                            // already prints for a row whose capture has moved on.
+                            slot[0] === '{q}'
+                                ? '([\\d,]+|—)'
+                                : '([A-Za-z0-9._-]+)';
         last = slot.index + slot[0].length;
     }
     source += escapeLiteral(template.slice(last));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-context-cost",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "Measure what your MCP servers cost in context tokens — audit your own config, or badge the server you publish",
   "type": "module",
   "license": "MIT",