mcp-context-cost 0.14.0 → 0.16.0

package/README.md

@@ -60,11 +60,22 @@ claude-desktop  ~/Library/Application Support/Claude/claude_desktop_config.json
 ```
 
 It finds configs for Claude Desktop, Claude Code (`~/.claude.json`, `.mcp.json`), Cursor,
-VS Code (`.vscode/mcp.json`), and Windsurf — or pass `--config <path>`. Servers are measured
-by the same path as the published leaderboard (dual `tools/list` capture, `o200k_base` over
+VS Code (`.vscode/mcp.json`), Windsurf, Codex CLI (`~/.codex/config.toml`), Gemini CLI
+(`~/.gemini/settings.json`), Zed (`context_servers`), Kiro (`~/.kiro/settings/mcp.json`) and
+Goose (`~/.config/goose/config.yaml`) — or pass `--config <path>`. Servers are measured by
+the same path as the published leaderboard (dual `tools/list` capture, `o200k_base` over
 canonical JSON), so a server in both places gets the same number. Nothing is written to your
 project, and env var **values** are never read into the output — only their names.
 
+A remote entry — `url`, or the client's own spelling of it — is first asked what it says to
+an unauthenticated `initialize`. An endpoint that answers is measured through the
+`mcp-remote` bridge, the path the leaderboard's remote rows already take. One that answers
+`401` or `403` is reported **auth-walled**, quoting the status and the `WWW-Authenticate`
+header it sent, with the URL: a working server this audit holds no credential for, so the
+total above it is a floor. One that answers nothing usable is **unreachable**, with the
+reason. Header values an entry carries are sent and never printed — only their names are —
+and nothing here ever opens a browser.
+
 Totals are reported per config file, never merged: a context window belongs to one client
 session, so summing Cursor's servers into Claude Desktop's total would describe a session
 nobody runs.
@@ -75,8 +86,9 @@ Not every client puts every tool definition in context on every request, so the
 is not automatically your bill. Which client reads the config, and how that client is
 configured **on this machine**, decides it — and `audit` reads that rather than assuming it.
 
-**Clients with no default deferral on record** — Claude Desktop, Cursor, VS Code, Windsurf.
-The total is what every request carries, as in the example above. That sentence is an
+**Clients with no default deferral on record** — Claude Desktop, Cursor, VS Code, Windsurf,
+Codex CLI, Gemini CLI, Zed, Kiro, Goose. The total is what every request carries, as in the
+example above. That sentence is an
 absence of a record about those clients, not a measurement of them, and the report says so
 in those words.
 
@@ -97,6 +109,7 @@ deferral off in a settings file is not a machine running the default:
 | `ANTHROPIC_BASE_URL` off `api.anthropic.com` | falls back to loading up front — consulted only while `ENABLE_TOOL_SEARCH` is unset |
 | anything else in `ENABLE_TOOL_SEARCH` | not a documented value, so nothing is claimed from it |
 | any of the three set, in a settings `env` block, to something that is not a string — a JSON boolean, a number, `null` | it is set there and what it is set to is unknown, so no posture is claimed: the report says whether these tokens are deferred cannot be said from it |
+| a server pinned `"alwaysLoad": true` in its entry | loads at session start whatever the setting says — read from the entry, named with its tokens, and left out of any threshold comparison |
 
 On a machine where none of them is set, the same stack reads:
 
@@ -114,7 +127,7 @@ On a machine where none of them is set, the same stack reads:
     a Microsoft Foundry deployment hosted on Azure, which rejects tool search server-side
     Google Cloud's Agent Platform on a model earlier than the Claude 4.5 generation
     a model without support for tool_reference blocks (before Sonnet 4.5 / Haiku 4.5 / Opus 4.5)
-    a server pinned with "alwaysLoad": true, whose tools load at session start regardless
+    a tool whose _meta carries "anthropic/alwaysLoad": true, which this audit does not read from a capture
 ```
 
 Set `ENABLE_TOOL_SEARCH=false` in that shell and the same config reports the opposite —
@@ -133,7 +146,7 @@ settings file exists and cannot be read, when the place that would decide sets t
 to something that is not a string, and when `ENABLE_TOOL_SEARCH` holds a value Claude Code
 does not document; and it will not pass an absence of a record off as a measurement. The
 first two print as unanswered questions. The third prints as an answer that names
-itself: for the four discovered clients with no default on record — `claude-desktop`, `cursor`, `vscode`, `windsurf` — the tokens are counted as
+itself: for the nine discovered clients with no default on record — `claude-desktop`, `cursor`, `vscode`, `windsurf`, `codex`, `gemini`, `zed`, `kiro`, `goose` — the tokens are counted as
 loaded up front, and the report says so in those words, "an absence of a record about the
 client, not a measurement of it".
 Full model, sources and dates: [METHODOLOGY §who pays the number](docs/METHODOLOGY.md#who-pays).
@@ -281,7 +294,7 @@ answers a question no client asks: **what did this server cost last month?**
 [results/regressions.md](results/regressions.md) reports each server's most recent movement —
 dated to when it happened, separated into *shipped more tools* versus *same tools, rewritten*,
 and compared only within one isolation. The ecosystem ratchets upward: of the servers whose
-cost has moved at all, 11 moved up against 6 that moved down. Method:
+cost has moved at all, 13 moved up against 5 that moved down. Method:
 [cost movement](docs/METHODOLOGY.md#cost-movement).
 
 If you publish a server, the same measurement is available as a badge, so your users can see
@@ -344,7 +357,7 @@ number is *not*, config policy, failure taxonomy, frozen color bands, known dive
 |---|---|
 | `src/core/` | the measurement spec, executable — canonical form, tokenizer, bands, badge JSON |
 | `src/sweep/` | raw-wire MCP stdio client + Dockerized batch sweep + leaderboard/dashboard generators |
-| `src/audit/` | client-config discovery (5 clients, JSONC-tolerant), the per-stack report, and the baseline diff |
+| `src/audit/` | client-config discovery (10 clients; JSON with comments, TOML, YAML), the remote probe, the per-stack report, and the baseline diff |
 | `src/cli.ts` | `audit` (measure your own stack), `verify` (re-derive any published number), `measure` |
 | `spec/fixtures/` | golden vectors shared by the TypeScript and bash implementations |
 | `tools/` | the scripts that call a network API — the Claude divergence run, the adoption reading, the registry scan — kept out of the package so the library stays offline |
@@ -387,8 +400,8 @@ repository), then in your README:
 A badge says what your server costs today; it does nothing about the release
 that adds 1,200 tokens to every user's context next month. Across the servers
 measured here most costs hold steady from sweep to sweep, but when a cost does
-move it usually moves up: the [movement report](results/regressions.md) has 11
-servers ratcheting upward against 6 that got cheaper, and none of those
+move it usually moves up: the [movement report](results/regressions.md) has 13
+servers ratcheting upward against 5 that got cheaper, and none of those
 maintainers had a check that would have said so first. `measure` takes the same
 gate flags `audit` does, so your own CI can be that check:
 
@@ -464,7 +477,7 @@ says as a whole is written up, dated, in
 [The State of MCP Context Cost](https://athakur3.github.io/mcp-context-cost/state-of-mcp-context-cost)
 (September 2026). Two
 weekly jobs re-measure the set — the `memory` reference server on Mondays, and a rotating
-sixth of the list on Wednesdays, so every row comes round within six weeks. Read each row's
+third of the list on Wednesdays, so every row comes round within three weeks. Read each row's
 date as the date it means, and don't take the cadence on trust — the build history is
 public, one click each:
 [re-sweep runs](https://github.com/athakur3/mcp-context-cost/actions/workflows/resweep.yml)

package/dist/audit/audit.d.ts

@@ -3,10 +3,20 @@ import { type ToolShapeBaseline, type ToolSuggestion } from '../core/tool-shape.
 import { type CaptureIndex, type CaptureVerdict } from '../core/capture-index.js';
 import type { Measurement, MeasurementStatus, ToolMeasurement } from '../core/types.js';
 import type { ConfiguredServer, LoadedConfig } from './config.js';
+import type { RemoteProbe } from './remote.js';
 import { type DeferralVerdict, type ToolSearchEnv, type ToolSearchSource } from './deferral.js';
 import { type AuditDiff, type IncreaseGate } from './diff.js';
 export declare const DEFAULT_CONTEXT_WINDOW = 200000;
-export type AuditStatus = MeasurementStatus | 'remote-not-measurable';
+/**
+ * A server's status in a report: the measurement statuses, plus two that only
+ * a remote endpoint can have. `auth-walled` — it answered the unauthenticated
+ * `initialize` with 401 or 403: it works, and it wants a credential this audit
+ * does not hold. `unreachable` — no MCP answer came back at all: a connection
+ * failure, a timeout, or a status that is neither an answer nor a wall. Before
+ * 2026-09-06 every `url` entry was `remote-not-measurable`, which said nothing
+ * about the endpoint and under-counted exactly the stacks the audit is for.
+ */
+export type AuditStatus = MeasurementStatus | 'auth-walled' | 'unreachable';
 export interface AuditServerResult {
     name: string;
     transport: 'stdio' | 'remote';
@@ -19,6 +29,10 @@ export interface AuditServerResult {
     url?: string;
     /** Names only — a server's env values never enter a report. */
     envVarNames: string[];
+    /** Names only, and only for a remote entry that carries any — values never enter a report. */
+    headerNames?: string[];
+    /** Claude Code's `alwaysLoad: true`, read from the entry: loads at session start whatever the setting. */
+    alwaysLoad?: true;
     canonicalSha256?: string | null;
     /**
      * Anthropic-request cost from the published Claude divergence run, only when
@@ -227,6 +241,12 @@ export declare function buildReport(configs: LoadedConfig[], measured: Map<strin
      * the report says, rather than reporting a default it did not establish.
      */
     settings?: ToolSearchSource[];
+    /**
+     * What each remote endpoint said to an unauthenticated `initialize`, keyed
+     * by `serverKey`. `runAudit` supplies it from `probeRemotes`; omitted, a
+     * remote entry is reported as not probed rather than as anything else.
+     */
+    remotes?: Map<string, RemoteProbe>;
 }): AuditReport;
 /** Human output. JSON output is the report object itself. */
 export declare function formatReport(report: AuditReport): string;

package/dist/audit/audit.js

@@ -16,7 +16,7 @@ import { METHODOLOGY_VERSION } from '../core/canonical.js';
 import { isCurrent } from '../core/divergence.js';
 import { SUGGEST_DESCRIPTION_PERCENTILE, suggestFor, } from '../core/tool-shape.js';
 import { identify } from '../core/capture-index.js';
-import { evaluateDeferral, PUBLISHED_WIRE_TO_CLIENT_RATIO, SHELL_SOURCE, } from './deferral.js';
+import { evaluateDeferral, BAND_PRECISION, PUBLISHED_WIRE_TO_CLIENT_RATIO, SHELL_SOURCE, } from './deferral.js';
 import { formatDiff, formatGate } from './diff.js';
 export const DEFAULT_CONTEXT_WINDOW = 200_000;
 const TRIM_TOOL_COUNT = 3;
@@ -85,7 +85,30 @@ export function serverKey(s) {
  */
 function envSignature(s) {
     const env = s.env ?? {};
-    return JSON.stringify(Object.keys(env).sort().map((k) => [k, env[k]]));
+    const headers = s.headers ?? {};
+    return JSON.stringify([
+        Object.keys(env).sort().map((k) => [k, env[k]]),
+        // A remote's headers decide what it serves the way env decides for a
+        // process: a bearer token selects an account, and an account its tools.
+        Object.keys(headers).sort().map((k) => [k, headers[k]]),
+    ]);
+}
+/**
+ * Every value an entry would spawn or send — env values, header values — so
+ * that none of them reaches a report by way of a server's own stderr. Values
+ * shorter than four characters are left alone: replacing every "1" in a
+ * message is not redaction.
+ */
+function secrets(s) {
+    return [...Object.values(s.env ?? {}), ...Object.values(s.headers ?? {})].filter((v) => v.length >= 4);
+}
+function redact(text, values) {
+    if (!text)
+        return text;
+    let out = text;
+    for (const v of values)
+        out = out.split(v).join('<redacted>');
+    return out;
 }
 /**
  * The measurement keys that stand for more than one distinct server.
@@ -105,8 +128,6 @@ export function collapsedKeys(configs) {
         if (cfg.error)
             continue;
         for (const s of cfg.servers) {
-            if (s.transport !== 'stdio')
-                continue;
             const key = serverKey(s);
             const seen = envs.get(key);
             if (seen)
@@ -160,7 +181,12 @@ function attachDeferral(configs, contextWindow, opts) {
         evaluateDeferral({
             client: group[0].client,
             sources: group.map((c) => c.source),
-            servers: group.flatMap((c) => c.servers.map((s) => ({ tokens: s.tokens ?? 0, claudeTokens: s.claudeTokens }))),
+            servers: group.flatMap((c) => c.servers.map((s) => ({
+                name: s.name,
+                tokens: s.tokens ?? 0,
+                claudeTokens: s.claudeTokens,
+                ...(s.alwaysLoad ? { alwaysLoad: true } : {}),
+            }))),
             skippedCount: group.reduce((a, c) => a + c.skipped.length, 0),
             sharedMeasurements: group.reduce((a, c) => a + (opts.shared.get(c) ?? 0), 0),
         }, { contextWindow, env: opts.env, settings: opts.settings, divergence: opts.divergence }));
@@ -219,17 +245,34 @@ export function buildReport(configs, measured, opts = {}) {
                 command: s.command,
                 url: s.url,
                 envVarNames: s.envVarNames,
+                ...(s.headerNames?.length ? { headerNames: s.headerNames } : {}),
+                ...(s.alwaysLoad ? { alwaysLoad: true } : {}),
             };
+            const none = { tokens: null, toolCount: null, share: null };
             if (s.transport === 'remote') {
-                skipped.push({
-                    ...base,
-                    status: 'remote-not-measurable',
-                    tokens: null,
-                    toolCount: null,
-                    share: null,
-                    notes: `remote endpoint (${s.url ?? 'url'}) — stdio measurement does not apply`,
-                });
-                continue;
+                const probe = opts.remotes?.get(serverKey(s));
+                if (!probe) {
+                    skipped.push({ ...base, ...none, status: 'unreachable', notes: `${s.url ?? 'url'} — not probed` });
+                    continue;
+                }
+                if (probe.kind === 'auth-walled') {
+                    // The server's own words: the status it sent and the header it named
+                    // its authorization server with. A wall is a working server this
+                    // audit holds no credential for; the session that holds one pays
+                    // this server on top of the total below, which is therefore a floor.
+                    skipped.push({
+                        ...base,
+                        ...none,
+                        status: 'auth-walled',
+                        notes: `${s.url} answered ${probe.detail} — wants a credential this audit does not hold`,
+                    });
+                    continue;
+                }
+                if (probe.kind === 'unreachable') {
+                    skipped.push({ ...base, ...none, status: 'unreachable', notes: `${s.url}: ${probe.detail}` });
+                    continue;
+                }
+                // Open: measured through the bridge, and read below like any launch.
             }
             const m = measured.get(serverKey(s));
             if (!m) {
@@ -243,7 +286,7 @@ export function buildReport(configs, measured, opts = {}) {
                     tokens: null,
                     toolCount: null,
                     share: null,
-                    notes: m.notes?.split('\n')[0]?.slice(0, 200),
+                    notes: redact(m.notes?.split('\n')[0]?.slice(0, 200), secrets(s)),
                 });
                 continue;
             }
@@ -258,7 +301,7 @@ export function buildReport(configs, measured, opts = {}) {
                 share: null, // filled once the total is known
                 canonicalSha256: m.canonicalSha256,
                 claudeTokens: opts.divergence ? (isCurrent(divRow, m.canonicalSha256 ?? null) ? divRow.claudeDelta : null) : undefined,
-                notes: m.status === 'dynamic' ? m.notes : undefined,
+                notes: m.status === 'dynamic' ? redact(m.notes, secrets(s)) : undefined,
             });
             for (const t of m.tools) {
                 tools.push({ server: s.name, tool: t.name, tokens: t.tokens });
@@ -330,8 +373,11 @@ export function buildReport(configs, measured, opts = {}) {
         // 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})`));
+        // (core/server-diff.ts) already refuses this; so does this one now. Every
+        // skipped row counts: an auth-walled endpoint is a working server the
+        // session pays for with its credential, and an unreachable one is a cost
+        // this could not establish, not a cost of zero.
+        const unestablished = results.flatMap((c) => c.skipped.map((s) => `${c.source}: ${s.name} (${s.status})`));
         const over = (worst?.totalTokens ?? 0) > opts.budget;
         report.budget = {
             limit: opts.budget,
@@ -447,6 +493,40 @@ function sharedMeasurementLines(d, skippedNames, consequence) {
     }
     return lines;
 }
+/**
+ * What the threshold below is a share *of*, said where the threshold is said.
+ *
+ * The setting is a percentage of the context window, so the token figure it
+ * resolves to is only as right as the window this audit assumed. That window is
+ * a property of the model the client runs, which no config file states and this
+ * audit therefore cannot read: it uses 200,000 unless `--context` overrides it.
+ * A model with a larger window puts the threshold proportionally higher, and a
+ * stack that clears a 20,000-token threshold does not clear a 100,000-token one.
+ *
+ * This is stated rather than silently assumed because the error has a direction.
+ * A window assumed too small makes the threshold too small, which pushes the
+ * verdict toward "at or above" — toward telling a reader their tool definitions
+ * are deferred, and therefore not charged, when the client's own larger
+ * threshold would have loaded every one of them up front. Of the two ways to be
+ * wrong here, that is the one that costs somebody tokens they were told they
+ * would not pay, so it does not get to be a footnote.
+ *
+ * Only threshold mode reaches this. The default defers everything at any size,
+ * where no window and no arithmetic enter the answer at all.
+ */
+function thresholdAssumptionLines(d) {
+    const share = d.thresholdShare ?? 0;
+    if (!(share > 0) || d.thresholdTokens === null || d.thresholdTokens === undefined)
+        return [];
+    const window = Math.round(d.thresholdTokens / share);
+    return [
+        `  That token figure assumes a ${n(window)}-token context window, which is a`,
+        '  property of the model in use and not of your config, so this audit cannot',
+        '  read it — pass --context to set it. A model with a larger window has a',
+        '  proportionally larger threshold, and the same stack can fall on either',
+        '  side of it depending on which model the client runs.',
+    ];
+}
 /** Where a threshold is in play, the unknown size is the whole verdict. */
 const SIDE_UNKNOWN = [
     '  either direction — which side of the threshold this stack falls on cannot be',
@@ -480,6 +560,14 @@ function deferralLines(d, skippedNames) {
             lines.push(`    ${s}`);
         lines.push('  so they face the question below together, as their sum.');
     }
+    // Read from the entries, so it is stated up front rather than listed among
+    // the conditions a reader has to check: whatever the setting says, these load.
+    if (d.mechanism === 'tool search' && d.alwaysLoad.servers.length) {
+        const n = d.alwaysLoad.servers.length;
+        lines.push(`  ${n} server${n === 1 ? ' is' : 's are'} pinned "alwaysLoad": true and load${n === 1 ? 's' : ''} at session start whatever`);
+        lines.push(`  the setting says: ${d.alwaysLoad.servers.join(', ')} — ${d.alwaysLoad.tokens.toLocaleString()} wire tokens,`);
+        lines.push('  left out of any threshold comparison below.');
+    }
     if (d.mode === 'client-unknown') {
         lines.push('  Which client reads this config is not known here, so whether it defers');
         lines.push('  tool definitions by default is not known either. Read as loaded up front.');
@@ -554,6 +642,7 @@ function deferralLines(d, skippedNames) {
     lines.push(`  ${d.client} defers tool definitions above a threshold here (${d.mechanism}):`);
     lines.push(`  ${settingPhrase(d)}, so deferral activates once the`);
     lines.push(`  definitions reach ${n(t)} tokens — ${pct(d.thresholdShare ?? 0)} of the context window.`);
+    lines.push(...thresholdAssumptionLines(d));
     lines.push(...postureSourceLines(d));
     const c = d.clientTokens;
     if (!c) {
@@ -608,7 +697,7 @@ function deferralLines(d, skippedNames) {
 /** "0.20×–1.92×", from whichever band the verdict was actually computed against. */
 function ratioBand(d) {
     const r = d.ratio ?? PUBLISHED_WIRE_TO_CLIENT_RATIO;
-    return `${r.low.toFixed(2)}×–${r.high.toFixed(2)}×`;
+    return `${r.low.toFixed(BAND_PRECISION)}×–${r.high.toFixed(BAND_PRECISION)}×`;
 }
 /** Human output. JSON output is the report object itself. */
 export function formatReport(report) {
@@ -807,8 +896,8 @@ export function formatReport(report) {
     }
     lines.push('');
     lines.push('These are wire tokens — what the server puts on the wire, counted with o200k_base. What your model is billed');
-    lines.push(`differs per provider: measured ratios run ${PUBLISHED_WIRE_TO_CLIENT_RATIO.low.toFixed(2)}×–` +
-        `${PUBLISHED_WIRE_TO_CLIENT_RATIO.high.toFixed(2)}× on Anthropic requests. See docs/METHODOLOGY.md §claude-divergence.`);
+    lines.push(`differs per provider: measured ratios run ${PUBLISHED_WIRE_TO_CLIENT_RATIO.low.toFixed(BAND_PRECISION)}×–` +
+        `${PUBLISHED_WIRE_TO_CLIENT_RATIO.high.toFixed(BAND_PRECISION)}× on Anthropic requests. See docs/METHODOLOGY.md §claude-divergence.`);
     return lines.map((l) => l.replace(/\s+$/, '')).join('\n');
 }
 /** Top-level tool list across every config — used by nothing yet, handy for --json consumers. */

package/dist/audit/config.d.ts

@@ -13,8 +13,19 @@ export interface ConfiguredServer {
     envVarNames: string[];
     /** Values, needed to spawn the server. NEVER serialize this. */
     env?: Record<string, string>;
-    /** Remote endpoint — recorded so the report can say why it was skipped. */
+    /** Remote endpoint — probed, then measured through the bridge or reported as walled. */
     url?: string;
+    /** Names only — a remote entry's header values never enter a report. Absent means none. */
+    headerNames?: string[];
+    /** Values, sent with the probe and the bridge. NEVER serialize this. */
+    headers?: Record<string, string>;
+    /**
+     * Claude Code's `alwaysLoad: true`: this server's tools load at session
+     * start whatever the tool-search setting says (its MCP documentation, §"Exempt
+     * a server from deferral", read 2026-09-06). Read from the entry, so the
+     * deferral verdict can count it rather than list it as a condition.
+     */
+    alwaysLoad?: true;
 }
 /**
  * JSON with comments and trailing commas — VS Code's mcp.json allows both, and
@@ -31,6 +42,7 @@ export declare function extractServers(doc: unknown, meta: {
     client: string;
     source: string;
     cwd?: string;
+    env?: Record<string, string | undefined>;
 }): ConfiguredServer[];
 /**
  * What one config document declares, servers and switched-off entries both.
@@ -45,6 +57,7 @@ export declare function extractDeclaration(doc: unknown, meta: {
     client: string;
     source: string;
     cwd?: string;
+    env?: Record<string, string | undefined>;
 }): {
     servers: ConfiguredServer[];
     disabled: string[];
@@ -52,6 +65,8 @@ export declare function extractDeclaration(doc: unknown, meta: {
 export interface ConfigCandidate {
     client: string;
     path: string;
+    /** How the file is written. Absent means JSON, with comments and trailing commas tolerated. */
+    format?: 'json' | 'toml' | 'yaml';
 }
 /** Every place a client config is known to live, whether or not it exists. */
 export declare function configCandidates(env: {
@@ -60,6 +75,8 @@ export declare function configCandidates(env: {
     platform: NodeJS.Platform;
     appData?: string;
 }): ConfigCandidate[];
+/** Parse one config file's text in the format its candidate declares. */
+export declare function parseConfigText(text: string, format?: ConfigCandidate['format']): unknown;
 export interface LoadedConfig {
     client: string;
     source: string;
@@ -84,7 +101,7 @@ export interface LoadedConfig {
     allDisabled?: string[];
 }
 /** Read + parse the candidates that exist. Unreadable files are reported, not thrown. */
-export declare function loadConfigs(candidates: ConfigCandidate[], cwd: string): LoadedConfig[];
+export declare function loadConfigs(candidates: ConfigCandidate[], cwd: string, processEnv?: Record<string, string | undefined>): LoadedConfig[];
 /** One file Claude Code reads its `env` block from. */
 export interface SettingsCandidate {
     scope: ToolSearchScope;