mcp-context-cost 0.1.0 → 0.3.0

package/dist/sweep/report.d.ts

@@ -1,3 +1,4 @@
+import { type DivergenceRun } from '../core/divergence.js';
 export interface ServerEntry {
     name: string;
     command: string;
@@ -11,6 +12,10 @@ export interface ServerEntry {
     dockerImage?: string;
     timeoutSeconds?: number;
 }
+/** Neutralize markdown/table syntax in third-party strings (tool names, notes). */
+export declare function mdCell(s: unknown): string;
+/** results/divergence.json if a divergence run has been recorded, else null. */
+export declare function loadDivergence(root?: string): DivergenceRun | null;
 export declare function writeLeaderboard(entries: ServerEntry[], root?: string): void;
 /** Percentile helper for freezing color bands against the observed distribution. */
 export declare function percentiles(entries: ServerEntry[], root?: string): Record<string, number>;

package/dist/sweep/report.js

@@ -4,8 +4,9 @@
  */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { isCurrent, parseDivergence } from '../core/divergence.js';
 /** Neutralize markdown/table syntax in third-party strings (tool names, notes). */
-function mdCell(s) {
+export function mdCell(s) {
     return String(s ?? '')
         .replace(/[|`[\]<>]/g, (c) => `\\${c}`)
         .replace(/\r?\n/g, ' ')
@@ -21,8 +22,21 @@ function loadRows(entries, root = process.cwd()) {
         return { entry, m: existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : null };
     });
 }
+/** results/divergence.json if a divergence run has been recorded, else null. */
+export function loadDivergence(root = process.cwd()) {
+    const p = join(root, 'results', 'divergence.json');
+    return existsSync(p) ? parseDivergence(readFileSync(p, 'utf8')) : null;
+}
 export function writeLeaderboard(entries, root = process.cwd()) {
     const rows = loadRows(entries, root);
+    const div = loadDivergence(root);
+    /** Claude tokens for a row, or null when not measured / stale / errored. */
+    const claude = (r) => {
+        if (!div || !r.m)
+            return null;
+        const d = div.servers[r.entry.name];
+        return isCurrent(d, r.m.canonicalSha256) ? d.claudeDelta : null;
+    };
     const measured = rows
         .filter((r) => r.m && (r.m.status === 'measured' || r.m.status === 'dynamic'))
         .sort((a, b) => (b.m.totalTokens ?? 0) - (a.m.totalTokens ?? 0));
@@ -31,14 +45,28 @@ export function writeLeaderboard(entries, root = process.cwd()) {
     md.push('# MCP server context-cost leaderboard');
     md.push('');
     md.push(`Tokens = o200k_base count of the canonical \`tools/list\` bytes ([methodology v1.0](../docs/METHODOLOGY.md)). ` +
-        `Measured ${measured.length}/${rows.length} candidates; every candidate is listed — failures are findings, not omissions.`);
+        `Measured ${measured.length}/${rows.length} candidates; every candidate is listed — failures are findings, not omissions. ` +
+        `Server names link to their per-tool breakdown.`);
     md.push('');
-    md.push('| # | server | tokens | tools | largest tool | status | category |');
-    md.push('|---:|---|---:|---:|---|---|---|');
+    if (div) {
+        const n = measured.filter((r) => claude(r) !== null).length;
+        md.push(`The **claude** column is the same tools measured through Anthropic's \`count_tokens\` on ` +
+            `\`${mdCell(div.model)}\` (${mdCell(div.measuredAt)}, method \`${mdCell(div.method)}\`): the tokens the server's ` +
+            `tools add to a request, measured for the top ${n}. It is not a rescaling of the o200k column — ` +
+            `two effects pull in opposite directions, and the [per-server pages](../docs/servers/) break both out. ` +
+            `See [Claude divergence](../docs/METHODOLOGY.md#claude-divergence).`);
+        md.push('');
+    }
+    md.push(`| # | server | tokens |${div ? ' claude |' : ''} tools | largest tool | status | category |`);
+    md.push(`|---:|---|---:|${div ? '---:|' : ''}---:|---|---|---|`);
     measured.forEach((r, i) => {
         const m = r.m;
         const largest = [...m.tools].sort((a, b) => b.tokens - a.tokens)[0];
-        md.push(`| ${i + 1} | ${mdCell(r.entry.name)} | ${m.totalTokens.toLocaleString('en-US')} | ${m.toolCount} | ` +
+        const link = `[${mdCell(r.entry.name)}](../docs/servers/${encodeURIComponent(r.entry.name)}.md)`;
+        const c = claude(r);
+        md.push(`| ${i + 1} | ${link} | ${m.totalTokens.toLocaleString('en-US')} |` +
+            (div ? ` ${c === null ? '—' : c.toLocaleString('en-US')} |` : '') +
+            ` ${m.toolCount} | ` +
             `${largest ? `${mdCell(largest.name)} (${largest.tokens.toLocaleString('en-US')})` : '—'} | ${m.status} | ${mdCell(r.entry.category)} |`);
     });
     md.push('');
@@ -54,9 +82,12 @@ export function writeLeaderboard(entries, root = process.cwd()) {
         md.push('');
     }
     writeFileSync(join(root, 'results', 'leaderboard.md'), md.join('\n') + '\n');
-    const csv = ['name,tokens,toolCount,status,category,metric,metricSource'];
+    // Columns are append-only: consumers key off the header, so adding the Claude
+    // pair at the end leaves every existing parser working.
+    const csv = ['name,tokens,toolCount,status,category,metric,metricSource,claudeTokens,claudeModel'];
     for (const r of rows) {
         const m = r.m;
+        const c = claude(r);
         csv.push([
             csvCell(r.entry.name),
             m?.totalTokens ?? '',
@@ -65,6 +96,8 @@ export function writeLeaderboard(entries, root = process.cwd()) {
             csvCell(r.entry.category),
             r.entry.metric ?? '',
             csvCell(r.entry.metricSource),
+            c ?? '',
+            c === null ? '' : csvCell(div.model),
         ].join(','));
     }
     writeFileSync(join(root, 'results', 'leaderboard.csv'), csv.join('\n') + '\n');

package/dist/sweep/run.d.ts

@@ -7,5 +7,16 @@ export interface MeasureOptions {
     dockerImage?: string;
     /** env var NAMES to provide as dummy values (docker mode). */
     dummyEnv?: string[];
+    /**
+     * Exact argv, when the caller already has it (client configs store command and
+     * args separately). Avoids re-splitting a joined string on spaces, which would
+     * break any path containing one. Host path only — docker still wraps `command`.
+     */
+    argv?: string[];
+    /**
+     * Write results/<name>/measurement.json + badges/<name>.json (default true).
+     * `audit` runs in the user's own directory and must not litter it.
+     */
+    persist?: boolean;
 }
 export declare function measureServer(name: string, command: string, opts?: MeasureOptions): Promise<Measurement>;

package/dist/sweep/run.js

@@ -5,7 +5,8 @@
  * Runs tools/list capture TWICE; differing tool sets -> status "dynamic".
  */
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { captureTools } from './client.js';
 import { dockerize } from './docker.js';
 import { measureTools, failedMeasurement, canonicalString } from '../core/canonical.js';
@@ -15,11 +16,14 @@ function arg(name) {
     return i >= 0 ? process.argv[i + 1] : undefined;
 }
 export async function measureServer(name, command, opts = {}) {
-    if (!/^[a-z0-9][a-z0-9._-]*$/i.test(name) || name.includes('..')) {
+    const persist = opts.persist !== false;
+    // The name becomes a directory when persisting; that's the only reason it's
+    // constrained, so in-memory callers may use whatever the config called it.
+    if (persist && (!/^[a-z0-9][a-z0-9._-]*$/i.test(name) || name.includes('..'))) {
         throw new Error(`invalid server name '${name}' — letters/digits/dot/dash/underscore only`);
     }
     const root = opts.root ?? process.cwd();
-    let spec = command;
+    let spec = opts.argv && opts.argv.length ? { command: opts.argv[0], argv: opts.argv.slice(1) } : command;
     let isolation = { docker: false };
     let containerName;
     if (opts.docker && command.trimStart().startsWith('docker ')) {
@@ -67,6 +71,8 @@ export async function measureServer(name, command, opts = {}) {
             spawn('docker', ['rm', '-f', containerName], { stdio: 'ignore' }).on('error', () => { });
         }
     }
+    if (!persist)
+        return m;
     const resultDir = join(root, 'results', name);
     mkdirSync(resultDir, { recursive: true });
     writeFileSync(join(resultDir, 'measurement.json'), JSON.stringify(m, null, 2) + '\n');
@@ -74,7 +80,10 @@ export async function measureServer(name, command, opts = {}) {
     writeFileSync(join(root, 'badges', `${name}.json`), JSON.stringify(toBadge(m)) + '\n');
     return m;
 }
-const isMain = process.argv[1]?.endsWith('run.ts') || process.argv[1]?.endsWith('run.js');
+// Exact path match, not endsWith('run.ts'): any other file whose name happens to
+// end in "run.ts" (src/audit/run.ts, a scratch dryrun.ts) would otherwise run this
+// block and exit 2 on missing --name.
+const isMain = process.argv[1] !== undefined && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
 if (isMain) {
     const name = arg('name');
     const command = arg('command');
@@ -87,6 +96,10 @@ if (isMain) {
         docker: process.argv.includes('--docker'),
         dockerImage: arg('docker-image'),
     });
+    // CLI path only — measureServer itself stays history-free so concurrent
+    // sweep-all workers never race on the same file.
+    const { appendHistory } = await import('./history.js');
+    appendHistory();
     console.log(m.status === 'measured' || m.status === 'dynamic'
         ? `${name}: ${m.totalTokens} tokens across ${m.toolCount} tools (${m.status})`
         : `${name}: ${m.status} — ${m.notes ?? ''}`);

package/dist/sweep/server-pages.d.ts

@@ -0,0 +1,17 @@
+import type { Measurement } from '../core/types.js';
+import { type ServerEntry } from './report.js';
+import { type HistoryRow } from './history.js';
+import { type DivergenceRun } from '../core/divergence.js';
+/** One server's page. `history` is that server's rows, oldest first. */
+export declare function renderServerPage(entry: ServerEntry, m: Measurement, history?: HistoryRow[], divergence?: DivergenceRun | null): string;
+/** The index that lists every candidate — measured ones link to their page. */
+export declare function renderServerIndex(rows: {
+    entry: ServerEntry;
+    m: Measurement | null;
+}[]): string;
+/** Write docs/servers/*.md for every measured server, plus the index. */
+export declare function writeServerPages(entries: ServerEntry[], root?: string): {
+    pages: number;
+};
+/** Public URL of a server's page — used by the leaderboard and the badge snippet. */
+export declare function serverPageUrl(name: string): string;

package/dist/sweep/server-pages.js

@@ -0,0 +1,228 @@
+/**
+ * Per-server detail pages: docs/servers/<name>.md plus an index.
+ *
+ * These are the badge's click-through target. A badge says "12,430 tokens";
+ * the page behind it says which tools those tokens are in, what launched the
+ * server, the hash of the bytes counted, and the one command that re-derives
+ * the number. Generated from results/ only — no network, no timestamps beyond
+ * the measurement's own, so regenerating without a new sweep is a no-op diff.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { bandColor, BAND_META } from '../core/bands.js';
+import { loadDivergence, mdCell } from './report.js';
+import { parseHistory } from './history.js';
+import { claudeRatio, fieldSelectionShare, isCurrent } from '../core/divergence.js';
+/**
+ * Pages are served from GitHub Pages (docs/), but results/ and badges/ are not
+ * published there — links into them must be absolute repo URLs.
+ */
+const REPO_URL = 'https://github.com/athakur3/mcp-context-cost';
+const BLOB = `${REPO_URL}/blob/main`;
+const PAGES_URL = 'https://athakur3.github.io/mcp-context-cost';
+/** Longest per-tool table we print inline; the rest live in the raw capture. */
+const MAX_TOOL_ROWS = 30;
+const fmt = (n) => n.toLocaleString('en-US');
+/** True when a measurement produced a number we can stand behind. */
+function isMeasured(m) {
+    return !!m && (m.status === 'measured' || m.status === 'dynamic') && typeof m.totalTokens === 'number';
+}
+function isolationText(m) {
+    const iso = m.isolation;
+    if (!iso)
+        return 'not recorded';
+    if (!iso.docker)
+        return 'host process (no container)';
+    return ['docker', iso.image, iso.network ? `network ${iso.network}` : '', iso.note]
+        .filter(Boolean)
+        .join(' · ');
+}
+/**
+ * The Claude divergence section: the headline, the projection onto the three
+ * fields an Anthropic tool definition carries, and Claude's own count of that
+ * projection. Printed only when a current divergence row exists for this server.
+ */
+function divergenceSection(row, run) {
+    const share = fieldSelectionShare(row);
+    const ratio = claudeRatio(row);
+    const md = [];
+    md.push('## What this costs on Claude');
+    md.push('');
+    md.push(`Measured ${mdCell(run.measuredAt)} against \`${mdCell(run.model)}\` via Anthropic's \`count_tokens\` ` +
+        `(method \`${mdCell(run.method)}\`).`);
+    md.push('');
+    md.push('| | tokens | |');
+    md.push('|---|---:|---|');
+    md.push(`| o200k, full capture | ${fmt(row.o200kFull)} | the badge number — every byte \`tools/list\` returned |`);
+    md.push(`| o200k, Anthropic fields only | ${fmt(row.o200kMapped)} | ` +
+        `${share === null ? '—' : `${(share * 100).toFixed(1)}% of the capture is MCP-only metadata`} |`);
+    md.push(`| **Claude, same fields** | **${fmt(row.claudeDelta)}** | ` +
+        `${ratio === null ? '—' : `${ratio.toFixed(2)}× the badge number`} |`);
+    md.push('');
+    md.push(`An Anthropic tool definition carries \`name\`, \`description\`, and \`input_schema\` and nothing else, so ` +
+        `\`title\`, \`annotations\`, \`outputSchema\`, \`execution\`, and \`icons\` are dropped before the request — ` +
+        `that is the second row. The third row is the same tools counted by Anthropic, which is larger than the ` +
+        `second because Anthropic's tokenizer is denser on this content than o200k_base *and* the API adds its own ` +
+        `framing (at most ${fmt(run.probeDelta)} tokens of it fixed, measured against a single minimal tool). ` +
+        `The two effects run in opposite directions, which is why the Claude number is not a fixed multiple of the badge.`);
+    md.push('');
+    return md;
+}
+/** One server's page. `history` is that server's rows, oldest first. */
+export function renderServerPage(entry, m, history = [], divergence = null) {
+    const total = m.totalTokens;
+    const band = BAND_META[bandColor(total)];
+    const tools = [...m.tools].sort((a, b) => b.tokens - a.tokens);
+    const shown = tools.slice(0, MAX_TOOL_ROWS);
+    const pct = (n) => (total > 0 ? `${((n / total) * 100).toFixed(1)}%` : '—');
+    const md = [];
+    md.push(`# ${mdCell(entry.name)} — context cost`);
+    md.push('');
+    md.push(`**${fmt(total)} tokens** across ${m.toolCount} tools — *${band.label}* (${band.range}). ` +
+        `Measured ${String(m.measuredAt).slice(0, 10)} under [methodology v${mdCell(m.methodologyVersion)}](../METHODOLOGY.html).`);
+    md.push('');
+    md.push('| | |');
+    md.push('|---|---|');
+    md.push(`| server (self-reported) | ${mdCell(m.serverName)}${m.serverVersion ? ` v${mdCell(String(m.serverVersion).replace(/^v/, ''))}` : ''} |`);
+    md.push(`| status | ${mdCell(m.status)} |`);
+    md.push(`| tokenizer | ${mdCell(m.provider)} / ${mdCell(m.encoding)} |`);
+    md.push(`| launch command | \`${mdCell(m.launchCommand ?? entry.command)}\` |`);
+    md.push(`| isolation | ${mdCell(isolationText(m))} |`);
+    md.push(`| env vars supplied | ${m.envVarNames?.length ? m.envVarNames.map(mdCell).join(', ') : 'none'} |`);
+    md.push(`| canonical SHA-256 | \`${mdCell(m.canonicalSha256)}\` |`);
+    if (entry.category)
+        md.push(`| category | ${mdCell(entry.category)} |`);
+    if (entry.repo)
+        md.push(`| source | ${mdCell(entry.repo)} |`);
+    md.push('');
+    if (m.status === 'dynamic') {
+        md.push('> This server\'s `tools/list` differed between two consecutive captures, so the number ' +
+            'is the first capture and moves between sweeps. Treat it as a range, not a constant.');
+        md.push('');
+    }
+    md.push('## Where the tokens are');
+    md.push('');
+    md.push('| tool | tokens | share | description | schema |');
+    md.push('|---|---:|---:|---:|---:|');
+    for (const t of shown) {
+        md.push(`| ${mdCell(t.name)} | ${fmt(t.tokens)} | ${pct(t.tokens)} | ${fmt(t.descriptionTokens)} | ${fmt(t.inputSchemaTokens)} |`);
+    }
+    md.push('');
+    if (tools.length > shown.length) {
+        const rest = tools.slice(shown.length).reduce((s, t) => s + t.tokens, 0);
+        md.push(`*${tools.length - shown.length} smaller tools omitted (${fmt(rest)} tokens combined) — ` +
+            `all of them are in the [raw capture](${BLOB}/results/${encodeURIComponent(entry.name)}/measurement.json).*`);
+        md.push('');
+    }
+    md.push('Each tool is tokenized on its own, so the parts do not sum exactly to the whole: the ' +
+        'array adds its own brackets and commas, and the tokenizer merges tokens across object ' +
+        'boundaries. The badge number is always the count of the whole array, never a sum of parts.');
+    md.push('');
+    const divRow = divergence?.servers[entry.name];
+    if (divergence && isCurrent(divRow, m.canonicalSha256)) {
+        md.push(...divergenceSection(divRow, divergence));
+    }
+    if (history.length > 1) {
+        md.push('## Over time');
+        md.push('');
+        md.push('| date | tokens | tools | change |');
+        md.push('|---|---:|---:|---:|');
+        history.forEach((h, i) => {
+            const prev = history[i - 1];
+            const delta = prev ? h.tokens - prev.tokens : null;
+            const change = delta === null ? '—' : delta === 0 ? 'no change' : `${delta > 0 ? '+' : ''}${fmt(delta)}`;
+            md.push(`| ${mdCell(h.date)} | ${fmt(h.tokens)} | ${h.toolCount} | ${change} |`);
+        });
+        md.push('');
+        md.push(`Full series: [results/history.csv](${BLOB}/results/history.csv).`);
+        md.push('');
+    }
+    md.push('## Re-derive it');
+    md.push('');
+    md.push('```bash');
+    md.push(`npx -y mcp-context-cost verify results/${entry.name}/measurement.json`);
+    md.push('```');
+    md.push('');
+    md.push(`That re-tokenizes the [published capture](${BLOB}/results/${encodeURIComponent(entry.name)}/measurement.json) ` +
+        `and checks the count and the hash. If it disagrees with the badge, the badge is wrong — ` +
+        `[open an issue](${REPO_URL}/issues) and it gets corrected.`);
+    md.push('');
+    md.push(`[Badge JSON](${BLOB}/badges/${encodeURIComponent(entry.name)}.json) · ` +
+        `[All servers](index.html) · [Leaderboard](${BLOB}/results/leaderboard.md) · ` +
+        `[Methodology](../METHODOLOGY.html)`);
+    md.push('');
+    return md.join('\n');
+}
+/** The index that lists every candidate — measured ones link to their page. */
+export function renderServerIndex(rows) {
+    const measured = rows.filter((r) => isMeasured(r.m)).sort((a, b) => b.m.totalTokens - a.m.totalTokens);
+    const rest = rows.filter((r) => !isMeasured(r.m));
+    const md = [];
+    md.push('# Server pages');
+    md.push('');
+    md.push(`One page per measured server: the per-tool breakdown behind the badge, the exact launch ` +
+        `command, and the command that re-derives the number. ${measured.length} of ${rows.length} ` +
+        `candidates measured.`);
+    md.push('');
+    md.push('| # | server | tokens | tools | band |');
+    md.push('|---:|---|---:|---:|---|');
+    measured.forEach((r, i) => {
+        const t = r.m.totalTokens;
+        md.push(`| ${i + 1} | [${mdCell(r.entry.name)}](${encodeURIComponent(r.entry.name)}.html) | ${fmt(t)} | ` +
+            `${r.m.toolCount} | ${BAND_META[bandColor(t)].label} |`);
+    });
+    md.push('');
+    if (rest.length > 0) {
+        md.push('## Not measured');
+        md.push('');
+        md.push('No page: there is no number to show. The reason is recorded per candidate.');
+        md.push('');
+        md.push('| server | status |');
+        md.push('|---|---|');
+        for (const r of rest) {
+            const status = r.entry.remote ? 'remote-auth-wall' : (r.m?.status ?? 'not-yet-run');
+            md.push(`| ${mdCell(r.entry.name)} | ${mdCell(status)} |`);
+        }
+        md.push('');
+    }
+    md.push(`[Leaderboard](${BLOB}/results/leaderboard.md) · [Methodology](../METHODOLOGY.html) · [Dashboard](../dashboard.html)`);
+    md.push('');
+    return md.join('\n');
+}
+/** Write docs/servers/*.md for every measured server, plus the index. */
+export function writeServerPages(entries, root = process.cwd()) {
+    const outDir = join(root, 'docs', 'servers');
+    mkdirSync(outDir, { recursive: true });
+    const historyPath = join(root, 'results', 'history.csv');
+    const history = existsSync(historyPath) ? parseHistory(readFileSync(historyPath, 'utf8')) : [];
+    const divergence = loadDivergence(root);
+    const rows = entries.map((entry) => {
+        const p = join(root, 'results', entry.name, 'measurement.json');
+        let m = null;
+        if (existsSync(p)) {
+            try {
+                m = JSON.parse(readFileSync(p, 'utf8'));
+            }
+            catch {
+                m = null; // a half-written measurement should not abort the whole run
+            }
+        }
+        return { entry, m };
+    });
+    let pages = 0;
+    for (const { entry, m } of rows) {
+        if (!isMeasured(m))
+            continue;
+        const series = history
+            .filter((h) => h.server === entry.name)
+            .sort((a, b) => a.date.localeCompare(b.date));
+        writeFileSync(join(outDir, `${entry.name}.md`), renderServerPage(entry, m, series, divergence));
+        pages++;
+    }
+    writeFileSync(join(outDir, 'index.md'), renderServerIndex(rows));
+    return { pages };
+}
+/** Public URL of a server's page — used by the leaderboard and the badge snippet. */
+export function serverPageUrl(name) {
+    return `${PAGES_URL}/servers/${encodeURIComponent(name)}.html`;
+}

package/dist/sweep/sweep-all.js

@@ -8,6 +8,7 @@ import { readFileSync } from 'node:fs';
 import { parse } from 'yaml';
 import { measureServer } from './run.js';
 import { writeLeaderboard } from './report.js';
+import { appendHistory } from './history.js';
 function arg(name) {
     const i = process.argv.indexOf(`--${name}`);
     return i >= 0 ? process.argv[i + 1] : undefined;
@@ -45,6 +46,8 @@ async function worker() {
     }
 }
 await Promise.all(Array.from({ length: Math.max(1, concurrency) }, () => worker()));
+// Serial, after every worker has finished: history.csv is a read-modify-write.
 writeLeaderboard(doc.servers);
+const h = appendHistory();
 const measured = Object.values(summary).filter((s) => s.includes('tokens')).length;
-console.log(`done: ${measured}/${entries.length} measured; leaderboard regenerated`);
+console.log(`done: ${measured}/${entries.length} measured; leaderboard + history (${h.rows} rows) regenerated`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-context-cost",
-  "version": "0.1.0",
-  "description": "Reproducible context-cost badges for MCP servers — measure what a server's tool schemas cost before the agent does any work",
+  "version": "0.3.0",
+  "description": "Measure what your MCP servers cost in context tokens — audit your own config, or badge the server you publish",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -15,6 +15,10 @@
     "model-context-protocol",
     "tokens",
     "context-window",
+    "audit",
+    "token-budget",
+    "claude",
+    "cursor",
     "badge",
     "shields",
     "developer-tools"
@@ -29,9 +33,11 @@
   ],
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build && npm test && npm run typecheck",
     "test": "vitest run",
     "test:badge": "./upstream/tests/badge-test.sh",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.tools.json",
+    "divergence": "tsx tools/measure-divergence.ts",
     "sweep": "tsx src/sweep/run.ts",
     "sweep:all": "tsx src/sweep/sweep-all.ts",
     "verify": "tsx src/cli.ts verify"
@@ -44,6 +50,7 @@
     "yaml": "^2.9.0"
   },
   "devDependencies": {
+    "@anthropic-ai/sdk": "^0.117.1",
     "@types/node": "^26.2.0",
     "tsx": "^4.23.12",
     "typescript": "^7.0.2",