dsh-capability-panel 1.1.1 → 1.2.0

package/lib/index.js

@@ -74,6 +74,198 @@ function aggregateBlocked(lines) {
 	return counts;
 }
 
+//#endregion
+//#region src/load-state.ts
+/** Pull the skill name out of a `skill` tool call's stringified arguments. */
+function skillNameOf(args) {
+	if (typeof args !== "string") return null;
+	try {
+		const parsed = JSON.parse(args);
+		if (parsed !== null && typeof parsed === "object" && "name" in parsed) {
+			const name = parsed.name;
+			return typeof name === "string" && name !== "" ? name : null;
+		}
+	} catch {}
+	return null;
+}
+function collectLoadRecords(events) {
+	const out = [];
+	for (const event of events) {
+		if (event.type !== "tool/call") continue;
+		if (event.data?.name !== "skill") continue;
+		const skillName = skillNameOf(event.data.arguments);
+		if (skillName === null) continue;
+		const seq = event.seq;
+		if (typeof seq !== "number") continue;
+		out.push({
+			seq,
+			skillName,
+			callId: event.data.callId ?? ""
+		});
+	}
+	return out;
+}
+/**
+* Map a tool result's pairing callId to its seq.
+*
+* Verified against real logs: `tool/result` events carry no
+* top-level callId; the pairing lives at `data.message.source.callId` and
+* matches the call's `data.callId` exactly.
+*
+* Last write wins on purpose: the middle-pruner appends a stub `tool/result`
+* carrying the SAME callId and a replace surfaceOp over the original's seq
+* (verified against a real compacted session), so the callId resolves to the
+* stub — the node whose fold verdict actually tracks the surface position.
+*/
+function indexToolResultSeqs(events) {
+	const out = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		if (event.type !== "tool/result") continue;
+		const callId = event.data?.message?.source?.callId;
+		const seq = event.seq;
+		if (typeof callId !== "string" || callId === "" || typeof seq !== "number") continue;
+		out.set(callId, seq);
+	}
+	return out;
+}
+/**
+* The load seqs whose skill content is gone from the model surface.
+*
+* A `tool/call` never joins the surface itself — SURFACE_EVENT_TYPES in
+* dsh-session is exactly { user/message, assistant/message, tool/result }, and
+* real skill calls carry `surfaceOp: null`. What the model actually sees of a
+* skill is its tool RESULT (a surface node), so eviction keys on the paired
+* result's surface membership, not on the call's position.
+*
+* `surfaceSeqs` is the live session's CURRENT surface (`session.surface.nodes`),
+* which the session maintains incrementally — reading it is O(1), no log fold
+* is ever run for this panel. A paired result seq absent from that set was
+* displaced by a prune stub's or a summary's `replace` op, i.e. shadowed.
+*
+* A load with no paired result is in flight or its result never landed; it is
+* NOT counted as shadowed, so it reports `loaded` — the honest reading of "the
+* model is about to see it".
+*/
+function shadowedLoadSeqs(loads, resultSeqByCallId, surfaceSeqs) {
+	const out = /* @__PURE__ */ new Set();
+	for (const load of loads) {
+		const resultSeq = resultSeqByCallId.get(load.callId);
+		if (resultSeq === void 0) continue;
+		if (!surfaceSeqs.has(resultSeq)) out.add(load.seq);
+	}
+	return out;
+}
+/**
+* Substring of dsh-compaction-tool-result-pruner's PRUNE_MARKER. Matching on
+* the bracketed phrase (without the surrounding newlines) keeps the check
+* robust to marker framing changes across pruner versions.
+*/
+const PRUNE_MARKER_TEXT = "[... tool result middle pruned ...]";
+function textBlocksOf(event) {
+	const content = event.data?.message?.content;
+	if (!Array.isArray(content)) return [];
+	const out = [];
+	const walk = (blocks) => {
+		for (const block of blocks) {
+			if (block === null || typeof block !== "object") continue;
+			const record = block;
+			if (record.type === "text" && typeof record.text === "string") out.push(record.text);
+			else if (Array.isArray(record.content)) walk(record.content);
+		}
+	};
+	walk(content);
+	return out;
+}
+/**
+* The load seqs whose paired tool result sits on the surface TRUNCATED —
+* head and tail visible, middle replaced by the pruner's marker. The model
+* partially sees these skills, so they read as their own state rather than
+* either extreme. Only surface-resident results are inspected; a shadowed
+* result is already reported by shadowedLoadSeqs and its content is
+* irrelevant to the model now.
+*/
+function prunedLoadSeqs(loads, resultSeqByCallId, surfaceSeqs, events) {
+	const prunedResults = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		if (event.type !== "tool/result") continue;
+		const seq = event.seq;
+		if (typeof seq !== "number" || !surfaceSeqs.has(seq)) continue;
+		if (textBlocksOf(event).some((text) => text.includes(PRUNE_MARKER_TEXT))) prunedResults.add(seq);
+	}
+	const out = /* @__PURE__ */ new Set();
+	for (const load of loads) {
+		const resultSeq = resultSeqByCallId.get(load.callId);
+		if (resultSeq !== void 0 && prunedResults.has(resultSeq)) out.add(load.seq);
+	}
+	return out;
+}
+/**
+* Decide each skill's state.
+*
+* `shadowedSeqs` holds LOAD seqs whose paired tool result is absent from the
+* current surface (see shadowedLoadSeqs for why the result, not the call,
+* carries the verdict); `prunedSeqs` holds load seqs whose result survives on
+* the surface with its middle truncated. Do NOT re-derive either from
+* replacement ranges here: after a replacement lands, a high-seq summary node
+* sits at the shadowed range's *position*, so surface order stops tracking
+* seq order and a numeric `start <= seq <= end` test silently misjudges later
+* compactions.
+*
+* Verified against real data: the middle-pruner had replaced the lark-shared /
+* lark-im / lark-event results with stubs (those now read `pruned`), and a
+* later full-history compaction (one replace over [7..16114]) shadowed those
+* stubs plus the find-skills / git-worktree-discipline results (those read
+* `evicted`).
+*/
+function decideStates(available, loads, shadowedSeqs, disabledSkills = /* @__PURE__ */ new Set(), prunedSeqs = /* @__PURE__ */ new Set()) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const record of loads) {
+		const bucket = byName.get(record.skillName);
+		if (bucket === void 0) byName.set(record.skillName, [record]);
+		else bucket.push(record);
+	}
+	return available.map(({ name, description, masked, source, provider, path, group }) => {
+		const records = byName.get(name) ?? [];
+		let state = "unloaded";
+		if (records.length > 0) {
+			const current = records.filter((r) => !shadowedSeqs.has(r.seq));
+			if (current.length === 0) state = "evicted";
+			else state = current.some((r) => !prunedSeqs.has(r.seq)) ? "loaded" : "pruned";
+		}
+		return {
+			name,
+			...description === void 0 ? {} : { description },
+			state,
+			enabled: !disabledSkills.has(name) && masked !== true,
+			loadCount: records.length,
+			source,
+			provider,
+			...path === void 0 ? {} : { path },
+			...group === void 0 ? {} : { group }
+		};
+	});
+}
+/** Group MCP tools by server: `mcp__<server>__<tool>`. */
+function groupMcpTools(toolNames) {
+	const byServer = /* @__PURE__ */ new Map();
+	for (const raw of toolNames) {
+		if (!raw.startsWith("mcp__")) continue;
+		const rest = raw.slice(5);
+		const cut = rest.indexOf("__");
+		if (cut <= 0) continue;
+		const server = rest.slice(0, cut);
+		const tool = rest.slice(cut + 2);
+		if (tool === "") continue;
+		const bucket = byServer.get(server);
+		if (bucket === void 0) byServer.set(server, [tool]);
+		else bucket.push(tool);
+	}
+	return [...byServer.entries()].map(([server, tools]) => ({
+		server,
+		tools: tools.sort()
+	})).sort((a, b) => a.server.localeCompare(b.server));
+}
+
 //#endregion
 //#region src/host/errors.ts
 var HttpError = class extends Error {
@@ -239,33 +431,45 @@ function createCapabilityController(ctx, appendStats, blockedCounts) {
 	const setServer = (sessionId, server, enabled) => {
 		const state = stateFor(sessionId);
 		const existing = state.mcpServers.get(server);
-		if (enabled && existing !== void 0) {
-			existing();
-			state.mcpServers.delete(server);
+		if (enabled) {
+			const prefix$1 = `mcp__${server}__`;
+			for (const [name, dispose] of [...state.mcpTools]) if (name.startsWith(prefix$1)) {
+				dispose();
+				state.mcpTools.delete(name);
+			}
+			if (existing !== void 0) {
+				existing.dispose();
+				state.mcpServers.delete(server);
+			}
 			return;
 		}
+		if (existing !== void 0) return;
 		const { agent, tools } = getAgentTools(sessionId);
-		if (enabled || existing !== void 0) return;
 		const toolService = ctx.get("tools");
 		if (toolService === void 0) throw new HttpError(503, "tools service unavailable");
 		const prefix = `mcp__${server}__`;
 		const names = [...toolService.schemas()].map((schema) => schema.name).filter((name) => typeof name === "string" && name.startsWith(prefix));
 		if (names.length === 0) throw new HttpError(404, `MCP server "${server}" exposes no tools`);
-		state.mcpServers.set(server, tools.restrict({ deny: names }));
+		state.mcpServers.set(server, {
+			dispose: tools.restrict({ deny: names }),
+			names
+		});
 		ensurePromptNote(agent, state);
 	};
 	const setTool = (sessionId, name, enabled, system) => {
 		const state = stateFor(sessionId);
 		const map = system ? state.systemTools : state.mcpTools;
 		const existing = map.get(name);
-		if (enabled && existing !== void 0) {
-			existing();
-			map.delete(name);
+		if (enabled) {
+			if (existing !== void 0) {
+				existing();
+				map.delete(name);
+			}
 			return;
 		}
+		if (existing !== void 0) return;
 		if (system && name === RESERVED_TOOL) throw new HttpError(409, "run_code is the reserved Code Mode transport and cannot be restricted");
 		const { agent, tools } = getAgentTools(sessionId);
-		if (enabled || existing !== void 0) return;
 		const toolService = ctx.get("tools");
 		if (toolService === void 0) throw new HttpError(503, "tools service unavailable");
 		const globalNames = new Set([...toolService.schemas()].map((schema) => schema.name).filter((entry) => typeof entry === "string"));
@@ -277,17 +481,15 @@ function createCapabilityController(ctx, appendStats, blockedCounts) {
 	};
 	ctx.effect(() => () => {
 		for (const state of states.values()) {
-			for (const map of [
-				state.skills,
-				state.mcpServers,
-				state.mcpTools,
-				state.systemTools
-			]) for (const dispose of map.values()) dispose();
+			for (const dispose of state.skills.values()) dispose();
+			for (const mask of state.mcpServers.values()) mask.dispose();
+			for (const dispose of state.mcpTools.values()) dispose();
+			for (const dispose of state.systemTools.values()) dispose();
 			state.noteDispose?.();
 		}
 		states.clear();
 	}, "capability-panel: capability masks");
-	const seed = async (sessionId, defaults) => {
+	const seed = async (sessionId, defaults, includeSkills = true) => {
 		const agent = ctx.get("agents")?.get(sessionId);
 		if (agent === void 0) return;
 		let state = states.get(sessionId);
@@ -305,22 +507,46 @@ function createCapabilityController(ctx, appendStats, blockedCounts) {
 			for (const schema of toolsService.schemas(agent)) if (typeof schema.name === "string") scopedNames.add(schema.name);
 			for (const name of defaults.tools) {
 				if (!globalNames.has(name)) continue;
-				if (name.startsWith("mcp__")) {
-					if (state?.mcpTools.has(name) === true) continue;
-					ensureState().mcpTools.set(name, scopedTools.restrict({ deny: [name] }));
-					maskedAny = true;
-					continue;
-				}
+				if (name.startsWith("mcp__")) continue;
 				if (name === RESERVED_TOOL || state?.systemTools.has(name) === true) continue;
 				if (!scopedNames.has(name)) continue;
 				ensureState().systemTools.set(name, scopedTools.restrict({ deny: [name] }));
 				ensureGuard();
 				maskedAny = true;
 			}
+			const mcpDefaults = defaults.tools.filter((name) => globalNames.has(name));
+			const fullByServer = new Map(groupMcpTools([...globalNames]).map((group) => [group.server, group.tools]));
+			for (const group of groupMcpTools(mcpDefaults)) {
+				const full = fullByServer.get(group.server);
+				if (full.every((tool) => group.tools.includes(tool))) {
+					const st = ensureState();
+					const prefix = `mcp__${group.server}__`;
+					const fullNames = full.map((tool) => `${prefix}${tool}`);
+					const existingMask = st.mcpServers.get(group.server);
+					if (existingMask !== void 0 && fullNames.every((name) => existingMask.names.includes(name))) continue;
+					for (const [name, dispose] of [...st.mcpTools]) if (name.startsWith(prefix)) {
+						dispose();
+						st.mcpTools.delete(name);
+					}
+					existingMask?.dispose();
+					st.mcpServers.set(group.server, {
+						dispose: scopedTools.restrict({ deny: fullNames }),
+						names: fullNames
+					});
+					maskedAny = true;
+					continue;
+				}
+				for (const tool of group.tools) {
+					const name = `mcp__${group.server}__${tool}`;
+					if (state?.mcpTools.has(name) === true) continue;
+					ensureState().mcpTools.set(name, scopedTools.restrict({ deny: [name] }));
+					maskedAny = true;
+				}
+			}
 		}
 		const scopedSkills = agent.ctx?.get("skills");
 		const skillsService = ctx.get("skills");
-		if (scopedSkills !== void 0 && skillsService !== void 0) {
+		if (includeSkills && scopedSkills !== void 0 && skillsService !== void 0) {
 			const cwd = agent.session?.header?.cwd;
 			const lookup = {
 				...cwd === void 0 ? {} : { cwd },
@@ -396,15 +622,16 @@ function createCapabilityController(ctx, appendStats, blockedCounts) {
 		reseed: (sessionId, defaults, overrides) => enqueue(sessionId, async () => {
 			const st = states.get(sessionId);
 			if (st !== void 0) {
+				for (const dispose of st.systemTools.values()) dispose();
+				for (const mask of st.mcpServers.values()) mask.dispose();
+				for (const dispose of st.mcpTools.values()) dispose();
+				for (const dispose of st.skills.values()) dispose();
 				for (const map of [
 					st.systemTools,
 					st.mcpServers,
 					st.mcpTools,
 					st.skills
-				]) {
-					for (const dispose of map.values()) dispose();
-					map.clear();
-				}
+				]) map.clear();
 				st.noteDispose?.();
 				delete st.noteDispose;
 				st.userToggled.clear();
@@ -413,6 +640,15 @@ function createCapabilityController(ctx, appendStats, blockedCounts) {
 			if (defaults.tools.length > 0 || defaults.skills.length > 0) await seed(sessionId, defaults);
 			if (overrides !== void 0) await restoreImpl(sessionId, overrides);
 		}),
+		remask: (sessionId, defaults, overrides) => enqueue(sessionId, async () => {
+			if (defaults.tools.length > 0) await seed(sessionId, defaults, false);
+			if (overrides !== void 0) await restoreImpl(sessionId, {
+				skills: {},
+				mcpServers: overrides.mcpServers,
+				mcpTools: overrides.mcpTools,
+				systemTools: overrides.systemTools
+			});
+		}),
 		set: (sessionId, kind, name, enabled) => enqueue(sessionId, async () => {
 			stateFor(sessionId).userToggled.add(`${kind}:${name}`);
 			if (kind === "skill") await setSkill(sessionId, name, enabled);
@@ -498,198 +734,134 @@ function registerPresetEnforcement(ctx, capabilities, presetTools, sessionOverri
 			return;
 		}
 	});
+	/**
+	* Re-mask when the tool registry changes. seed() can only mask names that
+	* are registered at that moment (tools.restrict refuses unknown names), so
+	* an on-demand MCP server that connects AFTER the session was created would
+	* otherwise arrive with every tool enabled, preset default or not. The
+	* registry broadcasts every layer change through this event — late
+	* registration, a reconnect's fresh generation, a teardown — and remask is
+	* idempotent over names already masked.
+	*
+	* The guard breaks the echo loop: our own restrict() calls re-emit
+	* tools/change, and without it every mask write would schedule another
+	* sweep. A change arriving mid-sweep is not lost, though: it is marked
+	* pending and one trailing sweep runs when the current one settles, so an
+	* external registration landing while a session's slow queue is still
+	* processing does not leave stale masks behind.
+	*/
+	let remasking = false;
+	let pendingSweep = false;
+	ctx.on("tools/change", () => {
+		if (remasking) {
+			pendingSweep = true;
+			return;
+		}
+		try {
+			const agents = ctx.get("agents");
+			if (agents === void 0 || typeof agents.list !== "function") return void 0;
+			return (async () => {
+				do {
+					remasking = true;
+					pendingSweep = false;
+					try {
+						let live;
+						try {
+							live = agents.list();
+						} catch {
+							return;
+						}
+						for (const agent of live) try {
+							const sessionId = agent?.id;
+							if (typeof sessionId !== "string") continue;
+							const presetId = ctx.get("agentPresets")?.composedPreset(agent.ctx);
+							const defaults = presetId === void 0 ? void 0 : presetTools.defaultsFor(presetId);
+							const overrides = sessionOverrides.overridesFor(sessionId);
+							const hasToolDefaults = defaults !== void 0 && defaults.tools.length > 0;
+							const hasToolOverrides = overrides !== void 0 && (Object.keys(overrides.mcpServers).length > 0 || Object.keys(overrides.mcpTools).length > 0 || Object.keys(overrides.systemTools).length > 0);
+							if (!hasToolDefaults && !hasToolOverrides) continue;
+							await capabilities.remask(sessionId, defaults ?? {
+								tools: [],
+								skills: []
+							}, overrides);
+						} catch {}
+					} finally {
+						remasking = false;
+					}
+				} while (pendingSweep);
+			})();
+		} catch {
+			return;
+		}
+	});
 }
 
 //#endregion
-//#region src/load-state.ts
-/** Pull the skill name out of a `skill` tool call's stringified arguments. */
-function skillNameOf(args) {
-	if (typeof args !== "string") return null;
-	try {
-		const parsed = JSON.parse(args);
-		if (parsed !== null && typeof parsed === "object" && "name" in parsed) {
-			const name = parsed.name;
-			return typeof name === "string" && name !== "" ? name : null;
-		}
-	} catch {}
-	return null;
+//#region src/host/mcp-connections.ts
+const MCP_CLIENT_NAME = "@deepseek-ai/dsh-mcp-client";
+function entryConfig(entry) {
+	const config = entry.options?.config;
+	if (config === null || typeof config !== "object" || Array.isArray(config)) return void 0;
+	return config;
 }
-function collectLoadRecords(events) {
-	const out = [];
-	for (const event of events) {
-		if (event.type !== "tool/call") continue;
-		if (event.data?.name !== "skill") continue;
-		const skillName = skillNameOf(event.data.arguments);
-		if (skillName === null) continue;
-		const seq = event.seq;
-		if (typeof seq !== "number") continue;
-		out.push({
-			seq,
-			skillName,
-			callId: event.data.callId ?? ""
-		});
-	}
-	return out;
+function declaredServerName(entry) {
+	if (entry.options?.name !== MCP_CLIENT_NAME) return void 0;
+	const serverName = entryConfig(entry)?.["serverName"];
+	return typeof serverName === "string" && serverName !== "" ? serverName : void 0;
 }
 /**
-* Map a tool result's pairing callId to its seq.
-*
-* Verified against real logs: `tool/result` events carry no
-* top-level callId; the pairing lives at `data.message.source.callId` and
-* matches the call's `data.callId` exactly.
-*
-* Last write wins on purpose: the middle-pruner appends a stub `tool/result`
-* carrying the SAME callId and a replace surfaceOp over the original's seq
-* (verified against a real compacted session), so the callId resolves to the
-* stub — the node whose fold verdict actually tracks the surface position.
+* Server names the host composition declares via `@deepseek-ai/dsh-mcp-client`
+* entries — connected or not. Matched by plugin name, not by the `serverName`
+* key: an unrelated entry carrying a same-named config key is not an MCP
+* server.
 */
-function indexToolResultSeqs(events) {
-	const out = /* @__PURE__ */ new Map();
-	for (const event of events) {
-		if (event.type !== "tool/result") continue;
-		const callId = event.data?.message?.source?.callId;
-		const seq = event.seq;
-		if (typeof callId !== "string" || callId === "" || typeof seq !== "number") continue;
-		out.set(callId, seq);
-	}
-	return out;
-}
-/**
-* The load seqs whose skill content is gone from the model surface.
-*
-* A `tool/call` never joins the surface itself — SURFACE_EVENT_TYPES in
-* dsh-session is exactly { user/message, assistant/message, tool/result }, and
-* real skill calls carry `surfaceOp: null`. What the model actually sees of a
-* skill is its tool RESULT (a surface node), so eviction keys on the paired
-* result's surface membership, not on the call's position.
-*
-* `surfaceSeqs` is the live session's CURRENT surface (`session.surface.nodes`),
-* which the session maintains incrementally — reading it is O(1), no log fold
-* is ever run for this panel. A paired result seq absent from that set was
-* displaced by a prune stub's or a summary's `replace` op, i.e. shadowed.
-*
-* A load with no paired result is in flight or its result never landed; it is
-* NOT counted as shadowed, so it reports `loaded` — the honest reading of "the
-* model is about to see it".
-*/
-function shadowedLoadSeqs(loads, resultSeqByCallId, surfaceSeqs) {
-	const out = /* @__PURE__ */ new Set();
-	for (const load of loads) {
-		const resultSeq = resultSeqByCallId.get(load.callId);
-		if (resultSeq === void 0) continue;
-		if (!surfaceSeqs.has(resultSeq)) out.add(load.seq);
-	}
-	return out;
-}
-/**
-* Substring of dsh-compaction-tool-result-pruner's PRUNE_MARKER. Matching on
-* the bracketed phrase (without the surrounding newlines) keeps the check
-* robust to marker framing changes across pruner versions.
-*/
-const PRUNE_MARKER_TEXT = "[... tool result middle pruned ...]";
-function textBlocksOf(event) {
-	const content = event.data?.message?.content;
-	if (!Array.isArray(content)) return [];
-	const out = [];
-	const walk = (blocks) => {
-		for (const block of blocks) {
-			if (block === null || typeof block !== "object") continue;
-			const record = block;
-			if (record.type === "text" && typeof record.text === "string") out.push(record.text);
-			else if (Array.isArray(record.content)) walk(record.content);
+function readConfiguredMcpServers(ctx) {
+	const servers = /* @__PURE__ */ new Set();
+	const loader = ctx.loader;
+	if (loader === void 0) return servers;
+	try {
+		for (const entry of loader.entries()) {
+			if (entry.disabled === true) continue;
+			const name = declaredServerName(entry);
+			if (name !== void 0) servers.add(name);
 		}
-	};
-	walk(content);
-	return out;
+	} catch {}
+	return servers;
 }
-/**
-* The load seqs whose paired tool result sits on the surface TRUNCATED —
-* head and tail visible, middle replaced by the pruner's marker. The model
-* partially sees these skills, so they read as their own state rather than
-* either extreme. Only surface-resident results are inspected; a shadowed
-* result is already reported by shadowedLoadSeqs and its content is
-* irrelevant to the model now.
-*/
-function prunedLoadSeqs(loads, resultSeqByCallId, surfaceSeqs, events) {
-	const prunedResults = /* @__PURE__ */ new Set();
-	for (const event of events) {
-		if (event.type !== "tool/result") continue;
-		const seq = event.seq;
-		if (typeof seq !== "number" || !surfaceSeqs.has(seq)) continue;
-		if (textBlocksOf(event).some((text) => text.includes(PRUNE_MARKER_TEXT))) prunedResults.add(seq);
-	}
-	const out = /* @__PURE__ */ new Set();
-	for (const load of loads) {
-		const resultSeq = resultSeqByCallId.get(load.callId);
-		if (resultSeq !== void 0 && prunedResults.has(resultSeq)) out.add(load.seq);
+function entryFor(ctx, server) {
+	const loader = ctx.loader;
+	if (loader === void 0) return void 0;
+	try {
+		for (const entry of loader.entries()) if (declaredServerName(entry) === server) return entry;
+	} catch {
+		return;
 	}
-	return out;
 }
 /**
-* Decide each skill's state.
+* Reload one declared MCP server's plugin instance: dispose its fiber, then
+* refresh the entry — the loader's own hot-swap pair. This is exactly a
+* manual HMR reload: it tears down the current connection (and stops its
+* reconnect timer) and re-initializes the client, which reconnects and re-syncs
+* the whole tool generation.
 *
-* `shadowedSeqs` holds LOAD seqs whose paired tool result is absent from the
-* current surface (see shadowedLoadSeqs for why the result, not the call,
-* carries the verdict); `prunedSeqs` holds load seqs whose result survives on
-* the surface with its middle truncated. Do NOT re-derive either from
-* replacement ranges here: after a replacement lands, a high-seq summary node
-* sits at the shadowed range's *position*, so surface order stops tracking
-* seq order and a numeric `start <= seq <= end` test silently misjudges later
-* compactions.
+* Honest scope of what this guarantees: only that a fresh connection attempt
+* starts NOW instead of waiting out the client's backoff. It does NOT prove
+* the server was "down" (the panel cannot observe connection state), and for a
+* stdio transport the reload respawns the child process. Registration lands
+* asynchronously after refresh resolves; the registry's `tools/change`
+* broadcast re-applies stored defaults, so callers need no readiness wait.
 *
-* Verified against real data: the middle-pruner had replaced the lark-shared /
-* lark-im / lark-event results with stubs (those now read `pruned`), and a
-* later full-history compaction (one replace over [7..16114]) shadowed those
-* stubs plus the find-skills / git-worktree-discipline results (those read
-* `evicted`).
+* Assumes a globally unique serverName: the settings view is host-global, and
+* dsh reserves one serverName per global mcp-client instance, so at most one
+* entry matches here. Agent-scoped instances may reuse a name across Agents,
+* but those are not reachable from this global walk.
 */
-function decideStates(available, loads, shadowedSeqs, disabledSkills = /* @__PURE__ */ new Set(), prunedSeqs = /* @__PURE__ */ new Set()) {
-	const byName = /* @__PURE__ */ new Map();
-	for (const record of loads) {
-		const bucket = byName.get(record.skillName);
-		if (bucket === void 0) byName.set(record.skillName, [record]);
-		else bucket.push(record);
-	}
-	return available.map(({ name, description, masked, source, provider, path, group }) => {
-		const records = byName.get(name) ?? [];
-		let state = "unloaded";
-		if (records.length > 0) {
-			const current = records.filter((r) => !shadowedSeqs.has(r.seq));
-			if (current.length === 0) state = "evicted";
-			else state = current.some((r) => !prunedSeqs.has(r.seq)) ? "loaded" : "pruned";
-		}
-		return {
-			name,
-			...description === void 0 ? {} : { description },
-			state,
-			enabled: !disabledSkills.has(name) && masked !== true,
-			loadCount: records.length,
-			source,
-			provider,
-			...path === void 0 ? {} : { path },
-			...group === void 0 ? {} : { group }
-		};
-	});
-}
-/** Group MCP tools by server: `mcp__<server>__<tool>`. */
-function groupMcpTools(toolNames) {
-	const byServer = /* @__PURE__ */ new Map();
-	for (const raw of toolNames) {
-		if (!raw.startsWith("mcp__")) continue;
-		const rest = raw.slice(5);
-		const cut = rest.indexOf("__");
-		if (cut <= 0) continue;
-		const server = rest.slice(0, cut);
-		const tool = rest.slice(cut + 2);
-		if (tool === "") continue;
-		const bucket = byServer.get(server);
-		if (bucket === void 0) byServer.set(server, [tool]);
-		else bucket.push(tool);
-	}
-	return [...byServer.entries()].map(([server, tools]) => ({
-		server,
-		tools: tools.sort()
-	})).sort((a, b) => a.server.localeCompare(b.server));
+async function restartMcpServer(ctx, server) {
+	const entry = entryFor(ctx, server);
+	if (entry === void 0) throw new HttpError(404, `MCP server "${server}" is not configured on this host`);
+	if (entry.disabled === true) throw new HttpError(409, `MCP server "${server}" is disabled in the host composition; enable it there instead of reloading it`);
+	await entry._dispose();
+	await entry.refresh();
 }
 
 //#endregion
@@ -716,7 +888,7 @@ function parentDir(path) {
 function displayPath(path, cwd) {
 	if (cwd !== void 0 && cwd !== "" && path.startsWith(`${cwd}/`)) return path.slice(cwd.length + 1);
 	const home = process.env["HOME"];
-	if (home !== void 0 && home !== "" && path.startsWith(home)) return `~${path.slice(home.length)}`;
+	if (home !== void 0 && home !== "" && (path === home || path.startsWith(`${home}/`))) return `~${path.slice(home.length)}`;
 	return path;
 }
 /** The DSH home, matching the runtime's own resolution order. */
@@ -854,7 +1026,7 @@ function readLogFacts(services, sessionId, degraded) {
 		return empty;
 	}
 }
-function readMcp(services, degraded, disabledServers, disabledTools, agent, presetName, presetPath) {
+function readMcp(services, degraded, disabledServers, disabledTools, agent, presetName, presetPath, maskedServerNames) {
 	const tools = services.get("tools");
 	if (tools === void 0) {
 		degraded.push("tools service unavailable");
@@ -876,7 +1048,8 @@ function readMcp(services, degraded, disabledServers, disabledTools, agent, pres
 		if (agent !== void 0) collect(agent);
 		const globalNames = /* @__PURE__ */ new Set();
 		for (const schema of tools.schemas()) if (typeof schema.name === "string" && schema.name.startsWith("mcp__")) globalNames.add(schema.name);
-		return groupMcpTools(names).map((group) => {
+		const configuredServers = readConfiguredMcpServers(services);
+		const groups = groupMcpTools(names).map((group) => {
 			const enabled = !disabledServers.has(group.server);
 			const entries = group.tools.map((tool) => {
 				const name = `mcp__${group.server}__${tool}`;
@@ -895,10 +1068,32 @@ function readMcp(services, degraded, disabledServers, disabledTools, agent, pres
 				server: group.server,
 				tools: entries,
 				enabled,
+				...configuredServers.has(group.server) ? { reconnectable: true } : {},
 				source,
 				...rawPath === void 0 ? {} : { path: displayPath(rawPath) }
 			};
 		});
+		const hostPath = dshHome();
+		for (const server of configuredServers) {
+			if (groups.some((group) => group.server === server)) continue;
+			const prefix = `mcp__${server}__`;
+			const roster = maskedServerNames?.get(server) ?? [...disabledTools].filter((name) => name.startsWith(prefix)).sort();
+			groups.push({
+				server,
+				tools: roster.map((name) => ({
+					name,
+					label: name.slice(prefix.length),
+					enabled: false
+				})),
+				enabled: false,
+				unavailable: true,
+				reconnectable: true,
+				source: "host",
+				...hostPath === void 0 ? {} : { path: displayPath(hostPath) }
+			});
+		}
+		groups.sort((a, b) => a.server.localeCompare(b.server));
+		return groups;
 	} catch (error) {
 		degraded.push(`tool read failed: ${error instanceof Error ? error.message : String(error)}`);
 		return [];
@@ -978,7 +1173,7 @@ async function buildPayload(services, sessionId, capabilityState = EMPTY_STATE,
 	return {
 		sessionId,
 		skills: decideStates(available, logFacts.loads, logFacts.shadowed, disabledSkills, logFacts.pruned),
-		mcp: readMcp(services, degraded, disabledServers, disabledTools, agent, presetName, presetPath),
+		mcp: readMcp(services, degraded, disabledServers, disabledTools, agent, presetName, presetPath, new Map([...capabilityState.mcpServers].map(([server, mask]) => [server, mask.names]))),
 		systemTools: readSystemTools(services, degraded, disabledSystem, agent),
 		blocked,
 		...degraded.length > 0 ? { degraded } : {}
@@ -1077,6 +1272,7 @@ function createPresetToolController(ctx, access) {
 			key: p.name ?? p.id,
 			path: p.path
 		}));
+		const configuredServers = readConfiguredMcpServers(ctx);
 		const globalNames = /* @__PURE__ */ new Set();
 		for (const schema of tools.schemas()) if (typeof schema.name === "string" && schema.name.startsWith("mcp__")) globalNames.add(schema.name);
 		return {
@@ -1118,10 +1314,26 @@ function createPresetToolController(ctx, access) {
 						server: group.server,
 						tools: tools$1,
 						enabled: tools$1.some((tool) => tool.enabled),
+						...configuredServers.has(group.server) ? { reconnectable: true } : {},
 						source: allGlobal ? "host" : presetName,
 						...rawPath === void 0 ? {} : { path: displayPath(rawPath) }
 					};
 				});
+				const hostPath = dshHome();
+				for (const server of configuredServers) {
+					if (mcp.some((group) => group.server === server)) continue;
+					const prefix = `mcp__${server}__`;
+					mcp.push({
+						server,
+						tools: [...disabled].filter((name) => name.startsWith(prefix)).sort().map((name) => row(name, name.slice(prefix.length))),
+						enabled: false,
+						unavailable: true,
+						reconnectable: true,
+						source: "host",
+						...hostPath === void 0 ? {} : { path: displayPath(hostPath) }
+					});
+				}
+				mcp.sort((a, b) => a.server.localeCompare(b.server));
 				const systemTools = entries.filter((entry) => !entry.name.startsWith("mcp__")).map((entry) => row(entry.name, entry.name));
 				return {
 					id: preset.id,
@@ -1400,6 +1612,33 @@ function createRouteHandler(services, capabilities, stats, blockedCounts, preset
 				}, true);
 				return;
 			}
+			if (url.pathname === `${ROUTE}/reconnect`) {
+				if (req.method !== "POST") {
+					res.writeHead(405, {
+						allow: "POST",
+						"content-type": "text/plain; charset=utf-8"
+					});
+					res.end("method not allowed");
+					return;
+				}
+				if (!validatePresetContentType(req, res)) return;
+				const body = await readRequestBody(req);
+				if (body === null || typeof body !== "object") {
+					json(res, 400, { error: "invalid request body" });
+					return;
+				}
+				const record = body;
+				if (typeof record.server !== "string" || record.server === "") {
+					json(res, 400, { error: "server is required" });
+					return;
+				}
+				await restartMcpServer(services, record.server);
+				json(res, 200, {
+					ok: true,
+					server: record.server
+				});
+				return;
+			}
 			if (url.pathname === `${ROUTE}/open-folder`) {
 				if (req.method !== "POST") {
 					res.writeHead(405, {