magus-cli 7.11.4 → 7.11.6

package/src/services/resolver.ts

@@ -285,6 +285,37 @@ export function resolveExtends(
 	};
 }
 
+/** Whether a profile entry, `extends` included, turns the plugin on. */
+export function profileLists(
+	entry: ProfileManifestEntry | undefined,
+	pluginId: string,
+): boolean {
+	if (!entry) return false;
+	const value = resolveExtends(entry).plugins?.[pluginId];
+	return value !== undefined && value !== false;
+}
+
+/**
+ * Every plugin id some profile in the manifest turns on, `extends` included —
+ * by {@link profileLists}, the test a removal uses to find the profiles it
+ * must edit.
+ *
+ * The planner's view of the profiles that are NOT active. The render writes
+ * `false` for each of these into the live settings.json, so a deprecated one
+ * shows as a row on the Plugins screen even though the active profile never
+ * names it; `magus update` and the screen both pass this set to the planner,
+ * which is how such a plugin gets planned for removal at all.
+ */
+export function pluginsAnyProfileLists(manifest: ProfileManifest): string[] {
+	const out = new Set<string>();
+	for (const entry of Object.values(manifest.profiles)) {
+		for (const pluginId of Object.keys(resolveExtends(entry).plugins ?? {})) {
+			if (profileLists(entry, pluginId)) out.add(pluginId);
+		}
+	}
+	return [...out];
+}
+
 /** The pin a selected requirement installs at, if its chosen option carries one. */
 export function pinOfBin(bin: SelectedBin): string | undefined {
 	const option = bin.chosen;

package/src/services/update-engine.ts

@@ -57,6 +57,7 @@ import {
 	inheritedRowsOf,
 	loadedVersionHere,
 	notDownloadedReason,
+	readInheritedRegistryRows,
 	readInstalledPluginsRegistry,
 	repairStaleLoad,
 	rowBelongsToRepository,
@@ -69,9 +70,15 @@ import {
 	readInstalledVersionForScope,
 	saveInstalledPluginVersionForScope,
 } from "./plugin-manager.js";
-import { activeProfile } from "./profile-live.js";
+import { reconcileActiveProfile, refuseOnProblems } from "./profile-absorb.js";
+import { regenerateLiveFiles } from "./profile-activate.js";
+import {
+	activeProfile,
+	hasCurrentMarker,
+	readActiveMarker,
+} from "./profile-live.js";
 import { removePluginFromProfile } from "./profile-state.js";
-import { profileDependentsOf } from "./resolver.js";
+import { profileDependentsOf, profileLists } from "./resolver.js";
 import { installSkill } from "./skills-manager.js";
 import {
 	type ToolFacts,
@@ -296,6 +303,17 @@ export interface PluginRemoveDeps {
 		projectPath: string,
 		profile: string | null | undefined,
 	) => Promise<boolean>;
+	/**
+	 * Stop EVERY profile listing a deprecated plugin, the live files absorbed
+	 * first (`unlistFromEveryProfile`); answers whether none lists it, read
+	 * back, and throws the first failure. What {@link applyRemove} runs in
+	 * place of `dropFromProfile` when present. Optional so a double that models
+	 * one profile keeps doing it through `dropFromProfile`.
+	 */
+	unlistEverywhere?: (
+		pluginId: string,
+		projectPath: string,
+	) => Promise<boolean>;
 	/**
 	 * Clear magus's OWN `installedPluginVersions` claim for the plugin at a
 	 * scope it was removed from (`forgetInstalledPluginVersion`). Claude Code
@@ -338,6 +356,12 @@ export const REAL_REMOVE_DEPS: PluginRemoveDeps = {
 		(await enabledAt(scope, projectPath))[pluginId] === true,
 	dropFromProfile: (pluginId, projectPath, profile) =>
 		removePluginFromProfile(projectPath, pluginId, profile),
+	unlistEverywhere: async (pluginId, projectPath) => {
+		const { problems } = await unlistFromEveryProfile(pluginId, projectPath);
+		if (problems.length > 0) throw problems[0];
+		const { profiles } = await readManifest(projectPath);
+		return !Object.values(profiles).some((e) => profileLists(e, pluginId));
+	},
 	forgetVersion: forgetInstalledPluginVersion,
 	// The profile picked as `removePluginFromProfile` picks it, so the check and
 	// the drop judge the same profile. A parse error throws, as it does there.
@@ -856,13 +880,14 @@ async function applyStaleLoad(
  * Remove ONE deprecated plugin — the `remove` half of {@link applyPlugins}.
  *
  * Uninstalls it at every scope the plan found it installed at, through the
- * Claude Code CLI wrapper, then stops the profile listing it. Both halves run
- * even when the first fails part-way: a profile that keeps a plugin no
- * marketplace publishes only ever asks for an install that cannot happen.
+ * Claude Code CLI wrapper, then stops every profile listing it
+ * (`unlistEverywhere`). Both halves run even when the first fails part-way: a
+ * profile that keeps a plugin no marketplace publishes only ever asks for an
+ * install that cannot happen.
  *
  * Success is READ BACK, never "the calls returned": installed at no scope here
- * afterwards — all three are checked, not just the planned ones — and the
- * profile no longer lists it.
+ * afterwards — all three are checked, not just the planned ones — and no
+ * profile lists it.
  */
 async function applyRemove(
 	item: PluginUpdateItem,
@@ -914,11 +939,11 @@ async function applyRemove(
 				inheritedError ??= error;
 			}
 		}
-		const unlisted = await remove.dropFromProfile(
-			item.pluginId,
-			projectPath,
-			profile,
-		);
+		// Every profile that lists it, or one left listing it brings the row back
+		// on the next render.
+		const unlisted = remove.unlistEverywhere
+			? await remove.unlistEverywhere(item.pluginId, projectPath)
+			: await remove.dropFromProfile(item.pluginId, projectPath, profile);
 
 		const still: PluginScope[] = [];
 		for (const scope of REMOVE_SCOPES) {
@@ -1007,6 +1032,115 @@ async function applyRemove(
 /** Every scope a removal must leave the plugin uninstalled at. */
 const REMOVE_SCOPES: readonly PluginScope[] = ["user", "project", "local"];
 
+/**
+ * Remove an orphan the plan holds no `remove` item for — the Plugins screen's
+ * `d` on a row the planner keeps rather than removes: it moved to another
+ * marketplace, another plugin still requires it, or its marketplace was not
+ * read. The user asked for it gone, so it goes.
+ *
+ * Uninstalls at every scope here, then each inherited row from its own folder,
+ * then {@link unlistFromEveryProfile}: a key the render writes `false` for is
+ * cleared only once no profile lists the id.
+ *
+ * `problems` holds every real failure; the CLI's "nothing at this scope here"
+ * answer is not one. `unlistedFrom` names the profiles that listed it.
+ */
+export async function removeDeprecatedPlugin(
+	pluginId: string,
+	projectPath: string,
+	deps: {
+		uninstall?: (id: string, scope: PluginScope, cwd: string) => Promise<void>;
+		inheritedRows?: (
+			id: string,
+			projectPath: string,
+		) => Promise<InstalledPluginEntry[]>;
+	} = {},
+): Promise<{ problems: unknown[]; unlistedFrom: string[] }> {
+	const uninstall = deps.uninstall ?? uninstallPluginViaCli;
+	const inheritedRows = deps.inheritedRows ?? readInheritedRegistryRows;
+	const problems: unknown[] = [];
+	const unlistedFrom: string[] = [];
+
+	for (const scope of REMOVE_SCOPES) {
+		try {
+			await uninstall(pluginId, scope, projectPath);
+		} catch (error) {
+			if (!isNotInstalledAnswer(error)) problems.push(error);
+		}
+	}
+	// A folder of the same repository may hold the install this one only
+	// shows: the CLI removes it only when run from that folder.
+	for (const row of await inheritedRows(pluginId, projectPath)) {
+		if (!row.projectPath) continue;
+		try {
+			await uninstall(pluginId, row.scope, row.projectPath);
+		} catch (error) {
+			problems.push(error);
+		}
+	}
+
+	const unlisted = await unlistFromEveryProfile(pluginId, projectPath);
+	problems.push(...unlisted.problems);
+	return { problems, unlistedFrom: unlisted.unlistedFrom };
+}
+
+/**
+ * Stop EVERY profile in the project listing a deprecated plugin, keeping the
+ * user's live edits — the profile half of both removals, {@link applyRemove}
+ * (`magus update`, the Plugins screen's `a` and `d`) and
+ * {@link removeDeprecatedPlugin}.
+ *
+ * Every profile, not only the active one: the render writes `false` for each
+ * id ANY profile lists, so one profile left listing it brings the row back on
+ * the next render. A deprecated plugin can never be installed, so no profile
+ * loses anything it could use.
+ *
+ * The live files are absorbed into the active profile BEFORE any profile is
+ * written, and rendered again after, so what Claude Code or the user wrote
+ * since the last render survives and the id's key is gone. Under
+ * `withCliBookkeeping` (`magus update`) both are left to the wrapper, whose
+ * reconcile absorbs before it renders: reconciling here would write a fresh
+ * marker mid-run, clearing the bookkeeping flag, so the installs that follow
+ * would read as the user's own edits.
+ *
+ * `unlistedFrom` names the profiles that listed it, each READ BACK as no longer
+ * listing it; `problems` holds every failure, a refused reconcile included,
+ * in which case nothing was written.
+ */
+async function unlistFromEveryProfile(
+	pluginId: string,
+	projectPath: string,
+): Promise<{ problems: unknown[]; unlistedFrom: string[] }> {
+	const problems: unknown[] = [];
+	const unlistedFrom: string[] = [];
+	try {
+		const marker = (await hasCurrentMarker(projectPath))
+			? await readActiveMarker(projectPath)
+			: null;
+		const wrapperReconciles = marker?.cliBookkeeping === true;
+		// Refuses, writing nothing, on an unreadable live file.
+		if (!wrapperReconciles) {
+			refuseOnProblems(await reconcileActiveProfile(projectPath));
+		}
+		const manifest = await readManifest(projectPath);
+		for (const [id, entry] of Object.entries(manifest.profiles)) {
+			if (!profileLists(entry, pluginId)) continue;
+			if (await removePluginFromProfile(projectPath, pluginId, id)) {
+				unlistedFrom.push(id);
+			} else {
+				problems.push(
+					new Error(`the ${entry.name ?? id} profile still lists it`),
+				);
+			}
+		}
+		// Renders nothing, and answers false, when no profile is active.
+		if (!wrapperReconciles) await regenerateLiveFiles(projectPath);
+	} catch (error) {
+		problems.push(error);
+	}
+	return { problems, unlistedFrom };
+}
+
 /** Options for {@link applyPlugins}. */
 export interface ApplyPluginsOptions {
 	/**

package/src/services/update-plan.ts

@@ -879,6 +879,8 @@ export function classifyPlugin(
  * Every plugin the active profile declares, under its pin, and every plugin
  * installed in any scope (user, project, local), under "latest" — the rule
  * {@link pinForRow} states — each classified by {@link classifyPlugin}, sorted.
+ * A plugin only other profiles list joins the plan only to be removed, when it
+ * is deprecated ({@link onlyOtherProfilesList}).
  *
  * ONE list, read by both surfaces: the screen's rows, header counts and
  * "update all", and the CLI's report and apply. It used to be two — the CLI
@@ -891,11 +893,16 @@ export function classifyPlugin(
  * @param catalog    getAvailablePlugins() output — keyed by id, or as a list
  * @param requiredBy closure.dependencies?.requiredBy — which plugin needs each
  *                   dependency the profile does not name itself
+ * @param listedByProfiles every plugin id ANY profile in the manifest lists
+ *                   (`pluginsAnyProfileLists`). One neither pinned nor
+ *                   installed is planned only as a deprecated `remove`; see
+ *                   {@link onlyOtherProfilesList}.
  */
 export function planPluginUpdates(
 	pinned: Readonly<Record<string, string>>,
 	catalog: ReadonlyMap<string, PluginInfo> | readonly PluginInfo[],
 	requiredBy: RequiredBy = {},
+	listedByProfiles: readonly string[] = [],
 ): PluginUpdateItem[] {
 	const index = indexCatalog(catalog);
 	const plugins =
@@ -908,13 +915,42 @@ export function planPluginUpdates(
 		const pin = pinForRow(info, pinned);
 		if (pin !== null) pins.set(info.id, pin);
 	}
+	const othersOnly = new Set<string>();
+	for (const pluginId of listedByProfiles) {
+		if (pins.has(pluginId)) continue;
+		othersOnly.add(pluginId);
+		pins.set(pluginId, "latest");
+	}
 	return settleDeprecated(
 		[...pins].map(([pluginId, pin]) =>
 			classifyPlugin(pluginId, pin, index, requiredBy),
 		),
 		index,
 		requiredBy,
-	).sort((a, b) => a.pluginId.localeCompare(b.pluginId));
+	)
+		.filter(
+			(item) => !othersOnly.has(item.pluginId) || onlyOtherProfilesList(item),
+		)
+		.sort((a, b) => a.pluginId.localeCompare(b.pluginId));
+}
+
+/**
+ * The one item a plugin gets when only profiles that are NOT active list it,
+ * and nothing here installs it: a deprecated `remove`.
+ *
+ * The render writes `false` for it into the live settings.json, so the Plugins
+ * screen shows it as a row, and a profile that keeps a plugin no marketplace
+ * publishes only ever asks for an install that cannot happen. Removing it here
+ * drops it from every profile that lists it, which is what clears the row.
+ *
+ * Anything else — published, moved, still required, a marketplace we did not
+ * read — is no work of this profile's: it is not active, so nothing is
+ * installed, updated or kept for it, and it gets no item at all. Judged after
+ * {@link settleDeprecated}, so retired plugins that only require each other are
+ * still removed together.
+ */
+function onlyOtherProfilesList(item: PluginUpdateItem): boolean {
+	return item.action === "remove" && item.reason === "deprecated";
 }
 
 /**
@@ -951,9 +987,13 @@ export function classifyPluginRows(
 	plugins: readonly PluginInfo[],
 	pins: Readonly<Record<string, string>>,
 	requiredBy: RequiredBy = {},
+	listedByProfiles: readonly string[] = [],
 ): Map<string, PluginUpdateItem> {
 	return new Map(
-		planPluginUpdates(pins, plugins, requiredBy).map((i) => [i.pluginId, i]),
+		planPluginUpdates(pins, plugins, requiredBy, listedByProfiles).map((i) => [
+			i.pluginId,
+			i,
+		]),
 	);
 }
 

package/src/ui/keymap.ts

@@ -294,6 +294,7 @@ const MCP_REGISTRY = [
 	bind("install", ["Enter"], "install", "Add the server to this project", 90),
 	search("Search the registry; the list reloads as you type"),
 	bind("local", ["l"], "local", "Back to this project's MCP servers", 50),
+	bind("remove", ["d"], "remove", "Remove the server from this project", 45),
 	bind("reload", ["R"], "reload", "Reload the results", 40),
 	CLEAR_FILTER,
 	MOVE,

package/src/ui/renderers/mcpRenderers.tsx

@@ -97,6 +97,8 @@ export interface McpRegistryListItem {
 	server: McpRegistryServer;
 	isInstalled: boolean;
 	needsRestart: boolean;
+	/** Run by the owner of the domain its name claims. */
+	isOfficial: boolean;
 }
 
 export function renderMcpRegistryRow(
@@ -104,10 +106,11 @@ export function renderMcpRegistryRow(
 	_index: number,
 	isSelected: boolean,
 ): React.ReactNode {
-	const { server, isInstalled, needsRestart } = item;
+	const { server, isInstalled, needsRestart, isOfficial } = item;
 	const version = server.version ? ` v${server.version}` : "";
 	const icon = isInstalled ? "● " : "";
 	const restart = needsRestart ? RESTART_MARK : "";
+	const official = isOfficial ? " official" : "";
 	if (isSelected) {
 		return (
 			<text bg={theme.selection.bg} fg={theme.selection.fg}>
@@ -115,6 +118,7 @@ export function renderMcpRegistryRow(
 				{icon}
 				{server.name}
 				{version}
+				{official}
 				{restart}{" "}
 			</text>
 		);
@@ -127,6 +131,7 @@ export function renderMcpRegistryRow(
 				<strong>{server.name}</strong>
 			</span>
 			<span fg={theme.colors.info}>{version}</span>
+			{official ? <span fg={theme.colors.success}>{official}</span> : null}
 			{restart ? <span fg={theme.colors.warning}>{restart}</span> : null}
 		</text>
 	);

package/src/ui/screens/McpRegistryScreen.tsx

@@ -15,9 +15,17 @@ import {
 	addMcpServer,
 	getEnabledMcpServers,
 	getInstalledMcpServers,
+	removeMcpServer,
 	setAllowMcp,
 } from "../../services/claude-settings.js";
-import { formatDate, searchMcpServers } from "../../services/mcp-registry.js";
+import {
+	createLatestOnlyGuard,
+	formatDate,
+	isOfficialMcpServer,
+	officialFirst,
+	registryInstallPlan,
+	searchMcpServers,
+} from "../../services/mcp-registry.js";
 import type { McpRegistryServer, McpServerConfig } from "../../types/index.js";
 import { ScrollableList } from "../components/ScrollableList.js";
 import {
@@ -131,24 +139,52 @@ export function McpRegistryScreen() {
 		void loadInstalled();
 	}, [loadInstalled]);
 
+	// Overlapping loads (first load, debounce, R) can resolve out of order: only
+	// the newest request's response may touch state. Unmounting takes a token too,
+	// so a response that lands afterwards is dropped.
+	const guardRef = useRef(createLatestOnlyGuard());
+	// The name under the cursor, so a replaced list keeps it on the same server.
+	const selectedNameRef = useRef<string | undefined>(undefined);
+	selectedNameRef.current = servers[mcpRegistry.selectedIndex]?.name;
+	// The query the list on screen was loaded with: the cursor follows a name
+	// only across a reload of the same query, never into a different result set.
+	const loadedQueryRef = useRef<string | undefined>(undefined);
+	// The same query as state, for rendering: badges follow the list on screen,
+	// not the text being typed.
+	const [loadedQuery, setLoadedQuery] = useState("");
+
 	// Load servers
-	const loadServers = useCallback(async (query: string) => {
-		setIsLoading(true);
-		setError(null);
-		try {
-			const response = await searchMcpServers({ query, limit: 50 });
-			if (!response || !Array.isArray(response.servers)) {
-				throw new Error("Invalid response from MCP Registry API");
+	const loadServers = useCallback(
+		async (query: string) => {
+			const guard = guardRef.current;
+			const token = guard.next();
+			setIsLoading(true);
+			setError(null);
+			try {
+				const response = await searchMcpServers({ query, limit: 50 });
+				if (!response || !Array.isArray(response.servers)) {
+					throw new Error("Invalid response from MCP Registry API");
+				}
+				if (!guard.isLatest(token)) return;
+				// Deduplicate to show only latest version of each server, official first
+				const next = officialFirst(deduplicateServers(response.servers), query);
+				const sameQuery = loadedQueryRef.current === query;
+				const keptAt = sameQuery
+					? next.findIndex((server) => server.name === selectedNameRef.current)
+					: -1;
+				loadedQueryRef.current = query;
+				setLoadedQuery(query);
+				setServers(next);
+				dispatch({ type: "MCPREGISTRY_SELECT", index: Math.max(0, keptAt) });
+			} catch (err) {
+				if (!guard.isLatest(token)) return;
+				setError(err instanceof Error ? err.message : "Failed to load servers");
+				setServers([]);
 			}
-			// Deduplicate to show only latest version of each server
-			const deduplicated = deduplicateServers(response.servers);
-			setServers(deduplicated);
-		} catch (err) {
-			setError(err instanceof Error ? err.message : "Failed to load servers");
-			setServers([]);
-		}
-		setIsLoading(false);
-	}, []);
+			if (guard.isLatest(token)) setIsLoading(false);
+		},
+		[dispatch],
+	);
 
 	// Debounced search
 	const debouncedSearch = useCallback(
@@ -168,7 +204,9 @@ export function McpRegistryScreen() {
 	const initialQueryRef = useRef(searchQuery);
 	useEffect(() => {
 		loadServers(initialQueryRef.current);
+		const guard = guardRef.current;
 		return () => {
+			guard.next();
 			if (searchTimeoutRef.current) {
 				clearTimeout(searchTimeoutRef.current);
 			}
@@ -179,6 +217,12 @@ export function McpRegistryScreen() {
 
 	/** A new query: the list reloads, debounced, and the cursor starts over. */
 	const setQuery = (query: string) => {
+		// The shown list is stale from this keystroke: drop any response still in
+		// flight and mark the list pending until the scheduled load settles, so
+		// install/remove cannot act on the old rows. The scheduled loadServers
+		// always runs (or the screen unmounts) and clears this in every outcome.
+		guardRef.current.next();
+		setIsLoading(true);
 		setSearchQuery(query);
 		dispatch({ type: "MCPREGISTRY_SEARCH", query });
 		dispatch({ type: "MCPREGISTRY_SELECT", index: 0 });
@@ -201,6 +245,9 @@ export function McpRegistryScreen() {
 		},
 		search: () => dispatch({ type: "SET_SEARCHING", isSearching: true }),
 		local: () => navigateToScreen("mcp"),
+		remove: () => {
+			void handleRemove();
+		},
 		reload: () => {
 			void loadServers(searchQuery);
 		},
@@ -219,14 +266,53 @@ export function McpRegistryScreen() {
 		},
 	});
 
+	const handleRemove = async () => {
+		if (isLoading) return;
+		const server = servers[mcpRegistry.selectedIndex];
+		if (!server || !installedNames.has(server.name)) return;
+
+		const confirmed = await modal.confirm(
+			`Remove ${server.name}?`,
+			"This will remove the MCP server configuration.",
+		);
+		if (!confirmed) return;
+
+		modal.loading(`Removing ${server.name}...`);
+		try {
+			await removeMcpServer(server.name, state.projectPath);
+			modal.hideModal();
+			dispatch({ type: "MCP_SERVER_CHANGED", name: server.name });
+			await loadInstalled();
+		} catch (error) {
+			modal.hideModal();
+			await showFailures(
+				stepFailureReport(
+					`Could not remove ${server.name}`,
+					server.name,
+					error,
+				),
+			);
+		}
+	};
+
 	const handleInstall = async () => {
+		// While loading, the visible panel is "Loading..." and `servers` is the
+		// previous, hidden list: installing from it would add a row nobody sees.
+		if (isLoading) return;
 		const server = servers[mcpRegistry.selectedIndex];
 		if (!server) return;
 
-		const config: McpServerConfig = {
-			type: "http",
-			url: server.url,
-		};
+		const plan = registryInstallPlan(server);
+		if (!plan.ok) {
+			// Nothing is written: the popup comes before the modal and the writes.
+			await showFailures({
+				headline: `${server.name} wasn't installed`,
+				rows: [{ subject: server.name, reason: plan.reason }],
+				fix: null,
+			});
+			return;
+		}
+		const config: McpServerConfig = plan.config;
 
 		modal.loading(`Installing ${server.name}...`);
 		try {
@@ -250,6 +336,7 @@ export function McpRegistryScreen() {
 		server,
 		isInstalled: installedNames.has(server.name),
 		needsRestart: state.mcp.changedThisSession.includes(server.name),
+		isOfficial: isOfficialMcpServer(server, loadedQuery),
 	}));
 
 	// Get selected server
@@ -279,6 +366,9 @@ export function McpRegistryScreen() {
 			? `v${selectedServer.version}`
 			: "unknown";
 
+		const plan = registryInstallPlan(selectedServer);
+		const packageRuns = plan.ok && plan.kind !== "http" ? plan.config : null;
+
 		return (
 			<box flexDirection="column">
 				<text fg={theme.colors.accent}>
@@ -288,6 +378,30 @@ export function McpRegistryScreen() {
 					<text fg={theme.colors.text}>{selectedServer.short_description}</text>
 				</box>
 				<box marginTop={1}>{renderMcpRegistryStatus(selectedItem)}</box>
+				{selectedItem.isOfficial ? (
+					<box flexDirection="row">
+						<text fg={theme.colors.muted}>{"Publisher "}</text>
+						<text fg={theme.colors.success}>{"official"}</text>
+					</box>
+				) : null}
+				{packageRuns ? (
+					<box flexDirection="column" marginTop={1}>
+						<box flexDirection="row">
+							<text fg={theme.colors.muted}>{"Runs  "}</text>
+							<text fg={theme.colors.text}>
+								{[packageRuns.command, ...(packageRuns.args ?? [])].join(" ")}
+							</text>
+						</box>
+						<text fg={theme.colors.warning}>
+							It may need API keys or settings to work. magus doesn't add any.
+						</text>
+						{selectedServer.source_code_url ? (
+							<text fg={theme.colors.muted}>
+								The source below says what to set.
+							</text>
+						) : null}
+					</box>
+				) : null}
 				<box flexDirection="row" marginTop={1}>
 					<text fg={theme.colors.text}>
 						<strong>Version: </strong>
@@ -316,11 +430,17 @@ export function McpRegistryScreen() {
 						</text>
 					</box>
 				)}
-				{selectedItem.isInstalled ? null : (
-					<box marginTop={1}>
-						<text fg={theme.colors.muted}>Press Enter to install</text>
-					</box>
-				)}
+				<box marginTop={1}>
+					{!selectedItem.isInstalled && !plan.ok ? (
+						<text fg={theme.colors.warning}>{plan.reason}</text>
+					) : (
+						<text fg={theme.colors.muted}>
+							{selectedItem.isInstalled
+								? "Press d to remove"
+								: "Press Enter to install"}
+						</text>
+					)}
+				</box>
 			</box>
 		);
 	};