fix(mcp): the startup chip's per-server counts must reflect EXPOSED tools

PR #31 review (Copilot). The chip built its per-server counts from
handles[i].tools.length — the raw tools/list payload — while the run actually
exposes built.tools, which is smaller after the per-server cap
(MAX_TOOLS_PER_SERVER) and after junk specs are skipped. So a server listing 100
tools rendered "server (100)" even though only 64 were callable, and worse, that
per-server number sat right next to an "allowed/total" denominator computed from
built.tools.length — the chip contradicted itself.

Per-server counts now derive from built.routes (the tools actually exposed) via a
new pure helper, toolCountsByServer, so they reflect what the agent can call and
SUM to the denominator. A server that exposed nothing shows "(0)" — honest, and a
useful signal that it connected but contributed no usable tools.

Verified: 41 tests (2 new). The key test reproduces the reviewer's scenario — a
server 5 over the cap plus a server listing junk — and asserts the counts are the
capped/filtered numbers AND that they sum to built.tools.length. Mutation-checked:
a wrong per-tool increment fails, and dropping the malformed-entry guard fails.
The agent.js consumption is one line reading the tested helper, covered by that
test + reading (agent.js requires vscode). Full gate: 18 suites, 0 failures.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ndemianc

extensions/levelcode-ai/agent.js

@@ -17,7 +17,7 @@ const providers = require('./providers/index');
 const { formatVerifyFeedback, verifyOutcome, looksUnrunnable, sniffPort, looksReady } = require('./verify');
 const { classifyCommand, dangerLabel } = require('./commandSafety');
 const { loadProjectRules } = require('./projectRules');
-const { loadServerConfig, buildAgentTools, classifyMcpTool, explainMcpRefusal } = require('./mcpConfig');
+const { loadServerConfig, buildAgentTools, toolCountsByServer, classifyMcpTool, explainMcpRefusal } = require('./mcpConfig');
 const { connectAll, getServer } = require('./mcpClient');
 
 const SYSTEM_BASE = [
@@ -549,7 +549,12 @@ async function setupMcp(ctx, wsFolders, dbg) {
 			const route = built.routes.get(t.name);
 			return classifyMcpTool(t.name, cfg.toolPolicy, route && route.annotations).approve === 'allow';
 		}).length;
-		const summary = handles.map((h) => h.name + ' (' + h.tools.length + ')').join(', ');
+		// Per-server counts come from what was actually EXPOSED (built.routes), not the raw tools/list
+		// length — a server capped at MAX_TOOLS_PER_SERVER or listing junk exposes fewer than it
+		// advertised, and showing the raw number would contradict the allowed/total denominator below
+		// (PR #31 review). A server that exposed nothing still shows "(0)": honest, and a useful signal.
+		const perServer = toolCountsByServer(built.routes);
+		const summary = handles.map((h) => h.name + ' (' + (perServer.get(h.name) || 0) + ')').join(', ');
 		dbg('mcp.ready', { servers: handles.map((h) => h.name), tools: built.tools.length, allowed });
 		ctx.post({ type: 'agentTool', icon: 'plug', text: '🔌 mcp · ' + summary + ' · ' + allowed + '/' + built.tools.length + ' allow-listed' });
 		return built;

extensions/levelcode-ai/mcpConfig.js

@@ -334,6 +334,26 @@ function buildAgentTools(servers, opts) {
 	return { tools, routes, problems: assigned.problems };
 }
 
+/**
+ * Per-server counts of the tools ACTUALLY exposed, taken from the routes buildAgentTools emitted — i.e.
+ * AFTER the per-server cap and junk-skipping. The startup chip uses this rather than the raw tools/list
+ * length, so its per-server numbers reflect what the agent can really call and SUM to the run's real
+ * total: a server that lists 100 tools but is capped to 64 must read `(64)`, not `(100)`, or the chip
+ * contradicts its own allowed/total denominator (PR #31 review).
+ *
+ * @param {Map<string,{server:string}>} routes  the routes map from buildAgentTools
+ * @returns {Map<string, number>} server name → exposed tool count
+ */
+function toolCountsByServer(routes) {
+	const counts = new Map();
+	if (!routes || typeof routes.values !== 'function') { return counts; }
+	for (const r of routes.values()) {
+		if (!r || typeof r.server !== 'string') { continue; }
+		counts.set(r.server, (counts.get(r.server) || 0) + 1);
+	}
+	return counts;
+}
+
 // ---- 3. approval policy ----------------------------------------------------------------------
 
 /**
@@ -391,6 +411,6 @@ function explainMcpRefusal(name, verdict) {
 
 module.exports = {
 	loadServerConfig, userScopedSetting, namespaceToolName, assignToolNames, buildAgentTools,
-	classifyMcpTool, explainMcpRefusal,
+	toolCountsByServer, classifyMcpTool, explainMcpRefusal,
 	BUILTIN_TOOL_NAMES, MAX_TOOL_NAME, MAX_TOOL_DESC, MAX_SERVERS, MAX_TOOLS_PER_SERVER, WORKSPACE_CONFIG_PATH
 };

extensions/levelcode-ai/test/mcpConfig.test.js

@@ -404,6 +404,33 @@ test('BUILD: the FALLBACK description is capped too — a giant tool name cannot
 	assert.ok(b.tools[0].name.length <= M.MAX_TOOL_NAME, 'and the name still stays legal');
 });
 
+test('BUILD: per-server exposed counts come from routes and SUM to the real total (chip honesty)', () => {
+	// PR #31 review: the startup chip must not show a raw tools/list length that a cap or junk-skip made
+	// untrue — e.g. "a (100)" next to a "/64 allow-listed" denominator. toolCountsByServer derives the
+	// per-server numbers from what was actually exposed, so they reflect reality and sum to the total.
+	const many = [];
+	for (let i = 0; i < M.MAX_TOOLS_PER_SERVER + 5; i++) { many.push({ name: 'a' + i }); }
+	const b = M.buildAgentTools([
+		{ name: 'a', tools: many },                                            // over the cap
+		{ name: 'b', tools: [{ name: 'one' }, null, { name: '' }, { name: 'two' }] }  // 2 real + junk
+	]);
+	const counts = M.toolCountsByServer(b.routes);
+	assert.strictEqual(counts.get('a'), M.MAX_TOOLS_PER_SERVER, 'a is capped, not its raw ' + many.length);
+	assert.strictEqual(counts.get('b'), 2, 'b exposes only its 2 valid tools');
+
+	// The load-bearing invariant: the per-server counts sum to built.tools.length — the chip denominator.
+	let sum = 0; for (const v of counts.values()) { sum += v; }
+	assert.strictEqual(sum, b.tools.length, 'per-server counts must sum to the real total');
+});
+
+test('BUILD: toolCountsByServer tolerates junk input without throwing', () => {
+	assert.strictEqual(M.toolCountsByServer(null).size, 0);
+	assert.strictEqual(M.toolCountsByServer(undefined).size, 0);
+	assert.strictEqual(M.toolCountsByServer(new Map()).size, 0);
+	// A routes-shaped map with a malformed entry is skipped, not counted.
+	assert.strictEqual(M.toolCountsByServer(new Map([['x', { server: 's' }], ['y', null], ['z', {}]])).get('s'), 1);
+});
+
 test('BUILD: annotations ride along so the policy can tighten on them', () => {
 	const b = M.buildAgentTools([SRV('s', [{ name: 'rm', annotations: { destructiveHint: true } }])]);
 	const route = b.routes.get('s__rm');