mcp-context-cost 0.11.2 → 0.11.3

package/dist/audit/audit.js

@@ -179,6 +179,13 @@ export function buildReport(configs, measured, opts = {}) {
     const contextWindow = opts.contextWindow ?? DEFAULT_CONTEXT_WINDOW;
     const problems = [];
     const emptyConfigs = [];
+    // canonicalSha256 → the divergence row computed from it, so a server can be
+    // identified by its bytes whatever the local config calls it.
+    const divByHash = new Map();
+    for (const row of Object.values(opts.divergence?.servers ?? {})) {
+        if (row?.capturedSha256)
+            divByHash.set(row.capturedSha256, row);
+    }
     const built = [];
     // Across every config at once: a twin in one client's file is measured for
     // the other client's entry just the same.

package/dist/audit/config.js

@@ -182,9 +182,18 @@ export function configCandidates(env) {
 /** Read + parse the candidates that exist. Unreadable files are reported, not thrown. */
 export function loadConfigs(candidates, cwd) {
     const out = [];
+    // Running from your home directory nominates `~/.cursor/mcp.json` twice —
+    // once as the home candidate, once as the cwd one. Loaded twice it is
+    // reported twice, doubles that client's deferral scope, and under
+    // `--baseline` the second copy pairs with nothing and fails the gate. One
+    // path is one config however many ways it was nominated.
+    const seen = new Set();
     for (const c of candidates) {
         if (!existsSync(c.path))
             continue;
+        if (seen.has(c.path))
+            continue;
+        seen.add(c.path);
         try {
             const doc = parseJsonc(readFileSync(c.path, 'utf8'));
             const { servers, disabled } = extractDeclaration(doc, { client: c.client, source: c.path, cwd });

package/dist/audit/diff.js

@@ -181,7 +181,15 @@ export function pairConfigs(before, after) {
             pairs.push({ before: null, after: cur, matchedBy: 'unmatched' });
         }
     }
-    if (before.length === 1 && after.length === 1 && pairs[0].before === null) {
+    // One on each side reads as the same config seen from two machines, where the
+    // path legitimately differs (a laptop's baseline against a CI checkout). It
+    // does not survive the clients differing: a Claude Desktop baseline against a
+    // Claude Code run compares two unrelated stacks, and the gate then rests on
+    // that difference. The paths may differ; what they are configs *for* may not.
+    if (before.length === 1 &&
+        after.length === 1 &&
+        pairs[0].before === null &&
+        before[0].client === after[0].client) {
         pairs[0] = { before: before[0], after: after[0], matchedBy: 'sole-config' };
         unusedBefore.delete(before[0].source);
     }

package/dist/cli.js

@@ -45,6 +45,19 @@ export function slugFromUrl(url) {
     const host = new URL(url).hostname.replace(/^(www|mcp)\./, '');
     return host.replace(/[^a-z0-9]+/gi, '-').replace(/^-+|-+$/g, '').toLowerCase() || 'remote';
 }
+/**
+ * Report a `verify` failure and exit 1, in whichever shape the caller asked
+ * for. `--json` is documented as putting `{ ok, rederivedTokens, rederivedSha,
+ * problems }` on stdout; a script reading that gets nothing from a thrown
+ * exception, so every failure path goes through here.
+ */
+function failVerify(json, problem) {
+    if (json)
+        console.log(JSON.stringify({ ok: false, rederivedTokens: null, rederivedSha: null, problems: [problem] }));
+    else
+        console.error(problem);
+    process.exit(1);
+}
 /** Installed version, for error messages that need to say which one you are running. */
 export function cliVersion() {
     try {
@@ -322,6 +335,12 @@ if (cmd === 'audit') {
                 `${where}\n` +
                 `${empty.length === 1 ? 'It was' : 'They were'} read and parsed; there is simply nothing declared to measure.\n` +
                 `Declare a server in one of them, or point at a different config: mcp-context-cost audit --config <path/to/mcp.json>`);
+        else if (all('config').length)
+            // A path the user named is not a discovery miss. Saying "looked in the
+            // standard locations" describes something the command did not do, and
+            // then advises doing the thing they just did.
+            console.error(`no MCP config found at the path(s) given: ${all('config').join(', ')}. ` +
+                `Nothing else was searched, because --config was set.`);
         else
             console.error(`no MCP config found. Looked in the standard Claude Desktop / Claude Code / Cursor / VS Code / Windsurf locations.${where}\n` +
                 `Point at one explicitly: mcp-context-cost audit --config <path/to/mcp.json>`);
@@ -355,18 +374,29 @@ else if (cmd === 'verify') {
             raw = await res.text();
         }
         catch (e) {
-            const problem = `failed to fetch ${remoteUrl}: ${e.message}`;
-            if (json)
-                console.log(JSON.stringify({ ok: false, rederivedTokens: null, rederivedSha: null, problems: [problem] }));
-            else
-                console.error(problem);
-            process.exit(1);
+            failVerify(json, `failed to fetch ${remoteUrl}: ${e.message}`);
         }
     }
     else {
-        raw = readFileSync(path, 'utf8');
+        try {
+            raw = readFileSync(path, 'utf8');
+        }
+        catch (e) {
+            // The remote branch above reports a failed fetch in the documented shape;
+            // this one used to throw, so `--json` produced a stack trace on stderr and
+            // nothing at all on stdout — the contract a script parses.
+            failVerify(json, `cannot read ${path}: ${e.message}`);
+        }
+    }
+    let m;
+    try {
+        m = JSON.parse(raw);
+    }
+    catch (e) {
+        // Reachable remotely: a proxy, a captive portal or an HTML error page
+        // served with status 200 passes the `res.ok` check above and arrives here.
+        failVerify(json, `${remoteUrl ?? path} is not valid JSON: ${e.message}`);
     }
-    const m = JSON.parse(raw);
     const r = verifyMeasurement(m);
     if (json) {
         console.log(JSON.stringify({ serverName: m.serverName, ...r, badge: r.ok ? toBadge(m) : undefined }));

package/dist/core/adoption.d.ts

@@ -143,6 +143,14 @@ export declare function decodeLoose(text: string): string;
 export interface EndpointBadge {
     url: string;
     linkTarget: string | null;
+    /**
+     * The badge's own label — markdown alt text or an `<img alt>`. What the badge
+     * calls itself is the only thing in a README that distinguishes *this*
+     * project's badge from any other shields endpoint badge, since the JSON can
+     * be hosted anywhere (the staged action publishes to a gist, with no path
+     * shape to recognise).
+     */
+    alt: string | null;
 }
 /**
  * Every shields endpoint badge in a file, decoded, each paired with its own
@@ -172,6 +180,21 @@ export declare function linksBackToProject(target: string, src?: BadgeSource): b
  * measurement here. See the header for why both count and why the link is
  * paired with the image rather than looked for anywhere in the file.
  */
+/**
+ * Whether a badge calls itself this project's badge.
+ *
+ * The self-hosted branch below used to accept the link alone and look at
+ * nothing else, so *any* shields endpoint badge — a coverage badge, say —
+ * wrapped in a link to this repository counted as displaying ours. That
+ * inflates the one number this project keeps about itself, which is the last
+ * place it can afford a generous reading.
+ *
+ * The URL cannot decide it: self-hosted JSON lives wherever its author put it,
+ * and the staged action publishes to a gist. What every published snippet does
+ * carry is the label — `context cost` — so that is what is read, tolerantly
+ * enough to accept `Context-Cost` and strictly enough to reject `coverage`.
+ */
+export declare function namesThisBadge(alt: string | null): boolean;
 export declare function displaysBadge(text: string, src?: BadgeSource): boolean;
 /**
  * Every shields endpoint `url` in a file whose JSON is served from this

package/dist/core/adoption.js

@@ -137,7 +137,11 @@ export function endpointBadges(text) {
             if (last && !before.slice(last.index ?? 0).includes('</a>'))
                 linkTarget = last[1];
         }
-        out.push({ url: m[1], linkTarget });
+        // Markdown puts the alt before the image; HTML puts it in the same tag.
+        const beforeAlt = decoded.slice(Math.max(0, start - LINK_WINDOW), start);
+        const mdAlt = beforeAlt.match(/!\[([^\]]*)\]\(\s*[^\s)]*$/);
+        const tagAlt = after.match(/^[^<>]*?\balt\s*=\s*["']([^"']*)["']/i);
+        out.push({ url: m[1], linkTarget, alt: mdAlt ? mdAlt[1] : tagAlt ? tagAlt[1] : null });
     }
     return out;
 }
@@ -169,8 +173,28 @@ export function linksBackToProject(target, src = BADGE_SOURCE) {
  * measurement here. See the header for why both count and why the link is
  * paired with the image rather than looked for anywhere in the file.
  */
+/**
+ * Whether a badge calls itself this project's badge.
+ *
+ * The self-hosted branch below used to accept the link alone and look at
+ * nothing else, so *any* shields endpoint badge — a coverage badge, say —
+ * wrapped in a link to this repository counted as displaying ours. That
+ * inflates the one number this project keeps about itself, which is the last
+ * place it can afford a generous reading.
+ *
+ * The URL cannot decide it: self-hosted JSON lives wherever its author put it,
+ * and the staged action publishes to a gist. What every published snippet does
+ * carry is the label — `context cost` — so that is what is read, tolerantly
+ * enough to accept `Context-Cost` and strictly enough to reject `coverage`.
+ */
+export function namesThisBadge(alt) {
+    if (!alt)
+        return false;
+    return alt.toLowerCase().replace(/[^a-z]/g, '').includes('contextcost');
+}
 export function displaysBadge(text, src = BADGE_SOURCE) {
-    return endpointBadges(text).some((b) => hostedHere(b.url, src) || (b.linkTarget !== null && linksBackToProject(b.linkTarget, src)));
+    return endpointBadges(text).some((b) => hostedHere(b.url, src) ||
+        (namesThisBadge(b.alt) && b.linkTarget !== null && linksBackToProject(b.linkTarget, src)));
 }
 /**
  * Every shields endpoint `url` in a file whose JSON is served from this

package/dist/core/capture-index.js

@@ -72,14 +72,18 @@ export function identify(canonicalSha256, index) {
     if (!mine)
         return { kind: 'unknown' };
     const currentSha = index.current[mine.server];
-    if (!currentSha || currentSha === canonicalSha256) {
+    if (currentSha === canonicalSha256) {
         return { kind: 'current', server: mine.server, date: mine.date, tokens: mine.totalTokens };
     }
-    const current = index.captures[currentSha];
-    // A `current` pointer with no capture behind it describes nothing; treat the
-    // version as identified but with nothing to compare it against.
+    // The bytes are identified, but what is current for this server is not: the
+    // pointer is missing, or points at a capture the index dropped as ambiguous.
+    // `current` would be an affirmative claim that nothing has moved, which the
+    // audit prints as "no server here is running a published capture that has
+    // since moved" — told to someone who may be far behind. Unknown currency
+    // reads as unknown, which is the discipline the rest of this module keeps.
+    const current = currentSha ? index.captures[currentSha] : undefined;
     if (!current)
-        return { kind: 'current', server: mine.server, date: mine.date, tokens: mine.totalTokens };
+        return { kind: 'unknown' };
     return {
         kind: 'behind',
         server: mine.server,

package/dist/core/cross-check.js

@@ -160,6 +160,9 @@ export function isComparable(row, canonicalSha256) {
         canonicalSha256 !== null &&
         row.capturedSha256 === canonicalSha256 &&
         row.ourTokens > 0 &&
+        // A report that parsed but carries `total: 0` is not a measurement of
+        // anything; published, it renders as a −100% divergence.
+        row.cliTokens > 0 &&
         row.ourMappedTokens > 0);
 }
 /**

package/dist/core/divergence.js

@@ -55,6 +55,14 @@ export function mappedTokens(raw) {
 export function fieldSelectionShare(row) {
     if (row.o200kFull <= 0)
         return null;
+    // The projection can add bytes rather than remove them — `inputSchema`
+    // becomes the longer `input_schema`, and a tool with no description gains
+    // `description: ""` — so a server with almost no metadata to drop can map
+    // *larger* than it measured. There is no share of the payload removed in that
+    // case, and publishing a negative one reads as "−11.1% of the capture is
+    // MCP-only metadata", which is not a thing.
+    if (row.o200kMapped > row.o200kFull)
+        return null;
     return (row.o200kFull - row.o200kMapped) / row.o200kFull;
 }
 /**

package/dist/core/regression.d.ts

@@ -124,7 +124,20 @@ export interface ToolAttribution {
      */
     unexplainedTokens: number;
 }
-export declare function attribute(from: ToolVectorEntry, to: ToolVectorEntry, deltaTokens: number): ToolAttribution;
+/**
+ * Per-tool attribution, or null when the names cannot carry it.
+ *
+ * The breakdown matches tools by name, so a name that appears twice on either
+ * side makes the maps below lose one of them silently — and the lost tokens
+ * resurface as `unexplainedTokens`, which the report explains to the reader as
+ * canonical-array framing bytes. That is a confident false explanation. Two
+ * ways it happens: a server that ships duplicate or namespaced-collapsed tool
+ * names, and `measureTools` recording every nameless tool as the single key
+ * `(unnamed)` — an invented name, where `toolNames` and `toAnthropicTools`
+ * deliberately drop nameless tools rather than invent one. Where the names
+ * cannot identify the tools, there is no attribution to give.
+ */
+export declare function attribute(from: ToolVectorEntry, to: ToolVectorEntry, deltaTokens: number): ToolAttribution | null;
 export interface CostChange {
     server: string;
     fromDate: string;

package/dist/core/regression.js

@@ -87,7 +87,23 @@ export function mechanismOf(deltaTokens, deltaTools) {
     // and rewritten, and the totals cannot separate the two.
     return 'mixed';
 }
+/**
+ * Per-tool attribution, or null when the names cannot carry it.
+ *
+ * The breakdown matches tools by name, so a name that appears twice on either
+ * side makes the maps below lose one of them silently — and the lost tokens
+ * resurface as `unexplainedTokens`, which the report explains to the reader as
+ * canonical-array framing bytes. That is a confident false explanation. Two
+ * ways it happens: a server that ships duplicate or namespaced-collapsed tool
+ * names, and `measureTools` recording every nameless tool as the single key
+ * `(unnamed)` — an invented name, where `toolNames` and `toAnthropicTools`
+ * deliberately drop nameless tools rather than invent one. Where the names
+ * cannot identify the tools, there is no attribution to give.
+ */
 export function attribute(from, to, deltaTokens) {
+    const unique = (ts) => new Set(ts.map((t) => t.name)).size === ts.length;
+    if (!unique(from.tools) || !unique(to.tools))
+        return null;
     const before = new Map(from.tools.map((t) => [t.name, t.tokens]));
     const after = new Map(to.tools.map((t) => [t.name, t.tokens]));
     const added = [];

package/dist/core/tool-shape.js

@@ -23,10 +23,18 @@ export function quantileTable(values) {
  * checkable by anyone holding the same JSON.
  */
 export function percentileOf(quantiles, value) {
+    // The LOWEST percentile whose quantile the value reaches, not the highest.
+    // Taking the highest reports a value tied with half the measured set as p100
+    // — "heavier than 100% of measured tools" about something exactly average for
+    // its tie — because every percentile across the tie carries the same
+    // quantile. The lowest names where the tie begins, which is what "heavier
+    // than P% of tools" means.
     let p = 0;
     for (let i = 0; i <= 100; i++) {
-        if (quantiles[i] <= value)
-            p = i;
+        if (quantiles[i] <= value) {
+            if (quantiles[i] < value || i === 0 || quantiles[i - 1] < quantiles[i])
+                p = i;
+        }
         else
             break;
     }

package/dist/sweep/dashboard.js

@@ -7,6 +7,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 { loadRows } from './report.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. */
@@ -53,10 +54,9 @@ export function generateDashboard(root = process.cwd()) {
     // Only the run of sweeps taken under the same isolation is plotted: a step
     // across an isolation change is the harness moving, not the server.
     const seriesFor = (name) => plottableSeries(history.filter((h) => h.server === name));
-    const rows = doc.servers.map((entry) => {
-        const p = join(root, 'results', entry.name, 'measurement.json');
-        return { entry, m: existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : null };
-    });
+    // Shared with the leaderboard rather than re-read here: one definition of how
+    // a measurement is loaded, including its tolerance for a half-written file.
+    const rows = loadRows(doc.servers, root);
     const measured = rows
         .filter((r) => r.m && (r.m.status === 'measured' || r.m.status === 'dynamic') && r.m.totalTokens !== null)
         .sort((a, b) => (b.m.totalTokens ?? 0) - (a.m.totalTokens ?? 0));

package/dist/sweep/harness-guard.d.ts

@@ -47,7 +47,15 @@ export interface Verdict {
  * `current` maps server name to the status it just measured at. Servers absent
  * from it were not swept and are ignored.
  */
-export declare function verdict(prior: Snapshot[], current: Map<string, MeasurementStatus>): Verdict;
+export declare function verdict(prior: Snapshot[], current: Map<string, MeasurementStatus>, 
+/**
+ * Servers this sweep could not measure because docker itself failed. They
+ * never reached a status, so they are absent from `current` and invisible to
+ * the comparison below — but they are the same fact it is looking for: a
+ * server that could have produced a number and did not. Counted here so the
+ * two symptoms share one threshold instead of being each other's blind spot.
+ */
+dockerFaults?: number): Verdict;
 /**
  * Put the snapshotted artifacts back, byte for byte. Only servers named in
  * `names` are touched, and only where a prior file existed — a server whose

package/dist/sweep/harness-guard.js

@@ -78,12 +78,21 @@ export function snapshot(names, root = process.cwd()) {
  * `current` maps server name to the status it just measured at. Servers absent
  * from it were not swept and are ignored.
  */
-export function verdict(prior, current) {
+export function verdict(prior, current, 
+/**
+ * Servers this sweep could not measure because docker itself failed. They
+ * never reached a status, so they are absent from `current` and invisible to
+ * the comparison below — but they are the same fact it is looking for: a
+ * server that could have produced a number and did not. Counted here so the
+ * two symptoms share one threshold instead of being each other's blind spot.
+ */
+dockerFaults = 0) {
     const comparableNames = prior
         .filter((s) => s.status !== null && isGood(s.status) && current.has(s.name))
         .map((s) => s.name);
     const regressed = comparableNames.filter((n) => !isGood(current.get(n)));
-    const comparable = comparableNames.length;
+    const failed = regressed.length + dockerFaults;
+    const comparable = comparableNames.length + dockerFaults;
     if (comparable === 0) {
         return {
             fault: false,
@@ -94,15 +103,16 @@ export function verdict(prior, current) {
             reason: 'no prior measurement to compare against — harness check not performed',
         };
     }
-    const ratio = regressed.length / comparable;
+    const ratio = failed / comparable;
     const pct = (ratio * 100).toFixed(0);
-    if (regressed.length >= MIN_REGRESSIONS && ratio >= FAULT_RATIO) {
+    const how = dockerFaults > 0 ? ` (${regressed.length} regressed, ${dockerFaults} unmeasurable)` : '';
+    if (failed >= MIN_REGRESSIONS && ratio >= FAULT_RATIO) {
         return {
             fault: true,
             regressed,
             comparable,
-            reason: `${regressed.length} of ${comparable} previously-measured servers (${pct}%) failed in ` +
-                `this sweep — at or above the ${MIN_REGRESSIONS}-server, ` +
+            reason: `${failed} of ${comparable} previously-measured servers (${pct}%) produced no number in ` +
+                `this sweep${how} — at or above the ${MIN_REGRESSIONS}-server, ` +
                 `${(FAULT_RATIO * 100).toFixed(0)}% threshold that reads as a broken harness ` +
                 `rather than broken servers`,
         };
@@ -111,8 +121,8 @@ export function verdict(prior, current) {
         fault: false,
         regressed,
         comparable,
-        reason: `${regressed.length} of ${comparable} previously-measured servers (${pct}%) failed in ` +
-            `this sweep — below the harness-fault threshold, publishing normally`,
+        reason: `${failed} of ${comparable} previously-measured servers (${pct}%) produced no number in ` +
+            `this sweep${how} — below the harness-fault threshold, publishing normally`,
     };
 }
 /**

package/dist/sweep/report.js

@@ -21,7 +21,20 @@ function csvCell(s) {
 export function loadRows(entries, root = process.cwd()) {
     return entries.map((entry) => {
         const p = join(root, 'results', entry.name, 'measurement.json');
-        return { entry, m: existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : null };
+        if (!existsSync(p))
+            return { entry, m: null };
+        try {
+            return { entry, m: JSON.parse(readFileSync(p, 'utf8')) };
+        }
+        catch {
+            // The same tolerance `appendHistory` states for the same file: a sweep
+            // killed mid-write leaves a truncated measurement, and every generator
+            // reads through here. Throwing meant one such file broke the leaderboard,
+            // the server pages, the dashboard, the tool-shape baseline and the
+            // published-stats check at once — weekly, with a SyntaxError that named
+            // no file. A server with no readable record reads as one with no record.
+            return { entry, m: null };
+        }
     });
 }
 /** results/divergence.json if a divergence run has been recorded, else null. */

package/dist/sweep/session-start.js

@@ -25,6 +25,7 @@ import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parse } from 'yaml';
 import { measureServer } from './run.js';
+import { DockerHarnessFault } from './docker.js';
 import { SESSION_START_METHOD, parseSessionStart, toSessionStartRow, } from '../core/session-start.js';
 export function loadSessionStart(root = process.cwd()) {
     const p = join(root, 'results', 'session-start.json');
@@ -63,15 +64,36 @@ if (isMain) {
     const queue = [...entries];
     async function worker() {
         for (let e = queue.shift(); e; e = queue.shift()) {
-            const m = await measureServer(e.name, e.command, {
-                timeoutMs: (e.timeoutSeconds ?? defaultTimeout) * 1000,
-                docker,
-                dockerImage: e.dockerImage,
-                dummyEnv: e.env ?? [],
-                dummyEnvValues: e.envValues,
-                needsGit: e.needsGit,
-                persist: false, // the measurements on disk are not this run's to rewrite
-            });
+            let m;
+            try {
+                m = await measureServer(e.name, e.command, {
+                    timeoutMs: (e.timeoutSeconds ?? defaultTimeout) * 1000,
+                    docker,
+                    dockerImage: e.dockerImage,
+                    dummyEnv: e.env ?? [],
+                    dummyEnvValues: e.envValues,
+                    needsGit: e.needsGit,
+                    persist: false, // the measurements on disk are not this run's to rewrite
+                });
+            }
+            catch (err) {
+                // One thrown error used to reject Promise.all and end the process
+                // before anything was written, discarding every capture the run had
+                // already completed — and skipping the `finally` that force-removes
+                // containers, orphaning the in-flight ones. A machine fault on one
+                // server is recorded against that server; the rest of the run stands.
+                if (!(err instanceof DockerHarnessFault))
+                    throw err;
+                servers[e.name] = {
+                    instructions: '',
+                    instructionsTokens: 0,
+                    instructionsSha256: '',
+                    capturedSha256: null,
+                    error: `docker harness fault: ${err.message.slice(0, 200)}`,
+                };
+                console.log(`  ${e.name}: docker harness fault — recorded, run continues`);
+                continue;
+            }
             if (m.status !== 'measured' && m.status !== 'dynamic') {
                 servers[e.name] = {
                     instructions: '',

package/dist/sweep/sweep-all.js

@@ -18,7 +18,7 @@ import { DockerHarnessFault } from './docker.js';
 import { writeLeaderboard } from './report.js';
 import { appendHistory } from './history.js';
 import { appendToolVectors, writeRegressions } from './regressions.js';
-import { FAULT_RATIO, MIN_REGRESSIONS, snapshot, verdict, restore } from './harness-guard.js';
+import { snapshot, verdict, restore } from './harness-guard.js';
 import { selectShard, shardIndexForDate } from './shard.js';
 function arg(name) {
     const i = process.argv.indexOf(`--${name}`);
@@ -101,24 +101,25 @@ async function worker() {
     }
 }
 await Promise.all(Array.from({ length: Math.max(1, concurrency) }, () => worker()));
-// A docker fault on most of the slice is the harness-fault story with an
-// earlier symptom — the guard below can't see it (nothing regressed on disk;
-// the throws happened before anything was written), so it is judged here by
-// the guard's own thresholds. Below them, the sweep publishes what it did
-// measure and the faulted servers wait for the next cycle.
-if (dockerFaults.size >= MIN_REGRESSIONS && dockerFaults.size / entries.length >= FAULT_RATIO) {
-    console.error(`\nHARNESS FAULT — docker could not run for ${dockerFaults.size} of ${entries.length} servers; ` +
-        `refusing to publish this sweep.\n` +
-        [...dockerFaults].map(([n, msg]) => `  ${n}: ${msg}`).join('\n') +
-        `\n  Nothing was overwritten — every previous record stands. ` +
-        `Check the Docker daemon and registry path, then re-run.`);
-    process.exit(1);
-}
 // Before publishing anything: is this sweep a statement about the servers, or
 // about the machine that measured them?
-const v = verdict(prior, statuses);
+//
+// The two symptoms are counted together, against one denominator. Judged apart
+// they were each other's blind spot: a flaky daemon that throws for 6 of 14
+// servers (6 ≥ 5, but 43% of the slice) and times out 4 more (4 < 5) trips
+// neither threshold, and the sweep publishes with 10 of 14 servers producing no
+// number and four good records overwritten with failures. A server that could
+// have produced a number and didn't is one fact, however it failed.
+const v = verdict(prior, statuses, dockerFaults.size);
 console.log(`harness check: ${v.reason}`);
+if (dockerFaults.size > 0 && !v.fault) {
+    console.warn(`  (${dockerFaults.size} docker fault(s) counted toward that check; those servers were not measured)`);
+}
 if (v.fault) {
+    if (dockerFaults.size) {
+        console.error(`\ndocker could not run for ${dockerFaults.size} server(s):\n` +
+            [...dockerFaults].map(([n, msg]) => `  ${n}: ${msg}`).join('\n'));
+    }
     const restored = restore(prior, v.regressed);
     console.error(`\nHARNESS FAULT — refusing to publish this sweep.\n` +
         `  regressed: ${v.regressed.join(', ')}\n` +

package/package.json

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